usr.sbin/rpc.lockd/lockd_lock.c

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