root/nfs/nfs_vfsops.c

DEFINITIONS

1. nfs_statfs
2. nfs_fsinfo
3. nfs_mountroot
4. nfs_mount_diskless
5. nfs_decode_args
6. nfs_mount
7. mountnfs
8. nfs_unmount
9. nfs_root
10. nfs_sync
11. nfs_vget
12. nfs_sysctl
13. nfs_fhtovp
14. nfs_vptofh
15. nfs_start
16. nfs_quotactl
17. nfs_checkexp

    1 /*      $OpenBSD: nfs_vfsops.c,v 1.66 2007/06/20 15:00:43 thib Exp $    */
    2 /*      $NetBSD: nfs_vfsops.c,v 1.46.4.1 1996/05/25 22:40:35 fvdl Exp $ */
    4 /*
    5  * Copyright (c) 1989, 1993, 1995
    6  *      The Regents of the University of California.  All rights reserved.
    7  *
    8  * This code is derived from software contributed to Berkeley by
    9  * Rick Macklem at The University of Guelph.
   10  *
   11  * Redistribution and use in source and binary forms, with or without
   12  * modification, are permitted provided that the following conditions
   13  * are met:
   14  * 1. Redistributions of source code must retain the above copyright
   15  *    notice, this list of conditions and the following disclaimer.
   16  * 2. Redistributions in binary form must reproduce the above copyright
   17  *    notice, this list of conditions and the following disclaimer in the
   18  *    documentation and/or other materials provided with the distribution.
   19  * 3. Neither the name of the University nor the names of its contributors
   20  *    may be used to endorse or promote products derived from this software
   21  *    without specific prior written permission.
   22  *
   23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   33  * SUCH DAMAGE.
   34  *
   35  *      @(#)nfs_vfsops.c        8.12 (Berkeley) 5/20/95
   36  */
   38 #include <sys/param.h>
   39 #include <sys/conf.h>
   40 #include <sys/ioctl.h>
   41 #include <sys/signal.h>
   42 #include <sys/proc.h>
   43 #include <sys/namei.h>
   44 #include <sys/vnode.h>
   45 #include <sys/kernel.h>
   46 #include <sys/mount.h>
   47 #include <sys/buf.h>
   48 #include <sys/mbuf.h>
   49 #include <sys/socket.h>
   50 #include <sys/socketvar.h>
   51 #include <sys/systm.h>
   52 #include <sys/sysctl.h>
   54 #include <net/if.h>
   55 #include <net/route.h>
   56 #include <netinet/in.h>
   58 #include <nfs/rpcv2.h>
   59 #include <nfs/nfsproto.h>
   60 #include <nfs/nfsnode.h>
   61 #include <nfs/nfs.h>
   62 #include <nfs/nfsmount.h>
   63 #include <nfs/xdr_subs.h>
   64 #include <nfs/nfsm_subs.h>
   65 #include <nfs/nfsdiskless.h>
   66 #include <nfs/nfs_var.h>
   68 #define NQ_DEADTHRESH   NQ_NEVERDEAD    /* Default nm_deadthresh */
   69 #define NQ_NEVERDEAD    9       /* Greater than max. nm_timeouts */
   71 extern struct nfsstats nfsstats;
   72 extern int nfs_ticks;
   73 extern u_int32_t nfs_procids[NFS_NPROCS];
   75 int             nfs_sysctl(int *, u_int, void *, size_t *, void *, size_t, struct proc *);
   76 int             nfs_checkexp(struct mount *, struct mbuf *, int *, struct ucred **);
   77 struct mount    *nfs_mount_diskless(struct nfs_dlmount *, char *, int);
   79 /*
   80  * nfs vfs operations.
   81  */
   82 const struct vfsops nfs_vfsops = {
nfs_mount,
nfs_start,
nfs_unmount,
nfs_root,
nfs_quotactl,
nfs_statfs,
nfs_sync,
nfs_vget,
nfs_fhtovp,
nfs_vptofh,
nfs_vfs_init,
nfs_sysctl,
nfs_checkexp
   96 };
   98 #define TRUE    1
   99 #define FALSE   0
  101 /*
  102  * nfs statfs call
  103  */
  104 int
