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/9.2/sys/nlm/nlm_advlock.c 239582 2012-08-22 19:53:33Z 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;
  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         if (unlock_vp)
  244                 VOP_UNLOCK(vp, 0);
  245 
  246         /*
  247          * We need to switch to mount-point creds so that we can send
  248          * packets from a privileged port.
  249          */
  250         cred = td->td_ucred;
  251         td->td_ucred = vp->v_mount->mnt_cred;
  252 
  253         host = nlm_find_host_by_name(servername, sa, vers);
  254         auth = authunix_create(cred);
  255         memset(&ext, 0, sizeof(ext));
  256 
  257         nf.nf_printed = FALSE;
  258         nf.nf_nmp = nmp;
  259         ext.rc_auth = auth;
  260 
  261         ext.rc_feedback = nlm_feedback;
  262         ext.rc_feedback_arg = &nf;
  263         ext.rc_timers = NULL;
  264 
  265         ns = NULL;
  266         if (flags & F_FLOCK) {
  267                 ns = nlm_find_svid(id);
  268                 KASSERT(fl->l_start == 0 && fl->l_len == 0,
  269                     ("F_FLOCK lock requests must be whole-file locks"));
  270                 if (!ns->ns_ucred) {
  271                         /*
  272                          * Remember the creds used for locking in case
  273                          * we need to recover the lock later.
  274                          */
  275                         ns->ns_ucred = crdup(cred);
  276                 }
  277                 svid = ns->ns_svid;
  278         } else if (flags & F_REMOTE) {
  279                 /*
  280                  * If we are recovering after a server restart or
  281                  * trashing locks on a force unmount, use the same
  282                  * svid as last time.
  283                  */
  284                 svid = fl->l_pid;
  285         } else {
  286                 svid = ((struct proc *) id)->p_pid;
  287         }
  288 
  289         switch(op) {
  290         case F_SETLK:
  291                 if ((flags & (F_FLOCK|F_WAIT)) == (F_FLOCK|F_WAIT)
  292                     && fl->l_type == F_WRLCK) {
  293                         /*
  294                          * The semantics for flock(2) require that any
  295                          * shared lock on the file must be released
  296                          * before an exclusive lock is granted. The
  297                          * local locking code interprets this by
  298                          * unlocking the file before sleeping on a
  299                          * blocked exclusive lock request. We
  300                          * approximate this by first attempting
  301                          * non-blocking and if that fails, we unlock
  302                          * the file and block.
  303                          */
  304                         error = nlm_setlock(host, &ext, vers, &timo, retries,
  305                             vp, F_SETLK, fl, flags & ~F_WAIT,
  306                             svid, fhlen, &fh.fh_bytes, size, reclaim);
  307                         if (error == EAGAIN) {
  308                                 fl->l_type = F_UNLCK;
  309                                 error = nlm_clearlock(host, &ext, vers, &timo,
  310                                     retries, vp, F_UNLCK, fl, flags,
  311                                     svid, fhlen, &fh.fh_bytes, size);
  312                                 fl->l_type = F_WRLCK;
  313                                 if (!error) {
  314                                         mtx_lock(&nlm_svid_lock);
  315                                         if (ns->ns_active) {
  316                                                 ns->ns_refs--;
  317                                                 ns->ns_active = FALSE;
  318                                         }
  319                                         mtx_unlock(&nlm_svid_lock);
  320                                         flags |= F_WAIT;
  321                                         error = nlm_setlock(host, &ext, vers,
  322                                             &timo, retries, vp, F_SETLK, fl,
  323                                             flags, svid, fhlen, &fh.fh_bytes,
  324                                             size, reclaim);
  325                                 }
  326                         }
  327                 } else {
  328                         error = nlm_setlock(host, &ext, vers, &timo, retries,
  329                             vp, op, fl, flags, svid, fhlen, &fh.fh_bytes,
  330                             size, reclaim);
  331                 }
  332                 if (!error && ns) {
  333                         mtx_lock(&nlm_svid_lock);
  334                         if (!ns->ns_active) {
  335                                 /*
  336                                  * Add one to the reference count to
  337                                  * hold onto the SVID for the lifetime
  338                                  * of the lock. Note that since
  339                                  * F_FLOCK only supports whole-file
  340                                  * locks, there can only be one active
  341                                  * lock for this SVID.
  342                                  */
  343                                 ns->ns_refs++;
  344                                 ns->ns_active = TRUE;
  345                         }
  346                         mtx_unlock(&nlm_svid_lock);
  347                 }
  348                 break;
  349 
  350         case F_UNLCK:
  351                 error = nlm_clearlock(host, &ext, vers, &timo, retries,
  352                     vp, op, fl, flags, svid, fhlen, &fh.fh_bytes, size);
  353                 if (!error && ns) {
  354                         mtx_lock(&nlm_svid_lock);
  355                         if (ns->ns_active) {
  356                                 ns->ns_refs--;
  357                                 ns->ns_active = FALSE;
  358                         }
  359                         mtx_unlock(&nlm_svid_lock);
  360                 }
  361                 break;
  362 
  363         case F_GETLK:
  364                 error = nlm_getlock(host, &ext, vers, &timo, retries,
  365                     vp, op, fl, flags, svid, fhlen, &fh.fh_bytes, size);
  366                 break;
  367 
  368         default:
  369                 error = EINVAL;
  370                 break;
  371         }
  372 
  373         if (ns)
  374                 nlm_free_svid(ns);
  375 
  376         td->td_ucred = cred;
  377         AUTH_DESTROY(auth);
  378 
  379         nlm_host_release(host);
  380 
  381         return (error);
  382 }
  383 
  384 int
  385 nlm_advlock(struct vop_advlock_args *ap)
  386 {
  387 
  388         return (nlm_advlock_internal(ap->a_vp, ap->a_id, ap->a_op, ap->a_fl,
  389                 ap->a_flags, FALSE, TRUE));
  390 }
  391 
  392 /*
  393  * Set the creds of td to the creds of the given lock's owner. The new
  394  * creds reference count will be incremented via crhold. The caller is
  395  * responsible for calling crfree and restoring td's original creds.
  396  */
  397 static void
  398 nlm_set_creds_for_lock(struct thread *td, struct flock *fl)
  399 {
  400         int i;
  401         struct nlm_file_svid *ns;
  402         struct proc *p;
  403         struct ucred *cred;
  404 
  405         cred = NULL;
  406         if (fl->l_pid > PID_MAX) {
  407                 /*
  408                  * If this was originally a F_FLOCK-style lock, we
  409                  * recorded the creds used when it was originally
  410                  * locked in the nlm_file_svid structure.
  411                  */
  412                 mtx_lock(&nlm_svid_lock);
  413                 for (i = 0; i < NLM_SVID_HASH_SIZE; i++) {
  414                         for (ns = LIST_FIRST(&nlm_file_svids[i]); ns;
  415                              ns = LIST_NEXT(ns, ns_link)) {
  416                                 if (ns->ns_svid == fl->l_pid) {
  417                                         cred = crhold(ns->ns_ucred);
  418                                         break;
  419                                 }
  420                         }
  421                 }
  422                 mtx_unlock(&nlm_svid_lock);
  423         } else {
  424                 /*
  425                  * This lock is owned by a process. Get a reference to
  426                  * the process creds.
  427                  */
  428                 p = pfind(fl->l_pid);
  429                 if (p) {
  430                         cred = crhold(p->p_ucred);
  431                         PROC_UNLOCK(p);
  432                 }
  433         }
  434 
  435         /*
  436          * If we can't find a cred, fall back on the recovery
  437          * thread's cred.
  438          */
  439         if (!cred) {
  440                 cred = crhold(td->td_ucred);
  441         }
  442 
  443         td->td_ucred = cred;
  444 }
  445 
  446 static int
  447 nlm_reclaim_free_lock(struct vnode *vp, struct flock *fl, void *arg)
  448 {
  449         struct flock newfl;
  450         struct thread *td = curthread;
  451         struct ucred *oldcred;
  452         int error;
  453 
  454         newfl = *fl;
  455         newfl.l_type = F_UNLCK;
  456 
  457         oldcred = td->td_ucred;
  458         nlm_set_creds_for_lock(td, &newfl);
  459 
  460         error = nlm_advlock_internal(vp, NULL, F_UNLCK, &newfl, F_REMOTE,
  461             FALSE, FALSE);
  462 
  463         crfree(td->td_ucred);
  464         td->td_ucred = oldcred;
  465 
  466         return (error);
  467 }
  468 
  469 int
  470 nlm_reclaim(struct vop_reclaim_args *ap)
  471 {
  472 
  473         nlm_cancel_wait(ap->a_vp);
  474         lf_iteratelocks_vnode(ap->a_vp, nlm_reclaim_free_lock, NULL);
  475         return (0);
  476 }
  477 
  478 struct nlm_recovery_context {
  479         struct nlm_host *nr_host;       /* host we are recovering */
  480         int             nr_state;       /* remote NSM state for recovery */
  481 };
  482 
  483 static int
  484 nlm_client_recover_lock(struct vnode *vp, struct flock *fl, void *arg)
  485 {
  486         struct nlm_recovery_context *nr = (struct nlm_recovery_context *) arg;
  487         struct thread *td = curthread;
  488         struct ucred *oldcred;
  489         int state, error;
  490 
  491         /*
  492          * If the remote NSM state changes during recovery, the host
  493          * must have rebooted a second time. In that case, we must
  494          * restart the recovery.
  495          */
  496         state = nlm_host_get_state(nr->nr_host);
  497         if (nr->nr_state != state)
  498                 return (ERESTART);
  499 
  500         error = vn_lock(vp, LK_SHARED);
  501         if (error)
  502                 return (error);
  503 
  504         oldcred = td->td_ucred;
  505         nlm_set_creds_for_lock(td, fl);
  506 
  507         error = nlm_advlock_internal(vp, NULL, F_SETLK, fl, F_REMOTE,
  508             TRUE, TRUE);
  509 
  510         crfree(td->td_ucred);
  511         td->td_ucred = oldcred;
  512 
  513         return (error);
  514 }
  515 
  516 void
  517 nlm_client_recovery(struct nlm_host *host)
  518 {
  519         struct nlm_recovery_context nr;
  520         int sysid, error;
  521 
  522         sysid = NLM_SYSID_CLIENT | nlm_host_get_sysid(host);
  523         do {
  524                 nr.nr_host = host;
  525                 nr.nr_state = nlm_host_get_state(host);
  526                 error = lf_iteratelocks_sysid(sysid,
  527                     nlm_client_recover_lock, &nr);
  528         } while (error == ERESTART);
  529 }
  530 
  531 static void
  532 nlm_convert_to_nlm_lock(struct nlm_lock *dst, struct nlm4_lock *src)
  533 {
  534 
  535         dst->caller_name = src->caller_name;
  536         dst->fh = src->fh;
  537         dst->oh = src->oh;
  538         dst->svid = src->svid;
  539         dst->l_offset = src->l_offset;
  540         dst->l_len = src->l_len;
  541 }
  542 
  543 static void
  544 nlm_convert_to_nlm4_holder(struct nlm4_holder *dst, struct nlm_holder *src)
  545 {
  546 
  547         dst->exclusive = src->exclusive;
  548         dst->svid = src->svid;
  549         dst->oh = src->oh;
  550         dst->l_offset = src->l_offset;
  551         dst->l_len = src->l_len;
  552 }
  553 
  554 static void
  555 nlm_convert_to_nlm4_res(struct nlm4_res *dst, struct nlm_res *src)
  556 {
  557         dst->cookie = src->cookie;
  558         dst->stat.stat = (enum nlm4_stats) src->stat.stat;
  559 }
  560 
  561 static enum clnt_stat
  562 nlm_test_rpc(rpcvers_t vers, nlm4_testargs *args, nlm4_testres *res, CLIENT *client,
  563     struct rpc_callextra *ext, struct timeval timo)
  564 {
  565         if (vers == NLM_VERS4) {
  566                 return nlm4_test_4(args, res, client, ext, timo);
  567         } else {
  568                 nlm_testargs args1;
  569                 nlm_testres res1;
  570                 enum clnt_stat stat;
  571 
  572                 args1.cookie = args->cookie;
  573                 args1.exclusive = args->exclusive;
  574                 nlm_convert_to_nlm_lock(&args1.alock, &args->alock);
  575                 memset(&res1, 0, sizeof(res1));
  576 
  577                 stat = nlm_test_1(&args1, &res1, client, ext, timo);
  578 
  579                 if (stat == RPC_SUCCESS) {
  580                         res->cookie = res1.cookie;
  581                         res->stat.stat = (enum nlm4_stats) res1.stat.stat;
  582                         if (res1.stat.stat == nlm_denied)
  583                                 nlm_convert_to_nlm4_holder(
  584                                         &res->stat.nlm4_testrply_u.holder,
  585                                         &res1.stat.nlm_testrply_u.holder);
  586                 }
  587 
  588                 return (stat);
  589         }
  590 }
  591 
  592 static enum clnt_stat
  593 nlm_lock_rpc(rpcvers_t vers, nlm4_lockargs *args, nlm4_res *res, CLIENT *client,
  594     struct rpc_callextra *ext, struct timeval timo)
  595 {
  596         if (vers == NLM_VERS4) {
  597                 return nlm4_lock_4(args, res, client, ext, timo);
  598         } else {
  599                 nlm_lockargs args1;
  600                 nlm_res res1;
  601                 enum clnt_stat stat;
  602 
  603                 args1.cookie = args->cookie;
  604                 args1.block = args->block;
  605                 args1.exclusive = args->exclusive;
  606                 nlm_convert_to_nlm_lock(&args1.alock, &args->alock);
  607                 args1.reclaim = args->reclaim;
  608                 args1.state = args->state;
  609                 memset(&res1, 0, sizeof(res1));
  610 
  611                 stat = nlm_lock_1(&args1, &res1, client, ext, timo);
  612 
  613                 if (stat == RPC_SUCCESS) {
  614                         nlm_convert_to_nlm4_res(res, &res1);
  615                 }
  616 
  617                 return (stat);
  618         }
  619 }
  620 
  621 static enum clnt_stat
  622 nlm_cancel_rpc(rpcvers_t vers, nlm4_cancargs *args, nlm4_res *res, CLIENT *client,
  623     struct rpc_callextra *ext, struct timeval timo)
  624 {
  625         if (vers == NLM_VERS4) {
  626                 return nlm4_cancel_4(args, res, client, ext, timo);
  627         } else {
  628                 nlm_cancargs args1;
  629                 nlm_res res1;
  630                 enum clnt_stat stat;
  631 
  632                 args1.cookie = args->cookie;
  633                 args1.block = args->block;
  634                 args1.exclusive = args->exclusive;
  635                 nlm_convert_to_nlm_lock(&args1.alock, &args->alock);
  636                 memset(&res1, 0, sizeof(res1));
  637 
  638                 stat = nlm_cancel_1(&args1, &res1, client, ext, timo);
  639 
  640                 if (stat == RPC_SUCCESS) {
  641                         nlm_convert_to_nlm4_res(res, &res1);
  642                 }
  643 
  644                 return (stat);
  645         }
  646 }
  647 
  648 static enum clnt_stat
  649 nlm_unlock_rpc(rpcvers_t vers, nlm4_unlockargs *args, nlm4_res *res, CLIENT *client,
  650     struct rpc_callextra *ext, struct timeval timo)
  651 {
  652         if (vers == NLM_VERS4) {
  653                 return nlm4_unlock_4(args, res, client, ext, timo);
  654         } else {
  655                 nlm_unlockargs args1;
  656                 nlm_res res1;
  657                 enum clnt_stat stat;
  658 
  659                 args1.cookie = args->cookie;
  660                 nlm_convert_to_nlm_lock(&args1.alock, &args->alock);
  661                 memset(&res1, 0, sizeof(res1));
  662 
  663                 stat = nlm_unlock_1(&args1, &res1, client, ext, timo);
  664 
  665                 if (stat == RPC_SUCCESS) {
  666                         nlm_convert_to_nlm4_res(res, &res1);
  667                 }
  668 
  669                 return (stat);
  670         }
  671 }
  672 
  673 /*
  674  * Called after a lock request (set or clear) succeeded. We record the
  675  * details in the local lock manager. Note that since the remote
  676  * server has granted the lock, we can be sure that it doesn't
  677  * conflict with any other locks we have in the local lock manager.
  678  *
  679  * Since it is possible that host may also make NLM client requests to
  680  * our NLM server, we use a different sysid value to record our own
  681  * client locks.
  682  *
  683  * Note that since it is possible for us to receive replies from the
  684  * server in a different order than the locks were granted (e.g. if
  685  * many local threads are contending for the same lock), we must use a
  686  * blocking operation when registering with the local lock manager.
  687  * We expect that any actual wait will be rare and short hence we
  688  * ignore signals for this.
  689  */
  690 static void
  691 nlm_record_lock(struct vnode *vp, int op, struct flock *fl,
  692     int svid, int sysid, off_t size)
  693 {
  694         struct vop_advlockasync_args a;
  695         struct flock newfl;
  696         int error;
  697 
  698         a.a_vp = vp;
  699         a.a_id = NULL;
  700         a.a_op = op;
  701         a.a_fl = &newfl;
  702         a.a_flags = F_REMOTE|F_WAIT|F_NOINTR;
  703         a.a_task = NULL;
  704         a.a_cookiep = NULL;
  705         newfl.l_start = fl->l_start;
  706         newfl.l_len = fl->l_len;
  707         newfl.l_type = fl->l_type;
  708         newfl.l_whence = fl->l_whence;
  709         newfl.l_pid = svid;
  710         newfl.l_sysid = NLM_SYSID_CLIENT | sysid;
  711 
  712         error = lf_advlockasync(&a, &vp->v_lockf, size);
  713         KASSERT(error == 0 || error == ENOENT,
  714             ("Failed to register NFS lock locally - error=%d", error));
  715 }
  716 
  717 static int
  718 nlm_setlock(struct nlm_host *host, struct rpc_callextra *ext,
  719     rpcvers_t vers, struct timeval *timo, int retries,
  720     struct vnode *vp, int op, struct flock *fl, int flags,
  721     int svid, size_t fhlen, void *fh, off_t size, bool_t reclaim)
  722 {
  723         struct nlm4_lockargs args;
  724         char oh_space[32];
  725         struct nlm4_res res;
  726         u_int xid;
  727         CLIENT *client;
  728         enum clnt_stat stat;
  729         int retry, block, exclusive;
  730         void *wait_handle = NULL;
  731         int error;
  732 
  733         memset(&args, 0, sizeof(args));
  734         memset(&res, 0, sizeof(res));
  735 
  736         block = (flags & F_WAIT) ? TRUE : FALSE;
  737         exclusive = (fl->l_type == F_WRLCK);
  738 
  739         error = nlm_init_lock(fl, flags, svid, vers, fhlen, fh, size,
  740             &args.alock, oh_space);
  741         if (error)
  742                 return (error);
  743         args.block = block;
  744         args.exclusive = exclusive;
  745         args.reclaim = reclaim;
  746         args.state = nlm_nsm_state;
  747 
  748         retry = 5*hz;
  749         for (;;) {
  750                 client = nlm_host_get_rpc(host, FALSE);
  751                 if (!client)
  752                         return (ENOLCK); /* XXX retry? */
  753 
  754                 if (block)
  755                         wait_handle = nlm_register_wait_lock(&args.alock, vp);
  756 
  757                 xid = atomic_fetchadd_int(&nlm_xid, 1);
  758                 args.cookie.n_len = sizeof(xid);
  759                 args.cookie.n_bytes = (char*) &xid;
  760 
  761                 stat = nlm_lock_rpc(vers, &args, &res, client, ext, *timo);
  762 
  763                 CLNT_RELEASE(client);
  764 
  765                 if (stat != RPC_SUCCESS) {
  766                         if (block)
  767                                 nlm_deregister_wait_lock(wait_handle);
  768                         if (retries) {
  769                                 retries--;
  770                                 continue;
  771                         }
  772                         return (EINVAL);
  773                 }
  774 
  775                 /*
  776                  * Free res.cookie.
  777                  */
  778                 xdr_free((xdrproc_t) xdr_nlm4_res, &res);
  779 
  780                 if (block && res.stat.stat != nlm4_blocked)
  781                         nlm_deregister_wait_lock(wait_handle);
  782 
  783                 if (res.stat.stat == nlm4_denied_grace_period) {
  784                         /*
  785                          * The server has recently rebooted and is
  786                          * giving old clients a change to reclaim
  787                          * their locks. Wait for a few seconds and try
  788                          * again.
  789                          */
  790                         error = tsleep(&args, PCATCH, "nlmgrace", retry);
  791                         if (error && error != EWOULDBLOCK)
  792                                 return (error);
  793                         retry = 2*retry;
  794                         if (retry > 30*hz)
  795                                 retry = 30*hz;
  796                         continue;
  797                 }
  798 
  799                 if (block && res.stat.stat == nlm4_blocked) {
  800                         /*
  801                          * The server should call us back with a
  802                          * granted message when the lock succeeds. In
  803                          * order to deal with broken servers, lost
  804                          * granted messages and server reboots, we
  805                          * will also re-try every few seconds.
  806                          */
  807                         error = nlm_wait_lock(wait_handle, retry);
  808                         if (error == EWOULDBLOCK) {
  809                                 retry = 2*retry;
  810                                 if (retry > 30*hz)
  811                                         retry = 30*hz;
  812                                 continue;
  813                         }
  814                         if (error) {
  815                                 /*
  816                                  * We need to call the server to
  817                                  * cancel our lock request.
  818                                  */
  819                                 nlm4_cancargs cancel;
  820 
  821                                 memset(&cancel, 0, sizeof(cancel));
  822 
  823                                 xid = atomic_fetchadd_int(&nlm_xid, 1);
  824                                 cancel.cookie.n_len = sizeof(xid);
  825                                 cancel.cookie.n_bytes = (char*) &xid;
  826                                 cancel.block = block;
  827                                 cancel.exclusive = exclusive;
  828                                 cancel.alock = args.alock;
  829 
  830                                 do {
  831                                         client = nlm_host_get_rpc(host, FALSE);
  832                                         if (!client)
  833                                                 /* XXX retry? */
  834                                                 return (ENOLCK);
  835 
  836                                         stat = nlm_cancel_rpc(vers, &cancel,
  837                                             &res, client, ext, *timo);
  838 
  839                                         CLNT_RELEASE(client);
  840 
  841                                         if (stat != RPC_SUCCESS) {
  842                                                 /*
  843                                                  * We need to cope
  844                                                  * with temporary
  845                                                  * network partitions
  846                                                  * as well as server
  847                                                  * reboots. This means
  848                                                  * we have to keep
  849                                                  * trying to cancel
  850                                                  * until the server
  851                                                  * wakes up again.
  852                                                  */
  853                                                 pause("nlmcancel", 10*hz);
  854                                         }
  855                                 } while (stat != RPC_SUCCESS);
  856 
  857                                 /*
  858                                  * Free res.cookie.
  859                                  */
  860                                 xdr_free((xdrproc_t) xdr_nlm4_res, &res);
  861 
  862                                 switch (res.stat.stat) {
  863                                 case nlm_denied:
  864                                         /*
  865                                          * There was nothing
  866                                          * to cancel. We are
  867                                          * going to go ahead
  868                                          * and assume we got
  869                                          * the lock.
  870                                          */
  871                                         error = 0;
  872                                         break;
  873 
  874                                 case nlm4_denied_grace_period:
  875                                         /*
  876                                          * The server has
  877                                          * recently rebooted -
  878                                          * treat this as a
  879                                          * successful
  880                                          * cancellation.
  881                                          */
  882                                         break;
  883 
  884                                 case nlm4_granted:
  885                                         /*
  886                                          * We managed to
  887                                          * cancel.
  888                                          */
  889                                         break;
  890 
  891                                 default:
  892                                         /*
  893                                          * Broken server
  894                                          * implementation -
  895                                          * can't really do
  896                                          * anything here.
  897                                          */
  898                                         break;
  899                                 }
  900 
  901                         }
  902                 } else {
  903                         error = nlm_map_status(res.stat.stat);
  904                 }
  905 
  906                 if (!error && !reclaim) {
  907                         nlm_record_lock(vp, op, fl, args.alock.svid,
  908                             nlm_host_get_sysid(host), size);
  909                         nlm_host_monitor(host, 0);
  910                 }
  911 
  912                 return (error);
  913         }
  914 }
  915 
  916 static int
  917 nlm_clearlock(struct nlm_host *host, struct rpc_callextra *ext,
  918     rpcvers_t vers, struct timeval *timo, int retries,
  919     struct vnode *vp, int op, struct flock *fl, int flags,
  920     int svid, size_t fhlen, void *fh, off_t size)
  921 {
  922         struct nlm4_unlockargs args;
  923         char oh_space[32];
  924         struct nlm4_res res;
  925         u_int xid;
  926         CLIENT *client;
  927         enum clnt_stat stat;
  928         int error;
  929 
  930         memset(&args, 0, sizeof(args));
  931         memset(&res, 0, sizeof(res));
  932 
  933         error = nlm_init_lock(fl, flags, svid, vers, fhlen, fh, size,
  934             &args.alock, oh_space);
  935         if (error)
  936                 return (error);
  937 
  938         for (;;) {
  939                 client = nlm_host_get_rpc(host, FALSE);
  940                 if (!client)
  941                         return (ENOLCK); /* XXX retry? */
  942 
  943                 xid = atomic_fetchadd_int(&nlm_xid, 1);
  944                 args.cookie.n_len = sizeof(xid);
  945                 args.cookie.n_bytes = (char*) &xid;
  946 
  947                 stat = nlm_unlock_rpc(vers, &args, &res, client, ext, *timo);
  948 
  949                 CLNT_RELEASE(client);
  950 
  951                 if (stat != RPC_SUCCESS) {
  952                         if (retries) {
  953                                 retries--;
  954                                 continue;
  955                         }
  956                         return (EINVAL);
  957                 }
  958 
  959                 /*
  960                  * Free res.cookie.
  961                  */
  962                 xdr_free((xdrproc_t) xdr_nlm4_res, &res);
  963 
  964                 if (res.stat.stat == nlm4_denied_grace_period) {
  965                         /*
  966                          * The server has recently rebooted and is
  967                          * giving old clients a change to reclaim
  968                          * their locks. Wait for a few seconds and try
  969                          * again.
  970                          */
  971                         error = tsleep(&args, PCATCH, "nlmgrace", 5*hz);
  972                         if (error && error != EWOULDBLOCK)
  973                                 return (error);
  974                         continue;
  975                 }
  976 
  977                 /*
  978                  * If we are being called via nlm_reclaim (which will
  979                  * use the F_REMOTE flag), don't record the lock
  980                  * operation in the local lock manager since the vnode
  981                  * is going away.
  982                  */
  983                 if (!(flags & F_REMOTE))
  984                         nlm_record_lock(vp, op, fl, args.alock.svid,
  985                             nlm_host_get_sysid(host), size);
  986 
  987                 return (0);
  988         }
  989 }
  990 
  991 static int
  992 nlm_getlock(struct nlm_host *host, struct rpc_callextra *ext,
  993     rpcvers_t vers, struct timeval *timo, int retries,
  994     struct vnode *vp, int op, struct flock *fl, int flags,
  995     int svid, size_t fhlen, void *fh, off_t size)
  996 {
  997         struct nlm4_testargs args;
  998         char oh_space[32];
  999         struct nlm4_testres res;
 1000         u_int xid;
 1001         CLIENT *client;
 1002         enum clnt_stat stat;
 1003         int exclusive;
 1004         int error;
 1005 
 1006         KASSERT(!(flags & F_FLOCK), ("unexpected F_FLOCK for F_GETLK"));
 1007 
 1008         memset(&args, 0, sizeof(args));
 1009         memset(&res, 0, sizeof(res));
 1010 
 1011         exclusive = (fl->l_type == F_WRLCK);
 1012 
 1013         error = nlm_init_lock(fl, flags, svid, vers, fhlen, fh, size,
 1014             &args.alock, oh_space);
 1015         if (error)
 1016                 return (error);
 1017         args.exclusive = exclusive;
 1018 
 1019         for (;;) {
 1020                 client = nlm_host_get_rpc(host, FALSE);
 1021                 if (!client)
 1022                         return (ENOLCK); /* XXX retry? */
 1023 
 1024                 xid = atomic_fetchadd_int(&nlm_xid, 1);
 1025                 args.cookie.n_len = sizeof(xid);
 1026                 args.cookie.n_bytes = (char*) &xid;
 1027 
 1028                 stat = nlm_test_rpc(vers, &args, &res, client, ext, *timo);
 1029 
 1030                 CLNT_RELEASE(client);
 1031 
 1032                 if (stat != RPC_SUCCESS) {
 1033                         if (retries) {
 1034                                 retries--;
 1035                                 continue;
 1036                         }
 1037                         return (EINVAL);
 1038                 }
 1039 
 1040                 if (res.stat.stat == nlm4_denied_grace_period) {
 1041                         /*
 1042                          * The server has recently rebooted and is
 1043                          * giving old clients a change to reclaim
 1044                          * their locks. Wait for a few seconds and try
 1045                          * again.
 1046                          */
 1047                         xdr_free((xdrproc_t) xdr_nlm4_testres, &res);
 1048                         error = tsleep(&args, PCATCH, "nlmgrace", 5*hz);
 1049                         if (error && error != EWOULDBLOCK)
 1050                                 return (error);
 1051                         continue;
 1052                 }
 1053 
 1054                 if (res.stat.stat == nlm4_denied) {
 1055                         struct nlm4_holder *h =
 1056                                 &res.stat.nlm4_testrply_u.holder;
 1057                         fl->l_start = h->l_offset;
 1058                         fl->l_len = h->l_len;
 1059                         fl->l_pid = h->svid;
 1060                         if (h->exclusive)
 1061                                 fl->l_type = F_WRLCK;
 1062                         else
 1063                                 fl->l_type = F_RDLCK;
 1064                         fl->l_whence = SEEK_SET;
 1065                         fl->l_sysid = 0;
 1066                 } else {
 1067                         fl->l_type = F_UNLCK;
 1068                 }
 1069 
 1070                 xdr_free((xdrproc_t) xdr_nlm4_testres, &res);
 1071 
 1072                 return (0);
 1073         }
 1074 }
 1075 
 1076 static int
 1077 nlm_map_status(nlm4_stats stat)
 1078 {
 1079         switch (stat) {
 1080         case nlm4_granted:
 1081                 return (0);
 1082 
 1083         case nlm4_denied:
 1084                 return (EAGAIN);
 1085 
 1086         case nlm4_denied_nolocks:
 1087                 return (ENOLCK);
 1088 
 1089         case nlm4_deadlck:
 1090                 return (EDEADLK);
 1091 
 1092         case nlm4_rofs:
 1093                 return (EROFS);
 1094 
 1095         case nlm4_stale_fh:
 1096                 return (ESTALE);
 1097 
 1098         case nlm4_fbig:
 1099                 return (EFBIG);
 1100 
 1101         case nlm4_failed:
 1102                 return (EACCES);
 1103 
 1104         default:
 1105                 return (EINVAL);
 1106         }
 1107 }
 1108 
 1109 static struct nlm_file_svid *
 1110 nlm_find_svid(void *id)
 1111 {
 1112         struct nlm_file_svid *ns, *newns;
 1113         int h;
 1114 
 1115         h = (((uintptr_t) id) >> 7) % NLM_SVID_HASH_SIZE;
 1116 
 1117         mtx_lock(&nlm_svid_lock);
 1118         LIST_FOREACH(ns, &nlm_file_svids[h], ns_link) {
 1119                 if (ns->ns_id == id) {
 1120                         ns->ns_refs++;
 1121                         break;
 1122                 }
 1123         }
 1124         mtx_unlock(&nlm_svid_lock);
 1125         if (!ns) {
 1126                 int svid = alloc_unr(nlm_svid_allocator);
 1127                 newns = malloc(sizeof(struct nlm_file_svid), M_NLM,
 1128                     M_WAITOK);
 1129                 newns->ns_refs = 1;
 1130                 newns->ns_id = id;
 1131                 newns->ns_svid = svid;
 1132                 newns->ns_ucred = NULL;
 1133                 newns->ns_active = FALSE;
 1134 
 1135                 /*
 1136                  * We need to check for a race with some other
 1137                  * thread allocating a svid for this file.
 1138                  */
 1139                 mtx_lock(&nlm_svid_lock);
 1140                 LIST_FOREACH(ns, &nlm_file_svids[h], ns_link) {
 1141                         if (ns->ns_id == id) {
 1142                                 ns->ns_refs++;
 1143                                 break;
 1144                         }
 1145                 }
 1146                 if (ns) {
 1147                         mtx_unlock(&nlm_svid_lock);
 1148                         free_unr(nlm_svid_allocator, newns->ns_svid);
 1149                         free(newns, M_NLM);
 1150                 } else {
 1151                         LIST_INSERT_HEAD(&nlm_file_svids[h], newns,
 1152                             ns_link);
 1153                         ns = newns;
 1154                         mtx_unlock(&nlm_svid_lock);
 1155                 }
 1156         }
 1157 
 1158         return (ns);
 1159 }
 1160 
 1161 static void
 1162 nlm_free_svid(struct nlm_file_svid *ns)
 1163 {
 1164 
 1165         mtx_lock(&nlm_svid_lock);
 1166         ns->ns_refs--;
 1167         if (!ns->ns_refs) {
 1168                 KASSERT(!ns->ns_active, ("Freeing active SVID"));
 1169                 LIST_REMOVE(ns, ns_link);
 1170                 mtx_unlock(&nlm_svid_lock);
 1171                 free_unr(nlm_svid_allocator, ns->ns_svid);
 1172                 if (ns->ns_ucred)
 1173                         crfree(ns->ns_ucred);
 1174                 free(ns, M_NLM);
 1175         } else {
 1176                 mtx_unlock(&nlm_svid_lock);
 1177         }
 1178 }
 1179 
 1180 static int
 1181 nlm_init_lock(struct flock *fl, int flags, int svid,
 1182     rpcvers_t vers, size_t fhlen, void *fh, off_t size,
 1183     struct nlm4_lock *lock, char oh_space[32])
 1184 {
 1185         size_t oh_len;
 1186         off_t start, len;
 1187 
 1188         if (fl->l_whence == SEEK_END) {
 1189                 if (size > OFF_MAX
 1190                     || (fl->l_start > 0 && size > OFF_MAX - fl->l_start))
 1191                         return (EOVERFLOW);
 1192                 start = size + fl->l_start;
 1193         } else if (fl->l_whence == SEEK_SET || fl->l_whence == SEEK_CUR) {
 1194                 start = fl->l_start;
 1195         } else {
 1196                 return (EINVAL);
 1197         }
 1198         if (start < 0)
 1199                 return (EINVAL);
 1200         if (fl->l_len < 0) {
 1201                 len = -fl->l_len;
 1202                 start -= len;
 1203                 if (start < 0)
 1204                         return (EINVAL);
 1205         } else {
 1206                 len = fl->l_len;
 1207         }
 1208 
 1209         if (vers == NLM_VERS) {
 1210                 /*
 1211                  * Enforce range limits on V1 locks
 1212                  */
 1213                 if (start > 0xffffffffLL || len > 0xffffffffLL)
 1214                         return (EOVERFLOW);
 1215         }
 1216 
 1217         snprintf(oh_space, 32, "%d@", svid);
 1218         oh_len = strlen(oh_space);
 1219         getcredhostname(NULL, oh_space + oh_len, 32 - oh_len);
 1220         oh_len = strlen(oh_space);
 1221 
 1222         memset(lock, 0, sizeof(*lock));
 1223         lock->caller_name = prison0.pr_hostname;
 1224         lock->fh.n_len = fhlen;
 1225         lock->fh.n_bytes = fh;
 1226         lock->oh.n_len = oh_len;
 1227         lock->oh.n_bytes = oh_space;
 1228         lock->svid = svid;
 1229         lock->l_offset = start;
 1230         lock->l_len = len;
 1231 
 1232         return (0);
 1233 }

Cache object: add93caf01c9b09a569b1da0d361e813


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