sys/fs/nfsclient/nfs_clvfsops.c

   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$");
  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          * XXX splnet, so networks will receive...
 419          */
 420         splnet();
 421
 422         /*
 423          * Do enough of ifconfig(8) so that the critical net interface can
 424          * talk to the server.
 425          */
 426         error = socreate(nd->myif.ifra_addr.sa_family, &so, nd->root_args.sotype, 0,
 427             td->td_ucred, td);
 428         if (error)
 429                 panic("nfs_mountroot: socreate(%04x): %d",
 430                         nd->myif.ifra_addr.sa_family, error);
 431
 432 #if 0 /* XXX Bad idea */
 433         /*
 434          * We might not have been told the right interface, so we pass
 435          * over the first ten interfaces of the same kind, until we get
 436          * one of them configured.
 437          */
 438
 439         for (i = strlen(nd->myif.ifra_name) - 1;
 440                 nd->myif.ifra_name[i] >= '0' &&
 441                 nd->myif.ifra_name[i] <= '9';
 442                 nd->myif.ifra_name[i] ++) {
 443                 error = ifioctl(so, SIOCAIFADDR, (caddr_t)&nd->myif, td);
 444                 if(!error)
 445                         break;
 446         }
 447 #endif
 448         error = ifioctl(so, SIOCAIFADDR, (caddr_t)&nd->myif, td);
 449         if (error)
 450                 panic("nfs_mountroot: SIOCAIFADDR: %d", error);
 451         if ((cp = kern_getenv("boot.netif.mtu")) != NULL) {
 452                 ir.ifr_mtu = strtol(cp, NULL, 10);
 453                 bcopy(nd->myif.ifra_name, ir.ifr_name, IFNAMSIZ);
 454                 freeenv(cp);
 455                 error = ifioctl(so, SIOCSIFMTU, (caddr_t)&ir, td);
 456                 if (error)
 457                         printf("nfs_mountroot: SIOCSIFMTU: %d", error);
 458         }
 459         soclose(so);
 460
 461         /*
 462          * If the gateway field is filled in, set it as the default route.
 463          * Note that pxeboot will set a default route of 0 if the route
 464          * is not set by the DHCP server.  Check also for a value of 0
 465          * to avoid panicking inappropriately in that situation.
 466          */
 467         if (nd->mygateway.sin_len != 0 &&
 468             nd->mygateway.sin_addr.s_addr != 0) {
 469                 struct sockaddr_in mask, sin;
 470
 471                 bzero((caddr_t)&mask, sizeof(mask));
 472                 sin = mask;
 473                 sin.sin_family = AF_INET;
 474                 sin.sin_len = sizeof(sin);
 475                 /* XXX MRT use table 0 for this sort of thing */
 476                 CURVNET_SET(TD_TO_VNET(td));
 477                 error = rtrequest_fib(RTM_ADD, (struct sockaddr *)&sin,
 478                     (struct sockaddr *)&nd->mygateway,
 479                     (struct sockaddr *)&mask,
 480                     RTF_UP | RTF_GATEWAY, NULL, RT_DEFAULT_FIB);
 481                 CURVNET_RESTORE();
 482                 if (error)
 483                         panic("nfs_mountroot: RTM_ADD: %d", error);
 484         }
 485
 486         /*
 487          * Create the rootfs mount point.
 488          */
 489         nd->root_args.fh = nd->root_fh;
 490         nd->root_args.fhsize = nd->root_fhsize;
 491         l = ntohl(nd->root_saddr.sin_addr.s_addr);
 492         snprintf(buf, sizeof(buf), "%ld.%ld.%ld.%ld:%s",
 493                 (l >> 24) & 0xff, (l >> 16) & 0xff,
 494                 (l >>  8) & 0xff, (l >>  0) & 0xff, nd->root_hostnam);
 495         printf("NFS ROOT: %s\n", buf);
 496         nd->root_args.hostname = buf;
 497         if ((error = nfs_mountdiskless(buf,
 498             &nd->root_saddr, &nd->root_args, td, &vp, mp)) != 0) {
 499                 return (error);
 500         }
 501
 502         /*
 503          * This is not really an nfs issue, but it is much easier to
 504          * set hostname here and then let the "/etc/rc.xxx" files
 505          * mount the right /var based upon its preset value.
 506          */
 507         mtx_lock(&prison0.pr_mtx);
 508         strlcpy(prison0.pr_hostname, nd->my_hostnam,
 509             sizeof(prison0.pr_hostname));
 510         mtx_unlock(&prison0.pr_mtx);
 511         inittodr(ntohl(nd->root_time));
 512         return (0);
 513 }
 514
 515 /*
 516  * Internal version of mount system call for diskless setup.
 517  */
 518 static int
 519 nfs_mountdiskless(char *path,
 520     struct sockaddr_in *sin, struct nfs_args *args, struct thread *td,
 521     struct vnode **vpp, struct mount *mp)
 522 {
 523         struct sockaddr *nam;
 524         int dirlen, error;
 525         char *dirpath;
 526
 527         /*
 528          * Find the directory path in "path", which also has the server's
 529          * name/ip address in it.
 530          */
 531         dirpath = strchr(path, ':');
 532         if (dirpath != NULL)
 533                 dirlen = strlen(++dirpath);
 534         else
 535                 dirlen = 0;
 536         nam = sodupsockaddr((struct sockaddr *)sin, M_WAITOK);
 537         if ((error = mountnfs(args, mp, nam, path, NULL, 0, dirpath, dirlen,
 538             NULL, 0, vpp, td->td_ucred, td, NFS_DEFAULT_NAMETIMEO,
 539             NFS_DEFAULT_NEGNAMETIMEO, 0)) != 0) {
 540                 printf("nfs_mountroot: mount %s on /: %d\n", path, error);
 541                 return (error);
 542         }
 543         return (0);
 544 }
 545
 546 static void
 547 nfs_sec_name(char *sec, int *flagsp)
 548 {
 549         if (!strcmp(sec, "krb5"))
 550                 *flagsp |= NFSMNT_KERB;
 551         else if (!strcmp(sec, "krb5i"))
 552                 *flagsp |= (NFSMNT_KERB | NFSMNT_INTEGRITY);
 553         else if (!strcmp(sec, "krb5p"))
 554                 *flagsp |= (NFSMNT_KERB | NFSMNT_PRIVACY);
 555 }
 556
 557 static void
 558 nfs_decode_args(struct mount *mp, struct nfsmount *nmp, struct nfs_args *argp,
 559     const char *hostname, struct ucred *cred, struct thread *td)
 560 {
 561         int s;
 562         int adjsock;
 563         char *p;
 564
 565         s = splnet();
 566
 567         /*
 568          * Set read-only flag if requested; otherwise, clear it if this is
 569          * an update.  If this is not an update, then either the read-only
 570          * flag is already clear, or this is a root mount and it was set
 571          * intentionally at some previous point.
 572          */
 573         if (vfs_getopt(mp->mnt_optnew, "ro", NULL, NULL) == 0) {
 574                 MNT_ILOCK(mp);
 575                 mp->mnt_flag |= MNT_RDONLY;
 576                 MNT_IUNLOCK(mp);
 577         } else if (mp->mnt_flag & MNT_UPDATE) {
 578                 MNT_ILOCK(mp);
 579                 mp->mnt_flag &= ~MNT_RDONLY;
 580                 MNT_IUNLOCK(mp);
 581         }
 582
 583         /*
 584          * Silently clear NFSMNT_NOCONN if it's a TCP mount, it makes
 585          * no sense in that context.  Also, set up appropriate retransmit
 586          * and soft timeout behavior.
 587          */
 588         if (argp->sotype == SOCK_STREAM) {
 589                 nmp->nm_flag &= ~NFSMNT_NOCONN;
 590                 nmp->nm_timeo = NFS_MAXTIMEO;
 591                 if ((argp->flags & NFSMNT_NFSV4) != 0)
 592                         nmp->nm_retry = INT_MAX;
 593                 else
 594                         nmp->nm_retry = NFS_RETRANS_TCP;
 595         }
 596
 597         /* Also clear RDIRPLUS if NFSv2, it crashes some servers */
 598         if ((argp->flags & (NFSMNT_NFSV3 | NFSMNT_NFSV4)) == 0) {
 599                 argp->flags &= ~NFSMNT_RDIRPLUS;
 600                 nmp->nm_flag &= ~NFSMNT_RDIRPLUS;
 601         }
 602
 603         /* Re-bind if rsrvd port requested and wasn't on one */
 604         adjsock = !(nmp->nm_flag & NFSMNT_RESVPORT)
 605                   && (argp->flags & NFSMNT_RESVPORT);
 606         /* Also re-bind if we're switching to/from a connected UDP socket */
 607         adjsock |= ((nmp->nm_flag & NFSMNT_NOCONN) !=
 608                     (argp->flags & NFSMNT_NOCONN));
 609
 610         /* Update flags atomically.  Don't change the lock bits. */
 611         nmp->nm_flag = argp->flags | nmp->nm_flag;
 612         splx(s);
 613
 614         if ((argp->flags & NFSMNT_TIMEO) && argp->timeo > 0) {
 615                 nmp->nm_timeo = (argp->timeo * NFS_HZ + 5) / 10;
 616                 if (nmp->nm_timeo < NFS_MINTIMEO)
 617                         nmp->nm_timeo = NFS_MINTIMEO;
 618                 else if (nmp->nm_timeo > NFS_MAXTIMEO)
 619                         nmp->nm_timeo = NFS_MAXTIMEO;
 620         }
 621
 622         if ((argp->flags & NFSMNT_RETRANS) && argp->retrans > 1) {
 623                 nmp->nm_retry = argp->retrans;
 624                 if (nmp->nm_retry > NFS_MAXREXMIT)
 625                         nmp->nm_retry = NFS_MAXREXMIT;
 626         }
 627
 628         if ((argp->flags & NFSMNT_WSIZE) && argp->wsize > 0) {
 629                 nmp->nm_wsize = argp->wsize;
 630                 /*
 631                  * Clip at the power of 2 below the size. There is an
 632                  * issue (not isolated) that causes intermittent page
 633                  * faults if this is not done.
 634                  */
 635                 if (nmp->nm_wsize > NFS_FABLKSIZE)
 636                         nmp->nm_wsize = 1 << (fls(nmp->nm_wsize) - 1);
 637                 else
 638                         nmp->nm_wsize = NFS_FABLKSIZE;
 639         }
 640
 641         if ((argp->flags & NFSMNT_RSIZE) && argp->rsize > 0) {
 642                 nmp->nm_rsize = argp->rsize;
 643                 /*
 644                  * Clip at the power of 2 below the size. There is an
 645                  * issue (not isolated) that causes intermittent page
 646                  * faults if this is not done.
 647                  */
 648                 if (nmp->nm_rsize > NFS_FABLKSIZE)
 649                         nmp->nm_rsize = 1 << (fls(nmp->nm_rsize) - 1);
 650                 else
 651                         nmp->nm_rsize = NFS_FABLKSIZE;
 652         }
 653
 654         if ((argp->flags & NFSMNT_READDIRSIZE) && argp->readdirsize > 0) {
 655                 nmp->nm_readdirsize = argp->readdirsize;
 656         }
 657
 658         if ((argp->flags & NFSMNT_ACREGMIN) && argp->acregmin >= 0)
 659                 nmp->nm_acregmin = argp->acregmin;
 660         else
 661                 nmp->nm_acregmin = NFS_MINATTRTIMO;
 662         if ((argp->flags & NFSMNT_ACREGMAX) && argp->acregmax >= 0)
 663                 nmp->nm_acregmax = argp->acregmax;
 664         else
 665                 nmp->nm_acregmax = NFS_MAXATTRTIMO;
 666         if ((argp->flags & NFSMNT_ACDIRMIN) && argp->acdirmin >= 0)
 667                 nmp->nm_acdirmin = argp->acdirmin;
 668         else
 669                 nmp->nm_acdirmin = NFS_MINDIRATTRTIMO;
 670         if ((argp->flags & NFSMNT_ACDIRMAX) && argp->acdirmax >= 0)
 671                 nmp->nm_acdirmax = argp->acdirmax;
 672         else
 673                 nmp->nm_acdirmax = NFS_MAXDIRATTRTIMO;
 674         if (nmp->nm_acdirmin > nmp->nm_acdirmax)
 675                 nmp->nm_acdirmin = nmp->nm_acdirmax;
 676         if (nmp->nm_acregmin > nmp->nm_acregmax)
 677                 nmp->nm_acregmin = nmp->nm_acregmax;
 678
 679         if ((argp->flags & NFSMNT_READAHEAD) && argp->readahead >= 0) {
 680                 if (argp->readahead <= NFS_MAXRAHEAD)
 681                         nmp->nm_readahead = argp->readahead;
 682                 else
 683                         nmp->nm_readahead = NFS_MAXRAHEAD;
 684         }
 685         if ((argp->flags & NFSMNT_WCOMMITSIZE) && argp->wcommitsize >= 0) {
 686                 if (argp->wcommitsize < nmp->nm_wsize)
 687                         nmp->nm_wcommitsize = nmp->nm_wsize;
 688                 else
 689                         nmp->nm_wcommitsize = argp->wcommitsize;
 690         }
 691
 692         adjsock |= ((nmp->nm_sotype != argp->sotype) ||
 693                     (nmp->nm_soproto != argp->proto));
 694
 695         if (nmp->nm_client != NULL && adjsock) {
 696                 int haslock = 0, error = 0;
 697
 698                 if (nmp->nm_sotype == SOCK_STREAM) {
 699                         error = newnfs_sndlock(&nmp->nm_sockreq.nr_lock);
 700                         if (!error)
 701                                 haslock = 1;
 702                 }
 703                 if (!error) {
 704                     newnfs_disconnect(&nmp->nm_sockreq);
 705                     if (haslock)
 706                         newnfs_sndunlock(&nmp->nm_sockreq.nr_lock);
 707                     nmp->nm_sotype = argp->sotype;
 708                     nmp->nm_soproto = argp->proto;
 709                     if (nmp->nm_sotype == SOCK_DGRAM)
 710                         while (newnfs_connect(nmp, &nmp->nm_sockreq,
 711                             cred, td, 0)) {
 712                                 printf("newnfs_args: retrying connect\n");
 713                                 (void) nfs_catnap(PSOCK, 0, "nfscon");
 714                         }
 715                 }
 716         } else {
 717                 nmp->nm_sotype = argp->sotype;
 718                 nmp->nm_soproto = argp->proto;
 719         }
 720
 721         if (hostname != NULL) {
 722                 strlcpy(nmp->nm_hostname, hostname,
 723                     sizeof(nmp->nm_hostname));
 724                 p = strchr(nmp->nm_hostname, ':');
 725                 if (p != NULL)
 726                         *p = '\0';
 727         }
 728 }
 729
 730 static const char *nfs_opts[] = { "from", "nfs_args",
 731     "noac", "noatime", "noexec", "suiddir", "nosuid", "nosymfollow", "union",
 732     "noclusterr", "noclusterw", "multilabel", "acls", "force", "update",
 733     "async", "noconn", "nolockd", "conn", "lockd", "intr", "rdirplus",
 734     "readdirsize", "soft", "hard", "mntudp", "tcp", "udp", "wsize", "rsize",
 735     "retrans", "actimeo", "acregmin", "acregmax", "acdirmin", "acdirmax",
 736     "resvport", "readahead", "hostname", "timeo", "timeout", "addr", "fh",
 737     "nfsv3", "sec", "principal", "nfsv4", "gssname", "allgssname", "dirpath",
 738     "minorversion", "nametimeo", "negnametimeo", "nocto", "noncontigwr",
 739     "pnfs", "wcommitsize",
 740     NULL };
 741
 742 /*
 743  * Parse the "from" mountarg, passed by the generic mount(8) program
 744  * or the mountroot code.  This is used when rerooting into NFS.
 745  *
 746  * Note that the "hostname" is actually a "hostname:/share/path" string.
 747  */
 748 static int
 749 nfs_mount_parse_from(struct vfsoptlist *opts, char **hostnamep,
 750     struct sockaddr_in **sinp, char *dirpath, size_t dirpathsize, int *dirlenp)
 751 {
 752         char nam[MNAMELEN + 1];
 753         char *delimp, *hostp, *spec;
 754         int error, have_bracket = 0, offset, rv, speclen;
 755         struct sockaddr_in *sin;
 756         size_t len;
 757
 758         error = vfs_getopt(opts, "from", (void **)&spec, &speclen);
 759         if (error != 0)
 760                 return (error);
 761
 762         /*
 763          * This part comes from sbin/mount_nfs/mount_nfs.c:getnfsargs().
 764          */
 765         if (*spec == '[' && (delimp = strchr(spec + 1, ']')) != NULL &&
 766             *(delimp + 1) == ':') {
 767                 hostp = spec + 1;
 768                 spec = delimp + 2;
 769                 have_bracket = 1;
 770         } else if ((delimp = strrchr(spec, ':')) != NULL) {
 771                 hostp = spec;
 772                 spec = delimp + 1;
 773         } else if ((delimp = strrchr(spec, '@')) != NULL) {
 774                 printf("%s: path@server syntax is deprecated, "
 775                     "use server:path\n", __func__);
 776                 hostp = delimp + 1;
 777         } else {
 778                 printf("%s: no <host>:<dirpath> nfs-name\n", __func__);
 779                 return (EINVAL);
 780         }
 781         *delimp = '\0';
 782
 783         /*
 784          * If there has been a trailing slash at mounttime it seems
 785          * that some mountd implementations fail to remove the mount
 786          * entries from their mountlist while unmounting.
 787          */
 788         for (speclen = strlen(spec);
 789             speclen > 1 && spec[speclen - 1] == '/';
 790             speclen--)
 791                 spec[speclen - 1] = '\0';
 792         if (strlen(hostp) + strlen(spec) + 1 > MNAMELEN) {
 793                 printf("%s: %s:%s: name too long", __func__, hostp, spec);
 794                 return (EINVAL);
 795         }
 796         /* Make both '@' and ':' notations equal */
 797         if (*hostp != '\0') {
 798                 len = strlen(hostp);
 799                 offset = 0;
 800                 if (have_bracket)
 801                         nam[offset++] = '[';
 802                 memmove(nam + offset, hostp, len);
 803                 if (have_bracket)
 804                         nam[len + offset++] = ']';
 805                 nam[len + offset++] = ':';
 806                 memmove(nam + len + offset, spec, speclen);
 807                 nam[len + speclen + offset] = '\0';
 808         } else
 809                 nam[0] = '\0';
 810
 811         /*
 812          * XXX: IPv6
 813          */
 814         sin = malloc(sizeof(*sin), M_SONAME, M_WAITOK);
 815         rv = inet_pton(AF_INET, hostp, &sin->sin_addr);
 816         if (rv != 1) {
 817                 printf("%s: cannot parse '%s', inet_pton() returned %d\n",
 818                     __func__, hostp, rv);
 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         return (0);
 836 }
 837
 838 /*
 839  * VFS Operations.
 840  *
 841  * mount system call
 842  * It seems a bit dumb to copyinstr() the host and path here and then
 843  * bcopy() them in mountnfs(), but I wanted to detect errors before
 844  * doing the getsockaddr() call because getsockaddr() allocates an mbuf and
 845  * an error after that means that I have to release the mbuf.
 846  */
 847 /* ARGSUSED */
 848 static int
 849 nfs_mount(struct mount *mp)
 850 {
 851         struct nfs_args args = {
 852             .version = NFS_ARGSVERSION,
 853             .addr = NULL,
 854             .addrlen = sizeof (struct sockaddr_in),
 855             .sotype = SOCK_STREAM,
 856             .proto = 0,
 857             .fh = NULL,
 858             .fhsize = 0,
 859             .flags = NFSMNT_RESVPORT,
 860             .wsize = NFS_WSIZE,
 861             .rsize = NFS_RSIZE,
 862             .readdirsize = NFS_READDIRSIZE,
 863             .timeo = 10,
 864             .retrans = NFS_RETRANS,
 865             .readahead = NFS_DEFRAHEAD,
 866             .wcommitsize = 0,                   /* was: NQ_DEFLEASE */
 867             .hostname = NULL,
 868             .acregmin = NFS_MINATTRTIMO,
 869             .acregmax = NFS_MAXATTRTIMO,
 870             .acdirmin = NFS_MINDIRATTRTIMO,
 871             .acdirmax = NFS_MAXDIRATTRTIMO,
 872         };
 873         int error = 0, ret, len;
 874         struct sockaddr *nam = NULL;
 875         struct vnode *vp;
 876         struct thread *td;
 877         char hst[MNAMELEN];
 878         u_char nfh[NFSX_FHMAX], krbname[100], dirpath[100], srvkrbname[100];
 879         char *cp, *opt, *name, *secname;
 880         int nametimeo = NFS_DEFAULT_NAMETIMEO;
 881         int negnametimeo = NFS_DEFAULT_NEGNAMETIMEO;
 882         int minvers = 0;
 883         int dirlen, has_nfs_args_opt, has_nfs_from_opt,
 884             krbnamelen, srvkrbnamelen;
 885         size_t hstlen;
 886
 887         has_nfs_args_opt = 0;
 888         has_nfs_from_opt = 0;
 889         if (vfs_filteropt(mp->mnt_optnew, nfs_opts)) {
 890                 error = EINVAL;
 891                 goto out;
 892         }
 893
 894         td = curthread;
 895         if ((mp->mnt_flag & (MNT_ROOTFS | MNT_UPDATE)) == MNT_ROOTFS &&
 896             nfs_diskless_valid != 0) {
 897                 error = nfs_mountroot(mp);
 898                 goto out;
 899         }
 900
 901         nfscl_init();
 902
 903         /*
 904          * The old mount_nfs program passed the struct nfs_args
 905          * from userspace to kernel.  The new mount_nfs program
 906          * passes string options via nmount() from userspace to kernel
 907          * and we populate the struct nfs_args in the kernel.
 908          */
 909         if (vfs_getopt(mp->mnt_optnew, "nfs_args", NULL, NULL) == 0) {
 910                 error = vfs_copyopt(mp->mnt_optnew, "nfs_args", &args,
 911                     sizeof(args));
 912                 if (error != 0)
 913                         goto out;
 914
 915                 if (args.version != NFS_ARGSVERSION) {
 916                         error = EPROGMISMATCH;
 917                         goto out;
 918                 }
 919                 has_nfs_args_opt = 1;
 920         }
 921
 922         /* Handle the new style options. */
 923         if (vfs_getopt(mp->mnt_optnew, "noac", NULL, NULL) == 0) {
 924                 args.acdirmin = args.acdirmax =
 925                     args.acregmin = args.acregmax = 0;
 926                 args.flags |= NFSMNT_ACDIRMIN | NFSMNT_ACDIRMAX |
 927                     NFSMNT_ACREGMIN | NFSMNT_ACREGMAX;
 928         }
 929         if (vfs_getopt(mp->mnt_optnew, "noconn", NULL, NULL) == 0)
 930                 args.flags |= NFSMNT_NOCONN;
 931         if (vfs_getopt(mp->mnt_optnew, "conn", NULL, NULL) == 0)
 932                 args.flags &= ~NFSMNT_NOCONN;
 933         if (vfs_getopt(mp->mnt_optnew, "nolockd", NULL, NULL) == 0)
 934                 args.flags |= NFSMNT_NOLOCKD;
 935         if (vfs_getopt(mp->mnt_optnew, "lockd", NULL, NULL) == 0)
 936                 args.flags &= ~NFSMNT_NOLOCKD;
 937         if (vfs_getopt(mp->mnt_optnew, "intr", NULL, NULL) == 0)
 938                 args.flags |= NFSMNT_INT;
 939         if (vfs_getopt(mp->mnt_optnew, "rdirplus", NULL, NULL) == 0)
 940                 args.flags |= NFSMNT_RDIRPLUS;
 941         if (vfs_getopt(mp->mnt_optnew, "resvport", NULL, NULL) == 0)
 942                 args.flags |= NFSMNT_RESVPORT;
 943         if (vfs_getopt(mp->mnt_optnew, "noresvport", NULL, NULL) == 0)
 944                 args.flags &= ~NFSMNT_RESVPORT;
 945         if (vfs_getopt(mp->mnt_optnew, "soft", NULL, NULL) == 0)
 946                 args.flags |= NFSMNT_SOFT;
 947         if (vfs_getopt(mp->mnt_optnew, "hard", NULL, NULL) == 0)
 948                 args.flags &= ~NFSMNT_SOFT;
 949         if (vfs_getopt(mp->mnt_optnew, "mntudp", NULL, NULL) == 0)
 950                 args.sotype = SOCK_DGRAM;
 951         if (vfs_getopt(mp->mnt_optnew, "udp", NULL, NULL) == 0)
 952                 args.sotype = SOCK_DGRAM;
 953         if (vfs_getopt(mp->mnt_optnew, "tcp", NULL, NULL) == 0)
 954                 args.sotype = SOCK_STREAM;
 955         if (vfs_getopt(mp->mnt_optnew, "nfsv3", NULL, NULL) == 0)
 956                 args.flags |= NFSMNT_NFSV3;
 957         if (vfs_getopt(mp->mnt_optnew, "nfsv4", NULL, NULL) == 0) {
 958                 args.flags |= NFSMNT_NFSV4;
 959                 args.sotype = SOCK_STREAM;
 960         }
 961         if (vfs_getopt(mp->mnt_optnew, "allgssname", NULL, NULL) == 0)
 962                 args.flags |= NFSMNT_ALLGSSNAME;
 963         if (vfs_getopt(mp->mnt_optnew, "nocto", NULL, NULL) == 0)
 964                 args.flags |= NFSMNT_NOCTO;
 965         if (vfs_getopt(mp->mnt_optnew, "noncontigwr", NULL, NULL) == 0)
 966                 args.flags |= NFSMNT_NONCONTIGWR;
 967         if (vfs_getopt(mp->mnt_optnew, "pnfs", NULL, NULL) == 0)
 968                 args.flags |= NFSMNT_PNFS;
 969         if (vfs_getopt(mp->mnt_optnew, "readdirsize", (void **)&opt, NULL) == 0) {
 970                 if (opt == NULL) {
 971                         vfs_mount_error(mp, "illegal readdirsize");
 972                         error = EINVAL;
 973                         goto out;
 974                 }
 975                 ret = sscanf(opt, "%d", &args.readdirsize);
 976                 if (ret != 1 || args.readdirsize <= 0) {
 977                         vfs_mount_error(mp, "illegal readdirsize: %s",
 978                             opt);
 979                         error = EINVAL;
 980                         goto out;
 981                 }
 982                 args.flags |= NFSMNT_READDIRSIZE;
 983         }
 984         if (vfs_getopt(mp->mnt_optnew, "readahead", (void **)&opt, NULL) == 0) {
 985                 if (opt == NULL) {
 986                         vfs_mount_error(mp, "illegal readahead");
 987                         error = EINVAL;
 988                         goto out;
 989                 }
 990                 ret = sscanf(opt, "%d", &args.readahead);
 991                 if (ret != 1 || args.readahead <= 0) {
 992                         vfs_mount_error(mp, "illegal readahead: %s",
 993                             opt);
 994                         error = EINVAL;
 995                         goto out;
 996                 }
 997                 args.flags |= NFSMNT_READAHEAD;
 998         }
 999         if (vfs_getopt(mp->mnt_optnew, "wsize", (void **)&opt, NULL) == 0) {
1000                 if (opt == NULL) {
1001                         vfs_mount_error(mp, "illegal wsize");
1002                         error = EINVAL;
1003                         goto out;
1004                 }
1005                 ret = sscanf(opt, "%d", &args.wsize);
1006                 if (ret != 1 || args.wsize <= 0) {
1007                         vfs_mount_error(mp, "illegal wsize: %s",
1008                             opt);
1009                         error = EINVAL;
1010                         goto out;
1011                 }
1012                 args.flags |= NFSMNT_WSIZE;
1013         }
1014         if (vfs_getopt(mp->mnt_optnew, "rsize", (void **)&opt, NULL) == 0) {
1015                 if (opt == NULL) {
1016                         vfs_mount_error(mp, "illegal rsize");
1017                         error = EINVAL;
1018                         goto out;
1019                 }
1020                 ret = sscanf(opt, "%d", &args.rsize);
1021                 if (ret != 1 || args.rsize <= 0) {
1022                         vfs_mount_error(mp, "illegal wsize: %s",
1023                             opt);
1024                         error = EINVAL;
1025                         goto out;
1026                 }
1027                 args.flags |= NFSMNT_RSIZE;
1028         }
1029         if (vfs_getopt(mp->mnt_optnew, "retrans", (void **)&opt, NULL) == 0) {
1030                 if (opt == NULL) {
1031                         vfs_mount_error(mp, "illegal retrans");
1032                         error = EINVAL;
1033                         goto out;
1034                 }
1035                 ret = sscanf(opt, "%d", &args.retrans);
1036                 if (ret != 1 || args.retrans <= 0) {
1037                         vfs_mount_error(mp, "illegal retrans: %s",
1038                             opt);
1039                         error = EINVAL;
1040                         goto out;
1041                 }
1042                 args.flags |= NFSMNT_RETRANS;
1043         }
1044         if (vfs_getopt(mp->mnt_optnew, "actimeo", (void **)&opt, NULL) == 0) {
1045                 ret = sscanf(opt, "%d", &args.acregmin);
1046                 if (ret != 1 || args.acregmin < 0) {
1047                         vfs_mount_error(mp, "illegal actimeo: %s",
1048                             opt);
1049                         error = EINVAL;
1050                         goto out;
1051                 }
1052                 args.acdirmin = args.acdirmax = args.acregmax = args.acregmin;
1053                 args.flags |= NFSMNT_ACDIRMIN | NFSMNT_ACDIRMAX |
1054                     NFSMNT_ACREGMIN | NFSMNT_ACREGMAX;
1055         }
1056         if (vfs_getopt(mp->mnt_optnew, "acregmin", (void **)&opt, NULL) == 0) {
1057                 ret = sscanf(opt, "%d", &args.acregmin);
1058                 if (ret != 1 || args.acregmin < 0) {
1059                         vfs_mount_error(mp, "illegal acregmin: %s",
1060                             opt);
1061                         error = EINVAL;
1062                         goto out;
1063                 }
1064                 args.flags |= NFSMNT_ACREGMIN;
1065         }
1066         if (vfs_getopt(mp->mnt_optnew, "acregmax", (void **)&opt, NULL) == 0) {
1067                 ret = sscanf(opt, "%d", &args.acregmax);
1068                 if (ret != 1 || args.acregmax < 0) {
1069                         vfs_mount_error(mp, "illegal acregmax: %s",
1070                             opt);
1071                         error = EINVAL;
1072                         goto out;
1073                 }
1074                 args.flags |= NFSMNT_ACREGMAX;
1075         }
1076         if (vfs_getopt(mp->mnt_optnew, "acdirmin", (void **)&opt, NULL) == 0) {
1077                 ret = sscanf(opt, "%d", &args.acdirmin);
1078                 if (ret != 1 || args.acdirmin < 0) {
1079                         vfs_mount_error(mp, "illegal acdirmin: %s",
1080                             opt);
1081                         error = EINVAL;
1082                         goto out;
1083                 }
1084                 args.flags |= NFSMNT_ACDIRMIN;
1085         }
1086         if (vfs_getopt(mp->mnt_optnew, "acdirmax", (void **)&opt, NULL) == 0) {
1087                 ret = sscanf(opt, "%d", &args.acdirmax);
1088                 if (ret != 1 || args.acdirmax < 0) {
1089                         vfs_mount_error(mp, "illegal acdirmax: %s",
1090                             opt);
1091                         error = EINVAL;
1092                         goto out;
1093                 }
1094                 args.flags |= NFSMNT_ACDIRMAX;
1095         }
1096         if (vfs_getopt(mp->mnt_optnew, "wcommitsize", (void **)&opt, NULL) == 0) {
1097                 ret = sscanf(opt, "%d", &args.wcommitsize);
1098                 if (ret != 1 || args.wcommitsize < 0) {
1099                         vfs_mount_error(mp, "illegal wcommitsize: %s", opt);
1100                         error = EINVAL;
1101                         goto out;
1102                 }
1103                 args.flags |= NFSMNT_WCOMMITSIZE;
1104         }
1105         if (vfs_getopt(mp->mnt_optnew, "timeo", (void **)&opt, NULL) == 0) {
1106                 ret = sscanf(opt, "%d", &args.timeo);
1107                 if (ret != 1 || args.timeo <= 0) {
1108                         vfs_mount_error(mp, "illegal timeo: %s",
1109                             opt);
1110                         error = EINVAL;
1111                         goto out;
1112                 }
1113                 args.flags |= NFSMNT_TIMEO;
1114         }
1115         if (vfs_getopt(mp->mnt_optnew, "timeout", (void **)&opt, NULL) == 0) {
1116                 ret = sscanf(opt, "%d", &args.timeo);
1117                 if (ret != 1 || args.timeo <= 0) {
1118                         vfs_mount_error(mp, "illegal timeout: %s",
1119                             opt);
1120                         error = EINVAL;
1121                         goto out;
1122                 }
1123                 args.flags |= NFSMNT_TIMEO;
1124         }
1125         if (vfs_getopt(mp->mnt_optnew, "nametimeo", (void **)&opt, NULL) == 0) {
1126                 ret = sscanf(opt, "%d", &nametimeo);
1127                 if (ret != 1 || nametimeo < 0) {
1128                         vfs_mount_error(mp, "illegal nametimeo: %s", opt);
1129                         error = EINVAL;
1130                         goto out;
1131                 }
1132         }
1133         if (vfs_getopt(mp->mnt_optnew, "negnametimeo", (void **)&opt, NULL)
1134             == 0) {
1135                 ret = sscanf(opt, "%d", &negnametimeo);
1136                 if (ret != 1 || negnametimeo < 0) {
1137                         vfs_mount_error(mp, "illegal negnametimeo: %s",
1138                             opt);
1139                         error = EINVAL;
1140                         goto out;
1141                 }
1142         }
1143         if (vfs_getopt(mp->mnt_optnew, "minorversion", (void **)&opt, NULL) ==
1144             0) {
1145                 ret = sscanf(opt, "%d", &minvers);
1146                 if (ret != 1 || minvers < 0 || minvers > 1 ||
1147                     (args.flags & NFSMNT_NFSV4) == 0) {
1148                         vfs_mount_error(mp, "illegal minorversion: %s", opt);
1149                         error = EINVAL;
1150                         goto out;
1151                 }
1152         }
1153         if (vfs_getopt(mp->mnt_optnew, "sec",
1154                 (void **) &secname, NULL) == 0)
1155                 nfs_sec_name(secname, &args.flags);
1156
1157         if (mp->mnt_flag & MNT_UPDATE) {
1158                 struct nfsmount *nmp = VFSTONFS(mp);
1159
1160                 if (nmp == NULL) {
1161                         error = EIO;
1162                         goto out;
1163                 }
1164
1165                 /*
1166                  * If a change from TCP->UDP is done and there are thread(s)
1167                  * that have I/O RPC(s) in progress with a transfer size
1168                  * greater than NFS_MAXDGRAMDATA, those thread(s) will be
1169                  * hung, retrying the RPC(s) forever. Usually these threads
1170                  * will be seen doing an uninterruptible sleep on wait channel
1171                  * "nfsreq".
1172                  */
1173                 if (args.sotype == SOCK_DGRAM && nmp->nm_sotype == SOCK_STREAM)
1174                         tprintf(td->td_proc, LOG_WARNING,
1175         "Warning: mount -u that changes TCP->UDP can result in hung threads\n");
1176
1177                 /*
1178                  * When doing an update, we can't change version,
1179                  * security, switch lockd strategies or change cookie
1180                  * translation
1181                  */
1182                 args.flags = (args.flags &
1183                     ~(NFSMNT_NFSV3 |
1184                       NFSMNT_NFSV4 |
1185                       NFSMNT_KERB |
1186                       NFSMNT_INTEGRITY |
1187                       NFSMNT_PRIVACY |
1188                       NFSMNT_NOLOCKD /*|NFSMNT_XLATECOOKIE*/)) |
1189                     (nmp->nm_flag &
1190                         (NFSMNT_NFSV3 |
1191                          NFSMNT_NFSV4 |
1192                          NFSMNT_KERB |
1193                          NFSMNT_INTEGRITY |
1194                          NFSMNT_PRIVACY |
1195                          NFSMNT_NOLOCKD /*|NFSMNT_XLATECOOKIE*/));
1196                 nfs_decode_args(mp, nmp, &args, NULL, td->td_ucred, td);
1197                 goto out;
1198         }
1199
1200         /*
1201          * Make the nfs_ip_paranoia sysctl serve as the default connection
1202          * or no-connection mode for those protocols that support
1203          * no-connection mode (the flag will be cleared later for protocols
1204          * that do not support no-connection mode).  This will allow a client
1205          * to receive replies from a different IP then the request was
1206          * sent to.  Note: default value for nfs_ip_paranoia is 1 (paranoid),
1207          * not 0.
1208          */
1209         if (nfs_ip_paranoia == 0)
1210                 args.flags |= NFSMNT_NOCONN;
1211
1212         if (has_nfs_args_opt != 0) {
1213                 /*
1214                  * In the 'nfs_args' case, the pointers in the args
1215                  * structure are in userland - we copy them in here.
1216                  */
1217                 if (args.fhsize < 0 || args.fhsize > NFSX_V3FHMAX) {
1218                         vfs_mount_error(mp, "Bad file handle");
1219                         error = EINVAL;
1220                         goto out;
1221                 }
1222                 error = copyin((caddr_t)args.fh, (caddr_t)nfh,
1223                     args.fhsize);
1224                 if (error != 0)
1225                         goto out;
1226                 error = copyinstr(args.hostname, hst, MNAMELEN - 1, &hstlen);
1227                 if (error != 0)
1228                         goto out;
1229                 bzero(&hst[hstlen], MNAMELEN - hstlen);
1230                 args.hostname = hst;
1231                 /* getsockaddr() call must be after above copyin() calls */
1232                 error = getsockaddr(&nam, (caddr_t)args.addr,
1233                     args.addrlen);
1234                 if (error != 0)
1235                         goto out;
1236         } else if (nfs_mount_parse_from(mp->mnt_optnew,
1237             &args.hostname, (struct sockaddr_in **)&nam, dirpath,
1238             sizeof(dirpath), &dirlen) == 0) {
1239                 has_nfs_from_opt = 1;
1240                 bcopy(args.hostname, hst, MNAMELEN);
1241                 hst[MNAMELEN - 1] = '\0';
1242
1243                 /*
1244                  * This only works with NFSv4 for now.
1245                  */
1246                 args.fhsize = 0;
1247                 args.flags |= NFSMNT_NFSV4;
1248                 args.sotype = SOCK_STREAM;
1249         } else {
1250                 if (vfs_getopt(mp->mnt_optnew, "fh", (void **)&args.fh,
1251                     &args.fhsize) == 0) {
1252                         if (args.fhsize < 0 || args.fhsize > NFSX_FHMAX) {
1253                                 vfs_mount_error(mp, "Bad file handle");
1254                                 error = EINVAL;
1255                                 goto out;
1256                         }
1257                         bcopy(args.fh, nfh, args.fhsize);
1258                 } else {
1259                         args.fhsize = 0;
1260                 }
1261                 (void) vfs_getopt(mp->mnt_optnew, "hostname",
1262                     (void **)&args.hostname, &len);
1263                 if (args.hostname == NULL) {
1264                         vfs_mount_error(mp, "Invalid hostname");
1265                         error = EINVAL;
1266                         goto out;
1267                 }
1268                 bcopy(args.hostname, hst, MNAMELEN);
1269                 hst[MNAMELEN - 1] = '\0';
1270         }
1271
1272         if (vfs_getopt(mp->mnt_optnew, "principal", (void **)&name, NULL) == 0)
1273                 strlcpy(srvkrbname, name, sizeof (srvkrbname));
1274         else {
1275                 snprintf(srvkrbname, sizeof (srvkrbname), "nfs@%s", hst);
1276                 cp = strchr(srvkrbname, ':');
1277                 if (cp != NULL)
1278                         *cp = '\0';
1279         }
1280         srvkrbnamelen = strlen(srvkrbname);
1281
1282         if (vfs_getopt(mp->mnt_optnew, "gssname", (void **)&name, NULL) == 0)
1283                 strlcpy(krbname, name, sizeof (krbname));
1284         else
1285                 krbname[0] = '\0';
1286         krbnamelen = strlen(krbname);
1287
1288         if (has_nfs_from_opt == 0) {
1289                 if (vfs_getopt(mp->mnt_optnew,
1290                     "dirpath", (void **)&name, NULL) == 0)
1291                         strlcpy(dirpath, name, sizeof (dirpath));
1292                 else
1293                         dirpath[0] = '\0';
1294                 dirlen = strlen(dirpath);
1295         }
1296
1297         if (has_nfs_args_opt == 0 && has_nfs_from_opt == 0) {
1298                 if (vfs_getopt(mp->mnt_optnew, "addr",
1299                     (void **)&args.addr, &args.addrlen) == 0) {
1300                         if (args.addrlen > SOCK_MAXADDRLEN) {
1301                                 error = ENAMETOOLONG;
1302                                 goto out;
1303                         }
1304                         nam = malloc(args.addrlen, M_SONAME, M_WAITOK);
1305                         bcopy(args.addr, nam, args.addrlen);
1306                         nam->sa_len = args.addrlen;
1307                 } else {
1308                         vfs_mount_error(mp, "No server address");
1309                         error = EINVAL;
1310                         goto out;
1311                 }
1312         }
1313
1314         args.fh = nfh;
1315         error = mountnfs(&args, mp, nam, hst, krbname, krbnamelen, dirpath,
1316             dirlen, srvkrbname, srvkrbnamelen, &vp, td->td_ucred, td,
1317             nametimeo, negnametimeo, minvers);
1318 out:
1319         if (!error) {
1320                 MNT_ILOCK(mp);
1321                 mp->mnt_kern_flag |= MNTK_LOOKUP_SHARED | MNTK_NO_IOPF |
1322                     MNTK_USES_BCACHE;
1323                 if ((VFSTONFS(mp)->nm_flag & NFSMNT_NFSV4) != 0)
1324                         mp->mnt_kern_flag |= MNTK_NULL_NOCACHE;
1325                 MNT_IUNLOCK(mp);
1326         }
1327         return (error);
1328 }
1329
1330
1331 /*
1332  * VFS Operations.
1333  *
1334  * mount system call
1335  * It seems a bit dumb to copyinstr() the host and path here and then
1336  * bcopy() them in mountnfs(), but I wanted to detect errors before
1337  * doing the getsockaddr() call because getsockaddr() allocates an mbuf and
1338  * an error after that means that I have to release the mbuf.
1339  */
1340 /* ARGSUSED */
1341 static int
1342 nfs_cmount(struct mntarg *ma, void *data, uint64_t flags)
1343 {
1344         int error;
1345         struct nfs_args args;
1346
1347         error = copyin(data, &args, sizeof (struct nfs_args));
1348         if (error)
1349                 return error;
1350
1351         ma = mount_arg(ma, "nfs_args", &args, sizeof args);
1352
1353         error = kernel_mount(ma, flags);
1354         return (error);
1355 }
1356
1357 /*
1358  * Common code for mount and mountroot
1359  */
1360 static int
1361 mountnfs(struct nfs_args *argp, struct mount *mp, struct sockaddr *nam,
1362     char *hst, u_char *krbname, int krbnamelen, u_char *dirpath, int dirlen,
1363     u_char *srvkrbname, int srvkrbnamelen, struct vnode **vpp,
1364     struct ucred *cred, struct thread *td, int nametimeo, int negnametimeo,
1365     int minvers)
1366 {
1367         struct nfsmount *nmp;
1368         struct nfsnode *np;
1369         int error, trycnt, ret;
1370         struct nfsvattr nfsva;
1371         struct nfsclclient *clp;
1372         struct nfsclds *dsp, *tdsp;
1373         uint32_t lease;
1374         static u_int64_t clval = 0;
1375
1376         NFSCL_DEBUG(3, "in mnt\n");
1377         clp = NULL;
1378         if (mp->mnt_flag & MNT_UPDATE) {
1379                 nmp = VFSTONFS(mp);
1380                 printf("%s: MNT_UPDATE is no longer handled here\n", __func__);
1381                 FREE(nam, M_SONAME);
1382                 return (0);
1383         } else {
1384                 MALLOC(nmp, struct nfsmount *, sizeof (struct nfsmount) +
1385                     krbnamelen + dirlen + srvkrbnamelen + 2,
1386                     M_NEWNFSMNT, M_WAITOK | M_ZERO);
1387                 TAILQ_INIT(&nmp->nm_bufq);
1388                 TAILQ_INIT(&nmp->nm_sess);
1389                 if (clval == 0)
1390                         clval = (u_int64_t)nfsboottime.tv_sec;
1391                 nmp->nm_clval = clval++;
1392                 nmp->nm_krbnamelen = krbnamelen;
1393                 nmp->nm_dirpathlen = dirlen;
1394                 nmp->nm_srvkrbnamelen = srvkrbnamelen;
1395                 if (td->td_ucred->cr_uid != (uid_t)0) {
1396                         /*
1397                          * nm_uid is used to get KerberosV credentials for
1398                          * the nfsv4 state handling operations if there is
1399                          * no host based principal set. Use the uid of
1400                          * this user if not root, since they are doing the
1401                          * mount. I don't think setting this for root will
1402                          * work, since root normally does not have user
1403                          * credentials in a credentials cache.
1404                          */
1405                         nmp->nm_uid = td->td_ucred->cr_uid;
1406                 } else {
1407                         /*
1408                          * Just set to -1, so it won't be used.
1409                          */
1410                         nmp->nm_uid = (uid_t)-1;
1411                 }
1412
1413                 /* Copy and null terminate all the names */
1414                 if (nmp->nm_krbnamelen > 0) {
1415                         bcopy(krbname, nmp->nm_krbname, nmp->nm_krbnamelen);
1416                         nmp->nm_name[nmp->nm_krbnamelen] = '\0';
1417                 }
1418                 if (nmp->nm_dirpathlen > 0) {
1419                         bcopy(dirpath, NFSMNT_DIRPATH(nmp),
1420                             nmp->nm_dirpathlen);
1421                         nmp->nm_name[nmp->nm_krbnamelen + nmp->nm_dirpathlen
1422                             + 1] = '\0';
1423                 }
1424                 if (nmp->nm_srvkrbnamelen > 0) {
1425                         bcopy(srvkrbname, NFSMNT_SRVKRBNAME(nmp),
1426                             nmp->nm_srvkrbnamelen);
1427                         nmp->nm_name[nmp->nm_krbnamelen + nmp->nm_dirpathlen
1428                             + nmp->nm_srvkrbnamelen + 2] = '\0';
1429                 }
1430                 nmp->nm_sockreq.nr_cred = crhold(cred);
1431                 mtx_init(&nmp->nm_sockreq.nr_mtx, "nfssock", NULL, MTX_DEF);
1432                 mp->mnt_data = nmp;
1433                 nmp->nm_getinfo = nfs_getnlminfo;
1434                 nmp->nm_vinvalbuf = ncl_vinvalbuf;
1435         }
1436         vfs_getnewfsid(mp);
1437         nmp->nm_mountp = mp;
1438         mtx_init(&nmp->nm_mtx, "NFSmount lock", NULL, MTX_DEF | MTX_DUPOK);
1439
1440         /*
1441          * Since nfs_decode_args() might optionally set them, these
1442          * need to be set to defaults before the call, so that the
1443          * optional settings aren't overwritten.
1444          */
1445         nmp->nm_nametimeo = nametimeo;
1446         nmp->nm_negnametimeo = negnametimeo;
1447         nmp->nm_timeo = NFS_TIMEO;
1448         nmp->nm_retry = NFS_RETRANS;
1449         nmp->nm_readahead = NFS_DEFRAHEAD;
1450
1451         /* This is empirical approximation of sqrt(hibufspace) * 256. */
1452         nmp->nm_wcommitsize = NFS_MAXBSIZE / 256;
1453         while ((long)nmp->nm_wcommitsize * nmp->nm_wcommitsize < hibufspace)
1454                 nmp->nm_wcommitsize *= 2;
1455         nmp->nm_wcommitsize *= 256;
1456
1457         if ((argp->flags & NFSMNT_NFSV4) != 0)
1458                 nmp->nm_minorvers = minvers;
1459         else
1460                 nmp->nm_minorvers = 0;
1461
1462         nfs_decode_args(mp, nmp, argp, hst, cred, td);
1463
1464         /*
1465          * V2 can only handle 32 bit filesizes.  A 4GB-1 limit may be too
1466          * high, depending on whether we end up with negative offsets in
1467          * the client or server somewhere.  2GB-1 may be safer.
1468          *
1469          * For V3, ncl_fsinfo will adjust this as necessary.  Assume maximum
1470          * that we can handle until we find out otherwise.
1471          */
1472         if ((argp->flags & (NFSMNT_NFSV3 | NFSMNT_NFSV4)) == 0)
1473                 nmp->nm_maxfilesize = 0xffffffffLL;
1474         else
1475                 nmp->nm_maxfilesize = OFF_MAX;
1476
1477         if ((argp->flags & (NFSMNT_NFSV3 | NFSMNT_NFSV4)) == 0) {
1478                 nmp->nm_wsize = NFS_WSIZE;
1479                 nmp->nm_rsize = NFS_RSIZE;
1480                 nmp->nm_readdirsize = NFS_READDIRSIZE;
1481         }
1482         nmp->nm_numgrps = NFS_MAXGRPS;
1483         nmp->nm_tprintf_delay = nfs_tprintf_delay;
1484         if (nmp->nm_tprintf_delay < 0)
1485                 nmp->nm_tprintf_delay = 0;
1486         nmp->nm_tprintf_initial_delay = nfs_tprintf_initial_delay;
1487         if (nmp->nm_tprintf_initial_delay < 0)
1488                 nmp->nm_tprintf_initial_delay = 0;
1489         nmp->nm_fhsize = argp->fhsize;
1490         if (nmp->nm_fhsize > 0)
1491                 bcopy((caddr_t)argp->fh, (caddr_t)nmp->nm_fh, argp->fhsize);
1492         bcopy(hst, mp->mnt_stat.f_mntfromname, MNAMELEN);
1493         nmp->nm_nam = nam;
1494         /* Set up the sockets and per-host congestion */
1495         nmp->nm_sotype = argp->sotype;
1496         nmp->nm_soproto = argp->proto;
1497         nmp->nm_sockreq.nr_prog = NFS_PROG;
1498         if ((argp->flags & NFSMNT_NFSV4))
1499                 nmp->nm_sockreq.nr_vers = NFS_VER4;
1500         else if ((argp->flags & NFSMNT_NFSV3))
1501                 nmp->nm_sockreq.nr_vers = NFS_VER3;
1502         else
1503                 nmp->nm_sockreq.nr_vers = NFS_VER2;
1504
1505
1506         if ((error = newnfs_connect(nmp, &nmp->nm_sockreq, cred, td, 0)))
1507                 goto bad;
1508         /* For NFSv4.1, get the clientid now. */
1509         if (nmp->nm_minorvers > 0) {
1510                 NFSCL_DEBUG(3, "at getcl\n");
1511                 error = nfscl_getcl(mp, cred, td, 0, &clp);
1512                 NFSCL_DEBUG(3, "aft getcl=%d\n", error);
1513                 if (error != 0)
1514                         goto bad;
1515         }
1516
1517         if (nmp->nm_fhsize == 0 && (nmp->nm_flag & NFSMNT_NFSV4) &&
1518             nmp->nm_dirpathlen > 0) {
1519                 NFSCL_DEBUG(3, "in dirp\n");
1520                 /*
1521                  * If the fhsize on the mount point == 0 for V4, the mount
1522                  * path needs to be looked up.
1523                  */
1524                 trycnt = 3;
1525                 do {
1526                         error = nfsrpc_getdirpath(nmp, NFSMNT_DIRPATH(nmp),
1527                             cred, td);
1528                         NFSCL_DEBUG(3, "aft dirp=%d\n", error);
1529                         if (error)
1530                                 (void) nfs_catnap(PZERO, error, "nfsgetdirp");
1531                 } while (error && --trycnt > 0);
1532                 if (error) {
1533                         error = nfscl_maperr(td, error, (uid_t)0, (gid_t)0);
1534                         goto bad;
1535                 }
1536         }
1537
1538         /*
1539          * A reference count is needed on the nfsnode representing the
1540          * remote root.  If this object is not persistent, then backward
1541          * traversals of the mount point (i.e. "..") will not work if
1542          * the nfsnode gets flushed out of the cache. Ufs does not have
1543          * this problem, because one can identify root inodes by their
1544          * number == ROOTINO (2).
1545          */
1546         if (nmp->nm_fhsize > 0) {
1547                 /*
1548                  * Set f_iosize to NFS_DIRBLKSIZ so that bo_bsize gets set
1549                  * non-zero for the root vnode. f_iosize will be set correctly
1550                  * by nfs_statfs() before any I/O occurs.
1551                  */
1552                 mp->mnt_stat.f_iosize = NFS_DIRBLKSIZ;
1553                 error = ncl_nget(mp, nmp->nm_fh, nmp->nm_fhsize, &np,
1554                     LK_EXCLUSIVE);
1555                 if (error)
1556                         goto bad;
1557                 *vpp = NFSTOV(np);
1558
1559                 /*
1560                  * Get file attributes and transfer parameters for the
1561                  * mountpoint.  This has the side effect of filling in
1562                  * (*vpp)->v_type with the correct value.
1563                  */
1564                 ret = nfsrpc_getattrnovp(nmp, nmp->nm_fh, nmp->nm_fhsize, 1,
1565                     cred, td, &nfsva, NULL, &lease);
1566                 if (ret) {
1567                         /*
1568                          * Just set default values to get things going.
1569                          */
1570                         NFSBZERO((caddr_t)&nfsva, sizeof (struct nfsvattr));
1571                         nfsva.na_vattr.va_type = VDIR;
1572                         nfsva.na_vattr.va_mode = 0777;
1573                         nfsva.na_vattr.va_nlink = 100;
1574                         nfsva.na_vattr.va_uid = (uid_t)0;
1575                         nfsva.na_vattr.va_gid = (gid_t)0;
1576                         nfsva.na_vattr.va_fileid = 2;
1577                         nfsva.na_vattr.va_gen = 1;
1578                         nfsva.na_vattr.va_blocksize = NFS_FABLKSIZE;
1579                         nfsva.na_vattr.va_size = 512 * 1024;
1580                         lease = 60;
1581                 }
1582                 (void) nfscl_loadattrcache(vpp, &nfsva, NULL, NULL, 0, 1);
1583                 if (nmp->nm_minorvers > 0) {
1584                         NFSCL_DEBUG(3, "lease=%d\n", (int)lease);
1585                         NFSLOCKCLSTATE();
1586                         clp->nfsc_renew = NFSCL_RENEW(lease);
1587                         clp->nfsc_expire = NFSD_MONOSEC + clp->nfsc_renew;
1588                         clp->nfsc_clientidrev++;
1589                         if (clp->nfsc_clientidrev == 0)
1590                                 clp->nfsc_clientidrev++;
1591                         NFSUNLOCKCLSTATE();
1592                         /*
1593                          * Mount will succeed, so the renew thread can be
1594                          * started now.
1595                          */
1596                         nfscl_start_renewthread(clp);
1597                         nfscl_clientrelease(clp);
1598                 }
1599                 if (argp->flags & NFSMNT_NFSV3)
1600                         ncl_fsinfo(nmp, *vpp, cred, td);
1601
1602                 /* Mark if the mount point supports NFSv4 ACLs. */
1603                 if ((argp->flags & NFSMNT_NFSV4) != 0 && nfsrv_useacl != 0 &&
1604                     ret == 0 &&
1605                     NFSISSET_ATTRBIT(&nfsva.na_suppattr, NFSATTRBIT_ACL)) {
1606                         MNT_ILOCK(mp);
1607                         mp->mnt_flag |= MNT_NFS4ACLS;
1608                         MNT_IUNLOCK(mp);
1609                 }
1610
1611                 /*
1612                  * Lose the lock but keep the ref.
1613                  */
1614                 NFSVOPUNLOCK(*vpp, 0);
1615                 return (0);
1616         }
1617         error = EIO;
1618
1619 bad:
1620         if (clp != NULL)
1621                 nfscl_clientrelease(clp);
1622         newnfs_disconnect(&nmp->nm_sockreq);
1623         crfree(nmp->nm_sockreq.nr_cred);
1624         if (nmp->nm_sockreq.nr_auth != NULL)
1625                 AUTH_DESTROY(nmp->nm_sockreq.nr_auth);
1626         mtx_destroy(&nmp->nm_sockreq.nr_mtx);
1627         mtx_destroy(&nmp->nm_mtx);
1628         if (nmp->nm_clp != NULL) {
1629                 NFSLOCKCLSTATE();
1630                 LIST_REMOVE(nmp->nm_clp, nfsc_list);
1631                 NFSUNLOCKCLSTATE();
1632                 free(nmp->nm_clp, M_NFSCLCLIENT);
1633         }
1634         TAILQ_FOREACH_SAFE(dsp, &nmp->nm_sess, nfsclds_list, tdsp)
1635                 nfscl_freenfsclds(dsp);
1636         FREE(nmp, M_NEWNFSMNT);
1637         FREE(nam, M_SONAME);
1638         return (error);
1639 }
1640
1641 /*
1642  * unmount system call
1643  */
1644 static int
1645 nfs_unmount(struct mount *mp, int mntflags)
1646 {
1647         struct thread *td;
1648         struct nfsmount *nmp;
1649         int error, flags = 0, i, trycnt = 0;
1650         struct nfsclds *dsp, *tdsp;
1651
1652         td = curthread;
1653
1654         if (mntflags & MNT_FORCE)
1655                 flags |= FORCECLOSE;
1656         nmp = VFSTONFS(mp);
1657         /*
1658          * Goes something like this..
1659          * - Call vflush() to clear out vnodes for this filesystem
1660          * - Close the socket
1661          * - Free up the data structures
1662          */
1663         /* In the forced case, cancel any outstanding requests. */
1664         if (mntflags & MNT_FORCE) {
1665                 error = newnfs_nmcancelreqs(nmp);
1666                 if (error)
1667                         goto out;
1668                 /* For a forced close, get rid of the renew thread now */
1669                 nfscl_umount(nmp, td);
1670         }
1671         /* We hold 1 extra ref on the root vnode; see comment in mountnfs(). */
1672         do {
1673                 error = vflush(mp, 1, flags, td);
1674                 if ((mntflags & MNT_FORCE) && error != 0 && ++trycnt < 30)
1675                         (void) nfs_catnap(PSOCK, error, "newndm");
1676         } while ((mntflags & MNT_FORCE) && error != 0 && trycnt < 30);
1677         if (error)
1678                 goto out;
1679
1680         /*
1681          * We are now committed to the unmount.
1682          */
1683         if ((mntflags & MNT_FORCE) == 0)
1684                 nfscl_umount(nmp, td);
1685         /* Make sure no nfsiods are assigned to this mount. */
1686         mtx_lock(&ncl_iod_mutex);
1687         for (i = 0; i < NFS_MAXASYNCDAEMON; i++)
1688                 if (ncl_iodmount[i] == nmp) {
1689                         ncl_iodwant[i] = NFSIOD_AVAILABLE;
1690                         ncl_iodmount[i] = NULL;
1691                 }
1692         mtx_unlock(&ncl_iod_mutex);
1693         newnfs_disconnect(&nmp->nm_sockreq);
1694         crfree(nmp->nm_sockreq.nr_cred);
1695         FREE(nmp->nm_nam, M_SONAME);
1696         if (nmp->nm_sockreq.nr_auth != NULL)
1697                 AUTH_DESTROY(nmp->nm_sockreq.nr_auth);
1698         mtx_destroy(&nmp->nm_sockreq.nr_mtx);
1699         mtx_destroy(&nmp->nm_mtx);
1700         TAILQ_FOREACH_SAFE(dsp, &nmp->nm_sess, nfsclds_list, tdsp)
1701                 nfscl_freenfsclds(dsp);
1702         FREE(nmp, M_NEWNFSMNT);
1703 out:
1704         return (error);
1705 }
1706
1707 /*
1708  * Return root of a filesystem
1709  */
1710 static int
1711 nfs_root(struct mount *mp, int flags, struct vnode **vpp)
1712 {
1713         struct vnode *vp;
1714         struct nfsmount *nmp;
1715         struct nfsnode *np;
1716         int error;
1717
1718         nmp = VFSTONFS(mp);
1719         error = ncl_nget(mp, nmp->nm_fh, nmp->nm_fhsize, &np, flags);
1720         if (error)
1721                 return error;
1722         vp = NFSTOV(np);
1723         /*
1724          * Get transfer parameters and attributes for root vnode once.
1725          */
1726         mtx_lock(&nmp->nm_mtx);
1727         if (NFSHASNFSV3(nmp) && !NFSHASGOTFSINFO(nmp)) {
1728                 mtx_unlock(&nmp->nm_mtx);
1729                 ncl_fsinfo(nmp, vp, curthread->td_ucred, curthread);
1730         } else
1731                 mtx_unlock(&nmp->nm_mtx);
1732         if (vp->v_type == VNON)
1733             vp->v_type = VDIR;
1734         vp->v_vflag |= VV_ROOT;
1735         *vpp = vp;
1736         return (0);
1737 }
1738
1739 /*
1740  * Flush out the buffer cache
1741  */
1742 /* ARGSUSED */
1743 static int
1744 nfs_sync(struct mount *mp, int waitfor)
1745 {
1746         struct vnode *vp, *mvp;
1747         struct thread *td;
1748         int error, allerror = 0;
1749
1750         td = curthread;
1751
1752         MNT_ILOCK(mp);
1753         /*
1754          * If a forced dismount is in progress, return from here so that
1755          * the umount(2) syscall doesn't get stuck in VFS_SYNC() before
1756          * calling VFS_UNMOUNT().
1757          */
1758         if ((mp->mnt_kern_flag & MNTK_UNMOUNTF) != 0) {
1759                 MNT_IUNLOCK(mp);
1760                 return (EBADF);
1761         }
1762         MNT_IUNLOCK(mp);
1763
1764         /*
1765          * Force stale buffer cache information to be flushed.
1766          */
1767 loop:
1768         MNT_VNODE_FOREACH_ALL(vp, mp, mvp) {
1769                 /* XXX Racy bv_cnt check. */
1770                 if (NFSVOPISLOCKED(vp) || vp->v_bufobj.bo_dirty.bv_cnt == 0 ||
1771                     waitfor == MNT_LAZY) {
1772                         VI_UNLOCK(vp);
1773                         continue;
1774                 }
1775                 if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) {
1776                         MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);
1777                         goto loop;
1778                 }
1779                 error = VOP_FSYNC(vp, waitfor, td);
1780                 if (error)
1781                         allerror = error;
1782                 NFSVOPUNLOCK(vp, 0);
1783                 vrele(vp);
1784         }
1785         return (allerror);
1786 }
1787
1788 static int
1789 nfs_sysctl(struct mount *mp, fsctlop_t op, struct sysctl_req *req)
1790 {
1791         struct nfsmount *nmp = VFSTONFS(mp);
1792         struct vfsquery vq;
1793         int error;
1794
1795         bzero(&vq, sizeof(vq));
1796         switch (op) {
1797 #if 0
1798         case VFS_CTL_NOLOCKS:
1799                 val = (nmp->nm_flag & NFSMNT_NOLOCKS) ? 1 : 0;
1800                 if (req->oldptr != NULL) {
1801                         error = SYSCTL_OUT(req, &val, sizeof(val));
1802                         if (error)
1803                                 return (error);
1804                 }
1805                 if (req->newptr != NULL) {
1806                         error = SYSCTL_IN(req, &val, sizeof(val));
1807                         if (error)
1808                                 return (error);
1809                         if (val)
1810                                 nmp->nm_flag |= NFSMNT_NOLOCKS;
1811                         else
1812                                 nmp->nm_flag &= ~NFSMNT_NOLOCKS;
1813                 }
1814                 break;
1815 #endif
1816         case VFS_CTL_QUERY:
1817                 mtx_lock(&nmp->nm_mtx);
1818                 if (nmp->nm_state & NFSSTA_TIMEO)
1819                         vq.vq_flags |= VQ_NOTRESP;
1820                 mtx_unlock(&nmp->nm_mtx);
1821 #if 0
1822                 if (!(nmp->nm_flag & NFSMNT_NOLOCKS) &&
1823                     (nmp->nm_state & NFSSTA_LOCKTIMEO))
1824                         vq.vq_flags |= VQ_NOTRESPLOCK;
1825 #endif
1826                 error = SYSCTL_OUT(req, &vq, sizeof(vq));
1827                 break;
1828         case VFS_CTL_TIMEO:
1829                 if (req->oldptr != NULL) {
1830                         error = SYSCTL_OUT(req, &nmp->nm_tprintf_initial_delay,
1831                             sizeof(nmp->nm_tprintf_initial_delay));
1832                         if (error)
1833                                 return (error);
1834                 }
1835                 if (req->newptr != NULL) {
1836                         error = vfs_suser(mp, req->td);
1837                         if (error)
1838                                 return (error);
1839                         error = SYSCTL_IN(req, &nmp->nm_tprintf_initial_delay,
1840                             sizeof(nmp->nm_tprintf_initial_delay));
1841                         if (error)
1842                                 return (error);
1843                         if (nmp->nm_tprintf_initial_delay < 0)
1844                                 nmp->nm_tprintf_initial_delay = 0;
1845                 }
1846                 break;
1847         default:
1848                 return (ENOTSUP);
1849         }
1850         return (0);
1851 }
1852
1853 /*
1854  * Purge any RPCs in progress, so that they will all return errors.
1855  * This allows dounmount() to continue as far as VFS_UNMOUNT() for a
1856  * forced dismount.
1857  */
1858 static void
1859 nfs_purge(struct mount *mp)
1860 {
1861         struct nfsmount *nmp = VFSTONFS(mp);
1862
1863         newnfs_nmcancelreqs(nmp);
1864 }
1865
1866 /*
1867  * Extract the information needed by the nlm from the nfs vnode.
1868  */
1869 static void
1870 nfs_getnlminfo(struct vnode *vp, uint8_t *fhp, size_t *fhlenp,
1871     struct sockaddr_storage *sp, int *is_v3p, off_t *sizep,
1872     struct timeval *timeop)
1873 {
1874         struct nfsmount *nmp;
1875         struct nfsnode *np = VTONFS(vp);
1876
1877         nmp = VFSTONFS(vp->v_mount);
1878         if (fhlenp != NULL)
1879                 *fhlenp = (size_t)np->n_fhp->nfh_len;
1880         if (fhp != NULL)
1881                 bcopy(np->n_fhp->nfh_fh, fhp, np->n_fhp->nfh_len);
1882         if (sp != NULL)
1883                 bcopy(nmp->nm_nam, sp, min(nmp->nm_nam->sa_len, sizeof(*sp)));
1884         if (is_v3p != NULL)
1885                 *is_v3p = NFS_ISV3(vp);
1886         if (sizep != NULL)
1887                 *sizep = np->n_size;
1888         if (timeop != NULL) {
1889                 timeop->tv_sec = nmp->nm_timeo / NFS_HZ;
1890                 timeop->tv_usec = (nmp->nm_timeo % NFS_HZ) * (1000000 / NFS_HZ);
1891         }
1892 }
1893
1894 /*
1895  * This function prints out an option name, based on the conditional
1896  * argument.
1897  */
1898 static __inline void nfscl_printopt(struct nfsmount *nmp, int testval,
1899     char *opt, char **buf, size_t *blen)
1900 {
1901         int len;
1902
1903         if (testval != 0 && *blen > strlen(opt)) {
1904                 len = snprintf(*buf, *blen, "%s", opt);
1905                 if (len != strlen(opt))
1906                         printf("EEK!!\n");
1907                 *buf += len;
1908                 *blen -= len;
1909         }
1910 }
1911
1912 /*
1913  * This function printf out an options integer value.
1914  */
1915 static __inline void nfscl_printoptval(struct nfsmount *nmp, int optval,
1916     char *opt, char **buf, size_t *blen)
1917 {
1918         int len;
1919
1920         if (*blen > strlen(opt) + 1) {
1921                 /* Could result in truncated output string. */
1922                 len = snprintf(*buf, *blen, "%s=%d", opt, optval);
1923                 if (len < *blen) {
1924                         *buf += len;
1925                         *blen -= len;
1926                 }
1927         }
1928 }
1929
1930 /*
1931  * Load the option flags and values into the buffer.
1932  */
1933 void nfscl_retopts(struct nfsmount *nmp, char *buffer, size_t buflen)
1934 {
1935         char *buf;
1936         size_t blen;
1937
1938         buf = buffer;
1939         blen = buflen;
1940         nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_NFSV4) != 0, "nfsv4", &buf,
1941             &blen);
1942         if ((nmp->nm_flag & NFSMNT_NFSV4) != 0) {
1943                 nfscl_printoptval(nmp, nmp->nm_minorvers, ",minorversion", &buf,
1944                     &blen);
1945                 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_PNFS) != 0, ",pnfs",
1946                     &buf, &blen);
1947         }
1948         nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_NFSV3) != 0, "nfsv3", &buf,
1949             &blen);
1950         nfscl_printopt(nmp, (nmp->nm_flag & (NFSMNT_NFSV3 | NFSMNT_NFSV4)) == 0,
1951             "nfsv2", &buf, &blen);
1952         nfscl_printopt(nmp, nmp->nm_sotype == SOCK_STREAM, ",tcp", &buf, &blen);
1953         nfscl_printopt(nmp, nmp->nm_sotype != SOCK_STREAM, ",udp", &buf, &blen);
1954         nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_RESVPORT) != 0, ",resvport",
1955             &buf, &blen);
1956         nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_NOCONN) != 0, ",noconn",
1957             &buf, &blen);
1958         nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_SOFT) == 0, ",hard", &buf,
1959             &blen);
1960         nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_SOFT) != 0, ",soft", &buf,
1961             &blen);
1962         nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_INT) != 0, ",intr", &buf,
1963             &blen);
1964         nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_NOCTO) == 0, ",cto", &buf,
1965             &blen);
1966         nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_NOCTO) != 0, ",nocto", &buf,
1967             &blen);
1968         nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_NONCONTIGWR) != 0,
1969             ",noncontigwr", &buf, &blen);
1970         nfscl_printopt(nmp, (nmp->nm_flag & (NFSMNT_NOLOCKD | NFSMNT_NFSV4)) ==
1971             0, ",lockd", &buf, &blen);
1972         nfscl_printopt(nmp, (nmp->nm_flag & (NFSMNT_NOLOCKD | NFSMNT_NFSV4)) ==
1973             NFSMNT_NOLOCKD, ",nolockd", &buf, &blen);
1974         nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_RDIRPLUS) != 0, ",rdirplus",
1975             &buf, &blen);
1976         nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_KERB) == 0, ",sec=sys",
1977             &buf, &blen);
1978         nfscl_printopt(nmp, (nmp->nm_flag & (NFSMNT_KERB | NFSMNT_INTEGRITY |
1979             NFSMNT_PRIVACY)) == NFSMNT_KERB, ",sec=krb5", &buf, &blen);
1980         nfscl_printopt(nmp, (nmp->nm_flag & (NFSMNT_KERB | NFSMNT_INTEGRITY |
1981             NFSMNT_PRIVACY)) == (NFSMNT_KERB | NFSMNT_INTEGRITY), ",sec=krb5i",
1982             &buf, &blen);
1983         nfscl_printopt(nmp, (nmp->nm_flag & (NFSMNT_KERB | NFSMNT_INTEGRITY |
1984             NFSMNT_PRIVACY)) == (NFSMNT_KERB | NFSMNT_PRIVACY), ",sec=krb5p",
1985             &buf, &blen);
1986         nfscl_printoptval(nmp, nmp->nm_acdirmin, ",acdirmin", &buf, &blen);
1987         nfscl_printoptval(nmp, nmp->nm_acdirmax, ",acdirmax", &buf, &blen);
1988         nfscl_printoptval(nmp, nmp->nm_acregmin, ",acregmin", &buf, &blen);
1989         nfscl_printoptval(nmp, nmp->nm_acregmax, ",acregmax", &buf, &blen);
1990         nfscl_printoptval(nmp, nmp->nm_nametimeo, ",nametimeo", &buf, &blen);
1991         nfscl_printoptval(nmp, nmp->nm_negnametimeo, ",negnametimeo", &buf,
1992             &blen);
1993         nfscl_printoptval(nmp, nmp->nm_rsize, ",rsize", &buf, &blen);
1994         nfscl_printoptval(nmp, nmp->nm_wsize, ",wsize", &buf, &blen);
1995         nfscl_printoptval(nmp, nmp->nm_readdirsize, ",readdirsize", &buf,
1996             &blen);
1997         nfscl_printoptval(nmp, nmp->nm_readahead, ",readahead", &buf, &blen);
1998         nfscl_printoptval(nmp, nmp->nm_wcommitsize, ",wcommitsize", &buf,
1999             &blen);
2000         nfscl_printoptval(nmp, nmp->nm_timeo, ",timeout", &buf, &blen);
2001         nfscl_printoptval(nmp, nmp->nm_retry, ",retrans", &buf, &blen);
2002 }
2003