1 /* $NetBSD: lockd_lock.c,v 1.5 2000/11/21 03:47:41 enami Exp $ */
4 * Copyright (c) 2001 Andrew P. Lentvorski, Jr.
5 * Copyright (c) 2000 Manuel Bouyer.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. All advertising materials mentioning features or use of this software
16 * must display the following acknowledgement:
17 * This product includes software developed by the University of
18 * California, Berkeley and its contributors.
19 * 4. Neither the name of the University nor the names of its contributors
20 * may be used to endorse or promote products derived from this software
21 * without specific prior written permission.
23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
37 #include <sys/cdefs.h>
38 __FBSDID("$FreeBSD$");
54 #include <sys/types.h>
56 #include <sys/socket.h>
57 #include <sys/param.h>
58 #include <sys/mount.h>
60 #include <rpcsvc/sm_inter.h>
61 #include <rpcsvc/nlm_prot.h>
62 #include "lockd_lock.h"
65 #define MAXOBJECTSIZE 64
66 #define MAXBUFFERSIZE 1024
69 * A set of utilities for managing file locking
71 * XXX: All locks are in a linked list, a better structure should be used
72 * to improve search/access effeciency.
75 /* struct describing a lock */
77 LIST_ENTRY(file_lock) nfslocklist;
78 fhandle_t filehandle; /* NFS filehandle */
79 struct sockaddr *addr;
80 struct nlm4_holder client; /* lock holder */
81 /* XXX: client_cookie used *only* in send_granted */
82 netobj client_cookie; /* cookie sent by the client */
83 int nsm_status; /* status from the remote lock manager */
84 int status; /* lock status, see below */
85 int flags; /* lock flags, see lockd_lock.h */
86 int blocking; /* blocking lock or not */
87 char client_name[SM_MAXSTRLEN]; /* client_name is really variable
88 length and must be last! */
91 LIST_HEAD(nfslocklist_head, file_lock);
92 struct nfslocklist_head nfslocklist_head = LIST_HEAD_INITIALIZER(nfslocklist_head);
94 LIST_HEAD(blockedlocklist_head, file_lock);
95 struct blockedlocklist_head blockedlocklist_head = LIST_HEAD_INITIALIZER(blockedlocklist_head);
98 #define LKST_LOCKED 1 /* lock is locked */
99 /* XXX: Is this flag file specific or lock specific? */
100 #define LKST_WAITING 2 /* file is already locked by another host */
101 #define LKST_PROCESSING 3 /* child is trying to aquire the lock */
102 #define LKST_DYING 4 /* must dies when we get news from the child */
104 /* struct describing a monitored host */
106 LIST_ENTRY(host) hostlst;
108 char name[SM_MAXSTRLEN]; /* name is really variable length and
111 /* list of hosts we monitor */
112 LIST_HEAD(hostlst_head, host);
113 struct hostlst_head hostlst_head = LIST_HEAD_INITIALIZER(hostlst_head);
116 * File monitoring handlers
117 * XXX: These might be able to be removed when kevent support
118 * is placed into the hardware lock/unlock routines. (ie.
119 * let the kernel do all the file monitoring)
122 /* Struct describing a monitored file */
124 LIST_ENTRY(monfile) monfilelist;
125 fhandle_t filehandle; /* Local access filehandle */
126 int fd; /* file descriptor: remains open until unlock! */
131 /* List of files we monitor */
132 LIST_HEAD(monfilelist_head, monfile);
133 struct monfilelist_head monfilelist_head = LIST_HEAD_INITIALIZER(monfilelist_head);
135 static int debugdelay = 0;
137 enum nfslock_status { NFS_GRANTED = 0, NFS_GRANTED_DUPLICATE,
138 NFS_DENIED, NFS_DENIED_NOLOCK,
141 enum hwlock_status { HW_GRANTED = 0, HW_GRANTED_DUPLICATE,
142 HW_DENIED, HW_DENIED_NOLOCK,
143 HW_STALEFH, HW_READONLY, HW_RESERR };
145 enum partialfilelock_status { PFL_GRANTED=0, PFL_GRANTED_DUPLICATE, PFL_DENIED,
146 PFL_NFSDENIED, PFL_NFSBLOCKED, PFL_NFSDENIED_NOLOCK, PFL_NFSRESERR,
147 PFL_HWDENIED, PFL_HWBLOCKED, PFL_HWDENIED_NOLOCK, PFL_HWRESERR};
149 enum LFLAGS {LEDGE_LEFT, LEDGE_LBOUNDARY, LEDGE_INSIDE, LEDGE_RBOUNDARY, LEDGE_RIGHT};
150 enum RFLAGS {REDGE_LEFT, REDGE_LBOUNDARY, REDGE_INSIDE, REDGE_RBOUNDARY, REDGE_RIGHT};
151 /* XXX: WARNING! I HAVE OVERLOADED THIS STATUS ENUM! SPLIT IT APART INTO TWO */
152 enum split_status {SPL_DISJOINT=0, SPL_LOCK1=1, SPL_LOCK2=2, SPL_CONTAINED=4, SPL_RESERR=8};
154 enum partialfilelock_status lock_partialfilelock(struct file_lock *fl);
156 void send_granted(struct file_lock *fl, int opcode);
158 void sigunlock(void);
159 void monitor_lock_host(const char *hostname);
160 void unmonitor_lock_host(char *hostname);
162 void copy_nlm4_lock_to_nlm4_holder(const struct nlm4_lock *src,
163 const bool_t exclusive, struct nlm4_holder *dest);
164 struct file_lock * allocate_file_lock(const netobj *lockowner,
165 const netobj *matchcookie,
166 const struct sockaddr *addr,
167 const char *caller_name);
168 void deallocate_file_lock(struct file_lock *fl);
169 void fill_file_lock(struct file_lock *fl, const fhandle_t *fh,
170 const bool_t exclusive, const int32_t svid,
171 const u_int64_t offset, const u_int64_t len,
172 const int state, const int status, const int flags, const int blocking);
173 int regions_overlap(const u_int64_t start1, const u_int64_t len1,
174 const u_int64_t start2, const u_int64_t len2);
175 enum split_status region_compare(const u_int64_t starte, const u_int64_t lene,
176 const u_int64_t startu, const u_int64_t lenu,
177 u_int64_t *start1, u_int64_t *len1, u_int64_t *start2, u_int64_t *len2);
178 int same_netobj(const netobj *n0, const netobj *n1);
179 int same_filelock_identity(const struct file_lock *fl0,
180 const struct file_lock *fl2);
182 static void debuglog(char const *fmt, ...);
183 void dump_static_object(const unsigned char* object, const int sizeof_object,
184 unsigned char* hbuff, const int sizeof_hbuff,
185 unsigned char* cbuff, const int sizeof_cbuff);
186 void dump_netobj(const struct netobj *nobj);
187 void dump_filelock(const struct file_lock *fl);
188 struct file_lock * get_lock_matching_unlock(const struct file_lock *fl);
189 enum nfslock_status test_nfslock(const struct file_lock *fl,
190 struct file_lock **conflicting_fl);
191 enum nfslock_status lock_nfslock(struct file_lock *fl);
192 enum nfslock_status delete_nfslock(struct file_lock *fl);
193 enum nfslock_status unlock_nfslock(const struct file_lock *fl,
194 struct file_lock **released_lock, struct file_lock **left_lock,
195 struct file_lock **right_lock);
196 enum hwlock_status lock_hwlock(struct file_lock *fl);
197 enum split_status split_nfslock(const struct file_lock *exist_lock,
198 const struct file_lock *unlock_lock, struct file_lock **left_lock,
199 struct file_lock **right_lock);
200 void add_blockingfilelock(struct file_lock *fl);
201 enum hwlock_status unlock_hwlock(const struct file_lock *fl);
202 enum hwlock_status test_hwlock(const struct file_lock *fl,
203 struct file_lock **conflicting_fl);
204 void remove_blockingfilelock(struct file_lock *fl);
205 void clear_blockingfilelock(const char *hostname);
206 void retry_blockingfilelocklist(void);
207 enum partialfilelock_status unlock_partialfilelock(
208 const struct file_lock *fl);
209 void clear_partialfilelock(const char *hostname);
210 enum partialfilelock_status test_partialfilelock(
211 const struct file_lock *fl, struct file_lock **conflicting_fl);
212 enum nlm_stats do_test(struct file_lock *fl,
213 struct file_lock **conflicting_fl);
214 enum nlm_stats do_unlock(struct file_lock *fl);
215 enum nlm_stats do_lock(struct file_lock *fl);
216 void do_clear(const char *hostname);
217 size_t strnlen(const char *, size_t);
220 debuglog(char const *fmt, ...)
224 if (debug_level < 1) {
231 vsyslog(LOG_DEBUG, fmt, ap);
236 dump_static_object(object, size_object, hbuff, size_hbuff, cbuff, size_cbuff)
237 const unsigned char *object;
238 const int size_object;
239 unsigned char *hbuff;
240 const int size_hbuff;
241 unsigned char *cbuff;
242 const int size_cbuff;
246 if (debug_level < 2) {
250 objectsize = size_object;
252 if (objectsize == 0) {
253 debuglog("object is size 0\n");
255 if (objectsize > MAXOBJECTSIZE) {
256 debuglog("Object of size %d being clamped"
257 "to size %d\n", objectsize, MAXOBJECTSIZE);
258 objectsize = MAXOBJECTSIZE;
262 if (size_hbuff < objectsize*2+1) {
263 debuglog("Hbuff not large enough."
266 for(i=0;i<objectsize;i++) {
267 sprintf(hbuff+i*2,"%02x",*(object+i));
274 if (size_cbuff < objectsize+1) {
275 debuglog("Cbuff not large enough."
279 for(i=0;i<objectsize;i++) {
280 if (*(object+i) >= 32 && *(object+i) <= 127) {
281 *(cbuff+i) = *(object+i);
292 dump_netobj(const struct netobj *nobj)
294 char hbuff[MAXBUFFERSIZE*2];
295 char cbuff[MAXBUFFERSIZE];
297 if (debug_level < 2) {
302 debuglog("Null netobj pointer\n");
304 else if (nobj->n_len == 0) {
305 debuglog("Size zero netobj\n");
307 dump_static_object(nobj->n_bytes, nobj->n_len,
308 hbuff, sizeof(hbuff), cbuff, sizeof(cbuff));
309 debuglog("netobj: len: %d data: %s ::: %s\n",
310 nobj->n_len, hbuff, cbuff);
314 /* #define DUMP_FILELOCK_VERBOSE */
316 dump_filelock(const struct file_lock *fl)
318 #ifdef DUMP_FILELOCK_VERBOSE
319 char hbuff[MAXBUFFERSIZE*2];
320 char cbuff[MAXBUFFERSIZE];
323 if (debug_level < 2) {
328 debuglog("Dumping file lock structure @ %p\n", fl);
330 #ifdef DUMP_FILELOCK_VERBOSE
331 dump_static_object((unsigned char *)&fl->filehandle,
332 sizeof(fl->filehandle), hbuff, sizeof(hbuff),
333 cbuff, sizeof(cbuff));
334 debuglog("Filehandle: %8s ::: %8s\n", hbuff, cbuff);
337 debuglog("Dumping nlm4_holder:\n"
338 "exc: %x svid: %x offset:len %llx:%llx\n",
339 fl->client.exclusive, fl->client.svid,
340 fl->client.l_offset, fl->client.l_len);
342 #ifdef DUMP_FILELOCK_VERBOSE
343 debuglog("Dumping client identity:\n");
344 dump_netobj(&fl->client.oh);
346 debuglog("Dumping client cookie:\n");
347 dump_netobj(&fl->client_cookie);
349 debuglog("nsm: %d status: %d flags: %d svid: %x"
350 " client_name: %s\n", fl->nsm_status, fl->status,
351 fl->flags, fl->client.svid, fl->client_name);
354 debuglog("NULL file lock structure\n");
359 copy_nlm4_lock_to_nlm4_holder(src, exclusive, dest)
360 const struct nlm4_lock *src;
361 const bool_t exclusive;
362 struct nlm4_holder *dest;
365 dest->exclusive = exclusive;
366 dest->oh.n_len = src->oh.n_len;
367 dest->oh.n_bytes = src->oh.n_bytes;
368 dest->svid = src->svid;
369 dest->l_offset = src->l_offset;
370 dest->l_len = src->l_len;
375 strnlen(const char *s, size_t len)
379 for (n = 0; s[n] != 0 && n < len; n++)
385 * allocate_file_lock: Create a lock with the given parameters
389 allocate_file_lock(const netobj *lockowner, const netobj *matchcookie,
390 const struct sockaddr *addr, const char *caller_name)
392 struct file_lock *newfl;
395 /* Beware of rubbish input! */
396 n = strnlen(caller_name, SM_MAXSTRLEN);
397 if (n == SM_MAXSTRLEN) {
401 newfl = malloc(sizeof(*newfl) - sizeof(newfl->client_name) + n + 1);
405 bzero(newfl, sizeof(*newfl) - sizeof(newfl->client_name));
406 memcpy(newfl->client_name, caller_name, n);
407 newfl->client_name[n] = 0;
409 newfl->client.oh.n_bytes = malloc(lockowner->n_len);
410 if (newfl->client.oh.n_bytes == NULL) {
414 newfl->client.oh.n_len = lockowner->n_len;
415 bcopy(lockowner->n_bytes, newfl->client.oh.n_bytes, lockowner->n_len);
417 newfl->client_cookie.n_bytes = malloc(matchcookie->n_len);
418 if (newfl->client_cookie.n_bytes == NULL) {
419 free(newfl->client.oh.n_bytes);
423 newfl->client_cookie.n_len = matchcookie->n_len;
424 bcopy(matchcookie->n_bytes, newfl->client_cookie.n_bytes, matchcookie->n_len);
426 newfl->addr = malloc(addr->sa_len);
427 if (newfl->addr == NULL) {
428 free(newfl->client_cookie.n_bytes);
429 free(newfl->client.oh.n_bytes);
433 memcpy(newfl->addr, addr, addr->sa_len);
439 * file_file_lock: Force creation of a valid file lock
442 fill_file_lock(struct file_lock *fl, const fhandle_t *fh,
443 const bool_t exclusive, const int32_t svid,
444 const u_int64_t offset, const u_int64_t len,
445 const int state, const int status, const int flags, const int blocking)
447 bcopy(fh, &fl->filehandle, sizeof(fhandle_t));
449 fl->client.exclusive = exclusive;
450 fl->client.svid = svid;
451 fl->client.l_offset = offset;
452 fl->client.l_len = len;
454 fl->nsm_status = state;
457 fl->blocking = blocking;
461 * deallocate_file_lock: Free all storage associated with a file lock
464 deallocate_file_lock(struct file_lock *fl)
467 free(fl->client.oh.n_bytes);
468 free(fl->client_cookie.n_bytes);
473 * regions_overlap(): This function examines the two provided regions for
477 regions_overlap(start1, len1, start2, len2)
478 const u_int64_t start1, len1, start2, len2;
480 u_int64_t d1,d2,d3,d4;
481 enum split_status result;
483 debuglog("Entering region overlap with vals: %llu:%llu--%llu:%llu\n",
484 start1, len1, start2, len2);
486 result = region_compare(start1, len1, start2, len2,
489 debuglog("Exiting region overlap with val: %d\n",result);
491 if (result == SPL_DISJOINT) {
501 * region_compare(): Examine lock regions and split appropriately
503 * XXX: Fix 64 bit overflow problems
504 * XXX: Check to make sure I got *ALL* the cases.
505 * XXX: This DESPERATELY needs a regression test.
508 region_compare(starte, lene, startu, lenu,
509 start1, len1, start2, len2)
510 const u_int64_t starte, lene, startu, lenu;
511 u_int64_t *start1, *len1, *start2, *len2;
514 * Please pay attention to the sequential exclusions
515 * of the if statements!!!
519 enum split_status retval;
521 retval = SPL_DISJOINT;
523 if (lene == 0 && lenu == 0) {
524 /* Examine left edge of locker */
525 lflags = LEDGE_INSIDE;
526 if (startu < starte) {
528 } else if (startu == starte) {
529 lflags = LEDGE_LBOUNDARY;
532 rflags = REDGE_RBOUNDARY; /* Both are infiinite */
534 if (lflags == LEDGE_INSIDE) {
536 *len1 = startu - starte;
539 if (lflags == LEDGE_LEFT || lflags == LEDGE_LBOUNDARY) {
540 retval = SPL_CONTAINED;
544 } else if (lene == 0 && lenu != 0) {
545 /* Established lock is infinite */
546 /* Examine left edge of unlocker */
547 lflags = LEDGE_INSIDE;
548 if (startu < starte) {
550 } else if (startu == starte) {
551 lflags = LEDGE_LBOUNDARY;
554 /* Examine right edge of unlocker */
555 if (startu + lenu < starte) {
556 /* Right edge of unlocker left of established lock */
559 } else if (startu + lenu == starte) {
560 /* Right edge of unlocker on start of established lock */
561 rflags = REDGE_LBOUNDARY;
563 } else { /* Infinifty is right of finity */
564 /* Right edge of unlocker inside established lock */
565 rflags = REDGE_INSIDE;
568 if (lflags == LEDGE_INSIDE) {
570 *len1 = startu - starte;
574 if (rflags == REDGE_INSIDE) {
575 /* Create right lock */
576 *start2 = startu+lenu;
580 } else if (lene != 0 && lenu == 0) {
581 /* Unlocker is infinite */
582 /* Examine left edge of unlocker */
583 lflags = LEDGE_RIGHT;
584 if (startu < starte) {
586 retval = SPL_CONTAINED;
588 } else if (startu == starte) {
589 lflags = LEDGE_LBOUNDARY;
590 retval = SPL_CONTAINED;
592 } else if ((startu > starte) && (startu < starte + lene - 1)) {
593 lflags = LEDGE_INSIDE;
594 } else if (startu == starte + lene - 1) {
595 lflags = LEDGE_RBOUNDARY;
596 } else { /* startu > starte + lene -1 */
597 lflags = LEDGE_RIGHT;
601 rflags = REDGE_RIGHT; /* Infinity is right of finity */
603 if (lflags == LEDGE_INSIDE || lflags == LEDGE_RBOUNDARY) {
605 *len1 = startu - starte;
610 /* Both locks are finite */
612 /* Examine left edge of unlocker */
613 lflags = LEDGE_RIGHT;
614 if (startu < starte) {
616 } else if (startu == starte) {
617 lflags = LEDGE_LBOUNDARY;
618 } else if ((startu > starte) && (startu < starte + lene - 1)) {
619 lflags = LEDGE_INSIDE;
620 } else if (startu == starte + lene - 1) {
621 lflags = LEDGE_RBOUNDARY;
622 } else { /* startu > starte + lene -1 */
623 lflags = LEDGE_RIGHT;
627 /* Examine right edge of unlocker */
628 if (startu + lenu < starte) {
629 /* Right edge of unlocker left of established lock */
632 } else if (startu + lenu == starte) {
633 /* Right edge of unlocker on start of established lock */
634 rflags = REDGE_LBOUNDARY;
636 } else if (startu + lenu < starte + lene) {
637 /* Right edge of unlocker inside established lock */
638 rflags = REDGE_INSIDE;
639 } else if (startu + lenu == starte + lene) {
640 /* Right edge of unlocker on right edge of established lock */
641 rflags = REDGE_RBOUNDARY;
642 } else { /* startu + lenu > starte + lene */
643 /* Right edge of unlocker is right of established lock */
644 rflags = REDGE_RIGHT;
647 if (lflags == LEDGE_INSIDE || lflags == LEDGE_RBOUNDARY) {
648 /* Create left lock */
650 *len1 = (startu - starte);
654 if (rflags == REDGE_INSIDE) {
655 /* Create right lock */
656 *start2 = startu+lenu;
657 *len2 = starte+lene-(startu+lenu);
661 if ((lflags == LEDGE_LEFT || lflags == LEDGE_LBOUNDARY) &&
662 (rflags == REDGE_RBOUNDARY || rflags == REDGE_RIGHT)) {
663 retval = SPL_CONTAINED;
670 * same_netobj: Compares the apprpriate bits of a netobj for identity
673 same_netobj(const netobj *n0, const netobj *n1)
679 debuglog("Entering netobj identity check\n");
681 if (n0->n_len == n1->n_len) {
682 debuglog("Preliminary length check passed\n");
683 retval = !bcmp(n0->n_bytes, n1->n_bytes, n0->n_len);
684 debuglog("netobj %smatch\n", retval ? "" : "mis");
691 * same_filelock_identity: Compares the appropriate bits of a file_lock
694 same_filelock_identity(fl0, fl1)
695 const struct file_lock *fl0, *fl1;
701 debuglog("Checking filelock identity\n");
704 * Check process ids and host information.
706 retval = (fl0->client.svid == fl1->client.svid &&
707 same_netobj(&(fl0->client.oh), &(fl1->client.oh)));
709 debuglog("Exiting checking filelock identity: retval: %d\n",retval);
715 * Below here are routines associated with manipulating the NFS
720 * get_lock_matching_unlock: Return a lock which matches the given unlock lock
722 * XXX: It is a shame that this duplicates so much code from test_nfslock.
725 get_lock_matching_unlock(const struct file_lock *fl)
727 struct file_lock *ifl; /* Iterator */
729 debuglog("Entering get_lock_matching_unlock\n");
730 debuglog("********Dump of fl*****************\n");
733 LIST_FOREACH(ifl, &nfslocklist_head, nfslocklist) {
734 debuglog("Pointer to file lock: %p\n",ifl);
736 debuglog("****Dump of ifl****\n");
738 debuglog("*******************\n");
741 * XXX: It is conceivable that someone could use the NLM RPC
742 * system to directly access filehandles. This may be a
743 * security hazard as the filehandle code may bypass normal
744 * file access controls
746 if (bcmp(&fl->filehandle, &ifl->filehandle, sizeof(fhandle_t)))
749 debuglog("get_lock_matching_unlock: Filehandles match, "
750 "checking regions\n");
752 /* Filehandles match, check for region overlap */
753 if (!regions_overlap(fl->client.l_offset, fl->client.l_len,
754 ifl->client.l_offset, ifl->client.l_len))
757 debuglog("get_lock_matching_unlock: Region overlap"
758 " found %llu : %llu -- %llu : %llu\n",
759 fl->client.l_offset,fl->client.l_len,
760 ifl->client.l_offset,ifl->client.l_len);
762 /* Regions overlap, check the identity */
763 if (!same_filelock_identity(fl,ifl))
766 debuglog("get_lock_matching_unlock: Duplicate lock id. Granting\n");
770 debuglog("Exiting bet_lock_matching_unlock\n");
776 * test_nfslock: check for NFS lock in lock list
778 * This routine makes the following assumptions:
779 * 1) Nothing will adjust the lock list during a lookup
781 * This routine has an intersting quirk which bit me hard.
782 * The conflicting_fl is the pointer to the conflicting lock.
783 * However, to modify the "*pointer* to the conflicting lock" rather
784 * that the "conflicting lock itself" one must pass in a "pointer to
785 * the pointer of the conflicting lock". Gross.
789 test_nfslock(const struct file_lock *fl, struct file_lock **conflicting_fl)
791 struct file_lock *ifl; /* Iterator */
792 enum nfslock_status retval;
794 debuglog("Entering test_nfslock\n");
796 retval = NFS_GRANTED;
797 (*conflicting_fl) = NULL;
799 debuglog("Entering lock search loop\n");
801 debuglog("***********************************\n");
802 debuglog("Dumping match filelock\n");
803 debuglog("***********************************\n");
805 debuglog("***********************************\n");
807 LIST_FOREACH(ifl, &nfslocklist_head, nfslocklist) {
808 if (retval == NFS_DENIED)
811 debuglog("Top of lock loop\n");
812 debuglog("Pointer to file lock: %p\n",ifl);
814 debuglog("***********************************\n");
815 debuglog("Dumping test filelock\n");
816 debuglog("***********************************\n");
818 debuglog("***********************************\n");
821 * XXX: It is conceivable that someone could use the NLM RPC
822 * system to directly access filehandles. This may be a
823 * security hazard as the filehandle code may bypass normal
824 * file access controls
826 if (bcmp(&fl->filehandle, &ifl->filehandle, sizeof(fhandle_t)))
829 debuglog("test_nfslock: filehandle match found\n");
831 /* Filehandles match, check for region overlap */
832 if (!regions_overlap(fl->client.l_offset, fl->client.l_len,
833 ifl->client.l_offset, ifl->client.l_len))
836 debuglog("test_nfslock: Region overlap found"
837 " %llu : %llu -- %llu : %llu\n",
838 fl->client.l_offset,fl->client.l_len,
839 ifl->client.l_offset,ifl->client.l_len);
841 /* Regions overlap, check the exclusivity */
842 if (!(fl->client.exclusive || ifl->client.exclusive))
845 debuglog("test_nfslock: Exclusivity failure: %d %d\n",
846 fl->client.exclusive,
847 ifl->client.exclusive);
849 if (same_filelock_identity(fl,ifl)) {
850 debuglog("test_nfslock: Duplicate id. Granting\n");
851 (*conflicting_fl) = ifl;
852 retval = NFS_GRANTED_DUPLICATE;
854 /* locking attempt fails */
855 debuglog("test_nfslock: Lock attempt failed\n");
856 debuglog("Desired lock\n");
858 debuglog("Conflicting lock\n");
860 (*conflicting_fl) = ifl;
865 debuglog("Dumping file locks\n");
866 debuglog("Exiting test_nfslock\n");
872 * lock_nfslock: attempt to create a lock in the NFS lock list
874 * This routine tests whether the lock will be granted and then adds
875 * the entry to the lock list if so.
877 * Argument fl gets modified as its list housekeeping entries get modified
878 * upon insertion into the NFS lock list
880 * This routine makes several assumptions:
881 * 1) It is perfectly happy to grant a duplicate lock from the same pid.
882 * While this seems to be intuitively wrong, it is required for proper
883 * Posix semantics during unlock. It is absolutely imperative to not
884 * unlock the main lock before the two child locks are established. Thus,
885 * one has be be able to create duplicate locks over an existing lock
886 * 2) It currently accepts duplicate locks from the same id,pid
890 lock_nfslock(struct file_lock *fl)
892 enum nfslock_status retval;
893 struct file_lock *dummy_fl;
897 debuglog("Entering lock_nfslock...\n");
899 retval = test_nfslock(fl,&dummy_fl);
901 if (retval == NFS_GRANTED || retval == NFS_GRANTED_DUPLICATE) {
902 debuglog("Inserting lock...\n");
904 LIST_INSERT_HEAD(&nfslocklist_head, fl, nfslocklist);
907 debuglog("Exiting lock_nfslock...\n");
913 * delete_nfslock: delete an NFS lock list entry
915 * This routine is used to delete a lock out of the NFS lock list
916 * without regard to status, underlying locks, regions or anything else
918 * Note that this routine *does not deallocate memory* of the lock.
919 * It just disconnects it from the list. The lock can then be used
920 * by other routines without fear of trashing the list.
924 delete_nfslock(struct file_lock *fl)
927 LIST_REMOVE(fl, nfslocklist);
929 return (NFS_GRANTED);
933 split_nfslock(exist_lock, unlock_lock, left_lock, right_lock)
934 const struct file_lock *exist_lock, *unlock_lock;
935 struct file_lock **left_lock, **right_lock;
937 u_int64_t start1, len1, start2, len2;
938 enum split_status spstatus;
940 spstatus = region_compare(exist_lock->client.l_offset, exist_lock->client.l_len,
941 unlock_lock->client.l_offset, unlock_lock->client.l_len,
942 &start1, &len1, &start2, &len2);
944 if ((spstatus & SPL_LOCK1) != 0) {
945 *left_lock = allocate_file_lock(&exist_lock->client.oh, &exist_lock->client_cookie, exist_lock->addr, exist_lock->client_name);
946 if (*left_lock == NULL) {
947 debuglog("Unable to allocate resource for split 1\n");
951 fill_file_lock(*left_lock, &exist_lock->filehandle,
952 exist_lock->client.exclusive, exist_lock->client.svid,
954 exist_lock->nsm_status,
955 exist_lock->status, exist_lock->flags, exist_lock->blocking);
958 if ((spstatus & SPL_LOCK2) != 0) {
959 *right_lock = allocate_file_lock(&exist_lock->client.oh, &exist_lock->client_cookie, exist_lock->addr, exist_lock->client_name);
960 if (*right_lock == NULL) {
961 debuglog("Unable to allocate resource for split 1\n");
962 if (*left_lock != NULL) {
963 deallocate_file_lock(*left_lock);
968 fill_file_lock(*right_lock, &exist_lock->filehandle,
969 exist_lock->client.exclusive, exist_lock->client.svid,
971 exist_lock->nsm_status,
972 exist_lock->status, exist_lock->flags, exist_lock->blocking);
979 unlock_nfslock(fl, released_lock, left_lock, right_lock)
980 const struct file_lock *fl;
981 struct file_lock **released_lock;
982 struct file_lock **left_lock;
983 struct file_lock **right_lock;
985 struct file_lock *mfl; /* Matching file lock */
986 enum nfslock_status retval;
987 enum split_status spstatus;
989 debuglog("Entering unlock_nfslock\n");
991 *released_lock = NULL;
995 retval = NFS_DENIED_NOLOCK;
997 debuglog("Attempting to match lock...\n");
998 mfl = get_lock_matching_unlock(fl);
1001 debuglog("Unlock matched. Querying for split\n");
1003 spstatus = split_nfslock(mfl, fl, left_lock, right_lock);
1005 debuglog("Split returned %d %p %p %p %p\n",spstatus,mfl,fl,*left_lock,*right_lock);
1006 debuglog("********Split dumps********");
1009 dump_filelock(*left_lock);
1010 dump_filelock(*right_lock);
1011 debuglog("********End Split dumps********");
1013 if (spstatus == SPL_RESERR) {
1014 if (*left_lock != NULL) {
1015 deallocate_file_lock(*left_lock);
1019 if (*right_lock != NULL) {
1020 deallocate_file_lock(*right_lock);
1027 /* Insert new locks from split if required */
1028 if (*left_lock != NULL) {
1029 debuglog("Split left activated\n");
1030 LIST_INSERT_HEAD(&nfslocklist_head, *left_lock, nfslocklist);
1033 if (*right_lock != NULL) {
1034 debuglog("Split right activated\n");
1035 LIST_INSERT_HEAD(&nfslocklist_head, *right_lock, nfslocklist);
1038 /* Unlock the lock since it matches identity */
1039 LIST_REMOVE(mfl, nfslocklist);
1040 *released_lock = mfl;
1041 retval = NFS_GRANTED;
1044 debuglog("Exiting unlock_nfslock\n");
1050 * Below here are the routines for manipulating the file lock directly
1051 * on the disk hardware itself
1054 lock_hwlock(struct file_lock *fl)
1056 struct monfile *imf,*nmf;
1057 int lflags, flerror;
1059 /* Scan to see if filehandle already present */
1060 LIST_FOREACH(imf, &monfilelist_head, monfilelist) {
1061 if (bcmp(&fl->filehandle, &imf->filehandle,
1062 sizeof(fl->filehandle)) == 0) {
1063 /* imf is the correct filehandle */
1069 * Filehandle already exists (we control the file)
1070 * *AND* NFS has already cleared the lock for availability
1071 * Grant it and bump the refcount.
1075 return (HW_GRANTED);
1078 /* No filehandle found, create and go */
1079 nmf = malloc(sizeof(struct monfile));
1081 debuglog("hwlock resource allocation failure\n");
1085 /* XXX: Is O_RDWR always the correct mode? */
1086 nmf->fd = fhopen(&fl->filehandle, O_RDWR);
1088 debuglog("fhopen failed (from %16s): %32s\n",
1089 fl->client_name, strerror(errno));
1093 return (HW_STALEFH);
1095 return (HW_READONLY);
1101 /* File opened correctly, fill the monitor struct */
1102 bcopy(&fl->filehandle, &nmf->filehandle, sizeof(fl->filehandle));
1104 nmf->exclusive = fl->client.exclusive;
1106 lflags = (nmf->exclusive == 1) ?
1107 (LOCK_EX | LOCK_NB) : (LOCK_SH | LOCK_NB);
1109 flerror = flock(nmf->fd, lflags);
1112 debuglog("flock failed (from %16s): %32s\n",
1113 fl->client_name, strerror(errno));
1120 return (HW_STALEFH);
1122 return (HW_READONLY);
1129 /* File opened and locked */
1130 LIST_INSERT_HEAD(&monfilelist_head, nmf, monfilelist);
1132 debuglog("flock succeeded (from %16s)\n", fl->client_name);
1133 return (HW_GRANTED);
1137 unlock_hwlock(const struct file_lock *fl)
1139 struct monfile *imf;
1141 debuglog("Entering unlock_hwlock\n");
1142 debuglog("Entering loop interation\n");
1144 /* Scan to see if filehandle already present */
1145 LIST_FOREACH(imf, &monfilelist_head, monfilelist) {
1146 if (bcmp(&fl->filehandle, &imf->filehandle,
1147 sizeof(fl->filehandle)) == 0) {
1148 /* imf is the correct filehandle */
1153 debuglog("Completed iteration. Proceeding\n");
1157 debuglog("Exiting unlock_hwlock (HW_DENIED_NOLOCK)\n");
1158 return (HW_DENIED_NOLOCK);
1164 if (imf->refcount < 0) {
1165 debuglog("Negative hardware reference count\n");
1168 if (imf->refcount <= 0) {
1170 LIST_REMOVE(imf, monfilelist);
1173 debuglog("Exiting unlock_hwlock (HW_GRANTED)\n");
1174 return (HW_GRANTED);
1178 test_hwlock(fl, conflicting_fl)
1179 const struct file_lock *fl __unused;
1180 struct file_lock **conflicting_fl __unused;
1184 * XXX: lock tests on hardware are not required until
1185 * true partial file testing is done on the underlying file
1193 * Below here are routines for manipulating blocked lock requests
1194 * They should only be called from the XXX_partialfilelock routines
1195 * if at all possible
1199 duplicate_block(struct file_lock *fl)
1201 struct file_lock *ifl,*nfl;
1204 debuglog("Entering duplicate_block");
1207 * Is this lock request already on the blocking list?
1208 * Consider it a dupe if the file handles, offset, length,
1209 * exclusivity and client match.
1211 LIST_FOREACH(ifl, &blockedlocklist_head, nfslocklist) {
1212 if (!bcmp(&fl->filehandle, &ifl->filehandle,
1213 sizeof(fhandle_t)) &&
1214 fl->client.exclusive == ifl->client.exclusive &&
1215 fl->client.l_offset == ifl->client.l_offset &&
1216 fl->client.l_len == ifl->client.l_len &&
1217 same_filelock_identity(fl, ifl)) {
1223 debuglog("Exiting duplicate_block: %s\n", retval ? "already blocked"
1224 : "not already blocked");
1229 add_blockingfilelock(struct file_lock *fl)
1231 debuglog("Entering add_blockingfilelock\n");
1234 * A blocking lock request _should_ never be duplicated as a client
1235 * that is already blocked shouldn't be able to request another
1236 * lock. Alas, there are some buggy clients that do request the same
1237 * lock repeatedly. Make sure only unique locks are on the blocked
1240 if (duplicate_block(fl)) {
1241 debuglog("Exiting add_blockingfilelock: already blocked\n");
1246 * Clear the blocking flag so that it can be reused without
1247 * adding it to the blocking queue a second time
1251 LIST_INSERT_HEAD(&blockedlocklist_head, fl, nfslocklist);
1253 debuglog("Exiting add_blockingfilelock: added blocked lock\n");
1257 remove_blockingfilelock(struct file_lock *fl)
1260 debuglog("Entering remove_blockingfilelock\n");
1262 LIST_REMOVE(fl, nfslocklist);
1264 debuglog("Exiting remove_blockingfilelock\n");
1268 clear_blockingfilelock(const char *hostname)
1270 struct file_lock *ifl,*nfl;
1273 * Normally, LIST_FOREACH is called for, but since
1274 * the current element *is* the iterator, deleting it
1275 * would mess up the iteration. Thus, a next element
1276 * must be used explicitly
1279 ifl = LIST_FIRST(&blockedlocklist_head);
1281 while (ifl != NULL) {
1282 nfl = LIST_NEXT(ifl, nfslocklist);
1284 if (strncmp(hostname, ifl->client_name, SM_MAXSTRLEN) == 0) {
1285 remove_blockingfilelock(ifl);
1286 deallocate_file_lock(ifl);
1294 retry_blockingfilelocklist(void)
1296 /* Retry all locks in the blocked list */
1297 struct file_lock *ifl, *nfl; /* Iterator */
1298 enum partialfilelock_status pflstatus;
1300 debuglog("Entering retry_blockingfilelocklist\n");
1302 LIST_FOREACH_SAFE(ifl, &blockedlocklist_head, nfslocklist, nfl) {
1303 debuglog("Iterator choice %p\n",ifl);
1304 debuglog("Next iterator choice %p\n",nfl);
1307 * SUBTLE BUG: The file_lock must be removed from the
1308 * old list so that it's list pointers get disconnected
1309 * before being allowed to participate in the new list
1310 * which will automatically add it in if necessary.
1313 LIST_REMOVE(ifl, nfslocklist);
1314 pflstatus = lock_partialfilelock(ifl);
1316 if (pflstatus == PFL_GRANTED || pflstatus == PFL_GRANTED_DUPLICATE) {
1317 debuglog("Granted blocked lock\n");
1318 /* lock granted and is now being used */
1319 send_granted(ifl,0);
1321 /* Reinsert lock back into blocked list */
1322 debuglog("Replacing blocked lock\n");
1323 LIST_INSERT_HEAD(&blockedlocklist_head, ifl, nfslocklist);
1327 debuglog("Exiting retry_blockingfilelocklist\n");
1331 * Below here are routines associated with manipulating all
1332 * aspects of the partial file locking system (list, hardware, etc.)
1336 * Please note that lock monitoring must be done at this level which
1337 * keeps track of *individual* lock requests on lock and unlock
1339 * XXX: Split unlocking is going to make the unlock code miserable
1343 * lock_partialfilelock:
1345 * Argument fl gets modified as its list housekeeping entries get modified
1346 * upon insertion into the NFS lock list
1348 * This routine makes several assumptions:
1349 * 1) It (will) pass locks through to flock to lock the entire underlying file
1350 * and then parcel out NFS locks if it gets control of the file.
1351 * This matches the old rpc.lockd file semantics (except where it
1352 * is now more correct). It is the safe solution, but will cause
1353 * overly restrictive blocking if someone is trying to use the
1354 * underlying files without using NFS. This appears to be an
1355 * acceptable tradeoff since most people use standalone NFS servers.
1356 * XXX: The right solution is probably kevent combined with fcntl
1358 * 2) Nothing modifies the lock lists between testing and granting
1359 * I have no idea whether this is a useful assumption or not
1362 enum partialfilelock_status
1363 lock_partialfilelock(struct file_lock *fl)
1365 enum partialfilelock_status retval;
1366 enum nfslock_status lnlstatus;
1367 enum hwlock_status hwstatus;
1369 debuglog("Entering lock_partialfilelock\n");
1371 retval = PFL_DENIED;
1374 * Execute the NFS lock first, if possible, as it is significantly
1375 * easier and less expensive to undo than the filesystem lock
1378 lnlstatus = lock_nfslock(fl);
1380 switch (lnlstatus) {
1382 case NFS_GRANTED_DUPLICATE:
1384 * At this point, the NFS lock is allocated and active.
1385 * Remember to clean it up if the hardware lock fails
1387 hwstatus = lock_hwlock(fl);
1391 case HW_GRANTED_DUPLICATE:
1392 debuglog("HW GRANTED\n");
1394 * XXX: Fixme: Check hwstatus for duplicate when
1395 * true partial file locking and accounting is
1396 * done on the hardware.
1398 if (lnlstatus == NFS_GRANTED_DUPLICATE) {
1399 retval = PFL_GRANTED_DUPLICATE;
1401 retval = PFL_GRANTED;
1403 monitor_lock_host(fl->client_name);
1406 debuglog("HW RESERR\n");
1407 retval = PFL_HWRESERR;
1410 debuglog("HW DENIED\n");
1411 retval = PFL_HWDENIED;
1414 debuglog("Unmatched hwstatus %d\n",hwstatus);
1418 if (retval != PFL_GRANTED &&
1419 retval != PFL_GRANTED_DUPLICATE) {
1420 /* Clean up the NFS lock */
1421 debuglog("Deleting trial NFS lock\n");
1426 retval = PFL_NFSDENIED;
1429 retval = PFL_NFSRESERR;
1431 debuglog("Unmatched lnlstatus %d\n");
1432 retval = PFL_NFSDENIED_NOLOCK;
1437 * By the time fl reaches here, it is completely free again on
1438 * failure. The NFS lock done before attempting the
1439 * hardware lock has been backed out
1442 if (retval == PFL_NFSDENIED || retval == PFL_HWDENIED) {
1443 /* Once last chance to check the lock */
1444 if (fl->blocking == 1) {
1445 if (retval == PFL_NFSDENIED) {
1446 /* Queue the lock */
1447 debuglog("BLOCKING LOCK RECEIVED\n");
1448 retval = PFL_NFSBLOCKED;
1449 add_blockingfilelock(fl);
1452 /* retval is okay as PFL_HWDENIED */
1453 debuglog("BLOCKING LOCK DENIED IN HARDWARE\n");
1457 /* Leave retval alone, it's already correct */
1458 debuglog("Lock denied. Non-blocking failure\n");
1463 debuglog("Exiting lock_partialfilelock\n");
1469 * unlock_partialfilelock:
1471 * Given a file_lock, unlock all locks which match.
1473 * Note that a given lock might have to unlock ITSELF! See
1474 * clear_partialfilelock for example.
1477 enum partialfilelock_status
1478 unlock_partialfilelock(const struct file_lock *fl)
1480 struct file_lock *lfl,*rfl,*releasedfl,*selffl;
1481 enum partialfilelock_status retval;
1482 enum nfslock_status unlstatus;
1483 enum hwlock_status unlhwstatus, lhwstatus;
1485 debuglog("Entering unlock_partialfilelock\n");
1491 retval = PFL_DENIED;
1494 * There are significant overlap and atomicity issues
1495 * with partially releasing a lock. For example, releasing
1496 * part of an NFS shared lock does *not* always release the
1497 * corresponding part of the file since there is only one
1498 * rpc.lockd UID but multiple users could be requesting it
1499 * from NFS. Also, an unlock request should never allow
1500 * another process to gain a lock on the remaining parts.
1501 * ie. Always apply the new locks before releasing the
1506 * Loop is required since multiple little locks
1507 * can be allocated and then deallocated with one
1510 * The loop is required to be here so that the nfs &
1511 * hw subsystems do not need to communicate with one
1516 debuglog("Value of releasedfl: %p\n",releasedfl);
1517 /* lfl&rfl are created *AND* placed into the NFS lock list if required */
1518 unlstatus = unlock_nfslock(fl, &releasedfl, &lfl, &rfl);
1519 debuglog("Value of releasedfl: %p\n",releasedfl);
1522 /* XXX: This is grungy. It should be refactored to be cleaner */
1524 lhwstatus = lock_hwlock(lfl);
1525 if (lhwstatus != HW_GRANTED &&
1526 lhwstatus != HW_GRANTED_DUPLICATE) {
1527 debuglog("HW duplicate lock failure for left split\n");
1529 monitor_lock_host(lfl->client_name);
1533 lhwstatus = lock_hwlock(rfl);
1534 if (lhwstatus != HW_GRANTED &&
1535 lhwstatus != HW_GRANTED_DUPLICATE) {
1536 debuglog("HW duplicate lock failure for right split\n");
1538 monitor_lock_host(rfl->client_name);
1541 switch (unlstatus) {
1543 /* Attempt to unlock on the hardware */
1544 debuglog("NFS unlock granted. Attempting hardware unlock\n");
1546 /* This call *MUST NOT* unlock the two newly allocated locks */
1547 unlhwstatus = unlock_hwlock(fl);
1548 debuglog("HW unlock returned with code %d\n",unlhwstatus);
1550 switch (unlhwstatus) {
1552 debuglog("HW unlock granted\n");
1553 unmonitor_lock_host(releasedfl->client_name);
1554 retval = PFL_GRANTED;
1556 case HW_DENIED_NOLOCK:
1557 /* Huh?!?! This shouldn't happen */
1558 debuglog("HW unlock denied no lock\n");
1559 retval = PFL_HWRESERR;
1560 /* Break out of do-while */
1561 unlstatus = NFS_RESERR;
1564 debuglog("HW unlock failed\n");
1565 retval = PFL_HWRESERR;
1566 /* Break out of do-while */
1567 unlstatus = NFS_RESERR;
1571 debuglog("Exiting with status retval: %d\n",retval);
1573 retry_blockingfilelocklist();
1575 case NFS_DENIED_NOLOCK:
1576 retval = PFL_GRANTED;
1577 debuglog("All locks cleaned out\n");
1580 retval = PFL_NFSRESERR;
1581 debuglog("NFS unlock failure\n");
1586 if (releasedfl != NULL) {
1587 if (fl == releasedfl) {
1589 * XXX: YECHHH!!! Attempt to unlock self succeeded
1590 * but we can't deallocate the space yet. This is what
1591 * happens when you don't write malloc and free together
1593 debuglog("Attempt to unlock self\n");
1594 selffl = releasedfl;
1597 * XXX: this deallocation *still* needs to migrate closer
1598 * to the allocation code way up in get_lock or the allocation
1599 * code needs to migrate down (violation of "When you write
1600 * malloc you must write free")
1603 deallocate_file_lock(releasedfl);
1607 } while (unlstatus == NFS_GRANTED);
1609 if (selffl != NULL) {
1611 * This statement wipes out the incoming file lock (fl)
1612 * in spite of the fact that it is declared const
1614 debuglog("WARNING! Destroying incoming lock pointer\n");
1615 deallocate_file_lock(selffl);
1618 debuglog("Exiting unlock_partialfilelock\n");
1624 * clear_partialfilelock
1626 * Normally called in response to statd state number change.
1627 * Wipe out all locks held by a host. As a bonus, the act of
1628 * doing so should automatically clear their statd entries and
1629 * unmonitor the host.
1633 clear_partialfilelock(const char *hostname)
1635 struct file_lock *ifl, *nfl;
1637 /* Clear blocking file lock list */
1638 clear_blockingfilelock(hostname);
1640 /* do all required unlocks */
1641 /* Note that unlock can smash the current pointer to a lock */
1644 * Normally, LIST_FOREACH is called for, but since
1645 * the current element *is* the iterator, deleting it
1646 * would mess up the iteration. Thus, a next element
1647 * must be used explicitly
1650 ifl = LIST_FIRST(&nfslocklist_head);
1652 while (ifl != NULL) {
1653 nfl = LIST_NEXT(ifl, nfslocklist);
1655 if (strncmp(hostname, ifl->client_name, SM_MAXSTRLEN) == 0) {
1656 /* Unlock destroys ifl out from underneath */
1657 unlock_partialfilelock(ifl);
1658 /* ifl is NO LONGER VALID AT THIS POINT */
1665 * test_partialfilelock:
1667 enum partialfilelock_status
1668 test_partialfilelock(const struct file_lock *fl,
1669 struct file_lock **conflicting_fl)
1671 enum partialfilelock_status retval;
1672 enum nfslock_status teststatus;
1674 debuglog("Entering testpartialfilelock...\n");
1676 retval = PFL_DENIED;
1678 teststatus = test_nfslock(fl, conflicting_fl);
1679 debuglog("test_partialfilelock: teststatus %d\n",teststatus);
1681 if (teststatus == NFS_GRANTED || teststatus == NFS_GRANTED_DUPLICATE) {
1682 /* XXX: Add the underlying filesystem locking code */
1683 retval = (teststatus == NFS_GRANTED) ?
1684 PFL_GRANTED : PFL_GRANTED_DUPLICATE;
1685 debuglog("Dumping locks...\n");
1687 dump_filelock(*conflicting_fl);
1688 debuglog("Done dumping locks...\n");
1690 retval = PFL_NFSDENIED;
1691 debuglog("NFS test denied.\n");
1693 debuglog("Conflicting.\n");
1694 dump_filelock(*conflicting_fl);
1697 debuglog("Exiting testpartialfilelock...\n");
1703 * Below here are routines associated with translating the partial file locking
1704 * codes into useful codes to send back to the NFS RPC messaging system
1708 * These routines translate the (relatively) useful return codes back onto
1709 * the few return codes which the nlm subsystems wishes to trasmit
1713 do_test(struct file_lock *fl, struct file_lock **conflicting_fl)
1715 enum partialfilelock_status pfsret;
1716 enum nlm_stats retval;
1718 debuglog("Entering do_test...\n");
1720 pfsret = test_partialfilelock(fl,conflicting_fl);
1724 debuglog("PFL test lock granted\n");
1726 dump_filelock(*conflicting_fl);
1727 retval = (fl->flags & LOCK_V4) ? nlm4_granted : nlm_granted;
1729 case PFL_GRANTED_DUPLICATE:
1730 debuglog("PFL test lock granted--duplicate id detected\n");
1732 dump_filelock(*conflicting_fl);
1733 debuglog("Clearing conflicting_fl for call semantics\n");
1734 *conflicting_fl = NULL;
1735 retval = (fl->flags & LOCK_V4) ? nlm4_granted : nlm_granted;
1739 debuglog("PFL test lock denied\n");
1741 dump_filelock(*conflicting_fl);
1742 retval = (fl->flags & LOCK_V4) ? nlm4_denied : nlm_denied;
1746 debuglog("PFL test lock resource fail\n");
1748 dump_filelock(*conflicting_fl);
1749 retval = (fl->flags & LOCK_V4) ? nlm4_denied_nolocks : nlm_denied_nolocks;
1752 debuglog("PFL test lock *FAILED*\n");
1754 dump_filelock(*conflicting_fl);
1755 retval = (fl->flags & LOCK_V4) ? nlm4_failed : nlm_denied;
1759 debuglog("Exiting do_test...\n");
1765 * do_lock: Try to acquire a lock
1767 * This routine makes a distinction between NLM versions. I am pretty
1768 * convinced that this should be abstracted out and bounced up a level
1772 do_lock(struct file_lock *fl)
1774 enum partialfilelock_status pfsret;
1775 enum nlm_stats retval;
1777 debuglog("Entering do_lock...\n");
1779 pfsret = lock_partialfilelock(fl);
1783 debuglog("PFL lock granted");
1785 retval = (fl->flags & LOCK_V4) ? nlm4_granted : nlm_granted;
1787 case PFL_GRANTED_DUPLICATE:
1788 debuglog("PFL lock granted--duplicate id detected");
1790 retval = (fl->flags & LOCK_V4) ? nlm4_granted : nlm_granted;
1794 debuglog("PFL_NFS lock denied");
1796 retval = (fl->flags & LOCK_V4) ? nlm4_denied : nlm_denied;
1798 case PFL_NFSBLOCKED:
1800 debuglog("PFL_NFS blocking lock denied. Queued.\n");
1802 retval = (fl->flags & LOCK_V4) ? nlm4_blocked : nlm_blocked;
1806 debuglog("PFL lock resource alocation fail\n");
1808 retval = (fl->flags & LOCK_V4) ? nlm4_denied_nolocks : nlm_denied_nolocks;
1811 debuglog("PFL lock *FAILED*");
1813 retval = (fl->flags & LOCK_V4) ? nlm4_failed : nlm_denied;
1817 debuglog("Exiting do_lock...\n");
1823 do_unlock(struct file_lock *fl)
1825 enum partialfilelock_status pfsret;
1826 enum nlm_stats retval;
1828 debuglog("Entering do_unlock...\n");
1829 pfsret = unlock_partialfilelock(fl);
1833 debuglog("PFL unlock granted");
1835 retval = (fl->flags & LOCK_V4) ? nlm4_granted : nlm_granted;
1839 debuglog("PFL_NFS unlock denied");
1841 retval = (fl->flags & LOCK_V4) ? nlm4_denied : nlm_denied;
1843 case PFL_NFSDENIED_NOLOCK:
1844 case PFL_HWDENIED_NOLOCK:
1845 debuglog("PFL_NFS no lock found\n");
1846 retval = (fl->flags & LOCK_V4) ? nlm4_granted : nlm_granted;
1850 debuglog("PFL unlock resource failure");
1852 retval = (fl->flags & LOCK_V4) ? nlm4_denied_nolocks : nlm_denied_nolocks;
1855 debuglog("PFL unlock *FAILED*");
1857 retval = (fl->flags & LOCK_V4) ? nlm4_failed : nlm_denied;
1861 debuglog("Exiting do_unlock...\n");
1869 * This routine is non-existent because it doesn't have a return code.
1870 * It is here for completeness in case someone *does* need to do return
1871 * codes later. A decent compiler should optimize this away.
1875 do_clear(const char *hostname)
1878 clear_partialfilelock(hostname);
1882 * The following routines are all called from the code which the
1887 * testlock(): inform the caller if the requested lock would be granted
1889 * returns NULL if lock would granted
1890 * returns pointer to a conflicting nlm4_holder if not
1893 struct nlm4_holder *
1894 testlock(struct nlm4_lock *lock, bool_t exclusive, int flags __unused)
1896 struct file_lock test_fl, *conflicting_fl;
1898 bzero(&test_fl, sizeof(test_fl));
1900 bcopy(lock->fh.n_bytes, &(test_fl.filehandle), sizeof(fhandle_t));
1901 copy_nlm4_lock_to_nlm4_holder(lock, exclusive, &test_fl.client);
1904 do_test(&test_fl, &conflicting_fl);
1906 if (conflicting_fl == NULL) {
1907 debuglog("No conflicting lock found\n");
1911 debuglog("Found conflicting lock\n");
1912 dump_filelock(conflicting_fl);
1914 return (&conflicting_fl->client);
1919 * getlock: try to aquire the lock.
1920 * If file is already locked and we can sleep, put the lock in the list with
1921 * status LKST_WAITING; it'll be processed later.
1922 * Otherwise try to lock. If we're allowed to block, fork a child which
1923 * will do the blocking lock.
1927 getlock(nlm4_lockargs *lckarg, struct svc_req *rqstp, const int flags)
1929 struct file_lock *newfl;
1930 enum nlm_stats retval;
1932 debuglog("Entering getlock...\n");
1934 if (grace_expired == 0 && lckarg->reclaim == 0)
1935 return (flags & LOCK_V4) ?
1936 nlm4_denied_grace_period : nlm_denied_grace_period;
1938 /* allocate new file_lock for this request */
1939 newfl = allocate_file_lock(&lckarg->alock.oh, &lckarg->cookie,
1940 (struct sockaddr *)svc_getrpccaller(rqstp->rq_xprt)->buf, lckarg->alock.caller_name);
1941 if (newfl == NULL) {
1942 syslog(LOG_NOTICE, "lock allocate failed: %s", strerror(errno));
1944 return (flags & LOCK_V4) ?
1945 nlm4_denied_nolocks : nlm_denied_nolocks;
1948 if (lckarg->alock.fh.n_len != sizeof(fhandle_t)) {
1949 debuglog("recieved fhandle size %d, local size %d",
1950 lckarg->alock.fh.n_len, (int)sizeof(fhandle_t));
1953 fill_file_lock(newfl, (fhandle_t *)lckarg->alock.fh.n_bytes,
1954 lckarg->exclusive, lckarg->alock.svid, lckarg->alock.l_offset,
1955 lckarg->alock.l_len,
1956 lckarg->state, 0, flags, lckarg->block);
1959 * newfl is now fully constructed and deallocate_file_lock
1960 * can now be used to delete it
1964 debuglog("Pointer to new lock is %p\n",newfl);
1966 retval = do_lock(newfl);
1968 debuglog("Pointer to new lock is %p\n",newfl);
1974 /* case nlm_granted: is the same as nlm4_granted */
1975 /* do_mon(lckarg->alock.caller_name); */
1978 /* case nlm_blocked: is the same as nlm4_blocked */
1979 /* do_mon(lckarg->alock.caller_name); */
1982 deallocate_file_lock(newfl);
1986 debuglog("Exiting getlock...\n");
1992 /* unlock a filehandle */
1994 unlock(nlm4_lock *lock, const int flags __unused)
1996 struct file_lock fl;
2001 debuglog("Entering unlock...\n");
2003 bzero(&fl,sizeof(struct file_lock));
2004 bcopy(lock->fh.n_bytes, &fl.filehandle, sizeof(fhandle_t));
2006 copy_nlm4_lock_to_nlm4_holder(lock, 0, &fl.client);
2008 err = do_unlock(&fl);
2012 debuglog("Exiting unlock...\n");
2018 * XXX: The following monitor/unmonitor routines
2019 * have not been extensively tested (ie. no regression
2020 * script exists like for the locking sections
2024 * monitor_lock_host: monitor lock hosts locally with a ref count and
2028 monitor_lock_host(const char *hostname)
2030 struct host *ihp, *nhp;
2032 struct sm_stat_res sres;
2033 int rpcret, statflag;
2039 LIST_FOREACH(ihp, &hostlst_head, hostlst) {
2040 if (strncmp(hostname, ihp->name, SM_MAXSTRLEN) == 0) {
2041 /* Host is already monitored, bump refcount */
2043 /* Host should only be in the monitor list once */
2048 /* Host is not yet monitored, add it */
2049 n = strnlen(hostname, SM_MAXSTRLEN);
2050 if (n == SM_MAXSTRLEN) {
2053 nhp = malloc(sizeof(*nhp) - sizeof(nhp->name) + n + 1);
2055 debuglog("Unable to allocate entry for statd mon\n");
2059 /* Allocated new host entry, now fill the fields */
2060 memcpy(nhp->name, hostname, n);
2063 debuglog("Locally Monitoring host %16s\n",hostname);
2065 debuglog("Attempting to tell statd\n");
2067 bzero(&smon,sizeof(smon));
2069 smon.mon_id.mon_name = nhp->name;
2070 smon.mon_id.my_id.my_name = "localhost";
2071 smon.mon_id.my_id.my_prog = NLM_PROG;
2072 smon.mon_id.my_id.my_vers = NLM_SM;
2073 smon.mon_id.my_id.my_proc = NLM_SM_NOTIFY;
2075 rpcret = callrpc("localhost", SM_PROG, SM_VERS, SM_MON,
2076 (xdrproc_t)xdr_mon, &smon,
2077 (xdrproc_t)xdr_sm_stat_res, &sres);
2080 if (sres.res_stat == stat_fail) {
2081 debuglog("Statd call failed\n");
2087 debuglog("Rpc call to statd failed with return value: %d\n",
2092 if (statflag == 1) {
2093 LIST_INSERT_HEAD(&hostlst_head, nhp, hostlst);
2101 * unmonitor_lock_host: clear monitor ref counts and inform statd when gone
2104 unmonitor_lock_host(char *hostname)
2107 struct mon_id smon_id;
2108 struct sm_stat smstat;
2113 for( ihp=LIST_FIRST(&hostlst_head); ihp != NULL;
2114 ihp=LIST_NEXT(ihp, hostlst)) {
2115 if (strncmp(hostname, ihp->name, SM_MAXSTRLEN) == 0) {
2116 /* Host is monitored, bump refcount */
2118 /* Host should only be in the monitor list once */
2124 debuglog("Could not find host %16s in mon list\n", hostname);
2128 if (ihp->refcnt > 0)
2131 if (ihp->refcnt < 0) {
2132 debuglog("Negative refcount!: %d\n",
2136 debuglog("Attempting to unmonitor host %16s\n", hostname);
2138 bzero(&smon_id,sizeof(smon_id));
2140 smon_id.mon_name = hostname;
2141 smon_id.my_id.my_name = "localhost";
2142 smon_id.my_id.my_prog = NLM_PROG;
2143 smon_id.my_id.my_vers = NLM_SM;
2144 smon_id.my_id.my_proc = NLM_SM_NOTIFY;
2146 rpcret = callrpc("localhost", SM_PROG, SM_VERS, SM_UNMON,
2147 (xdrproc_t)xdr_mon_id, &smon_id,
2148 (xdrproc_t)xdr_sm_stat, &smstat);
2151 debuglog("Rpc call to unmonitor statd failed with "
2152 " return value: %d\n", rpcret);
2155 LIST_REMOVE(ihp, hostlst);
2160 * notify: Clear all locks from a host if statd complains
2162 * XXX: This routine has not been thoroughly tested. However, neither
2163 * had the old one been. It used to compare the statd crash state counter
2164 * to the current lock state. The upshot of this was that it basically
2165 * cleared all locks from the specified host 99% of the time (with the
2166 * other 1% being a bug). Consequently, the assumption is that clearing
2167 * all locks from a host when notified by statd is acceptable.
2169 * Please note that this routine skips the usual level of redirection
2170 * through a do_* type routine. This introduces a possible level of
2171 * error and might better be written as do_notify and take this one out.
2176 notify(const char *hostname, const int state)
2178 debuglog("notify from %s, new state %d", hostname, state);
2184 debuglog("Leaving notify\n");
2188 send_granted(fl, opcode)
2189 struct file_lock *fl;
2190 int opcode __unused;
2194 struct timeval timeo;
2196 static struct nlm_res retval;
2197 static struct nlm4_res retval4;
2199 debuglog("About to send granted on blocked lock\n");
2201 cli = get_client(fl->addr,
2202 (fl->flags & LOCK_V4) ? NLM_VERS4 : NLM_VERS);
2204 syslog(LOG_NOTICE, "failed to get CLIENT for %s",
2207 * We fail to notify remote that the lock has been granted.
2208 * The client will timeout and retry, the lock will be
2209 * granted at this time.
2214 timeo.tv_usec = (fl->flags & LOCK_ASYNC) ? 0 : 500000; /* 0.5s */
2216 if (fl->flags & LOCK_V4) {
2217 static nlm4_testargs res;
2218 res.cookie = fl->client_cookie;
2219 res.exclusive = fl->client.exclusive;
2220 res.alock.caller_name = fl->client_name;
2221 res.alock.fh.n_len = sizeof(fhandle_t);
2222 res.alock.fh.n_bytes = (char*)&fl->filehandle;
2223 res.alock.oh = fl->client.oh;
2224 res.alock.svid = fl->client.svid;
2225 res.alock.l_offset = fl->client.l_offset;
2226 res.alock.l_len = fl->client.l_len;
2227 debuglog("sending v4 reply%s",
2228 (fl->flags & LOCK_ASYNC) ? " (async)":"");
2229 if (fl->flags & LOCK_ASYNC) {
2230 success = clnt_call(cli, NLM4_GRANTED_MSG,
2231 (xdrproc_t)xdr_nlm4_testargs, &res,
2232 (xdrproc_t)xdr_void, &dummy, timeo);
2234 success = clnt_call(cli, NLM4_GRANTED,
2235 (xdrproc_t)xdr_nlm4_testargs, &res,
2236 (xdrproc_t)xdr_nlm4_res, &retval4, timeo);
2239 static nlm_testargs res;
2241 res.cookie = fl->client_cookie;
2242 res.exclusive = fl->client.exclusive;
2243 res.alock.caller_name = fl->client_name;
2244 res.alock.fh.n_len = sizeof(fhandle_t);
2245 res.alock.fh.n_bytes = (char*)&fl->filehandle;
2246 res.alock.oh = fl->client.oh;
2247 res.alock.svid = fl->client.svid;
2248 res.alock.l_offset = fl->client.l_offset;
2249 res.alock.l_len = fl->client.l_len;
2250 debuglog("sending v1 reply%s",
2251 (fl->flags & LOCK_ASYNC) ? " (async)":"");
2252 if (fl->flags & LOCK_ASYNC) {
2253 success = clnt_call(cli, NLM_GRANTED_MSG,
2254 (xdrproc_t)xdr_nlm_testargs, &res,
2255 (xdrproc_t)xdr_void, &dummy, timeo);
2257 success = clnt_call(cli, NLM_GRANTED,
2258 (xdrproc_t)xdr_nlm_testargs, &res,
2259 (xdrproc_t)xdr_nlm_res, &retval, timeo);
2262 if (debug_level > 2)
2263 debuglog("clnt_call returns %d(%s) for granted",
2264 success, clnt_sperrno(success));
2269 * Routines below here have not been modified in the overhaul
2273 * Are these two routines still required since lockd is not spawning off
2274 * children to service locks anymore? Presumably they were originally
2275 * put in place to prevent a one child from changing the lock list out
2276 * from under another one.
2284 sigemptyset(&block);
2285 sigaddset(&block, SIGCHLD);
2287 if (sigprocmask(SIG_BLOCK, &block, NULL) < 0) {
2288 syslog(LOG_WARNING, "siglock failed: %s", strerror(errno));
2297 sigemptyset(&block);
2298 sigaddset(&block, SIGCHLD);
2300 if (sigprocmask(SIG_UNBLOCK, &block, NULL) < 0) {
2301 syslog(LOG_WARNING, "sigunlock failed: %s", strerror(errno));