1 /* $NetBSD: lockd_lock.c,v 1.5 2000/11/21 03:47:41 enami Exp $ */
2
3 /*-
4 * SPDX-License-Identifier: BSD-4-Clause
5 *
6 * Copyright (c) 2001 Andrew P. Lentvorski, Jr.
7 * Copyright (c) 2000 Manuel Bouyer.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3. All advertising materials mentioning features or use of this software
18 * must display the following acknowledgement:
19 * This product includes software developed by the University of
20 * California, Berkeley and its contributors.
21 * 4. Neither the name of the University nor the names of its contributors
22 * may be used to endorse or promote products derived from this software
23 * without specific prior written permission.
24 *
25 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35 * SUCH DAMAGE.
36 *
37 */
38
39 #include <sys/cdefs.h>
40 __FBSDID("$FreeBSD$");
41
42 #define LOCKD_DEBUG
43
44 #include <stdio.h>
45 #ifdef LOCKD_DEBUG
46 #include <stdarg.h>
47 #endif
48 #include <stdlib.h>
49 #include <unistd.h>
50 #include <fcntl.h>
51 #include <syslog.h>
52 #include <errno.h>
53 #include <string.h>
54 #include <signal.h>
55 #include <rpc/rpc.h>
56 #include <sys/types.h>
57 #include <sys/stat.h>
58 #include <sys/socket.h>
59 #include <sys/param.h>
60 #include <sys/mount.h>
61 #include <sys/wait.h>
62 #include <rpcsvc/sm_inter.h>
63 #include <rpcsvc/nlm_prot.h>
64 #include "lockd_lock.h"
65 #include "lockd.h"
66
67 #define MAXOBJECTSIZE 64
68 #define MAXBUFFERSIZE 1024
69
70 /*
71 * A set of utilities for managing file locking
72 *
73 * XXX: All locks are in a linked list, a better structure should be used
74 * to improve search/access efficiency.
75 */
76
77 /* struct describing a lock */
78 struct file_lock {
79 LIST_ENTRY(file_lock) nfslocklist;
80 fhandle_t filehandle; /* NFS filehandle */
81 struct sockaddr *addr;
82 struct nlm4_holder client; /* lock holder */
83 /* XXX: client_cookie used *only* in send_granted */
84 netobj client_cookie; /* cookie sent by the client */
85 int nsm_status; /* status from the remote lock manager */
86 int status; /* lock status, see below */
87 int flags; /* lock flags, see lockd_lock.h */
88 int blocking; /* blocking lock or not */
89 char client_name[SM_MAXSTRLEN]; /* client_name is really variable
90 length and must be last! */
91 };
92
93 LIST_HEAD(nfslocklist_head, file_lock);
94 struct nfslocklist_head nfslocklist_head = LIST_HEAD_INITIALIZER(nfslocklist_head);
95
96 LIST_HEAD(blockedlocklist_head, file_lock);
97 struct blockedlocklist_head blockedlocklist_head = LIST_HEAD_INITIALIZER(blockedlocklist_head);
98
99 /* lock status */
100 #define LKST_LOCKED 1 /* lock is locked */
101 /* XXX: Is this flag file specific or lock specific? */
102 #define LKST_WAITING 2 /* file is already locked by another host */
103 #define LKST_PROCESSING 3 /* child is trying to acquire the lock */
104 #define LKST_DYING 4 /* must dies when we get news from the child */
105
106 /* struct describing a monitored host */
107 struct host {
108 LIST_ENTRY(host) hostlst;
109 int refcnt;
110 char name[SM_MAXSTRLEN]; /* name is really variable length and
111 must be last! */
112 };
113 /* list of hosts we monitor */
114 LIST_HEAD(hostlst_head, host);
115 struct hostlst_head hostlst_head = LIST_HEAD_INITIALIZER(hostlst_head);
116
117 /*
118 * File monitoring handlers
119 * XXX: These might be able to be removed when kevent support
120 * is placed into the hardware lock/unlock routines. (ie.
121 * let the kernel do all the file monitoring)
122 */
123
124 /* Struct describing a monitored file */
125 struct monfile {
126 LIST_ENTRY(monfile) monfilelist;
127 fhandle_t filehandle; /* Local access filehandle */
128 int fd; /* file descriptor: remains open until unlock! */
129 int refcount;
130 int exclusive;
131 };
132
133 /* List of files we monitor */
134 LIST_HEAD(monfilelist_head, monfile);
135 struct monfilelist_head monfilelist_head = LIST_HEAD_INITIALIZER(monfilelist_head);
136
137 static int debugdelay = 0;
138
139 enum nfslock_status { NFS_GRANTED = 0, NFS_GRANTED_DUPLICATE,
140 NFS_DENIED, NFS_DENIED_NOLOCK,
141 NFS_RESERR };
142
143 enum hwlock_status { HW_GRANTED = 0, HW_GRANTED_DUPLICATE,
144 HW_DENIED, HW_DENIED_NOLOCK,
145 HW_STALEFH, HW_READONLY, HW_RESERR };
146
147 enum partialfilelock_status { PFL_GRANTED=0, PFL_GRANTED_DUPLICATE, PFL_DENIED,
148 PFL_NFSDENIED, PFL_NFSBLOCKED, PFL_NFSDENIED_NOLOCK, PFL_NFSRESERR,
149 PFL_HWDENIED, PFL_HWBLOCKED, PFL_HWDENIED_NOLOCK, PFL_HWRESERR};
150
151 enum LFLAGS {LEDGE_LEFT, LEDGE_LBOUNDARY, LEDGE_INSIDE, LEDGE_RBOUNDARY, LEDGE_RIGHT};
152 enum RFLAGS {REDGE_LEFT, REDGE_LBOUNDARY, REDGE_INSIDE, REDGE_RBOUNDARY, REDGE_RIGHT};
153 /* XXX: WARNING! I HAVE OVERLOADED THIS STATUS ENUM! SPLIT IT APART INTO TWO */
154 enum split_status {SPL_DISJOINT=0, SPL_LOCK1=1, SPL_LOCK2=2, SPL_CONTAINED=4, SPL_RESERR=8};
155
156 enum partialfilelock_status lock_partialfilelock(struct file_lock *fl);
157
158 void send_granted(struct file_lock *fl, int opcode);
159 void siglock(void);
160 void sigunlock(void);
161 void monitor_lock_host(const char *hostname);
162 void unmonitor_lock_host(char *hostname);
163
164 void copy_nlm4_lock_to_nlm4_holder(const struct nlm4_lock *src,
165 const bool_t exclusive, struct nlm4_holder *dest);
166 struct file_lock * allocate_file_lock(const netobj *lockowner,
167 const netobj *matchcookie,
168 const struct sockaddr *addr,
169 const char *caller_name);
170 void deallocate_file_lock(struct file_lock *fl);
171 void fill_file_lock(struct file_lock *fl, const fhandle_t *fh,
172 const bool_t exclusive, const int32_t svid,
173 const u_int64_t offset, const u_int64_t len,
174 const int state, const int status, const int flags, const int blocking);
175 int regions_overlap(const u_int64_t start1, const u_int64_t len1,
176 const u_int64_t start2, const u_int64_t len2);
177 enum split_status region_compare(const u_int64_t starte, const u_int64_t lene,
178 const u_int64_t startu, const u_int64_t lenu,
179 u_int64_t *start1, u_int64_t *len1, u_int64_t *start2, u_int64_t *len2);
180 int same_netobj(const netobj *n0, const netobj *n1);
181 int same_filelock_identity(const struct file_lock *fl0,
182 const struct file_lock *fl2);
183
184 static void debuglog(char const *fmt, ...);
185 void dump_static_object(const unsigned char* object, const int sizeof_object,
186 unsigned char* hbuff, const int sizeof_hbuff,
187 unsigned char* cbuff, const int sizeof_cbuff);
188 void dump_netobj(const struct netobj *nobj);
189 void dump_filelock(const struct file_lock *fl);
190 struct file_lock * get_lock_matching_unlock(const struct file_lock *fl);
191 enum nfslock_status test_nfslock(const struct file_lock *fl,
192 struct file_lock **conflicting_fl);
193 enum nfslock_status lock_nfslock(struct file_lock *fl);
194 enum nfslock_status delete_nfslock(struct file_lock *fl);
195 enum nfslock_status unlock_nfslock(const struct file_lock *fl,
196 struct file_lock **released_lock, struct file_lock **left_lock,
197 struct file_lock **right_lock);
198 enum hwlock_status lock_hwlock(struct file_lock *fl);
199 enum split_status split_nfslock(const struct file_lock *exist_lock,
200 const struct file_lock *unlock_lock, struct file_lock **left_lock,
201 struct file_lock **right_lock);
202 int duplicate_block(struct file_lock *fl);
203 void add_blockingfilelock(struct file_lock *fl);
204 enum hwlock_status unlock_hwlock(const struct file_lock *fl);
205 enum hwlock_status test_hwlock(const struct file_lock *fl,
206 struct file_lock **conflicting_fl);
207 void remove_blockingfilelock(struct file_lock *fl);
208 void clear_blockingfilelock(const char *hostname);
209 void retry_blockingfilelocklist(void);
210 enum partialfilelock_status unlock_partialfilelock(
211 const struct file_lock *fl);
212 void clear_partialfilelock(const char *hostname);
213 enum partialfilelock_status test_partialfilelock(
214 const struct file_lock *fl, struct file_lock **conflicting_fl);
215 enum nlm_stats do_test(struct file_lock *fl,
216 struct file_lock **conflicting_fl);
217 enum nlm_stats do_unlock(struct file_lock *fl);
218 enum nlm_stats do_lock(struct file_lock *fl);
219 void do_clear(const char *hostname);
220 size_t strnlen(const char *, size_t);
221
222 void
debuglog(char const * fmt,...)223 debuglog(char const *fmt, ...)
224 {
225 va_list ap;
226
227 if (debug_level < 1) {
228 return;
229 }
230
231 sleep(debugdelay);
232
233 va_start(ap, fmt);
234 vsyslog(LOG_DEBUG, fmt, ap);
235 va_end(ap);
236 }
237
238 void
dump_static_object(object,size_object,hbuff,size_hbuff,cbuff,size_cbuff)239 dump_static_object(object, size_object, hbuff, size_hbuff, cbuff, size_cbuff)
240 const unsigned char *object;
241 const int size_object;
242 unsigned char *hbuff;
243 const int size_hbuff;
244 unsigned char *cbuff;
245 const int size_cbuff;
246 {
247 int i, objectsize;
248
249 if (debug_level < 2) {
250 return;
251 }
252
253 objectsize = size_object;
254
255 if (objectsize == 0) {
256 debuglog("object is size 0\n");
257 } else {
258 if (objectsize > MAXOBJECTSIZE) {
259 debuglog("Object of size %d being clamped"
260 "to size %d\n", objectsize, MAXOBJECTSIZE);
261 objectsize = MAXOBJECTSIZE;
262 }
263
264 if (hbuff != NULL) {
265 if (size_hbuff < objectsize*2+1) {
266 debuglog("Hbuff not large enough."
267 " Increase size\n");
268 } else {
269 for(i=0;i<objectsize;i++) {
270 sprintf(hbuff+i*2,"%02x",*(object+i));
271 }
272 *(hbuff+i*2) = '\0';
273 }
274 }
275
276 if (cbuff != NULL) {
277 if (size_cbuff < objectsize+1) {
278 debuglog("Cbuff not large enough."
279 " Increase Size\n");
280 }
281
282 for(i=0;i<objectsize;i++) {
283 if (*(object+i) >= 32 && *(object+i) <= 127) {
284 *(cbuff+i) = *(object+i);
285 } else {
286 *(cbuff+i) = '.';
287 }
288 }
289 *(cbuff+i) = '\0';
290 }
291 }
292 }
293
294 void
dump_netobj(const struct netobj * nobj)295 dump_netobj(const struct netobj *nobj)
296 {
297 char hbuff[MAXBUFFERSIZE*2];
298 char cbuff[MAXBUFFERSIZE];
299
300 if (debug_level < 2) {
301 return;
302 }
303
304 if (nobj == NULL) {
305 debuglog("Null netobj pointer\n");
306 }
307 else if (nobj->n_len == 0) {
308 debuglog("Size zero netobj\n");
309 } else {
310 dump_static_object(nobj->n_bytes, nobj->n_len,
311 hbuff, sizeof(hbuff), cbuff, sizeof(cbuff));
312 debuglog("netobj: len: %d data: %s ::: %s\n",
313 nobj->n_len, hbuff, cbuff);
314 }
315 }
316
317 /* #define DUMP_FILELOCK_VERBOSE */
318 void
dump_filelock(const struct file_lock * fl)319 dump_filelock(const struct file_lock *fl)
320 {
321 #ifdef DUMP_FILELOCK_VERBOSE
322 char hbuff[MAXBUFFERSIZE*2];
323 char cbuff[MAXBUFFERSIZE];
324 #endif
325
326 if (debug_level < 2) {
327 return;
328 }
329
330 if (fl != NULL) {
331 debuglog("Dumping file lock structure @ %p\n", fl);
332
333 #ifdef DUMP_FILELOCK_VERBOSE
334 dump_static_object((unsigned char *)&fl->filehandle,
335 sizeof(fl->filehandle), hbuff, sizeof(hbuff),
336 cbuff, sizeof(cbuff));
337 debuglog("Filehandle: %8s ::: %8s\n", hbuff, cbuff);
338 #endif
339
340 debuglog("Dumping nlm4_holder:\n"
341 "exc: %x svid: %x offset:len %llx:%llx\n",
342 fl->client.exclusive, fl->client.svid,
343 fl->client.l_offset, fl->client.l_len);
344
345 #ifdef DUMP_FILELOCK_VERBOSE
346 debuglog("Dumping client identity:\n");
347 dump_netobj(&fl->client.oh);
348
349 debuglog("Dumping client cookie:\n");
350 dump_netobj(&fl->client_cookie);
351
352 debuglog("nsm: %d status: %d flags: %d svid: %x"
353 " client_name: %s\n", fl->nsm_status, fl->status,
354 fl->flags, fl->client.svid, fl->client_name);
355 #endif
356 } else {
357 debuglog("NULL file lock structure\n");
358 }
359 }
360
361 void
copy_nlm4_lock_to_nlm4_holder(src,exclusive,dest)362 copy_nlm4_lock_to_nlm4_holder(src, exclusive, dest)
363 const struct nlm4_lock *src;
364 const bool_t exclusive;
365 struct nlm4_holder *dest;
366 {
367
368 dest->exclusive = exclusive;
369 dest->oh.n_len = src->oh.n_len;
370 dest->oh.n_bytes = src->oh.n_bytes;
371 dest->svid = src->svid;
372 dest->l_offset = src->l_offset;
373 dest->l_len = src->l_len;
374 }
375
376
377 size_t
strnlen(const char * s,size_t len)378 strnlen(const char *s, size_t len)
379 {
380 size_t n;
381
382 for (n = 0; s[n] != 0 && n < len; n++)
383 ;
384 return n;
385 }
386
387 /*
388 * allocate_file_lock: Create a lock with the given parameters
389 */
390
391 struct file_lock *
allocate_file_lock(const netobj * lockowner,const netobj * matchcookie,const struct sockaddr * addr,const char * caller_name)392 allocate_file_lock(const netobj *lockowner, const netobj *matchcookie,
393 const struct sockaddr *addr, const char *caller_name)
394 {
395 struct file_lock *newfl;
396 size_t n;
397
398 /* Beware of rubbish input! */
399 n = strnlen(caller_name, SM_MAXSTRLEN);
400 if (n == SM_MAXSTRLEN) {
401 return NULL;
402 }
403
404 newfl = malloc(sizeof(*newfl) - sizeof(newfl->client_name) + n + 1);
405 if (newfl == NULL) {
406 return NULL;
407 }
408 bzero(newfl, sizeof(*newfl) - sizeof(newfl->client_name));
409 memcpy(newfl->client_name, caller_name, n);
410 newfl->client_name[n] = 0;
411
412 newfl->client.oh.n_bytes = malloc(lockowner->n_len);
413 if (newfl->client.oh.n_bytes == NULL) {
414 free(newfl);
415 return NULL;
416 }
417 newfl->client.oh.n_len = lockowner->n_len;
418 bcopy(lockowner->n_bytes, newfl->client.oh.n_bytes, lockowner->n_len);
419
420 newfl->client_cookie.n_bytes = malloc(matchcookie->n_len);
421 if (newfl->client_cookie.n_bytes == NULL) {
422 free(newfl->client.oh.n_bytes);
423 free(newfl);
424 return NULL;
425 }
426 newfl->client_cookie.n_len = matchcookie->n_len;
427 bcopy(matchcookie->n_bytes, newfl->client_cookie.n_bytes, matchcookie->n_len);
428
429 newfl->addr = malloc(addr->sa_len);
430 if (newfl->addr == NULL) {
431 free(newfl->client_cookie.n_bytes);
432 free(newfl->client.oh.n_bytes);
433 free(newfl);
434 return NULL;
435 }
436 memcpy(newfl->addr, addr, addr->sa_len);
437
438 return newfl;
439 }
440
441 /*
442 * file_file_lock: Force creation of a valid file lock
443 */
444 void
fill_file_lock(struct file_lock * fl,const fhandle_t * fh,const bool_t exclusive,const int32_t svid,const u_int64_t offset,const u_int64_t len,const int state,const int status,const int flags,const int blocking)445 fill_file_lock(struct file_lock *fl, const fhandle_t *fh,
446 const bool_t exclusive, const int32_t svid,
447 const u_int64_t offset, const u_int64_t len,
448 const int state, const int status, const int flags, const int blocking)
449 {
450 bcopy(fh, &fl->filehandle, sizeof(fhandle_t));
451
452 fl->client.exclusive = exclusive;
453 fl->client.svid = svid;
454 fl->client.l_offset = offset;
455 fl->client.l_len = len;
456
457 fl->nsm_status = state;
458 fl->status = status;
459 fl->flags = flags;
460 fl->blocking = blocking;
461 }
462
463 /*
464 * deallocate_file_lock: Free all storage associated with a file lock
465 */
466 void
deallocate_file_lock(struct file_lock * fl)467 deallocate_file_lock(struct file_lock *fl)
468 {
469 free(fl->addr);
470 free(fl->client.oh.n_bytes);
471 free(fl->client_cookie.n_bytes);
472 free(fl);
473 }
474
475 /*
476 * regions_overlap(): This function examines the two provided regions for
477 * overlap.
478 */
479 int
regions_overlap(start1,len1,start2,len2)480 regions_overlap(start1, len1, start2, len2)
481 const u_int64_t start1, len1, start2, len2;
482 {
483 u_int64_t d1,d2,d3,d4;
484 enum split_status result;
485
486 debuglog("Entering region overlap with vals: %llu:%llu--%llu:%llu\n",
487 start1, len1, start2, len2);
488
489 result = region_compare(start1, len1, start2, len2,
490 &d1, &d2, &d3, &d4);
491
492 debuglog("Exiting region overlap with val: %d\n",result);
493
494 if (result == SPL_DISJOINT) {
495 return 0;
496 } else {
497 return 1;
498 }
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
region_compare(starte,lene,startu,lenu,start1,len1,start2,len2)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
same_netobj(const netobj * n0,const netobj * n1)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
same_filelock_identity(fl0,fl1)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 *
get_lock_matching_unlock(const struct file_lock * fl)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
test_nfslock(const struct file_lock * fl,struct file_lock ** conflicting_fl)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 to 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
lock_nfslock(struct file_lock * fl)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
delete_nfslock(struct file_lock * fl)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
split_nfslock(exist_lock,unlock_lock,left_lock,right_lock)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
unlock_nfslock(fl,released_lock,left_lock,right_lock)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
lock_hwlock(struct file_lock * fl)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
unlock_hwlock(const struct file_lock * fl)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
test_hwlock(fl,conflicting_fl)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
duplicate_block(struct file_lock * fl)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
add_blockingfilelock(struct file_lock * fl)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
remove_blockingfilelock(struct file_lock * fl)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
clear_blockingfilelock(const char * hostname)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
retry_blockingfilelocklist(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
lock_partialfilelock(struct file_lock * fl)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 break;
1432 default:
1433 debuglog("Unmatched lnlstatus %d\n");
1434 retval = PFL_NFSDENIED_NOLOCK;
1435 break;
1436 }
1437
1438 /*
1439 * By the time fl reaches here, it is completely free again on
1440 * failure. The NFS lock done before attempting the
1441 * hardware lock has been backed out
1442 */
1443
1444 if (retval == PFL_NFSDENIED || retval == PFL_HWDENIED) {
1445 /* Once last chance to check the lock */
1446 if (fl->blocking == 1) {
1447 if (retval == PFL_NFSDENIED) {
1448 /* Queue the lock */
1449 debuglog("BLOCKING LOCK RECEIVED\n");
1450 retval = PFL_NFSBLOCKED;
1451 add_blockingfilelock(fl);
1452 dump_filelock(fl);
1453 } else {
1454 /* retval is okay as PFL_HWDENIED */
1455 debuglog("BLOCKING LOCK DENIED IN HARDWARE\n");
1456 dump_filelock(fl);
1457 }
1458 } else {
1459 /* Leave retval alone, it's already correct */
1460 debuglog("Lock denied. Non-blocking failure\n");
1461 dump_filelock(fl);
1462 }
1463 }
1464
1465 debuglog("Exiting lock_partialfilelock\n");
1466
1467 return retval;
1468 }
1469
1470 /*
1471 * unlock_partialfilelock:
1472 *
1473 * Given a file_lock, unlock all locks which match.
1474 *
1475 * Note that a given lock might have to unlock ITSELF! See
1476 * clear_partialfilelock for example.
1477 */
1478
1479 enum partialfilelock_status
unlock_partialfilelock(const struct file_lock * fl)1480 unlock_partialfilelock(const struct file_lock *fl)
1481 {
1482 struct file_lock *lfl,*rfl,*releasedfl,*selffl;
1483 enum partialfilelock_status retval;
1484 enum nfslock_status unlstatus;
1485 enum hwlock_status unlhwstatus, lhwstatus;
1486
1487 debuglog("Entering unlock_partialfilelock\n");
1488
1489 selffl = NULL;
1490 lfl = NULL;
1491 rfl = NULL;
1492 releasedfl = NULL;
1493 retval = PFL_DENIED;
1494
1495 /*
1496 * There are significant overlap and atomicity issues
1497 * with partially releasing a lock. For example, releasing
1498 * part of an NFS shared lock does *not* always release the
1499 * corresponding part of the file since there is only one
1500 * rpc.lockd UID but multiple users could be requesting it
1501 * from NFS. Also, an unlock request should never allow
1502 * another process to gain a lock on the remaining parts.
1503 * ie. Always apply the new locks before releasing the
1504 * old one
1505 */
1506
1507 /*
1508 * Loop is required since multiple little locks
1509 * can be allocated and then deallocated with one
1510 * big unlock.
1511 *
1512 * The loop is required to be here so that the nfs &
1513 * hw subsystems do not need to communicate with one
1514 * one another
1515 */
1516
1517 do {
1518 debuglog("Value of releasedfl: %p\n",releasedfl);
1519 /* lfl&rfl are created *AND* placed into the NFS lock list if required */
1520 unlstatus = unlock_nfslock(fl, &releasedfl, &lfl, &rfl);
1521 debuglog("Value of releasedfl: %p\n",releasedfl);
1522
1523
1524 /* XXX: This is grungy. It should be refactored to be cleaner */
1525 if (lfl != NULL) {
1526 lhwstatus = lock_hwlock(lfl);
1527 if (lhwstatus != HW_GRANTED &&
1528 lhwstatus != HW_GRANTED_DUPLICATE) {
1529 debuglog("HW duplicate lock failure for left split\n");
1530 }
1531 monitor_lock_host(lfl->client_name);
1532 }
1533
1534 if (rfl != NULL) {
1535 lhwstatus = lock_hwlock(rfl);
1536 if (lhwstatus != HW_GRANTED &&
1537 lhwstatus != HW_GRANTED_DUPLICATE) {
1538 debuglog("HW duplicate lock failure for right split\n");
1539 }
1540 monitor_lock_host(rfl->client_name);
1541 }
1542
1543 switch (unlstatus) {
1544 case NFS_GRANTED:
1545 /* Attempt to unlock on the hardware */
1546 debuglog("NFS unlock granted. Attempting hardware unlock\n");
1547
1548 /* This call *MUST NOT* unlock the two newly allocated locks */
1549 unlhwstatus = unlock_hwlock(fl);
1550 debuglog("HW unlock returned with code %d\n",unlhwstatus);
1551
1552 switch (unlhwstatus) {
1553 case HW_GRANTED:
1554 debuglog("HW unlock granted\n");
1555 unmonitor_lock_host(releasedfl->client_name);
1556 retval = PFL_GRANTED;
1557 break;
1558 case HW_DENIED_NOLOCK:
1559 /* Huh?!?! This shouldn't happen */
1560 debuglog("HW unlock denied no lock\n");
1561 retval = PFL_HWRESERR;
1562 /* Break out of do-while */
1563 unlstatus = NFS_RESERR;
1564 break;
1565 default:
1566 debuglog("HW unlock failed\n");
1567 retval = PFL_HWRESERR;
1568 /* Break out of do-while */
1569 unlstatus = NFS_RESERR;
1570 break;
1571 }
1572
1573 debuglog("Exiting with status retval: %d\n",retval);
1574
1575 retry_blockingfilelocklist();
1576 break;
1577 case NFS_DENIED_NOLOCK:
1578 retval = PFL_GRANTED;
1579 debuglog("All locks cleaned out\n");
1580 break;
1581 default:
1582 retval = PFL_NFSRESERR;
1583 debuglog("NFS unlock failure\n");
1584 dump_filelock(fl);
1585 break;
1586 }
1587
1588 if (releasedfl != NULL) {
1589 if (fl == releasedfl) {
1590 /*
1591 * XXX: YECHHH!!! Attempt to unlock self succeeded
1592 * but we can't deallocate the space yet. This is what
1593 * happens when you don't write malloc and free together
1594 */
1595 debuglog("Attempt to unlock self\n");
1596 selffl = releasedfl;
1597 } else {
1598 /*
1599 * XXX: this deallocation *still* needs to migrate closer
1600 * to the allocation code way up in get_lock or the allocation
1601 * code needs to migrate down (violation of "When you write
1602 * malloc you must write free")
1603 */
1604
1605 deallocate_file_lock(releasedfl);
1606 releasedfl = NULL;
1607 }
1608 }
1609
1610 } while (unlstatus == NFS_GRANTED);
1611
1612 if (selffl != NULL) {
1613 /*
1614 * This statement wipes out the incoming file lock (fl)
1615 * in spite of the fact that it is declared const
1616 */
1617 debuglog("WARNING! Destroying incoming lock pointer\n");
1618 deallocate_file_lock(selffl);
1619 }
1620
1621 debuglog("Exiting unlock_partialfilelock\n");
1622
1623 return retval;
1624 }
1625
1626 /*
1627 * clear_partialfilelock
1628 *
1629 * Normally called in response to statd state number change.
1630 * Wipe out all locks held by a host. As a bonus, the act of
1631 * doing so should automatically clear their statd entries and
1632 * unmonitor the host.
1633 */
1634
1635 void
clear_partialfilelock(const char * hostname)1636 clear_partialfilelock(const char *hostname)
1637 {
1638 struct file_lock *ifl, *nfl;
1639
1640 /* Clear blocking file lock list */
1641 clear_blockingfilelock(hostname);
1642
1643 /* do all required unlocks */
1644 /* Note that unlock can smash the current pointer to a lock */
1645
1646 /*
1647 * Normally, LIST_FOREACH is called for, but since
1648 * the current element *is* the iterator, deleting it
1649 * would mess up the iteration. Thus, a next element
1650 * must be used explicitly
1651 */
1652
1653 ifl = LIST_FIRST(&nfslocklist_head);
1654
1655 while (ifl != NULL) {
1656 nfl = LIST_NEXT(ifl, nfslocklist);
1657
1658 if (strncmp(hostname, ifl->client_name, SM_MAXSTRLEN) == 0) {
1659 /* Unlock destroys ifl out from underneath */
1660 unlock_partialfilelock(ifl);
1661 /* ifl is NO LONGER VALID AT THIS POINT */
1662 }
1663 ifl = nfl;
1664 }
1665 }
1666
1667 /*
1668 * test_partialfilelock:
1669 */
1670 enum partialfilelock_status
test_partialfilelock(const struct file_lock * fl,struct file_lock ** conflicting_fl)1671 test_partialfilelock(const struct file_lock *fl,
1672 struct file_lock **conflicting_fl)
1673 {
1674 enum partialfilelock_status retval;
1675 enum nfslock_status teststatus;
1676
1677 debuglog("Entering testpartialfilelock...\n");
1678
1679 retval = PFL_DENIED;
1680
1681 teststatus = test_nfslock(fl, conflicting_fl);
1682 debuglog("test_partialfilelock: teststatus %d\n",teststatus);
1683
1684 if (teststatus == NFS_GRANTED || teststatus == NFS_GRANTED_DUPLICATE) {
1685 /* XXX: Add the underlying filesystem locking code */
1686 retval = (teststatus == NFS_GRANTED) ?
1687 PFL_GRANTED : PFL_GRANTED_DUPLICATE;
1688 debuglog("Dumping locks...\n");
1689 dump_filelock(fl);
1690 dump_filelock(*conflicting_fl);
1691 debuglog("Done dumping locks...\n");
1692 } else {
1693 retval = PFL_NFSDENIED;
1694 debuglog("NFS test denied.\n");
1695 dump_filelock(fl);
1696 debuglog("Conflicting.\n");
1697 dump_filelock(*conflicting_fl);
1698 }
1699
1700 debuglog("Exiting testpartialfilelock...\n");
1701
1702 return retval;
1703 }
1704
1705 /*
1706 * Below here are routines associated with translating the partial file locking
1707 * codes into useful codes to send back to the NFS RPC messaging system
1708 */
1709
1710 /*
1711 * These routines translate the (relatively) useful return codes back onto
1712 * the few return codes which the nlm subsystems wishes to trasmit
1713 */
1714
1715 enum nlm_stats
do_test(struct file_lock * fl,struct file_lock ** conflicting_fl)1716 do_test(struct file_lock *fl, struct file_lock **conflicting_fl)
1717 {
1718 enum partialfilelock_status pfsret;
1719 enum nlm_stats retval;
1720
1721 debuglog("Entering do_test...\n");
1722
1723 pfsret = test_partialfilelock(fl,conflicting_fl);
1724
1725 switch (pfsret) {
1726 case PFL_GRANTED:
1727 debuglog("PFL test lock granted\n");
1728 dump_filelock(fl);
1729 dump_filelock(*conflicting_fl);
1730 retval = (fl->flags & LOCK_V4) ? nlm4_granted : nlm_granted;
1731 break;
1732 case PFL_GRANTED_DUPLICATE:
1733 debuglog("PFL test lock granted--duplicate id detected\n");
1734 dump_filelock(fl);
1735 dump_filelock(*conflicting_fl);
1736 debuglog("Clearing conflicting_fl for call semantics\n");
1737 *conflicting_fl = NULL;
1738 retval = (fl->flags & LOCK_V4) ? nlm4_granted : nlm_granted;
1739 break;
1740 case PFL_NFSDENIED:
1741 case PFL_HWDENIED:
1742 debuglog("PFL test lock denied\n");
1743 dump_filelock(fl);
1744 dump_filelock(*conflicting_fl);
1745 retval = (fl->flags & LOCK_V4) ? nlm4_denied : nlm_denied;
1746 break;
1747 case PFL_NFSRESERR:
1748 case PFL_HWRESERR:
1749 debuglog("PFL test lock resource fail\n");
1750 dump_filelock(fl);
1751 dump_filelock(*conflicting_fl);
1752 retval = (fl->flags & LOCK_V4) ? nlm4_denied_nolocks : nlm_denied_nolocks;
1753 break;
1754 default:
1755 debuglog("PFL test lock *FAILED*\n");
1756 dump_filelock(fl);
1757 dump_filelock(*conflicting_fl);
1758 retval = (fl->flags & LOCK_V4) ? nlm4_failed : nlm_denied;
1759 break;
1760 }
1761
1762 debuglog("Exiting do_test...\n");
1763
1764 return retval;
1765 }
1766
1767 /*
1768 * do_lock: Try to acquire a lock
1769 *
1770 * This routine makes a distinction between NLM versions. I am pretty
1771 * convinced that this should be abstracted out and bounced up a level
1772 */
1773
1774 enum nlm_stats
do_lock(struct file_lock * fl)1775 do_lock(struct file_lock *fl)
1776 {
1777 enum partialfilelock_status pfsret;
1778 enum nlm_stats retval;
1779
1780 debuglog("Entering do_lock...\n");
1781
1782 pfsret = lock_partialfilelock(fl);
1783
1784 switch (pfsret) {
1785 case PFL_GRANTED:
1786 debuglog("PFL lock granted");
1787 dump_filelock(fl);
1788 retval = (fl->flags & LOCK_V4) ? nlm4_granted : nlm_granted;
1789 break;
1790 case PFL_GRANTED_DUPLICATE:
1791 debuglog("PFL lock granted--duplicate id detected");
1792 dump_filelock(fl);
1793 retval = (fl->flags & LOCK_V4) ? nlm4_granted : nlm_granted;
1794 break;
1795 case PFL_NFSDENIED:
1796 case PFL_HWDENIED:
1797 debuglog("PFL_NFS lock denied");
1798 dump_filelock(fl);
1799 retval = (fl->flags & LOCK_V4) ? nlm4_denied : nlm_denied;
1800 break;
1801 case PFL_NFSBLOCKED:
1802 case PFL_HWBLOCKED:
1803 debuglog("PFL_NFS blocking lock denied. Queued.\n");
1804 dump_filelock(fl);
1805 retval = (fl->flags & LOCK_V4) ? nlm4_blocked : nlm_blocked;
1806 break;
1807 case PFL_NFSRESERR:
1808 case PFL_HWRESERR:
1809 debuglog("PFL lock resource alocation fail\n");
1810 dump_filelock(fl);
1811 retval = (fl->flags & LOCK_V4) ? nlm4_denied_nolocks : nlm_denied_nolocks;
1812 break;
1813 default:
1814 debuglog("PFL lock *FAILED*");
1815 dump_filelock(fl);
1816 retval = (fl->flags & LOCK_V4) ? nlm4_failed : nlm_denied;
1817 break;
1818 }
1819
1820 debuglog("Exiting do_lock...\n");
1821
1822 return retval;
1823 }
1824
1825 enum nlm_stats
do_unlock(struct file_lock * fl)1826 do_unlock(struct file_lock *fl)
1827 {
1828 enum partialfilelock_status pfsret;
1829 enum nlm_stats retval;
1830
1831 debuglog("Entering do_unlock...\n");
1832 pfsret = unlock_partialfilelock(fl);
1833
1834 switch (pfsret) {
1835 case PFL_GRANTED:
1836 debuglog("PFL unlock granted");
1837 dump_filelock(fl);
1838 retval = (fl->flags & LOCK_V4) ? nlm4_granted : nlm_granted;
1839 break;
1840 case PFL_NFSDENIED:
1841 case PFL_HWDENIED:
1842 debuglog("PFL_NFS unlock denied");
1843 dump_filelock(fl);
1844 retval = (fl->flags & LOCK_V4) ? nlm4_denied : nlm_denied;
1845 break;
1846 case PFL_NFSDENIED_NOLOCK:
1847 case PFL_HWDENIED_NOLOCK:
1848 debuglog("PFL_NFS no lock found\n");
1849 retval = (fl->flags & LOCK_V4) ? nlm4_granted : nlm_granted;
1850 break;
1851 case PFL_NFSRESERR:
1852 case PFL_HWRESERR:
1853 debuglog("PFL unlock resource failure");
1854 dump_filelock(fl);
1855 retval = (fl->flags & LOCK_V4) ? nlm4_denied_nolocks : nlm_denied_nolocks;
1856 break;
1857 default:
1858 debuglog("PFL unlock *FAILED*");
1859 dump_filelock(fl);
1860 retval = (fl->flags & LOCK_V4) ? nlm4_failed : nlm_denied;
1861 break;
1862 }
1863
1864 debuglog("Exiting do_unlock...\n");
1865
1866 return retval;
1867 }
1868
1869 /*
1870 * do_clear
1871 *
1872 * This routine is non-existent because it doesn't have a return code.
1873 * It is here for completeness in case someone *does* need to do return
1874 * codes later. A decent compiler should optimize this away.
1875 */
1876
1877 void
do_clear(const char * hostname)1878 do_clear(const char *hostname)
1879 {
1880
1881 clear_partialfilelock(hostname);
1882 }
1883
1884 /*
1885 * The following routines are all called from the code which the
1886 * RPC layer invokes
1887 */
1888
1889 /*
1890 * testlock(): inform the caller if the requested lock would be granted
1891 *
1892 * returns NULL if lock would granted
1893 * returns pointer to a conflicting nlm4_holder if not
1894 */
1895
1896 struct nlm4_holder *
testlock(struct nlm4_lock * lock,bool_t exclusive,int flags __unused)1897 testlock(struct nlm4_lock *lock, bool_t exclusive, int flags __unused)
1898 {
1899 struct file_lock test_fl, *conflicting_fl;
1900
1901 bzero(&test_fl, sizeof(test_fl));
1902
1903 bcopy(lock->fh.n_bytes, &(test_fl.filehandle), sizeof(fhandle_t));
1904 copy_nlm4_lock_to_nlm4_holder(lock, exclusive, &test_fl.client);
1905
1906 siglock();
1907 do_test(&test_fl, &conflicting_fl);
1908
1909 if (conflicting_fl == NULL) {
1910 debuglog("No conflicting lock found\n");
1911 sigunlock();
1912 return NULL;
1913 } else {
1914 debuglog("Found conflicting lock\n");
1915 dump_filelock(conflicting_fl);
1916 sigunlock();
1917 return (&conflicting_fl->client);
1918 }
1919 }
1920
1921 /*
1922 * getlock: try to acquire the lock.
1923 * If file is already locked and we can sleep, put the lock in the list with
1924 * status LKST_WAITING; it'll be processed later.
1925 * Otherwise try to lock. If we're allowed to block, fork a child which
1926 * will do the blocking lock.
1927 */
1928
1929 enum nlm_stats
getlock(nlm4_lockargs * lckarg,struct svc_req * rqstp,const int flags)1930 getlock(nlm4_lockargs *lckarg, struct svc_req *rqstp, const int flags)
1931 {
1932 struct file_lock *newfl;
1933 enum nlm_stats retval;
1934
1935 debuglog("Entering getlock...\n");
1936
1937 if (grace_expired == 0 && lckarg->reclaim == 0)
1938 return (flags & LOCK_V4) ?
1939 nlm4_denied_grace_period : nlm_denied_grace_period;
1940
1941 /* allocate new file_lock for this request */
1942 newfl = allocate_file_lock(&lckarg->alock.oh, &lckarg->cookie,
1943 (struct sockaddr *)svc_getrpccaller(rqstp->rq_xprt)->buf, lckarg->alock.caller_name);
1944 if (newfl == NULL) {
1945 syslog(LOG_NOTICE, "lock allocate failed: %s", strerror(errno));
1946 /* failed */
1947 return (flags & LOCK_V4) ?
1948 nlm4_denied_nolocks : nlm_denied_nolocks;
1949 }
1950
1951 if (lckarg->alock.fh.n_len != sizeof(fhandle_t)) {
1952 debuglog("received fhandle size %d, local size %d",
1953 lckarg->alock.fh.n_len, (int)sizeof(fhandle_t));
1954 }
1955
1956 fill_file_lock(newfl, (fhandle_t *)lckarg->alock.fh.n_bytes,
1957 lckarg->exclusive, lckarg->alock.svid, lckarg->alock.l_offset,
1958 lckarg->alock.l_len,
1959 lckarg->state, 0, flags, lckarg->block);
1960
1961 /*
1962 * newfl is now fully constructed and deallocate_file_lock
1963 * can now be used to delete it
1964 */
1965
1966 siglock();
1967 debuglog("Pointer to new lock is %p\n",newfl);
1968
1969 retval = do_lock(newfl);
1970
1971 debuglog("Pointer to new lock is %p\n",newfl);
1972 sigunlock();
1973
1974 switch (retval)
1975 {
1976 case nlm4_granted:
1977 /* case nlm_granted: is the same as nlm4_granted */
1978 /* do_mon(lckarg->alock.caller_name); */
1979 break;
1980 case nlm4_blocked:
1981 /* case nlm_blocked: is the same as nlm4_blocked */
1982 /* do_mon(lckarg->alock.caller_name); */
1983 break;
1984 default:
1985 deallocate_file_lock(newfl);
1986 break;
1987 }
1988
1989 debuglog("Exiting getlock...\n");
1990
1991 return retval;
1992 }
1993
1994
1995 /* unlock a filehandle */
1996 enum nlm_stats
unlock(nlm4_lock * lock,const int flags __unused)1997 unlock(nlm4_lock *lock, const int flags __unused)
1998 {
1999 struct file_lock fl;
2000 enum nlm_stats err;
2001
2002 siglock();
2003
2004 debuglog("Entering unlock...\n");
2005
2006 bzero(&fl,sizeof(struct file_lock));
2007 bcopy(lock->fh.n_bytes, &fl.filehandle, sizeof(fhandle_t));
2008
2009 copy_nlm4_lock_to_nlm4_holder(lock, 0, &fl.client);
2010
2011 err = do_unlock(&fl);
2012
2013 sigunlock();
2014
2015 debuglog("Exiting unlock...\n");
2016
2017 return err;
2018 }
2019
2020 /*
2021 * XXX: The following monitor/unmonitor routines
2022 * have not been extensively tested (ie. no regression
2023 * script exists like for the locking sections
2024 */
2025
2026 /*
2027 * monitor_lock_host: monitor lock hosts locally with a ref count and
2028 * inform statd
2029 */
2030 void
monitor_lock_host(const char * hostname)2031 monitor_lock_host(const char *hostname)
2032 {
2033 struct host *ihp, *nhp;
2034 struct mon smon;
2035 struct sm_stat_res sres;
2036 int rpcret, statflag;
2037 size_t n;
2038
2039 rpcret = 0;
2040 statflag = 0;
2041
2042 LIST_FOREACH(ihp, &hostlst_head, hostlst) {
2043 if (strncmp(hostname, ihp->name, SM_MAXSTRLEN) == 0) {
2044 /* Host is already monitored, bump refcount */
2045 ++ihp->refcnt;
2046 /* Host should only be in the monitor list once */
2047 return;
2048 }
2049 }
2050
2051 /* Host is not yet monitored, add it */
2052 n = strnlen(hostname, SM_MAXSTRLEN);
2053 if (n == SM_MAXSTRLEN) {
2054 return;
2055 }
2056 nhp = malloc(sizeof(*nhp) - sizeof(nhp->name) + n + 1);
2057 if (nhp == NULL) {
2058 debuglog("Unable to allocate entry for statd mon\n");
2059 return;
2060 }
2061
2062 /* Allocated new host entry, now fill the fields */
2063 memcpy(nhp->name, hostname, n);
2064 nhp->name[n] = 0;
2065 nhp->refcnt = 1;
2066 debuglog("Locally Monitoring host %16s\n",hostname);
2067
2068 debuglog("Attempting to tell statd\n");
2069
2070 bzero(&smon,sizeof(smon));
2071
2072 smon.mon_id.mon_name = nhp->name;
2073 smon.mon_id.my_id.my_name = "localhost";
2074 smon.mon_id.my_id.my_prog = NLM_PROG;
2075 smon.mon_id.my_id.my_vers = NLM_SM;
2076 smon.mon_id.my_id.my_proc = NLM_SM_NOTIFY;
2077
2078 rpcret = callrpc("localhost", SM_PROG, SM_VERS, SM_MON,
2079 (xdrproc_t)xdr_mon, &smon,
2080 (xdrproc_t)xdr_sm_stat_res, &sres);
2081
2082 if (rpcret == 0) {
2083 if (sres.res_stat == stat_fail) {
2084 debuglog("Statd call failed\n");
2085 statflag = 0;
2086 } else {
2087 statflag = 1;
2088 }
2089 } else {
2090 debuglog("Rpc call to statd failed with return value: %d\n",
2091 rpcret);
2092 statflag = 0;
2093 }
2094
2095 if (statflag == 1) {
2096 LIST_INSERT_HEAD(&hostlst_head, nhp, hostlst);
2097 } else {
2098 free(nhp);
2099 }
2100
2101 }
2102
2103 /*
2104 * unmonitor_lock_host: clear monitor ref counts and inform statd when gone
2105 */
2106 void
unmonitor_lock_host(char * hostname)2107 unmonitor_lock_host(char *hostname)
2108 {
2109 struct host *ihp;
2110 struct mon_id smon_id;
2111 struct sm_stat smstat;
2112 int rpcret;
2113
2114 rpcret = 0;
2115
2116 for( ihp=LIST_FIRST(&hostlst_head); ihp != NULL;
2117 ihp=LIST_NEXT(ihp, hostlst)) {
2118 if (strncmp(hostname, ihp->name, SM_MAXSTRLEN) == 0) {
2119 /* Host is monitored, bump refcount */
2120 --ihp->refcnt;
2121 /* Host should only be in the monitor list once */
2122 break;
2123 }
2124 }
2125
2126 if (ihp == NULL) {
2127 debuglog("Could not find host %16s in mon list\n", hostname);
2128 return;
2129 }
2130
2131 if (ihp->refcnt > 0)
2132 return;
2133
2134 if (ihp->refcnt < 0) {
2135 debuglog("Negative refcount!: %d\n",
2136 ihp->refcnt);
2137 }
2138
2139 debuglog("Attempting to unmonitor host %16s\n", hostname);
2140
2141 bzero(&smon_id,sizeof(smon_id));
2142
2143 smon_id.mon_name = hostname;
2144 smon_id.my_id.my_name = "localhost";
2145 smon_id.my_id.my_prog = NLM_PROG;
2146 smon_id.my_id.my_vers = NLM_SM;
2147 smon_id.my_id.my_proc = NLM_SM_NOTIFY;
2148
2149 rpcret = callrpc("localhost", SM_PROG, SM_VERS, SM_UNMON,
2150 (xdrproc_t)xdr_mon_id, &smon_id,
2151 (xdrproc_t)xdr_sm_stat, &smstat);
2152
2153 if (rpcret != 0) {
2154 debuglog("Rpc call to unmonitor statd failed with "
2155 " return value: %d\n", rpcret);
2156 }
2157
2158 LIST_REMOVE(ihp, hostlst);
2159 free(ihp);
2160 }
2161
2162 /*
2163 * notify: Clear all locks from a host if statd complains
2164 *
2165 * XXX: This routine has not been thoroughly tested. However, neither
2166 * had the old one been. It used to compare the statd crash state counter
2167 * to the current lock state. The upshot of this was that it basically
2168 * cleared all locks from the specified host 99% of the time (with the
2169 * other 1% being a bug). Consequently, the assumption is that clearing
2170 * all locks from a host when notified by statd is acceptable.
2171 *
2172 * Please note that this routine skips the usual level of redirection
2173 * through a do_* type routine. This introduces a possible level of
2174 * error and might better be written as do_notify and take this one out.
2175
2176 */
2177
2178 void
notify(const char * hostname,const int state)2179 notify(const char *hostname, const int state)
2180 {
2181 debuglog("notify from %s, new state %d", hostname, state);
2182
2183 siglock();
2184 do_clear(hostname);
2185 sigunlock();
2186
2187 debuglog("Leaving notify\n");
2188 }
2189
2190 void
send_granted(fl,opcode)2191 send_granted(fl, opcode)
2192 struct file_lock *fl;
2193 int opcode __unused;
2194 {
2195 CLIENT *cli;
2196 static char dummy;
2197 struct timeval timeo;
2198 int success;
2199 static struct nlm_res retval;
2200 static struct nlm4_res retval4;
2201
2202 debuglog("About to send granted on blocked lock\n");
2203
2204 cli = get_client(fl->addr,
2205 (fl->flags & LOCK_V4) ? NLM_VERS4 : NLM_VERS);
2206 if (cli == NULL) {
2207 syslog(LOG_NOTICE, "failed to get CLIENT for %s",
2208 fl->client_name);
2209 /*
2210 * We fail to notify remote that the lock has been granted.
2211 * The client will timeout and retry, the lock will be
2212 * granted at this time.
2213 */
2214 return;
2215 }
2216 timeo.tv_sec = 0;
2217 timeo.tv_usec = (fl->flags & LOCK_ASYNC) ? 0 : 500000; /* 0.5s */
2218
2219 if (fl->flags & LOCK_V4) {
2220 static nlm4_testargs res;
2221 res.cookie = fl->client_cookie;
2222 res.exclusive = fl->client.exclusive;
2223 res.alock.caller_name = fl->client_name;
2224 res.alock.fh.n_len = sizeof(fhandle_t);
2225 res.alock.fh.n_bytes = (char*)&fl->filehandle;
2226 res.alock.oh = fl->client.oh;
2227 res.alock.svid = fl->client.svid;
2228 res.alock.l_offset = fl->client.l_offset;
2229 res.alock.l_len = fl->client.l_len;
2230 debuglog("sending v4 reply%s",
2231 (fl->flags & LOCK_ASYNC) ? " (async)":"");
2232 if (fl->flags & LOCK_ASYNC) {
2233 success = clnt_call(cli, NLM4_GRANTED_MSG,
2234 (xdrproc_t)xdr_nlm4_testargs, &res,
2235 (xdrproc_t)xdr_void, &dummy, timeo);
2236 } else {
2237 success = clnt_call(cli, NLM4_GRANTED,
2238 (xdrproc_t)xdr_nlm4_testargs, &res,
2239 (xdrproc_t)xdr_nlm4_res, &retval4, timeo);
2240 }
2241 } else {
2242 static nlm_testargs res;
2243
2244 res.cookie = fl->client_cookie;
2245 res.exclusive = fl->client.exclusive;
2246 res.alock.caller_name = fl->client_name;
2247 res.alock.fh.n_len = sizeof(fhandle_t);
2248 res.alock.fh.n_bytes = (char*)&fl->filehandle;
2249 res.alock.oh = fl->client.oh;
2250 res.alock.svid = fl->client.svid;
2251 res.alock.l_offset = fl->client.l_offset;
2252 res.alock.l_len = fl->client.l_len;
2253 debuglog("sending v1 reply%s",
2254 (fl->flags & LOCK_ASYNC) ? " (async)":"");
2255 if (fl->flags & LOCK_ASYNC) {
2256 success = clnt_call(cli, NLM_GRANTED_MSG,
2257 (xdrproc_t)xdr_nlm_testargs, &res,
2258 (xdrproc_t)xdr_void, &dummy, timeo);
2259 } else {
2260 success = clnt_call(cli, NLM_GRANTED,
2261 (xdrproc_t)xdr_nlm_testargs, &res,
2262 (xdrproc_t)xdr_nlm_res, &retval, timeo);
2263 }
2264 }
2265 if (debug_level > 2)
2266 debuglog("clnt_call returns %d(%s) for granted",
2267 success, clnt_sperrno(success));
2268
2269 }
2270
2271 /*
2272 * Routines below here have not been modified in the overhaul
2273 */
2274
2275 /*
2276 * Are these two routines still required since lockd is not spawning off
2277 * children to service locks anymore? Presumably they were originally
2278 * put in place to prevent a one child from changing the lock list out
2279 * from under another one.
2280 */
2281
2282 void
siglock(void)2283 siglock(void)
2284 {
2285 sigset_t block;
2286
2287 sigemptyset(&block);
2288 sigaddset(&block, SIGCHLD);
2289
2290 if (sigprocmask(SIG_BLOCK, &block, NULL) < 0) {
2291 syslog(LOG_WARNING, "siglock failed: %s", strerror(errno));
2292 }
2293 }
2294
2295 void
sigunlock(void)2296 sigunlock(void)
2297 {
2298 sigset_t block;
2299
2300 sigemptyset(&block);
2301 sigaddset(&block, SIGCHLD);
2302
2303 if (sigprocmask(SIG_UNBLOCK, &block, NULL) < 0) {
2304 syslog(LOG_WARNING, "sigunlock failed: %s", strerror(errno));
2305 }
2306 }
2307