nfs_statfs(mp, sbp, p)
  106         struct mount *mp;
  107         struct statfs *sbp;
  108         struct proc *p;
  109 {
  110         struct vnode *vp;
  111         struct nfs_statfs *sfp = NULL;
caddr_t cp;
u_int32_t *tl;
int32_t t1, t2;
caddr_t bpos, dpos, cp2;
  116         struct nfsmount *nmp = VFSTONFS(mp);
  117         int error = 0, v3 = (nmp->nm_flag & NFSMNT_NFSV3), retattr;
  118         struct mbuf *mreq, *mrep = NULL, *md, *mb, *mb2;
  119         struct ucred *cred;
  120         struct nfsnode *np;
u_quad_t tquad;
error = nfs_nget(mp, (nfsfh_t *)nmp->nm_fh, nmp->nm_fhsize, &np);
  124         if (error)
  125                 return (error);
vp = NFSTOV(np);
cred = crget();
cred->cr_ngroups = 0;
  129         if (v3 && (nmp->nm_flag & NFSMNT_GOTFSINFO) == 0)
  130                 (void)nfs_fsinfo(nmp, vp, cred, p);
nfsstats.rpccnt[NFSPROC_FSSTAT]++;
nfsm_reqhead(vp, NFSPROC_FSSTAT, NFSX_FH(v3));
nfsm_fhtom(vp, v3);
nfsm_request(vp, NFSPROC_FSSTAT, p, cred);
  135         if (v3)
nfsm_postop_attr(vp, retattr);
  137         if (error) {
  138                 if (mrep != NULL)
m_free(mrep);
  140                 goto nfsmout;
  141         }
nfsm_dissect(sfp, struct nfs_statfs *, NFSX_STATFS(v3));
sbp->f_flags = nmp->nm_flag;
sbp->f_iosize = min(nmp->nm_rsize, nmp->nm_wsize);
  145         if (v3) {
sbp->f_bsize = NFS_FABLKSIZE;
tquad = fxdr_hyper(&sfp->sf_tbytes);
sbp->f_blocks = (u_int32_t)(tquad / (u_quad_t)NFS_FABLKSIZE);
tquad = fxdr_hyper(&sfp->sf_fbytes);
sbp->f_bfree = (u_int32_t)(tquad / (u_quad_t)NFS_FABLKSIZE);
tquad = fxdr_hyper(&sfp->sf_abytes);
sbp->f_bavail = (int32_t)((quad_t)tquad / (quad_t)NFS_FABLKSIZE);
sbp->f_files = (fxdr_unsigned(int32_t,
sfp->sf_tfiles.nfsuquad[1]) & 0x7fffffff);
sbp->f_ffree = (fxdr_unsigned(int32_t,
sfp->sf_ffiles.nfsuquad[1]) & 0x7fffffff);
  157         } else {
sbp->f_bsize = fxdr_unsigned(int32_t, sfp->sf_bsize);
sbp->f_blocks = fxdr_unsigned(int32_t, sfp->sf_blocks);
sbp->f_bfree = fxdr_unsigned(int32_t, sfp->sf_bfree);
sbp->f_bavail = fxdr_unsigned(int32_t, sfp->sf_bavail);
sbp->f_files = 0;
sbp->f_ffree = 0;
  164         }
  165         if (sbp != &mp->mnt_stat) {
bcopy(mp->mnt_stat.f_mntonname, sbp->f_mntonname, MNAMELEN);
bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN);
bcopy(&mp->mnt_stat.mount_info.nfs_args,
  169                     &sbp->mount_info.nfs_args, sizeof(struct nfs_args));
  170         }
strncpy(&sbp->f_fstypename[0], mp->mnt_vfc->vfc_name, MFSNAMELEN);
nfsm_reqdone;
vrele(vp);
crfree(cred);
  175         return (error);
  176 }
  178 /*
  179  * nfs version 3 fsinfo rpc call
  180  */
  181 int
