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/fs/nfsclient/nfs_clvfsops.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 1989, 1993, 1995
    3  *      The Regents of the University of California.  All rights reserved.
    4  *
    5  * This code is derived from software contributed to Berkeley by
    6  * Rick Macklem at The University of Guelph.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  * 4. Neither the name of the University nor the names of its contributors
   17  *    may be used to endorse or promote products derived from this software
   18  *    without specific prior written permission.
   19  *
   20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   30  * SUCH DAMAGE.
   31  *
   32  *      from nfs_vfsops.c       8.12 (Berkeley) 5/20/95
   33  */
   34 
   35 #include <sys/cdefs.h>
   36 __FBSDID("$FreeBSD: stable/11/sys/fs/nfsclient/nfs_clvfsops.c 356239 2019-12-31 18:28:25Z rmacklem $");
   37 
   38 
   39 #include "opt_bootp.h"
   40 #include "opt_nfsroot.h"
   41 
   42 #include <sys/param.h>
   43 #include <sys/systm.h>
   44 #include <sys/kernel.h>
   45 #include <sys/bio.h>
   46 #include <sys/buf.h>
   47 #include <sys/clock.h>
   48 #include <sys/jail.h>
   49 #include <sys/limits.h>
   50 #include <sys/lock.h>
   51 #include <sys/malloc.h>
   52 #include <sys/mbuf.h>
   53 #include <sys/module.h>
   54 #include <sys/mount.h>
   55 #include <sys/proc.h>
   56 #include <sys/socket.h>
   57 #include <sys/socketvar.h>
   58 #include <sys/sockio.h>
   59 #include <sys/sysctl.h>
   60 #include <sys/vnode.h>
   61 #include <sys/signalvar.h>
   62 
   63 #include <vm/vm.h>
   64 #include <vm/vm_extern.h>
   65 #include <vm/uma.h>
   66 
   67 #include <net/if.h>
   68 #include <net/route.h>
   69 #include <netinet/in.h>
   70 
   71 #include <fs/nfs/nfsport.h>
   72 #include <fs/nfsclient/nfsnode.h>
   73 #include <fs/nfsclient/nfsmount.h>
   74 #include <fs/nfsclient/nfs.h>
   75 #include <nfs/nfsdiskless.h>
   76 
   77 FEATURE(nfscl, "NFSv4 client");
   78 
   79 extern int nfscl_ticks;
   80 extern struct timeval nfsboottime;
   81 extern int nfsrv_useacl;
   82 extern int nfscl_debuglevel;
   83 extern enum nfsiod_state ncl_iodwant[NFS_MAXASYNCDAEMON];
   84 extern struct nfsmount *ncl_iodmount[NFS_MAXASYNCDAEMON];
   85 extern struct mtx ncl_iod_mutex;
   86 NFSCLSTATEMUTEX;
   87 
   88 MALLOC_DEFINE(M_NEWNFSREQ, "newnfsclient_req", "NFS request header");
   89 MALLOC_DEFINE(M_NEWNFSMNT, "newnfsmnt", "NFS mount struct");
   90 
   91 SYSCTL_DECL(_vfs_nfs);
   92 static int nfs_ip_paranoia = 1;
   93 SYSCTL_INT(_vfs_nfs, OID_AUTO, nfs_ip_paranoia, CTLFLAG_RW,
   94     &nfs_ip_paranoia, 0, "");
   95 static int nfs_tprintf_initial_delay = NFS_TPRINTF_INITIAL_DELAY;
   96 SYSCTL_INT(_vfs_nfs, NFS_TPRINTF_INITIAL_DELAY,
   97         downdelayinitial, CTLFLAG_RW, &nfs_tprintf_initial_delay, 0, "");
   98 /* how long between console messages "nfs server foo not responding" */
   99 static int nfs_tprintf_delay = NFS_TPRINTF_DELAY;
  100 SYSCTL_INT(_vfs_nfs, NFS_TPRINTF_DELAY,
  101         downdelayinterval, CTLFLAG_RW, &nfs_tprintf_delay, 0, "");
  102 #ifdef NFS_DEBUG
  103 int nfs_debug;
  104 SYSCTL_INT(_vfs_nfs, OID_AUTO, debug, CTLFLAG_RW, &nfs_debug, 0,
  105     "Toggle debug flag");
  106 #endif
  107 
  108 static int      nfs_mountroot(struct mount *);
  109 static void     nfs_sec_name(char *, int *);
  110 static void     nfs_decode_args(struct mount *mp, struct nfsmount *nmp,
  111                     struct nfs_args *argp, const char *, struct ucred *,
  112                     struct thread *);
  113 static int      mountnfs(struct nfs_args *, struct mount *,
  114                     struct sockaddr *, char *, u_char *, int, u_char *, int,
  115                     u_char *, int, struct vnode **, struct ucred *,
  116                     struct thread *, int, int, int);
  117 static void     nfs_getnlminfo(struct vnode *, uint8_t *, size_t *,
  118                     struct sockaddr_storage *, int *, off_t *,
  119                     struct timeval *);
  120 static vfs_mount_t nfs_mount;
  121 static vfs_cmount_t nfs_cmount;
  122 static vfs_unmount_t nfs_unmount;
  123 static vfs_root_t nfs_root;
  124 static vfs_statfs_t nfs_statfs;
  125 static vfs_sync_t nfs_sync;
  126 static vfs_sysctl_t nfs_sysctl;
  127 static vfs_purge_t nfs_purge;
  128 
  129 /*
  130  * nfs vfs operations.
  131  */
  132 static struct vfsops nfs_vfsops = {
  133         .vfs_init =             ncl_init,
  134         .vfs_mount =            nfs_mount,
  135         .vfs_cmount =           nfs_cmount,
  136         .vfs_root =             nfs_root,
  137         .vfs_statfs =           nfs_statfs,
  138         .vfs_sync =             nfs_sync,
  139         .vfs_uninit =           ncl_uninit,
  140         .vfs_unmount =          nfs_unmount,
  141         .vfs_sysctl =           nfs_sysctl,
  142         .vfs_purge =            nfs_purge,
  143 };
  144 VFS_SET(nfs_vfsops, nfs, VFCF_NETWORK | VFCF_SBDRY);
  145 
  146 /* So that loader and kldload(2) can find us, wherever we are.. */
  147 MODULE_VERSION(nfs, 1);
  148 MODULE_DEPEND(nfs, nfscommon, 1, 1, 1);
  149 MODULE_DEPEND(nfs, krpc, 1, 1, 1);
  150 MODULE_DEPEND(nfs, nfssvc, 1, 1, 1);
  151 MODULE_DEPEND(nfs, nfslock, 1, 1, 1);
  152 
  153 /*
  154  * This structure is now defined in sys/nfs/nfs_diskless.c so that it
  155  * can be shared by both NFS clients. It is declared here so that it
  156  * will be defined for kernels built without NFS_ROOT, although it
  157  * isn't used in that case.
  158  */
  159 #if !defined(NFS_ROOT)
  160 struct nfs_diskless     nfs_diskless = { { { 0 } } };
  161 struct nfsv3_diskless   nfsv3_diskless = { { { 0 } } };
  162 int                     nfs_diskless_valid = 0;
  163 #endif
  164 
  165 SYSCTL_INT(_vfs_nfs, OID_AUTO, diskless_valid, CTLFLAG_RD,
  166     &nfs_diskless_valid, 0,
  167     "Has the diskless struct been filled correctly");
  168 
  169 SYSCTL_STRING(_vfs_nfs, OID_AUTO, diskless_rootpath, CTLFLAG_RD,
  170     nfsv3_diskless.root_hostnam, 0, "Path to nfs root");
  171 
  172 SYSCTL_OPAQUE(_vfs_nfs, OID_AUTO, diskless_rootaddr, CTLFLAG_RD,
  173     &nfsv3_diskless.root_saddr, sizeof(nfsv3_diskless.root_saddr),
  174     "%Ssockaddr_in", "Diskless root nfs address");
  175 
  176 
  177 void            newnfsargs_ntoh(struct nfs_args *);
  178 static int      nfs_mountdiskless(char *,
  179                     struct sockaddr_in *, struct nfs_args *,
  180                     struct thread *, struct vnode **, struct mount *);
  181 static void     nfs_convert_diskless(void);
  182 static void     nfs_convert_oargs(struct nfs_args *args,
  183                     struct onfs_args *oargs);
  184 
  185 int
  186 newnfs_iosize(struct nfsmount *nmp)
  187 {
  188         int iosize, maxio;
  189 
  190         /* First, set the upper limit for iosize */
  191         if (nmp->nm_flag & NFSMNT_NFSV4) {
  192                 maxio = NFS_MAXBSIZE;
  193         } else if (nmp->nm_flag & NFSMNT_NFSV3) {
  194                 if (nmp->nm_sotype == SOCK_DGRAM)
  195                         maxio = NFS_MAXDGRAMDATA;
  196                 else
  197                         maxio = NFS_MAXBSIZE;
  198         } else {
  199                 maxio = NFS_V2MAXDATA;
  200         }
  201         if (nmp->nm_rsize > maxio || nmp->nm_rsize == 0)
  202                 nmp->nm_rsize = maxio;
  203         if (nmp->nm_rsize > NFS_MAXBSIZE)
  204                 nmp->nm_rsize = NFS_MAXBSIZE;
  205         if (nmp->nm_readdirsize > maxio || nmp->nm_readdirsize == 0)
  206                 nmp->nm_readdirsize = maxio;
  207         if (nmp->nm_readdirsize > nmp->nm_rsize)
  208                 nmp->nm_readdirsize = nmp->nm_rsize;
  209         if (nmp->nm_wsize > maxio || nmp->nm_wsize == 0)
  210                 nmp->nm_wsize = maxio;
  211         if (nmp->nm_wsize > NFS_MAXBSIZE)
  212                 nmp->nm_wsize = NFS_MAXBSIZE;
  213 
  214         /*
  215          * Calculate the size used for io buffers.  Use the larger
  216          * of the two sizes to minimise nfs requests but make sure
  217          * that it is at least one VM page to avoid wasting buffer
  218          * space.  It must also be at least NFS_DIRBLKSIZ, since
  219          * that is the buffer size used for directories.
  220          */
  221         iosize = imax(nmp->nm_rsize, nmp->nm_wsize);
  222         iosize = imax(iosize, PAGE_SIZE);
  223         iosize = imax(iosize, NFS_DIRBLKSIZ);
  224         nmp->nm_mountp->mnt_stat.f_iosize = iosize;
  225         return (iosize);
  226 }
  227 
  228 static void
  229 nfs_convert_oargs(struct nfs_args *args, struct onfs_args *oargs)
  230 {
  231 
  232         args->version = NFS_ARGSVERSION;
  233         args->addr = oargs->addr;
  234         args->addrlen = oargs->addrlen;
  235         args->sotype = oargs->sotype;
  236         args->proto = oargs->proto;
  237         args->fh = oargs->fh;
  238         args->fhsize = oargs->fhsize;
  239         args->flags = oargs->flags;
  240         args->wsize = oargs->wsize;
  241         args->rsize = oargs->rsize;
  242         args->readdirsize = oargs->readdirsize;
  243         args->timeo = oargs->timeo;
  244         args->retrans = oargs->retrans;
  245         args->readahead = oargs->readahead;
  246         args->hostname = oargs->hostname;
  247 }
  248 
  249 static void
  250 nfs_convert_diskless(void)
  251 {
  252 
  253         bcopy(&nfs_diskless.myif, &nfsv3_diskless.myif,
  254                 sizeof(struct ifaliasreq));
  255         bcopy(&nfs_diskless.mygateway, &nfsv3_diskless.mygateway,
  256                 sizeof(struct sockaddr_in));
  257         nfs_convert_oargs(&nfsv3_diskless.root_args,&nfs_diskless.root_args);
  258         if (nfsv3_diskless.root_args.flags & NFSMNT_NFSV3) {
  259                 nfsv3_diskless.root_fhsize = NFSX_MYFH;
  260                 bcopy(nfs_diskless.root_fh, nfsv3_diskless.root_fh, NFSX_MYFH);
  261         } else {
  262                 nfsv3_diskless.root_fhsize = NFSX_V2FH;
  263                 bcopy(nfs_diskless.root_fh, nfsv3_diskless.root_fh, NFSX_V2FH);
  264         }
  265         bcopy(&nfs_diskless.root_saddr,&nfsv3_diskless.root_saddr,
  266                 sizeof(struct sockaddr_in));
  267         bcopy(nfs_diskless.root_hostnam, nfsv3_diskless.root_hostnam, MNAMELEN);
  268         nfsv3_diskless.root_time = nfs_diskless.root_time;
  269         bcopy(nfs_diskless.my_hostnam, nfsv3_diskless.my_hostnam,
  270                 MAXHOSTNAMELEN);
  271         nfs_diskless_valid = 3;
  272 }
  273 
  274 /*
  275  * nfs statfs call
  276  */
  277 static int
  278 nfs_statfs(struct mount *mp, struct statfs *sbp)
  279 {
  280         struct vnode *vp;
  281         struct thread *td;
  282         struct nfsmount *nmp = VFSTONFS(mp);
  283         struct nfsvattr nfsva;
  284         struct nfsfsinfo fs;
  285         struct nfsstatfs sb;
  286         int error = 0, attrflag, gotfsinfo = 0, ret;
  287         struct nfsnode *np;
  288 
  289         td = curthread;
  290 
  291         error = vfs_busy(mp, MBF_NOWAIT);
  292         if (error)
  293                 return (error);
  294         error = ncl_nget(mp, nmp->nm_fh, nmp->nm_fhsize, &np, LK_EXCLUSIVE);
  295         if (error) {
  296                 vfs_unbusy(mp);
  297                 return (error);
  298         }
  299         vp = NFSTOV(np);
  300         mtx_lock(&nmp->nm_mtx);
  301         if (NFSHASNFSV3(nmp) && !NFSHASGOTFSINFO(nmp)) {
  302                 mtx_unlock(&nmp->nm_mtx);
  303                 error = nfsrpc_fsinfo(vp, &fs, td->td_ucred, td, &nfsva,
  304                     &attrflag, NULL);
  305                 if (!error)
  306                         gotfsinfo = 1;
  307         } else
  308                 mtx_unlock(&nmp->nm_mtx);
  309         if (!error)
  310                 error = nfsrpc_statfs(vp, &sb, &fs, td->td_ucred, td, &nfsva,
  311                     &attrflag, NULL);
  312         if (error != 0)
  313                 NFSCL_DEBUG(2, "statfs=%d\n", error);
  314         if (attrflag == 0) {
  315                 ret = nfsrpc_getattrnovp(nmp, nmp->nm_fh, nmp->nm_fhsize, 1,
  316                     td->td_ucred, td, &nfsva, NULL, NULL);
  317                 if (ret) {
  318                         /*
  319                          * Just set default values to get things going.
  320                          */
  321                         NFSBZERO((caddr_t)&nfsva, sizeof (struct nfsvattr));
  322                         nfsva.na_vattr.va_type = VDIR;
  323                         nfsva.na_vattr.va_mode = 0777;
  324                         nfsva.na_vattr.va_nlink = 100;
  325                         nfsva.na_vattr.va_uid = (uid_t)0;
  326                         nfsva.na_vattr.va_gid = (gid_t)0;
  327                         nfsva.na_vattr.va_fileid = 2;
  328                         nfsva.na_vattr.va_gen = 1;
  329                         nfsva.na_vattr.va_blocksize = NFS_FABLKSIZE;
  330                         nfsva.na_vattr.va_size = 512 * 1024;
  331                 }
  332         }
  333         (void) nfscl_loadattrcache(&vp, &nfsva, NULL, NULL, 0, 1);
  334         if (!error) {
  335             mtx_lock(&nmp->nm_mtx);
  336             if (gotfsinfo || (nmp->nm_flag & NFSMNT_NFSV4))
  337                 nfscl_loadfsinfo(nmp, &fs);
  338             nfscl_loadsbinfo(nmp, &sb, sbp);
  339             sbp->f_iosize = newnfs_iosize(nmp);
  340             mtx_unlock(&nmp->nm_mtx);
  341             if (sbp != &mp->mnt_stat) {
  342                 bcopy(mp->mnt_stat.f_mntonname, sbp->f_mntonname, MNAMELEN);
  343                 bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN);
  344             }
  345             strncpy(&sbp->f_fstypename[0], mp->mnt_vfc->vfc_name, MFSNAMELEN);
  346         } else if (NFS_ISV4(vp)) {
  347                 error = nfscl_maperr(td, error, (uid_t)0, (gid_t)0);
  348         }
  349         vput(vp);
  350         vfs_unbusy(mp);
  351         return (error);
  352 }
  353 
  354 /*
  355  * nfs version 3 fsinfo rpc call
  356  */
  357 int
  358 ncl_fsinfo(struct nfsmount *nmp, struct vnode *vp, struct ucred *cred,
  359     struct thread *td)
  360 {
  361         struct nfsfsinfo fs;
  362         struct nfsvattr nfsva;
  363         int error, attrflag;
  364         
  365         error = nfsrpc_fsinfo(vp, &fs, cred, td, &nfsva, &attrflag, NULL);
  366         if (!error) {
  367                 if (attrflag)
  368                         (void) nfscl_loadattrcache(&vp, &nfsva, NULL, NULL, 0,
  369                             1);
  370                 mtx_lock(&nmp->nm_mtx);
  371                 nfscl_loadfsinfo(nmp, &fs);
  372                 mtx_unlock(&nmp->nm_mtx);
  373         }
  374         return (error);
  375 }
  376 
  377 /*
  378  * Mount a remote root fs via. nfs. This depends on the info in the
  379  * nfs_diskless structure that has been filled in properly by some primary
  380  * bootstrap.
  381  * It goes something like this:
  382  * - do enough of "ifconfig" by calling ifioctl() so that the system
  383  *   can talk to the server
  384  * - If nfs_diskless.mygateway is filled in, use that address as
  385  *   a default gateway.
  386  * - build the rootfs mount point and call mountnfs() to do the rest.
  387  *
  388  * It is assumed to be safe to read, modify, and write the nfsv3_diskless
  389  * structure, as well as other global NFS client variables here, as
  390  * nfs_mountroot() will be called once in the boot before any other NFS
  391  * client activity occurs.
  392  */
  393 static int
  394 nfs_mountroot(struct mount *mp)
  395 {
  396         struct thread *td = curthread;
  397         struct nfsv3_diskless *nd = &nfsv3_diskless;
  398         struct socket *so;
  399         struct vnode *vp;
  400         struct ifreq ir;
  401         int error;
  402         u_long l;
  403         char buf[128];
  404         char *cp;
  405 
  406 #if defined(BOOTP_NFSROOT) && defined(BOOTP)
  407         bootpc_init();          /* use bootp to get nfs_diskless filled in */
  408 #elif defined(NFS_ROOT)
  409         nfs_setup_diskless();
  410 #endif
  411 
  412         if (nfs_diskless_valid == 0)
  413                 return (-1);
  414         if (nfs_diskless_valid == 1)
  415                 nfs_convert_diskless();
  416 
  417         /*
  418          * Do enough of ifconfig(8) so that the critical net interface can
  419          * talk to the server.
  420          */
  421         error = socreate(nd->myif.ifra_addr.sa_family, &so, nd->root_args.sotype, 0,
  422             td->td_ucred, td);
  423         if (error)
  424                 panic("nfs_mountroot: socreate(%04x): %d",
  425                         nd->myif.ifra_addr.sa_family, error);
  426 
  427 #if 0 /* XXX Bad idea */
  428         /*
  429          * We might not have been told the right interface, so we pass
  430          * over the first ten interfaces of the same kind, until we get
  431          * one of them configured.
  432          */
  433 
  434         for (i = strlen(nd->myif.ifra_name) - 1;
  435                 nd->myif.ifra_name[i] >= '' &&
  436                 nd->myif.ifra_name[i] <= '9';
  437                 nd->myif.ifra_name[i] ++) {
  438                 error = ifioctl(so, SIOCAIFADDR, (caddr_t)&nd->myif, td);
  439                 if(!error)
  440                         break;
  441         }
  442 #endif
  443         error = ifioctl(so, SIOCAIFADDR, (caddr_t)&nd->myif, td);
  444         if (error)
  445                 panic("nfs_mountroot: SIOCAIFADDR: %d", error);
  446         if ((cp = kern_getenv("boot.netif.mtu")) != NULL) {
  447                 ir.ifr_mtu = strtol(cp, NULL, 10);
  448                 bcopy(nd->myif.ifra_name, ir.ifr_name, IFNAMSIZ);
  449                 freeenv(cp);
  450                 error = ifioctl(so, SIOCSIFMTU, (caddr_t)&ir, td);
  451                 if (error)
  452                         printf("nfs_mountroot: SIOCSIFMTU: %d", error);
  453         }
  454         soclose(so);
  455 
  456         /*
  457          * If the gateway field is filled in, set it as the default route.
  458          * Note that pxeboot will set a default route of 0 if the route
  459          * is not set by the DHCP server.  Check also for a value of 0
  460          * to avoid panicking inappropriately in that situation.
  461          */
  462         if (nd->mygateway.sin_len != 0 &&
  463             nd->mygateway.sin_addr.s_addr != 0) {
  464                 struct sockaddr_in mask, sin;
  465 
  466                 bzero((caddr_t)&mask, sizeof(mask));
  467                 sin = mask;
  468                 sin.sin_family = AF_INET;
  469                 sin.sin_len = sizeof(sin);
  470                 /* XXX MRT use table 0 for this sort of thing */
  471                 CURVNET_SET(TD_TO_VNET(td));
  472                 error = rtrequest_fib(RTM_ADD, (struct sockaddr *)&sin,
  473                     (struct sockaddr *)&nd->mygateway,
  474                     (struct sockaddr *)&mask,
  475                     RTF_UP | RTF_GATEWAY, NULL, RT_DEFAULT_FIB);
  476                 CURVNET_RESTORE();
  477                 if (error)
  478                         panic("nfs_mountroot: RTM_ADD: %d", error);
  479         }
  480 
  481         /*
  482          * Create the rootfs mount point.
  483          */
  484         nd->root_args.fh = nd->root_fh;
  485         nd->root_args.fhsize = nd->root_fhsize;
  486         l = ntohl(nd->root_saddr.sin_addr.s_addr);
  487         snprintf(buf, sizeof(buf), "%ld.%ld.%ld.%ld:%s",
  488                 (l >> 24) & 0xff, (l >> 16) & 0xff,
  489                 (l >>  8) & 0xff, (l >>  0) & 0xff, nd->root_hostnam);
  490         printf("NFS ROOT: %s\n", buf);
  491         nd->root_args.hostname = buf;
  492         if ((error = nfs_mountdiskless(buf,
  493             &nd->root_saddr, &nd->root_args, td, &vp, mp)) != 0) {
  494                 return (error);
  495         }
  496 
  497         /*
  498          * This is not really an nfs issue, but it is much easier to
  499          * set hostname here and then let the "/etc/rc.xxx" files
  500          * mount the right /var based upon its preset value.
  501          */
  502         mtx_lock(&prison0.pr_mtx);
  503         strlcpy(prison0.pr_hostname, nd->my_hostnam,
  504             sizeof(prison0.pr_hostname));
  505         mtx_unlock(&prison0.pr_mtx);
  506         inittodr(ntohl(nd->root_time));
  507         return (0);
  508 }
  509 
  510 /*
  511  * Internal version of mount system call for diskless setup.
  512  */
  513 static int
  514 nfs_mountdiskless(char *path,
  515     struct sockaddr_in *sin, struct nfs_args *args, struct thread *td,
  516     struct vnode **vpp, struct mount *mp)
  517 {
  518         struct sockaddr *nam;
  519         int dirlen, error;
  520         char *dirpath;
  521 
  522         /*
  523          * Find the directory path in "path", which also has the server's
  524          * name/ip address in it.
  525          */
  526         dirpath = strchr(path, ':');
  527         if (dirpath != NULL)
  528                 dirlen = strlen(++dirpath);
  529         else
  530                 dirlen = 0;
  531         nam = sodupsockaddr((struct sockaddr *)sin, M_WAITOK);
  532         if ((error = mountnfs(args, mp, nam, path, NULL, 0, dirpath, dirlen,
  533             NULL, 0, vpp, td->td_ucred, td, NFS_DEFAULT_NAMETIMEO, 
  534             NFS_DEFAULT_NEGNAMETIMEO, 0)) != 0) {
  535                 printf("nfs_mountroot: mount %s on /: %d\n", path, error);
  536                 return (error);
  537         }
  538         return (0);
  539 }
  540 
  541 static void
  542 nfs_sec_name(char *sec, int *flagsp)
  543 {
  544         if (!strcmp(sec, "krb5"))
  545                 *flagsp |= NFSMNT_KERB;
  546         else if (!strcmp(sec, "krb5i"))
  547                 *flagsp |= (NFSMNT_KERB | NFSMNT_INTEGRITY);
  548         else if (!strcmp(sec, "krb5p"))
  549                 *flagsp |= (NFSMNT_KERB | NFSMNT_PRIVACY);
  550 }
  551 
  552 static void
  553 nfs_decode_args(struct mount *mp, struct nfsmount *nmp, struct nfs_args *argp,
  554     const char *hostname, struct ucred *cred, struct thread *td)
  555 {
  556         int adjsock;
  557         char *p;
  558 
  559         /*
  560          * Set read-only flag if requested; otherwise, clear it if this is
  561          * an update.  If this is not an update, then either the read-only
  562          * flag is already clear, or this is a root mount and it was set
  563          * intentionally at some previous point.
  564          */
  565         if (vfs_getopt(mp->mnt_optnew, "ro", NULL, NULL) == 0) {
  566                 MNT_ILOCK(mp);
  567                 mp->mnt_flag |= MNT_RDONLY;
  568                 MNT_IUNLOCK(mp);
  569         } else if (mp->mnt_flag & MNT_UPDATE) {
  570                 MNT_ILOCK(mp);
  571                 mp->mnt_flag &= ~MNT_RDONLY;
  572                 MNT_IUNLOCK(mp);
  573         }
  574 
  575         /*
  576          * Silently clear NFSMNT_NOCONN if it's a TCP mount, it makes
  577          * no sense in that context.  Also, set up appropriate retransmit
  578          * and soft timeout behavior.
  579          */
  580         if (argp->sotype == SOCK_STREAM) {
  581                 nmp->nm_flag &= ~NFSMNT_NOCONN;
  582                 nmp->nm_timeo = NFS_MAXTIMEO;
  583                 if ((argp->flags & NFSMNT_NFSV4) != 0)
  584                         nmp->nm_retry = INT_MAX;
  585                 else
  586                         nmp->nm_retry = NFS_RETRANS_TCP;
  587         }
  588 
  589         /* Also clear RDIRPLUS if NFSv2, it crashes some servers */
  590         if ((argp->flags & (NFSMNT_NFSV3 | NFSMNT_NFSV4)) == 0) {
  591                 argp->flags &= ~NFSMNT_RDIRPLUS;
  592                 nmp->nm_flag &= ~NFSMNT_RDIRPLUS;
  593         }
  594 
  595         /* Clear ONEOPENOWN for NFSv2, 3 and 4.0. */
  596         if (nmp->nm_minorvers == 0) {
  597                 argp->flags &= ~NFSMNT_ONEOPENOWN;
  598                 nmp->nm_flag &= ~NFSMNT_ONEOPENOWN;
  599         }
  600 
  601         /* Re-bind if rsrvd port requested and wasn't on one */
  602         adjsock = !(nmp->nm_flag & NFSMNT_RESVPORT)
  603                   && (argp->flags & NFSMNT_RESVPORT);
  604         /* Also re-bind if we're switching to/from a connected UDP socket */
  605         adjsock |= ((nmp->nm_flag & NFSMNT_NOCONN) !=
  606                     (argp->flags & NFSMNT_NOCONN));
  607 
  608         /* Update flags atomically.  Don't change the lock bits. */
  609         nmp->nm_flag = argp->flags | nmp->nm_flag;
  610 
  611         if ((argp->flags & NFSMNT_TIMEO) && argp->timeo > 0) {
  612                 nmp->nm_timeo = (argp->timeo * NFS_HZ + 5) / 10;
  613                 if (nmp->nm_timeo < NFS_MINTIMEO)
  614                         nmp->nm_timeo = NFS_MINTIMEO;
  615                 else if (nmp->nm_timeo > NFS_MAXTIMEO)
  616                         nmp->nm_timeo = NFS_MAXTIMEO;
  617         }
  618 
  619         if ((argp->flags & NFSMNT_RETRANS) && argp->retrans > 1) {
  620                 nmp->nm_retry = argp->retrans;
  621                 if (nmp->nm_retry > NFS_MAXREXMIT)
  622                         nmp->nm_retry = NFS_MAXREXMIT;
  623         }
  624 
  625         if ((argp->flags & NFSMNT_WSIZE) && argp->wsize > 0) {
  626                 nmp->nm_wsize = argp->wsize;
  627                 /*
  628                  * Clip at the power of 2 below the size. There is an
  629                  * issue (not isolated) that causes intermittent page
  630                  * faults if this is not done.
  631                  */
  632                 if (nmp->nm_wsize > NFS_FABLKSIZE)
  633                         nmp->nm_wsize = 1 << (fls(nmp->nm_wsize) - 1);
  634                 else
  635                         nmp->nm_wsize = NFS_FABLKSIZE;
  636         }
  637 
  638         if ((argp->flags & NFSMNT_RSIZE) && argp->rsize > 0) {
  639                 nmp->nm_rsize = argp->rsize;
  640                 /*
  641                  * Clip at the power of 2 below the size. There is an
  642                  * issue (not isolated) that causes intermittent page
  643                  * faults if this is not done.
  644                  */
  645                 if (nmp->nm_rsize > NFS_FABLKSIZE)
  646                         nmp->nm_rsize = 1 << (fls(nmp->nm_rsize) - 1);
  647                 else
  648                         nmp->nm_rsize = NFS_FABLKSIZE;
  649         }
  650 
  651         if ((argp->flags & NFSMNT_READDIRSIZE) && argp->readdirsize > 0) {
  652                 nmp->nm_readdirsize = argp->readdirsize;
  653         }
  654 
  655         if ((argp->flags & NFSMNT_ACREGMIN) && argp->acregmin >= 0)
  656                 nmp->nm_acregmin = argp->acregmin;
  657         else
  658                 nmp->nm_acregmin = NFS_MINATTRTIMO;
  659         if ((argp->flags & NFSMNT_ACREGMAX) && argp->acregmax >= 0)
  660                 nmp->nm_acregmax = argp->acregmax;
  661         else
  662                 nmp->nm_acregmax = NFS_MAXATTRTIMO;
  663         if ((argp->flags & NFSMNT_ACDIRMIN) && argp->acdirmin >= 0)
  664                 nmp->nm_acdirmin = argp->acdirmin;
  665         else
  666                 nmp->nm_acdirmin = NFS_MINDIRATTRTIMO;
  667         if ((argp->flags & NFSMNT_ACDIRMAX) && argp->acdirmax >= 0)
  668                 nmp->nm_acdirmax = argp->acdirmax;
  669         else
  670                 nmp->nm_acdirmax = NFS_MAXDIRATTRTIMO;
  671         if (nmp->nm_acdirmin > nmp->nm_acdirmax)
  672                 nmp->nm_acdirmin = nmp->nm_acdirmax;
  673         if (nmp->nm_acregmin > nmp->nm_acregmax)
  674                 nmp->nm_acregmin = nmp->nm_acregmax;
  675 
  676         if ((argp->flags & NFSMNT_READAHEAD) && argp->readahead >= 0) {
  677                 if (argp->readahead <= NFS_MAXRAHEAD)
  678                         nmp->nm_readahead = argp->readahead;
  679                 else
  680                         nmp->nm_readahead = NFS_MAXRAHEAD;
  681         }
  682         if ((argp->flags & NFSMNT_WCOMMITSIZE) && argp->wcommitsize >= 0) {
  683                 if (argp->wcommitsize < nmp->nm_wsize)
  684                         nmp->nm_wcommitsize = nmp->nm_wsize;
  685                 else
  686                         nmp->nm_wcommitsize = argp->wcommitsize;
  687         }
  688 
  689         adjsock |= ((nmp->nm_sotype != argp->sotype) ||
  690                     (nmp->nm_soproto != argp->proto));
  691 
  692         if (nmp->nm_client != NULL && adjsock) {
  693                 int haslock = 0, error = 0;
  694 
  695                 if (nmp->nm_sotype == SOCK_STREAM) {
  696                         error = newnfs_sndlock(&nmp->nm_sockreq.nr_lock);
  697                         if (!error)
  698                                 haslock = 1;
  699                 }
  700                 if (!error) {
  701                     newnfs_disconnect(&nmp->nm_sockreq);
  702                     if (haslock)
  703                         newnfs_sndunlock(&nmp->nm_sockreq.nr_lock);
  704                     nmp->nm_sotype = argp->sotype;
  705                     nmp->nm_soproto = argp->proto;
  706                     if (nmp->nm_sotype == SOCK_DGRAM)
  707                         while (newnfs_connect(nmp, &nmp->nm_sockreq,
  708                             cred, td, 0)) {
  709                                 printf("newnfs_args: retrying connect\n");
  710                                 (void) nfs_catnap(PSOCK, 0, "nfscon");
  711                         }
  712                 }
  713         } else {
  714                 nmp->nm_sotype = argp->sotype;
  715                 nmp->nm_soproto = argp->proto;
  716         }
  717 
  718         if (hostname != NULL) {
  719                 strlcpy(nmp->nm_hostname, hostname,
  720                     sizeof(nmp->nm_hostname));
  721                 p = strchr(nmp->nm_hostname, ':');
  722                 if (p != NULL)
  723                         *p = '\0';
  724         }
  725 }
  726 
  727 static const char *nfs_opts[] = { "from", "nfs_args",
  728     "noac", "noatime", "noexec", "suiddir", "nosuid", "nosymfollow", "union",
  729     "noclusterr", "noclusterw", "multilabel", "acls", "force", "update",
  730     "async", "noconn", "nolockd", "conn", "lockd", "intr", "rdirplus",
  731     "readdirsize", "soft", "hard", "mntudp", "tcp", "udp", "wsize", "rsize",
  732     "retrans", "actimeo", "acregmin", "acregmax", "acdirmin", "acdirmax",
  733     "resvport", "readahead", "hostname", "timeo", "timeout", "addr", "fh",
  734     "nfsv3", "sec", "principal", "nfsv4", "gssname", "allgssname", "dirpath",
  735     "minorversion", "nametimeo", "negnametimeo", "nocto", "noncontigwr",
  736     "pnfs", "wcommitsize", "oneopenown",
  737     NULL };
  738 
  739 /*
  740  * Parse the "from" mountarg, passed by the generic mount(8) program
  741  * or the mountroot code.  This is used when rerooting into NFS.
  742  *
  743  * Note that the "hostname" is actually a "hostname:/share/path" string.
  744  */
  745 static int
  746 nfs_mount_parse_from(struct vfsoptlist *opts, char **hostnamep,
  747     struct sockaddr_in **sinp, char *dirpath, size_t dirpathsize, int *dirlenp)
  748 {
  749         char *nam, *delimp, *hostp, *spec;
  750         int error, have_bracket = 0, offset, rv, speclen;
  751         struct sockaddr_in *sin;
  752         size_t len;
  753 
  754         error = vfs_getopt(opts, "from", (void **)&spec, &speclen);
  755         if (error != 0)
  756                 return (error);
  757         nam = malloc(MNAMELEN + 1, M_TEMP, M_WAITOK);
  758 
  759         /*
  760          * This part comes from sbin/mount_nfs/mount_nfs.c:getnfsargs().
  761          */
  762         if (*spec == '[' && (delimp = strchr(spec + 1, ']')) != NULL &&
  763             *(delimp + 1) == ':') {
  764                 hostp = spec + 1;
  765                 spec = delimp + 2;
  766                 have_bracket = 1;
  767         } else if ((delimp = strrchr(spec, ':')) != NULL) {
  768                 hostp = spec;
  769                 spec = delimp + 1;
  770         } else if ((delimp = strrchr(spec, '@')) != NULL) {
  771                 printf("%s: path@server syntax is deprecated, "
  772                     "use server:path\n", __func__);
  773                 hostp = delimp + 1;
  774         } else {
  775                 printf("%s: no <host>:<dirpath> nfs-name\n", __func__);
  776                 free(nam, M_TEMP);
  777                 return (EINVAL);
  778         }
  779         *delimp = '\0';
  780 
  781         /*
  782          * If there has been a trailing slash at mounttime it seems
  783          * that some mountd implementations fail to remove the mount
  784          * entries from their mountlist while unmounting.
  785          */
  786         for (speclen = strlen(spec);
  787             speclen > 1 && spec[speclen - 1] == '/';
  788             speclen--)
  789                 spec[speclen - 1] = '\0';
  790         if (strlen(hostp) + strlen(spec) + 1 > MNAMELEN) {
  791                 printf("%s: %s:%s: name too long", __func__, hostp, spec);
  792                 free(nam, M_TEMP);
  793                 return (EINVAL);
  794         }
  795         /* Make both '@' and ':' notations equal */
  796         if (*hostp != '\0') {
  797                 len = strlen(hostp);
  798                 offset = 0;
  799                 if (have_bracket)
  800                         nam[offset++] = '[';
  801                 memmove(nam + offset, hostp, len);
  802                 if (have_bracket)
  803                         nam[len + offset++] = ']';
  804                 nam[len + offset++] = ':';
  805                 memmove(nam + len + offset, spec, speclen);
  806                 nam[len + speclen + offset] = '\0';
  807         } else
  808                 nam[0] = '\0';
  809 
  810         /*
  811          * XXX: IPv6
  812          */
  813         sin = malloc(sizeof(*sin), M_SONAME, M_WAITOK);
  814         rv = inet_pton(AF_INET, hostp, &sin->sin_addr);
  815         if (rv != 1) {
  816                 printf("%s: cannot parse '%s', inet_pton() returned %d\n",
  817                     __func__, hostp, rv);
  818                 free(nam, M_TEMP);
  819                 free(sin, M_SONAME);
  820                 return (EINVAL);
  821         }
  822 
  823         sin->sin_len = sizeof(*sin);
  824         sin->sin_family = AF_INET;
  825         /*
  826          * XXX: hardcoded port number.
  827          */
  828         sin->sin_port = htons(2049);
  829 
  830         *hostnamep = strdup(nam, M_NEWNFSMNT);
  831         *sinp = sin;
  832         strlcpy(dirpath, spec, dirpathsize);
  833         *dirlenp = strlen(dirpath);
  834 
  835         free(nam, M_TEMP);
  836         return (0);
  837 }
  838 
  839 /*
  840  * VFS Operations.
  841  *
  842  * mount system call
  843  * It seems a bit dumb to copyinstr() the host and path here and then
  844  * bcopy() them in mountnfs(), but I wanted to detect errors before
  845  * doing the getsockaddr() call because getsockaddr() allocates an mbuf and
  846  * an error after that means that I have to release the mbuf.
  847  */
  848 /* ARGSUSED */
  849 static int
  850 nfs_mount(struct mount *mp)
  851 {
  852         struct nfs_args args = {
  853             .version = NFS_ARGSVERSION,
  854             .addr = NULL,
  855             .addrlen = sizeof (struct sockaddr_in),
  856             .sotype = SOCK_STREAM,
  857             .proto = 0,
  858             .fh = NULL,
  859             .fhsize = 0,
  860             .flags = NFSMNT_RESVPORT,
  861             .wsize = NFS_WSIZE,
  862             .rsize = NFS_RSIZE,
  863             .readdirsize = NFS_READDIRSIZE,
  864             .timeo = 10,
  865             .retrans = NFS_RETRANS,
  866             .readahead = NFS_DEFRAHEAD,
  867             .wcommitsize = 0,                   /* was: NQ_DEFLEASE */
  868             .hostname = NULL,
  869             .acregmin = NFS_MINATTRTIMO,
  870             .acregmax = NFS_MAXATTRTIMO,
  871             .acdirmin = NFS_MINDIRATTRTIMO,
  872             .acdirmax = NFS_MAXDIRATTRTIMO,
  873         };
  874         int error = 0, ret, len;
  875         struct sockaddr *nam = NULL;
  876         struct vnode *vp;
  877         struct thread *td;
  878         char *hst;
  879         u_char nfh[NFSX_FHMAX], krbname[100], dirpath[100], srvkrbname[100];
  880         char *cp, *opt, *name, *secname;
  881         int nametimeo = NFS_DEFAULT_NAMETIMEO;
  882         int negnametimeo = NFS_DEFAULT_NEGNAMETIMEO;
  883         int minvers = 0;
  884         int dirlen, has_nfs_args_opt, has_nfs_from_opt,
  885             krbnamelen, srvkrbnamelen;
  886         size_t hstlen;
  887 
  888         has_nfs_args_opt = 0;
  889         has_nfs_from_opt = 0;
  890         hst = malloc(MNAMELEN, M_TEMP, M_WAITOK);
  891         if (vfs_filteropt(mp->mnt_optnew, nfs_opts)) {
  892                 error = EINVAL;
  893                 goto out;
  894         }
  895 
  896         td = curthread;
  897         if ((mp->mnt_flag & (MNT_ROOTFS | MNT_UPDATE)) == MNT_ROOTFS &&
  898             nfs_diskless_valid != 0) {
  899                 error = nfs_mountroot(mp);
  900                 goto out;
  901         }
  902 
  903         nfscl_init();
  904 
  905         /*
  906          * The old mount_nfs program passed the struct nfs_args
  907          * from userspace to kernel.  The new mount_nfs program
  908          * passes string options via nmount() from userspace to kernel
  909          * and we populate the struct nfs_args in the kernel.
  910          */
  911         if (vfs_getopt(mp->mnt_optnew, "nfs_args", NULL, NULL) == 0) {
  912                 error = vfs_copyopt(mp->mnt_optnew, "nfs_args", &args,
  913                     sizeof(args));
  914                 if (error != 0)
  915                         goto out;
  916 
  917                 if (args.version != NFS_ARGSVERSION) {
  918                         error = EPROGMISMATCH;
  919                         goto out;
  920                 }
  921                 has_nfs_args_opt = 1;
  922         }
  923 
  924         /* Handle the new style options. */
  925         if (vfs_getopt(mp->mnt_optnew, "noac", NULL, NULL) == 0) {
  926                 args.acdirmin = args.acdirmax =
  927                     args.acregmin = args.acregmax = 0;
  928                 args.flags |= NFSMNT_ACDIRMIN | NFSMNT_ACDIRMAX |
  929                     NFSMNT_ACREGMIN | NFSMNT_ACREGMAX;
  930         }
  931         if (vfs_getopt(mp->mnt_optnew, "noconn", NULL, NULL) == 0)
  932                 args.flags |= NFSMNT_NOCONN;
  933         if (vfs_getopt(mp->mnt_optnew, "conn", NULL, NULL) == 0)
  934                 args.flags &= ~NFSMNT_NOCONN;
  935         if (vfs_getopt(mp->mnt_optnew, "nolockd", NULL, NULL) == 0)
  936                 args.flags |= NFSMNT_NOLOCKD;
  937         if (vfs_getopt(mp->mnt_optnew, "lockd", NULL, NULL) == 0)
  938                 args.flags &= ~NFSMNT_NOLOCKD;
  939         if (vfs_getopt(mp->mnt_optnew, "intr", NULL, NULL) == 0)
  940                 args.flags |= NFSMNT_INT;
  941         if (vfs_getopt(mp->mnt_optnew, "rdirplus", NULL, NULL) == 0)
  942                 args.flags |= NFSMNT_RDIRPLUS;
  943         if (vfs_getopt(mp->mnt_optnew, "resvport", NULL, NULL) == 0)
  944                 args.flags |= NFSMNT_RESVPORT;
  945         if (vfs_getopt(mp->mnt_optnew, "noresvport", NULL, NULL) == 0)
  946                 args.flags &= ~NFSMNT_RESVPORT;
  947         if (vfs_getopt(mp->mnt_optnew, "soft", NULL, NULL) == 0)
  948                 args.flags |= NFSMNT_SOFT;
  949         if (vfs_getopt(mp->mnt_optnew, "hard", NULL, NULL) == 0)
  950                 args.flags &= ~NFSMNT_SOFT;
  951         if (vfs_getopt(mp->mnt_optnew, "mntudp", NULL, NULL) == 0)
  952                 args.sotype = SOCK_DGRAM;
  953         if (vfs_getopt(mp->mnt_optnew, "udp", NULL, NULL) == 0)
  954                 args.sotype = SOCK_DGRAM;
  955         if (vfs_getopt(mp->mnt_optnew, "tcp", NULL, NULL) == 0)
  956                 args.sotype = SOCK_STREAM;
  957         if (vfs_getopt(mp->mnt_optnew, "nfsv3", NULL, NULL) == 0)
  958                 args.flags |= NFSMNT_NFSV3;
  959         if (vfs_getopt(mp->mnt_optnew, "nfsv4", NULL, NULL) == 0) {
  960                 args.flags |= NFSMNT_NFSV4;
  961                 args.sotype = SOCK_STREAM;
  962         }
  963         if (vfs_getopt(mp->mnt_optnew, "allgssname", NULL, NULL) == 0)
  964                 args.flags |= NFSMNT_ALLGSSNAME;
  965         if (vfs_getopt(mp->mnt_optnew, "nocto", NULL, NULL) == 0)
  966                 args.flags |= NFSMNT_NOCTO;
  967         if (vfs_getopt(mp->mnt_optnew, "noncontigwr", NULL, NULL) == 0)
  968                 args.flags |= NFSMNT_NONCONTIGWR;
  969         if (vfs_getopt(mp->mnt_optnew, "pnfs", NULL, NULL) == 0)
  970                 args.flags |= NFSMNT_PNFS;
  971         if (vfs_getopt(mp->mnt_optnew, "oneopenown", NULL, NULL) == 0)
  972                 args.flags |= NFSMNT_ONEOPENOWN;
  973         if (vfs_getopt(mp->mnt_optnew, "readdirsize", (void **)&opt, NULL) == 0) {
  974                 if (opt == NULL) { 
  975                         vfs_mount_error(mp, "illegal readdirsize");
  976                         error = EINVAL;
  977                         goto out;
  978                 }
  979                 ret = sscanf(opt, "%d", &args.readdirsize);
  980                 if (ret != 1 || args.readdirsize <= 0) {
  981                         vfs_mount_error(mp, "illegal readdirsize: %s",
  982                             opt);
  983                         error = EINVAL;
  984                         goto out;
  985                 }
  986                 args.flags |= NFSMNT_READDIRSIZE;
  987         }
  988         if (vfs_getopt(mp->mnt_optnew, "readahead", (void **)&opt, NULL) == 0) {
  989                 if (opt == NULL) { 
  990                         vfs_mount_error(mp, "illegal readahead");
  991                         error = EINVAL;
  992                         goto out;
  993                 }
  994                 ret = sscanf(opt, "%d", &args.readahead);
  995                 if (ret != 1 || args.readahead <= 0) {
  996                         vfs_mount_error(mp, "illegal readahead: %s",
  997                             opt);
  998                         error = EINVAL;
  999                         goto out;
 1000                 }
 1001                 args.flags |= NFSMNT_READAHEAD;
 1002         }
 1003         if (vfs_getopt(mp->mnt_optnew, "wsize", (void **)&opt, NULL) == 0) {
 1004                 if (opt == NULL) { 
 1005                         vfs_mount_error(mp, "illegal wsize");
 1006                         error = EINVAL;
 1007                         goto out;
 1008                 }
 1009                 ret = sscanf(opt, "%d", &args.wsize);
 1010                 if (ret != 1 || args.wsize <= 0) {
 1011                         vfs_mount_error(mp, "illegal wsize: %s",
 1012                             opt);
 1013                         error = EINVAL;
 1014                         goto out;
 1015                 }
 1016                 args.flags |= NFSMNT_WSIZE;
 1017         }
 1018         if (vfs_getopt(mp->mnt_optnew, "rsize", (void **)&opt, NULL) == 0) {
 1019                 if (opt == NULL) { 
 1020                         vfs_mount_error(mp, "illegal rsize");
 1021                         error = EINVAL;
 1022                         goto out;
 1023                 }
 1024                 ret = sscanf(opt, "%d", &args.rsize);
 1025                 if (ret != 1 || args.rsize <= 0) {
 1026                         vfs_mount_error(mp, "illegal wsize: %s",
 1027                             opt);
 1028                         error = EINVAL;
 1029                         goto out;
 1030                 }
 1031                 args.flags |= NFSMNT_RSIZE;
 1032         }
 1033         if (vfs_getopt(mp->mnt_optnew, "retrans", (void **)&opt, NULL) == 0) {
 1034                 if (opt == NULL) { 
 1035                         vfs_mount_error(mp, "illegal retrans");
 1036                         error = EINVAL;
 1037                         goto out;
 1038                 }
 1039                 ret = sscanf(opt, "%d", &args.retrans);
 1040                 if (ret != 1 || args.retrans <= 0) {
 1041                         vfs_mount_error(mp, "illegal retrans: %s",
 1042                             opt);
 1043                         error = EINVAL;
 1044                         goto out;
 1045                 }
 1046                 args.flags |= NFSMNT_RETRANS;
 1047         }
 1048         if (vfs_getopt(mp->mnt_optnew, "actimeo", (void **)&opt, NULL) == 0) {
 1049                 ret = sscanf(opt, "%d", &args.acregmin);
 1050                 if (ret != 1 || args.acregmin < 0) {
 1051                         vfs_mount_error(mp, "illegal actimeo: %s",
 1052                             opt);
 1053                         error = EINVAL;
 1054                         goto out;
 1055                 }
 1056                 args.acdirmin = args.acdirmax = args.acregmax = args.acregmin;
 1057                 args.flags |= NFSMNT_ACDIRMIN | NFSMNT_ACDIRMAX |
 1058                     NFSMNT_ACREGMIN | NFSMNT_ACREGMAX;
 1059         }
 1060         if (vfs_getopt(mp->mnt_optnew, "acregmin", (void **)&opt, NULL) == 0) {
 1061                 ret = sscanf(opt, "%d", &args.acregmin);
 1062                 if (ret != 1 || args.acregmin < 0) {
 1063                         vfs_mount_error(mp, "illegal acregmin: %s",
 1064                             opt);
 1065                         error = EINVAL;
 1066                         goto out;
 1067                 }
 1068                 args.flags |= NFSMNT_ACREGMIN;
 1069         }
 1070         if (vfs_getopt(mp->mnt_optnew, "acregmax", (void **)&opt, NULL) == 0) {
 1071                 ret = sscanf(opt, "%d", &args.acregmax);
 1072                 if (ret != 1 || args.acregmax < 0) {
 1073                         vfs_mount_error(mp, "illegal acregmax: %s",
 1074                             opt);
 1075                         error = EINVAL;
 1076                         goto out;
 1077                 }
 1078                 args.flags |= NFSMNT_ACREGMAX;
 1079         }
 1080         if (vfs_getopt(mp->mnt_optnew, "acdirmin", (void **)&opt, NULL) == 0) {
 1081                 ret = sscanf(opt, "%d", &args.acdirmin);
 1082                 if (ret != 1 || args.acdirmin < 0) {
 1083                         vfs_mount_error(mp, "illegal acdirmin: %s",
 1084                             opt);
 1085                         error = EINVAL;
 1086                         goto out;
 1087                 }
 1088                 args.flags |= NFSMNT_ACDIRMIN;
 1089         }
 1090         if (vfs_getopt(mp->mnt_optnew, "acdirmax", (void **)&opt, NULL) == 0) {
 1091                 ret = sscanf(opt, "%d", &args.acdirmax);
 1092                 if (ret != 1 || args.acdirmax < 0) {
 1093                         vfs_mount_error(mp, "illegal acdirmax: %s",
 1094                             opt);
 1095                         error = EINVAL;
 1096                         goto out;
 1097                 }
 1098                 args.flags |= NFSMNT_ACDIRMAX;
 1099         }
 1100         if (vfs_getopt(mp->mnt_optnew, "wcommitsize", (void **)&opt, NULL) == 0) {
 1101                 ret = sscanf(opt, "%d", &args.wcommitsize);
 1102                 if (ret != 1 || args.wcommitsize < 0) {
 1103                         vfs_mount_error(mp, "illegal wcommitsize: %s", opt);
 1104                         error = EINVAL;
 1105                         goto out;
 1106                 }
 1107                 args.flags |= NFSMNT_WCOMMITSIZE;
 1108         }
 1109         if (vfs_getopt(mp->mnt_optnew, "timeo", (void **)&opt, NULL) == 0) {
 1110                 ret = sscanf(opt, "%d", &args.timeo);
 1111                 if (ret != 1 || args.timeo <= 0) {
 1112                         vfs_mount_error(mp, "illegal timeo: %s",
 1113                             opt);
 1114                         error = EINVAL;
 1115                         goto out;
 1116                 }
 1117                 args.flags |= NFSMNT_TIMEO;
 1118         }
 1119         if (vfs_getopt(mp->mnt_optnew, "timeout", (void **)&opt, NULL) == 0) {
 1120                 ret = sscanf(opt, "%d", &args.timeo);
 1121                 if (ret != 1 || args.timeo <= 0) {
 1122                         vfs_mount_error(mp, "illegal timeout: %s",
 1123                             opt);
 1124                         error = EINVAL;
 1125                         goto out;
 1126                 }
 1127                 args.flags |= NFSMNT_TIMEO;
 1128         }
 1129         if (vfs_getopt(mp->mnt_optnew, "nametimeo", (void **)&opt, NULL) == 0) {
 1130                 ret = sscanf(opt, "%d", &nametimeo);
 1131                 if (ret != 1 || nametimeo < 0) {
 1132                         vfs_mount_error(mp, "illegal nametimeo: %s", opt);
 1133                         error = EINVAL;
 1134                         goto out;
 1135                 }
 1136         }
 1137         if (vfs_getopt(mp->mnt_optnew, "negnametimeo", (void **)&opt, NULL)
 1138             == 0) {
 1139                 ret = sscanf(opt, "%d", &negnametimeo);
 1140                 if (ret != 1 || negnametimeo < 0) {
 1141                         vfs_mount_error(mp, "illegal negnametimeo: %s",
 1142                             opt);
 1143                         error = EINVAL;
 1144                         goto out;
 1145                 }
 1146         }
 1147         if (vfs_getopt(mp->mnt_optnew, "minorversion", (void **)&opt, NULL) ==
 1148             0) {
 1149                 ret = sscanf(opt, "%d", &minvers);
 1150                 if (ret != 1 || minvers < 0 || minvers > 1 ||
 1151                     (args.flags & NFSMNT_NFSV4) == 0) {
 1152                         vfs_mount_error(mp, "illegal minorversion: %s", opt);
 1153                         error = EINVAL;
 1154                         goto out;
 1155                 }
 1156         }
 1157         if (vfs_getopt(mp->mnt_optnew, "sec",
 1158                 (void **) &secname, NULL) == 0)
 1159                 nfs_sec_name(secname, &args.flags);
 1160 
 1161         if (mp->mnt_flag & MNT_UPDATE) {
 1162                 struct nfsmount *nmp = VFSTONFS(mp);
 1163 
 1164                 if (nmp == NULL) {
 1165                         error = EIO;
 1166                         goto out;
 1167                 }
 1168 
 1169                 /*
 1170                  * If a change from TCP->UDP is done and there are thread(s)
 1171                  * that have I/O RPC(s) in progress with a transfer size
 1172                  * greater than NFS_MAXDGRAMDATA, those thread(s) will be
 1173                  * hung, retrying the RPC(s) forever. Usually these threads
 1174                  * will be seen doing an uninterruptible sleep on wait channel
 1175                  * "nfsreq".
 1176                  */
 1177                 if (args.sotype == SOCK_DGRAM && nmp->nm_sotype == SOCK_STREAM)
 1178                         tprintf(td->td_proc, LOG_WARNING,
 1179         "Warning: mount -u that changes TCP->UDP can result in hung threads\n");
 1180 
 1181                 /*
 1182                  * When doing an update, we can't change version,
 1183                  * security, switch lockd strategies, change cookie
 1184                  * translation or switch oneopenown.
 1185                  */
 1186                 args.flags = (args.flags &
 1187                     ~(NFSMNT_NFSV3 |
 1188                       NFSMNT_NFSV4 |
 1189                       NFSMNT_KERB |
 1190                       NFSMNT_INTEGRITY |
 1191                       NFSMNT_PRIVACY |
 1192                       NFSMNT_ONEOPENOWN |
 1193                       NFSMNT_NOLOCKD /*|NFSMNT_XLATECOOKIE*/)) |
 1194                     (nmp->nm_flag &
 1195                         (NFSMNT_NFSV3 |
 1196                          NFSMNT_NFSV4 |
 1197                          NFSMNT_KERB |
 1198                          NFSMNT_INTEGRITY |
 1199                          NFSMNT_PRIVACY |
 1200                          NFSMNT_ONEOPENOWN |
 1201                          NFSMNT_NOLOCKD /*|NFSMNT_XLATECOOKIE*/));
 1202                 nfs_decode_args(mp, nmp, &args, NULL, td->td_ucred, td);
 1203                 goto out;
 1204         }
 1205 
 1206         /*
 1207          * Make the nfs_ip_paranoia sysctl serve as the default connection
 1208          * or no-connection mode for those protocols that support 
 1209          * no-connection mode (the flag will be cleared later for protocols
 1210          * that do not support no-connection mode).  This will allow a client
 1211          * to receive replies from a different IP then the request was
 1212          * sent to.  Note: default value for nfs_ip_paranoia is 1 (paranoid),
 1213          * not 0.
 1214          */
 1215         if (nfs_ip_paranoia == 0)
 1216                 args.flags |= NFSMNT_NOCONN;
 1217 
 1218         if (has_nfs_args_opt != 0) {
 1219                 /*
 1220                  * In the 'nfs_args' case, the pointers in the args
 1221                  * structure are in userland - we copy them in here.
 1222                  */
 1223                 if (args.fhsize < 0 || args.fhsize > NFSX_V3FHMAX) {
 1224                         vfs_mount_error(mp, "Bad file handle");
 1225                         error = EINVAL;
 1226                         goto out;
 1227                 }
 1228                 error = copyin((caddr_t)args.fh, (caddr_t)nfh,
 1229                     args.fhsize);
 1230                 if (error != 0)
 1231                         goto out;
 1232                 error = copyinstr(args.hostname, hst, MNAMELEN - 1, &hstlen);
 1233                 if (error != 0)
 1234                         goto out;
 1235                 bzero(&hst[hstlen], MNAMELEN - hstlen);
 1236                 args.hostname = hst;
 1237                 /* getsockaddr() call must be after above copyin() calls */
 1238                 error = getsockaddr(&nam, (caddr_t)args.addr,
 1239                     args.addrlen);
 1240                 if (error != 0)
 1241                         goto out;
 1242         } else if (nfs_mount_parse_from(mp->mnt_optnew,
 1243             &args.hostname, (struct sockaddr_in **)&nam, dirpath,
 1244             sizeof(dirpath), &dirlen) == 0) {
 1245                 has_nfs_from_opt = 1;
 1246                 bcopy(args.hostname, hst, MNAMELEN);
 1247                 hst[MNAMELEN - 1] = '\0';
 1248 
 1249                 /*
 1250                  * This only works with NFSv4 for now.
 1251                  */
 1252                 args.fhsize = 0;
 1253                 args.flags |= NFSMNT_NFSV4;
 1254                 args.sotype = SOCK_STREAM;
 1255         } else {
 1256                 if (vfs_getopt(mp->mnt_optnew, "fh", (void **)&args.fh,
 1257                     &args.fhsize) == 0) {
 1258                         if (args.fhsize < 0 || args.fhsize > NFSX_FHMAX) {
 1259                                 vfs_mount_error(mp, "Bad file handle");
 1260                                 error = EINVAL;
 1261                                 goto out;
 1262                         }
 1263                         bcopy(args.fh, nfh, args.fhsize);
 1264                 } else {
 1265                         args.fhsize = 0;
 1266                 }
 1267                 (void) vfs_getopt(mp->mnt_optnew, "hostname",
 1268                     (void **)&args.hostname, &len);
 1269                 if (args.hostname == NULL) {
 1270                         vfs_mount_error(mp, "Invalid hostname");
 1271                         error = EINVAL;
 1272                         goto out;
 1273                 }
 1274                 if (len >= MNAMELEN) {
 1275                         vfs_mount_error(mp, "Hostname too long");
 1276                         error = EINVAL;
 1277                         goto out;
 1278                 }
 1279                 bcopy(args.hostname, hst, len);
 1280                 hst[len] = '\0';
 1281         }
 1282 
 1283         if (vfs_getopt(mp->mnt_optnew, "principal", (void **)&name, NULL) == 0)
 1284                 strlcpy(srvkrbname, name, sizeof (srvkrbname));
 1285         else {
 1286                 snprintf(srvkrbname, sizeof (srvkrbname), "nfs@%s", hst);
 1287                 cp = strchr(srvkrbname, ':');
 1288                 if (cp != NULL)
 1289                         *cp = '\0';
 1290         }
 1291         srvkrbnamelen = strlen(srvkrbname);
 1292 
 1293         if (vfs_getopt(mp->mnt_optnew, "gssname", (void **)&name, NULL) == 0)
 1294                 strlcpy(krbname, name, sizeof (krbname));
 1295         else
 1296                 krbname[0] = '\0';
 1297         krbnamelen = strlen(krbname);
 1298 
 1299         if (has_nfs_from_opt == 0) {
 1300                 if (vfs_getopt(mp->mnt_optnew,
 1301                     "dirpath", (void **)&name, NULL) == 0)
 1302                         strlcpy(dirpath, name, sizeof (dirpath));
 1303                 else
 1304                         dirpath[0] = '\0';
 1305                 dirlen = strlen(dirpath);
 1306         }
 1307 
 1308         if (has_nfs_args_opt == 0 && has_nfs_from_opt == 0) {
 1309                 if (vfs_getopt(mp->mnt_optnew, "addr",
 1310                     (void **)&args.addr, &args.addrlen) == 0) {
 1311                         if (args.addrlen > SOCK_MAXADDRLEN) {
 1312                                 error = ENAMETOOLONG;
 1313                                 goto out;
 1314                         }
 1315                         nam = malloc(args.addrlen, M_SONAME, M_WAITOK);
 1316                         bcopy(args.addr, nam, args.addrlen);
 1317                         nam->sa_len = args.addrlen;
 1318                 } else {
 1319                         vfs_mount_error(mp, "No server address");
 1320                         error = EINVAL;
 1321                         goto out;
 1322                 }
 1323         }
 1324 
 1325         args.fh = nfh;
 1326         error = mountnfs(&args, mp, nam, hst, krbname, krbnamelen, dirpath,
 1327             dirlen, srvkrbname, srvkrbnamelen, &vp, td->td_ucred, td,
 1328             nametimeo, negnametimeo, minvers);
 1329 out:
 1330         if (!error) {
 1331                 MNT_ILOCK(mp);
 1332                 mp->mnt_kern_flag |= MNTK_LOOKUP_SHARED | MNTK_NO_IOPF |
 1333                     MNTK_USES_BCACHE;
 1334                 if ((VFSTONFS(mp)->nm_flag & NFSMNT_NFSV4) != 0)
 1335                         mp->mnt_kern_flag |= MNTK_NULL_NOCACHE;
 1336                 MNT_IUNLOCK(mp);
 1337         }
 1338         free(hst, M_TEMP);
 1339         return (error);
 1340 }
 1341 
 1342 
 1343 /*
 1344  * VFS Operations.
 1345  *
 1346  * mount system call
 1347  * It seems a bit dumb to copyinstr() the host and path here and then
 1348  * bcopy() them in mountnfs(), but I wanted to detect errors before
 1349  * doing the getsockaddr() call because getsockaddr() allocates an mbuf and
 1350  * an error after that means that I have to release the mbuf.
 1351  */
 1352 /* ARGSUSED */
 1353 static int
 1354 nfs_cmount(struct mntarg *ma, void *data, uint64_t flags)
 1355 {
 1356         int error;
 1357         struct nfs_args args;
 1358 
 1359         error = copyin(data, &args, sizeof (struct nfs_args));
 1360         if (error)
 1361                 return error;
 1362 
 1363         ma = mount_arg(ma, "nfs_args", &args, sizeof args);
 1364 
 1365         error = kernel_mount(ma, flags);
 1366         return (error);
 1367 }
 1368 
 1369 /*
 1370  * Common code for mount and mountroot
 1371  */
 1372 static int
 1373 mountnfs(struct nfs_args *argp, struct mount *mp, struct sockaddr *nam,
 1374     char *hst, u_char *krbname, int krbnamelen, u_char *dirpath, int dirlen,
 1375     u_char *srvkrbname, int srvkrbnamelen, struct vnode **vpp,
 1376     struct ucred *cred, struct thread *td, int nametimeo, int negnametimeo,
 1377     int minvers)
 1378 {
 1379         struct nfsmount *nmp;
 1380         struct nfsnode *np;
 1381         int error, trycnt, ret;
 1382         struct nfsvattr nfsva;
 1383         struct nfsclclient *clp;
 1384         struct nfsclds *dsp, *tdsp;
 1385         uint32_t lease;
 1386         static u_int64_t clval = 0;
 1387 
 1388         NFSCL_DEBUG(3, "in mnt\n");
 1389         clp = NULL;
 1390         if (mp->mnt_flag & MNT_UPDATE) {
 1391                 nmp = VFSTONFS(mp);
 1392                 printf("%s: MNT_UPDATE is no longer handled here\n", __func__);
 1393                 FREE(nam, M_SONAME);
 1394                 return (0);
 1395         } else {
 1396                 MALLOC(nmp, struct nfsmount *, sizeof (struct nfsmount) +
 1397                     krbnamelen + dirlen + srvkrbnamelen + 2,
 1398                     M_NEWNFSMNT, M_WAITOK | M_ZERO);
 1399                 TAILQ_INIT(&nmp->nm_bufq);
 1400                 TAILQ_INIT(&nmp->nm_sess);
 1401                 if (clval == 0)
 1402                         clval = (u_int64_t)nfsboottime.tv_sec;
 1403                 nmp->nm_clval = clval++;
 1404                 nmp->nm_krbnamelen = krbnamelen;
 1405                 nmp->nm_dirpathlen = dirlen;
 1406                 nmp->nm_srvkrbnamelen = srvkrbnamelen;
 1407                 if (td->td_ucred->cr_uid != (uid_t)0) {
 1408                         /*
 1409                          * nm_uid is used to get KerberosV credentials for
 1410                          * the nfsv4 state handling operations if there is
 1411                          * no host based principal set. Use the uid of
 1412                          * this user if not root, since they are doing the
 1413                          * mount. I don't think setting this for root will
 1414                          * work, since root normally does not have user
 1415                          * credentials in a credentials cache.
 1416                          */
 1417                         nmp->nm_uid = td->td_ucred->cr_uid;
 1418                 } else {
 1419                         /*
 1420                          * Just set to -1, so it won't be used.
 1421                          */
 1422                         nmp->nm_uid = (uid_t)-1;
 1423                 }
 1424 
 1425                 /* Copy and null terminate all the names */
 1426                 if (nmp->nm_krbnamelen > 0) {
 1427                         bcopy(krbname, nmp->nm_krbname, nmp->nm_krbnamelen);
 1428                         nmp->nm_name[nmp->nm_krbnamelen] = '\0';
 1429                 }
 1430                 if (nmp->nm_dirpathlen > 0) {
 1431                         bcopy(dirpath, NFSMNT_DIRPATH(nmp),
 1432                             nmp->nm_dirpathlen);
 1433                         nmp->nm_name[nmp->nm_krbnamelen + nmp->nm_dirpathlen
 1434                             + 1] = '\0';
 1435                 }
 1436                 if (nmp->nm_srvkrbnamelen > 0) {
 1437                         bcopy(srvkrbname, NFSMNT_SRVKRBNAME(nmp),
 1438                             nmp->nm_srvkrbnamelen);
 1439                         nmp->nm_name[nmp->nm_krbnamelen + nmp->nm_dirpathlen
 1440                             + nmp->nm_srvkrbnamelen + 2] = '\0';
 1441                 }
 1442                 nmp->nm_sockreq.nr_cred = crhold(cred);
 1443                 mtx_init(&nmp->nm_sockreq.nr_mtx, "nfssock", NULL, MTX_DEF);
 1444                 mp->mnt_data = nmp;
 1445                 nmp->nm_getinfo = nfs_getnlminfo;
 1446                 nmp->nm_vinvalbuf = ncl_vinvalbuf;
 1447         }
 1448         vfs_getnewfsid(mp);
 1449         nmp->nm_mountp = mp;
 1450         mtx_init(&nmp->nm_mtx, "NFSmount lock", NULL, MTX_DEF | MTX_DUPOK);
 1451 
 1452         /*
 1453          * Since nfs_decode_args() might optionally set them, these
 1454          * need to be set to defaults before the call, so that the
 1455          * optional settings aren't overwritten.
 1456          */
 1457         nmp->nm_nametimeo = nametimeo;
 1458         nmp->nm_negnametimeo = negnametimeo;
 1459         nmp->nm_timeo = NFS_TIMEO;
 1460         nmp->nm_retry = NFS_RETRANS;
 1461         nmp->nm_readahead = NFS_DEFRAHEAD;
 1462 
 1463         /* This is empirical approximation of sqrt(hibufspace) * 256. */
 1464         nmp->nm_wcommitsize = NFS_MAXBSIZE / 256;
 1465         while ((long)nmp->nm_wcommitsize * nmp->nm_wcommitsize < hibufspace)
 1466                 nmp->nm_wcommitsize *= 2;
 1467         nmp->nm_wcommitsize *= 256;
 1468 
 1469         if ((argp->flags & NFSMNT_NFSV4) != 0)
 1470                 nmp->nm_minorvers = minvers;
 1471         else
 1472                 nmp->nm_minorvers = 0;
 1473 
 1474         nfs_decode_args(mp, nmp, argp, hst, cred, td);
 1475 
 1476         /*
 1477          * V2 can only handle 32 bit filesizes.  A 4GB-1 limit may be too
 1478          * high, depending on whether we end up with negative offsets in
 1479          * the client or server somewhere.  2GB-1 may be safer.
 1480          *
 1481          * For V3, ncl_fsinfo will adjust this as necessary.  Assume maximum
 1482          * that we can handle until we find out otherwise.
 1483          */
 1484         if ((argp->flags & (NFSMNT_NFSV3 | NFSMNT_NFSV4)) == 0)
 1485                 nmp->nm_maxfilesize = 0xffffffffLL;
 1486         else
 1487                 nmp->nm_maxfilesize = OFF_MAX;
 1488 
 1489         if ((argp->flags & (NFSMNT_NFSV3 | NFSMNT_NFSV4)) == 0) {
 1490                 nmp->nm_wsize = NFS_WSIZE;
 1491                 nmp->nm_rsize = NFS_RSIZE;
 1492                 nmp->nm_readdirsize = NFS_READDIRSIZE;
 1493         }
 1494         nmp->nm_numgrps = NFS_MAXGRPS;
 1495         nmp->nm_tprintf_delay = nfs_tprintf_delay;
 1496         if (nmp->nm_tprintf_delay < 0)
 1497                 nmp->nm_tprintf_delay = 0;
 1498         nmp->nm_tprintf_initial_delay = nfs_tprintf_initial_delay;
 1499         if (nmp->nm_tprintf_initial_delay < 0)
 1500                 nmp->nm_tprintf_initial_delay = 0;
 1501         nmp->nm_fhsize = argp->fhsize;
 1502         if (nmp->nm_fhsize > 0)
 1503                 bcopy((caddr_t)argp->fh, (caddr_t)nmp->nm_fh, argp->fhsize);
 1504         bcopy(hst, mp->mnt_stat.f_mntfromname, MNAMELEN);
 1505         nmp->nm_nam = nam;
 1506         /* Set up the sockets and per-host congestion */
 1507         nmp->nm_sotype = argp->sotype;
 1508         nmp->nm_soproto = argp->proto;
 1509         nmp->nm_sockreq.nr_prog = NFS_PROG;
 1510         if ((argp->flags & NFSMNT_NFSV4))
 1511                 nmp->nm_sockreq.nr_vers = NFS_VER4;
 1512         else if ((argp->flags & NFSMNT_NFSV3))
 1513                 nmp->nm_sockreq.nr_vers = NFS_VER3;
 1514         else
 1515                 nmp->nm_sockreq.nr_vers = NFS_VER2;
 1516 
 1517 
 1518         if ((error = newnfs_connect(nmp, &nmp->nm_sockreq, cred, td, 0)))
 1519                 goto bad;
 1520         /* For NFSv4.1, get the clientid now. */
 1521         if (nmp->nm_minorvers > 0) {
 1522                 NFSCL_DEBUG(3, "at getcl\n");
 1523                 error = nfscl_getcl(mp, cred, td, 0, &clp);
 1524                 NFSCL_DEBUG(3, "aft getcl=%d\n", error);
 1525                 if (error != 0)
 1526                         goto bad;
 1527         }
 1528 
 1529         if (nmp->nm_fhsize == 0 && (nmp->nm_flag & NFSMNT_NFSV4) &&
 1530             nmp->nm_dirpathlen > 0) {
 1531                 NFSCL_DEBUG(3, "in dirp\n");
 1532                 /*
 1533                  * If the fhsize on the mount point == 0 for V4, the mount
 1534                  * path needs to be looked up.
 1535                  */
 1536                 trycnt = 3;
 1537                 do {
 1538                         error = nfsrpc_getdirpath(nmp, NFSMNT_DIRPATH(nmp),
 1539                             cred, td);
 1540                         NFSCL_DEBUG(3, "aft dirp=%d\n", error);
 1541                         if (error)
 1542                                 (void) nfs_catnap(PZERO, error, "nfsgetdirp");
 1543                 } while (error && --trycnt > 0);
 1544                 if (error)
 1545                         goto bad;
 1546         }
 1547 
 1548         /*
 1549          * A reference count is needed on the nfsnode representing the
 1550          * remote root.  If this object is not persistent, then backward
 1551          * traversals of the mount point (i.e. "..") will not work if
 1552          * the nfsnode gets flushed out of the cache. Ufs does not have
 1553          * this problem, because one can identify root inodes by their
 1554          * number == ROOTINO (2).
 1555          */
 1556         if (nmp->nm_fhsize > 0) {
 1557                 /*
 1558                  * Set f_iosize to NFS_DIRBLKSIZ so that bo_bsize gets set
 1559                  * non-zero for the root vnode. f_iosize will be set correctly
 1560                  * by nfs_statfs() before any I/O occurs.
 1561                  */
 1562                 mp->mnt_stat.f_iosize = NFS_DIRBLKSIZ;
 1563                 error = ncl_nget(mp, nmp->nm_fh, nmp->nm_fhsize, &np,
 1564                     LK_EXCLUSIVE);
 1565                 if (error)
 1566                         goto bad;
 1567                 *vpp = NFSTOV(np);
 1568         
 1569                 /*
 1570                  * Get file attributes and transfer parameters for the
 1571                  * mountpoint.  This has the side effect of filling in
 1572                  * (*vpp)->v_type with the correct value.
 1573                  */
 1574                 ret = nfsrpc_getattrnovp(nmp, nmp->nm_fh, nmp->nm_fhsize, 1,
 1575                     cred, td, &nfsva, NULL, &lease);
 1576                 if (ret) {
 1577                         /*
 1578                          * Just set default values to get things going.
 1579                          */
 1580                         NFSBZERO((caddr_t)&nfsva, sizeof (struct nfsvattr));
 1581                         nfsva.na_vattr.va_type = VDIR;
 1582                         nfsva.na_vattr.va_mode = 0777;
 1583                         nfsva.na_vattr.va_nlink = 100;
 1584                         nfsva.na_vattr.va_uid = (uid_t)0;
 1585                         nfsva.na_vattr.va_gid = (gid_t)0;
 1586                         nfsva.na_vattr.va_fileid = 2;
 1587                         nfsva.na_vattr.va_gen = 1;
 1588                         nfsva.na_vattr.va_blocksize = NFS_FABLKSIZE;
 1589                         nfsva.na_vattr.va_size = 512 * 1024;
 1590                         lease = 60;
 1591                 }
 1592                 (void) nfscl_loadattrcache(vpp, &nfsva, NULL, NULL, 0, 1);
 1593                 if (nmp->nm_minorvers > 0) {
 1594                         NFSCL_DEBUG(3, "lease=%d\n", (int)lease);
 1595                         NFSLOCKCLSTATE();
 1596                         clp->nfsc_renew = NFSCL_RENEW(lease);
 1597                         clp->nfsc_expire = NFSD_MONOSEC + clp->nfsc_renew;
 1598                         clp->nfsc_clientidrev++;
 1599                         if (clp->nfsc_clientidrev == 0)
 1600                                 clp->nfsc_clientidrev++;
 1601                         NFSUNLOCKCLSTATE();
 1602                         /*
 1603                          * Mount will succeed, so the renew thread can be
 1604                          * started now.
 1605                          */
 1606                         nfscl_start_renewthread(clp);
 1607                         nfscl_clientrelease(clp);
 1608                 }
 1609                 if (argp->flags & NFSMNT_NFSV3)
 1610                         ncl_fsinfo(nmp, *vpp, cred, td);
 1611         
 1612                 /* Mark if the mount point supports NFSv4 ACLs. */
 1613                 if ((argp->flags & NFSMNT_NFSV4) != 0 && nfsrv_useacl != 0 &&
 1614                     ret == 0 &&
 1615                     NFSISSET_ATTRBIT(&nfsva.na_suppattr, NFSATTRBIT_ACL)) {
 1616                         MNT_ILOCK(mp);
 1617                         mp->mnt_flag |= MNT_NFS4ACLS;
 1618                         MNT_IUNLOCK(mp);
 1619                 }
 1620         
 1621                 /*
 1622                  * Lose the lock but keep the ref.
 1623                  */
 1624                 NFSVOPUNLOCK(*vpp, 0);
 1625                 return (0);
 1626         }
 1627         error = EIO;
 1628 
 1629 bad:
 1630         if (clp != NULL)
 1631                 nfscl_clientrelease(clp);
 1632         newnfs_disconnect(&nmp->nm_sockreq);
 1633         crfree(nmp->nm_sockreq.nr_cred);
 1634         if (nmp->nm_sockreq.nr_auth != NULL)
 1635                 AUTH_DESTROY(nmp->nm_sockreq.nr_auth);
 1636         mtx_destroy(&nmp->nm_sockreq.nr_mtx);
 1637         mtx_destroy(&nmp->nm_mtx);
 1638         if (nmp->nm_clp != NULL) {
 1639                 NFSLOCKCLSTATE();
 1640                 LIST_REMOVE(nmp->nm_clp, nfsc_list);
 1641                 NFSUNLOCKCLSTATE();
 1642                 free(nmp->nm_clp, M_NFSCLCLIENT);
 1643         }
 1644         TAILQ_FOREACH_SAFE(dsp, &nmp->nm_sess, nfsclds_list, tdsp) {
 1645                 if (dsp != TAILQ_FIRST(&nmp->nm_sess) &&
 1646                     dsp->nfsclds_sockp != NULL)
 1647                         newnfs_disconnect(dsp->nfsclds_sockp);
 1648                 nfscl_freenfsclds(dsp);
 1649         }
 1650         FREE(nmp, M_NEWNFSMNT);
 1651         FREE(nam, M_SONAME);
 1652         return (error);
 1653 }
 1654 
 1655 /*
 1656  * unmount system call
 1657  */
 1658 static int
 1659 nfs_unmount(struct mount *mp, int mntflags)
 1660 {
 1661         struct thread *td;
 1662         struct nfsmount *nmp;
 1663         int error, flags = 0, i, trycnt = 0;
 1664         struct nfsclds *dsp, *tdsp;
 1665 
 1666         td = curthread;
 1667 
 1668         if (mntflags & MNT_FORCE)
 1669                 flags |= FORCECLOSE;
 1670         nmp = VFSTONFS(mp);
 1671         /*
 1672          * Goes something like this..
 1673          * - Call vflush() to clear out vnodes for this filesystem
 1674          * - Close the socket
 1675          * - Free up the data structures
 1676          */
 1677         /* In the forced case, cancel any outstanding requests. */
 1678         if (mntflags & MNT_FORCE) {
 1679                 error = newnfs_nmcancelreqs(nmp);
 1680                 if (error)
 1681                         goto out;
 1682                 /* For a forced close, get rid of the renew thread now */
 1683                 nfscl_umount(nmp, td);
 1684         }
 1685         /* We hold 1 extra ref on the root vnode; see comment in mountnfs(). */
 1686         do {
 1687                 error = vflush(mp, 1, flags, td);
 1688                 if ((mntflags & MNT_FORCE) && error != 0 && ++trycnt < 30)
 1689                         (void) nfs_catnap(PSOCK, error, "newndm");
 1690         } while ((mntflags & MNT_FORCE) && error != 0 && trycnt < 30);
 1691         if (error)
 1692                 goto out;
 1693 
 1694         /*
 1695          * We are now committed to the unmount.
 1696          */
 1697         if ((mntflags & MNT_FORCE) == 0)
 1698                 nfscl_umount(nmp, td);
 1699         else {
 1700                 mtx_lock(&nmp->nm_mtx);
 1701                 nmp->nm_privflag |= NFSMNTP_FORCEDISM;
 1702                 mtx_unlock(&nmp->nm_mtx);
 1703         }
 1704         /* Make sure no nfsiods are assigned to this mount. */
 1705         mtx_lock(&ncl_iod_mutex);
 1706         for (i = 0; i < NFS_MAXASYNCDAEMON; i++)
 1707                 if (ncl_iodmount[i] == nmp) {
 1708                         ncl_iodwant[i] = NFSIOD_AVAILABLE;
 1709                         ncl_iodmount[i] = NULL;
 1710                 }
 1711         mtx_unlock(&ncl_iod_mutex);
 1712 
 1713         /*
 1714          * We can now set mnt_data to NULL and wait for
 1715          * nfssvc(NFSSVC_FORCEDISM) to complete.
 1716          */
 1717         mtx_lock(&mountlist_mtx);
 1718         mtx_lock(&nmp->nm_mtx);
 1719         mp->mnt_data = NULL;
 1720         mtx_unlock(&mountlist_mtx);
 1721         while ((nmp->nm_privflag & NFSMNTP_CANCELRPCS) != 0)
 1722                 msleep(nmp, &nmp->nm_mtx, PVFS, "nfsfdism", 0);
 1723         mtx_unlock(&nmp->nm_mtx);
 1724 
 1725         newnfs_disconnect(&nmp->nm_sockreq);
 1726         crfree(nmp->nm_sockreq.nr_cred);
 1727         FREE(nmp->nm_nam, M_SONAME);
 1728         if (nmp->nm_sockreq.nr_auth != NULL)
 1729                 AUTH_DESTROY(nmp->nm_sockreq.nr_auth);
 1730         mtx_destroy(&nmp->nm_sockreq.nr_mtx);
 1731         mtx_destroy(&nmp->nm_mtx);
 1732         TAILQ_FOREACH_SAFE(dsp, &nmp->nm_sess, nfsclds_list, tdsp) {
 1733                 if (dsp != TAILQ_FIRST(&nmp->nm_sess) &&
 1734                     dsp->nfsclds_sockp != NULL)
 1735                         newnfs_disconnect(dsp->nfsclds_sockp);
 1736                 nfscl_freenfsclds(dsp);
 1737         }
 1738         FREE(nmp, M_NEWNFSMNT);
 1739 out:
 1740         return (error);
 1741 }
 1742 
 1743 /*
 1744  * Return root of a filesystem
 1745  */
 1746 static int
 1747 nfs_root(struct mount *mp, int flags, struct vnode **vpp)
 1748 {
 1749         struct vnode *vp;
 1750         struct nfsmount *nmp;
 1751         struct nfsnode *np;
 1752         int error;
 1753 
 1754         nmp = VFSTONFS(mp);
 1755         error = ncl_nget(mp, nmp->nm_fh, nmp->nm_fhsize, &np, flags);
 1756         if (error)
 1757                 return error;
 1758         vp = NFSTOV(np);
 1759         /*
 1760          * Get transfer parameters and attributes for root vnode once.
 1761          */
 1762         mtx_lock(&nmp->nm_mtx);
 1763         if (NFSHASNFSV3(nmp) && !NFSHASGOTFSINFO(nmp)) {
 1764                 mtx_unlock(&nmp->nm_mtx);
 1765                 ncl_fsinfo(nmp, vp, curthread->td_ucred, curthread);
 1766         } else 
 1767                 mtx_unlock(&nmp->nm_mtx);
 1768         if (vp->v_type == VNON)
 1769             vp->v_type = VDIR;
 1770         vp->v_vflag |= VV_ROOT;
 1771         *vpp = vp;
 1772         return (0);
 1773 }
 1774 
 1775 /*
 1776  * Flush out the buffer cache
 1777  */
 1778 /* ARGSUSED */
 1779 static int
 1780 nfs_sync(struct mount *mp, int waitfor)
 1781 {
 1782         struct vnode *vp, *mvp;
 1783         struct thread *td;
 1784         int error, allerror = 0;
 1785 
 1786         td = curthread;
 1787 
 1788         MNT_ILOCK(mp);
 1789         /*
 1790          * If a forced dismount is in progress, return from here so that
 1791          * the umount(2) syscall doesn't get stuck in VFS_SYNC() before
 1792          * calling VFS_UNMOUNT().
 1793          */
 1794         if (NFSCL_FORCEDISM(mp)) {
 1795                 MNT_IUNLOCK(mp);
 1796                 return (EBADF);
 1797         }
 1798         MNT_IUNLOCK(mp);
 1799 
 1800         /*
 1801          * Force stale buffer cache information to be flushed.
 1802          */
 1803 loop:
 1804         MNT_VNODE_FOREACH_ALL(vp, mp, mvp) {
 1805                 /* XXX Racy bv_cnt check. */
 1806                 if (NFSVOPISLOCKED(vp) || vp->v_bufobj.bo_dirty.bv_cnt == 0 ||
 1807                     waitfor == MNT_LAZY) {
 1808                         VI_UNLOCK(vp);
 1809                         continue;
 1810                 }
 1811                 if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) {
 1812                         MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);
 1813                         goto loop;
 1814                 }
 1815                 error = VOP_FSYNC(vp, waitfor, td);
 1816                 if (error)
 1817                         allerror = error;
 1818                 NFSVOPUNLOCK(vp, 0);
 1819                 vrele(vp);
 1820         }
 1821         return (allerror);
 1822 }
 1823 
 1824 static int
 1825 nfs_sysctl(struct mount *mp, fsctlop_t op, struct sysctl_req *req)
 1826 {
 1827         struct nfsmount *nmp = VFSTONFS(mp);
 1828         struct vfsquery vq;
 1829         int error;
 1830 
 1831         bzero(&vq, sizeof(vq));
 1832         switch (op) {
 1833 #if 0
 1834         case VFS_CTL_NOLOCKS:
 1835                 val = (nmp->nm_flag & NFSMNT_NOLOCKS) ? 1 : 0;
 1836                 if (req->oldptr != NULL) {
 1837                         error = SYSCTL_OUT(req, &val, sizeof(val));
 1838                         if (error)
 1839                                 return (error);
 1840                 }
 1841                 if (req->newptr != NULL) {
 1842                         error = SYSCTL_IN(req, &val, sizeof(val));
 1843                         if (error)
 1844                                 return (error);
 1845                         if (val)
 1846                                 nmp->nm_flag |= NFSMNT_NOLOCKS;
 1847                         else
 1848                                 nmp->nm_flag &= ~NFSMNT_NOLOCKS;
 1849                 }
 1850                 break;
 1851 #endif
 1852         case VFS_CTL_QUERY:
 1853                 mtx_lock(&nmp->nm_mtx);
 1854                 if (nmp->nm_state & NFSSTA_TIMEO)
 1855                         vq.vq_flags |= VQ_NOTRESP;
 1856                 mtx_unlock(&nmp->nm_mtx);
 1857 #if 0
 1858                 if (!(nmp->nm_flag & NFSMNT_NOLOCKS) &&
 1859                     (nmp->nm_state & NFSSTA_LOCKTIMEO))
 1860                         vq.vq_flags |= VQ_NOTRESPLOCK;
 1861 #endif
 1862                 error = SYSCTL_OUT(req, &vq, sizeof(vq));
 1863                 break;
 1864         case VFS_CTL_TIMEO:
 1865                 if (req->oldptr != NULL) {
 1866                         error = SYSCTL_OUT(req, &nmp->nm_tprintf_initial_delay,
 1867                             sizeof(nmp->nm_tprintf_initial_delay));
 1868                         if (error)
 1869                                 return (error);
 1870                 }
 1871                 if (req->newptr != NULL) {
 1872                         error = vfs_suser(mp, req->td);
 1873                         if (error)
 1874                                 return (error);
 1875                         error = SYSCTL_IN(req, &nmp->nm_tprintf_initial_delay,
 1876                             sizeof(nmp->nm_tprintf_initial_delay));
 1877                         if (error)
 1878                                 return (error);
 1879                         if (nmp->nm_tprintf_initial_delay < 0)
 1880                                 nmp->nm_tprintf_initial_delay = 0;
 1881                 }
 1882                 break;
 1883         default:
 1884                 return (ENOTSUP);
 1885         }
 1886         return (0);
 1887 }
 1888 
 1889 /*
 1890  * Purge any RPCs in progress, so that they will all return errors.
 1891  * This allows dounmount() to continue as far as VFS_UNMOUNT() for a
 1892  * forced dismount.
 1893  */
 1894 static void
 1895 nfs_purge(struct mount *mp)
 1896 {
 1897         struct nfsmount *nmp = VFSTONFS(mp);
 1898 
 1899         newnfs_nmcancelreqs(nmp);
 1900 }
 1901 
 1902 /*
 1903  * Extract the information needed by the nlm from the nfs vnode.
 1904  */
 1905 static void
 1906 nfs_getnlminfo(struct vnode *vp, uint8_t *fhp, size_t *fhlenp,
 1907     struct sockaddr_storage *sp, int *is_v3p, off_t *sizep,
 1908     struct timeval *timeop)
 1909 {
 1910         struct nfsmount *nmp;
 1911         struct nfsnode *np = VTONFS(vp);
 1912 
 1913         nmp = VFSTONFS(vp->v_mount);
 1914         if (fhlenp != NULL)
 1915                 *fhlenp = (size_t)np->n_fhp->nfh_len;
 1916         if (fhp != NULL)
 1917                 bcopy(np->n_fhp->nfh_fh, fhp, np->n_fhp->nfh_len);
 1918         if (sp != NULL)
 1919                 bcopy(nmp->nm_nam, sp, min(nmp->nm_nam->sa_len, sizeof(*sp)));
 1920         if (is_v3p != NULL)
 1921                 *is_v3p = NFS_ISV3(vp);
 1922         if (sizep != NULL)
 1923                 *sizep = np->n_size;
 1924         if (timeop != NULL) {
 1925                 timeop->tv_sec = nmp->nm_timeo / NFS_HZ;
 1926                 timeop->tv_usec = (nmp->nm_timeo % NFS_HZ) * (1000000 / NFS_HZ);
 1927         }
 1928 }
 1929 
 1930 /*
 1931  * This function prints out an option name, based on the conditional
 1932  * argument.
 1933  */
 1934 static __inline void nfscl_printopt(struct nfsmount *nmp, int testval,
 1935     char *opt, char **buf, size_t *blen)
 1936 {
 1937         int len;
 1938 
 1939         if (testval != 0 && *blen > strlen(opt)) {
 1940                 len = snprintf(*buf, *blen, "%s", opt);
 1941                 if (len != strlen(opt))
 1942                         printf("EEK!!\n");
 1943                 *buf += len;
 1944                 *blen -= len;
 1945         }
 1946 }
 1947 
 1948 /*
 1949  * This function printf out an options integer value.
 1950  */
 1951 static __inline void nfscl_printoptval(struct nfsmount *nmp, int optval,
 1952     char *opt, char **buf, size_t *blen)
 1953 {
 1954         int len;
 1955 
 1956         if (*blen > strlen(opt) + 1) {
 1957                 /* Could result in truncated output string. */
 1958                 len = snprintf(*buf, *blen, "%s=%d", opt, optval);
 1959                 if (len < *blen) {
 1960                         *buf += len;
 1961                         *blen -= len;
 1962                 }
 1963         }
 1964 }
 1965 
 1966 /*
 1967  * Load the option flags and values into the buffer.
 1968  */
 1969 void nfscl_retopts(struct nfsmount *nmp, char *buffer, size_t buflen)
 1970 {
 1971         char *buf;
 1972         size_t blen;
 1973 
 1974         buf = buffer;
 1975         blen = buflen;
 1976         nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_NFSV4) != 0, "nfsv4", &buf,
 1977             &blen);
 1978         if ((nmp->nm_flag & NFSMNT_NFSV4) != 0) {
 1979                 nfscl_printoptval(nmp, nmp->nm_minorvers, ",minorversion", &buf,
 1980                     &blen);
 1981                 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_PNFS) != 0, ",pnfs",
 1982                     &buf, &blen);
 1983                 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_ONEOPENOWN) != 0 &&
 1984                     nmp->nm_minorvers > 0, ",oneopenown", &buf, &blen);
 1985         }
 1986         nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_NFSV3) != 0, "nfsv3", &buf,
 1987             &blen);
 1988         nfscl_printopt(nmp, (nmp->nm_flag & (NFSMNT_NFSV3 | NFSMNT_NFSV4)) == 0,
 1989             "nfsv2", &buf, &blen);
 1990         nfscl_printopt(nmp, nmp->nm_sotype == SOCK_STREAM, ",tcp", &buf, &blen);
 1991         nfscl_printopt(nmp, nmp->nm_sotype != SOCK_STREAM, ",udp", &buf, &blen);
 1992         nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_RESVPORT) != 0, ",resvport",
 1993             &buf, &blen);
 1994         nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_NOCONN) != 0, ",noconn",
 1995             &buf, &blen);
 1996         nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_SOFT) == 0, ",hard", &buf,
 1997             &blen);
 1998         nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_SOFT) != 0, ",soft", &buf,
 1999             &blen);
 2000         nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_INT) != 0, ",intr", &buf,
 2001             &blen);
 2002         nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_NOCTO) == 0, ",cto", &buf,
 2003             &blen);
 2004         nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_NOCTO) != 0, ",nocto", &buf,
 2005             &blen);
 2006         nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_NONCONTIGWR) != 0,
 2007             ",noncontigwr", &buf, &blen);
 2008         nfscl_printopt(nmp, (nmp->nm_flag & (NFSMNT_NOLOCKD | NFSMNT_NFSV4)) ==
 2009             0, ",lockd", &buf, &blen);
 2010         nfscl_printopt(nmp, (nmp->nm_flag & (NFSMNT_NOLOCKD | NFSMNT_NFSV4)) ==
 2011             NFSMNT_NOLOCKD, ",nolockd", &buf, &blen);
 2012         nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_RDIRPLUS) != 0, ",rdirplus",
 2013             &buf, &blen);
 2014         nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_KERB) == 0, ",sec=sys",
 2015             &buf, &blen);
 2016         nfscl_printopt(nmp, (nmp->nm_flag & (NFSMNT_KERB | NFSMNT_INTEGRITY |
 2017             NFSMNT_PRIVACY)) == NFSMNT_KERB, ",sec=krb5", &buf, &blen);
 2018         nfscl_printopt(nmp, (nmp->nm_flag & (NFSMNT_KERB | NFSMNT_INTEGRITY |
 2019             NFSMNT_PRIVACY)) == (NFSMNT_KERB | NFSMNT_INTEGRITY), ",sec=krb5i",
 2020             &buf, &blen);
 2021         nfscl_printopt(nmp, (nmp->nm_flag & (NFSMNT_KERB | NFSMNT_INTEGRITY |
 2022             NFSMNT_PRIVACY)) == (NFSMNT_KERB | NFSMNT_PRIVACY), ",sec=krb5p",
 2023             &buf, &blen);
 2024         nfscl_printoptval(nmp, nmp->nm_acdirmin, ",acdirmin", &buf, &blen);
 2025         nfscl_printoptval(nmp, nmp->nm_acdirmax, ",acdirmax", &buf, &blen);
 2026         nfscl_printoptval(nmp, nmp->nm_acregmin, ",acregmin", &buf, &blen);
 2027         nfscl_printoptval(nmp, nmp->nm_acregmax, ",acregmax", &buf, &blen);
 2028         nfscl_printoptval(nmp, nmp->nm_nametimeo, ",nametimeo", &buf, &blen);
 2029         nfscl_printoptval(nmp, nmp->nm_negnametimeo, ",negnametimeo", &buf,
 2030             &blen);
 2031         nfscl_printoptval(nmp, nmp->nm_rsize, ",rsize", &buf, &blen);
 2032         nfscl_printoptval(nmp, nmp->nm_wsize, ",wsize", &buf, &blen);
 2033         nfscl_printoptval(nmp, nmp->nm_readdirsize, ",readdirsize", &buf,
 2034             &blen);
 2035         nfscl_printoptval(nmp, nmp->nm_readahead, ",readahead", &buf, &blen);
 2036         nfscl_printoptval(nmp, nmp->nm_wcommitsize, ",wcommitsize", &buf,
 2037             &blen);
 2038         nfscl_printoptval(nmp, nmp->nm_timeo, ",timeout", &buf, &blen);
 2039         nfscl_printoptval(nmp, nmp->nm_retry, ",retrans", &buf, &blen);
 2040 }
 2041 

Cache object: b29d9678c4e910cf4230f8dc34b26593


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