1 /*
2 * Copyright (c) 2000 Manuel Bouyer.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 * 3. Neither the name of the University nor the names of its contributors
13 * may be used to endorse or promote products derived from this software
14 * without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 *
28 * $NetBSD: lockd_lock.c,v 1.5 2000/11/21 03:47:41 enami Exp $
29 * $FreeBSD: src/usr.sbin/rpc.lockd/lockd_lock.c,v 1.1 2001/03/19 12:50:09 alfred Exp $
30 */
31
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <unistd.h>
35 #include <fcntl.h>
36 #include <syslog.h>
37 #include <errno.h>
38 #include <string.h>
39 #include <signal.h>
40 #include <rpc/rpc.h>
41 #include <sys/types.h>
42 #include <sys/stat.h>
43 #include <sys/socket.h>
44 #include <sys/queue.h>
45 #include <sys/param.h>
46 #include <sys/mount.h>
47 #include <sys/wait.h>
48 #include <rpcsvc/sm_inter.h>
49 #include <rpcsvc/nlm_prot.h>
50 #include "lockd_lock.h"
51 #include "lockd.h"
52
53 /* A set of utilities for managing file locking */
54 LIST_HEAD(lcklst_head, file_lock);
55 struct lcklst_head lcklst_head = LIST_HEAD_INITIALIZER(lcklst_head);
56
57 /* struct describing a lock */
58 struct file_lock {
59 LIST_ENTRY(file_lock) lcklst;
60 fhandle_t filehandle; /* NFS filehandle */
61 struct sockaddr *addr;
62 struct nlm4_holder client; /* lock holder */
63 netobj client_cookie; /* cookie sent by the client */
64 char client_name[128];
65 int nsm_status; /* status from the remote lock manager */
66 int status; /* lock status, see below */
67 int flags; /* lock flags, see lockd_lock.h */
68 pid_t locker; /* pid of the child process trying to get the lock */
69 int fd; /* file descriptor for this lock */
70 };
71
72 /* lock status */
73 #define LKST_LOCKED 1 /* lock is locked */
74 #define LKST_WAITING 2 /* file is already locked by another host */
75 #define LKST_PROCESSING 3 /* child is trying to acquire the lock */
76 #define LKST_DYING 4 /* must dies when we get news from the child */
77
78 void lfree(struct file_lock *);
79 void sigchild_handler(int);
80 enum nlm_stats do_lock(struct file_lock *, int);
81 enum nlm_stats do_unlock(struct file_lock *);
82 void send_granted(struct file_lock *, int);
83 void siglock(void);
84 void sigunlock(void);
85
86 /* list of hosts we monitor */
87 LIST_HEAD(hostlst_head, host);
88 struct hostlst_head hostlst_head = LIST_HEAD_INITIALIZER(hostlst_head);
89
90 /* struct describing a lock */
91 struct host {
92 LIST_ENTRY(host) hostlst;
93 char name[SM_MAXSTRLEN];
94 int refcnt;
95 };
96
97 void do_mon(char *);
98
99 /*
100 * testlock(): inform the caller if the requested lock would be granted or not
101 * returns NULL if lock would granted, or pointer to the current nlm4_holder
102 * otherwise.
103 */
104
105 struct nlm4_holder *
testlock(struct nlm4_lock * lock,int flags)106 testlock(struct nlm4_lock *lock, int flags)
107 {
108 struct file_lock *fl;
109 fhandle_t filehandle;
110
111 /* convert lock to a local filehandle */
112 memcpy(&filehandle, lock->fh.n_bytes, sizeof(filehandle));
113
114 siglock();
115 /* search through the list for lock holder */
116 for (fl = LIST_FIRST(&lcklst_head); fl != NULL;
117 fl = LIST_NEXT(fl, lcklst)) {
118 if (fl->status != LKST_LOCKED)
119 continue;
120 if (memcmp(&fl->filehandle, &filehandle, sizeof(filehandle)))
121 continue;
122 /* got it ! */
123 syslog(LOG_DEBUG, "test for %s: found lock held by %s",
124 lock->caller_name, fl->client_name);
125 sigunlock();
126 return (&fl->client);
127 }
128 /* not found */
129 sigunlock();
130 syslog(LOG_DEBUG, "test for %s: no lock found", lock->caller_name);
131 return NULL;
132 }
133
134 /*
135 * getlock: try to acquire the lock.
136 * If file is already locked and we can sleep, put the lock in the list with
137 * status LKST_WAITING; it'll be processed later.
138 * Otherwise try to lock. If we're allowed to block, fork a child which
139 * will do the blocking lock.
140 */
141 enum nlm_stats
getlock(nlm4_lockargs * lckarg,struct svc_req * rqstp,int flags)142 getlock(nlm4_lockargs *lckarg, struct svc_req *rqstp, int flags)
143 {
144 struct file_lock *fl, *newfl;
145 enum nlm_stats retval;
146
147 if (grace_expired == 0 && lckarg->reclaim == 0)
148 return (flags & LOCK_V4) ?
149 nlm4_denied_grace_period : nlm_denied_grace_period;
150
151 /* allocate new file_lock for this request */
152 newfl = malloc(sizeof(struct file_lock));
153 if (newfl == NULL) {
154 syslog(LOG_NOTICE, "malloc failed: %s", strerror(errno));
155 /* failed */
156 return (flags & LOCK_V4) ?
157 nlm4_denied_nolock : nlm_denied_nolocks;
158 }
159 if (lckarg->alock.fh.n_len != sizeof(fhandle_t)) {
160 syslog(LOG_DEBUG, "received fhandle size %d, local size %d",
161 lckarg->alock.fh.n_len, (int)sizeof(fhandle_t));
162 }
163 memcpy(&newfl->filehandle, lckarg->alock.fh.n_bytes, sizeof(fhandle_t));
164 newfl->addr = (struct sockaddr *)svc_getrpccaller(rqstp->rq_xprt)->buf;
165 newfl->client.exclusive = lckarg->exclusive;
166 newfl->client.svid = lckarg->alock.svid;
167 newfl->client.oh.n_bytes = malloc(lckarg->alock.oh.n_len);
168 if (newfl->client.oh.n_bytes == NULL) {
169 syslog(LOG_NOTICE, "malloc failed: %s", strerror(errno));
170 free(newfl);
171 return (flags & LOCK_V4) ?
172 nlm4_denied_nolock : nlm_denied_nolocks;
173 }
174 newfl->client.oh.n_len = lckarg->alock.oh.n_len;
175 memcpy(newfl->client.oh.n_bytes, lckarg->alock.oh.n_bytes,
176 lckarg->alock.oh.n_len);
177 newfl->client.l_offset = lckarg->alock.l_offset;
178 newfl->client.l_len = lckarg->alock.l_len;
179 newfl->client_cookie.n_len = lckarg->cookie.n_len;
180 newfl->client_cookie.n_bytes = malloc(lckarg->cookie.n_len);
181 if (newfl->client_cookie.n_bytes == NULL) {
182 syslog(LOG_NOTICE, "malloc failed: %s", strerror(errno));
183 free(newfl->client.oh.n_bytes);
184 free(newfl);
185 return (flags & LOCK_V4) ?
186 nlm4_denied_nolock : nlm_denied_nolocks;
187 }
188 memcpy(newfl->client_cookie.n_bytes, lckarg->cookie.n_bytes,
189 lckarg->cookie.n_len);
190 strncpy(newfl->client_name, lckarg->alock.caller_name, 128);
191 newfl->nsm_status = lckarg->state;
192 newfl->status = 0;
193 newfl->flags = flags;
194 siglock();
195 /* look for a lock rq from this host for this fh */
196 for (fl = LIST_FIRST(&lcklst_head); fl != NULL;
197 fl = LIST_NEXT(fl, lcklst)) {
198 if (memcmp(&newfl->filehandle, &fl->filehandle,
199 sizeof(fhandle_t)) == 0) {
200 if (strcmp(newfl->client_name, fl->client_name) == 0 &&
201 newfl->client.svid == fl->client.svid) {
202 /* already locked by this host ??? */
203 sigunlock();
204 syslog(LOG_NOTICE, "duplicate lock from %s",
205 newfl->client_name);
206 lfree(newfl);
207 switch(fl->status) {
208 case LKST_LOCKED:
209 return (flags & LOCK_V4) ?
210 nlm4_granted : nlm_granted;
211 case LKST_WAITING:
212 case LKST_PROCESSING:
213 return (flags & LOCK_V4) ?
214 nlm4_blocked : nlm_blocked;
215 case LKST_DYING:
216 return (flags & LOCK_V4) ?
217 nlm4_denied : nlm_denied;
218 default:
219 syslog(LOG_NOTICE, "bad status %d",
220 fl->status);
221 return (flags & LOCK_V4) ?
222 nlm4_failed : nlm_denied;
223 }
224 }
225 /*
226 * We already have a lock for this file. Put this one
227 * in waiting state if allowed to block
228 */
229 if (lckarg->block) {
230 syslog(LOG_DEBUG, "lock from %s: already "
231 "locked, waiting",
232 lckarg->alock.caller_name);
233 newfl->status = LKST_WAITING;
234 LIST_INSERT_HEAD(&lcklst_head, newfl, lcklst);
235 do_mon(lckarg->alock.caller_name);
236 sigunlock();
237 return (flags & LOCK_V4) ?
238 nlm4_blocked : nlm_blocked;
239 } else {
240 sigunlock();
241 syslog(LOG_DEBUG, "lock from %s: already "
242 "locked, failed",
243 lckarg->alock.caller_name);
244 lfree(newfl);
245 return (flags & LOCK_V4) ?
246 nlm4_denied : nlm_denied;
247 }
248 }
249 }
250 /* no entry for this file yet; add to list */
251 LIST_INSERT_HEAD(&lcklst_head, newfl, lcklst);
252 /* do the lock */
253 retval = do_lock(newfl, lckarg->block);
254 switch (retval) {
255 case nlm4_granted:
256 /* case nlm_granted: is the same as nlm4_granted */
257 case nlm4_blocked:
258 /* case nlm_blocked: is the same as nlm4_blocked */
259 do_mon(lckarg->alock.caller_name);
260 break;
261 default:
262 lfree(newfl);
263 break;
264 }
265 sigunlock();
266 return retval;
267 }
268
269 /* unlock a filehandle */
270 enum nlm_stats
unlock(nlm4_lock * lck,int flags)271 unlock(nlm4_lock *lck, int flags)
272 {
273 struct file_lock *fl;
274 fhandle_t filehandle;
275 int err = (flags & LOCK_V4) ? nlm4_granted : nlm_granted;
276
277 memcpy(&filehandle, lck->fh.n_bytes, sizeof(fhandle_t));
278 siglock();
279 for (fl = LIST_FIRST(&lcklst_head); fl != NULL;
280 fl = LIST_NEXT(fl, lcklst)) {
281 if (strcmp(fl->client_name, lck->caller_name) ||
282 memcmp(&filehandle, &fl->filehandle, sizeof(fhandle_t)) ||
283 fl->client.oh.n_len != lck->oh.n_len ||
284 memcmp(fl->client.oh.n_bytes, lck->oh.n_bytes,
285 fl->client.oh.n_len) != 0 ||
286 fl->client.svid != lck->svid)
287 continue;
288 /* Got it, unlock and remove from the queue */
289 syslog(LOG_DEBUG, "unlock from %s: found struct, status %d",
290 lck->caller_name, fl->status);
291 switch (fl->status) {
292 case LKST_LOCKED:
293 err = do_unlock(fl);
294 break;
295 case LKST_WAITING:
296 /* remove from the list */
297 LIST_REMOVE(fl, lcklst);
298 lfree(fl);
299 break;
300 case LKST_PROCESSING:
301 /*
302 * being handled by a child; will clean up
303 * when the child exits
304 */
305 fl->status = LKST_DYING;
306 break;
307 case LKST_DYING:
308 /* nothing to do */
309 break;
310 default:
311 syslog(LOG_NOTICE, "unknown status %d for %s",
312 fl->status, fl->client_name);
313 }
314 sigunlock();
315 return err;
316 }
317 sigunlock();
318 /* didn't find a matching entry; log anyway */
319 syslog(LOG_NOTICE, "no matching entry for %s",
320 lck->caller_name);
321 return (flags & LOCK_V4) ? nlm4_granted : nlm_granted;
322 }
323
324 void
lfree(struct file_lock * fl)325 lfree(struct file_lock *fl)
326 {
327 free(fl->client.oh.n_bytes);
328 free(fl->client_cookie.n_bytes);
329 free(fl);
330 }
331
332 void
sigchild_handler(int sig)333 sigchild_handler(int sig)
334 {
335 int status;
336 pid_t pid;
337 struct file_lock *fl;
338
339 while (1) {
340 pid = wait4(-1, &status, WNOHANG, NULL);
341 if (pid == -1) {
342 if (errno != ECHILD)
343 syslog(LOG_NOTICE, "wait failed: %s",
344 strerror(errno));
345 else
346 syslog(LOG_DEBUG, "wait failed: %s",
347 strerror(errno));
348 return;
349 }
350 if (pid == 0) {
351 /* no more child to handle yet */
352 return;
353 }
354 /*
355 * if we're here we have a child that exited
356 * Find the associated file_lock.
357 */
358 for (fl = LIST_FIRST(&lcklst_head); fl != NULL;
359 fl = LIST_NEXT(fl, lcklst)) {
360 if (pid == fl->locker)
361 break;
362 }
363 if (pid != fl->locker) {
364 syslog(LOG_NOTICE, "unknown child %d", pid);
365 } else {
366 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
367 syslog(LOG_NOTICE, "child %d failed", pid);
368 /*
369 * can't do much here; we can't reply
370 * anything but OK for blocked locks
371 * Eventually the client will time out
372 * and retry.
373 */
374 do_unlock(fl);
375 return;
376 }
377
378 /* check lock status */
379 syslog(LOG_DEBUG, "processing child %d, status %d",
380 pid, fl->status);
381 switch(fl->status) {
382 case LKST_PROCESSING:
383 fl->status = LKST_LOCKED;
384 send_granted(fl, (fl->flags & LOCK_V4) ?
385 nlm4_granted : nlm_granted);
386 break;
387 case LKST_DYING:
388 do_unlock(fl);
389 break;
390 default:
391 syslog(LOG_NOTICE, "bad lock status (%d) for"
392 " child %d", fl->status, pid);
393 }
394 }
395 }
396 }
397
398 /*
399 *
400 * try to acquire the lock described by fl. Eventually fock a child to do a
401 * blocking lock if allowed and required.
402 */
403
404 enum nlm_stats
do_lock(struct file_lock * fl,int block)405 do_lock(struct file_lock *fl, int block)
406 {
407 int lflags, error;
408 struct stat st;
409
410 fl->fd = fhopen(&fl->filehandle, O_RDWR);
411 if (fl->fd < 0) {
412 switch (errno) {
413 case ESTALE:
414 error = nlm4_stale_fh;
415 break;
416 case EROFS:
417 error = nlm4_rofs;
418 break;
419 default:
420 error = nlm4_failed;
421 }
422 if ((fl->flags & LOCK_V4) == 0)
423 error = nlm_denied;
424 syslog(LOG_NOTICE, "fhopen failed (from %s): %s",
425 fl->client_name, strerror(errno));
426 LIST_REMOVE(fl, lcklst);
427 return error;
428 }
429 if (fstat(fl->fd, &st) < 0) {
430 syslog(LOG_NOTICE, "fstat failed (from %s): %s",
431 fl->client_name, strerror(errno));
432 }
433 syslog(LOG_DEBUG, "lock from %s for file%s%s: dev %d ino %ju (uid %d), "
434 "flags %d",
435 fl->client_name, fl->client.exclusive ? " (exclusive)":"",
436 block ? " (block)":"",
437 st.st_dev, (uintmax_t)st.st_ino, st.st_uid, fl->flags);
438 lflags = LOCK_NB;
439 if (fl->client.exclusive == 0)
440 lflags |= LOCK_SH;
441 else
442 lflags |= LOCK_EX;
443 error = flock(fl->fd, lflags);
444 if (error != 0 && errno == EAGAIN && block) {
445 switch (fl->locker = fork()) {
446 case -1: /* fork failed */
447 syslog(LOG_NOTICE, "fork failed: %s", strerror(errno));
448 LIST_REMOVE(fl, lcklst);
449 close(fl->fd);
450 return (fl->flags & LOCK_V4) ?
451 nlm4_denied_nolock : nlm_denied_nolocks;
452 case 0:
453 /*
454 * Attempt a blocking lock. Will have to call
455 * NLM_GRANTED later.
456 */
457 setproctitle("%s", fl->client_name);
458 lflags &= ~LOCK_NB;
459 if(flock(fl->fd, lflags) != 0) {
460 syslog(LOG_NOTICE, "flock failed: %s",
461 strerror(errno));
462 exit(-1);
463 }
464 /* lock granted */
465 exit(0);
466 default:
467 syslog(LOG_DEBUG, "lock request from %s: forked %d",
468 fl->client_name, fl->locker);
469 fl->status = LKST_PROCESSING;
470 return (fl->flags & LOCK_V4) ?
471 nlm4_blocked : nlm_blocked;
472 }
473 }
474 /* non block case */
475 if (error != 0) {
476 switch (errno) {
477 case EAGAIN:
478 error = nlm4_denied;
479 break;
480 case ESTALE:
481 error = nlm4_stale_fh;
482 break;
483 case EROFS:
484 error = nlm4_rofs;
485 break;
486 default:
487 error = nlm4_failed;
488 }
489 if ((fl->flags & LOCK_V4) == 0)
490 error = nlm_denied;
491 if (errno != EAGAIN)
492 syslog(LOG_NOTICE, "flock for %s failed: %s",
493 fl->client_name, strerror(errno));
494 else syslog(LOG_DEBUG, "flock for %s failed: %s",
495 fl->client_name, strerror(errno));
496 LIST_REMOVE(fl, lcklst);
497 close(fl->fd);
498 return error;
499 }
500 fl->status = LKST_LOCKED;
501 return (fl->flags & LOCK_V4) ? nlm4_granted : nlm_granted;
502 }
503
504 void
send_granted(struct file_lock * fl,int opcode)505 send_granted(struct file_lock *fl, int opcode)
506 {
507 CLIENT *cli;
508 static char dummy;
509 struct timeval timeo;
510 int success;
511 static struct nlm_res retval;
512 static struct nlm4_res retval4;
513
514 cli = get_client(fl->addr,
515 (fl->flags & LOCK_V4) ? NLM_VERS4 : NLM_VERS);
516 if (cli == NULL) {
517 syslog(LOG_NOTICE, "failed to get CLIENT for %s",
518 fl->client_name);
519 /*
520 * We fail to notify remote that the lock has been granted.
521 * The client will timeout and retry, the lock will be
522 * granted at this time.
523 */
524 return;
525 }
526 timeo.tv_sec = 0;
527 timeo.tv_usec = (fl->flags & LOCK_ASYNC) ? 0 : 500000; /* 0.5s */
528
529 if (fl->flags & LOCK_V4) {
530 static nlm4_testargs res;
531 res.cookie = fl->client_cookie;
532 res.exclusive = fl->client.exclusive;
533 res.alock.caller_name = fl->client_name;
534 res.alock.fh.n_len = sizeof(fhandle_t);
535 res.alock.fh.n_bytes = (char*)&fl->filehandle;
536 res.alock.oh = fl->client.oh;
537 res.alock.svid = fl->client.svid;
538 res.alock.l_offset = fl->client.l_offset;
539 res.alock.l_len = fl->client.l_len;
540 syslog(LOG_DEBUG, "sending v4 reply%s",
541 (fl->flags & LOCK_ASYNC) ? " (async)":"");
542 if (fl->flags & LOCK_ASYNC) {
543 success = clnt_call(cli, NLM4_GRANTED_MSG,
544 (xdrproc_t)xdr_nlm4_testargs, &res,
545 (xdrproc_t)xdr_void, &dummy, timeo);
546 } else {
547 success = clnt_call(cli, NLM4_GRANTED,
548 (xdrproc_t)xdr_nlm4_testargs, &res,
549 (xdrproc_t)xdr_nlm4_res, &retval4, timeo);
550 }
551 } else {
552 static nlm_testargs res;
553
554 res.cookie = fl->client_cookie;
555 res.exclusive = fl->client.exclusive;
556 res.alock.caller_name = fl->client_name;
557 res.alock.fh.n_len = sizeof(fhandle_t);
558 res.alock.fh.n_bytes = (char*)&fl->filehandle;
559 res.alock.oh = fl->client.oh;
560 res.alock.svid = fl->client.svid;
561 res.alock.l_offset = fl->client.l_offset;
562 res.alock.l_len = fl->client.l_len;
563 syslog(LOG_DEBUG, "sending v1 reply%s",
564 (fl->flags & LOCK_ASYNC) ? " (async)":"");
565 if (fl->flags & LOCK_ASYNC) {
566 success = clnt_call(cli, NLM_GRANTED_MSG,
567 (xdrproc_t)xdr_nlm_testargs, &res,
568 (xdrproc_t)xdr_void, &dummy, timeo);
569 } else {
570 success = clnt_call(cli, NLM_GRANTED,
571 (xdrproc_t)xdr_nlm_testargs, &res,
572 (xdrproc_t)xdr_nlm_res, &retval, timeo);
573 }
574 }
575 if (debug_level > 2)
576 syslog(LOG_DEBUG, "clnt_call returns %d(%s) for granted",
577 success, clnt_sperrno(success));
578
579 }
580
581 enum nlm_stats
do_unlock(struct file_lock * rfl)582 do_unlock(struct file_lock *rfl)
583 {
584 struct file_lock *fl;
585 int error;
586 int lockst;
587
588 /* unlock the file: closing is enough! */
589 if (close(rfl->fd) < 0) {
590 if (errno == ESTALE)
591 error = nlm4_stale_fh;
592 else
593 error = nlm4_failed;
594 if ((rfl->flags & LOCK_V4) == 0)
595 error = nlm_denied;
596 syslog(LOG_NOTICE,
597 "close failed (from %s): %s",
598 rfl->client_name, strerror(errno));
599 } else {
600 error = (rfl->flags & LOCK_V4) ?
601 nlm4_granted : nlm_granted;
602 }
603 LIST_REMOVE(rfl, lcklst);
604
605 /* process the next LKST_WAITING lock request for this fh */
606 for (fl = LIST_FIRST(&lcklst_head); fl != NULL;
607 fl = LIST_NEXT(fl, lcklst)) {
608 if (fl->status != LKST_WAITING ||
609 memcmp(&rfl->filehandle, &fl->filehandle,
610 sizeof(fhandle_t)) != 0)
611 continue;
612
613 lockst = do_lock(fl, 1); /* If it's LKST_WAITING we can block */
614 switch (lockst) {
615 case nlm4_granted:
616 /* case nlm_granted: same as nlm4_granted */
617 send_granted(fl, (fl->flags & LOCK_V4) ?
618 nlm4_granted : nlm_granted);
619 break;
620 case nlm4_blocked:
621 /* case nlm_blocked: same as nlm4_blocked */
622 break;
623 default:
624 lfree(fl);
625 break;
626 }
627 break;
628 }
629 return error;
630 }
631
632 void
siglock(void)633 siglock(void)
634 {
635 sigset_t block;
636
637 sigemptyset(&block);
638 sigaddset(&block, SIGCHLD);
639
640 if (sigprocmask(SIG_BLOCK, &block, NULL) < 0) {
641 syslog(LOG_WARNING, "siglock failed: %s", strerror(errno));
642 }
643 }
644
645 void
sigunlock(void)646 sigunlock(void)
647 {
648 sigset_t block;
649
650 sigemptyset(&block);
651 sigaddset(&block, SIGCHLD);
652
653 if (sigprocmask(SIG_UNBLOCK, &block, NULL) < 0) {
654 syslog(LOG_WARNING, "sigunlock failed: %s", strerror(errno));
655 }
656 }
657
658 /* monitor a host through rpc.statd, and keep a ref count */
659 void
do_mon(char * hostname)660 do_mon(char *hostname)
661 {
662 struct host *hp;
663 struct mon my_mon;
664 struct sm_stat_res res;
665 int retval;
666
667 for (hp = LIST_FIRST(&hostlst_head); hp != NULL;
668 hp = LIST_NEXT(hp, hostlst)) {
669 if (strcmp(hostname, hp->name) == 0) {
670 /* already monitored, just bump refcnt */
671 hp->refcnt++;
672 return;
673 }
674 }
675 /* not found, have to create an entry for it */
676 hp = malloc(sizeof(struct host));
677 strncpy(hp->name, hostname, SM_MAXSTRLEN);
678 hp->refcnt = 1;
679 syslog(LOG_DEBUG, "monitoring host %s",
680 hostname);
681 memset(&my_mon, 0, sizeof(my_mon));
682 my_mon.mon_id.mon_name = hp->name;
683 my_mon.mon_id.my_id.my_name = "localhost";
684 my_mon.mon_id.my_id.my_prog = NLM_PROG;
685 my_mon.mon_id.my_id.my_vers = NLM_SM;
686 my_mon.mon_id.my_id.my_proc = NLM_SM_NOTIFY;
687 if ((retval =
688 callrpc("localhost", SM_PROG, SM_VERS, SM_MON, (xdrproc_t)xdr_mon,
689 (char*)&my_mon, (xdrproc_t)xdr_sm_stat_res, (char*)&res)) != 0) {
690 syslog(LOG_WARNING, "rpc to statd failed: %s",
691 clnt_sperrno((enum clnt_stat)retval));
692 free(hp);
693 return;
694 }
695 if (res.res_stat == stat_fail) {
696 syslog(LOG_WARNING, "statd failed");
697 free(hp);
698 return;
699 }
700 LIST_INSERT_HEAD(&hostlst_head, hp, hostlst);
701 }
702
703 void
notify(const char * hostname,int state)704 notify(const char *hostname, int state)
705 {
706 struct file_lock *fl, *next_fl;
707 int err;
708 syslog(LOG_DEBUG, "notify from %s, new state %d", hostname, state);
709 /* search all lock for this host; if status changed, release the lock */
710 siglock();
711 for (fl = LIST_FIRST(&lcklst_head); fl != NULL; fl = next_fl) {
712 next_fl = LIST_NEXT(fl, lcklst);
713 if (strcmp(hostname, fl->client_name) == 0 &&
714 fl->nsm_status != state) {
715 syslog(LOG_DEBUG, "state %d, nsm_state %d, unlocking",
716 fl->status, fl->nsm_status);
717 switch(fl->status) {
718 case LKST_LOCKED:
719 err = do_unlock(fl);
720 if (err != nlm_granted)
721 syslog(LOG_DEBUG,
722 "notify: unlock failed for %s (%d)",
723 hostname, err);
724 break;
725 case LKST_WAITING:
726 LIST_REMOVE(fl, lcklst);
727 lfree(fl);
728 break;
729 case LKST_PROCESSING:
730 fl->status = LKST_DYING;
731 break;
732 case LKST_DYING:
733 break;
734 default:
735 syslog(LOG_NOTICE, "unknown status %d for %s",
736 fl->status, fl->client_name);
737 }
738 }
739 }
740 sigunlock();
741 }
742