#define LOCKD_DEBUG
#include <stdio.h>
#ifdef LOCKD_DEBUG
#include <stdarg.h>
#endif
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <syslog.h>
#include <errno.h>
#include <string.h>
#include <signal.h>
#include <rpc/rpc.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <sys/param.h>
#include <sys/mount.h>
#include <sys/wait.h>
#include <rpcsvc/sm_inter.h>
#include <rpcsvc/nlm_prot.h>
#include "lockd.h"
#include "lockd_lock.h"
#define MAXOBJECTSIZE 64
#define MAXBUFFERSIZE 1024
struct file_lock {
LIST_ENTRY(file_lock) nfslocklist;
netobj filehandle;
struct sockaddr *addr;
struct nlm4_holder client;
u_int64_t granted_cookie;
int nsm_status;
int status;
int flags;
int blocking;
char client_name[SM_MAXSTRLEN];
};
LIST_HEAD(nfslocklist_head, file_lock);
struct nfslocklist_head nfslocklist_head = LIST_HEAD_INITIALIZER(nfslocklist_head);
LIST_HEAD(blockedlocklist_head, file_lock);
struct blockedlocklist_head blockedlocklist_head = LIST_HEAD_INITIALIZER(blockedlocklist_head);
struct file_share {
LIST_ENTRY(file_share) nfssharelist;
netobj oh;
short mode;
short access;
char client_name[SM_MAXSTRLEN];
};
LIST_HEAD(nfssharelist_head, file_share);
struct sharefile {
LIST_ENTRY(sharefile) sharefilelist;
netobj filehandle;
int fd;
int refcount;
struct nfssharelist_head sharelist_head;
};
LIST_HEAD(nfssharefilelist_head, sharefile);
struct nfssharefilelist_head nfssharefilelist_head = LIST_HEAD_INITIALIZER(nfssharefilelist_head);
#define LKST_LOCKED 1
#define LKST_WAITING 2
#define LKST_PROCESSING 3
#define LKST_DYING 4
struct host {
TAILQ_ENTRY(host) hostlst;
int refcnt;
time_t lastuse;
struct sockaddr addr;
char *name;
char *revname;
};
TAILQ_HEAD(hostlst_head, host);
struct hostlst_head hostlst_head = TAILQ_HEAD_INITIALIZER(hostlst_head);
struct hostlst_head hostlst_unref = TAILQ_HEAD_INITIALIZER(hostlst_unref);
int host_expire = 60;
time_t currsec;
u_int64_t send_granted_cookie = 0;
struct monfile {
LIST_ENTRY(monfile) monfilelist;
netobj filehandle;
int fd;
int refcount;
int exclusive;
};
LIST_HEAD(monfilelist_head, monfile);
struct monfilelist_head monfilelist_head = LIST_HEAD_INITIALIZER(monfilelist_head);
static int debugdelay = 0;
enum nfslock_status { NFS_GRANTED = 0, NFS_GRANTED_DUPLICATE,
NFS_DENIED, NFS_DENIED_NOLOCK,
NFS_RESERR };
enum hwlock_status { HW_GRANTED = 0, HW_GRANTED_DUPLICATE,
HW_DENIED, HW_DENIED_NOLOCK,
HW_STALEFH, HW_READONLY, HW_RESERR };
enum partialfilelock_status { PFL_GRANTED=0, PFL_GRANTED_DUPLICATE, PFL_DENIED,
PFL_NFSDENIED, PFL_NFSBLOCKED, PFL_NFSDENIED_NOLOCK, PFL_NFSRESERR,
PFL_HWDENIED, PFL_HWBLOCKED, PFL_HWDENIED_NOLOCK, PFL_HWRESERR,
PFL_HWDENIED_STALEFH, PFL_HWDENIED_READONLY };
enum LFLAGS {LEDGE_LEFT, LEDGE_LBOUNDARY, LEDGE_INSIDE, LEDGE_RBOUNDARY, LEDGE_RIGHT};
enum RFLAGS {REDGE_LEFT, REDGE_LBOUNDARY, REDGE_INSIDE, REDGE_RBOUNDARY, REDGE_RIGHT};
enum split_status {SPL_DISJOINT=0, SPL_LOCK1=1, SPL_LOCK2=2, SPL_CONTAINED=4, SPL_RESERR=8};
enum partialfilelock_status lock_partialfilelock(struct file_lock *fl);
int send_granted(struct file_lock *fl, int opcode);
void siglock(void);
void sigunlock(void);
void destroy_lock_host(struct host *ihp);
static void monitor_lock_host(const char *hostname, const struct sockaddr *addr);
void copy_nlm4_lock_to_nlm4_holder(const struct nlm4_lock *src,
const bool_t exclusive, struct nlm4_holder *dest);
struct file_lock * allocate_file_lock(const netobj *lockowner,
const netobj *filehandle, const struct sockaddr *addr,
const char *caller_name);
void deallocate_file_lock(struct file_lock *fl);
void fill_file_lock(struct file_lock *fl,
const bool_t exclusive, const int32_t svid,
const u_int64_t offset, const u_int64_t len,
const int state, const int status, const int flags, const int blocking);
int regions_overlap(const u_int64_t start1, const u_int64_t len1,
const u_int64_t start2, const u_int64_t len2);;
enum split_status region_compare(const u_int64_t starte, const u_int64_t lene,
const u_int64_t startu, const u_int64_t lenu,
u_int64_t *start1, u_int64_t *len1, u_int64_t *start2, u_int64_t *len2);
int same_netobj(const netobj *n0, const netobj *n1);
int same_filelock_identity(const struct file_lock *fl0,
const struct file_lock *fl2);
static void debuglog(char const *fmt, ...);
void dump_static_object(const unsigned char* object, const int sizeof_object,
unsigned char* hbuff, const int sizeof_hbuff,
unsigned char* cbuff, const int sizeof_cbuff);
void dump_netobj(const struct netobj *nobj);
void dump_filelock(const struct file_lock *fl);
struct file_lock * get_lock_matching_unlock(const struct file_lock *fl);
enum nfslock_status test_nfslock(const struct file_lock *fl,
struct file_lock **conflicting_fl);
enum nfslock_status lock_nfslock(struct file_lock *fl);
enum nfslock_status delete_nfslock(struct file_lock *fl);
enum nfslock_status unlock_nfslock(const struct file_lock *fl,
struct file_lock **released_lock, struct file_lock **left_lock,
struct file_lock **right_lock);
enum hwlock_status lock_hwlock(struct file_lock *fl);
enum split_status split_nfslock(const struct file_lock *exist_lock,
const struct file_lock *unlock_lock, struct file_lock **left_lock,
struct file_lock **right_lock);
void add_blockingfilelock(struct file_lock *fl);
enum hwlock_status unlock_hwlock(const struct file_lock *fl);
enum hwlock_status test_hwlock(const struct file_lock *fl,
struct file_lock **conflicting_fl);
void remove_blockingfilelock(struct file_lock *fl);
void clear_blockingfilelock(const char *hostname);
void retry_blockingfilelocklist(netobj *fh);
enum partialfilelock_status unlock_partialfilelock(
const struct file_lock *fl);
void clear_partialfilelock(const char *hostname);
enum partialfilelock_status test_partialfilelock(
const struct file_lock *fl, struct file_lock **conflicting_fl);
enum nlm4_stats do_test(struct file_lock *fl, struct file_lock **conflicting_fl);
enum nlm4_stats do_unlock(struct file_lock *fl);
enum nlm4_stats do_lock(struct file_lock *fl);
void do_clear(const char *hostname);
void
debuglog(char const *fmt, ...)
{
va_list ap;
if (debug_level < 1) {
return;
}
sleep(debugdelay);
va_start(ap, fmt);
vsyslog(LOG_DEBUG, fmt, ap);
va_end(ap);
}
void
dump_static_object(object, size_object, hbuff, size_hbuff, cbuff, size_cbuff)
const unsigned char *object;
const int size_object;
unsigned char *hbuff;
const int size_hbuff;
unsigned char *cbuff;
const int size_cbuff;
{
int i, objectsize;
if (debug_level < 2) {
return;
}
objectsize = size_object;
if (objectsize == 0) {
debuglog("object is size 0\n");
} else {
if (objectsize > MAXOBJECTSIZE) {
debuglog("Object of size %d being clamped"
"to size %d\n", objectsize, MAXOBJECTSIZE);
objectsize = MAXOBJECTSIZE;
}
if (hbuff != NULL) {
if (size_hbuff < objectsize*2+1) {
debuglog("Hbuff not large enough."
" Increase size\n");
} else {
for(i=0;i<objectsize;i++) {
sprintf(hbuff+i*2,"%02x",*(object+i));
}
*(hbuff+i*2) = '\0';
}
}
if (cbuff != NULL) {
if (size_cbuff < objectsize+1) {
debuglog("Cbuff not large enough."
" Increase Size\n");
}
for(i=0;i<objectsize;i++) {
if (*(object+i) >= 32 && *(object+i) <= 127) {
*(cbuff+i) = *(object+i);
} else {
*(cbuff+i) = '.';
}
}
*(cbuff+i) = '\0';
}
}
}
void
dump_netobj(const struct netobj *nobj)
{
char hbuff[MAXBUFFERSIZE*2];
char cbuff[MAXBUFFERSIZE];
if (debug_level < 2) {
return;
}
if (nobj == NULL) {
debuglog("Null netobj pointer\n");
}
else if (nobj->n_len == 0) {
debuglog("Size zero netobj\n");
} else {
dump_static_object(nobj->n_bytes, nobj->n_len,
hbuff, sizeof(hbuff), cbuff, sizeof(cbuff));
debuglog("netobj: len: %d data: %s ::: %s\n",
nobj->n_len, hbuff, cbuff);
}
}
void
dump_filelock(const struct file_lock *fl)
{
#ifdef DUMP_FILELOCK_VERBOSE
char hbuff[MAXBUFFERSIZE*2];
char cbuff[MAXBUFFERSIZE];
#endif
if (debug_level < 2) {
return;
}
if (fl != NULL) {
debuglog("Dumping file lock structure @ %p\n", fl);
#ifdef DUMP_FILELOCK_VERBOSE
dump_static_object((unsigned char *)&fl->filehandle.n_bytes,
fl->filehandle.n_len, hbuff, sizeof(hbuff),
cbuff, sizeof(cbuff));
debuglog("Filehandle: %8s ::: %8s\n", hbuff, cbuff);
#endif
debuglog("Dumping nlm4_holder:\n"
"exc: %x svid: %x offset:len %llx:%llx\n",
fl->client.exclusive, fl->client.svid,
fl->client.l_offset, fl->client.l_len);
#ifdef DUMP_FILELOCK_VERBOSE
debuglog("Dumping client identity:\n");
dump_netobj(&fl->client.oh);
debuglog("nsm: %d status: %d flags: %d locker: %d"
" fd: %d\n", fl->nsm_status, fl->status,
fl->flags, fl->locker, fl->fd);
#endif
} else {
debuglog("NULL file lock structure\n");
}
}
void
copy_nlm4_lock_to_nlm4_holder(src, exclusive, dest)
const struct nlm4_lock *src;
const bool_t exclusive;
struct nlm4_holder *dest;
{
dest->exclusive = exclusive;
dest->oh.n_len = src->oh.n_len;
dest->oh.n_bytes = src->oh.n_bytes;
dest->svid = src->svid;
dest->l_offset = src->l_offset;
dest->l_len = src->l_len;
}
size_t
strnlen(const char *s, size_t len)
{
size_t n;
for (n = 0; s[n] != 0 && n < len; n++)
;
return n;
}
struct file_lock *
allocate_file_lock(const netobj *lockowner, const netobj *filehandle,
const struct sockaddr *addr, const char *caller_name)
{
struct file_lock *newfl;
size_t n;
n = strnlen(caller_name, SM_MAXSTRLEN);
if (n == SM_MAXSTRLEN) {
return NULL;
}
newfl = malloc(sizeof(*newfl) - sizeof(newfl->client_name) + n + 1);
if (newfl == NULL) {
return NULL;
}
bzero(newfl, sizeof(*newfl) - sizeof(newfl->client_name));
memcpy(newfl->client_name, caller_name, n);
newfl->client_name[n] = 0;
newfl->client.oh.n_bytes = malloc(lockowner->n_len);
if (newfl->client.oh.n_bytes == NULL) {
free(newfl);
return NULL;
}
newfl->client.oh.n_len = lockowner->n_len;
bcopy(lockowner->n_bytes, newfl->client.oh.n_bytes, lockowner->n_len);
newfl->filehandle.n_bytes = malloc(filehandle->n_len);
if (newfl->filehandle.n_bytes == NULL) {
free(newfl->client.oh.n_bytes);
free(newfl);
return NULL;
}
newfl->filehandle.n_len = filehandle->n_len;
bcopy(filehandle->n_bytes, newfl->filehandle.n_bytes, filehandle->n_len);
newfl->addr = malloc(addr->sa_len);
if (newfl->addr == NULL) {
free(newfl->client.oh.n_bytes);
free(newfl);
return NULL;
}
memcpy(newfl->addr, addr, addr->sa_len);
return newfl;
}
void
fill_file_lock(struct file_lock *fl,
const bool_t exclusive, const int32_t svid,
const u_int64_t offset, const u_int64_t len,
const int state, const int status, const int flags, const int blocking)
{
fl->client.exclusive = exclusive;
fl->client.svid = svid;
fl->client.l_offset = offset;
fl->client.l_len = len;
fl->nsm_status = state;
fl->status = status;
fl->flags = flags;
fl->blocking = blocking;
}
void
deallocate_file_lock(struct file_lock *fl)
{
free(fl->addr);
free(fl->client.oh.n_bytes);
free(fl->filehandle.n_bytes);
free(fl);
}
int
regions_overlap(start1, len1, start2, len2)
const u_int64_t start1, len1, start2, len2;
{
u_int64_t d1,d2,d3,d4;
enum split_status result;
debuglog("Entering region overlap with vals: %llu:%llu--%llu:%llu\n",
start1, len1, start2, len2);
result = region_compare(start1, len1, start2, len2,
&d1, &d2, &d3, &d4);
debuglog("Exiting region overlap with val: %d\n",result);
if (result == SPL_DISJOINT) {
return 0;
} else {
return 1;
}
return (result);
}
enum split_status
region_compare(starte, lene, startu, lenu,
start1, len1, start2, len2)
const u_int64_t starte, lene, startu, lenu;
u_int64_t *start1, *len1, *start2, *len2;
{
enum LFLAGS lflags;
enum RFLAGS rflags;
enum split_status retval;
retval = SPL_DISJOINT;
if (lene == 0 && lenu == 0) {
if (startu < starte) {
lflags = LEDGE_LEFT;
} else if (startu == starte) {
lflags = LEDGE_LBOUNDARY;
} else {
lflags = LEDGE_INSIDE;
}
rflags = REDGE_RBOUNDARY;
if (lflags == LEDGE_INSIDE) {
*start1 = starte;
*len1 = startu - starte;
}
if (lflags == LEDGE_LEFT || lflags == LEDGE_LBOUNDARY) {
retval = SPL_CONTAINED;
} else {
retval = SPL_LOCK1;
}
} else if (lene == 0 && lenu != 0) {
if (startu < starte) {
lflags = LEDGE_LEFT;
} else if (startu == starte) {
lflags = LEDGE_LBOUNDARY;
} else if (startu > starte) {
lflags = LEDGE_INSIDE;
}
if (startu + lenu < starte) {
rflags = REDGE_LEFT;
return SPL_DISJOINT;
} else if (startu + lenu == starte) {
rflags = REDGE_LBOUNDARY;
return SPL_DISJOINT;
} else {
rflags = REDGE_INSIDE;
}
if (lflags == LEDGE_INSIDE) {
*start1 = starte;
*len1 = startu - starte;
retval |= SPL_LOCK1;
}
if (rflags == REDGE_INSIDE) {
*start2 = startu+lenu;
*len2 = 0;
retval |= SPL_LOCK2;
}
} else if (lene != 0 && lenu == 0) {
if (startu < starte) {
lflags = LEDGE_LEFT;
retval = SPL_CONTAINED;
return retval;
} else if (startu == starte) {
lflags = LEDGE_LBOUNDARY;
retval = SPL_CONTAINED;
return retval;
} else if ((startu > starte) && (startu < starte + lene - 1)) {
lflags = LEDGE_INSIDE;
} else if (startu == starte + lene - 1) {
lflags = LEDGE_RBOUNDARY;
} else {
lflags = LEDGE_RIGHT;
return SPL_DISJOINT;
}
rflags = REDGE_RIGHT;
if (lflags == LEDGE_INSIDE || lflags == LEDGE_RBOUNDARY) {
*start1 = starte;
*len1 = startu - starte;
retval |= SPL_LOCK1;
return retval;
}
} else {
if (startu < starte) {
lflags = LEDGE_LEFT;
} else if (startu == starte) {
lflags = LEDGE_LBOUNDARY;
} else if ((startu > starte) && (startu < starte + lene - 1)) {
lflags = LEDGE_INSIDE;
} else if (startu == starte + lene - 1) {
lflags = LEDGE_RBOUNDARY;
} else {
lflags = LEDGE_RIGHT;
return SPL_DISJOINT;
}
if (startu + lenu < starte) {
rflags = REDGE_LEFT;
return SPL_DISJOINT;
} else if (startu + lenu == starte) {
rflags = REDGE_LBOUNDARY;
return SPL_DISJOINT;
} else if (startu + lenu < starte + lene) {
rflags = REDGE_INSIDE;
} else if (startu + lenu == starte + lene) {
rflags = REDGE_RBOUNDARY;
} else {
rflags = REDGE_RIGHT;
}
if (lflags == LEDGE_INSIDE || lflags == LEDGE_RBOUNDARY) {
*start1 = starte;
*len1 = (startu - starte);
retval |= SPL_LOCK1;
}
if (rflags == REDGE_INSIDE) {
*start2 = startu+lenu;
*len2 = starte+lene-(startu+lenu);
retval |= SPL_LOCK2;
}
if ((lflags == LEDGE_LEFT || lflags == LEDGE_LBOUNDARY) &&
(rflags == REDGE_RBOUNDARY || rflags == REDGE_RIGHT)) {
retval = SPL_CONTAINED;
}
}
return retval;
}
int
same_netobj(const netobj *n0, const netobj *n1)
{
int retval;
retval = 0;
debuglog("Entering netobj identity check\n");
if (n0->n_len == n1->n_len) {
debuglog("Preliminary length check passed\n");
retval = !bcmp(n0->n_bytes, n1->n_bytes, n0->n_len);
debuglog("netobj %smatch\n", retval ? "" : "mis");
}
return (retval);
}
int
same_filelock_identity(fl0, fl1)
const struct file_lock *fl0, *fl1;
{
int retval;
retval = 0;
debuglog("Checking filelock identity\n");
retval = (fl0->client.svid == fl1->client.svid &&
same_netobj(&(fl0->client.oh), &(fl1->client.oh)));
debuglog("Exiting checking filelock identity: retval: %d\n",retval);
return (retval);
}
struct file_lock *
get_lock_matching_unlock(const struct file_lock *fl)
{
struct file_lock *ifl;
debuglog("Entering lock_matching_unlock\n");
debuglog("********Dump of fl*****************\n");
dump_filelock(fl);
LIST_FOREACH(ifl, &nfslocklist_head, nfslocklist) {
debuglog("Pointer to file lock: %p\n",ifl);
debuglog("****Dump of ifl****\n");
dump_filelock(ifl);
debuglog("*******************\n");
if (fl->filehandle.n_len != ifl->filehandle.n_len)
continue;
if (bcmp(fl->filehandle.n_bytes, ifl->filehandle.n_bytes,
fl->filehandle.n_len))
continue;
debuglog("matching_unlock: Filehandles match, "
"checking regions\n");
if (!regions_overlap(fl->client.l_offset, fl->client.l_len,
ifl->client.l_offset, ifl->client.l_len))
continue;
debuglog("matching_unlock: Region overlap"
" found %llu : %llu -- %llu : %llu\n",
fl->client.l_offset,fl->client.l_len,
ifl->client.l_offset,ifl->client.l_len);
if (!same_filelock_identity(fl,ifl))
continue;
debuglog("matching_unlock: Duplicate lock id. Granting\n");
return (ifl);
}
debuglog("Exiting lock_matching_unlock\n");
return (NULL);
}
enum nfslock_status
test_nfslock(const struct file_lock *fl, struct file_lock **conflicting_fl)
{
struct file_lock *ifl;
enum nfslock_status retval;
debuglog("Entering test_nfslock\n");
retval = NFS_GRANTED;
(*conflicting_fl) = NULL;
debuglog("Entering lock search loop\n");
debuglog("***********************************\n");
debuglog("Dumping match filelock\n");
debuglog("***********************************\n");
dump_filelock(fl);
debuglog("***********************************\n");
LIST_FOREACH(ifl, &nfslocklist_head, nfslocklist) {
if (retval == NFS_DENIED)
break;
debuglog("Top of lock loop\n");
debuglog("Pointer to file lock: %p\n",ifl);
debuglog("***********************************\n");
debuglog("Dumping test filelock\n");
debuglog("***********************************\n");
dump_filelock(ifl);
debuglog("***********************************\n");
if (fl->filehandle.n_len != ifl->filehandle.n_len)
continue;
if (bcmp(fl->filehandle.n_bytes, ifl->filehandle.n_bytes,
fl->filehandle.n_len))
continue;
debuglog("test_nfslock: filehandle match found\n");
if (!regions_overlap(fl->client.l_offset, fl->client.l_len,
ifl->client.l_offset, ifl->client.l_len))
continue;
debuglog("test_nfslock: Region overlap found"
" %llu : %llu -- %llu : %llu\n",
fl->client.l_offset,fl->client.l_len,
ifl->client.l_offset,ifl->client.l_len);
if (!(fl->client.exclusive || ifl->client.exclusive))
continue;
debuglog("test_nfslock: Exclusivity failure: %d %d\n",
fl->client.exclusive,
ifl->client.exclusive);
if (same_filelock_identity(fl,ifl)) {
debuglog("test_nfslock: Duplicate id. Granting\n");
(*conflicting_fl) = ifl;
retval = NFS_GRANTED_DUPLICATE;
} else {
debuglog("test_nfslock: Lock attempt failed\n");
debuglog("Desired lock\n");
dump_filelock(fl);
debuglog("Conflicting lock\n");
dump_filelock(ifl);
(*conflicting_fl) = ifl;
retval = NFS_DENIED;
}
}
debuglog("Dumping file locks\n");
debuglog("Exiting test_nfslock\n");
return (retval);
}
enum nfslock_status
lock_nfslock(struct file_lock *fl)
{
enum nfslock_status retval;
struct file_lock *dummy_fl;
dummy_fl = NULL;
debuglog("Entering lock_nfslock...\n");
retval = test_nfslock(fl,&dummy_fl);
if (retval == NFS_GRANTED || retval == NFS_GRANTED_DUPLICATE) {
debuglog("Inserting lock...\n");
dump_filelock(fl);
LIST_INSERT_HEAD(&nfslocklist_head, fl, nfslocklist);
}
debuglog("Exiting lock_nfslock...\n");
return (retval);
}
enum nfslock_status
delete_nfslock(struct file_lock *fl)
{
LIST_REMOVE(fl, nfslocklist);
return (NFS_GRANTED);
}
enum split_status
split_nfslock(exist_lock, unlock_lock, left_lock, right_lock)
const struct file_lock *exist_lock, *unlock_lock;
struct file_lock **left_lock, **right_lock;
{
u_int64_t start1, len1, start2, len2;
enum split_status spstatus;
spstatus = region_compare(exist_lock->client.l_offset, exist_lock->client.l_len,
unlock_lock->client.l_offset, unlock_lock->client.l_len,
&start1, &len1, &start2, &len2);
if ((spstatus & SPL_LOCK1) != 0) {
*left_lock = allocate_file_lock(&exist_lock->client.oh, &exist_lock->filehandle, exist_lock->addr, exist_lock->client_name);
if (*left_lock == NULL) {
debuglog("Unable to allocate resource for split 1\n");
return SPL_RESERR;
}
fill_file_lock(*left_lock,
exist_lock->client.exclusive, exist_lock->client.svid,
start1, len1,
exist_lock->nsm_status,
exist_lock->status, exist_lock->flags, exist_lock->blocking);
}
if ((spstatus & SPL_LOCK2) != 0) {
*right_lock = allocate_file_lock(&exist_lock->client.oh, &exist_lock->filehandle, exist_lock->addr, exist_lock->client_name);
if (*right_lock == NULL) {
debuglog("Unable to allocate resource for split 1\n");
if (*left_lock != NULL) {
deallocate_file_lock(*left_lock);
}
return SPL_RESERR;
}
fill_file_lock(*right_lock,
exist_lock->client.exclusive, exist_lock->client.svid,
start2, len2,
exist_lock->nsm_status,
exist_lock->status, exist_lock->flags, exist_lock->blocking);
}
return spstatus;
}
enum nfslock_status
unlock_nfslock(fl, released_lock, left_lock, right_lock)
const struct file_lock *fl;
struct file_lock **released_lock;
struct file_lock **left_lock;
struct file_lock **right_lock;
{
struct file_lock *mfl;
enum nfslock_status retval;
enum split_status spstatus;
debuglog("Entering unlock_nfslock\n");
*released_lock = NULL;
*left_lock = NULL;
*right_lock = NULL;
retval = NFS_DENIED_NOLOCK;
debuglog("Attempting to match lock...\n");
mfl = get_lock_matching_unlock(fl);
if (mfl != NULL) {
debuglog("Unlock matched. Querying for split\n");
spstatus = split_nfslock(mfl, fl, left_lock, right_lock);
debuglog("Split returned %d %p %p %p %p\n",spstatus,mfl,fl,*left_lock,*right_lock);
debuglog("********Split dumps********");
dump_filelock(mfl);
dump_filelock(fl);
dump_filelock(*left_lock);
dump_filelock(*right_lock);
debuglog("********End Split dumps********");
if (spstatus == SPL_RESERR) {
if (*left_lock != NULL) {
deallocate_file_lock(*left_lock);
*left_lock = NULL;
}
if (*right_lock != NULL) {
deallocate_file_lock(*right_lock);
*right_lock = NULL;
}
return NFS_RESERR;
}
if (*left_lock != NULL) {
debuglog("Split left activated\n");
LIST_INSERT_HEAD(&nfslocklist_head, *left_lock, nfslocklist);
}
if (*right_lock != NULL) {
debuglog("Split right activated\n");
LIST_INSERT_HEAD(&nfslocklist_head, *right_lock, nfslocklist);
}
LIST_REMOVE(mfl, nfslocklist);
*released_lock = mfl;
retval = NFS_GRANTED;
}
debuglog("Exiting unlock_nfslock\n");
return retval;
}
enum hwlock_status
lock_hwlock(struct file_lock *fl)
{
struct monfile *imf,*nmf;
int lflags, flerror;
fhandle_t fh;
LIST_FOREACH(imf, &monfilelist_head, monfilelist) {
if ((fl->filehandle.n_len == imf->filehandle.n_len) &&
(bcmp(fl->filehandle.n_bytes, imf->filehandle.n_bytes,
fl->filehandle.n_len) == 0)) {
break;
}
}
if (imf != NULL) {
++(imf->refcount);
return (HW_GRANTED);
}
nmf = malloc(sizeof(struct monfile));
if (nmf == NULL) {
debuglog("hwlock resource allocation failure\n");
return (HW_RESERR);
}
nmf->filehandle.n_bytes = malloc(fl->filehandle.n_len);
if (nmf->filehandle.n_bytes == NULL) {
debuglog("hwlock resource allocation failure\n");
free(nmf);
return (HW_RESERR);
}
if (fl->filehandle.n_len > NFS_MAX_FH_SIZE) {
debuglog("hwlock: bad fh length %d (from %16s): %32s\n",
fl->filehandle.n_len, fl->client_name, strerror(errno));
free(nmf->filehandle.n_bytes);
free(nmf);
return (HW_STALEFH);
}
fh.fh_len = fl->filehandle.n_len;
bcopy(fl->filehandle.n_bytes, fh.fh_data, fh.fh_len);
nmf->fd = fhopen(&fh, O_RDWR);
if (nmf->fd < 0) {
debuglog("fhopen failed (from %16s): %32s\n",
fl->client_name, strerror(errno));
free(nmf->filehandle.n_bytes);
free(nmf);
switch (errno) {
case ESTALE:
return (HW_STALEFH);
case EROFS:
return (HW_READONLY);
default:
return (HW_RESERR);
}
}
nmf->filehandle.n_len = fl->filehandle.n_len;
bcopy(fl->filehandle.n_bytes, nmf->filehandle.n_bytes, fl->filehandle.n_len);
nmf->refcount = 1;
nmf->exclusive = fl->client.exclusive;
lflags = (nmf->exclusive == 1) ?
(LOCK_EX | LOCK_NB) : (LOCK_SH | LOCK_NB);
flerror = flock(nmf->fd, lflags);
if (flerror != 0) {
debuglog("flock failed (from %16s): %32s\n",
fl->client_name, strerror(errno));
close(nmf->fd);
free(nmf->filehandle.n_bytes);
free(nmf);
switch (errno) {
case EAGAIN:
return (HW_DENIED);
case ESTALE:
return (HW_STALEFH);
case EROFS:
return (HW_READONLY);
default:
return (HW_RESERR);
break;
}
}
LIST_INSERT_HEAD(&monfilelist_head, nmf, monfilelist);
debuglog("flock succeeded (from %16s)\n", fl->client_name);
return (HW_GRANTED);
}
enum hwlock_status
unlock_hwlock(const struct file_lock *fl)
{
struct monfile *imf;
debuglog("Entering unlock_hwlock\n");
debuglog("Entering loop interation\n");
LIST_FOREACH(imf, &monfilelist_head, monfilelist) {
if ((fl->filehandle.n_len == imf->filehandle.n_len) &&
(bcmp(fl->filehandle.n_bytes, imf->filehandle.n_bytes,
fl->filehandle.n_len) == 0)) {
break;
}
}
debuglog("Completed iteration. Proceeding\n");
if (imf == NULL) {
debuglog("Exiting unlock_hwlock (HW_DENIED_NOLOCK)\n");
return (HW_DENIED_NOLOCK);
}
--imf->refcount;
if (imf->refcount < 0) {
debuglog("Negative hardware reference count\n");
}
if (imf->refcount <= 0) {
close(imf->fd);
LIST_REMOVE(imf, monfilelist);
free(imf->filehandle.n_bytes);
free(imf);
}
debuglog("Exiting unlock_hwlock (HW_GRANTED)\n");
return (HW_GRANTED);
}
enum hwlock_status
test_hwlock(fl, conflicting_fl)
const struct file_lock *fl __unused;
struct file_lock **conflicting_fl __unused;
{
return (HW_RESERR);
}
void
add_blockingfilelock(struct file_lock *fl)
{
struct file_lock *ifl, *nfl;
debuglog("Entering add_blockingfilelock\n");
ifl = LIST_FIRST(&blockedlocklist_head);
for (; ifl != NULL; ifl = nfl) {
debuglog("Pointer to file lock: %p\n",ifl);
debuglog("****Dump of ifl****\n");
dump_filelock(ifl);
debuglog("*******************\n");
nfl = LIST_NEXT(ifl, nfslocklist);
if (fl->filehandle.n_len != ifl->filehandle.n_len)
continue;
if (bcmp(fl->filehandle.n_bytes, ifl->filehandle.n_bytes,
fl->filehandle.n_len))
continue;
if ((fl->client.l_offset != ifl->client.l_offset) ||
(fl->client.l_len != ifl->client.l_len))
continue;
if (!same_filelock_identity(fl,ifl))
continue;
debuglog("add_blockingfilelock: removing duplicate lock request.\n");
remove_blockingfilelock(ifl);
deallocate_file_lock(ifl);
break;
}
fl->blocking = 0;
LIST_INSERT_HEAD(&blockedlocklist_head, fl, nfslocklist);
debuglog("Exiting add_blockingfilelock\n");
}
void
remove_blockingfilelock(struct file_lock *fl)
{
debuglog("Entering remove_blockingfilelock\n");
LIST_REMOVE(fl, nfslocklist);
debuglog("Exiting remove_blockingfilelock\n");
}
void
clear_blockingfilelock(const char *hostname)
{
struct file_lock *ifl,*nfl;
ifl = LIST_FIRST(&blockedlocklist_head);
while (ifl != NULL) {
nfl = LIST_NEXT(ifl, nfslocklist);
if (strncmp(hostname, ifl->client_name, SM_MAXSTRLEN) == 0) {
remove_blockingfilelock(ifl);
deallocate_file_lock(ifl);
}
ifl = nfl;
}
}
int need_retry_blocked_locks = 0;
void
retry_blockingfilelocklist(netobj *fh)
{
struct file_lock *ifl, *nfl, *pfl;
enum partialfilelock_status pflstatus;
int rv;
debuglog("Entering retry_blockingfilelocklist\n");
need_retry_blocked_locks = 0;
pfl = NULL;
ifl = LIST_FIRST(&blockedlocklist_head);
debuglog("Iterator choice %p\n",ifl);
while (ifl != NULL) {
nfl = LIST_NEXT(ifl, nfslocklist);
debuglog("Iterator choice %p\n",ifl);
debuglog("Prev iterator choice %p\n",pfl);
debuglog("Next iterator choice %p\n",nfl);
if (fh && !same_netobj(fh, &ifl->filehandle)) {
ifl = nfl;
continue;
}
LIST_REMOVE(ifl, nfslocklist);
pflstatus = lock_partialfilelock(ifl);
if (pflstatus == PFL_GRANTED || pflstatus == PFL_GRANTED_DUPLICATE) {
debuglog("Granted blocked lock\n");
rv = send_granted(ifl, 0);
if (rv) {
do_unlock(ifl);
}
} else if (pflstatus == PFL_HWDENIED_STALEFH) {
deallocate_file_lock(ifl);
} else {
debuglog("Replacing blocked lock\n");
if (pfl != NULL)
LIST_INSERT_AFTER(pfl, ifl, nfslocklist);
else
LIST_INSERT_HEAD(&blockedlocklist_head, ifl, nfslocklist);
}
if (pflstatus == PFL_GRANTED || pflstatus == PFL_GRANTED_DUPLICATE ||
pflstatus == PFL_HWDENIED_STALEFH) {
} else {
pfl = ifl;
}
ifl = nfl;
}
debuglog("Exiting retry_blockingfilelocklist\n");
}
enum partialfilelock_status
lock_partialfilelock(struct file_lock *fl)
{
enum partialfilelock_status retval;
enum nfslock_status lnlstatus;
enum hwlock_status hwstatus;
debuglog("Entering lock_partialfilelock\n");
retval = PFL_DENIED;
lnlstatus = lock_nfslock(fl);
switch (lnlstatus) {
case NFS_GRANTED:
case NFS_GRANTED_DUPLICATE:
hwstatus = lock_hwlock(fl);
switch (hwstatus) {
case HW_GRANTED:
case HW_GRANTED_DUPLICATE:
debuglog("HW GRANTED\n");
if (lnlstatus == NFS_GRANTED_DUPLICATE) {
retval = PFL_GRANTED_DUPLICATE;
} else {
retval = PFL_GRANTED;
}
if (fl->flags & LOCK_MON)
monitor_lock_host_by_name(fl->client_name, fl->addr);
break;
case HW_RESERR:
debuglog("HW RESERR\n");
retval = PFL_HWRESERR;
break;
case HW_DENIED:
debuglog("HW DENIED\n");
retval = PFL_HWDENIED;
break;
case HW_DENIED_NOLOCK:
debuglog("HW DENIED NOLOCK\n");
retval = PFL_HWDENIED_NOLOCK;
break;
case HW_STALEFH:
debuglog("HW STALE FH\n");
retval = PFL_HWDENIED_STALEFH;
break;
case HW_READONLY:
debuglog("HW READONLY\n");
retval = PFL_HWDENIED_READONLY;
break;
default:
debuglog("Unmatched hwstatus %d\n",hwstatus);
break;
}
if (retval != PFL_GRANTED &&
retval != PFL_GRANTED_DUPLICATE) {
debuglog("Deleting trial NFS lock\n");
delete_nfslock(fl);
}
break;
case NFS_DENIED:
retval = PFL_NFSDENIED;
break;
case NFS_RESERR:
retval = PFL_NFSRESERR;
default:
debuglog("Unmatched lnlstatus %d\n");
retval = PFL_NFSDENIED_NOLOCK;
break;
}
if (retval == PFL_NFSDENIED || retval == PFL_HWDENIED) {
if (fl->blocking == 1) {
if (retval == PFL_NFSDENIED) {
debuglog("BLOCKING LOCK RECEIVED\n");
retval = PFL_NFSBLOCKED;
add_blockingfilelock(fl);
dump_filelock(fl);
} else {
debuglog("BLOCKING LOCK DENIED IN HARDWARE\n");
dump_filelock(fl);
}
} else {
debuglog("Lock denied. Non-blocking failure\n");
dump_filelock(fl);
}
}
debuglog("Exiting lock_partialfilelock\n");
return retval;
}
enum partialfilelock_status
unlock_partialfilelock(const struct file_lock *fl)
{
struct file_lock *lfl,*rfl,*releasedfl,*selffl;
enum partialfilelock_status retval;
enum nfslock_status unlstatus;
enum hwlock_status unlhwstatus, lhwstatus;
debuglog("Entering unlock_partialfilelock\n");
selffl = NULL;
lfl = NULL;
rfl = NULL;
releasedfl = NULL;
retval = PFL_DENIED;
do {
debuglog("Value of releasedfl: %p\n",releasedfl);
unlstatus = unlock_nfslock(fl, &releasedfl, &lfl, &rfl);
debuglog("Value of releasedfl: %p\n",releasedfl);
if (lfl != NULL) {
lhwstatus = lock_hwlock(lfl);
if (lhwstatus != HW_GRANTED &&
lhwstatus != HW_GRANTED_DUPLICATE) {
debuglog("HW duplicate lock failure for left split\n");
}
if (lfl->flags & LOCK_MON)
monitor_lock_host_by_name(lfl->client_name, lfl->addr);
}
if (rfl != NULL) {
lhwstatus = lock_hwlock(rfl);
if (lhwstatus != HW_GRANTED &&
lhwstatus != HW_GRANTED_DUPLICATE) {
debuglog("HW duplicate lock failure for right split\n");
}
if (rfl->flags & LOCK_MON)
monitor_lock_host_by_name(rfl->client_name, rfl->addr);
}
switch (unlstatus) {
case NFS_GRANTED:
debuglog("NFS unlock granted. Attempting hardware unlock\n");
unlhwstatus = unlock_hwlock(fl);
debuglog("HW unlock returned with code %d\n",unlhwstatus);
switch (unlhwstatus) {
case HW_GRANTED:
debuglog("HW unlock granted\n");
if (releasedfl->flags & LOCK_MON)
unmonitor_lock_host(releasedfl->client_name);
retval = PFL_GRANTED;
break;
case HW_DENIED_NOLOCK:
debuglog("HW unlock denied no lock\n");
retval = PFL_HWRESERR;
unlstatus = NFS_RESERR;
break;
default:
debuglog("HW unlock failed\n");
retval = PFL_HWRESERR;
unlstatus = NFS_RESERR;
break;
}
debuglog("Exiting with status retval: %d\n",retval);
need_retry_blocked_locks = 1;
break;
case NFS_DENIED_NOLOCK:
retval = PFL_GRANTED;
debuglog("All locks cleaned out\n");
break;
default:
retval = PFL_NFSRESERR;
debuglog("NFS unlock failure\n");
dump_filelock(fl);
break;
}
if (releasedfl != NULL) {
if (fl == releasedfl) {
debuglog("Attempt to unlock self\n");
selffl = releasedfl;
} else {
deallocate_file_lock(releasedfl);
}
}
} while (unlstatus == NFS_GRANTED);
if (selffl != NULL) {
debuglog("WARNING! Destroying incoming lock pointer\n");
deallocate_file_lock(selffl);
}
debuglog("Exiting unlock_partialfilelock\n");
return retval;
}
void
clear_partialfilelock(const char *hostname)
{
struct file_lock *ifl, *nfl;
enum partialfilelock_status pfsret;
struct host *ihp;
TAILQ_FOREACH(ihp, &hostlst_head, hostlst) {
if (ihp->revname && strncmp(hostname, ihp->revname,
SM_MAXSTRLEN) == 0) {
hostname = ihp->name;
debuglog("Clearing locks for %s (%s)\n",
hostname, ihp->revname);
break;
}
}
clear_blockingfilelock(hostname);
restart:
ifl = LIST_FIRST(&nfslocklist_head);
while (ifl != NULL) {
nfl = LIST_NEXT(ifl, nfslocklist);
if (strncmp(hostname, ifl->client_name, SM_MAXSTRLEN) == 0) {
pfsret = unlock_partialfilelock(ifl);
if (pfsret != PFL_GRANTED) {
syslog(LOG_WARNING, "lock clearing for %s failed: %d",
hostname, pfsret);
break;
}
goto restart;
}
ifl = nfl;
}
}
enum partialfilelock_status
test_partialfilelock(const struct file_lock *fl,
struct file_lock **conflicting_fl)
{
enum partialfilelock_status retval;
enum nfslock_status teststatus;
debuglog("Entering testpartialfilelock...\n");
retval = PFL_DENIED;
teststatus = test_nfslock(fl, conflicting_fl);
debuglog("test_partialfilelock: teststatus %d\n",teststatus);
if (teststatus == NFS_GRANTED || teststatus == NFS_GRANTED_DUPLICATE) {
retval = (teststatus == NFS_GRANTED) ?
PFL_GRANTED : PFL_GRANTED_DUPLICATE;
debuglog("Dumping locks...\n");
dump_filelock(fl);
dump_filelock(*conflicting_fl);
debuglog("Done dumping locks...\n");
} else {
retval = PFL_NFSDENIED;
debuglog("NFS test denied.\n");
dump_filelock(fl);
debuglog("Conflicting.\n");
dump_filelock(*conflicting_fl);
}
debuglog("Exiting testpartialfilelock...\n");
return retval;
}
enum nlm4_stats
do_test(struct file_lock *fl, struct file_lock **conflicting_fl)
{
enum partialfilelock_status pfsret;
enum nlm4_stats retval;
debuglog("Entering do_test...\n");
pfsret = test_partialfilelock(fl,conflicting_fl);
switch (pfsret) {
case PFL_GRANTED:
debuglog("PFL test lock granted\n");
dump_filelock(fl);
dump_filelock(*conflicting_fl);
retval = (fl->flags & LOCK_V4) ? nlm4_granted : nlm_granted;
break;
case PFL_GRANTED_DUPLICATE:
debuglog("PFL test lock granted--duplicate id detected\n");
dump_filelock(fl);
dump_filelock(*conflicting_fl);
debuglog("Clearing conflicting_fl for call semantics\n");
*conflicting_fl = NULL;
retval = (fl->flags & LOCK_V4) ? nlm4_granted : nlm_granted;
break;
case PFL_NFSDENIED:
case PFL_HWDENIED:
debuglog("PFL test lock denied\n");
dump_filelock(fl);
dump_filelock(*conflicting_fl);
retval = (fl->flags & LOCK_V4) ? nlm4_denied : nlm_denied;
break;
case PFL_NFSRESERR:
case PFL_HWRESERR:
debuglog("PFL test lock resource fail\n");
dump_filelock(fl);
dump_filelock(*conflicting_fl);
retval = (fl->flags & LOCK_V4) ? nlm4_denied_nolocks : nlm_denied_nolocks;
break;
default:
debuglog("PFL test lock *FAILED*\n");
dump_filelock(fl);
dump_filelock(*conflicting_fl);
retval = (fl->flags & LOCK_V4) ? nlm4_failed : nlm_denied;
break;
}
debuglog("Exiting do_test...\n");
return retval;
}
enum nlm4_stats
do_lock(struct file_lock *fl)
{
enum partialfilelock_status pfsret;
enum nlm4_stats retval;
debuglog("Entering do_lock...\n");
pfsret = lock_partialfilelock(fl);
switch (pfsret) {
case PFL_GRANTED:
debuglog("PFL lock granted");
dump_filelock(fl);
retval = (fl->flags & LOCK_V4) ? nlm4_granted : nlm_granted;
break;
case PFL_GRANTED_DUPLICATE:
debuglog("PFL lock granted--duplicate id detected");
dump_filelock(fl);
retval = (fl->flags & LOCK_V4) ? nlm4_granted : nlm_granted;
break;
case PFL_NFSDENIED:
case PFL_HWDENIED:
debuglog("PFL_NFS lock denied");
dump_filelock(fl);
retval = (fl->flags & LOCK_V4) ? nlm4_denied : nlm_denied;
break;
case PFL_NFSBLOCKED:
case PFL_HWBLOCKED:
debuglog("PFL_NFS blocking lock denied. Queued.\n");
dump_filelock(fl);
retval = (fl->flags & LOCK_V4) ? nlm4_blocked : nlm_blocked;
break;
case PFL_NFSRESERR:
case PFL_HWRESERR:
case PFL_NFSDENIED_NOLOCK:
case PFL_HWDENIED_NOLOCK:
debuglog("PFL lock resource alocation fail\n");
dump_filelock(fl);
retval = (fl->flags & LOCK_V4) ? nlm4_denied_nolocks : nlm_denied_nolocks;
break;
case PFL_HWDENIED_STALEFH:
debuglog("PFL_NFS lock denied STALEFH");
dump_filelock(fl);
retval = (fl->flags & LOCK_V4) ? nlm4_stale_fh : nlm_denied;
break;
case PFL_HWDENIED_READONLY:
debuglog("PFL_NFS lock denied READONLY");
dump_filelock(fl);
retval = (fl->flags & LOCK_V4) ? nlm4_rofs : nlm_denied;
break;
default:
debuglog("PFL lock *FAILED*");
dump_filelock(fl);
retval = (fl->flags & LOCK_V4) ? nlm4_failed : nlm_denied;
break;
}
debuglog("Exiting do_lock...\n");
return retval;
}
enum nlm4_stats
do_unlock(struct file_lock *fl)
{
enum partialfilelock_status pfsret;
enum nlm4_stats retval;
debuglog("Entering do_unlock...\n");
pfsret = unlock_partialfilelock(fl);
switch (pfsret) {
case PFL_GRANTED:
debuglog("PFL unlock granted");
dump_filelock(fl);
retval = (fl->flags & LOCK_V4) ? nlm4_granted : nlm_granted;
break;
case PFL_NFSDENIED:
case PFL_HWDENIED:
debuglog("PFL_NFS unlock denied");
dump_filelock(fl);
retval = (fl->flags & LOCK_V4) ? nlm4_denied : nlm_denied;
break;
case PFL_NFSDENIED_NOLOCK:
case PFL_HWDENIED_NOLOCK:
debuglog("PFL_NFS no lock found\n");
retval = (fl->flags & LOCK_V4) ? nlm4_granted : nlm_granted;
break;
case PFL_NFSRESERR:
case PFL_HWRESERR:
debuglog("PFL unlock resource failure");
dump_filelock(fl);
retval = (fl->flags & LOCK_V4) ? nlm4_denied_nolocks : nlm_denied_nolocks;
break;
default:
debuglog("PFL unlock *FAILED*");
dump_filelock(fl);
retval = (fl->flags & LOCK_V4) ? nlm4_failed : nlm_denied;
break;
}
debuglog("Exiting do_unlock...\n");
return retval;
}
void
do_clear(const char *hostname)
{
clear_partialfilelock(hostname);
}
struct nlm4_holder *
testlock(struct nlm4_lock *lock, bool_t exclusive, int flags __unused)
{
struct file_lock test_fl, *conflicting_fl;
if (lock->fh.n_len > NFS_MAX_FH_SIZE) {
debuglog("received fhandle size %d, max size %d",
lock->fh.n_len, NFS_MAX_FH_SIZE);
return NULL;
}
bzero(&test_fl, sizeof(test_fl));
test_fl.filehandle.n_len = lock->fh.n_len;
test_fl.filehandle.n_bytes = lock->fh.n_bytes;
copy_nlm4_lock_to_nlm4_holder(lock, exclusive, &test_fl.client);
siglock();
do_test(&test_fl, &conflicting_fl);
if (conflicting_fl == NULL) {
debuglog("No conflicting lock found\n");
sigunlock();
return NULL;
} else {
debuglog("Found conflicting lock\n");
dump_filelock(conflicting_fl);
sigunlock();
return (&conflicting_fl->client);
}
}
enum nlm4_stats
getlock(nlm4_lockargs *lckarg, struct svc_req *rqstp, const int flags)
{
struct file_lock *newfl;
enum nlm4_stats retval;
debuglog("Entering getlock...\n");
if (grace_expired == 0 && lckarg->reclaim == 0)
return (flags & LOCK_V4) ?
nlm4_denied_grace_period : nlm_denied_grace_period;
if (lckarg->alock.fh.n_len > NFS_MAX_FH_SIZE) {
debuglog("received fhandle size %d, max size %d",
lckarg->alock.fh.n_len, NFS_MAX_FH_SIZE);
return (flags & LOCK_V4) ? nlm4_failed : nlm_denied;
}
newfl = allocate_file_lock(&lckarg->alock.oh, &lckarg->alock.fh,
(struct sockaddr *)svc_getcaller(rqstp->rq_xprt),
lckarg->alock.caller_name);
if (newfl == NULL) {
syslog(LOG_NOTICE, "lock allocate failed: %s", strerror(errno));
return (flags & LOCK_V4) ?
nlm4_denied_nolocks : nlm_denied_nolocks;
}
fill_file_lock(newfl,
lckarg->exclusive, lckarg->alock.svid, lckarg->alock.l_offset,
lckarg->alock.l_len,
lckarg->state, 0, flags, lckarg->block);
siglock();
debuglog("Pointer to new lock is %p\n",newfl);
retval = do_lock(newfl);
debuglog("Pointer to new lock is %p\n",newfl);
sigunlock();
switch (retval)
{
case nlm4_granted:
break;
case nlm4_blocked:
break;
default:
deallocate_file_lock(newfl);
break;
}
debuglog("Exiting getlock...\n");
return retval;
}
enum nlm4_stats
unlock(nlm4_lock *lock, const int flags)
{
struct file_lock fl;
enum nlm4_stats err;
debuglog("Entering unlock...\n");
if (lock->fh.n_len > NFS_MAX_FH_SIZE) {
debuglog("received fhandle size %d, max size %d",
lock->fh.n_len, NFS_MAX_FH_SIZE);
return (flags & LOCK_V4) ? nlm4_failed : nlm_denied;
}
siglock();
bzero(&fl,sizeof(struct file_lock));
fl.filehandle.n_len = lock->fh.n_len;
fl.filehandle.n_bytes = lock->fh.n_bytes;
copy_nlm4_lock_to_nlm4_holder(lock, 0, &fl.client);
err = do_unlock(&fl);
sigunlock();
debuglog("Exiting unlock...\n");
return err;
}
enum nlm4_stats
cancellock(nlm4_cancargs *args, const int flags)
{
struct file_lock *ifl, *nfl;
enum nlm4_stats err;
debuglog("Entering cancellock...\n");
if (args->alock.fh.n_len > NFS_MAX_FH_SIZE) {
debuglog("received fhandle size %d, max size %d",
args->alock.fh.n_len, NFS_MAX_FH_SIZE);
return (flags & LOCK_V4) ? nlm4_failed : nlm_denied;
}
siglock();
err = (flags & LOCK_V4) ? nlm4_denied : nlm_denied;
ifl = LIST_FIRST(&blockedlocklist_head);
for ( ; ifl != NULL; ifl = nfl) {
nfl = LIST_NEXT(ifl, nfslocklist);
if (!same_netobj(&args->alock.fh, &ifl->filehandle))
continue;
if (strncmp(args->alock.caller_name, ifl->client_name, SM_MAXSTRLEN))
continue;
if (!same_netobj(&args->alock.oh, &ifl->client.oh))
continue;
if (args->alock.svid != ifl->client.svid)
continue;
if (args->alock.l_offset != ifl->client.l_offset)
continue;
if (args->alock.l_len != ifl->client.l_len)
continue;
if (args->exclusive != ifl->client.exclusive)
continue;
remove_blockingfilelock(ifl);
deallocate_file_lock(ifl);
err = (flags & LOCK_V4) ? nlm4_granted : nlm_granted;
break;
}
sigunlock();
debuglog("Exiting cancellock...\n");
return err;
}
struct host *
get_lock_host(struct hostlst_head *hd, const char *hostname, const struct sockaddr *saddr)
{
struct host *ihp;
if (!hostname && !saddr)
return (NULL);
debuglog("get_lock_host %s\n", hostname ? hostname : "addr");
TAILQ_FOREACH(ihp, hd, hostlst) {
if (hostname && (strncmp(hostname, ihp->name, SM_MAXSTRLEN) != 0))
continue;
if (saddr && addrcmp(saddr, &ihp->addr))
continue;
TAILQ_REMOVE(hd, ihp, hostlst);
if (!saddr || !ihp->addr.sa_len)
++ihp->refcnt;
ihp->lastuse = currsec;
TAILQ_INSERT_HEAD(&hostlst_head, ihp, hostlst);
break;
}
debuglog("get_lock_host %s %s\n",
ihp == NULL ? "did not find" : "found", hostname ? hostname : "addr");
return (ihp);
}
void
monitor_lock_host_by_name(const char *hostname, const struct sockaddr *saddr)
{
struct host *ihp;
debuglog("monitor_lock_host: %s\n", hostname);
ihp = get_lock_host(&hostlst_head, hostname, NULL);
if (ihp == NULL)
ihp = get_lock_host(&hostlst_unref, hostname, NULL);
if (ihp != NULL) {
if (ihp->revname)
debuglog("Monitor_lock_host: %s - %s (cached)\n",
ihp->name, ihp->revname);
else
debuglog("Monitor_lock_host: %s (cached)\n", ihp->name);
return;
}
monitor_lock_host(hostname, saddr);
}
void
monitor_lock_host_by_addr(const struct sockaddr *saddr)
{
struct host *ihp;
struct hostent *hp;
char hostaddr[SM_MAXSTRLEN];
struct sockaddr_in *sin = (struct sockaddr_in *)saddr;
if (getnameinfo(saddr, saddr->sa_len, hostaddr, sizeof(hostaddr),
NULL, 0, NI_NUMERICHOST)) {
debuglog("monitor_lock_host: bad address\n");
return;
}
debuglog("monitor_lock_host: %s\n", hostaddr);
ihp = get_lock_host(&hostlst_head, NULL, saddr);
if (ihp == NULL)
ihp = get_lock_host(&hostlst_unref, NULL, saddr);
if (ihp != NULL) {
debuglog("Monitor_lock_host: %s (cached)\n", ihp->name);
return;
}
hp = gethostbyaddr((char*)&sin->sin_addr, sizeof(sin->sin_addr), AF_INET);
if (hp) {
monitor_lock_host(hp->h_name, saddr);
} else {
monitor_lock_host(hostaddr, saddr);
}
}
static void
monitor_lock_host(const char *hostname, const struct sockaddr *saddr)
{
struct host *nhp;
struct hostent *hp = NULL;
struct mon smon;
struct sm_stat_res sres;
int rpcret;
int retrying = 0;
size_t n;
struct sockaddr_in *sin = (struct sockaddr_in *) saddr;
rpcret = 0;
debuglog("Monitor_lock_host: %s (creating)\n", hostname);
n = strnlen(hostname, SM_MAXSTRLEN);
if (n == SM_MAXSTRLEN) {
debuglog("monitor_lock_host: hostname too long\n");
return;
}
nhp = (struct host *) malloc(sizeof(struct host));
if (nhp == NULL) {
debuglog("Unable to allocate entry for statd mon\n");
return;
}
nhp->name = strdup(hostname);
if (nhp->name == NULL) {
debuglog("Unable to allocate entry name for statd mon\n");
free(nhp);
return;
}
nhp->revname = NULL;
nhp->refcnt = 1;
nhp->lastuse = currsec;
if (saddr) {
bcopy(saddr, &nhp->addr, saddr->sa_len);
} else {
nhp->addr.sa_len = 0;
}
debuglog("Locally Monitoring host '%s'\n", hostname);
debuglog("Attempting to tell statd\n");
bzero(&smon,sizeof(smon));
smon.mon_id.mon_name = nhp->name;
smon.mon_id.my_id.my_name = "localhost\0";
smon.mon_id.my_id.my_prog = NLM_PROG;
smon.mon_id.my_id.my_vers = NLM_SM;
smon.mon_id.my_id.my_proc = NLM_SM_NOTIFY;
retry:
rpcret = callrpc("localhost", SM_PROG, SM_VERS, SM_MON, xdr_mon,
&smon, xdr_sm_stat_res, &sres);
if (rpcret == 0) {
if (sres.res_stat == stat_fail && !retrying) {
debuglog("Statd call failed\n");
if (saddr)
hp = gethostbyaddr((char *) &sin->sin_addr,
sizeof(sin->sin_addr), AF_INET);
if (hp != NULL && strcmp(nhp->name, hp->h_name) != 0) {
debuglog("Statd retry with '%s'\n", hp->h_name);
smon.mon_id.mon_name = hp->h_name;
nhp->revname = strdup(hp->h_name);
if (nhp->revname == NULL) {
debuglog("No memory for revname\n");
free(nhp->name);
free(nhp);
return;
}
retrying = 1;
goto retry;
}
}
} else {
debuglog("Rpc call to statd failed with return value: %d\n",
rpcret);
}
TAILQ_INSERT_HEAD(&hostlst_head, nhp, hostlst);
}
void
unmonitor_lock_host(const char *hostname)
{
struct host *ihp;
TAILQ_FOREACH(ihp, &hostlst_head, hostlst) {
if (strncmp(hostname, ihp->name, SM_MAXSTRLEN) == 0) {
--ihp->refcnt;
break;
}
}
if (ihp == NULL) {
debuglog("Could not find host %16s in mon list\n", hostname);
return;
}
if (ihp->refcnt > 0)
return;
if (ihp->refcnt < 0) {
debuglog("Negative refcount!: %d\n", ihp->refcnt);
}
TAILQ_REMOVE(&hostlst_head, ihp, hostlst);
TAILQ_INSERT_HEAD(&hostlst_unref, ihp, hostlst);
if (host_expire <= 0)
destroy_lock_host(ihp);
}
void
destroy_lock_host(struct host *ihp)
{
struct mon_id smon_id;
struct sm_stat smstat;
int rpcret;
char *name;
name = ihp->revname ? ihp->revname : ihp->name;
debuglog("Attempting to unmonitor host %16s\n", name);
bzero(&smon_id,sizeof(smon_id));
smon_id.mon_name = name;
smon_id.my_id.my_name = "localhost";
smon_id.my_id.my_prog = NLM_PROG;
smon_id.my_id.my_vers = NLM_SM;
smon_id.my_id.my_proc = NLM_SM_NOTIFY;
rpcret = callrpc("localhost", SM_PROG, SM_VERS, SM_UNMON, xdr_mon_id,
&smon_id, xdr_sm_stat, &smstat);
if (rpcret != 0) {
debuglog("Rpc call to unmonitor statd failed with "
" return value: %d: %s", rpcret, clnt_sperrno(rpcret));
} else {
debuglog("Succeeded unmonitoring %16s\n", ihp->name);
}
TAILQ_REMOVE(&hostlst_unref, ihp, hostlst);
if (ihp->name)
free(ihp->name);
if (ihp->revname)
free(ihp->revname);
free(ihp);
}
int
expire_lock_hosts(void)
{
struct host *ihp;
debuglog("expire_lock_hosts: called\n");
for ( ;; ) {
ihp = TAILQ_LAST(&hostlst_unref, hostlst_head);
if (ihp == NULL)
break;
if (host_expire > 0 && ihp->lastuse >= currsec - host_expire)
break;
debuglog("expire_lock_hosts: expiring %s %d %d %d\n",
ihp->name, (int)ihp->lastuse,
(int)currsec, (int)currsec - host_expire);
destroy_lock_host(ihp);
}
return (TAILQ_LAST(&hostlst_unref, hostlst_head) != NULL);
}
void
notify(const char *hostname, const int state)
{
debuglog("notify from %s, new state %d", hostname, state);
siglock();
do_clear(hostname);
sigunlock();
debuglog("Leaving notify\n");
}
int
send_granted(fl, opcode)
struct file_lock *fl;
int opcode __unused;
{
CLIENT *cli;
static char dummy;
struct timeval timeo;
enum clnt_stat rv;
static struct nlm_res retval;
static struct nlm4_res retval4;
debuglog("About to send granted on blocked lock\n");
cli = get_client(fl->addr,
(fl->flags & LOCK_V4) ? NLM_VERS4 : NLM_VERS);
if (cli == NULL) {
syslog(LOG_NOTICE, "failed to get CLIENT for %s",
fl->client_name);
return -1;
}
timeo.tv_sec = 0;
timeo.tv_usec = (fl->flags & LOCK_ASYNC) ? 0 : 500000;
fl->granted_cookie = ++send_granted_cookie;
if (!send_granted_cookie)
send_granted_cookie++;
if (fl->flags & LOCK_V4) {
static nlm4_testargs res;
res.cookie.n_len = sizeof(fl->granted_cookie);
res.cookie.n_bytes = (char*)&fl->granted_cookie;
res.exclusive = fl->client.exclusive;
res.alock.caller_name = fl->client_name;
res.alock.fh.n_len = fl->filehandle.n_len;
res.alock.fh.n_bytes = fl->filehandle.n_bytes;
res.alock.oh = fl->client.oh;
res.alock.svid = fl->client.svid;
res.alock.l_offset = fl->client.l_offset;
res.alock.l_len = fl->client.l_len;
debuglog("sending v4 reply%s",
(fl->flags & LOCK_ASYNC) ? " (async)":"");
if (fl->flags & LOCK_ASYNC) {
rv = clnt_call(cli, NLM4_GRANTED_MSG,
xdr_nlm4_testargs, &res, xdr_void, &dummy, timeo);
} else {
rv = clnt_call(cli, NLM4_GRANTED,
xdr_nlm4_testargs, &res, xdr_nlm4_res,
&retval4, timeo);
}
} else {
static nlm_testargs res;
res.cookie.n_len = sizeof(fl->granted_cookie);
res.cookie.n_bytes = (char*)&fl->granted_cookie;
res.exclusive = fl->client.exclusive;
res.alock.caller_name = fl->client_name;
res.alock.fh.n_len = fl->filehandle.n_len;
res.alock.fh.n_bytes = fl->filehandle.n_bytes;
res.alock.oh = fl->client.oh;
res.alock.svid = fl->client.svid;
res.alock.l_offset = fl->client.l_offset;
res.alock.l_len = fl->client.l_len;
debuglog("sending v1 reply%s",
(fl->flags & LOCK_ASYNC) ? " (async)":"");
if (fl->flags & LOCK_ASYNC) {
rv = clnt_call(cli, NLM_GRANTED_MSG,
xdr_nlm_testargs, &res, xdr_void, &dummy, timeo);
} else {
rv = clnt_call(cli, NLM_GRANTED,
xdr_nlm_testargs, &res, xdr_nlm_res,
&retval, timeo);
}
}
if (debug_level > 2)
debuglog("clnt_call returns %d(%s) for granted",
rv, clnt_sperrno(rv));
if ((rv != RPC_SUCCESS) &&
!((fl->flags & LOCK_ASYNC) && (rv == RPC_TIMEDOUT)))
return -1;
return 0;
}
void
granted_failed(nlm4_res *arg)
{
u_int64_t cookie;
struct file_lock *ifl;
debuglog("Entering granted_failed, status %d\n", arg->stat.stat);
if (arg->cookie.n_len != sizeof(cookie)) {
debuglog("Exiting granted_failed: bogus cookie size %d\n",
arg->cookie.n_len);
return;
}
bcopy(arg->cookie.n_bytes, &cookie, sizeof(cookie));
debuglog("granted_failed, cookie 0x%llx\n", cookie);
LIST_FOREACH(ifl, &nfslocklist_head, nfslocklist) {
debuglog("Pointer to file lock: %p\n",ifl);
debuglog("****Dump of ifl****\n");
dump_filelock(ifl);
if (ifl->granted_cookie != cookie)
continue;
debuglog("granted_failed: cookie found\n");
break;
}
if (ifl) {
do_unlock(ifl);
} else {
debuglog("granted_failed: cookie NOT FOUND\n");
}
debuglog("Exiting granted_failed\n");
}
enum nlm4_stats
getshare(nlm_shareargs *shrarg, struct svc_req *rqstp, const int flags)
{
struct sharefile *shrfile;
struct file_share *sh;
size_t n;
debuglog("Entering getshare...\n");
if (grace_expired == 0 && shrarg->reclaim == 0) {
debuglog("getshare denied - grace period\n");
return (flags & LOCK_V4) ?
nlm4_denied_grace_period :
nlm_denied_grace_period;
}
if (shrarg->share.fh.n_len > NFS_MAX_FH_SIZE) {
debuglog("received fhandle size %d, max size %d",
shrarg->share.fh.n_len, NFS_MAX_FH_SIZE);
return (flags & LOCK_V4) ? nlm4_failed : nlm_denied;
}
LIST_FOREACH(shrfile, &nfssharefilelist_head, sharefilelist) {
if ((shrarg->share.fh.n_len == shrfile->filehandle.n_len) &&
(bcmp(shrarg->share.fh.n_bytes, shrfile->filehandle.n_bytes,
shrarg->share.fh.n_len) == 0)) {
break;
}
}
if (!shrfile) {
fhandle_t fh;
int fd;
fh.fh_len = shrarg->share.fh.n_len;
bcopy(shrarg->share.fh.n_bytes, fh.fh_data, fh.fh_len);
fd = fhopen(&fh, O_RDONLY);
if (fd < 0) {
debuglog("fhopen failed (from %16s): %32s\n",
shrarg->share.caller_name, strerror(errno));
if ((flags & LOCK_V4) == 0)
return nlm_denied;
switch (errno) {
case ESTALE:
return nlm4_stale_fh;
default:
return nlm4_failed;
}
}
shrfile = malloc(sizeof(struct sharefile));
if (!shrfile) {
debuglog("getshare failed: can't allocate sharefile\n");
close(fd);
return (flags & LOCK_V4) ? nlm4_denied_nolocks : nlm_denied_nolocks;
}
shrfile->filehandle.n_len = shrarg->share.fh.n_len;
shrfile->filehandle.n_bytes = malloc(shrarg->share.fh.n_len);
if (!shrfile->filehandle.n_bytes) {
debuglog("getshare failed: can't allocate sharefile filehandle\n");
free(shrfile);
close(fd);
return (flags & LOCK_V4) ? nlm4_denied_nolocks : nlm_denied_nolocks;
}
bcopy(shrarg->share.fh.n_bytes, shrfile->filehandle.n_bytes,
shrarg->share.fh.n_len);
shrfile->fd = fd;
shrfile->refcount = 0;
shrfile->sharelist_head.lh_first = NULL;
LIST_INSERT_HEAD(&nfssharefilelist_head, shrfile, sharefilelist);
}
LIST_FOREACH(sh, &shrfile->sharelist_head, nfssharelist) {
if ((strncmp(shrarg->share.caller_name, sh->client_name, SM_MAXSTRLEN) == 0) &&
same_netobj(&shrarg->share.oh, &sh->oh)) {
sh->mode = shrarg->share.mode;
sh->access = shrarg->share.access;
debuglog("getshare: updated existing share\n");
return (flags & LOCK_V4) ? nlm4_granted : nlm_granted;
}
if (((shrarg->share.mode & sh->access) != 0) ||
((shrarg->share.access & sh->mode) != 0)) {
debuglog("getshare: conflicts with existing share\n");
return (flags & LOCK_V4) ? nlm4_denied : nlm_denied;
}
}
n = strnlen(shrarg->share.caller_name, SM_MAXSTRLEN);
if (n < SM_MAXSTRLEN) {
sh = malloc(sizeof(*sh) - sizeof(sh->client_name) + n + 1);
} else {
debuglog("getshare failed: hostname too long\n");
sh = NULL;
}
if (!sh) {
debuglog("getshare failed: can't allocate share\n");
if (!shrfile->refcount) {
LIST_REMOVE(shrfile, sharefilelist);
close(shrfile->fd);
free(shrfile->filehandle.n_bytes);
free(shrfile);
}
return (flags & LOCK_V4) ? nlm4_denied_nolocks : nlm_denied_nolocks;
}
bzero(sh, sizeof(*sh) - sizeof(sh->client_name));
sh->oh.n_len = shrarg->share.oh.n_len;
sh->oh.n_bytes = malloc(sh->oh.n_len);
if (!sh->oh.n_bytes) {
debuglog("getshare failed: can't allocate share owner handle\n");
free(sh);
if (!shrfile->refcount) {
LIST_REMOVE(shrfile, sharefilelist);
close(shrfile->fd);
free(shrfile->filehandle.n_bytes);
free(shrfile);
}
return (flags & LOCK_V4) ? nlm4_denied_nolocks : nlm_denied_nolocks;
}
memcpy(sh->client_name, shrarg->share.caller_name, n);
sh->client_name[n] = 0;
sh->mode = shrarg->share.mode;
sh->access = shrarg->share.access;
LIST_INSERT_HEAD(&shrfile->sharelist_head, sh, nfssharelist);
shrfile->refcount++;
debuglog("Exiting getshare...\n");
return (flags & LOCK_V4) ? nlm4_granted : nlm_granted;
}
enum nlm4_stats
unshare(nlm_shareargs *shrarg, struct svc_req *rqstp, const int flags)
{
struct sharefile *shrfile;
struct file_share *sh;
debuglog("Entering unshare...\n");
if (shrarg->share.fh.n_len > NFS_MAX_FH_SIZE) {
debuglog("received fhandle size %d, max size %d",
shrarg->share.fh.n_len, NFS_MAX_FH_SIZE);
return (flags & LOCK_V4) ? nlm4_failed : nlm_denied;
}
LIST_FOREACH(shrfile, &nfssharefilelist_head, sharefilelist) {
if ((shrarg->share.fh.n_len == shrfile->filehandle.n_len) &&
(bcmp(shrarg->share.fh.n_bytes, shrfile->filehandle.n_bytes,
shrarg->share.fh.n_len) == 0)) {
break;
}
}
if (!shrfile) {
debuglog("unshare: no such share file\n");
return (flags & LOCK_V4) ? nlm4_granted : nlm_granted;
}
LIST_FOREACH(sh, &shrfile->sharelist_head, nfssharelist) {
if ((strncmp(shrarg->share.caller_name, sh->client_name, SM_MAXSTRLEN) == 0) &&
same_netobj(&shrarg->share.oh, &sh->oh))
break;
}
if (!sh) {
debuglog("unshare: no such share\n");
return (flags & LOCK_V4) ? nlm4_granted : nlm_granted;
}
shrfile->refcount--;
LIST_REMOVE(sh, nfssharelist);
free(sh->oh.n_bytes);
free(sh);
if (!shrfile->refcount) {
debuglog("unshare: file has no more shares\n");
LIST_REMOVE(shrfile, sharefilelist);
close(shrfile->fd);
free(shrfile->filehandle.n_bytes);
free(shrfile);
}
debuglog("Exiting unshare...\n");
return (flags & LOCK_V4) ? nlm4_granted : nlm_granted;
}
void
do_free_all(const char *hostname)
{
struct file_lock *ifl, *nfl;
struct sharefile *shrfile, *nshrfile;
struct file_share *ifs, *nfs;
enum partialfilelock_status pfsret;
ifl = LIST_FIRST(&blockedlocklist_head);
while (ifl != NULL) {
nfl = LIST_NEXT(ifl, nfslocklist);
if (((ifl->flags & LOCK_MON) == 0) &&
(strncmp(hostname, ifl->client_name, SM_MAXSTRLEN) == 0)) {
remove_blockingfilelock(ifl);
deallocate_file_lock(ifl);
}
ifl = nfl;
}
restart:
ifl = LIST_FIRST(&nfslocklist_head);
while (ifl != NULL) {
nfl = LIST_NEXT(ifl, nfslocklist);
if (((ifl->flags & LOCK_MON) == 0) &&
(strncmp(hostname, ifl->client_name, SM_MAXSTRLEN) == 0)) {
pfsret = unlock_partialfilelock(ifl);
if (pfsret != PFL_GRANTED) {
syslog(LOG_WARNING, "unmonitored lock clearing for %s failed: %d",
hostname, pfsret);
break;
}
goto restart;
}
ifl = nfl;
}
shrfile = LIST_FIRST(&nfssharefilelist_head);
while (shrfile != NULL) {
nshrfile = LIST_NEXT(shrfile, sharefilelist);
ifs = LIST_FIRST(&shrfile->sharelist_head);
while (ifs != NULL) {
nfs = LIST_NEXT(ifs, nfssharelist);
if (strncmp(hostname, ifs->client_name, SM_MAXSTRLEN) == 0) {
shrfile->refcount--;
LIST_REMOVE(ifs, nfssharelist);
free(ifs->oh.n_bytes);
free(ifs);
}
ifs = nfs;
}
if (!shrfile->refcount) {
LIST_REMOVE(shrfile, sharefilelist);
close(shrfile->fd);
free(shrfile->filehandle.n_bytes);
free(shrfile);
}
shrfile = nshrfile;
}
}
void
siglock(void)
{
sigset_t block;
sigemptyset(&block);
sigaddset(&block, SIGCHLD);
if (sigprocmask(SIG_BLOCK, &block, NULL) < 0) {
syslog(LOG_WARNING, "siglock failed: %s", strerror(errno));
}
}
void
sigunlock(void)
{
sigset_t block;
sigemptyset(&block);
sigaddset(&block, SIGCHLD);
if (sigprocmask(SIG_UNBLOCK, &block, NULL) < 0) {
syslog(LOG_WARNING, "sigunlock failed: %s", strerror(errno));
}
}