nfs_fsinfo(nmp, vp, cred, p)
  183         struct nfsmount *nmp;
  184         struct vnode *vp;
  185         struct ucred *cred;
  186         struct proc *p;
  187 {
  188         struct nfsv3_fsinfo *fsp;
caddr_t cp;
int32_t t1, t2;
u_int32_t *tl, pref, max;
caddr_t bpos, dpos, cp2;
  193         int error = 0, retattr;
  194         struct mbuf *mreq, *mrep, *md, *mb, *mb2;
nfsstats.rpccnt[NFSPROC_FSINFO]++;
nfsm_reqhead(vp, NFSPROC_FSINFO, NFSX_FH(1));
nfsm_fhtom(vp, 1);
nfsm_request(vp, NFSPROC_FSINFO, p, cred);
nfsm_postop_attr(vp, retattr);
  201         if (!error) {
nfsm_dissect(fsp, struct nfsv3_fsinfo *, NFSX_V3FSINFO);
pref = fxdr_unsigned(u_int32_t, fsp->fs_wtpref);
  204                 if (pref < nmp->nm_wsize)
nmp->nm_wsize = (pref + NFS_FABLKSIZE - 1) &
  206                                 ~(NFS_FABLKSIZE - 1);
max = fxdr_unsigned(u_int32_t, fsp->fs_wtmax);
  208                 if (max < nmp->nm_wsize) {
nmp->nm_wsize = max & ~(NFS_FABLKSIZE - 1);
  210                         if (nmp->nm_wsize == 0)
nmp->nm_wsize = max;
  212                 }
pref = fxdr_unsigned(u_int32_t, fsp->fs_rtpref);
  214                 if (pref < nmp->nm_rsize)
nmp->nm_rsize = (pref + NFS_FABLKSIZE - 1) &
  216                                 ~(NFS_FABLKSIZE - 1);
max = fxdr_unsigned(u_int32_t, fsp->fs_rtmax);
  218                 if (max < nmp->nm_rsize) {
nmp->nm_rsize = max & ~(NFS_FABLKSIZE - 1);
  220                         if (nmp->nm_rsize == 0)
nmp->nm_rsize = max;
  222                 }
pref = fxdr_unsigned(u_int32_t, fsp->fs_dtpref);
  224                 if (pref < nmp->nm_readdirsize)
nmp->nm_readdirsize = (pref + NFS_DIRBLKSIZ - 1) &
  226                                 ~(NFS_DIRBLKSIZ - 1);
  227                 if (max < nmp->nm_readdirsize) {
nmp->nm_readdirsize = max & ~(NFS_DIRBLKSIZ - 1);
  229                         if (nmp->nm_readdirsize == 0)
nmp->nm_readdirsize = max;
  231                 }
nmp->nm_flag |= NFSMNT_GOTFSINFO;
  233         }
nfsm_reqdone;
  235         return (error);
  236 }
  238 /*
  239  * Mount a remote root fs via. NFS.  It goes like this:
  240  * - Call nfs_boot_init() to fill in the nfs_diskless struct
  241  *   (using RARP, bootparam RPC, mountd RPC)
  242  * - hand craft the swap nfs vnode hanging off a fake mount point
  243  *      if swdevt[0].sw_dev == NODEV
  244  * - build the rootfs mount point and call mountnfs() to do the rest.
  245  */
  246 int
nfs_mountroot()
  248 {
  249         struct nfs_diskless nd;
  250         struct vattr attr;
  251         struct mount *mp;
  252         struct vnode *vp;
  253         struct proc *procp;
  254         long n;
  255         int error;
procp = curproc; /* XXX */
  259         /*
  260          * Call nfs_boot_init() to fill in the nfs_diskless struct.
  261          * Side effect:  Finds and configures a network interface.
  262          */
bzero((caddr_t) &nd, sizeof(nd));
nfs_boot_init(&nd, procp);
  266         /*
  267          * Create the root mount point.
  268          */
  269         if (nfs_boot_getfh(&nd.nd_boot, "root", &nd.nd_root, -1))
panic("nfs_mountroot: root");
mp = nfs_mount_diskless(&nd.nd_root, "/", 0);
nfs_root(mp, &rootvp);
printf("root on %s\n", nd.nd_root.ndm_host);
  275         /*
  276          * Link it into the mount list.
  277          */
CIRCLEQ_INSERT_TAIL(&mountlist, mp, mnt_list);
vfs_unbusy(mp);
  281         /* Get root attributes (for the time). */
error = VOP_GETATTR(rootvp, &attr, procp->p_ucred, procp);
  283         if (error) panic("nfs_mountroot: getattr for root");
n = attr.va_atime.tv_sec;
  285 #ifdef  DEBUG
printf("root time: 0x%lx\n", n);
  287 #endif
inittodr(n);
  290 #ifdef notyet
  291         /* Set up swap credentials. */
proc0.p_ucred->cr_uid = ntohl(nd.swap_ucred.cr_uid);
proc0.p_ucred->cr_gid = ntohl(nd.swap_ucred.cr_gid);
  294         if ((proc0.p_ucred->cr_ngroups = ntohs(nd.swap_ucred.cr_ngroups)) >
NGROUPS)
proc0.p_ucred->cr_ngroups = NGROUPS;
  297         for (i = 0; i < proc0.p_ucred->cr_ngroups; i++)
proc0.p_ucred->cr_groups[i] = ntohl(nd.swap_ucred.cr_groups[i]);
  299 #endif
  301         /*
  302          * "Mount" the swap device.
  303          *
  304          * On a "dataless" configuration (swap on disk) we will have:
  305          *      (swdevt[0].sw_dev != NODEV) identifying the swap device.
  306          */
  307         if (bdevvp(swapdev, &swapdev_vp))
panic("nfs_mountroot: can't setup swap vp");
  309         if (swdevt[0].sw_dev != NODEV) {
printf("swap on device 0x%x\n", swdevt[0].sw_dev);
  311                 return (0);
  312         }
  314         /*
  315          * If swapping to an nfs node:  (swdevt[0].sw_dev == NODEV)
  316          * Create a fake mount point just for the swap vnode so that the
  317          * swap file can be on a different server from the rootfs.
  318          *
  319          * Wait 5 retries, finally no swap is cool. -mickey
  320          */
error = nfs_boot_getfh(&nd.nd_boot, "swap", &nd.nd_swap, 5);
  322         if (!error) {
mp = nfs_mount_diskless(&nd.nd_swap, "/swap", 0);
nfs_root(mp, &vp);
vfs_unbusy(mp);
  327                 /*
  328                  * Since the swap file is not the root dir of a file system,
  329                  * hack it to a regular file.
  330                  */
vp->v_type = VREG;
vp->v_flag = 0;
  334                 /* 
  335                  * Next line is a hack to make swapmount() work on NFS swap files. 
  336                  * XXX-smurph 
  337                  */ 
swdevt[0].sw_dev = NETDEV;
  339                 /* end hack */
swdevt[0].sw_vp = vp;
  342                 /*
  343                  * Find out how large the swap file is.
  344                  */
error = VOP_GETATTR(vp, &attr, procp->p_ucred, procp);
  346                 if (error)
printf("nfs_mountroot: getattr for swap\n");
n = (long) (attr.va_size >> DEV_BSHIFT);
printf("swap on %s\n", nd.nd_swap.ndm_host);
  351 #ifdef  DEBUG
printf("swap size: 0x%lx (blocks)\n", n);
  353 #endif
  354                 return (0);
  355         }
printf("WARNING: no swap\n");
swdevt[0].sw_dev = NODEV;
swdevt[0].sw_vp = NULL;
  361         return (0);
  362 }
  364 /*
  365  * Internal version of mount system call for diskless setup.
  366  */
  367 struct mount *
