2 * Copyright (c) 2000 Manuel Bouyer.
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 * 3. All advertising materials mentioning features or use of this software
13 * must display the following acknowledgement:
14 * This product includes software developed by the University of
15 * California, Berkeley and its contributors.
16 * 4. Neither the name of the University nor the names of its contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * $NetBSD: lockd_lock.c,v 1.5 2000/11/21 03:47:41 enami Exp $
33 * $FreeBSD: src/usr.sbin/rpc.lockd/lockd_lock.c,v 1.1 2001/03/19 12:50:09 alfred Exp $
45 #include <sys/types.h>
47 #include <sys/socket.h>
48 #include <sys/queue.h>
49 #include <sys/param.h>
50 #include <sys/mount.h>
52 #include <rpcsvc/sm_inter.h>
53 #include <rpcsvc/nlm_prot.h>
54 #include "lockd_lock.h"
57 /* A set of utilities for managing file locking */
58 LIST_HEAD(lcklst_head, file_lock);
59 struct lcklst_head lcklst_head = LIST_HEAD_INITIALIZER(lcklst_head);
61 /* struct describing a lock */
63 LIST_ENTRY(file_lock) lcklst;
64 fhandle_t filehandle; /* NFS filehandle */
65 struct sockaddr *addr;
66 struct nlm4_holder client; /* lock holder */
67 netobj client_cookie; /* cookie sent by the client */
68 char client_name[128];
69 int nsm_status; /* status from the remote lock manager */
70 int status; /* lock status, see below */
71 int flags; /* lock flags, see lockd_lock.h */
72 pid_t locker; /* pid of the child process trying to get the lock */
73 int fd; /* file descriptor for this lock */
77 #define LKST_LOCKED 1 /* lock is locked */
78 #define LKST_WAITING 2 /* file is already locked by another host */
79 #define LKST_PROCESSING 3 /* child is trying to acquire the lock */
80 #define LKST_DYING 4 /* must dies when we get news from the child */
82 void lfree(struct file_lock *);
83 void sigchild_handler(int);
84 enum nlm_stats do_lock(struct file_lock *, int);
85 enum nlm_stats do_unlock(struct file_lock *);
86 void send_granted(struct file_lock *, int);
90 /* list of hosts we monitor */
91 LIST_HEAD(hostlst_head, host);
92 struct hostlst_head hostlst_head = LIST_HEAD_INITIALIZER(hostlst_head);
94 /* struct describing a lock */
96 LIST_ENTRY(host) hostlst;
97 char name[SM_MAXSTRLEN];
104 * testlock(): inform the caller if the requested lock would be granted or not
105 * returns NULL if lock would granted, or pointer to the current nlm4_holder
110 testlock(struct nlm4_lock *lock, int flags)
112 struct file_lock *fl;
113 fhandle_t filehandle;
115 /* convert lock to a local filehandle */
116 memcpy(&filehandle, lock->fh.n_bytes, sizeof(filehandle));
119 /* search through the list for lock holder */
120 for (fl = LIST_FIRST(&lcklst_head); fl != NULL;
121 fl = LIST_NEXT(fl, lcklst)) {
122 if (fl->status != LKST_LOCKED)
124 if (memcmp(&fl->filehandle, &filehandle, sizeof(filehandle)))
127 syslog(LOG_DEBUG, "test for %s: found lock held by %s",
128 lock->caller_name, fl->client_name);
130 return (&fl->client);
134 syslog(LOG_DEBUG, "test for %s: no lock found", lock->caller_name);
139 * getlock: try to acquire the lock.
140 * If file is already locked and we can sleep, put the lock in the list with
141 * status LKST_WAITING; it'll be processed later.
142 * Otherwise try to lock. If we're allowed to block, fork a child which
143 * will do the blocking lock.
146 getlock(nlm4_lockargs *lckarg, struct svc_req *rqstp, int flags)
148 struct file_lock *fl, *newfl;
149 enum nlm_stats retval;
151 if (grace_expired == 0 && lckarg->reclaim == 0)
152 return (flags & LOCK_V4) ?
153 nlm4_denied_grace_period : nlm_denied_grace_period;
155 /* allocate new file_lock for this request */
156 newfl = malloc(sizeof(struct file_lock));
158 syslog(LOG_NOTICE, "malloc failed: %s", strerror(errno));
160 return (flags & LOCK_V4) ?
161 nlm4_denied_nolock : nlm_denied_nolocks;
163 if (lckarg->alock.fh.n_len != sizeof(fhandle_t)) {
164 syslog(LOG_DEBUG, "received fhandle size %d, local size %d",
165 lckarg->alock.fh.n_len, (int)sizeof(fhandle_t));
167 memcpy(&newfl->filehandle, lckarg->alock.fh.n_bytes, sizeof(fhandle_t));
168 newfl->addr = (struct sockaddr *)svc_getrpccaller(rqstp->rq_xprt)->buf;
169 newfl->client.exclusive = lckarg->exclusive;
170 newfl->client.svid = lckarg->alock.svid;
171 newfl->client.oh.n_bytes = malloc(lckarg->alock.oh.n_len);
172 if (newfl->client.oh.n_bytes == NULL) {
173 syslog(LOG_NOTICE, "malloc failed: %s", strerror(errno));
175 return (flags & LOCK_V4) ?
176 nlm4_denied_nolock : nlm_denied_nolocks;
178 newfl->client.oh.n_len = lckarg->alock.oh.n_len;
179 memcpy(newfl->client.oh.n_bytes, lckarg->alock.oh.n_bytes,
180 lckarg->alock.oh.n_len);
181 newfl->client.l_offset = lckarg->alock.l_offset;
182 newfl->client.l_len = lckarg->alock.l_len;
183 newfl->client_cookie.n_len = lckarg->cookie.n_len;
184 newfl->client_cookie.n_bytes = malloc(lckarg->cookie.n_len);
185 if (newfl->client_cookie.n_bytes == NULL) {
186 syslog(LOG_NOTICE, "malloc failed: %s", strerror(errno));
187 free(newfl->client.oh.n_bytes);
189 return (flags & LOCK_V4) ?
190 nlm4_denied_nolock : nlm_denied_nolocks;
192 memcpy(newfl->client_cookie.n_bytes, lckarg->cookie.n_bytes,
193 lckarg->cookie.n_len);
194 strncpy(newfl->client_name, lckarg->alock.caller_name, 128);
195 newfl->nsm_status = lckarg->state;
197 newfl->flags = flags;
199 /* look for a lock rq from this host for this fh */
200 for (fl = LIST_FIRST(&lcklst_head); fl != NULL;
201 fl = LIST_NEXT(fl, lcklst)) {
202 if (memcmp(&newfl->filehandle, &fl->filehandle,
203 sizeof(fhandle_t)) == 0) {
204 if (strcmp(newfl->client_name, fl->client_name) == 0 &&
205 newfl->client.svid == fl->client.svid) {
206 /* already locked by this host ??? */
208 syslog(LOG_NOTICE, "duplicate lock from %s",
213 return (flags & LOCK_V4) ?
214 nlm4_granted : nlm_granted;
216 case LKST_PROCESSING:
217 return (flags & LOCK_V4) ?
218 nlm4_blocked : nlm_blocked;
220 return (flags & LOCK_V4) ?
221 nlm4_denied : nlm_denied;
223 syslog(LOG_NOTICE, "bad status %d",
225 return (flags & LOCK_V4) ?
226 nlm4_failed : nlm_denied;
230 * We already have a lock for this file. Put this one
231 * in waiting state if allowed to block
234 syslog(LOG_DEBUG, "lock from %s: already "
236 lckarg->alock.caller_name);
237 newfl->status = LKST_WAITING;
238 LIST_INSERT_HEAD(&lcklst_head, newfl, lcklst);
239 do_mon(lckarg->alock.caller_name);
241 return (flags & LOCK_V4) ?
242 nlm4_blocked : nlm_blocked;
245 syslog(LOG_DEBUG, "lock from %s: already "
247 lckarg->alock.caller_name);
249 return (flags & LOCK_V4) ?
250 nlm4_denied : nlm_denied;
254 /* no entry for this file yet; add to list */
255 LIST_INSERT_HEAD(&lcklst_head, newfl, lcklst);
257 retval = do_lock(newfl, lckarg->block);
260 /* case nlm_granted: is the same as nlm4_granted */
262 /* case nlm_blocked: is the same as nlm4_blocked */
263 do_mon(lckarg->alock.caller_name);
273 /* unlock a filehandle */
275 unlock(nlm4_lock *lck, int flags)
277 struct file_lock *fl;
278 fhandle_t filehandle;
279 int err = (flags & LOCK_V4) ? nlm4_granted : nlm_granted;
281 memcpy(&filehandle, lck->fh.n_bytes, sizeof(fhandle_t));
283 for (fl = LIST_FIRST(&lcklst_head); fl != NULL;
284 fl = LIST_NEXT(fl, lcklst)) {
285 if (strcmp(fl->client_name, lck->caller_name) ||
286 memcmp(&filehandle, &fl->filehandle, sizeof(fhandle_t)) ||
287 fl->client.oh.n_len != lck->oh.n_len ||
288 memcmp(fl->client.oh.n_bytes, lck->oh.n_bytes,
289 fl->client.oh.n_len) != 0 ||
290 fl->client.svid != lck->svid)
292 /* Got it, unlock and remove from the queue */
293 syslog(LOG_DEBUG, "unlock from %s: found struct, status %d",
294 lck->caller_name, fl->status);
295 switch (fl->status) {
300 /* remove from the list */
301 LIST_REMOVE(fl, lcklst);
304 case LKST_PROCESSING:
306 * being handled by a child; will clean up
307 * when the child exits
309 fl->status = LKST_DYING;
315 syslog(LOG_NOTICE, "unknow status %d for %s",
316 fl->status, fl->client_name);
322 /* didn't find a matching entry; log anyway */
323 syslog(LOG_NOTICE, "no matching entry for %s",
325 return (flags & LOCK_V4) ? nlm4_granted : nlm_granted;
329 lfree(struct file_lock *fl)
331 free(fl->client.oh.n_bytes);
332 free(fl->client_cookie.n_bytes);
337 sigchild_handler(int sig)
341 struct file_lock *fl;
344 pid = wait4(-1, &status, WNOHANG, NULL);
347 syslog(LOG_NOTICE, "wait failed: %s",
350 syslog(LOG_DEBUG, "wait failed: %s",
355 /* no more child to handle yet */
359 * if we're here we have a child that exited
360 * Find the associated file_lock.
362 for (fl = LIST_FIRST(&lcklst_head); fl != NULL;
363 fl = LIST_NEXT(fl, lcklst)) {
364 if (pid == fl->locker)
367 if (pid != fl->locker) {
368 syslog(LOG_NOTICE, "unknow child %d", pid);
370 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
371 syslog(LOG_NOTICE, "child %d failed", pid);
373 * can't do much here; we can't reply
374 * anything but OK for blocked locks
375 * Eventually the client will time out
382 /* check lock status */
383 syslog(LOG_DEBUG, "processing child %d, status %d",
386 case LKST_PROCESSING:
387 fl->status = LKST_LOCKED;
388 send_granted(fl, (fl->flags & LOCK_V4) ?
389 nlm4_granted : nlm_granted);
395 syslog(LOG_NOTICE, "bad lock status (%d) for"
396 " child %d", fl->status, pid);
404 * try to acquire the lock described by fl. Eventually fock a child to do a
405 * blocking lock if allowed and required.
409 do_lock(struct file_lock *fl, int block)
414 fl->fd = fhopen(&fl->filehandle, O_RDWR);
418 error = nlm4_stale_fh;
426 if ((fl->flags & LOCK_V4) == 0)
428 syslog(LOG_NOTICE, "fhopen failed (from %s): %s",
429 fl->client_name, strerror(errno));
430 LIST_REMOVE(fl, lcklst);
433 if (fstat(fl->fd, &st) < 0) {
434 syslog(LOG_NOTICE, "fstat failed (from %s): %s",
435 fl->client_name, strerror(errno));
437 syslog(LOG_DEBUG, "lock from %s for file%s%s: dev %d ino %ju (uid %d), "
439 fl->client_name, fl->client.exclusive ? " (exclusive)":"",
440 block ? " (block)":"",
441 st.st_dev, (uintmax_t)st.st_ino, st.st_uid, fl->flags);
443 if (fl->client.exclusive == 0)
447 error = flock(fl->fd, lflags);
448 if (error != 0 && errno == EAGAIN && block) {
449 switch (fl->locker = fork()) {
450 case -1: /* fork failed */
451 syslog(LOG_NOTICE, "fork failed: %s", strerror(errno));
452 LIST_REMOVE(fl, lcklst);
454 return (fl->flags & LOCK_V4) ?
455 nlm4_denied_nolock : nlm_denied_nolocks;
458 * Attempt a blocking lock. Will have to call
461 setproctitle("%s", fl->client_name);
463 if(flock(fl->fd, lflags) != 0) {
464 syslog(LOG_NOTICE, "flock failed: %s",
471 syslog(LOG_DEBUG, "lock request from %s: forked %d",
472 fl->client_name, fl->locker);
473 fl->status = LKST_PROCESSING;
474 return (fl->flags & LOCK_V4) ?
475 nlm4_blocked : nlm_blocked;
485 error = nlm4_stale_fh;
493 if ((fl->flags & LOCK_V4) == 0)
496 syslog(LOG_NOTICE, "flock for %s failed: %s",
497 fl->client_name, strerror(errno));
498 else syslog(LOG_DEBUG, "flock for %s failed: %s",
499 fl->client_name, strerror(errno));
500 LIST_REMOVE(fl, lcklst);
504 fl->status = LKST_LOCKED;
505 return (fl->flags & LOCK_V4) ? nlm4_granted : nlm_granted;
509 send_granted(struct file_lock *fl, int opcode)
513 struct timeval timeo;
515 static struct nlm_res retval;
516 static struct nlm4_res retval4;
518 cli = get_client(fl->addr,
519 (fl->flags & LOCK_V4) ? NLM_VERS4 : NLM_VERS);
521 syslog(LOG_NOTICE, "failed to get CLIENT for %s",
524 * We fail to notify remote that the lock has been granted.
525 * The client will timeout and retry, the lock will be
526 * granted at this time.
531 timeo.tv_usec = (fl->flags & LOCK_ASYNC) ? 0 : 500000; /* 0.5s */
533 if (fl->flags & LOCK_V4) {
534 static nlm4_testargs res;
535 res.cookie = fl->client_cookie;
536 res.exclusive = fl->client.exclusive;
537 res.alock.caller_name = fl->client_name;
538 res.alock.fh.n_len = sizeof(fhandle_t);
539 res.alock.fh.n_bytes = (char*)&fl->filehandle;
540 res.alock.oh = fl->client.oh;
541 res.alock.svid = fl->client.svid;
542 res.alock.l_offset = fl->client.l_offset;
543 res.alock.l_len = fl->client.l_len;
544 syslog(LOG_DEBUG, "sending v4 reply%s",
545 (fl->flags & LOCK_ASYNC) ? " (async)":"");
546 if (fl->flags & LOCK_ASYNC) {
547 success = clnt_call(cli, NLM4_GRANTED_MSG,
548 (xdrproc_t)xdr_nlm4_testargs, &res,
549 (xdrproc_t)xdr_void, &dummy, timeo);
551 success = clnt_call(cli, NLM4_GRANTED,
552 (xdrproc_t)xdr_nlm4_testargs, &res,
553 (xdrproc_t)xdr_nlm4_res, &retval4, timeo);
556 static nlm_testargs res;
558 res.cookie = fl->client_cookie;
559 res.exclusive = fl->client.exclusive;
560 res.alock.caller_name = fl->client_name;
561 res.alock.fh.n_len = sizeof(fhandle_t);
562 res.alock.fh.n_bytes = (char*)&fl->filehandle;
563 res.alock.oh = fl->client.oh;
564 res.alock.svid = fl->client.svid;
565 res.alock.l_offset = fl->client.l_offset;
566 res.alock.l_len = fl->client.l_len;
567 syslog(LOG_DEBUG, "sending v1 reply%s",
568 (fl->flags & LOCK_ASYNC) ? " (async)":"");
569 if (fl->flags & LOCK_ASYNC) {
570 success = clnt_call(cli, NLM_GRANTED_MSG,
571 (xdrproc_t)xdr_nlm_testargs, &res,
572 (xdrproc_t)xdr_void, &dummy, timeo);
574 success = clnt_call(cli, NLM_GRANTED,
575 (xdrproc_t)xdr_nlm_testargs, &res,
576 (xdrproc_t)xdr_nlm_res, &retval, timeo);
580 syslog(LOG_DEBUG, "clnt_call returns %d(%s) for granted",
581 success, clnt_sperrno(success));
586 do_unlock(struct file_lock *rfl)
588 struct file_lock *fl;
592 /* unlock the file: closing is enouth ! */
593 if (close(rfl->fd) < 0) {
595 error = nlm4_stale_fh;
598 if ((fl->flags & LOCK_V4) == 0)
601 "close failed (from %s): %s",
602 rfl->client_name, strerror(errno));
604 error = (fl->flags & LOCK_V4) ?
605 nlm4_granted : nlm_granted;
607 LIST_REMOVE(rfl, lcklst);
609 /* process the next LKST_WAITING lock request for this fh */
610 for (fl = LIST_FIRST(&lcklst_head); fl != NULL;
611 fl = LIST_NEXT(fl, lcklst)) {
612 if (fl->status != LKST_WAITING ||
613 memcmp(&rfl->filehandle, &fl->filehandle,
614 sizeof(fhandle_t)) != 0)
617 lockst = do_lock(fl, 1); /* If it's LKST_WAITING we can block */
620 /* case nlm_granted: same as nlm4_granted */
621 send_granted(fl, (fl->flags & LOCK_V4) ?
622 nlm4_granted : nlm_granted);
625 /* case nlm_blocked: same as nlm4_blocked */
642 sigaddset(&block, SIGCHLD);
644 if (sigprocmask(SIG_BLOCK, &block, NULL) < 0) {
645 syslog(LOG_WARNING, "siglock failed: %s", strerror(errno));
655 sigaddset(&block, SIGCHLD);
657 if (sigprocmask(SIG_UNBLOCK, &block, NULL) < 0) {
658 syslog(LOG_WARNING, "sigunlock failed: %s", strerror(errno));
662 /* monitor a host through rpc.statd, and keep a ref count */
664 do_mon(char *hostname)
668 struct sm_stat_res res;
671 for (hp = LIST_FIRST(&hostlst_head); hp != NULL;
672 hp = LIST_NEXT(hp, hostlst)) {
673 if (strcmp(hostname, hp->name) == 0) {
674 /* already monitored, just bump refcnt */
679 /* not found, have to create an entry for it */
680 hp = malloc(sizeof(struct host));
681 strncpy(hp->name, hostname, SM_MAXSTRLEN);
683 syslog(LOG_DEBUG, "monitoring host %s",
685 memset(&my_mon, 0, sizeof(my_mon));
686 my_mon.mon_id.mon_name = hp->name;
687 my_mon.mon_id.my_id.my_name = "localhost";
688 my_mon.mon_id.my_id.my_prog = NLM_PROG;
689 my_mon.mon_id.my_id.my_vers = NLM_SM;
690 my_mon.mon_id.my_id.my_proc = NLM_SM_NOTIFY;
692 callrpc("localhost", SM_PROG, SM_VERS, SM_MON, (xdrproc_t)xdr_mon,
693 (char*)&my_mon, (xdrproc_t)xdr_sm_stat_res, (char*)&res)) != 0) {
694 syslog(LOG_WARNING, "rpc to statd failed: %s",
695 clnt_sperrno((enum clnt_stat)retval));
699 if (res.res_stat == stat_fail) {
700 syslog(LOG_WARNING, "statd failed");
704 LIST_INSERT_HEAD(&hostlst_head, hp, hostlst);
708 notify(const char *hostname, int state)
710 struct file_lock *fl, *next_fl;
712 syslog(LOG_DEBUG, "notify from %s, new state %d", hostname, state);
713 /* search all lock for this host; if status changed, release the lock */
715 for (fl = LIST_FIRST(&lcklst_head); fl != NULL; fl = next_fl) {
716 next_fl = LIST_NEXT(fl, lcklst);
717 if (strcmp(hostname, fl->client_name) == 0 &&
718 fl->nsm_status != state) {
719 syslog(LOG_DEBUG, "state %d, nsm_state %d, unlocking",
720 fl->status, fl->nsm_status);
724 if (err != nlm_granted)
726 "notify: unlock failed for %s (%d)",
730 LIST_REMOVE(fl, lcklst);
733 case LKST_PROCESSING:
734 fl->status = LKST_DYING;
739 syslog(LOG_NOTICE, "unknown status %d for %s",
740 fl->status, fl->client_name);