xref: /freebsd/usr.sbin/rpc.lockd/lockd_lock.c (revision 6472ac3d8a86336899b6cfb789a4cd9897e3fab5)
1 /*	$NetBSD: lockd_lock.c,v 1.5 2000/11/21 03:47:41 enami Exp $	*/
2 
3 /*
4  * Copyright (c) 2001 Andrew P. Lentvorski, Jr.
5  * Copyright (c) 2000 Manuel Bouyer.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
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.
22  *
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
33  * SUCH DAMAGE.
34  *
35  */
36 
37 #include <sys/cdefs.h>
38 __FBSDID("$FreeBSD$");
39 
40 #define LOCKD_DEBUG
41 
42 #include <stdio.h>
43 #ifdef LOCKD_DEBUG
44 #include <stdarg.h>
45 #endif
46 #include <stdlib.h>
47 #include <unistd.h>
48 #include <fcntl.h>
49 #include <syslog.h>
50 #include <errno.h>
51 #include <string.h>
52 #include <signal.h>
53 #include <rpc/rpc.h>
54 #include <sys/types.h>
55 #include <sys/stat.h>
56 #include <sys/socket.h>
57 #include <sys/param.h>
58 #include <sys/mount.h>
59 #include <sys/wait.h>
60 #include <rpcsvc/sm_inter.h>
61 #include <rpcsvc/nlm_prot.h>
62 #include "lockd_lock.h"
63 #include "lockd.h"
64 
65 #define MAXOBJECTSIZE 64
66 #define MAXBUFFERSIZE 1024
67 
68 /*
69  * A set of utilities for managing file locking
70  *
71  * XXX: All locks are in a linked list, a better structure should be used
72  * to improve search/access effeciency.
73  */
74 
75 /* struct describing a lock */
76 struct file_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! */
89 };
90 
91 LIST_HEAD(nfslocklist_head, file_lock);
92 struct nfslocklist_head nfslocklist_head = LIST_HEAD_INITIALIZER(nfslocklist_head);
93 
94 LIST_HEAD(blockedlocklist_head, file_lock);
95 struct blockedlocklist_head blockedlocklist_head = LIST_HEAD_INITIALIZER(blockedlocklist_head);
96 
97 /* lock status */
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 */
103 
104 /* struct describing a monitored host */
105 struct host {
106 	LIST_ENTRY(host) hostlst;
107 	int refcnt;
108 	char name[SM_MAXSTRLEN]; /* name is really variable length and
109                                     must be last! */
110 };
111 /* list of hosts we monitor */
112 LIST_HEAD(hostlst_head, host);
113 struct hostlst_head hostlst_head = LIST_HEAD_INITIALIZER(hostlst_head);
114 
115 /*
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)
120  */
121 
122 /* Struct describing a monitored file */
123 struct monfile {
124 	LIST_ENTRY(monfile) monfilelist;
125 	fhandle_t filehandle; /* Local access filehandle */
126 	int fd; /* file descriptor: remains open until unlock! */
127 	int refcount;
128 	int exclusive;
129 };
130 
131 /* List of files we monitor */
132 LIST_HEAD(monfilelist_head, monfile);
133 struct monfilelist_head monfilelist_head = LIST_HEAD_INITIALIZER(monfilelist_head);
134 
135 static int debugdelay = 0;
136 
137 enum nfslock_status { NFS_GRANTED = 0, NFS_GRANTED_DUPLICATE,
138 		      NFS_DENIED, NFS_DENIED_NOLOCK,
139 		      NFS_RESERR };
140 
141 enum hwlock_status { HW_GRANTED = 0, HW_GRANTED_DUPLICATE,
142 		     HW_DENIED, HW_DENIED_NOLOCK,
143 		     HW_STALEFH, HW_READONLY, HW_RESERR };
144 
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};
148 
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};
153 
154 enum partialfilelock_status lock_partialfilelock(struct file_lock *fl);
155 
156 void send_granted(struct file_lock *fl, int opcode);
157 void siglock(void);
158 void sigunlock(void);
159 void monitor_lock_host(const char *hostname);
160 void unmonitor_lock_host(char *hostname);
161 
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);
181 
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 int	duplicate_block(struct file_lock *fl);
201 void	add_blockingfilelock(struct file_lock *fl);
202 enum hwlock_status	unlock_hwlock(const struct file_lock *fl);
203 enum hwlock_status	test_hwlock(const struct file_lock *fl,
204     struct file_lock **conflicting_fl);
205 void	remove_blockingfilelock(struct file_lock *fl);
206 void	clear_blockingfilelock(const char *hostname);
207 void	retry_blockingfilelocklist(void);
208 enum partialfilelock_status	unlock_partialfilelock(
209     const struct file_lock *fl);
210 void	clear_partialfilelock(const char *hostname);
211 enum partialfilelock_status	test_partialfilelock(
212     const struct file_lock *fl, struct file_lock **conflicting_fl);
213 enum nlm_stats	do_test(struct file_lock *fl,
214     struct file_lock **conflicting_fl);
215 enum nlm_stats	do_unlock(struct file_lock *fl);
216 enum nlm_stats	do_lock(struct file_lock *fl);
217 void	do_clear(const char *hostname);
218 size_t	strnlen(const char *, size_t);
219 
220 void
221 debuglog(char const *fmt, ...)
222 {
223 	va_list ap;
224 
225 	if (debug_level < 1) {
226 		return;
227 	}
228 
229 	sleep(debugdelay);
230 
231 	va_start(ap, fmt);
232 	vsyslog(LOG_DEBUG, fmt, ap);
233 	va_end(ap);
234 }
235 
236 void
237 dump_static_object(object, size_object, hbuff, size_hbuff, cbuff, size_cbuff)
238 	const unsigned char *object;
239 	const int size_object;
240 	unsigned char *hbuff;
241 	const int size_hbuff;
242 	unsigned char *cbuff;
243 	const int size_cbuff;
244 {
245 	int i, objectsize;
246 
247 	if (debug_level < 2) {
248 		return;
249 	}
250 
251 	objectsize = size_object;
252 
253 	if (objectsize == 0) {
254 		debuglog("object is size 0\n");
255 	} else {
256 		if (objectsize > MAXOBJECTSIZE) {
257 			debuglog("Object of size %d being clamped"
258 			    "to size %d\n", objectsize, MAXOBJECTSIZE);
259 			objectsize = MAXOBJECTSIZE;
260 		}
261 
262 		if (hbuff != NULL) {
263 			if (size_hbuff < objectsize*2+1) {
264 				debuglog("Hbuff not large enough."
265 				    "  Increase size\n");
266 			} else {
267 				for(i=0;i<objectsize;i++) {
268 					sprintf(hbuff+i*2,"%02x",*(object+i));
269 				}
270 				*(hbuff+i*2) = '\0';
271 			}
272 		}
273 
274 		if (cbuff != NULL) {
275 			if (size_cbuff < objectsize+1) {
276 				debuglog("Cbuff not large enough."
277 				    "  Increase Size\n");
278 			}
279 
280 			for(i=0;i<objectsize;i++) {
281 				if (*(object+i) >= 32 && *(object+i) <= 127) {
282 					*(cbuff+i) = *(object+i);
283 				} else {
284 					*(cbuff+i) = '.';
285 				}
286 			}
287 			*(cbuff+i) = '\0';
288 		}
289 	}
290 }
291 
292 void
293 dump_netobj(const struct netobj *nobj)
294 {
295 	char hbuff[MAXBUFFERSIZE*2];
296 	char cbuff[MAXBUFFERSIZE];
297 
298 	if (debug_level < 2) {
299 		return;
300 	}
301 
302 	if (nobj == NULL) {
303 		debuglog("Null netobj pointer\n");
304 	}
305 	else if (nobj->n_len == 0) {
306 		debuglog("Size zero netobj\n");
307 	} else {
308 		dump_static_object(nobj->n_bytes, nobj->n_len,
309 		    hbuff, sizeof(hbuff), cbuff, sizeof(cbuff));
310 		debuglog("netobj: len: %d  data: %s :::  %s\n",
311 		    nobj->n_len, hbuff, cbuff);
312 	}
313 }
314 
315 /* #define DUMP_FILELOCK_VERBOSE */
316 void
317 dump_filelock(const struct file_lock *fl)
318 {
319 #ifdef DUMP_FILELOCK_VERBOSE
320 	char hbuff[MAXBUFFERSIZE*2];
321 	char cbuff[MAXBUFFERSIZE];
322 #endif
323 
324 	if (debug_level < 2) {
325 		return;
326 	}
327 
328 	if (fl != NULL) {
329 		debuglog("Dumping file lock structure @ %p\n", fl);
330 
331 #ifdef DUMP_FILELOCK_VERBOSE
332 		dump_static_object((unsigned char *)&fl->filehandle,
333 		    sizeof(fl->filehandle), hbuff, sizeof(hbuff),
334 		    cbuff, sizeof(cbuff));
335 		debuglog("Filehandle: %8s  :::  %8s\n", hbuff, cbuff);
336 #endif
337 
338 		debuglog("Dumping nlm4_holder:\n"
339 		    "exc: %x  svid: %x  offset:len %llx:%llx\n",
340 		    fl->client.exclusive, fl->client.svid,
341 		    fl->client.l_offset, fl->client.l_len);
342 
343 #ifdef DUMP_FILELOCK_VERBOSE
344 		debuglog("Dumping client identity:\n");
345 		dump_netobj(&fl->client.oh);
346 
347 		debuglog("Dumping client cookie:\n");
348 		dump_netobj(&fl->client_cookie);
349 
350 		debuglog("nsm: %d  status: %d  flags: %d  svid: %x"
351 		    "  client_name: %s\n", fl->nsm_status, fl->status,
352 		    fl->flags, fl->client.svid, fl->client_name);
353 #endif
354 	} else {
355 		debuglog("NULL file lock structure\n");
356 	}
357 }
358 
359 void
360 copy_nlm4_lock_to_nlm4_holder(src, exclusive, dest)
361 	const struct nlm4_lock *src;
362 	const bool_t exclusive;
363 	struct nlm4_holder *dest;
364 {
365 
366 	dest->exclusive = exclusive;
367 	dest->oh.n_len = src->oh.n_len;
368 	dest->oh.n_bytes = src->oh.n_bytes;
369 	dest->svid = src->svid;
370 	dest->l_offset = src->l_offset;
371 	dest->l_len = src->l_len;
372 }
373 
374 
375 size_t
376 strnlen(const char *s, size_t len)
377 {
378     size_t n;
379 
380     for (n = 0;  s[n] != 0 && n < len; n++)
381         ;
382     return n;
383 }
384 
385 /*
386  * allocate_file_lock: Create a lock with the given parameters
387  */
388 
389 struct file_lock *
390 allocate_file_lock(const netobj *lockowner, const netobj *matchcookie,
391 		   const struct sockaddr *addr, const char *caller_name)
392 {
393 	struct file_lock *newfl;
394 	size_t n;
395 
396 	/* Beware of rubbish input! */
397 	n = strnlen(caller_name, SM_MAXSTRLEN);
398 	if (n == SM_MAXSTRLEN) {
399 		return NULL;
400 	}
401 
402 	newfl = malloc(sizeof(*newfl) - sizeof(newfl->client_name) + n + 1);
403 	if (newfl == NULL) {
404 		return NULL;
405 	}
406 	bzero(newfl, sizeof(*newfl) - sizeof(newfl->client_name));
407 	memcpy(newfl->client_name, caller_name, n);
408 	newfl->client_name[n] = 0;
409 
410 	newfl->client.oh.n_bytes = malloc(lockowner->n_len);
411 	if (newfl->client.oh.n_bytes == NULL) {
412 		free(newfl);
413 		return NULL;
414 	}
415 	newfl->client.oh.n_len = lockowner->n_len;
416 	bcopy(lockowner->n_bytes, newfl->client.oh.n_bytes, lockowner->n_len);
417 
418 	newfl->client_cookie.n_bytes = malloc(matchcookie->n_len);
419 	if (newfl->client_cookie.n_bytes == NULL) {
420 		free(newfl->client.oh.n_bytes);
421 		free(newfl);
422 		return NULL;
423 	}
424 	newfl->client_cookie.n_len = matchcookie->n_len;
425 	bcopy(matchcookie->n_bytes, newfl->client_cookie.n_bytes, matchcookie->n_len);
426 
427 	newfl->addr = malloc(addr->sa_len);
428 	if (newfl->addr == NULL) {
429 		free(newfl->client_cookie.n_bytes);
430 		free(newfl->client.oh.n_bytes);
431 		free(newfl);
432 		return NULL;
433 	}
434 	memcpy(newfl->addr, addr, addr->sa_len);
435 
436 	return newfl;
437 }
438 
439 /*
440  * file_file_lock: Force creation of a valid file lock
441  */
442 void
443 fill_file_lock(struct file_lock *fl, const fhandle_t *fh,
444     const bool_t exclusive, const int32_t svid,
445     const u_int64_t offset, const u_int64_t len,
446     const int state, const int status, const int flags, const int blocking)
447 {
448 	bcopy(fh, &fl->filehandle, sizeof(fhandle_t));
449 
450 	fl->client.exclusive = exclusive;
451 	fl->client.svid = svid;
452 	fl->client.l_offset = offset;
453 	fl->client.l_len = len;
454 
455 	fl->nsm_status = state;
456 	fl->status = status;
457 	fl->flags = flags;
458 	fl->blocking = blocking;
459 }
460 
461 /*
462  * deallocate_file_lock: Free all storage associated with a file lock
463  */
464 void
465 deallocate_file_lock(struct file_lock *fl)
466 {
467 	free(fl->addr);
468 	free(fl->client.oh.n_bytes);
469 	free(fl->client_cookie.n_bytes);
470 	free(fl);
471 }
472 
473 /*
474  * regions_overlap(): This function examines the two provided regions for
475  * overlap.
476  */
477 int
478 regions_overlap(start1, len1, start2, len2)
479 	const u_int64_t start1, len1, start2, len2;
480 {
481 	u_int64_t d1,d2,d3,d4;
482 	enum split_status result;
483 
484 	debuglog("Entering region overlap with vals: %llu:%llu--%llu:%llu\n",
485 		 start1, len1, start2, len2);
486 
487 	result = region_compare(start1, len1, start2, len2,
488 	    &d1, &d2, &d3, &d4);
489 
490 	debuglog("Exiting region overlap with val: %d\n",result);
491 
492 	if (result == SPL_DISJOINT) {
493 		return 0;
494 	} else {
495 		return 1;
496 	}
497 
498 	return (result);
499 }
500 
501 /*
502  * region_compare(): Examine lock regions and split appropriately
503  *
504  * XXX: Fix 64 bit overflow problems
505  * XXX: Check to make sure I got *ALL* the cases.
506  * XXX: This DESPERATELY needs a regression test.
507  */
508 enum split_status
509 region_compare(starte, lene, startu, lenu,
510     start1, len1, start2, len2)
511 	const u_int64_t starte, lene, startu, lenu;
512 	u_int64_t *start1, *len1, *start2, *len2;
513 {
514 	/*
515 	 * Please pay attention to the sequential exclusions
516 	 * of the if statements!!!
517 	 */
518 	enum LFLAGS lflags;
519 	enum RFLAGS rflags;
520 	enum split_status retval;
521 
522 	retval = SPL_DISJOINT;
523 
524 	if (lene == 0 && lenu == 0) {
525 		/* Examine left edge of locker */
526 		lflags = LEDGE_INSIDE;
527 		if (startu < starte) {
528 			lflags = LEDGE_LEFT;
529 		} else if (startu == starte) {
530 			lflags = LEDGE_LBOUNDARY;
531 		}
532 
533 		rflags = REDGE_RBOUNDARY; /* Both are infiinite */
534 
535 		if (lflags == LEDGE_INSIDE) {
536 			*start1 = starte;
537 			*len1 = startu - starte;
538 		}
539 
540 		if (lflags == LEDGE_LEFT || lflags == LEDGE_LBOUNDARY) {
541 			retval = SPL_CONTAINED;
542 		} else {
543 			retval = SPL_LOCK1;
544 		}
545 	} else if (lene == 0 && lenu != 0) {
546 		/* Established lock is infinite */
547 		/* Examine left edge of unlocker */
548 		lflags = LEDGE_INSIDE;
549 		if (startu < starte) {
550 			lflags = LEDGE_LEFT;
551 		} else if (startu == starte) {
552 			lflags = LEDGE_LBOUNDARY;
553 		}
554 
555 		/* Examine right edge of unlocker */
556 		if (startu + lenu < starte) {
557 			/* Right edge of unlocker left of established lock */
558 			rflags = REDGE_LEFT;
559 			return SPL_DISJOINT;
560 		} else if (startu + lenu == starte) {
561 			/* Right edge of unlocker on start of established lock */
562 			rflags = REDGE_LBOUNDARY;
563 			return SPL_DISJOINT;
564 		} else { /* Infinifty is right of finity */
565 			/* Right edge of unlocker inside established lock */
566 			rflags = REDGE_INSIDE;
567 		}
568 
569 		if (lflags == LEDGE_INSIDE) {
570 			*start1 = starte;
571 			*len1 = startu - starte;
572 			retval |= SPL_LOCK1;
573 		}
574 
575 		if (rflags == REDGE_INSIDE) {
576 			/* Create right lock */
577 			*start2 = startu+lenu;
578 			*len2 = 0;
579 			retval |= SPL_LOCK2;
580 		}
581 	} else if (lene != 0 && lenu == 0) {
582 		/* Unlocker is infinite */
583 		/* Examine left edge of unlocker */
584 		lflags = LEDGE_RIGHT;
585 		if (startu < starte) {
586 			lflags = LEDGE_LEFT;
587 			retval = SPL_CONTAINED;
588 			return retval;
589 		} else if (startu == starte) {
590 			lflags = LEDGE_LBOUNDARY;
591 			retval = SPL_CONTAINED;
592 			return retval;
593 		} else if ((startu > starte) && (startu < starte + lene - 1)) {
594 			lflags = LEDGE_INSIDE;
595 		} else if (startu == starte + lene - 1) {
596 			lflags = LEDGE_RBOUNDARY;
597 		} else { /* startu > starte + lene -1 */
598 			lflags = LEDGE_RIGHT;
599 			return SPL_DISJOINT;
600 		}
601 
602 		rflags = REDGE_RIGHT; /* Infinity is right of finity */
603 
604 		if (lflags == LEDGE_INSIDE || lflags == LEDGE_RBOUNDARY) {
605 			*start1 = starte;
606 			*len1 = startu - starte;
607 			retval |= SPL_LOCK1;
608 			return retval;
609 		}
610 	} else {
611 		/* Both locks are finite */
612 
613 		/* Examine left edge of unlocker */
614 		lflags = LEDGE_RIGHT;
615 		if (startu < starte) {
616 			lflags = LEDGE_LEFT;
617 		} else if (startu == starte) {
618 			lflags = LEDGE_LBOUNDARY;
619 		} else if ((startu > starte) && (startu < starte + lene - 1)) {
620 			lflags = LEDGE_INSIDE;
621 		} else if (startu == starte + lene - 1) {
622 			lflags = LEDGE_RBOUNDARY;
623 		} else { /* startu > starte + lene -1 */
624 			lflags = LEDGE_RIGHT;
625 			return SPL_DISJOINT;
626 		}
627 
628 		/* Examine right edge of unlocker */
629 		if (startu + lenu < starte) {
630 			/* Right edge of unlocker left of established lock */
631 			rflags = REDGE_LEFT;
632 			return SPL_DISJOINT;
633 		} else if (startu + lenu == starte) {
634 			/* Right edge of unlocker on start of established lock */
635 			rflags = REDGE_LBOUNDARY;
636 			return SPL_DISJOINT;
637 		} else if (startu + lenu < starte + lene) {
638 			/* Right edge of unlocker inside established lock */
639 			rflags = REDGE_INSIDE;
640 		} else if (startu + lenu == starte + lene) {
641 			/* Right edge of unlocker on right edge of established lock */
642 			rflags = REDGE_RBOUNDARY;
643 		} else { /* startu + lenu > starte + lene */
644 			/* Right edge of unlocker is right of established lock */
645 			rflags = REDGE_RIGHT;
646 		}
647 
648 		if (lflags == LEDGE_INSIDE || lflags == LEDGE_RBOUNDARY) {
649 			/* Create left lock */
650 			*start1 = starte;
651 			*len1 = (startu - starte);
652 			retval |= SPL_LOCK1;
653 		}
654 
655 		if (rflags == REDGE_INSIDE) {
656 			/* Create right lock */
657 			*start2 = startu+lenu;
658 			*len2 = starte+lene-(startu+lenu);
659 			retval |= SPL_LOCK2;
660 		}
661 
662 		if ((lflags == LEDGE_LEFT || lflags == LEDGE_LBOUNDARY) &&
663 		    (rflags == REDGE_RBOUNDARY || rflags == REDGE_RIGHT)) {
664 			retval = SPL_CONTAINED;
665 		}
666 	}
667 	return retval;
668 }
669 
670 /*
671  * same_netobj: Compares the apprpriate bits of a netobj for identity
672  */
673 int
674 same_netobj(const netobj *n0, const netobj *n1)
675 {
676 	int retval;
677 
678 	retval = 0;
679 
680 	debuglog("Entering netobj identity check\n");
681 
682 	if (n0->n_len == n1->n_len) {
683 		debuglog("Preliminary length check passed\n");
684 		retval = !bcmp(n0->n_bytes, n1->n_bytes, n0->n_len);
685 		debuglog("netobj %smatch\n", retval ? "" : "mis");
686 	}
687 
688 	return (retval);
689 }
690 
691 /*
692  * same_filelock_identity: Compares the appropriate bits of a file_lock
693  */
694 int
695 same_filelock_identity(fl0, fl1)
696 	const struct file_lock *fl0, *fl1;
697 {
698 	int retval;
699 
700 	retval = 0;
701 
702 	debuglog("Checking filelock identity\n");
703 
704 	/*
705 	 * Check process ids and host information.
706 	 */
707 	retval = (fl0->client.svid == fl1->client.svid &&
708 	    same_netobj(&(fl0->client.oh), &(fl1->client.oh)));
709 
710 	debuglog("Exiting checking filelock identity: retval: %d\n",retval);
711 
712 	return (retval);
713 }
714 
715 /*
716  * Below here are routines associated with manipulating the NFS
717  * lock list.
718  */
719 
720 /*
721  * get_lock_matching_unlock: Return a lock which matches the given unlock lock
722  *                           or NULL otehrwise
723  * XXX: It is a shame that this duplicates so much code from test_nfslock.
724  */
725 struct file_lock *
726 get_lock_matching_unlock(const struct file_lock *fl)
727 {
728 	struct file_lock *ifl; /* Iterator */
729 
730 	debuglog("Entering get_lock_matching_unlock\n");
731 	debuglog("********Dump of fl*****************\n");
732 	dump_filelock(fl);
733 
734 	LIST_FOREACH(ifl, &nfslocklist_head, nfslocklist) {
735 		debuglog("Pointer to file lock: %p\n",ifl);
736 
737 		debuglog("****Dump of ifl****\n");
738 		dump_filelock(ifl);
739 		debuglog("*******************\n");
740 
741 		/*
742 		 * XXX: It is conceivable that someone could use the NLM RPC
743 		 * system to directly access filehandles.  This may be a
744 		 * security hazard as the filehandle code may bypass normal
745 		 * file access controls
746 		 */
747 		if (bcmp(&fl->filehandle, &ifl->filehandle, sizeof(fhandle_t)))
748 			continue;
749 
750 		debuglog("get_lock_matching_unlock: Filehandles match, "
751 		    "checking regions\n");
752 
753 		/* Filehandles match, check for region overlap */
754 		if (!regions_overlap(fl->client.l_offset, fl->client.l_len,
755 			ifl->client.l_offset, ifl->client.l_len))
756 			continue;
757 
758 		debuglog("get_lock_matching_unlock: Region overlap"
759 		    " found %llu : %llu -- %llu : %llu\n",
760 		    fl->client.l_offset,fl->client.l_len,
761 		    ifl->client.l_offset,ifl->client.l_len);
762 
763 		/* Regions overlap, check the identity */
764 		if (!same_filelock_identity(fl,ifl))
765 			continue;
766 
767 		debuglog("get_lock_matching_unlock: Duplicate lock id.  Granting\n");
768 		return (ifl);
769 	}
770 
771 	debuglog("Exiting bet_lock_matching_unlock\n");
772 
773 	return (NULL);
774 }
775 
776 /*
777  * test_nfslock: check for NFS lock in lock list
778  *
779  * This routine makes the following assumptions:
780  *    1) Nothing will adjust the lock list during a lookup
781  *
782  * This routine has an intersting quirk which bit me hard.
783  * The conflicting_fl is the pointer to the conflicting lock.
784  * However, to modify the "*pointer* to the conflicting lock" rather
785  * that the "conflicting lock itself" one must pass in a "pointer to
786  * the pointer of the conflicting lock".  Gross.
787  */
788 
789 enum nfslock_status
790 test_nfslock(const struct file_lock *fl, struct file_lock **conflicting_fl)
791 {
792 	struct file_lock *ifl; /* Iterator */
793 	enum nfslock_status retval;
794 
795 	debuglog("Entering test_nfslock\n");
796 
797 	retval = NFS_GRANTED;
798 	(*conflicting_fl) = NULL;
799 
800 	debuglog("Entering lock search loop\n");
801 
802 	debuglog("***********************************\n");
803 	debuglog("Dumping match filelock\n");
804 	debuglog("***********************************\n");
805 	dump_filelock(fl);
806 	debuglog("***********************************\n");
807 
808 	LIST_FOREACH(ifl, &nfslocklist_head, nfslocklist) {
809 		if (retval == NFS_DENIED)
810 			break;
811 
812 		debuglog("Top of lock loop\n");
813 		debuglog("Pointer to file lock: %p\n",ifl);
814 
815 		debuglog("***********************************\n");
816 		debuglog("Dumping test filelock\n");
817 		debuglog("***********************************\n");
818 		dump_filelock(ifl);
819 		debuglog("***********************************\n");
820 
821 		/*
822 		 * XXX: It is conceivable that someone could use the NLM RPC
823 		 * system to directly access filehandles.  This may be a
824 		 * security hazard as the filehandle code may bypass normal
825 		 * file access controls
826 		 */
827 		if (bcmp(&fl->filehandle, &ifl->filehandle, sizeof(fhandle_t)))
828 			continue;
829 
830 		debuglog("test_nfslock: filehandle match found\n");
831 
832 		/* Filehandles match, check for region overlap */
833 		if (!regions_overlap(fl->client.l_offset, fl->client.l_len,
834 			ifl->client.l_offset, ifl->client.l_len))
835 			continue;
836 
837 		debuglog("test_nfslock: Region overlap found"
838 		    " %llu : %llu -- %llu : %llu\n",
839 		    fl->client.l_offset,fl->client.l_len,
840 		    ifl->client.l_offset,ifl->client.l_len);
841 
842 		/* Regions overlap, check the exclusivity */
843 		if (!(fl->client.exclusive || ifl->client.exclusive))
844 			continue;
845 
846 		debuglog("test_nfslock: Exclusivity failure: %d %d\n",
847 		    fl->client.exclusive,
848 		    ifl->client.exclusive);
849 
850 		if (same_filelock_identity(fl,ifl)) {
851 			debuglog("test_nfslock: Duplicate id.  Granting\n");
852 			(*conflicting_fl) = ifl;
853 			retval = NFS_GRANTED_DUPLICATE;
854 		} else {
855 			/* locking attempt fails */
856 			debuglog("test_nfslock: Lock attempt failed\n");
857 			debuglog("Desired lock\n");
858 			dump_filelock(fl);
859 			debuglog("Conflicting lock\n");
860 			dump_filelock(ifl);
861 			(*conflicting_fl) = ifl;
862 			retval = NFS_DENIED;
863 		}
864 	}
865 
866 	debuglog("Dumping file locks\n");
867 	debuglog("Exiting test_nfslock\n");
868 
869 	return (retval);
870 }
871 
872 /*
873  * lock_nfslock: attempt to create a lock in the NFS lock list
874  *
875  * This routine tests whether the lock will be granted and then adds
876  * the entry to the lock list if so.
877  *
878  * Argument fl gets modified as its list housekeeping entries get modified
879  * upon insertion into the NFS lock list
880  *
881  * This routine makes several assumptions:
882  *    1) It is perfectly happy to grant a duplicate lock from the same pid.
883  *       While this seems to be intuitively wrong, it is required for proper
884  *       Posix semantics during unlock.  It is absolutely imperative to not
885  *       unlock the main lock before the two child locks are established. Thus,
886  *       one has be be able to create duplicate locks over an existing lock
887  *    2) It currently accepts duplicate locks from the same id,pid
888  */
889 
890 enum nfslock_status
891 lock_nfslock(struct file_lock *fl)
892 {
893 	enum nfslock_status retval;
894 	struct file_lock *dummy_fl;
895 
896 	dummy_fl = NULL;
897 
898 	debuglog("Entering lock_nfslock...\n");
899 
900 	retval = test_nfslock(fl,&dummy_fl);
901 
902 	if (retval == NFS_GRANTED || retval == NFS_GRANTED_DUPLICATE) {
903 		debuglog("Inserting lock...\n");
904 		dump_filelock(fl);
905 		LIST_INSERT_HEAD(&nfslocklist_head, fl, nfslocklist);
906 	}
907 
908 	debuglog("Exiting lock_nfslock...\n");
909 
910 	return (retval);
911 }
912 
913 /*
914  * delete_nfslock: delete an NFS lock list entry
915  *
916  * This routine is used to delete a lock out of the NFS lock list
917  * without regard to status, underlying locks, regions or anything else
918  *
919  * Note that this routine *does not deallocate memory* of the lock.
920  * It just disconnects it from the list.  The lock can then be used
921  * by other routines without fear of trashing the list.
922  */
923 
924 enum nfslock_status
925 delete_nfslock(struct file_lock *fl)
926 {
927 
928 	LIST_REMOVE(fl, nfslocklist);
929 
930 	return (NFS_GRANTED);
931 }
932 
933 enum split_status
934 split_nfslock(exist_lock, unlock_lock, left_lock, right_lock)
935 	const struct file_lock *exist_lock, *unlock_lock;
936 	struct file_lock **left_lock, **right_lock;
937 {
938 	u_int64_t start1, len1, start2, len2;
939 	enum split_status spstatus;
940 
941 	spstatus = region_compare(exist_lock->client.l_offset, exist_lock->client.l_len,
942 	    unlock_lock->client.l_offset, unlock_lock->client.l_len,
943 	    &start1, &len1, &start2, &len2);
944 
945 	if ((spstatus & SPL_LOCK1) != 0) {
946 		*left_lock = allocate_file_lock(&exist_lock->client.oh, &exist_lock->client_cookie, exist_lock->addr, exist_lock->client_name);
947 		if (*left_lock == NULL) {
948 			debuglog("Unable to allocate resource for split 1\n");
949 			return SPL_RESERR;
950 		}
951 
952 		fill_file_lock(*left_lock, &exist_lock->filehandle,
953 		    exist_lock->client.exclusive, exist_lock->client.svid,
954 		    start1, len1,
955 		    exist_lock->nsm_status,
956 		    exist_lock->status, exist_lock->flags, exist_lock->blocking);
957 	}
958 
959 	if ((spstatus & SPL_LOCK2) != 0) {
960 		*right_lock = allocate_file_lock(&exist_lock->client.oh, &exist_lock->client_cookie, exist_lock->addr, exist_lock->client_name);
961 		if (*right_lock == NULL) {
962 			debuglog("Unable to allocate resource for split 1\n");
963 			if (*left_lock != NULL) {
964 				deallocate_file_lock(*left_lock);
965 			}
966 			return SPL_RESERR;
967 		}
968 
969 		fill_file_lock(*right_lock, &exist_lock->filehandle,
970 		    exist_lock->client.exclusive, exist_lock->client.svid,
971 		    start2, len2,
972 		    exist_lock->nsm_status,
973 		    exist_lock->status, exist_lock->flags, exist_lock->blocking);
974 	}
975 
976 	return spstatus;
977 }
978 
979 enum nfslock_status
980 unlock_nfslock(fl, released_lock, left_lock, right_lock)
981 	const struct file_lock *fl;
982 	struct file_lock **released_lock;
983 	struct file_lock **left_lock;
984 	struct file_lock **right_lock;
985 {
986 	struct file_lock *mfl; /* Matching file lock */
987 	enum nfslock_status retval;
988 	enum split_status spstatus;
989 
990 	debuglog("Entering unlock_nfslock\n");
991 
992 	*released_lock = NULL;
993 	*left_lock = NULL;
994 	*right_lock = NULL;
995 
996 	retval = NFS_DENIED_NOLOCK;
997 
998 	debuglog("Attempting to match lock...\n");
999 	mfl = get_lock_matching_unlock(fl);
1000 
1001 	if (mfl != NULL) {
1002 		debuglog("Unlock matched.  Querying for split\n");
1003 
1004 		spstatus = split_nfslock(mfl, fl, left_lock, right_lock);
1005 
1006 		debuglog("Split returned %d %p %p %p %p\n",spstatus,mfl,fl,*left_lock,*right_lock);
1007 		debuglog("********Split dumps********");
1008 		dump_filelock(mfl);
1009 		dump_filelock(fl);
1010 		dump_filelock(*left_lock);
1011 		dump_filelock(*right_lock);
1012 		debuglog("********End Split dumps********");
1013 
1014 		if (spstatus == SPL_RESERR) {
1015 			if (*left_lock != NULL) {
1016 				deallocate_file_lock(*left_lock);
1017 				*left_lock = NULL;
1018 			}
1019 
1020 			if (*right_lock != NULL) {
1021 				deallocate_file_lock(*right_lock);
1022 				*right_lock = NULL;
1023 			}
1024 
1025 			return NFS_RESERR;
1026 		}
1027 
1028 		/* Insert new locks from split if required */
1029 		if (*left_lock != NULL) {
1030 			debuglog("Split left activated\n");
1031 			LIST_INSERT_HEAD(&nfslocklist_head, *left_lock, nfslocklist);
1032 		}
1033 
1034 		if (*right_lock != NULL) {
1035 			debuglog("Split right activated\n");
1036 			LIST_INSERT_HEAD(&nfslocklist_head, *right_lock, nfslocklist);
1037 		}
1038 
1039 		/* Unlock the lock since it matches identity */
1040 		LIST_REMOVE(mfl, nfslocklist);
1041 		*released_lock = mfl;
1042 		retval = NFS_GRANTED;
1043 	}
1044 
1045 	debuglog("Exiting unlock_nfslock\n");
1046 
1047 	return retval;
1048 }
1049 
1050 /*
1051  * Below here are the routines for manipulating the file lock directly
1052  * on the disk hardware itself
1053  */
1054 enum hwlock_status
1055 lock_hwlock(struct file_lock *fl)
1056 {
1057 	struct monfile *imf,*nmf;
1058 	int lflags, flerror;
1059 
1060 	/* Scan to see if filehandle already present */
1061 	LIST_FOREACH(imf, &monfilelist_head, monfilelist) {
1062 		if (bcmp(&fl->filehandle, &imf->filehandle,
1063 			sizeof(fl->filehandle)) == 0) {
1064 			/* imf is the correct filehandle */
1065 			break;
1066 		}
1067 	}
1068 
1069 	/*
1070 	 * Filehandle already exists (we control the file)
1071 	 * *AND* NFS has already cleared the lock for availability
1072 	 * Grant it and bump the refcount.
1073 	 */
1074 	if (imf != NULL) {
1075 		++(imf->refcount);
1076 		return (HW_GRANTED);
1077 	}
1078 
1079 	/* No filehandle found, create and go */
1080 	nmf = malloc(sizeof(struct monfile));
1081 	if (nmf == NULL) {
1082 		debuglog("hwlock resource allocation failure\n");
1083 		return (HW_RESERR);
1084 	}
1085 
1086 	/* XXX: Is O_RDWR always the correct mode? */
1087 	nmf->fd = fhopen(&fl->filehandle, O_RDWR);
1088 	if (nmf->fd < 0) {
1089 		debuglog("fhopen failed (from %16s): %32s\n",
1090 		    fl->client_name, strerror(errno));
1091 		free(nmf);
1092 		switch (errno) {
1093 		case ESTALE:
1094 			return (HW_STALEFH);
1095 		case EROFS:
1096 			return (HW_READONLY);
1097 		default:
1098 			return (HW_RESERR);
1099 		}
1100 	}
1101 
1102 	/* File opened correctly, fill the monitor struct */
1103 	bcopy(&fl->filehandle, &nmf->filehandle, sizeof(fl->filehandle));
1104 	nmf->refcount = 1;
1105 	nmf->exclusive = fl->client.exclusive;
1106 
1107 	lflags = (nmf->exclusive == 1) ?
1108 	    (LOCK_EX | LOCK_NB) : (LOCK_SH | LOCK_NB);
1109 
1110 	flerror = flock(nmf->fd, lflags);
1111 
1112 	if (flerror != 0) {
1113 		debuglog("flock failed (from %16s): %32s\n",
1114 		    fl->client_name, strerror(errno));
1115 		close(nmf->fd);
1116 		free(nmf);
1117 		switch (errno) {
1118 		case EAGAIN:
1119 			return (HW_DENIED);
1120 		case ESTALE:
1121 			return (HW_STALEFH);
1122 		case EROFS:
1123 			return (HW_READONLY);
1124 		default:
1125 			return (HW_RESERR);
1126 			break;
1127 		}
1128 	}
1129 
1130 	/* File opened and locked */
1131 	LIST_INSERT_HEAD(&monfilelist_head, nmf, monfilelist);
1132 
1133 	debuglog("flock succeeded (from %16s)\n", fl->client_name);
1134 	return (HW_GRANTED);
1135 }
1136 
1137 enum hwlock_status
1138 unlock_hwlock(const struct file_lock *fl)
1139 {
1140 	struct monfile *imf;
1141 
1142 	debuglog("Entering unlock_hwlock\n");
1143 	debuglog("Entering loop interation\n");
1144 
1145 	/* Scan to see if filehandle already present */
1146 	LIST_FOREACH(imf, &monfilelist_head, monfilelist) {
1147 		if (bcmp(&fl->filehandle, &imf->filehandle,
1148 			sizeof(fl->filehandle)) == 0) {
1149 			/* imf is the correct filehandle */
1150 			break;
1151 		}
1152 	}
1153 
1154 	debuglog("Completed iteration.  Proceeding\n");
1155 
1156 	if (imf == NULL) {
1157 		/* No lock found */
1158 		debuglog("Exiting unlock_hwlock (HW_DENIED_NOLOCK)\n");
1159 		return (HW_DENIED_NOLOCK);
1160 	}
1161 
1162 	/* Lock found */
1163 	--imf->refcount;
1164 
1165 	if (imf->refcount < 0) {
1166 		debuglog("Negative hardware reference count\n");
1167 	}
1168 
1169 	if (imf->refcount <= 0) {
1170 		close(imf->fd);
1171 		LIST_REMOVE(imf, monfilelist);
1172 		free(imf);
1173 	}
1174 	debuglog("Exiting unlock_hwlock (HW_GRANTED)\n");
1175 	return (HW_GRANTED);
1176 }
1177 
1178 enum hwlock_status
1179 test_hwlock(fl, conflicting_fl)
1180 	const struct file_lock *fl __unused;
1181 	struct file_lock **conflicting_fl __unused;
1182 {
1183 
1184 	/*
1185 	 * XXX: lock tests on hardware are not required until
1186 	 * true partial file testing is done on the underlying file
1187 	 */
1188 	return (HW_RESERR);
1189 }
1190 
1191 
1192 
1193 /*
1194  * Below here are routines for manipulating blocked lock requests
1195  * They should only be called from the XXX_partialfilelock routines
1196  * if at all possible
1197  */
1198 
1199 int
1200 duplicate_block(struct file_lock *fl)
1201 {
1202 	struct file_lock *ifl;
1203 	int retval = 0;
1204 
1205 	debuglog("Entering duplicate_block");
1206 
1207 	/*
1208 	 * Is this lock request already on the blocking list?
1209 	 * Consider it a dupe if the file handles, offset, length,
1210 	 * exclusivity and client match.
1211 	 */
1212 	LIST_FOREACH(ifl, &blockedlocklist_head, nfslocklist) {
1213 		if (!bcmp(&fl->filehandle, &ifl->filehandle,
1214 			sizeof(fhandle_t)) &&
1215 		    fl->client.exclusive == ifl->client.exclusive &&
1216 		    fl->client.l_offset == ifl->client.l_offset &&
1217 		    fl->client.l_len == ifl->client.l_len &&
1218 		    same_filelock_identity(fl, ifl)) {
1219 			retval = 1;
1220 			break;
1221 		}
1222 	}
1223 
1224 	debuglog("Exiting duplicate_block: %s\n", retval ? "already blocked"
1225 	    : "not already blocked");
1226 	return retval;
1227 }
1228 
1229 void
1230 add_blockingfilelock(struct file_lock *fl)
1231 {
1232 	debuglog("Entering add_blockingfilelock\n");
1233 
1234 	/*
1235 	 * A blocking lock request _should_ never be duplicated as a client
1236 	 * that is already blocked shouldn't be able to request another
1237 	 * lock. Alas, there are some buggy clients that do request the same
1238 	 * lock repeatedly. Make sure only unique locks are on the blocked
1239 	 * lock list.
1240 	 */
1241 	if (duplicate_block(fl)) {
1242 		debuglog("Exiting add_blockingfilelock: already blocked\n");
1243 		return;
1244 	}
1245 
1246 	/*
1247 	 * Clear the blocking flag so that it can be reused without
1248 	 * adding it to the blocking queue a second time
1249 	 */
1250 
1251 	fl->blocking = 0;
1252 	LIST_INSERT_HEAD(&blockedlocklist_head, fl, nfslocklist);
1253 
1254 	debuglog("Exiting add_blockingfilelock: added blocked lock\n");
1255 }
1256 
1257 void
1258 remove_blockingfilelock(struct file_lock *fl)
1259 {
1260 
1261 	debuglog("Entering remove_blockingfilelock\n");
1262 
1263 	LIST_REMOVE(fl, nfslocklist);
1264 
1265 	debuglog("Exiting remove_blockingfilelock\n");
1266 }
1267 
1268 void
1269 clear_blockingfilelock(const char *hostname)
1270 {
1271 	struct file_lock *ifl,*nfl;
1272 
1273 	/*
1274 	 * Normally, LIST_FOREACH is called for, but since
1275 	 * the current element *is* the iterator, deleting it
1276 	 * would mess up the iteration.  Thus, a next element
1277 	 * must be used explicitly
1278 	 */
1279 
1280 	ifl = LIST_FIRST(&blockedlocklist_head);
1281 
1282 	while (ifl != NULL) {
1283 		nfl = LIST_NEXT(ifl, nfslocklist);
1284 
1285 		if (strncmp(hostname, ifl->client_name, SM_MAXSTRLEN) == 0) {
1286 			remove_blockingfilelock(ifl);
1287 			deallocate_file_lock(ifl);
1288 		}
1289 
1290 		ifl = nfl;
1291 	}
1292 }
1293 
1294 void
1295 retry_blockingfilelocklist(void)
1296 {
1297 	/* Retry all locks in the blocked list */
1298 	struct file_lock *ifl, *nfl; /* Iterator */
1299 	enum partialfilelock_status pflstatus;
1300 
1301 	debuglog("Entering retry_blockingfilelocklist\n");
1302 
1303 	LIST_FOREACH_SAFE(ifl, &blockedlocklist_head, nfslocklist, nfl) {
1304 		debuglog("Iterator choice %p\n",ifl);
1305 		debuglog("Next iterator choice %p\n",nfl);
1306 
1307 		/*
1308 		 * SUBTLE BUG: The file_lock must be removed from the
1309 		 * old list so that it's list pointers get disconnected
1310 		 * before being allowed to participate in the new list
1311 		 * which will automatically add it in if necessary.
1312 		 */
1313 
1314 		LIST_REMOVE(ifl, nfslocklist);
1315 		pflstatus = lock_partialfilelock(ifl);
1316 
1317 		if (pflstatus == PFL_GRANTED || pflstatus == PFL_GRANTED_DUPLICATE) {
1318 			debuglog("Granted blocked lock\n");
1319 			/* lock granted and is now being used */
1320 			send_granted(ifl,0);
1321 		} else {
1322 			/* Reinsert lock back into blocked list */
1323 			debuglog("Replacing blocked lock\n");
1324 			LIST_INSERT_HEAD(&blockedlocklist_head, ifl, nfslocklist);
1325 		}
1326 	}
1327 
1328 	debuglog("Exiting retry_blockingfilelocklist\n");
1329 }
1330 
1331 /*
1332  * Below here are routines associated with manipulating all
1333  * aspects of the partial file locking system (list, hardware, etc.)
1334  */
1335 
1336 /*
1337  * Please note that lock monitoring must be done at this level which
1338  * keeps track of *individual* lock requests on lock and unlock
1339  *
1340  * XXX: Split unlocking is going to make the unlock code miserable
1341  */
1342 
1343 /*
1344  * lock_partialfilelock:
1345  *
1346  * Argument fl gets modified as its list housekeeping entries get modified
1347  * upon insertion into the NFS lock list
1348  *
1349  * This routine makes several assumptions:
1350  * 1) It (will) pass locks through to flock to lock the entire underlying file
1351  *     and then parcel out NFS locks if it gets control of the file.
1352  *         This matches the old rpc.lockd file semantics (except where it
1353  *         is now more correct).  It is the safe solution, but will cause
1354  *         overly restrictive blocking if someone is trying to use the
1355  *         underlying files without using NFS.  This appears to be an
1356  *         acceptable tradeoff since most people use standalone NFS servers.
1357  * XXX: The right solution is probably kevent combined with fcntl
1358  *
1359  *    2) Nothing modifies the lock lists between testing and granting
1360  *           I have no idea whether this is a useful assumption or not
1361  */
1362 
1363 enum partialfilelock_status
1364 lock_partialfilelock(struct file_lock *fl)
1365 {
1366 	enum partialfilelock_status retval;
1367 	enum nfslock_status lnlstatus;
1368 	enum hwlock_status hwstatus;
1369 
1370 	debuglog("Entering lock_partialfilelock\n");
1371 
1372 	retval = PFL_DENIED;
1373 
1374 	/*
1375 	 * Execute the NFS lock first, if possible, as it is significantly
1376 	 * easier and less expensive to undo than the filesystem lock
1377 	 */
1378 
1379 	lnlstatus = lock_nfslock(fl);
1380 
1381 	switch (lnlstatus) {
1382 	case NFS_GRANTED:
1383 	case NFS_GRANTED_DUPLICATE:
1384 		/*
1385 		 * At this point, the NFS lock is allocated and active.
1386 		 * Remember to clean it up if the hardware lock fails
1387 		 */
1388 		hwstatus = lock_hwlock(fl);
1389 
1390 		switch (hwstatus) {
1391 		case HW_GRANTED:
1392 		case HW_GRANTED_DUPLICATE:
1393 			debuglog("HW GRANTED\n");
1394 			/*
1395 			 * XXX: Fixme: Check hwstatus for duplicate when
1396 			 * true partial file locking and accounting is
1397 			 * done on the hardware.
1398 			 */
1399 			if (lnlstatus == NFS_GRANTED_DUPLICATE) {
1400 				retval = PFL_GRANTED_DUPLICATE;
1401 			} else {
1402 				retval = PFL_GRANTED;
1403 			}
1404 			monitor_lock_host(fl->client_name);
1405 			break;
1406 		case HW_RESERR:
1407 			debuglog("HW RESERR\n");
1408 			retval = PFL_HWRESERR;
1409 			break;
1410 		case HW_DENIED:
1411 			debuglog("HW DENIED\n");
1412 			retval = PFL_HWDENIED;
1413 			break;
1414 		default:
1415 			debuglog("Unmatched hwstatus %d\n",hwstatus);
1416 			break;
1417 		}
1418 
1419 		if (retval != PFL_GRANTED &&
1420 		    retval != PFL_GRANTED_DUPLICATE) {
1421 			/* Clean up the NFS lock */
1422 			debuglog("Deleting trial NFS lock\n");
1423 			delete_nfslock(fl);
1424 		}
1425 		break;
1426 	case NFS_DENIED:
1427 		retval = PFL_NFSDENIED;
1428 		break;
1429 	case NFS_RESERR:
1430 		retval = PFL_NFSRESERR;
1431 	default:
1432 		debuglog("Unmatched lnlstatus %d\n");
1433 		retval = PFL_NFSDENIED_NOLOCK;
1434 		break;
1435 	}
1436 
1437 	/*
1438 	 * By the time fl reaches here, it is completely free again on
1439 	 * failure.  The NFS lock done before attempting the
1440 	 * hardware lock has been backed out
1441 	 */
1442 
1443 	if (retval == PFL_NFSDENIED || retval == PFL_HWDENIED) {
1444 		/* Once last chance to check the lock */
1445 		if (fl->blocking == 1) {
1446 			if (retval == PFL_NFSDENIED) {
1447 				/* Queue the lock */
1448 				debuglog("BLOCKING LOCK RECEIVED\n");
1449 				retval = PFL_NFSBLOCKED;
1450 				add_blockingfilelock(fl);
1451 				dump_filelock(fl);
1452 			} else {
1453 				/* retval is okay as PFL_HWDENIED */
1454 				debuglog("BLOCKING LOCK DENIED IN HARDWARE\n");
1455 				dump_filelock(fl);
1456 			}
1457 		} else {
1458 			/* Leave retval alone, it's already correct */
1459 			debuglog("Lock denied.  Non-blocking failure\n");
1460 			dump_filelock(fl);
1461 		}
1462 	}
1463 
1464 	debuglog("Exiting lock_partialfilelock\n");
1465 
1466 	return retval;
1467 }
1468 
1469 /*
1470  * unlock_partialfilelock:
1471  *
1472  * Given a file_lock, unlock all locks which match.
1473  *
1474  * Note that a given lock might have to unlock ITSELF!  See
1475  * clear_partialfilelock for example.
1476  */
1477 
1478 enum partialfilelock_status
1479 unlock_partialfilelock(const struct file_lock *fl)
1480 {
1481 	struct file_lock *lfl,*rfl,*releasedfl,*selffl;
1482 	enum partialfilelock_status retval;
1483 	enum nfslock_status unlstatus;
1484 	enum hwlock_status unlhwstatus, lhwstatus;
1485 
1486 	debuglog("Entering unlock_partialfilelock\n");
1487 
1488 	selffl = NULL;
1489 	lfl = NULL;
1490 	rfl = NULL;
1491 	releasedfl = NULL;
1492 	retval = PFL_DENIED;
1493 
1494 	/*
1495 	 * There are significant overlap and atomicity issues
1496 	 * with partially releasing a lock.  For example, releasing
1497 	 * part of an NFS shared lock does *not* always release the
1498 	 * corresponding part of the file since there is only one
1499 	 * rpc.lockd UID but multiple users could be requesting it
1500 	 * from NFS.  Also, an unlock request should never allow
1501 	 * another process to gain a lock on the remaining parts.
1502 	 * ie. Always apply the new locks before releasing the
1503 	 * old one
1504 	 */
1505 
1506 	/*
1507 	 * Loop is required since multiple little locks
1508 	 * can be allocated and then deallocated with one
1509 	 * big unlock.
1510 	 *
1511 	 * The loop is required to be here so that the nfs &
1512 	 * hw subsystems do not need to communicate with one
1513 	 * one another
1514 	 */
1515 
1516 	do {
1517 		debuglog("Value of releasedfl: %p\n",releasedfl);
1518 		/* lfl&rfl are created *AND* placed into the NFS lock list if required */
1519 		unlstatus = unlock_nfslock(fl, &releasedfl, &lfl, &rfl);
1520 		debuglog("Value of releasedfl: %p\n",releasedfl);
1521 
1522 
1523 		/* XXX: This is grungy.  It should be refactored to be cleaner */
1524 		if (lfl != NULL) {
1525 			lhwstatus = lock_hwlock(lfl);
1526 			if (lhwstatus != HW_GRANTED &&
1527 			    lhwstatus != HW_GRANTED_DUPLICATE) {
1528 				debuglog("HW duplicate lock failure for left split\n");
1529 			}
1530 			monitor_lock_host(lfl->client_name);
1531 		}
1532 
1533 		if (rfl != NULL) {
1534 			lhwstatus = lock_hwlock(rfl);
1535 			if (lhwstatus != HW_GRANTED &&
1536 			    lhwstatus != HW_GRANTED_DUPLICATE) {
1537 				debuglog("HW duplicate lock failure for right split\n");
1538 			}
1539 			monitor_lock_host(rfl->client_name);
1540 		}
1541 
1542 		switch (unlstatus) {
1543 		case NFS_GRANTED:
1544 			/* Attempt to unlock on the hardware */
1545 			debuglog("NFS unlock granted.  Attempting hardware unlock\n");
1546 
1547 			/* This call *MUST NOT* unlock the two newly allocated locks */
1548 			unlhwstatus = unlock_hwlock(fl);
1549 			debuglog("HW unlock returned with code %d\n",unlhwstatus);
1550 
1551 			switch (unlhwstatus) {
1552 			case HW_GRANTED:
1553 				debuglog("HW unlock granted\n");
1554 				unmonitor_lock_host(releasedfl->client_name);
1555 				retval = PFL_GRANTED;
1556 				break;
1557 			case HW_DENIED_NOLOCK:
1558 				/* Huh?!?!  This shouldn't happen */
1559 				debuglog("HW unlock denied no lock\n");
1560 				retval = PFL_HWRESERR;
1561 				/* Break out of do-while */
1562 				unlstatus = NFS_RESERR;
1563 				break;
1564 			default:
1565 				debuglog("HW unlock failed\n");
1566 				retval = PFL_HWRESERR;
1567 				/* Break out of do-while */
1568 				unlstatus = NFS_RESERR;
1569 				break;
1570 			}
1571 
1572 			debuglog("Exiting with status retval: %d\n",retval);
1573 
1574 			retry_blockingfilelocklist();
1575 			break;
1576 		case NFS_DENIED_NOLOCK:
1577 			retval = PFL_GRANTED;
1578 			debuglog("All locks cleaned out\n");
1579 			break;
1580 		default:
1581 			retval = PFL_NFSRESERR;
1582 			debuglog("NFS unlock failure\n");
1583 			dump_filelock(fl);
1584 			break;
1585 		}
1586 
1587 		if (releasedfl != NULL) {
1588 			if (fl == releasedfl) {
1589 				/*
1590 				 * XXX: YECHHH!!! Attempt to unlock self succeeded
1591 				 * but we can't deallocate the space yet.  This is what
1592 				 * happens when you don't write malloc and free together
1593 				 */
1594 				debuglog("Attempt to unlock self\n");
1595 				selffl = releasedfl;
1596 			} else {
1597 				/*
1598 				 * XXX: this deallocation *still* needs to migrate closer
1599 				 * to the allocation code way up in get_lock or the allocation
1600 				 * code needs to migrate down (violation of "When you write
1601 				 * malloc you must write free")
1602 				 */
1603 
1604 				deallocate_file_lock(releasedfl);
1605 			}
1606 		}
1607 
1608 	} while (unlstatus == NFS_GRANTED);
1609 
1610 	if (selffl != NULL) {
1611 		/*
1612 		 * This statement wipes out the incoming file lock (fl)
1613 		 * in spite of the fact that it is declared const
1614 		 */
1615 		debuglog("WARNING!  Destroying incoming lock pointer\n");
1616 		deallocate_file_lock(selffl);
1617 	}
1618 
1619 	debuglog("Exiting unlock_partialfilelock\n");
1620 
1621 	return retval;
1622 }
1623 
1624 /*
1625  * clear_partialfilelock
1626  *
1627  * Normally called in response to statd state number change.
1628  * Wipe out all locks held by a host.  As a bonus, the act of
1629  * doing so should automatically clear their statd entries and
1630  * unmonitor the host.
1631  */
1632 
1633 void
1634 clear_partialfilelock(const char *hostname)
1635 {
1636 	struct file_lock *ifl, *nfl;
1637 
1638 	/* Clear blocking file lock list */
1639 	clear_blockingfilelock(hostname);
1640 
1641 	/* do all required unlocks */
1642 	/* Note that unlock can smash the current pointer to a lock */
1643 
1644 	/*
1645 	 * Normally, LIST_FOREACH is called for, but since
1646 	 * the current element *is* the iterator, deleting it
1647 	 * would mess up the iteration.  Thus, a next element
1648 	 * must be used explicitly
1649 	 */
1650 
1651 	ifl = LIST_FIRST(&nfslocklist_head);
1652 
1653 	while (ifl != NULL) {
1654 		nfl = LIST_NEXT(ifl, nfslocklist);
1655 
1656 		if (strncmp(hostname, ifl->client_name, SM_MAXSTRLEN) == 0) {
1657 			/* Unlock destroys ifl out from underneath */
1658 			unlock_partialfilelock(ifl);
1659 			/* ifl is NO LONGER VALID AT THIS POINT */
1660 		}
1661 		ifl = nfl;
1662 	}
1663 }
1664 
1665 /*
1666  * test_partialfilelock:
1667  */
1668 enum partialfilelock_status
1669 test_partialfilelock(const struct file_lock *fl,
1670     struct file_lock **conflicting_fl)
1671 {
1672 	enum partialfilelock_status retval;
1673 	enum nfslock_status teststatus;
1674 
1675 	debuglog("Entering testpartialfilelock...\n");
1676 
1677 	retval = PFL_DENIED;
1678 
1679 	teststatus = test_nfslock(fl, conflicting_fl);
1680 	debuglog("test_partialfilelock: teststatus %d\n",teststatus);
1681 
1682 	if (teststatus == NFS_GRANTED || teststatus == NFS_GRANTED_DUPLICATE) {
1683 		/* XXX: Add the underlying filesystem locking code */
1684 		retval = (teststatus == NFS_GRANTED) ?
1685 		    PFL_GRANTED : PFL_GRANTED_DUPLICATE;
1686 		debuglog("Dumping locks...\n");
1687 		dump_filelock(fl);
1688 		dump_filelock(*conflicting_fl);
1689 		debuglog("Done dumping locks...\n");
1690 	} else {
1691 		retval = PFL_NFSDENIED;
1692 		debuglog("NFS test denied.\n");
1693 		dump_filelock(fl);
1694 		debuglog("Conflicting.\n");
1695 		dump_filelock(*conflicting_fl);
1696 	}
1697 
1698 	debuglog("Exiting testpartialfilelock...\n");
1699 
1700 	return retval;
1701 }
1702 
1703 /*
1704  * Below here are routines associated with translating the partial file locking
1705  * codes into useful codes to send back to the NFS RPC messaging system
1706  */
1707 
1708 /*
1709  * These routines translate the (relatively) useful return codes back onto
1710  * the few return codes which the nlm subsystems wishes to trasmit
1711  */
1712 
1713 enum nlm_stats
1714 do_test(struct file_lock *fl, struct file_lock **conflicting_fl)
1715 {
1716 	enum partialfilelock_status pfsret;
1717 	enum nlm_stats retval;
1718 
1719 	debuglog("Entering do_test...\n");
1720 
1721 	pfsret = test_partialfilelock(fl,conflicting_fl);
1722 
1723 	switch (pfsret) {
1724 	case PFL_GRANTED:
1725 		debuglog("PFL test lock granted\n");
1726 		dump_filelock(fl);
1727 		dump_filelock(*conflicting_fl);
1728 		retval = (fl->flags & LOCK_V4) ? nlm4_granted : nlm_granted;
1729 		break;
1730 	case PFL_GRANTED_DUPLICATE:
1731 		debuglog("PFL test lock granted--duplicate id detected\n");
1732 		dump_filelock(fl);
1733 		dump_filelock(*conflicting_fl);
1734 		debuglog("Clearing conflicting_fl for call semantics\n");
1735 		*conflicting_fl = NULL;
1736 		retval = (fl->flags & LOCK_V4) ? nlm4_granted : nlm_granted;
1737 		break;
1738 	case PFL_NFSDENIED:
1739 	case PFL_HWDENIED:
1740 		debuglog("PFL test lock denied\n");
1741 		dump_filelock(fl);
1742 		dump_filelock(*conflicting_fl);
1743 		retval = (fl->flags & LOCK_V4) ? nlm4_denied : nlm_denied;
1744 		break;
1745 	case PFL_NFSRESERR:
1746 	case PFL_HWRESERR:
1747 		debuglog("PFL test lock resource fail\n");
1748 		dump_filelock(fl);
1749 		dump_filelock(*conflicting_fl);
1750 		retval = (fl->flags & LOCK_V4) ? nlm4_denied_nolocks : nlm_denied_nolocks;
1751 		break;
1752 	default:
1753 		debuglog("PFL test lock *FAILED*\n");
1754 		dump_filelock(fl);
1755 		dump_filelock(*conflicting_fl);
1756 		retval = (fl->flags & LOCK_V4) ? nlm4_failed : nlm_denied;
1757 		break;
1758 	}
1759 
1760 	debuglog("Exiting do_test...\n");
1761 
1762 	return retval;
1763 }
1764 
1765 /*
1766  * do_lock: Try to acquire a lock
1767  *
1768  * This routine makes a distinction between NLM versions.  I am pretty
1769  * convinced that this should be abstracted out and bounced up a level
1770  */
1771 
1772 enum nlm_stats
1773 do_lock(struct file_lock *fl)
1774 {
1775 	enum partialfilelock_status pfsret;
1776 	enum nlm_stats retval;
1777 
1778 	debuglog("Entering do_lock...\n");
1779 
1780 	pfsret = lock_partialfilelock(fl);
1781 
1782 	switch (pfsret) {
1783 	case PFL_GRANTED:
1784 		debuglog("PFL lock granted");
1785 		dump_filelock(fl);
1786 		retval = (fl->flags & LOCK_V4) ? nlm4_granted : nlm_granted;
1787 		break;
1788 	case PFL_GRANTED_DUPLICATE:
1789 		debuglog("PFL lock granted--duplicate id detected");
1790 		dump_filelock(fl);
1791 		retval = (fl->flags & LOCK_V4) ? nlm4_granted : nlm_granted;
1792 		break;
1793 	case PFL_NFSDENIED:
1794 	case PFL_HWDENIED:
1795 		debuglog("PFL_NFS lock denied");
1796 		dump_filelock(fl);
1797 		retval = (fl->flags & LOCK_V4) ? nlm4_denied : nlm_denied;
1798 		break;
1799 	case PFL_NFSBLOCKED:
1800 	case PFL_HWBLOCKED:
1801 		debuglog("PFL_NFS blocking lock denied.  Queued.\n");
1802 		dump_filelock(fl);
1803 		retval = (fl->flags & LOCK_V4) ? nlm4_blocked : nlm_blocked;
1804 		break;
1805 	case PFL_NFSRESERR:
1806 	case PFL_HWRESERR:
1807 		debuglog("PFL lock resource alocation fail\n");
1808 		dump_filelock(fl);
1809 		retval = (fl->flags & LOCK_V4) ? nlm4_denied_nolocks : nlm_denied_nolocks;
1810 		break;
1811 	default:
1812 		debuglog("PFL lock *FAILED*");
1813 		dump_filelock(fl);
1814 		retval = (fl->flags & LOCK_V4) ? nlm4_failed : nlm_denied;
1815 		break;
1816 	}
1817 
1818 	debuglog("Exiting do_lock...\n");
1819 
1820 	return retval;
1821 }
1822 
1823 enum nlm_stats
1824 do_unlock(struct file_lock *fl)
1825 {
1826 	enum partialfilelock_status pfsret;
1827 	enum nlm_stats retval;
1828 
1829 	debuglog("Entering do_unlock...\n");
1830 	pfsret = unlock_partialfilelock(fl);
1831 
1832 	switch (pfsret) {
1833 	case PFL_GRANTED:
1834 		debuglog("PFL unlock granted");
1835 		dump_filelock(fl);
1836 		retval = (fl->flags & LOCK_V4) ? nlm4_granted : nlm_granted;
1837 		break;
1838 	case PFL_NFSDENIED:
1839 	case PFL_HWDENIED:
1840 		debuglog("PFL_NFS unlock denied");
1841 		dump_filelock(fl);
1842 		retval = (fl->flags & LOCK_V4) ? nlm4_denied : nlm_denied;
1843 		break;
1844 	case PFL_NFSDENIED_NOLOCK:
1845 	case PFL_HWDENIED_NOLOCK:
1846 		debuglog("PFL_NFS no lock found\n");
1847 		retval = (fl->flags & LOCK_V4) ? nlm4_granted : nlm_granted;
1848 		break;
1849 	case PFL_NFSRESERR:
1850 	case PFL_HWRESERR:
1851 		debuglog("PFL unlock resource failure");
1852 		dump_filelock(fl);
1853 		retval = (fl->flags & LOCK_V4) ? nlm4_denied_nolocks : nlm_denied_nolocks;
1854 		break;
1855 	default:
1856 		debuglog("PFL unlock *FAILED*");
1857 		dump_filelock(fl);
1858 		retval = (fl->flags & LOCK_V4) ? nlm4_failed : nlm_denied;
1859 		break;
1860 	}
1861 
1862 	debuglog("Exiting do_unlock...\n");
1863 
1864 	return retval;
1865 }
1866 
1867 /*
1868  * do_clear
1869  *
1870  * This routine is non-existent because it doesn't have a return code.
1871  * It is here for completeness in case someone *does* need to do return
1872  * codes later.  A decent compiler should optimize this away.
1873  */
1874 
1875 void
1876 do_clear(const char *hostname)
1877 {
1878 
1879 	clear_partialfilelock(hostname);
1880 }
1881 
1882 /*
1883  * The following routines are all called from the code which the
1884  * RPC layer invokes
1885  */
1886 
1887 /*
1888  * testlock(): inform the caller if the requested lock would be granted
1889  *
1890  * returns NULL if lock would granted
1891  * returns pointer to a conflicting nlm4_holder if not
1892  */
1893 
1894 struct nlm4_holder *
1895 testlock(struct nlm4_lock *lock, bool_t exclusive, int flags __unused)
1896 {
1897 	struct file_lock test_fl, *conflicting_fl;
1898 
1899 	bzero(&test_fl, sizeof(test_fl));
1900 
1901 	bcopy(lock->fh.n_bytes, &(test_fl.filehandle), sizeof(fhandle_t));
1902 	copy_nlm4_lock_to_nlm4_holder(lock, exclusive, &test_fl.client);
1903 
1904 	siglock();
1905 	do_test(&test_fl, &conflicting_fl);
1906 
1907 	if (conflicting_fl == NULL) {
1908 		debuglog("No conflicting lock found\n");
1909 		sigunlock();
1910 		return NULL;
1911 	} else {
1912 		debuglog("Found conflicting lock\n");
1913 		dump_filelock(conflicting_fl);
1914 		sigunlock();
1915 		return (&conflicting_fl->client);
1916 	}
1917 }
1918 
1919 /*
1920  * getlock: try to aquire the lock.
1921  * If file is already locked and we can sleep, put the lock in the list with
1922  * status LKST_WAITING; it'll be processed later.
1923  * Otherwise try to lock. If we're allowed to block, fork a child which
1924  * will do the blocking lock.
1925  */
1926 
1927 enum nlm_stats
1928 getlock(nlm4_lockargs *lckarg, struct svc_req *rqstp, const int flags)
1929 {
1930 	struct file_lock *newfl;
1931 	enum nlm_stats retval;
1932 
1933 	debuglog("Entering getlock...\n");
1934 
1935 	if (grace_expired == 0 && lckarg->reclaim == 0)
1936 		return (flags & LOCK_V4) ?
1937 		    nlm4_denied_grace_period : nlm_denied_grace_period;
1938 
1939 	/* allocate new file_lock for this request */
1940 	newfl = allocate_file_lock(&lckarg->alock.oh, &lckarg->cookie,
1941 				   (struct sockaddr *)svc_getrpccaller(rqstp->rq_xprt)->buf, lckarg->alock.caller_name);
1942 	if (newfl == NULL) {
1943 		syslog(LOG_NOTICE, "lock allocate failed: %s", strerror(errno));
1944 		/* failed */
1945 		return (flags & LOCK_V4) ?
1946 		    nlm4_denied_nolocks : nlm_denied_nolocks;
1947 	}
1948 
1949 	if (lckarg->alock.fh.n_len != sizeof(fhandle_t)) {
1950 		debuglog("recieved fhandle size %d, local size %d",
1951 		    lckarg->alock.fh.n_len, (int)sizeof(fhandle_t));
1952 	}
1953 
1954 	fill_file_lock(newfl, (fhandle_t *)lckarg->alock.fh.n_bytes,
1955 	    lckarg->exclusive, lckarg->alock.svid, lckarg->alock.l_offset,
1956 	    lckarg->alock.l_len,
1957 	    lckarg->state, 0, flags, lckarg->block);
1958 
1959 	/*
1960 	 * newfl is now fully constructed and deallocate_file_lock
1961 	 * can now be used to delete it
1962 	 */
1963 
1964 	siglock();
1965 	debuglog("Pointer to new lock is %p\n",newfl);
1966 
1967 	retval = do_lock(newfl);
1968 
1969 	debuglog("Pointer to new lock is %p\n",newfl);
1970 	sigunlock();
1971 
1972 	switch (retval)
1973 		{
1974 		case nlm4_granted:
1975 			/* case nlm_granted: is the same as nlm4_granted */
1976 			/* do_mon(lckarg->alock.caller_name); */
1977 			break;
1978 		case nlm4_blocked:
1979 			/* case nlm_blocked: is the same as nlm4_blocked */
1980 			/* do_mon(lckarg->alock.caller_name); */
1981 			break;
1982 		default:
1983 			deallocate_file_lock(newfl);
1984 			break;
1985 		}
1986 
1987 	debuglog("Exiting getlock...\n");
1988 
1989 	return retval;
1990 }
1991 
1992 
1993 /* unlock a filehandle */
1994 enum nlm_stats
1995 unlock(nlm4_lock *lock, const int flags __unused)
1996 {
1997 	struct file_lock fl;
1998 	enum nlm_stats err;
1999 
2000 	siglock();
2001 
2002 	debuglog("Entering unlock...\n");
2003 
2004 	bzero(&fl,sizeof(struct file_lock));
2005 	bcopy(lock->fh.n_bytes, &fl.filehandle, sizeof(fhandle_t));
2006 
2007 	copy_nlm4_lock_to_nlm4_holder(lock, 0, &fl.client);
2008 
2009 	err = do_unlock(&fl);
2010 
2011 	sigunlock();
2012 
2013 	debuglog("Exiting unlock...\n");
2014 
2015 	return err;
2016 }
2017 
2018 /*
2019  * XXX: The following monitor/unmonitor routines
2020  * have not been extensively tested (ie. no regression
2021  * script exists like for the locking sections
2022  */
2023 
2024 /*
2025  * monitor_lock_host: monitor lock hosts locally with a ref count and
2026  * inform statd
2027  */
2028 void
2029 monitor_lock_host(const char *hostname)
2030 {
2031 	struct host *ihp, *nhp;
2032 	struct mon smon;
2033 	struct sm_stat_res sres;
2034 	int rpcret, statflag;
2035 	size_t n;
2036 
2037 	rpcret = 0;
2038 	statflag = 0;
2039 
2040 	LIST_FOREACH(ihp, &hostlst_head, hostlst) {
2041 		if (strncmp(hostname, ihp->name, SM_MAXSTRLEN) == 0) {
2042 			/* Host is already monitored, bump refcount */
2043 			++ihp->refcnt;
2044 			/* Host should only be in the monitor list once */
2045 			return;
2046 		}
2047 	}
2048 
2049 	/* Host is not yet monitored, add it */
2050 	n = strnlen(hostname, SM_MAXSTRLEN);
2051 	if (n == SM_MAXSTRLEN) {
2052 		return;
2053 	}
2054 	nhp = malloc(sizeof(*nhp) - sizeof(nhp->name) + n + 1);
2055 	if (nhp == NULL) {
2056 		debuglog("Unable to allocate entry for statd mon\n");
2057 		return;
2058 	}
2059 
2060 	/* Allocated new host entry, now fill the fields */
2061 	memcpy(nhp->name, hostname, n);
2062 	nhp->name[n] = 0;
2063 	nhp->refcnt = 1;
2064 	debuglog("Locally Monitoring host %16s\n",hostname);
2065 
2066 	debuglog("Attempting to tell statd\n");
2067 
2068 	bzero(&smon,sizeof(smon));
2069 
2070 	smon.mon_id.mon_name = nhp->name;
2071 	smon.mon_id.my_id.my_name = "localhost";
2072 	smon.mon_id.my_id.my_prog = NLM_PROG;
2073 	smon.mon_id.my_id.my_vers = NLM_SM;
2074 	smon.mon_id.my_id.my_proc = NLM_SM_NOTIFY;
2075 
2076 	rpcret = callrpc("localhost", SM_PROG, SM_VERS, SM_MON,
2077 	    (xdrproc_t)xdr_mon, &smon,
2078 	    (xdrproc_t)xdr_sm_stat_res, &sres);
2079 
2080 	if (rpcret == 0) {
2081 		if (sres.res_stat == stat_fail) {
2082 			debuglog("Statd call failed\n");
2083 			statflag = 0;
2084 		} else {
2085 			statflag = 1;
2086 		}
2087 	} else {
2088 		debuglog("Rpc call to statd failed with return value: %d\n",
2089 		    rpcret);
2090 		statflag = 0;
2091 	}
2092 
2093 	if (statflag == 1) {
2094 		LIST_INSERT_HEAD(&hostlst_head, nhp, hostlst);
2095 	} else {
2096 		free(nhp);
2097 	}
2098 
2099 }
2100 
2101 /*
2102  * unmonitor_lock_host: clear monitor ref counts and inform statd when gone
2103  */
2104 void
2105 unmonitor_lock_host(char *hostname)
2106 {
2107 	struct host *ihp;
2108 	struct mon_id smon_id;
2109 	struct sm_stat smstat;
2110 	int rpcret;
2111 
2112 	rpcret = 0;
2113 
2114 	for( ihp=LIST_FIRST(&hostlst_head); ihp != NULL;
2115 	     ihp=LIST_NEXT(ihp, hostlst)) {
2116 		if (strncmp(hostname, ihp->name, SM_MAXSTRLEN) == 0) {
2117 			/* Host is monitored, bump refcount */
2118 			--ihp->refcnt;
2119 			/* Host should only be in the monitor list once */
2120 			break;
2121 		}
2122 	}
2123 
2124 	if (ihp == NULL) {
2125 		debuglog("Could not find host %16s in mon list\n", hostname);
2126 		return;
2127 	}
2128 
2129 	if (ihp->refcnt > 0)
2130 		return;
2131 
2132 	if (ihp->refcnt < 0) {
2133 		debuglog("Negative refcount!: %d\n",
2134 		    ihp->refcnt);
2135 	}
2136 
2137 	debuglog("Attempting to unmonitor host %16s\n", hostname);
2138 
2139 	bzero(&smon_id,sizeof(smon_id));
2140 
2141 	smon_id.mon_name = hostname;
2142 	smon_id.my_id.my_name = "localhost";
2143 	smon_id.my_id.my_prog = NLM_PROG;
2144 	smon_id.my_id.my_vers = NLM_SM;
2145 	smon_id.my_id.my_proc = NLM_SM_NOTIFY;
2146 
2147 	rpcret = callrpc("localhost", SM_PROG, SM_VERS, SM_UNMON,
2148 	    (xdrproc_t)xdr_mon_id, &smon_id,
2149 	    (xdrproc_t)xdr_sm_stat, &smstat);
2150 
2151 	if (rpcret != 0) {
2152 		debuglog("Rpc call to unmonitor statd failed with "
2153 		   " return value: %d\n", rpcret);
2154 	}
2155 
2156 	LIST_REMOVE(ihp, hostlst);
2157 	free(ihp);
2158 }
2159 
2160 /*
2161  * notify: Clear all locks from a host if statd complains
2162  *
2163  * XXX: This routine has not been thoroughly tested.  However, neither
2164  * had the old one been.  It used to compare the statd crash state counter
2165  * to the current lock state.  The upshot of this was that it basically
2166  * cleared all locks from the specified host 99% of the time (with the
2167  * other 1% being a bug).  Consequently, the assumption is that clearing
2168  * all locks from a host when notified by statd is acceptable.
2169  *
2170  * Please note that this routine skips the usual level of redirection
2171  * through a do_* type routine.  This introduces a possible level of
2172  * error and might better be written as do_notify and take this one out.
2173 
2174  */
2175 
2176 void
2177 notify(const char *hostname, const int state)
2178 {
2179 	debuglog("notify from %s, new state %d", hostname, state);
2180 
2181 	siglock();
2182 	do_clear(hostname);
2183 	sigunlock();
2184 
2185 	debuglog("Leaving notify\n");
2186 }
2187 
2188 void
2189 send_granted(fl, opcode)
2190 	struct file_lock *fl;
2191 	int opcode __unused;
2192 {
2193 	CLIENT *cli;
2194 	static char dummy;
2195 	struct timeval timeo;
2196 	int success;
2197 	static struct nlm_res retval;
2198 	static struct nlm4_res retval4;
2199 
2200 	debuglog("About to send granted on blocked lock\n");
2201 
2202 	cli = get_client(fl->addr,
2203 	    (fl->flags & LOCK_V4) ? NLM_VERS4 : NLM_VERS);
2204 	if (cli == NULL) {
2205 		syslog(LOG_NOTICE, "failed to get CLIENT for %s",
2206 		    fl->client_name);
2207 		/*
2208 		 * We fail to notify remote that the lock has been granted.
2209 		 * The client will timeout and retry, the lock will be
2210 		 * granted at this time.
2211 		 */
2212 		return;
2213 	}
2214 	timeo.tv_sec = 0;
2215 	timeo.tv_usec = (fl->flags & LOCK_ASYNC) ? 0 : 500000; /* 0.5s */
2216 
2217 	if (fl->flags & LOCK_V4) {
2218 		static nlm4_testargs res;
2219 		res.cookie = fl->client_cookie;
2220 		res.exclusive = fl->client.exclusive;
2221 		res.alock.caller_name = fl->client_name;
2222 		res.alock.fh.n_len = sizeof(fhandle_t);
2223 		res.alock.fh.n_bytes = (char*)&fl->filehandle;
2224 		res.alock.oh = fl->client.oh;
2225 		res.alock.svid = fl->client.svid;
2226 		res.alock.l_offset = fl->client.l_offset;
2227 		res.alock.l_len = fl->client.l_len;
2228 		debuglog("sending v4 reply%s",
2229 			 (fl->flags & LOCK_ASYNC) ? " (async)":"");
2230 		if (fl->flags & LOCK_ASYNC) {
2231 			success = clnt_call(cli, NLM4_GRANTED_MSG,
2232 			    (xdrproc_t)xdr_nlm4_testargs, &res,
2233 			    (xdrproc_t)xdr_void, &dummy, timeo);
2234 		} else {
2235 			success = clnt_call(cli, NLM4_GRANTED,
2236 			    (xdrproc_t)xdr_nlm4_testargs, &res,
2237 			    (xdrproc_t)xdr_nlm4_res, &retval4, timeo);
2238 		}
2239 	} else {
2240 		static nlm_testargs res;
2241 
2242 		res.cookie = fl->client_cookie;
2243 		res.exclusive = fl->client.exclusive;
2244 		res.alock.caller_name = fl->client_name;
2245 		res.alock.fh.n_len = sizeof(fhandle_t);
2246 		res.alock.fh.n_bytes = (char*)&fl->filehandle;
2247 		res.alock.oh = fl->client.oh;
2248 		res.alock.svid = fl->client.svid;
2249 		res.alock.l_offset = fl->client.l_offset;
2250 		res.alock.l_len = fl->client.l_len;
2251 		debuglog("sending v1 reply%s",
2252 			 (fl->flags & LOCK_ASYNC) ? " (async)":"");
2253 		if (fl->flags & LOCK_ASYNC) {
2254 			success = clnt_call(cli, NLM_GRANTED_MSG,
2255 			    (xdrproc_t)xdr_nlm_testargs, &res,
2256 			    (xdrproc_t)xdr_void, &dummy, timeo);
2257 		} else {
2258 			success = clnt_call(cli, NLM_GRANTED,
2259 			    (xdrproc_t)xdr_nlm_testargs, &res,
2260 			    (xdrproc_t)xdr_nlm_res, &retval, timeo);
2261 		}
2262 	}
2263 	if (debug_level > 2)
2264 		debuglog("clnt_call returns %d(%s) for granted",
2265 			 success, clnt_sperrno(success));
2266 
2267 }
2268 
2269 /*
2270  * Routines below here have not been modified in the overhaul
2271  */
2272 
2273 /*
2274  * Are these two routines still required since lockd is not spawning off
2275  * children to service locks anymore?  Presumably they were originally
2276  * put in place to prevent a one child from changing the lock list out
2277  * from under another one.
2278  */
2279 
2280 void
2281 siglock(void)
2282 {
2283   sigset_t block;
2284 
2285   sigemptyset(&block);
2286   sigaddset(&block, SIGCHLD);
2287 
2288   if (sigprocmask(SIG_BLOCK, &block, NULL) < 0) {
2289     syslog(LOG_WARNING, "siglock failed: %s", strerror(errno));
2290   }
2291 }
2292 
2293 void
2294 sigunlock(void)
2295 {
2296   sigset_t block;
2297 
2298   sigemptyset(&block);
2299   sigaddset(&block, SIGCHLD);
2300 
2301   if (sigprocmask(SIG_UNBLOCK, &block, NULL) < 0) {
2302     syslog(LOG_WARNING, "sigunlock failed: %s", strerror(errno));
2303   }
2304 }
2305