nfs_mount_diskless(ndmntp, mntname, mntflag)
  369         struct nfs_dlmount *ndmntp;
  370         char *mntname;
  371         int mntflag;
  372 {
  373         struct nfs_args args;
  374         struct mount *mp;
  375         struct mbuf *m;
  376         int error;
  378         if (vfs_rootmountalloc("nfs", mntname, &mp))
panic("nfs_mount_diskless: vfs_rootmountalloc failed");
mp->mnt_flag |= mntflag;
  382         /* Initialize mount args. */
bzero((caddr_t) &args, sizeof(args));
args.addr     = (struct sockaddr *)&ndmntp->ndm_saddr;
args.addrlen  = args.addr->sa_len;
args.sotype   = SOCK_DGRAM;
args.fh       = ndmntp->ndm_fh;
args.fhsize   = NFSX_V2FH;
args.hostname = ndmntp->ndm_host;
  391 #ifdef  NFS_BOOT_OPTIONS
args.flags    |= NFS_BOOT_OPTIONS;
  393 #endif
  394 #ifdef  NFS_BOOT_RWSIZE
  395         /*
  396          * Reduce rsize,wsize for interfaces that consistently
  397          * drop fragments of long UDP messages.  (i.e. wd8003).
  398          * You can always change these later via remount.
  399          */
args.flags   |= NFSMNT_WSIZE | NFSMNT_RSIZE;
args.wsize    = NFS_BOOT_RWSIZE;
args.rsize    = NFS_BOOT_RWSIZE;
  403 #endif
  405         /* Get mbuf for server sockaddr. */
m = m_get(M_WAIT, MT_SONAME);
bcopy((caddr_t)args.addr, mtod(m, caddr_t),
  408             (m->m_len = args.addr->sa_len));
error = mountnfs(&args, mp, m, mntname, args.hostname);
  411         if (error)
panic("nfs_mountroot: mount %s failed: %d", mntname, error);
  414         return (mp);
  415 }
  417 void
