The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/nlm/nlm_prot_impl.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 2008 Isilon Inc http://www.isilon.com/
    3  * Authors: Doug Rabson <dfr@rabson.org>
    4  * Developed with Red Inc: Alfred Perlstein <alfred@freebsd.org>
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions
    8  * are met:
    9  * 1. Redistributions of source code must retain the above copyright
   10  *    notice, this list of conditions and the following disclaimer.
   11  * 2. Redistributions in binary form must reproduce the above copyright
   12  *    notice, this list of conditions and the following disclaimer in the
   13  *    documentation and/or other materials provided with the distribution.
   14  *
   15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   25  * SUCH DAMAGE.
   26  */
   27 
   28 #include "opt_inet6.h"
   29 
   30 #include <sys/cdefs.h>
   31 __FBSDID("$FreeBSD: releng/9.2/sys/nlm/nlm_prot_impl.c 248085 2013-03-09 02:36:32Z marius $");
   32 
   33 #include <sys/param.h>
   34 #include <sys/fail.h>
   35 #include <sys/fcntl.h>
   36 #include <sys/kernel.h>
   37 #include <sys/kthread.h>
   38 #include <sys/lockf.h>
   39 #include <sys/malloc.h>
   40 #include <sys/mount.h>
   41 #if __FreeBSD_version >= 700000
   42 #include <sys/priv.h>
   43 #endif
   44 #include <sys/proc.h>
   45 #include <sys/socket.h>
   46 #include <sys/socketvar.h>
   47 #include <sys/syscall.h>
   48 #include <sys/sysctl.h>
   49 #include <sys/sysent.h>
   50 #include <sys/syslog.h>
   51 #include <sys/sysproto.h>
   52 #include <sys/systm.h>
   53 #include <sys/taskqueue.h>
   54 #include <sys/unistd.h>
   55 #include <sys/vnode.h>
   56 
   57 #include <nfs/nfsproto.h>
   58 #include <nfs/nfs_lock.h>
   59 
   60 #include <nlm/nlm_prot.h>
   61 #include <nlm/sm_inter.h>
   62 #include <nlm/nlm.h>
   63 #include <rpc/rpc_com.h>
   64 #include <rpc/rpcb_prot.h>
   65 
   66 MALLOC_DEFINE(M_NLM, "NLM", "Network Lock Manager");
   67 
   68 /*
   69  * If a host is inactive (and holds no locks) for this amount of
   70  * seconds, we consider it idle and stop tracking it.
   71  */
   72 #define NLM_IDLE_TIMEOUT        30
   73 
   74 /*
   75  * We check the host list for idle every few seconds.
   76  */
   77 #define NLM_IDLE_PERIOD         5
   78 
   79 /*
   80  * We only look for GRANTED_RES messages for a little while.
   81  */
   82 #define NLM_EXPIRE_TIMEOUT      10
   83 
   84 /*
   85  * Support for sysctl vfs.nlm.sysid
   86  */
   87 static SYSCTL_NODE(_vfs, OID_AUTO, nlm, CTLFLAG_RW, NULL,
   88     "Network Lock Manager");
   89 static SYSCTL_NODE(_vfs_nlm, OID_AUTO, sysid, CTLFLAG_RW, NULL, "");
   90 
   91 /*
   92  * Syscall hooks
   93  */
   94 static int nlm_syscall_offset = SYS_nlm_syscall;
   95 static struct sysent nlm_syscall_prev_sysent;
   96 #if __FreeBSD_version < 700000
   97 static struct sysent nlm_syscall_sysent = {
   98         (sizeof(struct nlm_syscall_args) / sizeof(register_t)) | SYF_MPSAFE,
   99         (sy_call_t *) nlm_syscall
  100 };
  101 #else
  102 MAKE_SYSENT(nlm_syscall);
  103 #endif
  104 static bool_t nlm_syscall_registered = FALSE;
  105 
  106 /*
  107  * Debug level passed in from userland. We also support a sysctl hook
  108  * so that it can be changed on a live system.
  109  */
  110 static int nlm_debug_level;
  111 SYSCTL_INT(_debug, OID_AUTO, nlm_debug, CTLFLAG_RW, &nlm_debug_level, 0, "");
  112 
  113 #define NLM_DEBUG(_level, args...)                      \
  114         do {                                            \
  115                 if (nlm_debug_level >= (_level))        \
  116                         log(LOG_DEBUG, args);           \
  117         } while(0)
  118 #define NLM_ERR(args...)                        \
  119         do {                                    \
  120                 log(LOG_ERR, args);             \
  121         } while(0)
  122 
  123 /*
  124  * Grace period handling. The value of nlm_grace_threshold is the
  125  * value of time_uptime after which we are serving requests normally.
  126  */
  127 static time_t nlm_grace_threshold;
  128 
  129 /*
  130  * We check for idle hosts if time_uptime is greater than
  131  * nlm_next_idle_check,
  132  */
  133 static time_t nlm_next_idle_check;
  134 
  135 /*
  136  * A socket to use for RPC - shared by all IPv4 RPC clients.
  137  */
  138 static struct socket *nlm_socket;
  139 
  140 #ifdef INET6
  141 
  142 /*
  143  * A socket to use for RPC - shared by all IPv6 RPC clients.
  144  */
  145 static struct socket *nlm_socket6;
  146 
  147 #endif
  148 
  149 /*
  150  * An RPC client handle that can be used to communicate with the local
  151  * NSM.
  152  */
  153 static CLIENT *nlm_nsm;
  154 
  155 /*
  156  * An AUTH handle for the server's creds.
  157  */
  158 static AUTH *nlm_auth;
  159 
  160 /*
  161  * A zero timeval for sending async RPC messages.
  162  */
  163 struct timeval nlm_zero_tv = { 0, 0 };
  164 
  165 /*
  166  * The local NSM state number
  167  */
  168 int nlm_nsm_state;
  169 
  170 
  171 /*
  172  * A lock to protect the host list and waiting lock list.
  173  */
  174 static struct mtx nlm_global_lock;
  175 
  176 /*
  177  * Locks:
  178  * (l)          locked by nh_lock
  179  * (s)          only accessed via server RPC which is single threaded
  180  * (g)          locked by nlm_global_lock
  181  * (c)          const until freeing
  182  * (a)          modified using atomic ops
  183  */
  184 
  185 /*
  186  * A pending client-side lock request, stored on the nlm_waiting_locks
  187  * list.
  188  */
  189 struct nlm_waiting_lock {
  190         TAILQ_ENTRY(nlm_waiting_lock) nw_link; /* (g) */
  191         bool_t          nw_waiting;            /* (g) */
  192         nlm4_lock       nw_lock;               /* (c) */
  193         union nfsfh     nw_fh;                 /* (c) */
  194         struct vnode    *nw_vp;                /* (c) */
  195 };
  196 TAILQ_HEAD(nlm_waiting_lock_list, nlm_waiting_lock);
  197 
  198 struct nlm_waiting_lock_list nlm_waiting_locks; /* (g) */
  199 
  200 /*
  201  * A pending server-side asynchronous lock request, stored on the
  202  * nh_pending list of the NLM host.
  203  */
  204 struct nlm_async_lock {
  205         TAILQ_ENTRY(nlm_async_lock) af_link; /* (l) host's list of locks */
  206         struct task     af_task;        /* (c) async callback details */
  207         void            *af_cookie;     /* (l) lock manager cancel token */
  208         struct vnode    *af_vp;         /* (l) vnode to lock */
  209         struct flock    af_fl;          /* (c) lock details */
  210         struct nlm_host *af_host;       /* (c) host which is locking */
  211         CLIENT          *af_rpc;        /* (c) rpc client to send message */
  212         nlm4_testargs   af_granted;     /* (c) notification details */
  213         time_t          af_expiretime;  /* (c) notification time */
  214 };
  215 TAILQ_HEAD(nlm_async_lock_list, nlm_async_lock);
  216 
  217 /*
  218  * NLM host.
  219  */
  220 enum nlm_host_state {
  221         NLM_UNMONITORED,
  222         NLM_MONITORED,
  223         NLM_MONITOR_FAILED,
  224         NLM_RECOVERING
  225 };
  226 
  227 struct nlm_rpc {
  228         CLIENT          *nr_client;    /* (l) RPC client handle */
  229         time_t          nr_create_time; /* (l) when client was created */
  230 };
  231 
  232 struct nlm_host {
  233         struct mtx      nh_lock;
  234         volatile u_int  nh_refs;       /* (a) reference count */
  235         TAILQ_ENTRY(nlm_host) nh_link; /* (g) global list of hosts */
  236         char            nh_caller_name[MAXNAMELEN]; /* (c) printable name of host */
  237         uint32_t        nh_sysid;        /* (c) our allocaed system ID */
  238         char            nh_sysid_string[10]; /* (c) string rep. of sysid */
  239         struct sockaddr_storage nh_addr; /* (s) remote address of host */
  240         struct nlm_rpc  nh_srvrpc;       /* (l) RPC for server replies */
  241         struct nlm_rpc  nh_clntrpc;      /* (l) RPC for client requests */
  242         rpcvers_t       nh_vers;         /* (s) NLM version of host */
  243         int             nh_state;        /* (s) last seen NSM state of host */
  244         enum nlm_host_state nh_monstate; /* (l) local NSM monitoring state */
  245         time_t          nh_idle_timeout; /* (s) Time at which host is idle */
  246         struct sysctl_ctx_list nh_sysctl; /* (c) vfs.nlm.sysid nodes */
  247         uint32_t        nh_grantcookie;  /* (l) grant cookie counter */
  248         struct nlm_async_lock_list nh_pending; /* (l) pending async locks */
  249         struct nlm_async_lock_list nh_granted; /* (l) granted locks */
  250         struct nlm_async_lock_list nh_finished; /* (l) finished async locks */
  251 };
  252 TAILQ_HEAD(nlm_host_list, nlm_host);
  253 
  254 static struct nlm_host_list nlm_hosts; /* (g) */
  255 static uint32_t nlm_next_sysid = 1;    /* (g) */
  256 
  257 static void     nlm_host_unmonitor(struct nlm_host *);
  258 
  259 struct nlm_grantcookie {
  260         uint32_t        ng_sysid;
  261         uint32_t        ng_cookie;
  262 };
  263 
  264 static inline uint32_t
  265 ng_sysid(struct netobj *src)
  266 {
  267 
  268         return ((struct nlm_grantcookie *)src->n_bytes)->ng_sysid;
  269 }
  270 
  271 static inline uint32_t
  272 ng_cookie(struct netobj *src)
  273 {
  274 
  275         return ((struct nlm_grantcookie *)src->n_bytes)->ng_cookie;
  276 }
  277 
  278 /**********************************************************************/
  279 
  280 /*
  281  * Initialise NLM globals.
  282  */
  283 static void
  284 nlm_init(void *dummy)
  285 {
  286         int error;
  287 
  288         mtx_init(&nlm_global_lock, "nlm_global_lock", NULL, MTX_DEF);
  289         TAILQ_INIT(&nlm_waiting_locks);
  290         TAILQ_INIT(&nlm_hosts);
  291 
  292         error = syscall_register(&nlm_syscall_offset, &nlm_syscall_sysent,
  293             &nlm_syscall_prev_sysent);
  294         if (error)
  295                 NLM_ERR("Can't register NLM syscall\n");
  296         else
  297                 nlm_syscall_registered = TRUE;
  298 }
  299 SYSINIT(nlm_init, SI_SUB_LOCK, SI_ORDER_FIRST, nlm_init, NULL);
  300 
  301 static void
  302 nlm_uninit(void *dummy)
  303 {
  304 
  305         if (nlm_syscall_registered)
  306                 syscall_deregister(&nlm_syscall_offset,
  307                     &nlm_syscall_prev_sysent);
  308 }
  309 SYSUNINIT(nlm_uninit, SI_SUB_LOCK, SI_ORDER_FIRST, nlm_uninit, NULL);
  310 
  311 /*
  312  * Create a netobj from an arbitrary source.
  313  */
  314 void
  315 nlm_make_netobj(struct netobj *dst, caddr_t src, size_t srcsize,
  316     struct malloc_type *type)
  317 {
  318 
  319         dst->n_len = srcsize;
  320         dst->n_bytes = malloc(srcsize, type, M_WAITOK);
  321         memcpy(dst->n_bytes, src, srcsize);
  322 }
  323 
  324 /*
  325  * Copy a struct netobj.
  326  */ 
  327 void
  328 nlm_copy_netobj(struct netobj *dst, struct netobj *src,
  329     struct malloc_type *type)
  330 {
  331 
  332         nlm_make_netobj(dst, src->n_bytes, src->n_len, type);
  333 }
  334 
  335 
  336 /*
  337  * Create an RPC client handle for the given (address,prog,vers)
  338  * triple using UDP.
  339  */
  340 static CLIENT *
  341 nlm_get_rpc(struct sockaddr *sa, rpcprog_t prog, rpcvers_t vers)
  342 {
  343         char *wchan = "nlmrcv";
  344         const char* protofmly;
  345         struct sockaddr_storage ss;
  346         struct socket *so;
  347         CLIENT *rpcb;
  348         struct timeval timo;
  349         RPCB parms;
  350         char *uaddr;
  351         enum clnt_stat stat = RPC_SUCCESS;
  352         int rpcvers = RPCBVERS4;
  353         bool_t do_tcp = FALSE;
  354         bool_t tryagain = FALSE;
  355         struct portmap mapping;
  356         u_short port = 0;
  357 
  358         /*
  359          * First we need to contact the remote RPCBIND service to find
  360          * the right port.
  361          */
  362         memcpy(&ss, sa, sa->sa_len);
  363         switch (ss.ss_family) {
  364         case AF_INET:
  365                 ((struct sockaddr_in *)&ss)->sin_port = htons(111);
  366                 protofmly = "inet";
  367                 so = nlm_socket;
  368                 break;
  369                 
  370 #ifdef INET6
  371         case AF_INET6:
  372                 ((struct sockaddr_in6 *)&ss)->sin6_port = htons(111);
  373                 protofmly = "inet6";
  374                 so = nlm_socket6;
  375                 break;
  376 #endif
  377 
  378         default:
  379                 /*
  380                  * Unsupported address family - fail.
  381                  */
  382                 return (NULL);
  383         }
  384 
  385         rpcb = clnt_dg_create(so, (struct sockaddr *)&ss,
  386             RPCBPROG, rpcvers, 0, 0);
  387         if (!rpcb)
  388                 return (NULL);
  389 
  390 try_tcp:
  391         parms.r_prog = prog;
  392         parms.r_vers = vers;
  393         if (do_tcp)
  394                 parms.r_netid = "tcp";
  395         else
  396                 parms.r_netid = "udp";
  397         parms.r_addr = "";
  398         parms.r_owner = "";
  399 
  400         /*
  401          * Use the default timeout.
  402          */
  403         timo.tv_sec = 25;
  404         timo.tv_usec = 0;
  405 again:
  406         switch (rpcvers) {
  407         case RPCBVERS4:
  408         case RPCBVERS:
  409                 /*
  410                  * Try RPCBIND 4 then 3.
  411                  */
  412                 uaddr = NULL;
  413                 stat = CLNT_CALL(rpcb, (rpcprog_t) RPCBPROC_GETADDR,
  414                     (xdrproc_t) xdr_rpcb, &parms,
  415                     (xdrproc_t) xdr_wrapstring, &uaddr, timo);
  416                 if (stat == RPC_SUCCESS) {
  417                         /*
  418                          * We have a reply from the remote RPCBIND - turn it
  419                          * into an appropriate address and make a new client
  420                          * that can talk to the remote NLM.
  421                          *
  422                          * XXX fixup IPv6 scope ID.
  423                          */
  424                         struct netbuf *a;
  425                         a = __rpc_uaddr2taddr_af(ss.ss_family, uaddr);
  426                         if (!a) {
  427                                 tryagain = TRUE;
  428                         } else {
  429                                 tryagain = FALSE;
  430                                 memcpy(&ss, a->buf, a->len);
  431                                 free(a->buf, M_RPC);
  432                                 free(a, M_RPC);
  433                                 xdr_free((xdrproc_t) xdr_wrapstring, &uaddr);
  434                         }
  435                 }
  436                 if (tryagain || stat == RPC_PROGVERSMISMATCH) {
  437                         if (rpcvers == RPCBVERS4)
  438                                 rpcvers = RPCBVERS;
  439                         else if (rpcvers == RPCBVERS)
  440                                 rpcvers = PMAPVERS;
  441                         CLNT_CONTROL(rpcb, CLSET_VERS, &rpcvers);
  442                         goto again;
  443                 }
  444                 break;
  445         case PMAPVERS:
  446                 /*
  447                  * Try portmap.
  448                  */
  449                 mapping.pm_prog = parms.r_prog;
  450                 mapping.pm_vers = parms.r_vers;
  451                 mapping.pm_prot = do_tcp ? IPPROTO_TCP : IPPROTO_UDP;
  452                 mapping.pm_port = 0;
  453 
  454                 stat = CLNT_CALL(rpcb, (rpcprog_t) PMAPPROC_GETPORT,
  455                     (xdrproc_t) xdr_portmap, &mapping,
  456                     (xdrproc_t) xdr_u_short, &port, timo);
  457 
  458                 if (stat == RPC_SUCCESS) {
  459                         switch (ss.ss_family) {
  460                         case AF_INET:
  461                                 ((struct sockaddr_in *)&ss)->sin_port =
  462                                         htons(port);
  463                                 break;
  464                 
  465 #ifdef INET6
  466                         case AF_INET6:
  467                                 ((struct sockaddr_in6 *)&ss)->sin6_port =
  468                                         htons(port);
  469                                 break;
  470 #endif
  471                         }
  472                 }
  473                 break;
  474         default:
  475                 panic("invalid rpcvers %d", rpcvers);
  476         }
  477         /*
  478          * We may have a positive response from the portmapper, but the NLM
  479          * service was not found. Make sure we received a valid port.
  480          */
  481         switch (ss.ss_family) {
  482         case AF_INET:
  483                 port = ((struct sockaddr_in *)&ss)->sin_port;
  484                 break;
  485 #ifdef INET6
  486         case AF_INET6:
  487                 port = ((struct sockaddr_in6 *)&ss)->sin6_port;
  488                 break;
  489 #endif
  490         }
  491         if (stat != RPC_SUCCESS || !port) {
  492                 /*
  493                  * If we were able to talk to rpcbind or portmap, but the udp
  494                  * variant wasn't available, ask about tcp.
  495                  *
  496                  * XXX - We could also check for a TCP portmapper, but
  497                  * if the host is running a portmapper at all, we should be able
  498                  * to hail it over UDP.
  499                  */
  500                 if (stat == RPC_SUCCESS && !do_tcp) {
  501                         do_tcp = TRUE;
  502                         goto try_tcp;
  503                 }
  504 
  505                 /* Otherwise, bad news. */
  506                 NLM_ERR("NLM: failed to contact remote rpcbind, "
  507                     "stat = %d, port = %d\n", (int) stat, port);
  508                 CLNT_DESTROY(rpcb);
  509                 return (NULL);
  510         }
  511 
  512         if (do_tcp) {
  513                 /*
  514                  * Destroy the UDP client we used to speak to rpcbind and
  515                  * recreate as a TCP client.
  516                  */
  517                 struct netconfig *nconf = NULL;
  518 
  519                 CLNT_DESTROY(rpcb);
  520 
  521                 switch (ss.ss_family) {
  522                 case AF_INET:
  523                         nconf = getnetconfigent("tcp");
  524                         break;
  525 #ifdef INET6
  526                 case AF_INET6:
  527                         nconf = getnetconfigent("tcp6");
  528                         break;
  529 #endif
  530                 }
  531 
  532                 rpcb = clnt_reconnect_create(nconf, (struct sockaddr *)&ss,
  533                     prog, vers, 0, 0);
  534                 CLNT_CONTROL(rpcb, CLSET_WAITCHAN, wchan);
  535                 rpcb->cl_auth = nlm_auth;
  536                 
  537         } else {
  538                 /*
  539                  * Re-use the client we used to speak to rpcbind.
  540                  */
  541                 CLNT_CONTROL(rpcb, CLSET_SVC_ADDR, &ss);
  542                 CLNT_CONTROL(rpcb, CLSET_PROG, &prog);
  543                 CLNT_CONTROL(rpcb, CLSET_VERS, &vers);
  544                 CLNT_CONTROL(rpcb, CLSET_WAITCHAN, wchan);
  545                 rpcb->cl_auth = nlm_auth;
  546         }
  547 
  548         return (rpcb);
  549 }
  550 
  551 /*
  552  * This async callback after when an async lock request has been
  553  * granted. We notify the host which initiated the request.
  554  */
  555 static void
  556 nlm_lock_callback(void *arg, int pending)
  557 {
  558         struct nlm_async_lock *af = (struct nlm_async_lock *) arg;
  559         struct rpc_callextra ext;
  560 
  561         NLM_DEBUG(2, "NLM: async lock %p for %s (sysid %d) granted,"
  562             " cookie %d:%d\n", af, af->af_host->nh_caller_name,
  563             af->af_host->nh_sysid, ng_sysid(&af->af_granted.cookie),
  564             ng_cookie(&af->af_granted.cookie));
  565 
  566         /*
  567          * Send the results back to the host.
  568          *
  569          * Note: there is a possible race here with nlm_host_notify
  570          * destroying the RPC client. To avoid problems, the first
  571          * thing nlm_host_notify does is to cancel pending async lock
  572          * requests.
  573          */
  574         memset(&ext, 0, sizeof(ext));
  575         ext.rc_auth = nlm_auth;
  576         if (af->af_host->nh_vers == NLM_VERS4) {
  577                 nlm4_granted_msg_4(&af->af_granted,
  578                     NULL, af->af_rpc, &ext, nlm_zero_tv);
  579         } else {
  580                 /*
  581                  * Back-convert to legacy protocol
  582                  */
  583                 nlm_testargs granted;
  584                 granted.cookie = af->af_granted.cookie;
  585                 granted.exclusive = af->af_granted.exclusive;
  586                 granted.alock.caller_name =
  587                         af->af_granted.alock.caller_name;
  588                 granted.alock.fh = af->af_granted.alock.fh;
  589                 granted.alock.oh = af->af_granted.alock.oh;
  590                 granted.alock.svid = af->af_granted.alock.svid;
  591                 granted.alock.l_offset =
  592                         af->af_granted.alock.l_offset;
  593                 granted.alock.l_len =
  594                         af->af_granted.alock.l_len;
  595 
  596                 nlm_granted_msg_1(&granted,
  597                     NULL, af->af_rpc, &ext, nlm_zero_tv);
  598         }
  599 
  600         /*
  601          * Move this entry to the nh_granted list.
  602          */
  603         af->af_expiretime = time_uptime + NLM_EXPIRE_TIMEOUT;
  604         mtx_lock(&af->af_host->nh_lock);
  605         TAILQ_REMOVE(&af->af_host->nh_pending, af, af_link);
  606         TAILQ_INSERT_TAIL(&af->af_host->nh_granted, af, af_link);
  607         mtx_unlock(&af->af_host->nh_lock);
  608 }
  609 
  610 /*
  611  * Free an async lock request. The request must have been removed from
  612  * any list.
  613  */
  614 static void
  615 nlm_free_async_lock(struct nlm_async_lock *af)
  616 {
  617         /*
  618          * Free an async lock.
  619          */
  620         if (af->af_rpc)
  621                 CLNT_RELEASE(af->af_rpc);
  622         xdr_free((xdrproc_t) xdr_nlm4_testargs, &af->af_granted);
  623         if (af->af_vp)
  624                 vrele(af->af_vp);
  625         free(af, M_NLM);
  626 }
  627 
  628 /*
  629  * Cancel our async request - this must be called with
  630  * af->nh_host->nh_lock held. This is slightly complicated by a
  631  * potential race with our own callback. If we fail to cancel the
  632  * lock, it must already have been granted - we make sure our async
  633  * task has completed by calling taskqueue_drain in this case.
  634  */
  635 static int
  636 nlm_cancel_async_lock(struct nlm_async_lock *af)
  637 {
  638         struct nlm_host *host = af->af_host;
  639         int error;
  640 
  641         mtx_assert(&host->nh_lock, MA_OWNED);
  642 
  643         mtx_unlock(&host->nh_lock);
  644 
  645         error = VOP_ADVLOCKASYNC(af->af_vp, NULL, F_CANCEL, &af->af_fl,
  646             F_REMOTE, NULL, &af->af_cookie);
  647 
  648         if (error) {
  649                 /*
  650                  * We failed to cancel - make sure our callback has
  651                  * completed before we continue.
  652                  */
  653                 taskqueue_drain(taskqueue_thread, &af->af_task);
  654         }
  655 
  656         mtx_lock(&host->nh_lock);
  657         
  658         if (!error) {
  659                 NLM_DEBUG(2, "NLM: async lock %p for %s (sysid %d) "
  660                     "cancelled\n", af, host->nh_caller_name, host->nh_sysid);
  661 
  662                 /*
  663                  * Remove from the nh_pending list and free now that
  664                  * we are safe from the callback.
  665                  */
  666                 TAILQ_REMOVE(&host->nh_pending, af, af_link);
  667                 mtx_unlock(&host->nh_lock);
  668                 nlm_free_async_lock(af);
  669                 mtx_lock(&host->nh_lock);
  670         }
  671 
  672         return (error);
  673 }
  674 
  675 static void
  676 nlm_check_expired_locks(struct nlm_host *host)
  677 {
  678         struct nlm_async_lock *af;
  679         time_t uptime = time_uptime;
  680 
  681         mtx_lock(&host->nh_lock);
  682         while ((af = TAILQ_FIRST(&host->nh_granted)) != NULL
  683             && uptime >= af->af_expiretime) {
  684                 NLM_DEBUG(2, "NLM: async lock %p for %s (sysid %d) expired,"
  685                     " cookie %d:%d\n", af, af->af_host->nh_caller_name,
  686                     af->af_host->nh_sysid, ng_sysid(&af->af_granted.cookie),
  687                     ng_cookie(&af->af_granted.cookie));
  688                 TAILQ_REMOVE(&host->nh_granted, af, af_link);
  689                 mtx_unlock(&host->nh_lock);
  690                 nlm_free_async_lock(af);
  691                 mtx_lock(&host->nh_lock);
  692         }
  693         while ((af = TAILQ_FIRST(&host->nh_finished)) != NULL) {
  694                 TAILQ_REMOVE(&host->nh_finished, af, af_link);
  695                 mtx_unlock(&host->nh_lock);
  696                 nlm_free_async_lock(af);
  697                 mtx_lock(&host->nh_lock);
  698         }
  699         mtx_unlock(&host->nh_lock);
  700 }
  701 
  702 /*
  703  * Free resources used by a host. This is called after the reference
  704  * count has reached zero so it doesn't need to worry about locks.
  705  */
  706 static void
  707 nlm_host_destroy(struct nlm_host *host)
  708 {
  709 
  710         mtx_lock(&nlm_global_lock);
  711         TAILQ_REMOVE(&nlm_hosts, host, nh_link);
  712         mtx_unlock(&nlm_global_lock);
  713 
  714         if (host->nh_srvrpc.nr_client)
  715                 CLNT_RELEASE(host->nh_srvrpc.nr_client);
  716         if (host->nh_clntrpc.nr_client)
  717                 CLNT_RELEASE(host->nh_clntrpc.nr_client);
  718         mtx_destroy(&host->nh_lock);
  719         sysctl_ctx_free(&host->nh_sysctl);
  720         free(host, M_NLM);
  721 }
  722 
  723 /*
  724  * Thread start callback for client lock recovery
  725  */
  726 static void
  727 nlm_client_recovery_start(void *arg)
  728 {
  729         struct nlm_host *host = (struct nlm_host *) arg;
  730 
  731         NLM_DEBUG(1, "NLM: client lock recovery for %s started\n",
  732             host->nh_caller_name);
  733 
  734         nlm_client_recovery(host);
  735 
  736         NLM_DEBUG(1, "NLM: client lock recovery for %s completed\n",
  737             host->nh_caller_name);
  738 
  739         host->nh_monstate = NLM_MONITORED;
  740         nlm_host_release(host);
  741 
  742         kthread_exit();
  743 }
  744 
  745 /*
  746  * This is called when we receive a host state change notification. We
  747  * unlock any active locks owned by the host. When rpc.lockd is
  748  * shutting down, this function is called with newstate set to zero
  749  * which allows us to cancel any pending async locks and clear the
  750  * locking state.
  751  */
  752 static void
  753 nlm_host_notify(struct nlm_host *host, int newstate)
  754 {
  755         struct nlm_async_lock *af;
  756 
  757         if (newstate) {
  758                 NLM_DEBUG(1, "NLM: host %s (sysid %d) rebooted, new "
  759                     "state is %d\n", host->nh_caller_name,
  760                     host->nh_sysid, newstate);
  761         }
  762 
  763         /*
  764          * Cancel any pending async locks for this host.
  765          */
  766         mtx_lock(&host->nh_lock);
  767         while ((af = TAILQ_FIRST(&host->nh_pending)) != NULL) {
  768                 /*
  769                  * nlm_cancel_async_lock will remove the entry from
  770                  * nh_pending and free it.
  771                  */
  772                 nlm_cancel_async_lock(af);
  773         }
  774         mtx_unlock(&host->nh_lock);
  775         nlm_check_expired_locks(host);
  776 
  777         /*
  778          * The host just rebooted - trash its locks.
  779          */
  780         lf_clearremotesys(host->nh_sysid);
  781         host->nh_state = newstate;
  782 
  783         /*
  784          * If we have any remote locks for this host (i.e. it
  785          * represents a remote NFS server that our local NFS client
  786          * has locks for), start a recovery thread.
  787          */
  788         if (newstate != 0
  789             && host->nh_monstate != NLM_RECOVERING
  790             && lf_countlocks(NLM_SYSID_CLIENT | host->nh_sysid) > 0) {
  791                 struct thread *td;
  792                 host->nh_monstate = NLM_RECOVERING;
  793                 refcount_acquire(&host->nh_refs);
  794                 kthread_add(nlm_client_recovery_start, host, curproc, &td, 0, 0,
  795                     "NFS lock recovery for %s", host->nh_caller_name);
  796         }
  797 }
  798 
  799 /*
  800  * Sysctl handler to count the number of locks for a sysid.
  801  */
  802 static int
  803 nlm_host_lock_count_sysctl(SYSCTL_HANDLER_ARGS)
  804 {
  805         struct nlm_host *host;
  806         int count;
  807 
  808         host = oidp->oid_arg1;
  809         count = lf_countlocks(host->nh_sysid);
  810         return sysctl_handle_int(oidp, &count, 0, req);
  811 }
  812 
  813 /*
  814  * Sysctl handler to count the number of client locks for a sysid.
  815  */
  816 static int
  817 nlm_host_client_lock_count_sysctl(SYSCTL_HANDLER_ARGS)
  818 {
  819         struct nlm_host *host;
  820         int count;
  821 
  822         host = oidp->oid_arg1;
  823         count = lf_countlocks(NLM_SYSID_CLIENT | host->nh_sysid);
  824         return sysctl_handle_int(oidp, &count, 0, req);
  825 }
  826 
  827 /*
  828  * Create a new NLM host.
  829  */
  830 static struct nlm_host *
  831 nlm_create_host(const char* caller_name)
  832 {
  833         struct nlm_host *host;
  834         struct sysctl_oid *oid;
  835 
  836         mtx_assert(&nlm_global_lock, MA_OWNED);
  837 
  838         NLM_DEBUG(1, "NLM: new host %s (sysid %d)\n",
  839             caller_name, nlm_next_sysid);
  840         host = malloc(sizeof(struct nlm_host), M_NLM, M_NOWAIT|M_ZERO);
  841         if (!host)
  842                 return (NULL);
  843         mtx_init(&host->nh_lock, "nh_lock", NULL, MTX_DEF);
  844         host->nh_refs = 1;
  845         strlcpy(host->nh_caller_name, caller_name, MAXNAMELEN);
  846         host->nh_sysid = nlm_next_sysid++;
  847         snprintf(host->nh_sysid_string, sizeof(host->nh_sysid_string),
  848                 "%d", host->nh_sysid);
  849         host->nh_vers = 0;
  850         host->nh_state = 0;
  851         host->nh_monstate = NLM_UNMONITORED;
  852         host->nh_grantcookie = 1;
  853         TAILQ_INIT(&host->nh_pending);
  854         TAILQ_INIT(&host->nh_granted);
  855         TAILQ_INIT(&host->nh_finished);
  856         TAILQ_INSERT_TAIL(&nlm_hosts, host, nh_link);
  857 
  858         mtx_unlock(&nlm_global_lock);
  859 
  860         sysctl_ctx_init(&host->nh_sysctl);
  861         oid = SYSCTL_ADD_NODE(&host->nh_sysctl,
  862             SYSCTL_STATIC_CHILDREN(_vfs_nlm_sysid),
  863             OID_AUTO, host->nh_sysid_string, CTLFLAG_RD, NULL, "");
  864         SYSCTL_ADD_STRING(&host->nh_sysctl, SYSCTL_CHILDREN(oid), OID_AUTO,
  865             "hostname", CTLFLAG_RD, host->nh_caller_name, 0, "");
  866         SYSCTL_ADD_UINT(&host->nh_sysctl, SYSCTL_CHILDREN(oid), OID_AUTO,
  867             "version", CTLFLAG_RD, &host->nh_vers, 0, "");
  868         SYSCTL_ADD_UINT(&host->nh_sysctl, SYSCTL_CHILDREN(oid), OID_AUTO,
  869             "monitored", CTLFLAG_RD, &host->nh_monstate, 0, "");
  870         SYSCTL_ADD_PROC(&host->nh_sysctl, SYSCTL_CHILDREN(oid), OID_AUTO,
  871             "lock_count", CTLTYPE_INT | CTLFLAG_RD, host, 0,
  872             nlm_host_lock_count_sysctl, "I", "");
  873         SYSCTL_ADD_PROC(&host->nh_sysctl, SYSCTL_CHILDREN(oid), OID_AUTO,
  874             "client_lock_count", CTLTYPE_INT | CTLFLAG_RD, host, 0,
  875             nlm_host_client_lock_count_sysctl, "I", "");
  876 
  877         mtx_lock(&nlm_global_lock);
  878 
  879         return (host);
  880 }
  881 
  882 /*
  883  * Acquire the next sysid for remote locks not handled by the NLM.
  884  */
  885 uint32_t
  886 nlm_acquire_next_sysid(void)
  887 {
  888         uint32_t next_sysid;
  889 
  890         mtx_lock(&nlm_global_lock);
  891         next_sysid = nlm_next_sysid++;
  892         mtx_unlock(&nlm_global_lock);
  893         return (next_sysid);
  894 }
  895 
  896 /*
  897  * Return non-zero if the address parts of the two sockaddrs are the
  898  * same.
  899  */
  900 static int
  901 nlm_compare_addr(const struct sockaddr *a, const struct sockaddr *b)
  902 {
  903         const struct sockaddr_in *a4, *b4;
  904 #ifdef INET6
  905         const struct sockaddr_in6 *a6, *b6;
  906 #endif
  907 
  908         if (a->sa_family != b->sa_family)
  909                 return (FALSE);
  910 
  911         switch (a->sa_family) {
  912         case AF_INET:
  913                 a4 = (const struct sockaddr_in *) a;
  914                 b4 = (const struct sockaddr_in *) b;
  915                 return !memcmp(&a4->sin_addr, &b4->sin_addr,
  916                     sizeof(a4->sin_addr));
  917 #ifdef INET6
  918         case AF_INET6:
  919                 a6 = (const struct sockaddr_in6 *) a;
  920                 b6 = (const struct sockaddr_in6 *) b;
  921                 return !memcmp(&a6->sin6_addr, &b6->sin6_addr,
  922                     sizeof(a6->sin6_addr));
  923 #endif
  924         }
  925 
  926         return (0);
  927 }
  928 
  929 /*
  930  * Check for idle hosts and stop monitoring them. We could also free
  931  * the host structure here, possibly after a larger timeout but that
  932  * would require some care to avoid races with
  933  * e.g. nlm_host_lock_count_sysctl.
  934  */
  935 static void
  936 nlm_check_idle(void)
  937 {
  938         struct nlm_host *host;
  939 
  940         mtx_assert(&nlm_global_lock, MA_OWNED);
  941 
  942         if (time_uptime <= nlm_next_idle_check)
  943                 return;
  944 
  945         nlm_next_idle_check = time_uptime + NLM_IDLE_PERIOD;
  946 
  947         TAILQ_FOREACH(host, &nlm_hosts, nh_link) {
  948                 if (host->nh_monstate == NLM_MONITORED
  949                     && time_uptime > host->nh_idle_timeout) {
  950                         mtx_unlock(&nlm_global_lock);
  951                         if (lf_countlocks(host->nh_sysid) > 0
  952                             || lf_countlocks(NLM_SYSID_CLIENT
  953                                 + host->nh_sysid)) {
  954                                 host->nh_idle_timeout =
  955                                         time_uptime + NLM_IDLE_TIMEOUT;
  956                                 mtx_lock(&nlm_global_lock);
  957                                 continue;
  958                         }
  959                         nlm_host_unmonitor(host);
  960                         mtx_lock(&nlm_global_lock);
  961                 } 
  962         }
  963 }
  964 
  965 /*
  966  * Search for an existing NLM host that matches the given name
  967  * (typically the caller_name element of an nlm4_lock).  If none is
  968  * found, create a new host. If 'addr' is non-NULL, record the remote
  969  * address of the host so that we can call it back for async
  970  * responses. If 'vers' is greater than zero then record the NLM
  971  * program version to use to communicate with this client.
  972  */
  973 struct nlm_host *
  974 nlm_find_host_by_name(const char *name, const struct sockaddr *addr,
  975     rpcvers_t vers)
  976 {
  977         struct nlm_host *host;
  978 
  979         mtx_lock(&nlm_global_lock);
  980 
  981         /*
  982          * The remote host is determined by caller_name.
  983          */
  984         TAILQ_FOREACH(host, &nlm_hosts, nh_link) {
  985                 if (!strcmp(host->nh_caller_name, name))
  986                         break;
  987         }
  988 
  989         if (!host) {
  990                 host = nlm_create_host(name);
  991                 if (!host) {
  992                         mtx_unlock(&nlm_global_lock);
  993                         return (NULL);
  994                 }
  995         }
  996         refcount_acquire(&host->nh_refs);
  997 
  998         host->nh_idle_timeout = time_uptime + NLM_IDLE_TIMEOUT;
  999 
 1000         /*
 1001          * If we have an address for the host, record it so that we
 1002          * can send async replies etc.
 1003          */
 1004         if (addr) {
 1005                 
 1006                 KASSERT(addr->sa_len < sizeof(struct sockaddr_storage),
 1007                     ("Strange remote transport address length"));
 1008 
 1009                 /*
 1010                  * If we have seen an address before and we currently
 1011                  * have an RPC client handle, make sure the address is
 1012                  * the same, otherwise discard the client handle.
 1013                  */
 1014                 if (host->nh_addr.ss_len && host->nh_srvrpc.nr_client) {
 1015                         if (!nlm_compare_addr(
 1016                                     (struct sockaddr *) &host->nh_addr,
 1017                                     addr)
 1018                             || host->nh_vers != vers) {
 1019                                 CLIENT *client;
 1020                                 mtx_lock(&host->nh_lock);
 1021                                 client = host->nh_srvrpc.nr_client;
 1022                                 host->nh_srvrpc.nr_client = NULL;
 1023                                 mtx_unlock(&host->nh_lock);
 1024                                 if (client) {
 1025                                         CLNT_RELEASE(client);
 1026                                 }
 1027                         }
 1028                 }
 1029                 memcpy(&host->nh_addr, addr, addr->sa_len);
 1030                 host->nh_vers = vers;
 1031         }
 1032 
 1033         nlm_check_idle();
 1034 
 1035         mtx_unlock(&nlm_global_lock);
 1036 
 1037         return (host);
 1038 }
 1039 
 1040 /*
 1041  * Search for an existing NLM host that matches the given remote
 1042  * address. If none is found, create a new host with the requested
 1043  * address and remember 'vers' as the NLM protocol version to use for
 1044  * that host.
 1045  */
 1046 struct nlm_host *
 1047 nlm_find_host_by_addr(const struct sockaddr *addr, int vers)
 1048 {
 1049         /*
 1050          * Fake up a name using inet_ntop. This buffer is
 1051          * large enough for an IPv6 address.
 1052          */
 1053         char tmp[sizeof "ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255"];
 1054         struct nlm_host *host;
 1055 
 1056         switch (addr->sa_family) {
 1057         case AF_INET:
 1058                 inet_ntop(AF_INET,
 1059                     &((const struct sockaddr_in *) addr)->sin_addr,
 1060                     tmp, sizeof tmp);
 1061                 break;
 1062 #ifdef INET6
 1063         case AF_INET6:
 1064                 inet_ntop(AF_INET6,
 1065                     &((const struct sockaddr_in6 *) addr)->sin6_addr,
 1066                     tmp, sizeof tmp);
 1067                 break;
 1068 #endif
 1069         default:
 1070                 strcmp(tmp, "<unknown>");
 1071         }
 1072 
 1073 
 1074         mtx_lock(&nlm_global_lock);
 1075 
 1076         /*
 1077          * The remote host is determined by caller_name.
 1078          */
 1079         TAILQ_FOREACH(host, &nlm_hosts, nh_link) {
 1080                 if (nlm_compare_addr(addr,
 1081                         (const struct sockaddr *) &host->nh_addr))
 1082                         break;
 1083         }
 1084 
 1085         if (!host) {
 1086                 host = nlm_create_host(tmp);
 1087                 if (!host) {
 1088                         mtx_unlock(&nlm_global_lock);
 1089                         return (NULL);
 1090                 }
 1091                 memcpy(&host->nh_addr, addr, addr->sa_len);
 1092                 host->nh_vers = vers;
 1093         }
 1094         refcount_acquire(&host->nh_refs);
 1095 
 1096         host->nh_idle_timeout = time_uptime + NLM_IDLE_TIMEOUT;
 1097 
 1098         nlm_check_idle();
 1099 
 1100         mtx_unlock(&nlm_global_lock);
 1101 
 1102         return (host);
 1103 }
 1104 
 1105 /*
 1106  * Find the NLM host that matches the value of 'sysid'. If none
 1107  * exists, return NULL.
 1108  */
 1109 static struct nlm_host *
 1110 nlm_find_host_by_sysid(int sysid)
 1111 {
 1112         struct nlm_host *host;
 1113 
 1114         TAILQ_FOREACH(host, &nlm_hosts, nh_link) {
 1115                 if (host->nh_sysid == sysid) {
 1116                         refcount_acquire(&host->nh_refs);
 1117                         return (host);
 1118                 }
 1119         }
 1120 
 1121         return (NULL);
 1122 }
 1123 
 1124 void nlm_host_release(struct nlm_host *host)
 1125 {
 1126         if (refcount_release(&host->nh_refs)) {
 1127                 /*
 1128                  * Free the host
 1129                  */
 1130                 nlm_host_destroy(host);
 1131         }
 1132 }
 1133 
 1134 /*
 1135  * Unregister this NLM host with the local NSM due to idleness.
 1136  */
 1137 static void
 1138 nlm_host_unmonitor(struct nlm_host *host)
 1139 {
 1140         mon_id smmonid;
 1141         sm_stat_res smstat;
 1142         struct timeval timo;
 1143         enum clnt_stat stat;
 1144 
 1145         NLM_DEBUG(1, "NLM: unmonitoring %s (sysid %d)\n",
 1146             host->nh_caller_name, host->nh_sysid);
 1147 
 1148         /*
 1149          * We put our assigned system ID value in the priv field to
 1150          * make it simpler to find the host if we are notified of a
 1151          * host restart.
 1152          */
 1153         smmonid.mon_name = host->nh_caller_name;
 1154         smmonid.my_id.my_name = "localhost";
 1155         smmonid.my_id.my_prog = NLM_PROG;
 1156         smmonid.my_id.my_vers = NLM_SM;
 1157         smmonid.my_id.my_proc = NLM_SM_NOTIFY;
 1158 
 1159         timo.tv_sec = 25;
 1160         timo.tv_usec = 0;
 1161         stat = CLNT_CALL(nlm_nsm, SM_UNMON,
 1162             (xdrproc_t) xdr_mon, &smmonid,
 1163             (xdrproc_t) xdr_sm_stat, &smstat, timo);
 1164 
 1165         if (stat != RPC_SUCCESS) {
 1166                 NLM_ERR("Failed to contact local NSM - rpc error %d\n", stat);
 1167                 return;
 1168         }
 1169         if (smstat.res_stat == stat_fail) {
 1170                 NLM_ERR("Local NSM refuses to unmonitor %s\n",
 1171                     host->nh_caller_name);
 1172                 return;
 1173         }
 1174 
 1175         host->nh_monstate = NLM_UNMONITORED;
 1176 }
 1177 
 1178 /*
 1179  * Register this NLM host with the local NSM so that we can be
 1180  * notified if it reboots.
 1181  */
 1182 void
 1183 nlm_host_monitor(struct nlm_host *host, int state)
 1184 {
 1185         mon smmon;
 1186         sm_stat_res smstat;
 1187         struct timeval timo;
 1188         enum clnt_stat stat;
 1189 
 1190         if (state && !host->nh_state) {
 1191                 /*
 1192                  * This is the first time we have seen an NSM state
 1193                  * value for this host. We record it here to help
 1194                  * detect host reboots.
 1195                  */
 1196                 host->nh_state = state;
 1197                 NLM_DEBUG(1, "NLM: host %s (sysid %d) has NSM state %d\n",
 1198                     host->nh_caller_name, host->nh_sysid, state);
 1199         }
 1200 
 1201         mtx_lock(&host->nh_lock);
 1202         if (host->nh_monstate != NLM_UNMONITORED) {
 1203                 mtx_unlock(&host->nh_lock);
 1204                 return;
 1205         }
 1206         host->nh_monstate = NLM_MONITORED;
 1207         mtx_unlock(&host->nh_lock);
 1208 
 1209         NLM_DEBUG(1, "NLM: monitoring %s (sysid %d)\n",
 1210             host->nh_caller_name, host->nh_sysid);
 1211 
 1212         /*
 1213          * We put our assigned system ID value in the priv field to
 1214          * make it simpler to find the host if we are notified of a
 1215          * host restart.
 1216          */
 1217         smmon.mon_id.mon_name = host->nh_caller_name;
 1218         smmon.mon_id.my_id.my_name = "localhost";
 1219         smmon.mon_id.my_id.my_prog = NLM_PROG;
 1220         smmon.mon_id.my_id.my_vers = NLM_SM;
 1221         smmon.mon_id.my_id.my_proc = NLM_SM_NOTIFY;
 1222         memcpy(smmon.priv, &host->nh_sysid, sizeof(host->nh_sysid));
 1223 
 1224         timo.tv_sec = 25;
 1225         timo.tv_usec = 0;
 1226         stat = CLNT_CALL(nlm_nsm, SM_MON,
 1227             (xdrproc_t) xdr_mon, &smmon,
 1228             (xdrproc_t) xdr_sm_stat, &smstat, timo);
 1229 
 1230         if (stat != RPC_SUCCESS) {
 1231                 NLM_ERR("Failed to contact local NSM - rpc error %d\n", stat);
 1232                 return;
 1233         }
 1234         if (smstat.res_stat == stat_fail) {
 1235                 NLM_ERR("Local NSM refuses to monitor %s\n",
 1236                     host->nh_caller_name);
 1237                 mtx_lock(&host->nh_lock);
 1238                 host->nh_monstate = NLM_MONITOR_FAILED;
 1239                 mtx_unlock(&host->nh_lock);
 1240                 return;
 1241         }
 1242 
 1243         host->nh_monstate = NLM_MONITORED;
 1244 }
 1245 
 1246 /*
 1247  * Return an RPC client handle that can be used to talk to the NLM
 1248  * running on the given host.
 1249  */
 1250 CLIENT *
 1251 nlm_host_get_rpc(struct nlm_host *host, bool_t isserver)
 1252 {
 1253         struct nlm_rpc *rpc;
 1254         CLIENT *client;
 1255 
 1256         mtx_lock(&host->nh_lock);
 1257 
 1258         if (isserver)
 1259                 rpc = &host->nh_srvrpc;
 1260         else
 1261                 rpc = &host->nh_clntrpc;
 1262 
 1263         /*
 1264          * We can't hold onto RPC handles for too long - the async
 1265          * call/reply protocol used by some NLM clients makes it hard
 1266          * to tell when they change port numbers (e.g. after a
 1267          * reboot). Note that if a client reboots while it isn't
 1268          * holding any locks, it won't bother to notify us. We
 1269          * expire the RPC handles after two minutes.
 1270          */
 1271         if (rpc->nr_client && time_uptime > rpc->nr_create_time + 2*60) {
 1272                 client = rpc->nr_client;
 1273                 rpc->nr_client = NULL;
 1274                 mtx_unlock(&host->nh_lock);
 1275                 CLNT_RELEASE(client);
 1276                 mtx_lock(&host->nh_lock);
 1277         }
 1278 
 1279         if (!rpc->nr_client) {
 1280                 mtx_unlock(&host->nh_lock);
 1281                 client = nlm_get_rpc((struct sockaddr *)&host->nh_addr,
 1282                     NLM_PROG, host->nh_vers);
 1283                 mtx_lock(&host->nh_lock);
 1284 
 1285                 if (client) {
 1286                         if (rpc->nr_client) {
 1287                                 mtx_unlock(&host->nh_lock);
 1288                                 CLNT_DESTROY(client);
 1289                                 mtx_lock(&host->nh_lock);
 1290                         } else {
 1291                                 rpc->nr_client = client;
 1292                                 rpc->nr_create_time = time_uptime;
 1293                         }
 1294                 }
 1295         }
 1296 
 1297         client = rpc->nr_client;
 1298         if (client)
 1299                 CLNT_ACQUIRE(client);
 1300         mtx_unlock(&host->nh_lock);
 1301 
 1302         return (client);
 1303 
 1304 }
 1305 
 1306 int nlm_host_get_sysid(struct nlm_host *host)
 1307 {
 1308 
 1309         return (host->nh_sysid);
 1310 }
 1311 
 1312 int
 1313 nlm_host_get_state(struct nlm_host *host)
 1314 {
 1315 
 1316         return (host->nh_state);
 1317 }
 1318 
 1319 void *
 1320 nlm_register_wait_lock(struct nlm4_lock *lock, struct vnode *vp)
 1321 {
 1322         struct nlm_waiting_lock *nw;
 1323 
 1324         nw = malloc(sizeof(struct nlm_waiting_lock), M_NLM, M_WAITOK);
 1325         nw->nw_lock = *lock;
 1326         memcpy(&nw->nw_fh.fh_bytes, nw->nw_lock.fh.n_bytes,
 1327             nw->nw_lock.fh.n_len);
 1328         nw->nw_lock.fh.n_bytes = nw->nw_fh.fh_bytes;
 1329         nw->nw_waiting = TRUE;
 1330         nw->nw_vp = vp;
 1331         mtx_lock(&nlm_global_lock);
 1332         TAILQ_INSERT_TAIL(&nlm_waiting_locks, nw, nw_link);
 1333         mtx_unlock(&nlm_global_lock);
 1334 
 1335         return nw;
 1336 }
 1337 
 1338 void
 1339 nlm_deregister_wait_lock(void *handle)
 1340 {
 1341         struct nlm_waiting_lock *nw = handle;
 1342 
 1343         mtx_lock(&nlm_global_lock);
 1344         TAILQ_REMOVE(&nlm_waiting_locks, nw, nw_link);
 1345         mtx_unlock(&nlm_global_lock);
 1346         
 1347         free(nw, M_NLM);
 1348 }
 1349 
 1350 int
 1351 nlm_wait_lock(void *handle, int timo)
 1352 {
 1353         struct nlm_waiting_lock *nw = handle;
 1354         int error;
 1355 
 1356         /*
 1357          * If the granted message arrived before we got here,
 1358          * nw->nw_waiting will be FALSE - in that case, don't sleep.
 1359          */
 1360         mtx_lock(&nlm_global_lock);
 1361         error = 0;
 1362         if (nw->nw_waiting)
 1363                 error = msleep(nw, &nlm_global_lock, PCATCH, "nlmlock", timo);
 1364         TAILQ_REMOVE(&nlm_waiting_locks, nw, nw_link);
 1365         if (error) {
 1366                 /*
 1367                  * The granted message may arrive after the
 1368                  * interrupt/timeout but before we manage to lock the
 1369                  * mutex. Detect this by examining nw_lock.
 1370                  */
 1371                 if (!nw->nw_waiting)
 1372                         error = 0;
 1373         } else {
 1374                 /*
 1375                  * If nlm_cancel_wait is called, then error will be
 1376                  * zero but nw_waiting will still be TRUE. We
 1377                  * translate this into EINTR.
 1378                  */
 1379                 if (nw->nw_waiting)
 1380                         error = EINTR;
 1381         }
 1382         mtx_unlock(&nlm_global_lock);
 1383 
 1384         free(nw, M_NLM);
 1385 
 1386         return (error);
 1387 }
 1388 
 1389 void
 1390 nlm_cancel_wait(struct vnode *vp)
 1391 {
 1392         struct nlm_waiting_lock *nw;
 1393 
 1394         mtx_lock(&nlm_global_lock);
 1395         TAILQ_FOREACH(nw, &nlm_waiting_locks, nw_link) {
 1396                 if (nw->nw_vp == vp) {
 1397                         wakeup(nw);
 1398                 }
 1399         }
 1400         mtx_unlock(&nlm_global_lock);
 1401 }
 1402 
 1403 
 1404 /**********************************************************************/
 1405 
 1406 /*
 1407  * Syscall interface with userland.
 1408  */
 1409 
 1410 extern void nlm_prog_0(struct svc_req *rqstp, SVCXPRT *transp);
 1411 extern void nlm_prog_1(struct svc_req *rqstp, SVCXPRT *transp);
 1412 extern void nlm_prog_3(struct svc_req *rqstp, SVCXPRT *transp);
 1413 extern void nlm_prog_4(struct svc_req *rqstp, SVCXPRT *transp);
 1414 
 1415 static int
 1416 nlm_register_services(SVCPOOL *pool, int addr_count, char **addrs)
 1417 {
 1418         static rpcvers_t versions[] = {
 1419                 NLM_SM, NLM_VERS, NLM_VERSX, NLM_VERS4
 1420         };
 1421         static void (*dispatchers[])(struct svc_req *, SVCXPRT *) = {
 1422                 nlm_prog_0, nlm_prog_1, nlm_prog_3, nlm_prog_4
 1423         };
 1424         static const int version_count = sizeof(versions) / sizeof(versions[0]);
 1425 
 1426         SVCXPRT **xprts;
 1427         char netid[16];
 1428         char uaddr[128];
 1429         struct netconfig *nconf;
 1430         int i, j, error;
 1431 
 1432         if (!addr_count) {
 1433                 NLM_ERR("NLM: no service addresses given - can't start server");
 1434                 return (EINVAL);
 1435         }
 1436 
 1437         xprts = malloc(addr_count * sizeof(SVCXPRT *), M_NLM, M_WAITOK|M_ZERO);
 1438         for (i = 0; i < version_count; i++) {
 1439                 for (j = 0; j < addr_count; j++) {
 1440                         /*
 1441                          * Create transports for the first version and
 1442                          * then just register everything else to the
 1443                          * same transports.
 1444                          */
 1445                         if (i == 0) {
 1446                                 char *up;
 1447 
 1448                                 error = copyin(&addrs[2*j], &up,
 1449                                     sizeof(char*));
 1450                                 if (error)
 1451                                         goto out;
 1452                                 error = copyinstr(up, netid, sizeof(netid),
 1453                                     NULL);
 1454                                 if (error)
 1455                                         goto out;
 1456                                 error = copyin(&addrs[2*j+1], &up,
 1457                                     sizeof(char*));
 1458                                 if (error)
 1459                                         goto out;
 1460                                 error = copyinstr(up, uaddr, sizeof(uaddr),
 1461                                     NULL);
 1462                                 if (error)
 1463                                         goto out;
 1464                                 nconf = getnetconfigent(netid);
 1465                                 if (!nconf) {
 1466                                         NLM_ERR("Can't lookup netid %s\n",
 1467                                             netid);
 1468                                         error = EINVAL;
 1469                                         goto out;
 1470                                 }
 1471                                 xprts[j] = svc_tp_create(pool, dispatchers[i],
 1472                                     NLM_PROG, versions[i], uaddr, nconf);
 1473                                 if (!xprts[j]) {
 1474                                         NLM_ERR("NLM: unable to create "
 1475                                             "(NLM_PROG, %d).\n", versions[i]);
 1476                                         error = EINVAL;
 1477                                         goto out;
 1478                                 }
 1479                                 freenetconfigent(nconf);
 1480                         } else {
 1481                                 nconf = getnetconfigent(xprts[j]->xp_netid);
 1482                                 rpcb_unset(NLM_PROG, versions[i], nconf);
 1483                                 if (!svc_reg(xprts[j], NLM_PROG, versions[i],
 1484                                         dispatchers[i], nconf)) {
 1485                                         NLM_ERR("NLM: can't register "
 1486                                             "(NLM_PROG, %d)\n", versions[i]);
 1487                                         error = EINVAL;
 1488                                         goto out;
 1489                                 }
 1490                         }
 1491                 }
 1492         }
 1493         error = 0;
 1494 out:
 1495         for (j = 0; j < addr_count; j++) {
 1496                 if (xprts[j])
 1497                         SVC_RELEASE(xprts[j]);
 1498         }
 1499         free(xprts, M_NLM);
 1500         return (error);
 1501 }
 1502 
 1503 /*
 1504  * Main server entry point. Contacts the local NSM to get its current
 1505  * state and send SM_UNMON_ALL. Registers the NLM services and then
 1506  * services requests. Does not return until the server is interrupted
 1507  * by a signal.
 1508  */
 1509 static int
 1510 nlm_server_main(int addr_count, char **addrs)
 1511 {
 1512         struct thread *td = curthread;
 1513         int error;
 1514         SVCPOOL *pool = NULL;
 1515         struct sockopt opt;
 1516         int portlow;
 1517 #ifdef INET6
 1518         struct sockaddr_in6 sin6;
 1519 #endif
 1520         struct sockaddr_in sin;
 1521         my_id id;
 1522         sm_stat smstat;
 1523         struct timeval timo;
 1524         enum clnt_stat stat;
 1525         struct nlm_host *host, *nhost;
 1526         struct nlm_waiting_lock *nw;
 1527         vop_advlock_t *old_nfs_advlock;
 1528         vop_reclaim_t *old_nfs_reclaim;
 1529         int v4_used;
 1530 #ifdef INET6
 1531         int v6_used;
 1532 #endif
 1533 
 1534         if (nlm_socket) {
 1535                 NLM_ERR("NLM: can't start server - "
 1536                     "it appears to be running already\n");
 1537                 return (EPERM);
 1538         }
 1539 
 1540         memset(&opt, 0, sizeof(opt));
 1541 
 1542         nlm_socket = NULL;
 1543         error = socreate(AF_INET, &nlm_socket, SOCK_DGRAM, 0,
 1544             td->td_ucred, td);
 1545         if (error) {
 1546                 NLM_ERR("NLM: can't create IPv4 socket - error %d\n", error);
 1547                 return (error);
 1548         }
 1549         opt.sopt_dir = SOPT_SET;
 1550         opt.sopt_level = IPPROTO_IP;
 1551         opt.sopt_name = IP_PORTRANGE;
 1552         portlow = IP_PORTRANGE_LOW;
 1553         opt.sopt_val = &portlow;
 1554         opt.sopt_valsize = sizeof(portlow);
 1555         sosetopt(nlm_socket, &opt);
 1556 
 1557 #ifdef INET6
 1558         nlm_socket6 = NULL;
 1559         error = socreate(AF_INET6, &nlm_socket6, SOCK_DGRAM, 0,
 1560             td->td_ucred, td);
 1561         if (error) {
 1562                 NLM_ERR("NLM: can't create IPv6 socket - error %d\n", error);
 1563                 goto out;
 1564                 return (error);
 1565         }
 1566         opt.sopt_dir = SOPT_SET;
 1567         opt.sopt_level = IPPROTO_IPV6;
 1568         opt.sopt_name = IPV6_PORTRANGE;
 1569         portlow = IPV6_PORTRANGE_LOW;
 1570         opt.sopt_val = &portlow;
 1571         opt.sopt_valsize = sizeof(portlow);
 1572         sosetopt(nlm_socket6, &opt);
 1573 #endif
 1574 
 1575         nlm_auth = authunix_create(curthread->td_ucred);
 1576 
 1577 #ifdef INET6
 1578         memset(&sin6, 0, sizeof(sin6));
 1579         sin6.sin6_len = sizeof(sin6);
 1580         sin6.sin6_family = AF_INET6;
 1581         sin6.sin6_addr = in6addr_loopback;
 1582         nlm_nsm = nlm_get_rpc((struct sockaddr *) &sin6, SM_PROG, SM_VERS);
 1583         if (!nlm_nsm) {
 1584 #endif
 1585                 memset(&sin, 0, sizeof(sin));
 1586                 sin.sin_len = sizeof(sin);
 1587                 sin.sin_family = AF_INET;
 1588                 sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 1589                 nlm_nsm = nlm_get_rpc((struct sockaddr *) &sin, SM_PROG,
 1590                     SM_VERS);
 1591 #ifdef INET6
 1592         }
 1593 #endif
 1594 
 1595         if (!nlm_nsm) {
 1596                 NLM_ERR("Can't start NLM - unable to contact NSM\n");
 1597                 error = EINVAL;
 1598                 goto out;
 1599         }
 1600 
 1601         pool = svcpool_create("NLM", NULL);
 1602 
 1603         error = nlm_register_services(pool, addr_count, addrs);
 1604         if (error)
 1605                 goto out;
 1606 
 1607         memset(&id, 0, sizeof(id));
 1608         id.my_name = "NFS NLM";
 1609 
 1610         timo.tv_sec = 25;
 1611         timo.tv_usec = 0;
 1612         stat = CLNT_CALL(nlm_nsm, SM_UNMON_ALL,
 1613             (xdrproc_t) xdr_my_id, &id,
 1614             (xdrproc_t) xdr_sm_stat, &smstat, timo);
 1615 
 1616         if (stat != RPC_SUCCESS) {
 1617                 struct rpc_err err;
 1618 
 1619                 CLNT_GETERR(nlm_nsm, &err);
 1620                 NLM_ERR("NLM: unexpected error contacting NSM, "
 1621                     "stat=%d, errno=%d\n", stat, err.re_errno);
 1622                 error = EINVAL;
 1623                 goto out;
 1624         }
 1625 
 1626         NLM_DEBUG(1, "NLM: local NSM state is %d\n", smstat.state);
 1627         nlm_nsm_state = smstat.state;
 1628 
 1629         old_nfs_advlock = nfs_advlock_p;
 1630         nfs_advlock_p = nlm_advlock;
 1631         old_nfs_reclaim = nfs_reclaim_p;
 1632         nfs_reclaim_p = nlm_reclaim;
 1633 
 1634         svc_run(pool);
 1635         error = 0;
 1636 
 1637         nfs_advlock_p = old_nfs_advlock;
 1638         nfs_reclaim_p = old_nfs_reclaim;
 1639 
 1640 out:
 1641         if (pool)
 1642                 svcpool_destroy(pool);
 1643 
 1644         /*
 1645          * We are finished communicating with the NSM.
 1646          */
 1647         if (nlm_nsm) {
 1648                 CLNT_RELEASE(nlm_nsm);
 1649                 nlm_nsm = NULL;
 1650         }
 1651 
 1652         /*
 1653          * Trash all the existing state so that if the server
 1654          * restarts, it gets a clean slate. This is complicated by the
 1655          * possibility that there may be other threads trying to make
 1656          * client locking requests.
 1657          *
 1658          * First we fake a client reboot notification which will
 1659          * cancel any pending async locks and purge remote lock state
 1660          * from the local lock manager. We release the reference from
 1661          * nlm_hosts to the host (which may remove it from the list
 1662          * and free it). After this phase, the only entries in the
 1663          * nlm_host list should be from other threads performing
 1664          * client lock requests. We arrange to defer closing the
 1665          * sockets until the last RPC client handle is released.
 1666          */
 1667         v4_used = 0;
 1668 #ifdef INET6
 1669         v6_used = 0;
 1670 #endif
 1671         mtx_lock(&nlm_global_lock);
 1672         TAILQ_FOREACH(nw, &nlm_waiting_locks, nw_link) {
 1673                 wakeup(nw);
 1674         }
 1675         TAILQ_FOREACH_SAFE(host, &nlm_hosts, nh_link, nhost) {
 1676                 mtx_unlock(&nlm_global_lock);
 1677                 nlm_host_notify(host, 0);
 1678                 nlm_host_release(host);
 1679                 mtx_lock(&nlm_global_lock);
 1680         }
 1681         TAILQ_FOREACH_SAFE(host, &nlm_hosts, nh_link, nhost) {
 1682                 mtx_lock(&host->nh_lock);
 1683                 if (host->nh_srvrpc.nr_client
 1684                     || host->nh_clntrpc.nr_client) {
 1685                         if (host->nh_addr.ss_family == AF_INET)
 1686                                 v4_used++;
 1687 #ifdef INET6
 1688                         if (host->nh_addr.ss_family == AF_INET6)
 1689                                 v6_used++;
 1690 #endif
 1691                         /*
 1692                          * Note that the rpc over udp code copes
 1693                          * correctly with the fact that a socket may
 1694                          * be used by many rpc handles.
 1695                          */
 1696                         if (host->nh_srvrpc.nr_client)
 1697                                 CLNT_CONTROL(host->nh_srvrpc.nr_client,
 1698                                     CLSET_FD_CLOSE, 0);
 1699                         if (host->nh_clntrpc.nr_client)
 1700                                 CLNT_CONTROL(host->nh_clntrpc.nr_client,
 1701                                     CLSET_FD_CLOSE, 0);
 1702                 }
 1703                 mtx_unlock(&host->nh_lock);
 1704         }
 1705         mtx_unlock(&nlm_global_lock);
 1706 
 1707         AUTH_DESTROY(nlm_auth);
 1708 
 1709         if (!v4_used)
 1710                 soclose(nlm_socket);
 1711         nlm_socket = NULL;
 1712 #ifdef INET6
 1713         if (!v6_used)
 1714                 soclose(nlm_socket6);
 1715         nlm_socket6 = NULL;
 1716 #endif
 1717 
 1718         return (error);
 1719 }
 1720 
 1721 int
 1722 sys_nlm_syscall(struct thread *td, struct nlm_syscall_args *uap)
 1723 {
 1724         int error;
 1725 
 1726 #if __FreeBSD_version >= 700000
 1727         error = priv_check(td, PRIV_NFS_LOCKD);
 1728 #else
 1729         error = suser(td);
 1730 #endif
 1731         if (error)
 1732                 return (error);
 1733 
 1734         nlm_debug_level = uap->debug_level;
 1735         nlm_grace_threshold = time_uptime + uap->grace_period;
 1736         nlm_next_idle_check = time_uptime + NLM_IDLE_PERIOD;
 1737 
 1738         return nlm_server_main(uap->addr_count, uap->addrs);
 1739 }
 1740 
 1741 /**********************************************************************/
 1742 
 1743 /*
 1744  * NLM implementation details, called from the RPC stubs.
 1745  */
 1746 
 1747 
 1748 void
 1749 nlm_sm_notify(struct nlm_sm_status *argp)
 1750 {
 1751         uint32_t sysid;
 1752         struct nlm_host *host;
 1753 
 1754         NLM_DEBUG(3, "nlm_sm_notify(): mon_name = %s\n", argp->mon_name);
 1755         memcpy(&sysid, &argp->priv, sizeof(sysid));
 1756         host = nlm_find_host_by_sysid(sysid);
 1757         if (host) {
 1758                 nlm_host_notify(host, argp->state);
 1759                 nlm_host_release(host);
 1760         }
 1761 }
 1762 
 1763 static void
 1764 nlm_convert_to_fhandle_t(fhandle_t *fhp, struct netobj *p)
 1765 {
 1766         memcpy(fhp, p->n_bytes, sizeof(fhandle_t));
 1767 }
 1768 
 1769 struct vfs_state {
 1770         struct mount    *vs_mp;
 1771         struct vnode    *vs_vp;
 1772         int             vs_vfslocked;
 1773         int             vs_vnlocked;
 1774 };
 1775 
 1776 static int
 1777 nlm_get_vfs_state(struct nlm_host *host, struct svc_req *rqstp,
 1778     fhandle_t *fhp, struct vfs_state *vs, accmode_t accmode)
 1779 {
 1780         int error, exflags;
 1781         struct ucred *cred = NULL, *credanon = NULL;
 1782         
 1783         memset(vs, 0, sizeof(*vs));
 1784 
 1785         vs->vs_mp = vfs_getvfs(&fhp->fh_fsid);
 1786         if (!vs->vs_mp) {
 1787                 return (ESTALE);
 1788         }
 1789         vs->vs_vfslocked = VFS_LOCK_GIANT(vs->vs_mp);
 1790 
 1791         /* accmode == 0 means don't check, since it is an unlock. */
 1792         if (accmode != 0) {
 1793                 error = VFS_CHECKEXP(vs->vs_mp,
 1794                     (struct sockaddr *)&host->nh_addr, &exflags, &credanon,
 1795                     NULL, NULL);
 1796                 if (error)
 1797                         goto out;
 1798 
 1799                 if (exflags & MNT_EXRDONLY ||
 1800                     (vs->vs_mp->mnt_flag & MNT_RDONLY)) {
 1801                         error = EROFS;
 1802                         goto out;
 1803                 }
 1804         }
 1805 
 1806         error = VFS_FHTOVP(vs->vs_mp, &fhp->fh_fid, LK_EXCLUSIVE, &vs->vs_vp);
 1807         if (error)
 1808                 goto out;
 1809         vs->vs_vnlocked = TRUE;
 1810 
 1811         if (accmode != 0) {
 1812                 if (!svc_getcred(rqstp, &cred, NULL)) {
 1813                         error = EINVAL;
 1814                         goto out;
 1815                 }
 1816                 if (cred->cr_uid == 0 || (exflags & MNT_EXPORTANON)) {
 1817                         crfree(cred);
 1818                         cred = credanon;
 1819                         credanon = NULL;
 1820                 }
 1821 
 1822                 /*
 1823                  * Check cred.
 1824                  */
 1825                 error = VOP_ACCESS(vs->vs_vp, accmode, cred, curthread);
 1826                 /*
 1827                  * If this failed and accmode != VWRITE, try again with
 1828                  * VWRITE to maintain backwards compatibility with the
 1829                  * old code that always used VWRITE.
 1830                  */
 1831                 if (error != 0 && accmode != VWRITE)
 1832                         error = VOP_ACCESS(vs->vs_vp, VWRITE, cred, curthread);
 1833                 if (error)
 1834                         goto out;
 1835         }
 1836 
 1837 #if __FreeBSD_version < 800011
 1838         VOP_UNLOCK(vs->vs_vp, 0, curthread);
 1839 #else
 1840         VOP_UNLOCK(vs->vs_vp, 0);
 1841 #endif
 1842         vs->vs_vnlocked = FALSE;
 1843 
 1844 out:
 1845         if (cred)
 1846                 crfree(cred);
 1847         if (credanon)
 1848                 crfree(credanon);
 1849 
 1850         return (error);
 1851 }
 1852 
 1853 static void
 1854 nlm_release_vfs_state(struct vfs_state *vs)
 1855 {
 1856 
 1857         if (vs->vs_vp) {
 1858                 if (vs->vs_vnlocked)
 1859                         vput(vs->vs_vp);
 1860                 else
 1861                         vrele(vs->vs_vp);
 1862         }
 1863         if (vs->vs_mp)
 1864                 vfs_rel(vs->vs_mp);
 1865         VFS_UNLOCK_GIANT(vs->vs_vfslocked);
 1866 }
 1867 
 1868 static nlm4_stats
 1869 nlm_convert_error(int error)
 1870 {
 1871 
 1872         if (error == ESTALE)
 1873                 return nlm4_stale_fh;
 1874         else if (error == EROFS)
 1875                 return nlm4_rofs;
 1876         else
 1877                 return nlm4_failed;
 1878 }
 1879 
 1880 int
 1881 nlm_do_test(nlm4_testargs *argp, nlm4_testres *result, struct svc_req *rqstp,
 1882         CLIENT **rpcp)
 1883 {
 1884         fhandle_t fh;
 1885         struct vfs_state vs;
 1886         struct nlm_host *host, *bhost;
 1887         int error, sysid;
 1888         struct flock fl;
 1889         accmode_t accmode;
 1890         
 1891         memset(result, 0, sizeof(*result));
 1892         memset(&vs, 0, sizeof(vs));
 1893 
 1894         host = nlm_find_host_by_name(argp->alock.caller_name,
 1895             svc_getrpccaller(rqstp), rqstp->rq_vers);
 1896         if (!host) {
 1897                 result->stat.stat = nlm4_denied_nolocks;
 1898                 return (ENOMEM);
 1899         }
 1900 
 1901         NLM_DEBUG(3, "nlm_do_test(): caller_name = %s (sysid = %d)\n",
 1902             host->nh_caller_name, host->nh_sysid);
 1903 
 1904         nlm_check_expired_locks(host);
 1905         sysid = host->nh_sysid;
 1906 
 1907         nlm_convert_to_fhandle_t(&fh, &argp->alock.fh);
 1908         nlm_copy_netobj(&result->cookie, &argp->cookie, M_RPC);
 1909 
 1910         if (time_uptime < nlm_grace_threshold) {
 1911                 result->stat.stat = nlm4_denied_grace_period;
 1912                 goto out;
 1913         }
 1914 
 1915         accmode = argp->exclusive ? VWRITE : VREAD;
 1916         error = nlm_get_vfs_state(host, rqstp, &fh, &vs, accmode);
 1917         if (error) {
 1918                 result->stat.stat = nlm_convert_error(error);
 1919                 goto out;
 1920         }
 1921 
 1922         fl.l_start = argp->alock.l_offset;
 1923         fl.l_len = argp->alock.l_len;
 1924         fl.l_pid = argp->alock.svid;
 1925         fl.l_sysid = sysid;
 1926         fl.l_whence = SEEK_SET;
 1927         if (argp->exclusive)
 1928                 fl.l_type = F_WRLCK;
 1929         else
 1930                 fl.l_type = F_RDLCK;
 1931         error = VOP_ADVLOCK(vs.vs_vp, NULL, F_GETLK, &fl, F_REMOTE);
 1932         if (error) {
 1933                 result->stat.stat = nlm4_failed;
 1934                 goto out;
 1935         }
 1936 
 1937         if (fl.l_type == F_UNLCK) {
 1938                 result->stat.stat = nlm4_granted;
 1939         } else {
 1940                 result->stat.stat = nlm4_denied;
 1941                 result->stat.nlm4_testrply_u.holder.exclusive =
 1942                         (fl.l_type == F_WRLCK);
 1943                 result->stat.nlm4_testrply_u.holder.svid = fl.l_pid;
 1944                 bhost = nlm_find_host_by_sysid(fl.l_sysid);
 1945                 if (bhost) {
 1946                         /*
 1947                          * We don't have any useful way of recording
 1948                          * the value of oh used in the original lock
 1949                          * request. Ideally, the test reply would have
 1950                          * a space for the owning host's name allowing
 1951                          * our caller's NLM to keep track.
 1952                          *
 1953                          * As far as I can see, Solaris uses an eight
 1954                          * byte structure for oh which contains a four
 1955                          * byte pid encoded in local byte order and
 1956                          * the first four bytes of the host
 1957                          * name. Linux uses a variable length string
 1958                          * 'pid@hostname' in ascii but doesn't even
 1959                          * return that in test replies.
 1960                          *
 1961                          * For the moment, return nothing in oh
 1962                          * (already zero'ed above).
 1963                          */
 1964                         nlm_host_release(bhost);
 1965                 }
 1966                 result->stat.nlm4_testrply_u.holder.l_offset = fl.l_start;
 1967                 result->stat.nlm4_testrply_u.holder.l_len = fl.l_len;
 1968         }
 1969 
 1970 out:
 1971         nlm_release_vfs_state(&vs);
 1972         if (rpcp)
 1973                 *rpcp = nlm_host_get_rpc(host, TRUE);
 1974         nlm_host_release(host);
 1975         return (0);
 1976 }
 1977 
 1978 int
 1979 nlm_do_lock(nlm4_lockargs *argp, nlm4_res *result, struct svc_req *rqstp,
 1980     bool_t monitor, CLIENT **rpcp)
 1981 {
 1982         fhandle_t fh;
 1983         struct vfs_state vs;
 1984         struct nlm_host *host;
 1985         int error, sysid;
 1986         struct flock fl;
 1987         accmode_t accmode;
 1988         
 1989         memset(result, 0, sizeof(*result));
 1990         memset(&vs, 0, sizeof(vs));
 1991 
 1992         host = nlm_find_host_by_name(argp->alock.caller_name,
 1993             svc_getrpccaller(rqstp), rqstp->rq_vers);
 1994         if (!host) {
 1995                 result->stat.stat = nlm4_denied_nolocks;
 1996                 return (ENOMEM);
 1997         }
 1998 
 1999         NLM_DEBUG(3, "nlm_do_lock(): caller_name = %s (sysid = %d)\n",
 2000             host->nh_caller_name, host->nh_sysid);
 2001 
 2002         if (monitor && host->nh_state && argp->state
 2003             && host->nh_state != argp->state) {
 2004                 /*
 2005                  * The host rebooted without telling us. Trash its
 2006                  * locks.
 2007                  */
 2008                 nlm_host_notify(host, argp->state);
 2009         }
 2010 
 2011         nlm_check_expired_locks(host);
 2012         sysid = host->nh_sysid;
 2013 
 2014         nlm_convert_to_fhandle_t(&fh, &argp->alock.fh);
 2015         nlm_copy_netobj(&result->cookie, &argp->cookie, M_RPC);
 2016 
 2017         if (time_uptime < nlm_grace_threshold && !argp->reclaim) {
 2018                 result->stat.stat = nlm4_denied_grace_period;
 2019                 goto out;
 2020         }
 2021 
 2022         accmode = argp->exclusive ? VWRITE : VREAD;
 2023         error = nlm_get_vfs_state(host, rqstp, &fh, &vs, accmode);
 2024         if (error) {
 2025                 result->stat.stat = nlm_convert_error(error);
 2026                 goto out;
 2027         }
 2028 
 2029         fl.l_start = argp->alock.l_offset;
 2030         fl.l_len = argp->alock.l_len;
 2031         fl.l_pid = argp->alock.svid;
 2032         fl.l_sysid = sysid;
 2033         fl.l_whence = SEEK_SET;
 2034         if (argp->exclusive)
 2035                 fl.l_type = F_WRLCK;
 2036         else
 2037                 fl.l_type = F_RDLCK;
 2038         if (argp->block) {
 2039                 struct nlm_async_lock *af;
 2040                 CLIENT *client;
 2041                 struct nlm_grantcookie cookie;
 2042 
 2043                 /*
 2044                  * First, make sure we can contact the host's NLM.
 2045                  */
 2046                 client = nlm_host_get_rpc(host, TRUE);
 2047                 if (!client) {
 2048                         result->stat.stat = nlm4_failed;
 2049                         goto out;
 2050                 }
 2051 
 2052                 /*
 2053                  * First we need to check and see if there is an
 2054                  * existing blocked lock that matches. This could be a
 2055                  * badly behaved client or an RPC re-send. If we find
 2056                  * one, just return nlm4_blocked.
 2057                  */
 2058                 mtx_lock(&host->nh_lock);
 2059                 TAILQ_FOREACH(af, &host->nh_pending, af_link) {
 2060                         if (af->af_fl.l_start == fl.l_start
 2061                             && af->af_fl.l_len == fl.l_len
 2062                             && af->af_fl.l_pid == fl.l_pid
 2063                             && af->af_fl.l_type == fl.l_type) {
 2064                                 break;
 2065                         }
 2066                 }
 2067                 if (!af) {
 2068                         cookie.ng_sysid = host->nh_sysid;
 2069                         cookie.ng_cookie = host->nh_grantcookie++;
 2070                 }
 2071                 mtx_unlock(&host->nh_lock);
 2072                 if (af) {
 2073                         CLNT_RELEASE(client);
 2074                         result->stat.stat = nlm4_blocked;
 2075                         goto out;
 2076                 }
 2077 
 2078                 af = malloc(sizeof(struct nlm_async_lock), M_NLM,
 2079                     M_WAITOK|M_ZERO);
 2080                 TASK_INIT(&af->af_task, 0, nlm_lock_callback, af);
 2081                 af->af_vp = vs.vs_vp;
 2082                 af->af_fl = fl;
 2083                 af->af_host = host;
 2084                 af->af_rpc = client;
 2085                 /*
 2086                  * We use M_RPC here so that we can xdr_free the thing
 2087                  * later.
 2088                  */
 2089                 nlm_make_netobj(&af->af_granted.cookie,
 2090                     (caddr_t)&cookie, sizeof(cookie), M_RPC);
 2091                 af->af_granted.exclusive = argp->exclusive;
 2092                 af->af_granted.alock.caller_name =
 2093                         strdup(argp->alock.caller_name, M_RPC);
 2094                 nlm_copy_netobj(&af->af_granted.alock.fh,
 2095                     &argp->alock.fh, M_RPC);
 2096                 nlm_copy_netobj(&af->af_granted.alock.oh,
 2097                     &argp->alock.oh, M_RPC);
 2098                 af->af_granted.alock.svid = argp->alock.svid;
 2099                 af->af_granted.alock.l_offset = argp->alock.l_offset;
 2100                 af->af_granted.alock.l_len = argp->alock.l_len;
 2101 
 2102                 /*
 2103                  * Put the entry on the pending list before calling
 2104                  * VOP_ADVLOCKASYNC. We do this in case the lock
 2105                  * request was blocked (returning EINPROGRESS) but
 2106                  * then granted before we manage to run again. The
 2107                  * client may receive the granted message before we
 2108                  * send our blocked reply but thats their problem.
 2109                  */
 2110                 mtx_lock(&host->nh_lock);
 2111                 TAILQ_INSERT_TAIL(&host->nh_pending, af, af_link);
 2112                 mtx_unlock(&host->nh_lock);
 2113 
 2114                 error = VOP_ADVLOCKASYNC(vs.vs_vp, NULL, F_SETLK, &fl, F_REMOTE,
 2115                     &af->af_task, &af->af_cookie);
 2116 
 2117                 /*
 2118                  * If the lock completed synchronously, just free the
 2119                  * tracking structure now.
 2120                  */
 2121                 if (error != EINPROGRESS) {
 2122                         CLNT_RELEASE(af->af_rpc);
 2123                         mtx_lock(&host->nh_lock);
 2124                         TAILQ_REMOVE(&host->nh_pending, af, af_link);
 2125                         mtx_unlock(&host->nh_lock);
 2126                         xdr_free((xdrproc_t) xdr_nlm4_testargs,
 2127                             &af->af_granted);
 2128                         free(af, M_NLM);
 2129                 } else {
 2130                         NLM_DEBUG(2, "NLM: pending async lock %p for %s "
 2131                             "(sysid %d)\n", af, host->nh_caller_name, sysid);
 2132                         /*
 2133                          * Don't vrele the vnode just yet - this must
 2134                          * wait until either the async callback
 2135                          * happens or the lock is cancelled.
 2136                          */
 2137                         vs.vs_vp = NULL;
 2138                 }
 2139         } else {
 2140                 error = VOP_ADVLOCK(vs.vs_vp, NULL, F_SETLK, &fl, F_REMOTE);
 2141         }
 2142 
 2143         if (error) {
 2144                 if (error == EINPROGRESS) {
 2145                         result->stat.stat = nlm4_blocked;
 2146                 } else if (error == EDEADLK) {
 2147                         result->stat.stat = nlm4_deadlck;
 2148                 } else if (error == EAGAIN) {
 2149                         result->stat.stat = nlm4_denied;
 2150                 } else {
 2151                         result->stat.stat = nlm4_failed;
 2152                 }
 2153         } else {
 2154                 if (monitor)
 2155                         nlm_host_monitor(host, argp->state);
 2156                 result->stat.stat = nlm4_granted;
 2157         }       
 2158 
 2159 out:
 2160         nlm_release_vfs_state(&vs);
 2161         if (rpcp)
 2162                 *rpcp = nlm_host_get_rpc(host, TRUE);
 2163         nlm_host_release(host);
 2164         return (0);
 2165 }
 2166 
 2167 int
 2168 nlm_do_cancel(nlm4_cancargs *argp, nlm4_res *result, struct svc_req *rqstp,
 2169     CLIENT **rpcp)
 2170 {
 2171         fhandle_t fh;
 2172         struct vfs_state vs;
 2173         struct nlm_host *host;
 2174         int error, sysid;
 2175         struct flock fl;
 2176         struct nlm_async_lock *af;
 2177         
 2178         memset(result, 0, sizeof(*result));
 2179         memset(&vs, 0, sizeof(vs));
 2180 
 2181         host = nlm_find_host_by_name(argp->alock.caller_name,
 2182             svc_getrpccaller(rqstp), rqstp->rq_vers);
 2183         if (!host) {
 2184                 result->stat.stat = nlm4_denied_nolocks;
 2185                 return (ENOMEM);
 2186         }
 2187 
 2188         NLM_DEBUG(3, "nlm_do_cancel(): caller_name = %s (sysid = %d)\n",
 2189             host->nh_caller_name, host->nh_sysid);
 2190 
 2191         nlm_check_expired_locks(host);
 2192         sysid = host->nh_sysid;
 2193 
 2194         nlm_convert_to_fhandle_t(&fh, &argp->alock.fh);
 2195         nlm_copy_netobj(&result->cookie, &argp->cookie, M_RPC);
 2196 
 2197         if (time_uptime < nlm_grace_threshold) {
 2198                 result->stat.stat = nlm4_denied_grace_period;
 2199                 goto out;
 2200         }
 2201 
 2202         error = nlm_get_vfs_state(host, rqstp, &fh, &vs, (accmode_t)0);
 2203         if (error) {
 2204                 result->stat.stat = nlm_convert_error(error);
 2205                 goto out;
 2206         }
 2207 
 2208         fl.l_start = argp->alock.l_offset;
 2209         fl.l_len = argp->alock.l_len;
 2210         fl.l_pid = argp->alock.svid;
 2211         fl.l_sysid = sysid;
 2212         fl.l_whence = SEEK_SET;
 2213         if (argp->exclusive)
 2214                 fl.l_type = F_WRLCK;
 2215         else
 2216                 fl.l_type = F_RDLCK;
 2217 
 2218         /*
 2219          * First we need to try and find the async lock request - if
 2220          * there isn't one, we give up and return nlm4_denied.
 2221          */
 2222         mtx_lock(&host->nh_lock);
 2223 
 2224         TAILQ_FOREACH(af, &host->nh_pending, af_link) {
 2225                 if (af->af_fl.l_start == fl.l_start
 2226                     && af->af_fl.l_len == fl.l_len
 2227                     && af->af_fl.l_pid == fl.l_pid
 2228                     && af->af_fl.l_type == fl.l_type) {
 2229                         break;
 2230                 }
 2231         }
 2232 
 2233         if (!af) {
 2234                 mtx_unlock(&host->nh_lock);
 2235                 result->stat.stat = nlm4_denied;
 2236                 goto out;
 2237         }
 2238 
 2239         error = nlm_cancel_async_lock(af);
 2240 
 2241         if (error) {
 2242                 result->stat.stat = nlm4_denied;
 2243         } else {
 2244                 result->stat.stat = nlm4_granted;
 2245         }
 2246 
 2247         mtx_unlock(&host->nh_lock);
 2248 
 2249 out:
 2250         nlm_release_vfs_state(&vs);
 2251         if (rpcp)
 2252                 *rpcp = nlm_host_get_rpc(host, TRUE);
 2253         nlm_host_release(host);
 2254         return (0);
 2255 }
 2256 
 2257 int
 2258 nlm_do_unlock(nlm4_unlockargs *argp, nlm4_res *result, struct svc_req *rqstp,
 2259     CLIENT **rpcp)
 2260 {
 2261         fhandle_t fh;
 2262         struct vfs_state vs;
 2263         struct nlm_host *host;
 2264         int error, sysid;
 2265         struct flock fl;
 2266         
 2267         memset(result, 0, sizeof(*result));
 2268         memset(&vs, 0, sizeof(vs));
 2269 
 2270         host = nlm_find_host_by_name(argp->alock.caller_name,
 2271             svc_getrpccaller(rqstp), rqstp->rq_vers);
 2272         if (!host) {
 2273                 result->stat.stat = nlm4_denied_nolocks;
 2274                 return (ENOMEM);
 2275         }
 2276 
 2277         NLM_DEBUG(3, "nlm_do_unlock(): caller_name = %s (sysid = %d)\n",
 2278             host->nh_caller_name, host->nh_sysid);
 2279 
 2280         nlm_check_expired_locks(host);
 2281         sysid = host->nh_sysid;
 2282 
 2283         nlm_convert_to_fhandle_t(&fh, &argp->alock.fh);
 2284         nlm_copy_netobj(&result->cookie, &argp->cookie, M_RPC);
 2285 
 2286         if (time_uptime < nlm_grace_threshold) {
 2287                 result->stat.stat = nlm4_denied_grace_period;
 2288                 goto out;
 2289         }
 2290 
 2291         error = nlm_get_vfs_state(host, rqstp, &fh, &vs, (accmode_t)0);
 2292         if (error) {
 2293                 result->stat.stat = nlm_convert_error(error);
 2294                 goto out;
 2295         }
 2296 
 2297         fl.l_start = argp->alock.l_offset;
 2298         fl.l_len = argp->alock.l_len;
 2299         fl.l_pid = argp->alock.svid;
 2300         fl.l_sysid = sysid;
 2301         fl.l_whence = SEEK_SET;
 2302         fl.l_type = F_UNLCK;
 2303         error = VOP_ADVLOCK(vs.vs_vp, NULL, F_UNLCK, &fl, F_REMOTE);
 2304 
 2305         /*
 2306          * Ignore the error - there is no result code for failure,
 2307          * only for grace period.
 2308          */
 2309         result->stat.stat = nlm4_granted;
 2310 
 2311 out:
 2312         nlm_release_vfs_state(&vs);
 2313         if (rpcp)
 2314                 *rpcp = nlm_host_get_rpc(host, TRUE);
 2315         nlm_host_release(host);
 2316         return (0);
 2317 }
 2318 
 2319 int
 2320 nlm_do_granted(nlm4_testargs *argp, nlm4_res *result, struct svc_req *rqstp,
 2321 
 2322     CLIENT **rpcp)
 2323 {
 2324         struct nlm_host *host;
 2325         struct nlm_waiting_lock *nw;
 2326         
 2327         memset(result, 0, sizeof(*result));
 2328 
 2329         host = nlm_find_host_by_addr(svc_getrpccaller(rqstp), rqstp->rq_vers);
 2330         if (!host) {
 2331                 result->stat.stat = nlm4_denied_nolocks;
 2332                 return (ENOMEM);
 2333         }
 2334 
 2335         nlm_copy_netobj(&result->cookie, &argp->cookie, M_RPC);
 2336         result->stat.stat = nlm4_denied;
 2337         KFAIL_POINT_CODE(DEBUG_FP, nlm_deny_grant, goto out);
 2338 
 2339         mtx_lock(&nlm_global_lock);
 2340         TAILQ_FOREACH(nw, &nlm_waiting_locks, nw_link) {
 2341                 if (!nw->nw_waiting)
 2342                         continue;
 2343                 if (argp->alock.svid == nw->nw_lock.svid
 2344                     && argp->alock.l_offset == nw->nw_lock.l_offset
 2345                     && argp->alock.l_len == nw->nw_lock.l_len
 2346                     && argp->alock.fh.n_len == nw->nw_lock.fh.n_len
 2347                     && !memcmp(argp->alock.fh.n_bytes, nw->nw_lock.fh.n_bytes,
 2348                         nw->nw_lock.fh.n_len)) {
 2349                         nw->nw_waiting = FALSE;
 2350                         wakeup(nw);
 2351                         result->stat.stat = nlm4_granted;
 2352                         break;
 2353                 }
 2354         }
 2355         mtx_unlock(&nlm_global_lock);
 2356 
 2357 out:
 2358         if (rpcp)
 2359                 *rpcp = nlm_host_get_rpc(host, TRUE);
 2360         nlm_host_release(host);
 2361         return (0);
 2362 }
 2363 
 2364 void
 2365 nlm_do_granted_res(nlm4_res *argp, struct svc_req *rqstp)
 2366 {
 2367         struct nlm_host *host = NULL;
 2368         struct nlm_async_lock *af = NULL;
 2369         int error;
 2370 
 2371         if (argp->cookie.n_len != sizeof(struct nlm_grantcookie)) {
 2372                 NLM_DEBUG(1, "NLM: bogus grant cookie");
 2373                 goto out;
 2374         }
 2375 
 2376         host = nlm_find_host_by_sysid(ng_sysid(&argp->cookie));
 2377         if (!host) {
 2378                 NLM_DEBUG(1, "NLM: Unknown host rejected our grant");
 2379                 goto out;
 2380         }
 2381 
 2382         mtx_lock(&host->nh_lock);
 2383         TAILQ_FOREACH(af, &host->nh_granted, af_link)
 2384             if (ng_cookie(&argp->cookie) ==
 2385                 ng_cookie(&af->af_granted.cookie))
 2386                     break;
 2387         if (af)
 2388                 TAILQ_REMOVE(&host->nh_granted, af, af_link);
 2389         mtx_unlock(&host->nh_lock);
 2390 
 2391         if (!af) {
 2392                 NLM_DEBUG(1, "NLM: host %s (sysid %d) replied to our grant "
 2393                     "with unrecognized cookie %d:%d", host->nh_caller_name,
 2394                     host->nh_sysid, ng_sysid(&argp->cookie),
 2395                     ng_cookie(&argp->cookie));
 2396                 goto out;
 2397         }
 2398 
 2399         if (argp->stat.stat != nlm4_granted) {
 2400                 af->af_fl.l_type = F_UNLCK;
 2401                 error = VOP_ADVLOCK(af->af_vp, NULL, F_UNLCK, &af->af_fl, F_REMOTE);
 2402                 if (error) {
 2403                         NLM_DEBUG(1, "NLM: host %s (sysid %d) rejected our grant "
 2404                             "and we failed to unlock (%d)", host->nh_caller_name,
 2405                             host->nh_sysid, error);
 2406                         goto out;
 2407                 }
 2408 
 2409                 NLM_DEBUG(5, "NLM: async lock %p rejected by host %s (sysid %d)",
 2410                     af, host->nh_caller_name, host->nh_sysid);
 2411         } else {
 2412                 NLM_DEBUG(5, "NLM: async lock %p accepted by host %s (sysid %d)",
 2413                     af, host->nh_caller_name, host->nh_sysid);
 2414         }
 2415 
 2416  out:
 2417         if (af)
 2418                 nlm_free_async_lock(af);
 2419         if (host)
 2420                 nlm_host_release(host);
 2421 }
 2422 
 2423 void
 2424 nlm_do_free_all(nlm4_notify *argp)
 2425 {
 2426         struct nlm_host *host, *thost;
 2427 
 2428         TAILQ_FOREACH_SAFE(host, &nlm_hosts, nh_link, thost) {
 2429                 if (!strcmp(host->nh_caller_name, argp->name))
 2430                         nlm_host_notify(host, argp->state);
 2431         }
 2432 }
 2433 
 2434 /*
 2435  * Kernel module glue
 2436  */
 2437 static int
 2438 nfslockd_modevent(module_t mod, int type, void *data)
 2439 {
 2440 
 2441         return (0);
 2442 }
 2443 static moduledata_t nfslockd_mod = {
 2444         "nfslockd",
 2445         nfslockd_modevent,
 2446         NULL,
 2447 };
 2448 DECLARE_MODULE(nfslockd, nfslockd_mod, SI_SUB_VFS, SI_ORDER_ANY);
 2449 
 2450 /* So that loader and kldload(2) can find us, wherever we are.. */
 2451 MODULE_DEPEND(nfslockd, krpc, 1, 1, 1);
 2452 MODULE_DEPEND(nfslockd, nfslock, 1, 1, 1);
 2453 MODULE_VERSION(nfslockd, 1);

Cache object: 5e09571b7bec3ce6aa93ded1f6217b17


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.