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_advlock.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 <sys/cdefs.h>
   29 __FBSDID("$FreeBSD: releng/11.2/sys/nlm/nlm_advlock.c 302216 2016-06-26 20:08:42Z kib $");
   30 
   31 #include <sys/param.h>
   32 #include <sys/fcntl.h>
   33 #include <sys/jail.h>
   34 #include <sys/kernel.h>
   35 #include <sys/limits.h>
   36 #include <sys/lock.h>
   37 #include <sys/lockf.h>
   38 #include <sys/malloc.h>
   39 #include <sys/mbuf.h>
   40 #include <sys/mount.h>
   41 #include <sys/mutex.h>
   42 #include <sys/proc.h>
   43 #include <sys/socket.h>
   44 #include <sys/syslog.h>
   45 #include <sys/systm.h>
   46 #include <sys/unistd.h>
   47 #include <sys/vnode.h>
   48 
   49 #include <nfs/nfsproto.h>
   50 #include <nfsclient/nfs.h>
   51 #include <nfsclient/nfsmount.h>
   52 
   53 #include <nlm/nlm_prot.h>
   54 #include <nlm/nlm.h>
   55 
   56 /*
   57  * We need to keep track of the svid values used for F_FLOCK locks.
   58  */
   59 struct nlm_file_svid {
   60         int             ns_refs;        /* thread count + 1 if active */
   61         int             ns_svid;        /* on-the-wire SVID for this file */
   62         struct ucred    *ns_ucred;      /* creds to use for lock recovery */
   63         void            *ns_id;         /* local struct file pointer */
   64         bool_t          ns_active;      /* TRUE if we own a lock */
   65         LIST_ENTRY(nlm_file_svid) ns_link;
   66 };
   67 LIST_HEAD(nlm_file_svid_list, nlm_file_svid);
   68 
   69 #define NLM_SVID_HASH_SIZE      256
   70 struct nlm_file_svid_list nlm_file_svids[NLM_SVID_HASH_SIZE];
   71 
   72 struct mtx nlm_svid_lock;
   73 static struct unrhdr *nlm_svid_allocator;
   74 static volatile u_int nlm_xid = 1;
   75 
   76 static int nlm_setlock(struct nlm_host *host, struct rpc_callextra *ext,
   77     rpcvers_t vers, struct timeval *timo, int retries,
   78     struct vnode *vp, int op, struct flock *fl, int flags,
   79     int svid, size_t fhlen, void *fh, off_t size, bool_t reclaim);
   80 static int nlm_clearlock(struct nlm_host *host,  struct rpc_callextra *ext,
   81     rpcvers_t vers, struct timeval *timo, int retries,
   82     struct vnode *vp, int op, struct flock *fl, int flags,
   83     int svid, size_t fhlen, void *fh, off_t size);
   84 static int nlm_getlock(struct nlm_host *host, struct rpc_callextra *ext,
   85     rpcvers_t vers, struct timeval *timo, int retries,
   86     struct vnode *vp, int op, struct flock *fl, int flags,
   87     int svid, size_t fhlen, void *fh, off_t size);
   88 static int nlm_map_status(nlm4_stats stat);
   89 static struct nlm_file_svid *nlm_find_svid(void *id);
   90 static void nlm_free_svid(struct nlm_file_svid *nf);
   91 static int nlm_init_lock(struct flock *fl, int flags, int svid,
   92     rpcvers_t vers, size_t fhlen, void *fh, off_t size,
   93     struct nlm4_lock *lock, char oh_space[32]);
   94 
   95 static void
   96 nlm_client_init(void *dummy)
   97 {
   98         int i;
   99 
  100         mtx_init(&nlm_svid_lock, "NLM svid lock", NULL, MTX_DEF);
  101         /* pid_max cannot be greater than PID_MAX */
  102         nlm_svid_allocator = new_unrhdr(PID_MAX + 2, INT_MAX, &nlm_svid_lock);
  103         for (i = 0; i < NLM_SVID_HASH_SIZE; i++)
  104                 LIST_INIT(&nlm_file_svids[i]);
  105 }
  106 SYSINIT(nlm_client_init, SI_SUB_LOCK, SI_ORDER_FIRST, nlm_client_init, NULL);
  107 
  108 static int
  109 nlm_msg(struct thread *td, const char *server, const char *msg, int error)
  110 {
  111         struct proc *p;
  112 
  113         p = td ? td->td_proc : NULL;
  114         if (error) {
  115                 tprintf(p, LOG_INFO, "nfs server %s: %s, error %d\n", server,
  116                     msg, error);
  117         } else {
  118                 tprintf(p, LOG_INFO, "nfs server %s: %s\n", server, msg);
  119         }
  120         return (0);
  121 }
  122 
  123 struct nlm_feedback_arg {
  124         bool_t  nf_printed;
  125         struct nfsmount *nf_nmp;
  126 };
  127 
  128 static void
  129 nlm_down(struct nlm_feedback_arg *nf, struct thread *td,
  130     const char *msg, int error)
  131 {
  132         struct nfsmount *nmp = nf->nf_nmp;
  133 
  134         if (nmp == NULL)
  135                 return;
  136         mtx_lock(&nmp->nm_mtx);
  137         if (!(nmp->nm_state & NFSSTA_LOCKTIMEO)) {
  138                 nmp->nm_state |= NFSSTA_LOCKTIMEO;
  139                 mtx_unlock(&nmp->nm_mtx);
  140                 vfs_event_signal(&nmp->nm_mountp->mnt_stat.f_fsid,
  141                     VQ_NOTRESPLOCK, 0);
  142         } else {
  143                 mtx_unlock(&nmp->nm_mtx);
  144         }
  145 
  146         nf->nf_printed = TRUE;
  147         nlm_msg(td, nmp->nm_mountp->mnt_stat.f_mntfromname, msg, error);
  148 }
  149 
  150 static void
  151 nlm_up(struct nlm_feedback_arg *nf, struct thread *td,
  152     const char *msg)
  153 {
  154         struct nfsmount *nmp = nf->nf_nmp;
  155 
  156         if (!nf->nf_printed)
  157                 return;
  158 
  159         nlm_msg(td, nmp->nm_mountp->mnt_stat.f_mntfromname, msg, 0);
  160 
  161         mtx_lock(&nmp->nm_mtx);
  162         if (nmp->nm_state & NFSSTA_LOCKTIMEO) {
  163                 nmp->nm_state &= ~NFSSTA_LOCKTIMEO;
  164                 mtx_unlock(&nmp->nm_mtx);
  165                 vfs_event_signal(&nmp->nm_mountp->mnt_stat.f_fsid,
  166                     VQ_NOTRESPLOCK, 1);
  167         } else {
  168                 mtx_unlock(&nmp->nm_mtx);
  169         }
  170 }
  171 
  172 static void
  173 nlm_feedback(int type, int proc, void *arg)
  174 {
  175         struct thread *td = curthread;
  176         struct nlm_feedback_arg *nf = (struct nlm_feedback_arg *) arg;
  177 
  178         switch (type) {
  179         case FEEDBACK_REXMIT2:
  180         case FEEDBACK_RECONNECT:
  181                 nlm_down(nf, td, "lockd not responding", 0);
  182                 break;
  183 
  184         case FEEDBACK_OK:
  185                 nlm_up(nf, td, "lockd is alive again");
  186                 break;
  187         }
  188 }
  189 
  190 /*
  191  * nlm_advlock --
  192  *      NFS advisory byte-level locks.
  193  */
  194 static int
  195 nlm_advlock_internal(struct vnode *vp, void *id, int op, struct flock *fl,
  196     int flags, bool_t reclaim, bool_t unlock_vp)
  197 {
  198         struct thread *td = curthread;
  199         struct nfsmount *nmp;
  200         off_t size;
  201         size_t fhlen;
  202         union nfsfh fh;
  203         struct sockaddr *sa;
  204         struct sockaddr_storage ss;
  205         char servername[MNAMELEN];
  206         struct timeval timo;
  207         int retries;
  208         rpcvers_t vers;
  209         struct nlm_host *host;
  210         struct rpc_callextra ext;
  211         struct nlm_feedback_arg nf;
  212         AUTH *auth;
  213         struct ucred *cred, *cred1;
  214         struct nlm_file_svid *ns;
  215         int svid;
  216         int error;
  217         int is_v3;
  218 
  219         ASSERT_VOP_LOCKED(vp, "nlm_advlock_1");
  220 
  221         nmp = VFSTONFS(vp->v_mount);
  222         /*
  223          * Push any pending writes to the server and flush our cache
  224          * so that if we are contending with another machine for a
  225          * file, we get whatever they wrote and vice-versa.
  226          */
  227         if (op == F_SETLK || op == F_UNLCK)
  228                 nmp->nm_vinvalbuf(vp, V_SAVE, td, 1);
  229 
  230         strcpy(servername, nmp->nm_hostname);
  231         nmp->nm_getinfo(vp, fh.fh_bytes, &fhlen, &ss, &is_v3, &size, &timo);
  232         sa = (struct sockaddr *) &ss;
  233         if (is_v3 != 0)
  234                 vers = NLM_VERS4;
  235         else
  236                 vers = NLM_VERS;
  237 
  238         if (nmp->nm_flag & NFSMNT_SOFT)
  239                 retries = nmp->nm_retry;
  240         else
  241                 retries = INT_MAX;
  242 
  243         /*
  244          * We need to switch to mount-point creds so that we can send
  245          * packets from a privileged port.  Reference mnt_cred and
  246          * switch to them before unlocking the vnode, since mount
  247          * point could be unmounted right after unlock.
  248          */
  249         cred = td->td_ucred;
  250         td->td_ucred = vp->v_mount->mnt_cred;
  251         crhold(td->td_ucred);
  252         if (unlock_vp)
  253                 VOP_UNLOCK(vp, 0);
  254 
  255         host = nlm_find_host_by_name(servername, sa, vers);
  256         auth = authunix_create(cred);
  257         memset(&ext, 0, sizeof(ext));
  258 
  259         nf.nf_printed = FALSE;
  260         nf.nf_nmp = nmp;
  261         ext.rc_auth = auth;
  262 
  263         ext.rc_feedback = nlm_feedback;
  264         ext.rc_feedback_arg = &nf;
  265         ext.rc_timers = NULL;
  266 
  267         ns = NULL;
  268         if (flags & F_FLOCK) {
  269                 ns = nlm_find_svid(id);
  270                 KASSERT(fl->l_start == 0 && fl->l_len == 0,
  271                     ("F_FLOCK lock requests must be whole-file locks"));
  272                 if (!ns->ns_ucred) {
  273                         /*
  274                          * Remember the creds used for locking in case
  275                          * we need to recover the lock later.
  276                          */
  277                         ns->ns_ucred = crdup(cred);
  278                 }
  279                 svid = ns->ns_svid;
  280         } else if (flags & F_REMOTE) {
  281                 /*
  282                  * If we are recovering after a server restart or
  283                  * trashing locks on a force unmount, use the same
  284                  * svid as last time.
  285                  */
  286                 svid = fl->l_pid;
  287         } else {
  288                 svid = ((struct proc *) id)->p_pid;
  289         }
  290 
  291         switch(op) {
  292         case F_SETLK:
  293                 if ((flags & (F_FLOCK|F_WAIT)) == (F_FLOCK|F_WAIT)
  294                     && fl->l_type == F_WRLCK) {
  295                         /*
  296                          * The semantics for flock(2) require that any
  297                          * shared lock on the file must be released
  298                          * before an exclusive lock is granted. The
  299                          * local locking code interprets this by
  300                          * unlocking the file before sleeping on a
  301                          * blocked exclusive lock request. We
  302                          * approximate this by first attempting
  303                          * non-blocking and if that fails, we unlock
  304                          * the file and block.
  305                          */
  306                         error = nlm_setlock(host, &ext, vers, &timo, retries,
  307                             vp, F_SETLK, fl, flags & ~F_WAIT,
  308                             svid, fhlen, &fh.fh_bytes, size, reclaim);
  309                         if (error == EAGAIN) {
  310                                 fl->l_type = F_UNLCK;
  311                                 error = nlm_clearlock(host, &ext, vers, &timo,
  312                                     retries, vp, F_UNLCK, fl, flags,
  313                                     svid, fhlen, &fh.fh_bytes, size);
  314                                 fl->l_type = F_WRLCK;
  315                                 if (!error) {
  316                                         mtx_lock(&nlm_svid_lock);
  317                                         if (ns->ns_active) {
  318                                                 ns->ns_refs--;
  319                                                 ns->ns_active = FALSE;
  320                                         }
  321                                         mtx_unlock(&nlm_svid_lock);
  322                                         flags |= F_WAIT;
  323                                         error = nlm_setlock(host, &ext, vers,
  324                                             &timo, retries, vp, F_SETLK, fl,
  325                                             flags, svid, fhlen, &fh.fh_bytes,
  326                                             size, reclaim);
  327                                 }
  328                         }
  329                 } else {
  330                         error = nlm_setlock(host, &ext, vers, &timo, retries,
  331                             vp, op, fl, flags, svid, fhlen, &fh.fh_bytes,
  332                             size, reclaim);
  333                 }
  334                 if (!error && ns) {
  335                         mtx_lock(&nlm_svid_lock);
  336                         if (!ns->ns_active) {
  337                                 /*
  338                                  * Add one to the reference count to
  339                                  * hold onto the SVID for the lifetime
  340                                  * of the lock. Note that since
  341                                  * F_FLOCK only supports whole-file
  342                                  * locks, there can only be one active
  343                                  * lock for this SVID.
  344                                  */
  345                                 ns->ns_refs++;
  346                                 ns->ns_active = TRUE;
  347                         }
  348                         mtx_unlock(&nlm_svid_lock);
  349                 }
  350                 break;
  351 
  352         case F_UNLCK:
  353                 error = nlm_clearlock(host, &ext, vers, &timo, retries,
  354                     vp, op, fl, flags, svid, fhlen, &fh.fh_bytes, size);
  355                 if (!error && ns) {
  356                         mtx_lock(&nlm_svid_lock);
  357                         if (ns->ns_active) {
  358                                 ns->ns_refs--;
  359                                 ns->ns_active = FALSE;
  360                         }
  361                         mtx_unlock(&nlm_svid_lock);
  362                 }
  363                 break;
  364 
  365         case F_GETLK:
  366                 error = nlm_getlock(host, &ext, vers, &timo, retries,
  367                     vp, op, fl, flags, svid, fhlen, &fh.fh_bytes, size);
  368                 break;
  369 
  370         default:
  371                 error = EINVAL;
  372                 break;
  373         }
  374 
  375         if (ns)
  376                 nlm_free_svid(ns);
  377 
  378         cred1 = td->td_ucred;
  379         td->td_ucred = cred;
  380         crfree(cred1);
  381         AUTH_DESTROY(auth);
  382 
  383         nlm_host_release(host);
  384 
  385         return (error);
  386 }
  387 
  388 int
  389 nlm_advlock(struct vop_advlock_args *ap)
  390 {
  391 
  392         return (nlm_advlock_internal(ap->a_vp, ap->a_id, ap->a_op, ap->a_fl,
  393                 ap->a_flags, FALSE, TRUE));
  394 }
  395 
  396 /*
  397  * Set the creds of td to the creds of the given lock's owner. The new
  398  * creds reference count will be incremented via crhold. The caller is
  399  * responsible for calling crfree and restoring td's original creds.
  400  */
  401 static void
  402 nlm_set_creds_for_lock(struct thread *td, struct flock *fl)
  403 {
  404         int i;
  405         struct nlm_file_svid *ns;
  406         struct proc *p;
  407         struct ucred *cred;
  408 
  409         cred = NULL;
  410         if (fl->l_pid > PID_MAX) {
  411                 /*
  412                  * If this was originally a F_FLOCK-style lock, we
  413                  * recorded the creds used when it was originally
  414                  * locked in the nlm_file_svid structure.
  415                  */
  416                 mtx_lock(&nlm_svid_lock);
  417                 for (i = 0; i < NLM_SVID_HASH_SIZE; i++) {
  418                         for (ns = LIST_FIRST(&nlm_file_svids[i]); ns;
  419                              ns = LIST_NEXT(ns, ns_link)) {
  420                                 if (ns->ns_svid == fl->l_pid) {
  421                                         cred = crhold(ns->ns_ucred);
  422                                         break;
  423                                 }
  424                         }
  425                 }
  426                 mtx_unlock(&nlm_svid_lock);
  427         } else {
  428                 /*
  429                  * This lock is owned by a process. Get a reference to
  430                  * the process creds.
  431                  */
  432                 p = pfind(fl->l_pid);
  433                 if (p) {
  434                         cred = crhold(p->p_ucred);
  435                         PROC_UNLOCK(p);
  436                 }
  437         }
  438 
  439         /*
  440          * If we can't find a cred, fall back on the recovery
  441          * thread's cred.
  442          */
  443         if (!cred) {
  444                 cred = crhold(td->td_ucred);
  445         }
  446 
  447         td->td_ucred = cred;
  448 }
  449 
  450 static int
  451 nlm_reclaim_free_lock(struct vnode *vp, struct flock *fl, void *arg)
  452 {
  453         struct flock newfl;
  454         struct thread *td = curthread;
  455         struct ucred *oldcred;
  456         int error;
  457 
  458         newfl = *fl;
  459         newfl.l_type = F_UNLCK;
  460 
  461         oldcred = td->td_ucred;
  462         nlm_set_creds_for_lock(td, &newfl);
  463 
  464         error = nlm_advlock_internal(vp, NULL, F_UNLCK, &newfl, F_REMOTE,
  465             FALSE, FALSE);
  466 
  467         crfree(td->td_ucred);
  468         td->td_ucred = oldcred;
  469 
  470         return (error);
  471 }
  472 
  473 int
  474 nlm_reclaim(struct vop_reclaim_args *ap)
  475 {
  476 
  477         nlm_cancel_wait(ap->a_vp);
  478         lf_iteratelocks_vnode(ap->a_vp, nlm_reclaim_free_lock, NULL);
  479         return (0);
  480 }
  481 
  482 struct nlm_recovery_context {
  483         struct nlm_host *nr_host;       /* host we are recovering */
  484         int             nr_state;       /* remote NSM state for recovery */
  485 };
  486 
  487 static int
  488 nlm_client_recover_lock(struct vnode *vp, struct flock *fl, void *arg)
  489 {
  490         struct nlm_recovery_context *nr = (struct nlm_recovery_context *) arg;
  491         struct thread *td = curthread;
  492         struct ucred *oldcred;
  493         int state, error;
  494 
  495         /*
  496          * If the remote NSM state changes during recovery, the host
  497          * must have rebooted a second time. In that case, we must
  498          * restart the recovery.
  499          */
  500         state = nlm_host_get_state(nr->nr_host);
  501         if (nr->nr_state != state)
  502                 return (ERESTART);
  503 
  504         error = vn_lock(vp, LK_SHARED);
  505         if (error)
  506                 return (error);
  507 
  508         oldcred = td->td_ucred;
  509         nlm_set_creds_for_lock(td, fl);
  510 
  511         error = nlm_advlock_internal(vp, NULL, F_SETLK, fl, F_REMOTE,
  512             TRUE, TRUE);
  513 
  514         crfree(td->td_ucred);
  515         td->td_ucred = oldcred;
  516 
  517         return (error);
  518 }
  519 
  520 void
  521 nlm_client_recovery(struct nlm_host *host)
  522 {
  523         struct nlm_recovery_context nr;
  524         int sysid, error;
  525 
  526         sysid = NLM_SYSID_CLIENT | nlm_host_get_sysid(host);
  527         do {
  528                 nr.nr_host = host;
  529                 nr.nr_state = nlm_host_get_state(host);
  530                 error = lf_iteratelocks_sysid(sysid,
  531                     nlm_client_recover_lock, &nr);
  532         } while (error == ERESTART);
  533 }
  534 
  535 static void
  536 nlm_convert_to_nlm_lock(struct nlm_lock *dst, struct nlm4_lock *src)
  537 {
  538 
  539         dst->caller_name = src->caller_name;
  540         dst->fh = src->fh;
  541         dst->oh = src->oh;
  542         dst->svid = src->svid;
  543         dst->l_offset = src->l_offset;
  544         dst->l_len = src->l_len;
  545 }
  546 
  547 static void
  548 nlm_convert_to_nlm4_holder(struct nlm4_holder *dst, struct nlm_holder *src)
  549 {
  550 
  551         dst->exclusive = src->exclusive;
  552         dst->svid = src->svid;
  553         dst->oh = src->oh;
  554         dst->l_offset = src->l_offset;
  555         dst->l_len = src->l_len;
  556 }
  557 
  558 static void
  559 nlm_convert_to_nlm4_res(struct nlm4_res *dst, struct nlm_res *src)
  560 {
  561         dst->cookie = src->cookie;
  562         dst->stat.stat = (enum nlm4_stats) src->stat.stat;
  563 }
  564 
  565 static enum clnt_stat
  566 nlm_test_rpc(rpcvers_t vers, nlm4_testargs *args, nlm4_testres *res, CLIENT *client,
  567     struct rpc_callextra *ext, struct timeval timo)
  568 {
  569         if (vers == NLM_VERS4) {
  570                 return nlm4_test_4(args, res, client, ext, timo);
  571         } else {
  572                 nlm_testargs args1;
  573                 nlm_testres res1;
  574                 enum clnt_stat stat;
  575 
  576                 args1.cookie = args->cookie;
  577                 args1.exclusive = args->exclusive;
  578                 nlm_convert_to_nlm_lock(&args1.alock, &args->alock);
  579                 memset(&res1, 0, sizeof(res1));
  580 
  581                 stat = nlm_test_1(&args1, &res1, client, ext, timo);
  582 
  583                 if (stat == RPC_SUCCESS) {
  584                         res->cookie = res1.cookie;
  585                         res->stat.stat = (enum nlm4_stats) res1.stat.stat;
  586                         if (res1.stat.stat == nlm_denied)
  587                                 nlm_convert_to_nlm4_holder(
  588                                         &res->stat.nlm4_testrply_u.holder,
  589                                         &res1.stat.nlm_testrply_u.holder);
  590                 }
  591 
  592                 return (stat);
  593         }
  594 }
  595 
  596 static enum clnt_stat
  597 nlm_lock_rpc(rpcvers_t vers, nlm4_lockargs *args, nlm4_res *res, CLIENT *client,
  598     struct rpc_callextra *ext, struct timeval timo)
  599 {
  600         if (vers == NLM_VERS4) {
  601                 return nlm4_lock_4(args, res, client, ext, timo);
  602         } else {
  603                 nlm_lockargs args1;
  604                 nlm_res res1;
  605                 enum clnt_stat stat;
  606 
  607                 args1.cookie = args->cookie;
  608                 args1.block = args->block;
  609                 args1.exclusive = args->exclusive;
  610                 nlm_convert_to_nlm_lock(&args1.alock, &args->alock);
  611                 args1.reclaim = args->reclaim;
  612                 args1.state = args->state;
  613                 memset(&res1, 0, sizeof(res1));
  614 
  615                 stat = nlm_lock_1(&args1, &res1, client, ext, timo);
  616 
  617                 if (stat == RPC_SUCCESS) {
  618                         nlm_convert_to_nlm4_res(res, &res1);
  619                 }
  620 
  621                 return (stat);
  622         }
  623 }
  624 
  625 static enum clnt_stat
  626 nlm_cancel_rpc(rpcvers_t vers, nlm4_cancargs *args, nlm4_res *res, CLIENT *client,
  627     struct rpc_callextra *ext, struct timeval timo)
  628 {
  629         if (vers == NLM_VERS4) {
  630                 return nlm4_cancel_4(args, res, client, ext, timo);
  631         } else {
  632                 nlm_cancargs args1;
  633                 nlm_res res1;
  634                 enum clnt_stat stat;
  635 
  636                 args1.cookie = args->cookie;
  637                 args1.block = args->block;
  638                 args1.exclusive = args->exclusive;
  639                 nlm_convert_to_nlm_lock(&args1.alock, &args->alock);
  640                 memset(&res1, 0, sizeof(res1));
  641 
  642                 stat = nlm_cancel_1(&args1, &res1, client, ext, timo);
  643 
  644                 if (stat == RPC_SUCCESS) {
  645                         nlm_convert_to_nlm4_res(res, &res1);
  646                 }
  647 
  648                 return (stat);
  649         }
  650 }
  651 
  652 static enum clnt_stat
  653 nlm_unlock_rpc(rpcvers_t vers, nlm4_unlockargs *args, nlm4_res *res, CLIENT *client,
  654     struct rpc_callextra *ext, struct timeval timo)
  655 {
  656         if (vers == NLM_VERS4) {
  657                 return nlm4_unlock_4(args, res, client, ext, timo);
  658         } else {
  659                 nlm_unlockargs args1;
  660                 nlm_res res1;
  661                 enum clnt_stat stat;
  662 
  663                 args1.cookie = args->cookie;
  664                 nlm_convert_to_nlm_lock(&args1.alock, &args->alock);
  665                 memset(&res1, 0, sizeof(res1));
  666 
  667                 stat = nlm_unlock_1(&args1, &res1, client, ext, timo);
  668 
  669                 if (stat == RPC_SUCCESS) {
  670                         nlm_convert_to_nlm4_res(res, &res1);
  671                 }
  672 
  673                 return (stat);
  674         }
  675 }
  676 
  677 /*
  678  * Called after a lock request (set or clear) succeeded. We record the
  679  * details in the local lock manager. Note that since the remote
  680  * server has granted the lock, we can be sure that it doesn't
  681  * conflict with any other locks we have in the local lock manager.
  682  *
  683  * Since it is possible that host may also make NLM client requests to
  684  * our NLM server, we use a different sysid value to record our own
  685  * client locks.
  686  *
  687  * Note that since it is possible for us to receive replies from the
  688  * server in a different order than the locks were granted (e.g. if
  689  * many local threads are contending for the same lock), we must use a
  690  * blocking operation when registering with the local lock manager.
  691  * We expect that any actual wait will be rare and short hence we
  692  * ignore signals for this.
  693  */
  694 static void
  695 nlm_record_lock(struct vnode *vp, int op, struct flock *fl,
  696     int svid, int sysid, off_t size)
  697 {
  698         struct vop_advlockasync_args a;
  699         struct flock newfl;
  700         struct proc *p;
  701         int error, stops_deferred;
  702 
  703         a.a_vp = vp;
  704         a.a_id = NULL;
  705         a.a_op = op;
  706         a.a_fl = &newfl;
  707         a.a_flags = F_REMOTE|F_WAIT|F_NOINTR;
  708         a.a_task = NULL;
  709         a.a_cookiep = NULL;
  710         newfl.l_start = fl->l_start;
  711         newfl.l_len = fl->l_len;
  712         newfl.l_type = fl->l_type;
  713         newfl.l_whence = fl->l_whence;
  714         newfl.l_pid = svid;
  715         newfl.l_sysid = NLM_SYSID_CLIENT | sysid;
  716 
  717         for (;;) {
  718                 error = lf_advlockasync(&a, &vp->v_lockf, size);
  719                 if (error == EDEADLK) {
  720                         /*
  721                          * Locks are associated with the processes and
  722                          * not with threads.  Suppose we have two
  723                          * threads A1 A2 in one process, A1 locked
  724                          * file f1, A2 is locking file f2, and A1 is
  725                          * unlocking f1. Then remote server may
  726                          * already unlocked f1, while local still not
  727                          * yet scheduled A1 to make the call to local
  728                          * advlock manager. The process B owns lock on
  729                          * f2 and issued the lock on f1.  Remote would
  730                          * grant B the request on f1, but local would
  731                          * return EDEADLK.
  732                         */
  733                         pause("nlmdlk", 1);
  734                         p = curproc;
  735                         stops_deferred = sigdeferstop(SIGDEFERSTOP_OFF);
  736                         PROC_LOCK(p);
  737                         thread_suspend_check(0);
  738                         PROC_UNLOCK(p);
  739                         sigallowstop(stops_deferred);
  740                 } else if (error == EINTR) {
  741                         /*
  742                          * lf_purgelocks() might wake up the lock
  743                          * waiter and removed our lock graph edges.
  744                          * There is no sense in re-trying recording
  745                          * the lock to the local manager after
  746                          * reclaim.
  747                          */
  748                         error = 0;
  749                         break;
  750                 } else
  751                         break;
  752         }
  753         KASSERT(error == 0 || error == ENOENT,
  754             ("Failed to register NFS lock locally - error=%d", error));
  755 }
  756 
  757 static int
  758 nlm_setlock(struct nlm_host *host, struct rpc_callextra *ext,
  759     rpcvers_t vers, struct timeval *timo, int retries,
  760     struct vnode *vp, int op, struct flock *fl, int flags,
  761     int svid, size_t fhlen, void *fh, off_t size, bool_t reclaim)
  762 {
  763         struct nlm4_lockargs args;
  764         char oh_space[32];
  765         struct nlm4_res res;
  766         u_int xid;
  767         CLIENT *client;
  768         enum clnt_stat stat;
  769         int retry, block, exclusive;
  770         void *wait_handle = NULL;
  771         int error;
  772 
  773         memset(&args, 0, sizeof(args));
  774         memset(&res, 0, sizeof(res));
  775 
  776         block = (flags & F_WAIT) ? TRUE : FALSE;
  777         exclusive = (fl->l_type == F_WRLCK);
  778 
  779         error = nlm_init_lock(fl, flags, svid, vers, fhlen, fh, size,
  780             &args.alock, oh_space);
  781         if (error)
  782                 return (error);
  783         args.block = block;
  784         args.exclusive = exclusive;
  785         args.reclaim = reclaim;
  786         args.state = nlm_nsm_state;
  787 
  788         retry = 5*hz;
  789         for (;;) {
  790                 client = nlm_host_get_rpc(host, FALSE);
  791                 if (!client)
  792                         return (ENOLCK); /* XXX retry? */
  793 
  794                 if (block)
  795                         wait_handle = nlm_register_wait_lock(&args.alock, vp);
  796 
  797                 xid = atomic_fetchadd_int(&nlm_xid, 1);
  798                 args.cookie.n_len = sizeof(xid);
  799                 args.cookie.n_bytes = (char*) &xid;
  800 
  801                 stat = nlm_lock_rpc(vers, &args, &res, client, ext, *timo);
  802 
  803                 CLNT_RELEASE(client);
  804 
  805                 if (stat != RPC_SUCCESS) {
  806                         if (block)
  807                                 nlm_deregister_wait_lock(wait_handle);
  808                         if (retries) {
  809                                 retries--;
  810                                 continue;
  811                         }
  812                         return (EINVAL);
  813                 }
  814 
  815                 /*
  816                  * Free res.cookie.
  817                  */
  818                 xdr_free((xdrproc_t) xdr_nlm4_res, &res);
  819 
  820                 if (block && res.stat.stat != nlm4_blocked)
  821                         nlm_deregister_wait_lock(wait_handle);
  822 
  823                 if (res.stat.stat == nlm4_denied_grace_period) {
  824                         /*
  825                          * The server has recently rebooted and is
  826                          * giving old clients a change to reclaim
  827                          * their locks. Wait for a few seconds and try
  828                          * again.
  829                          */
  830                         error = tsleep(&args, PCATCH, "nlmgrace", retry);
  831                         if (error && error != EWOULDBLOCK)
  832                                 return (error);
  833                         retry = 2*retry;
  834                         if (retry > 30*hz)
  835                                 retry = 30*hz;
  836                         continue;
  837                 }
  838 
  839                 if (block && res.stat.stat == nlm4_blocked) {
  840                         /*
  841                          * The server should call us back with a
  842                          * granted message when the lock succeeds. In
  843                          * order to deal with broken servers, lost
  844                          * granted messages and server reboots, we
  845                          * will also re-try every few seconds.
  846                          */
  847                         error = nlm_wait_lock(wait_handle, retry);
  848                         if (error == EWOULDBLOCK) {
  849                                 retry = 2*retry;
  850                                 if (retry > 30*hz)
  851                                         retry = 30*hz;
  852                                 continue;
  853                         }
  854                         if (error) {
  855                                 /*
  856                                  * We need to call the server to
  857                                  * cancel our lock request.
  858                                  */
  859                                 nlm4_cancargs cancel;
  860 
  861                                 memset(&cancel, 0, sizeof(cancel));
  862 
  863                                 xid = atomic_fetchadd_int(&nlm_xid, 1);
  864                                 cancel.cookie.n_len = sizeof(xid);
  865                                 cancel.cookie.n_bytes = (char*) &xid;
  866                                 cancel.block = block;
  867                                 cancel.exclusive = exclusive;
  868                                 cancel.alock = args.alock;
  869 
  870                                 do {
  871                                         client = nlm_host_get_rpc(host, FALSE);
  872                                         if (!client)
  873                                                 /* XXX retry? */
  874                                                 return (ENOLCK);
  875 
  876                                         stat = nlm_cancel_rpc(vers, &cancel,
  877                                             &res, client, ext, *timo);
  878 
  879                                         CLNT_RELEASE(client);
  880 
  881                                         if (stat != RPC_SUCCESS) {
  882                                                 /*
  883                                                  * We need to cope
  884                                                  * with temporary
  885                                                  * network partitions
  886                                                  * as well as server
  887                                                  * reboots. This means
  888                                                  * we have to keep
  889                                                  * trying to cancel
  890                                                  * until the server
  891                                                  * wakes up again.
  892                                                  */
  893                                                 pause("nlmcancel", 10*hz);
  894                                         }
  895                                 } while (stat != RPC_SUCCESS);
  896 
  897                                 /*
  898                                  * Free res.cookie.
  899                                  */
  900                                 xdr_free((xdrproc_t) xdr_nlm4_res, &res);
  901 
  902                                 switch (res.stat.stat) {
  903                                 case nlm_denied:
  904                                         /*
  905                                          * There was nothing
  906                                          * to cancel. We are
  907                                          * going to go ahead
  908                                          * and assume we got
  909                                          * the lock.
  910                                          */
  911                                         error = 0;
  912                                         break;
  913 
  914                                 case nlm4_denied_grace_period:
  915                                         /*
  916                                          * The server has
  917                                          * recently rebooted -
  918                                          * treat this as a
  919                                          * successful
  920                                          * cancellation.
  921                                          */
  922                                         break;
  923 
  924                                 case nlm4_granted:
  925                                         /*
  926                                          * We managed to
  927                                          * cancel.
  928                                          */
  929                                         break;
  930 
  931                                 default:
  932                                         /*
  933                                          * Broken server
  934                                          * implementation -
  935                                          * can't really do
  936                                          * anything here.
  937                                          */
  938                                         break;
  939                                 }
  940 
  941                         }
  942                 } else {
  943                         error = nlm_map_status(res.stat.stat);
  944                 }
  945 
  946                 if (!error && !reclaim) {
  947                         nlm_record_lock(vp, op, fl, args.alock.svid,
  948                             nlm_host_get_sysid(host), size);
  949                         nlm_host_monitor(host, 0);
  950                 }
  951 
  952                 return (error);
  953         }
  954 }
  955 
  956 static int
  957 nlm_clearlock(struct nlm_host *host, struct rpc_callextra *ext,
  958     rpcvers_t vers, struct timeval *timo, int retries,
  959     struct vnode *vp, int op, struct flock *fl, int flags,
  960     int svid, size_t fhlen, void *fh, off_t size)
  961 {
  962         struct nlm4_unlockargs args;
  963         char oh_space[32];
  964         struct nlm4_res res;
  965         u_int xid;
  966         CLIENT *client;
  967         enum clnt_stat stat;
  968         int error;
  969 
  970         memset(&args, 0, sizeof(args));
  971         memset(&res, 0, sizeof(res));
  972 
  973         error = nlm_init_lock(fl, flags, svid, vers, fhlen, fh, size,
  974             &args.alock, oh_space);
  975         if (error)
  976                 return (error);
  977 
  978         for (;;) {
  979                 client = nlm_host_get_rpc(host, FALSE);
  980                 if (!client)
  981                         return (ENOLCK); /* XXX retry? */
  982 
  983                 xid = atomic_fetchadd_int(&nlm_xid, 1);
  984                 args.cookie.n_len = sizeof(xid);
  985                 args.cookie.n_bytes = (char*) &xid;
  986 
  987                 stat = nlm_unlock_rpc(vers, &args, &res, client, ext, *timo);
  988 
  989                 CLNT_RELEASE(client);
  990 
  991                 if (stat != RPC_SUCCESS) {
  992                         if (retries) {
  993                                 retries--;
  994                                 continue;
  995                         }
  996                         return (EINVAL);
  997                 }
  998 
  999                 /*
 1000                  * Free res.cookie.
 1001                  */
 1002                 xdr_free((xdrproc_t) xdr_nlm4_res, &res);
 1003 
 1004                 if (res.stat.stat == nlm4_denied_grace_period) {
 1005                         /*
 1006                          * The server has recently rebooted and is
 1007                          * giving old clients a change to reclaim
 1008                          * their locks. Wait for a few seconds and try
 1009                          * again.
 1010                          */
 1011                         error = tsleep(&args, PCATCH, "nlmgrace", 5*hz);
 1012                         if (error && error != EWOULDBLOCK)
 1013                                 return (error);
 1014                         continue;
 1015                 }
 1016 
 1017                 /*
 1018                  * If we are being called via nlm_reclaim (which will
 1019                  * use the F_REMOTE flag), don't record the lock
 1020                  * operation in the local lock manager since the vnode
 1021                  * is going away.
 1022                  */
 1023                 if (!(flags & F_REMOTE))
 1024                         nlm_record_lock(vp, op, fl, args.alock.svid,
 1025                             nlm_host_get_sysid(host), size);
 1026 
 1027                 return (0);
 1028         }
 1029 }
 1030 
 1031 static int
 1032 nlm_getlock(struct nlm_host *host, struct rpc_callextra *ext,
 1033     rpcvers_t vers, struct timeval *timo, int retries,
 1034     struct vnode *vp, int op, struct flock *fl, int flags,
 1035     int svid, size_t fhlen, void *fh, off_t size)
 1036 {
 1037         struct nlm4_testargs args;
 1038         char oh_space[32];
 1039         struct nlm4_testres res;
 1040         u_int xid;
 1041         CLIENT *client;
 1042         enum clnt_stat stat;
 1043         int exclusive;
 1044         int error;
 1045 
 1046         KASSERT(!(flags & F_FLOCK), ("unexpected F_FLOCK for F_GETLK"));
 1047 
 1048         memset(&args, 0, sizeof(args));
 1049         memset(&res, 0, sizeof(res));
 1050 
 1051         exclusive = (fl->l_type == F_WRLCK);
 1052 
 1053         error = nlm_init_lock(fl, flags, svid, vers, fhlen, fh, size,
 1054             &args.alock, oh_space);
 1055         if (error)
 1056                 return (error);
 1057         args.exclusive = exclusive;
 1058 
 1059         for (;;) {
 1060                 client = nlm_host_get_rpc(host, FALSE);
 1061                 if (!client)
 1062                         return (ENOLCK); /* XXX retry? */
 1063 
 1064                 xid = atomic_fetchadd_int(&nlm_xid, 1);
 1065                 args.cookie.n_len = sizeof(xid);
 1066                 args.cookie.n_bytes = (char*) &xid;
 1067 
 1068                 stat = nlm_test_rpc(vers, &args, &res, client, ext, *timo);
 1069 
 1070                 CLNT_RELEASE(client);
 1071 
 1072                 if (stat != RPC_SUCCESS) {
 1073                         if (retries) {
 1074                                 retries--;
 1075                                 continue;
 1076                         }
 1077                         return (EINVAL);
 1078                 }
 1079 
 1080                 if (res.stat.stat == nlm4_denied_grace_period) {
 1081                         /*
 1082                          * The server has recently rebooted and is
 1083                          * giving old clients a change to reclaim
 1084                          * their locks. Wait for a few seconds and try
 1085                          * again.
 1086                          */
 1087                         xdr_free((xdrproc_t) xdr_nlm4_testres, &res);
 1088                         error = tsleep(&args, PCATCH, "nlmgrace", 5*hz);
 1089                         if (error && error != EWOULDBLOCK)
 1090                                 return (error);
 1091                         continue;
 1092                 }
 1093 
 1094                 if (res.stat.stat == nlm4_denied) {
 1095                         struct nlm4_holder *h =
 1096                                 &res.stat.nlm4_testrply_u.holder;
 1097                         fl->l_start = h->l_offset;
 1098                         fl->l_len = h->l_len;
 1099                         fl->l_pid = h->svid;
 1100                         if (h->exclusive)
 1101                                 fl->l_type = F_WRLCK;
 1102                         else
 1103                                 fl->l_type = F_RDLCK;
 1104                         fl->l_whence = SEEK_SET;
 1105                         fl->l_sysid = 0;
 1106                 } else {
 1107                         fl->l_type = F_UNLCK;
 1108                 }
 1109 
 1110                 xdr_free((xdrproc_t) xdr_nlm4_testres, &res);
 1111 
 1112                 return (0);
 1113         }
 1114 }
 1115 
 1116 static int
 1117 nlm_map_status(nlm4_stats stat)
 1118 {
 1119         switch (stat) {
 1120         case nlm4_granted:
 1121                 return (0);
 1122 
 1123         case nlm4_denied:
 1124                 return (EAGAIN);
 1125 
 1126         case nlm4_denied_nolocks:
 1127                 return (ENOLCK);
 1128 
 1129         case nlm4_deadlck:
 1130                 return (EDEADLK);
 1131 
 1132         case nlm4_rofs:
 1133                 return (EROFS);
 1134 
 1135         case nlm4_stale_fh:
 1136                 return (ESTALE);
 1137 
 1138         case nlm4_fbig:
 1139                 return (EFBIG);
 1140 
 1141         case nlm4_failed:
 1142                 return (EACCES);
 1143 
 1144         default:
 1145                 return (EINVAL);
 1146         }
 1147 }
 1148 
 1149 static struct nlm_file_svid *
 1150 nlm_find_svid(void *id)
 1151 {
 1152         struct nlm_file_svid *ns, *newns;
 1153         int h;
 1154 
 1155         h = (((uintptr_t) id) >> 7) % NLM_SVID_HASH_SIZE;
 1156 
 1157         mtx_lock(&nlm_svid_lock);
 1158         LIST_FOREACH(ns, &nlm_file_svids[h], ns_link) {
 1159                 if (ns->ns_id == id) {
 1160                         ns->ns_refs++;
 1161                         break;
 1162                 }
 1163         }
 1164         mtx_unlock(&nlm_svid_lock);
 1165         if (!ns) {
 1166                 int svid = alloc_unr(nlm_svid_allocator);
 1167                 newns = malloc(sizeof(struct nlm_file_svid), M_NLM,
 1168                     M_WAITOK);
 1169                 newns->ns_refs = 1;
 1170                 newns->ns_id = id;
 1171                 newns->ns_svid = svid;
 1172                 newns->ns_ucred = NULL;
 1173                 newns->ns_active = FALSE;
 1174 
 1175                 /*
 1176                  * We need to check for a race with some other
 1177                  * thread allocating a svid for this file.
 1178                  */
 1179                 mtx_lock(&nlm_svid_lock);
 1180                 LIST_FOREACH(ns, &nlm_file_svids[h], ns_link) {
 1181                         if (ns->ns_id == id) {
 1182                                 ns->ns_refs++;
 1183                                 break;
 1184                         }
 1185                 }
 1186                 if (ns) {
 1187                         mtx_unlock(&nlm_svid_lock);
 1188                         free_unr(nlm_svid_allocator, newns->ns_svid);
 1189                         free(newns, M_NLM);
 1190                 } else {
 1191                         LIST_INSERT_HEAD(&nlm_file_svids[h], newns,
 1192                             ns_link);
 1193                         ns = newns;
 1194                         mtx_unlock(&nlm_svid_lock);
 1195                 }
 1196         }
 1197 
 1198         return (ns);
 1199 }
 1200 
 1201 static void
 1202 nlm_free_svid(struct nlm_file_svid *ns)
 1203 {
 1204 
 1205         mtx_lock(&nlm_svid_lock);
 1206         ns->ns_refs--;
 1207         if (!ns->ns_refs) {
 1208                 KASSERT(!ns->ns_active, ("Freeing active SVID"));
 1209                 LIST_REMOVE(ns, ns_link);
 1210                 mtx_unlock(&nlm_svid_lock);
 1211                 free_unr(nlm_svid_allocator, ns->ns_svid);
 1212                 if (ns->ns_ucred)
 1213                         crfree(ns->ns_ucred);
 1214                 free(ns, M_NLM);
 1215         } else {
 1216                 mtx_unlock(&nlm_svid_lock);
 1217         }
 1218 }
 1219 
 1220 static int
 1221 nlm_init_lock(struct flock *fl, int flags, int svid,
 1222     rpcvers_t vers, size_t fhlen, void *fh, off_t size,
 1223     struct nlm4_lock *lock, char oh_space[32])
 1224 {
 1225         size_t oh_len;
 1226         off_t start, len;
 1227 
 1228         if (fl->l_whence == SEEK_END) {
 1229                 if (size > OFF_MAX
 1230                     || (fl->l_start > 0 && size > OFF_MAX - fl->l_start))
 1231                         return (EOVERFLOW);
 1232                 start = size + fl->l_start;
 1233         } else if (fl->l_whence == SEEK_SET || fl->l_whence == SEEK_CUR) {
 1234                 start = fl->l_start;
 1235         } else {
 1236                 return (EINVAL);
 1237         }
 1238         if (start < 0)
 1239                 return (EINVAL);
 1240         if (fl->l_len < 0) {
 1241                 len = -fl->l_len;
 1242                 start -= len;
 1243                 if (start < 0)
 1244                         return (EINVAL);
 1245         } else {
 1246                 len = fl->l_len;
 1247         }
 1248 
 1249         if (vers == NLM_VERS) {
 1250                 /*
 1251                  * Enforce range limits on V1 locks
 1252                  */
 1253                 if (start > 0xffffffffLL || len > 0xffffffffLL)
 1254                         return (EOVERFLOW);
 1255         }
 1256 
 1257         snprintf(oh_space, 32, "%d@", svid);
 1258         oh_len = strlen(oh_space);
 1259         getcredhostname(NULL, oh_space + oh_len, 32 - oh_len);
 1260         oh_len = strlen(oh_space);
 1261 
 1262         memset(lock, 0, sizeof(*lock));
 1263         lock->caller_name = prison0.pr_hostname;
 1264         lock->fh.n_len = fhlen;
 1265         lock->fh.n_bytes = fh;
 1266         lock->oh.n_len = oh_len;
 1267         lock->oh.n_bytes = oh_space;
 1268         lock->svid = svid;
 1269         lock->l_offset = start;
 1270         lock->l_len = len;
 1271 
 1272         return (0);
 1273 }

Cache object: 6f4fcbb43e73cdcf16aebfbd1d3bd85a


[ 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.