nfs_decode_args(nmp, argp, nargp)
  419         struct nfsmount *nmp;
  420         struct nfs_args *argp;
  421         struct nfs_args *nargp;
  422 {
  423         int s;
  424         int adjsock = 0;
  425         int maxio;
s = splsoftnet();
  429 #if 0
  430         /* Re-bind if rsrvd port requested and wasn't on one */
adjsock = !(nmp->nm_flag & NFSMNT_RESVPORT)
  432                   && (argp->flags & NFSMNT_RESVPORT);
  433 #endif
  434         /* Also re-bind if we're switching to/from a connected UDP socket */
adjsock |= ((nmp->nm_flag & NFSMNT_NOCONN) !=
  436             (argp->flags & NFSMNT_NOCONN));
  438         /* Update flags atomically.  Don't change the lock bits. */
nmp->nm_flag =
  440             (argp->flags & ~NFSMNT_INTERNAL) | (nmp->nm_flag & NFSMNT_INTERNAL);
splx(s);
  443         if ((argp->flags & NFSMNT_TIMEO) && argp->timeo > 0) {
nmp->nm_timeo = (argp->timeo * NFS_HZ + 5) / 10;
  445                 if (nmp->nm_timeo < NFS_MINTIMEO)
nmp->nm_timeo = NFS_MINTIMEO;
  447                 else if (nmp->nm_timeo > NFS_MAXTIMEO)
nmp->nm_timeo = NFS_MAXTIMEO;
  449         }
  451         if ((argp->flags & NFSMNT_RETRANS) && argp->retrans > 1) {
nmp->nm_retry = argp->retrans;
  453                 if (nmp->nm_retry > NFS_MAXREXMIT)
nmp->nm_retry = NFS_MAXREXMIT;
  455         }
  457         if (argp->flags & NFSMNT_NFSV3) {
  458                 if (argp->sotype == SOCK_DGRAM)
maxio = NFS_MAXDGRAMDATA;
  460                 else
maxio = NFS_MAXDATA;
  462         } else
maxio = NFS_V2MAXDATA;
  465         if ((argp->flags & NFSMNT_WSIZE) && argp->wsize > 0) {
  466                 int osize = nmp->nm_wsize;
nmp->nm_wsize = argp->wsize;
  468                 /* Round down to multiple of blocksize */
nmp->nm_wsize &= ~(NFS_FABLKSIZE - 1);
  470                 if (nmp->nm_wsize <= 0)
nmp->nm_wsize = NFS_FABLKSIZE;
adjsock |= (nmp->nm_wsize != osize);
  473         }
  474         if (nmp->nm_wsize > maxio)
nmp->nm_wsize = maxio;
  476         if (nmp->nm_wsize > MAXBSIZE)
nmp->nm_wsize = MAXBSIZE;
  479         if ((argp->flags & NFSMNT_RSIZE) && argp->rsize > 0) {
  480                 int osize = nmp->nm_rsize;
nmp->nm_rsize = argp->rsize;
  482                 /* Round down to multiple of blocksize */
nmp->nm_rsize &= ~(NFS_FABLKSIZE - 1);
  484                 if (nmp->nm_rsize <= 0)
nmp->nm_rsize = NFS_FABLKSIZE;
adjsock |= (nmp->nm_rsize != osize);
  487         }
  488         if (nmp->nm_rsize > maxio)
nmp->nm_rsize = maxio;
  490         if (nmp->nm_rsize > MAXBSIZE)
nmp->nm_rsize = MAXBSIZE;
  493         if ((argp->flags & NFSMNT_READDIRSIZE) && argp->readdirsize > 0) {
nmp->nm_readdirsize = argp->readdirsize;
  495                 /* Round down to multiple of blocksize */
nmp->nm_readdirsize &= ~(NFS_DIRBLKSIZ - 1);
  497                 if (nmp->nm_readdirsize < NFS_DIRBLKSIZ)
nmp->nm_readdirsize = NFS_DIRBLKSIZ;
  499         } else if (argp->flags & NFSMNT_RSIZE)
nmp->nm_readdirsize = nmp->nm_rsize;
  502         if (nmp->nm_readdirsize > maxio)
nmp->nm_readdirsize = maxio;
  505         if ((argp->flags & NFSMNT_MAXGRPS) && argp->maxgrouplist >= 0 &&
argp->maxgrouplist <= NFS_MAXGRPS)
nmp->nm_numgrps = argp->maxgrouplist;
  508         if ((argp->flags & NFSMNT_READAHEAD) && argp->readahead >= 0 &&
argp->readahead <= NFS_MAXRAHEAD)
nmp->nm_readahead = argp->readahead;
  511         if ((argp->flags & NFSMNT_DEADTHRESH) && argp->deadthresh >= 1 &&
argp->deadthresh <= NQ_NEVERDEAD)
nmp->nm_deadthresh = argp->deadthresh;
  514         if (argp->flags & NFSMNT_ACREGMIN && argp->acregmin >= 0) {
  515                 if (argp->acregmin > 0xffff)
nmp->nm_acregmin = 0xffff;
  517                 else
nmp->nm_acregmin = argp->acregmin;
  519         }
  520         if (argp->flags & NFSMNT_ACREGMAX && argp->acregmax >= 0) {
  521                 if (argp->acregmax > 0xffff)
nmp->nm_acregmax = 0xffff;
  523                 else
nmp->nm_acregmax = argp->acregmax;
  525         }
  526         if (nmp->nm_acregmin > nmp->nm_acregmax)
nmp->nm_acregmin = nmp->nm_acregmax;
  529         if (argp->flags & NFSMNT_ACDIRMIN && argp->acdirmin >= 0) {
  530                 if (argp->acdirmin > 0xffff)
nmp->nm_acdirmin = 0xffff;
  532                 else
nmp->nm_acdirmin = argp->acdirmin;
  534         }
  535         if (argp->flags & NFSMNT_ACDIRMAX && argp->acdirmax >= 0) {
  536                 if (argp->acdirmax > 0xffff)
nmp->nm_acdirmax = 0xffff;
  538                 else
nmp->nm_acdirmax = argp->acdirmax;
  540         }
  541         if (nmp->nm_acdirmin > nmp->nm_acdirmax)
nmp->nm_acdirmin = nmp->nm_acdirmax;
  544         if (nmp->nm_so && adjsock) {
nfs_disconnect(nmp);
  546                 if (nmp->nm_sotype == SOCK_DGRAM)
  547                         while (nfs_connect(nmp, (struct nfsreq *)0)) {
printf("nfs_args: retrying connect\n");
  549                                 (void) tsleep((caddr_t)&lbolt,
PSOCK, "nfscon", 0);
  551                         }
  552         }
  554         /* Update nargp based on nmp */
nargp->wsize = nmp->nm_wsize;
nargp->rsize = nmp->nm_rsize;
nargp->readdirsize = nmp->nm_readdirsize;
nargp->timeo = nmp->nm_timeo;
nargp->retrans = nmp->nm_retry;
nargp->maxgrouplist = nmp->nm_numgrps;
nargp->readahead = nmp->nm_readahead;
nargp->deadthresh = nmp->nm_deadthresh;
nargp->acregmin = nmp->nm_acregmin;
nargp->acregmax = nmp->nm_acregmax;
nargp->acdirmin = nmp->nm_acdirmin;
nargp->acdirmax = nmp->nm_acdirmax;
  567 }
  569 /*
  570  * VFS Operations.
  571  *
  572  * mount system call
  573  * It seems a bit dumb to copyinstr() the host and path here and then
  574  * bcopy() them in mountnfs(), but I wanted to detect errors before
  575  * doing the sockargs() call because sockargs() allocates an mbuf and
  576  * an error after that means that I have to release the mbuf.
  577  */
  578 /* ARGSUSED */
  579 int
nfs_mount(mp, path, data, ndp, p)
  581         struct mount *mp;
  582         const char *path;
  583         void *data;
  584         struct nameidata *ndp;
  585         struct proc *p;
  586 {
  587         int error;
  588         struct nfs_args args;
  589         struct mbuf *nam;
  590         char pth[MNAMELEN], hst[MNAMELEN];
size_t len;
u_char nfh[NFSX_V3FHMAX];
error = copyin (data, &args, sizeof (args.version));
  595         if (error)
  596                 return (error);
  597         if (args.version == 3) {
error = copyin (data, (caddr_t)&args,
  599                                 sizeof (struct nfs_args3));
args.flags &= ~(NFSMNT_INTERNAL|NFSMNT_NOAC);
  601         }
  602         else if (args.version == NFS_ARGSVERSION) {
error = copyin(data, (caddr_t)&args, sizeof (struct nfs_args));
args.flags &= ~NFSMNT_NOAC; /* XXX - compatibility */
  605         }
  606         else
  607                 return (EPROGMISMATCH);
  608         if (error)
  609                 return (error);
  611         if ((args.flags & (NFSMNT_NFSV3|NFSMNT_RDIRPLUS)) == NFSMNT_RDIRPLUS)
  612                 return (EINVAL);
  614         if (nfs_niothreads < 0) {
nfs_niothreads = 4;
nfs_getset_niothreads(TRUE);
  617         }
  619         if (mp->mnt_flag & MNT_UPDATE) {
  620                 struct nfsmount *nmp = VFSTONFS(mp);
  622                 if (nmp == NULL)
  623                         return (EIO);
  624                 /*
  625                  * When doing an update, we can't change from or to
  626                  * v3.
  627                  */
args.flags = (args.flags & ~(NFSMNT_NFSV3)) |
  629                     (nmp->nm_flag & (NFSMNT_NFSV3));
nfs_decode_args(nmp, &args, &mp->mnt_stat.mount_info.nfs_args);
  631                 return (0);
  632         }
  633         if (args.fhsize < 0 || args.fhsize > NFSX_V3FHMAX)
  634                 return (EINVAL);
error = copyin((caddr_t)args.fh, (caddr_t)nfh, args.fhsize);
  636         if (error)
  637                 return (error);
error = copyinstr(path, pth, MNAMELEN-1, &len);
  639         if (error)
  640                 return (error);
bzero(&pth[len], MNAMELEN - len);
error = copyinstr(args.hostname, hst, MNAMELEN-1, &len);
  643         if (error)
  644                 return (error);
bzero(&hst[len], MNAMELEN - len);
  646         /* sockargs() call must be after above copyin() calls */
error = sockargs(&nam, args.addr, args.addrlen, MT_SONAME);
  648         if (error)
  649                 return (error);
args.fh = nfh;
error = mountnfs(&args, mp, nam, pth, hst);
  652         return (error);
  653 }
  655 /*
  656  * Common code for mount and mountroot
  657  */
  658 int
mountnfs(argp, mp, nam, pth, hst)
  660         struct nfs_args *argp;
  661         struct mount *mp;
  662         struct mbuf *nam;
  663         char *pth, *hst;
  664 {
  665         struct nfsmount *nmp;
  666         int error;
  668         if (mp->mnt_flag & MNT_UPDATE) {
nmp = VFSTONFS(mp);
  670                 /* update paths, file handles, etc, here        XXX */
m_freem(nam);
  672                 return (0);
  673         } else {
MALLOC(nmp, struct nfsmount *, sizeof (struct nfsmount),
M_NFSMNT, M_WAITOK);
bzero((caddr_t)nmp, sizeof (struct nfsmount));
mp->mnt_data = (qaddr_t)nmp;
TAILQ_INIT(&nmp->nm_uidlruhead);
  679         }
vfs_getnewfsid(mp);
nmp->nm_mountp = mp;
nmp->nm_timeo = NFS_TIMEO;
nmp->nm_retry = NFS_RETRANS;
nmp->nm_wsize = NFS_WSIZE;
nmp->nm_rsize = NFS_RSIZE;
nmp->nm_readdirsize = NFS_READDIRSIZE;
nmp->nm_numgrps = NFS_MAXGRPS;
nmp->nm_readahead = NFS_DEFRAHEAD;
nmp->nm_deadthresh = NQ_DEADTHRESH;
nmp->nm_fhsize = argp->fhsize;
nmp->nm_acregmin = NFS_MINATTRTIMO;
nmp->nm_acregmax = NFS_MAXATTRTIMO;
nmp->nm_acdirmin = NFS_MINATTRTIMO;
nmp->nm_acdirmax = NFS_MAXATTRTIMO;
bcopy((caddr_t)argp->fh, (caddr_t)nmp->nm_fh, argp->fhsize);
strncpy(&mp->mnt_stat.f_fstypename[0], mp->mnt_vfc->vfc_name, MFSNAMELEN);
bcopy(hst, mp->mnt_stat.f_mntfromname, MNAMELEN);
bcopy(pth, mp->mnt_stat.f_mntonname, MNAMELEN);
bcopy(argp, &mp->mnt_stat.mount_info.nfs_args, sizeof(*argp));
nmp->nm_nam = nam;
nfs_decode_args(nmp, argp, &mp->mnt_stat.mount_info.nfs_args);
  704         /* Set up the sockets and per-host congestion */
nmp->nm_sotype = argp->sotype;
nmp->nm_soproto = argp->proto;
  708         /*
  709          * For Connection based sockets (TCP,...) defer the connect until
  710          * the first request, in case the server is not responding.
  711          */
  712         if (nmp->nm_sotype == SOCK_DGRAM &&
  713             (error = nfs_connect(nmp, (struct nfsreq *)0)))
  714                 goto bad;
  716         /*
  717          * This is silly, but it has to be set so that vinifod() works.
  718          * We do not want to do an nfs_statfs() here since we can get
  719          * stuck on a dead server and we are holding a lock on the mount
  720          * point.
  721          */
mp->mnt_stat.f_iosize = NFS_MAXDGRAMDATA;
  724         return (0);
bad:
nfs_disconnect(nmp);
free((caddr_t)nmp, M_NFSMNT);
m_freem(nam);
  729         return (error);
  730 }
  732 /* unmount system call */
  733 int
nfs_unmount(struct mount *mp, int mntflags, struct proc *p)
  735 {
  736         struct nfsmount *nmp;
  737         int error, flags;
nmp = VFSTONFS(mp);
flags = 0;
  742         if (mntflags & MNT_FORCE)
flags |= FORCECLOSE;
error = vflush(mp, NULL, flags);
  746         if (error)
  747                 return (error);
nfs_disconnect(nmp);
m_freem(nmp->nm_nam);
free(nmp, M_NFSMNT);
  752         return (0);
  753 }
  755 /*
  756  * Return root of a filesystem
  757  */
  758 int
nfs_root(mp, vpp)
  760         struct mount *mp;
  761         struct vnode **vpp;
  762 {
  763         struct nfsmount *nmp;
  764         struct nfsnode *np;
  765         int error;
nmp = VFSTONFS(mp);
error = nfs_nget(mp, (nfsfh_t *)nmp->nm_fh, nmp->nm_fhsize, &np);
  769         if (error)
  770                 return (error);
  771         *vpp = NFSTOV(np);
  772         return (0);
  773 }
  775 /*
  776  * Flush out the buffer cache
  777  */
  778 /* ARGSUSED */
  779 int
nfs_sync(mp, waitfor, cred, p)
  781         struct mount *mp;
  782         int waitfor;
  783         struct ucred *cred;
  784         struct proc *p;
  785 {
  786         struct vnode *vp;
  787         int error, allerror = 0;
  789         /*
  790          * Don't traverse the vnode list if we want to skip all of them.
  791          */
  792         if (waitfor == MNT_LAZY)
  793                 return (allerror);
  795         /*
  796          * Force stale buffer cache information to be flushed.
  797          */
loop:
  799         for (vp = LIST_FIRST(&mp->mnt_vnodelist); vp != NULL;
vp = LIST_NEXT(vp, v_mntvnodes)) {
  801                 /*
  802                  * If the vnode that we are about to sync is no longer
  803                  * associated with this mount point, start over.
  804                  */
  805                 if (vp->v_mount != mp)
  806                         goto loop;
  807                 if (VOP_ISLOCKED(vp) || LIST_FIRST(&vp->v_dirtyblkhd) == NULL)
  808                         continue;
  809                 if (vget(vp, LK_EXCLUSIVE, p))
  810                         goto loop;
error = VOP_FSYNC(vp, cred, waitfor, p);
  812                 if (error)
allerror = error;
vput(vp);
  815         }
  817         return (allerror);
  818 }
  820 /*
  821  * NFS flat namespace lookup.
  822  * Currently unsupported.
  823  */
  824 /* ARGSUSED */
  825 int
nfs_vget(mp, ino, vpp)
  827         struct mount *mp;
ino_t ino;
  829         struct vnode **vpp;
  830 {
  832         return (EOPNOTSUPP);
  833 }
  835 /*
  836  * Do that sysctl thang...
  837  */
  838 int
nfs_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
size_t newlen, struct proc *p)
  841 {
  842         int rv;
  844         /*
  845          * All names at this level are terminal.
  846          */
  847         if(namelen > 1)
  848                 return ENOTDIR; /* overloaded */
  850         switch(name[0]) {
  851         case NFS_NFSSTATS:
  852                 if(!oldp) {
  853                         *oldlenp = sizeof nfsstats;
  854                         return 0;
  855                 }
  857                 if(*oldlenp < sizeof nfsstats) {
  858                         *oldlenp = sizeof nfsstats;
  859                         return ENOMEM;
  860                 }
rv = copyout(&nfsstats, oldp, sizeof nfsstats);
  863                 if(rv) return rv;
  865                 if(newp && newlen != sizeof nfsstats)
  866                         return EINVAL;
  868                 if(newp) {
  869                         return copyin(newp, &nfsstats, sizeof nfsstats);
  870                 }
  871                 return 0;
  873         case NFS_NIOTHREADS:
nfs_getset_niothreads(0);
rv = sysctl_int(oldp, oldlenp, newp, newlen, &nfs_niothreads);
  877                 if (newp)
nfs_getset_niothreads(1);
  880                 return rv;
  882         default:
  883                 return EOPNOTSUPP;
  884         }
  885 }
  888 /*
  889  * At this point, this should never happen
  890  */
  891 /* ARGSUSED */
  892 int
nfs_fhtovp(mp, fhp, vpp)
  894         struct mount *mp;
  895         struct fid *fhp;
  896         struct vnode **vpp;
  897 {
  899         return (EINVAL);
  900 }
  902 /*
  903  * Vnode pointer to File handle, should never happen either
  904  */
  905 /* ARGSUSED */
  906 int
nfs_vptofh(vp, fhp)
  908         struct vnode *vp;
  909         struct fid *fhp;
  910 {
  912         return (EINVAL);
  913 }
  915 /*
  916  * Vfs start routine, a no-op.
  917  */
  918 /* ARGSUSED */
  919 int
nfs_start(mp, flags, p)
  921         struct mount *mp;
  922         int flags;
  923         struct proc *p;
  924 {
  926         return (0);
  927 }
  929 /*
  930  * Do operations associated with quotas, not supported
  931  */
  932 /* ARGSUSED */
  933 int
nfs_quotactl(mp, cmd, uid, arg, p)
  935         struct mount *mp;
  936         int cmd;
uid_t uid;
caddr_t arg;
  939         struct proc *p;
  940 {
  942         return (EOPNOTSUPP);
  943 }
  945 /*
  946  * check export permission, not supported
  947  */
  948 /* ARGUSED */
  949 int
nfs_checkexp(mp, nam, exflagsp, credanonp)
  951         struct mount *mp;
  952         struct mbuf *nam;
  953         int *exflagsp;
  954         struct ucred **credanonp;
  955 {
  956         return (EOPNOTSUPP);
  957 }