Annotation of sys/nfs/nfs_vfsops.c, Revision 1.1
1.1 ! nbrk 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 $ */
! 3:
! 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: */
! 37:
! 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>
! 53:
! 54: #include <net/if.h>
! 55: #include <net/route.h>
! 56: #include <netinet/in.h>
! 57:
! 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>
! 67:
! 68: #define NQ_DEADTHRESH NQ_NEVERDEAD /* Default nm_deadthresh */
! 69: #define NQ_NEVERDEAD 9 /* Greater than max. nm_timeouts */
! 70:
! 71: extern struct nfsstats nfsstats;
! 72: extern int nfs_ticks;
! 73: extern u_int32_t nfs_procids[NFS_NPROCS];
! 74:
! 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);
! 78:
! 79: /*
! 80: * nfs vfs operations.
! 81: */
! 82: const struct vfsops nfs_vfsops = {
! 83: nfs_mount,
! 84: nfs_start,
! 85: nfs_unmount,
! 86: nfs_root,
! 87: nfs_quotactl,
! 88: nfs_statfs,
! 89: nfs_sync,
! 90: nfs_vget,
! 91: nfs_fhtovp,
! 92: nfs_vptofh,
! 93: nfs_vfs_init,
! 94: nfs_sysctl,
! 95: nfs_checkexp
! 96: };
! 97:
! 98: #define TRUE 1
! 99: #define FALSE 0
! 100:
! 101: /*
! 102: * nfs statfs call
! 103: */
! 104: int
! 105: 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;
! 112: caddr_t cp;
! 113: u_int32_t *tl;
! 114: int32_t t1, t2;
! 115: 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;
! 121: u_quad_t tquad;
! 122:
! 123: error = nfs_nget(mp, (nfsfh_t *)nmp->nm_fh, nmp->nm_fhsize, &np);
! 124: if (error)
! 125: return (error);
! 126: vp = NFSTOV(np);
! 127: cred = crget();
! 128: cred->cr_ngroups = 0;
! 129: if (v3 && (nmp->nm_flag & NFSMNT_GOTFSINFO) == 0)
! 130: (void)nfs_fsinfo(nmp, vp, cred, p);
! 131: nfsstats.rpccnt[NFSPROC_FSSTAT]++;
! 132: nfsm_reqhead(vp, NFSPROC_FSSTAT, NFSX_FH(v3));
! 133: nfsm_fhtom(vp, v3);
! 134: nfsm_request(vp, NFSPROC_FSSTAT, p, cred);
! 135: if (v3)
! 136: nfsm_postop_attr(vp, retattr);
! 137: if (error) {
! 138: if (mrep != NULL)
! 139: m_free(mrep);
! 140: goto nfsmout;
! 141: }
! 142: nfsm_dissect(sfp, struct nfs_statfs *, NFSX_STATFS(v3));
! 143: sbp->f_flags = nmp->nm_flag;
! 144: sbp->f_iosize = min(nmp->nm_rsize, nmp->nm_wsize);
! 145: if (v3) {
! 146: sbp->f_bsize = NFS_FABLKSIZE;
! 147: tquad = fxdr_hyper(&sfp->sf_tbytes);
! 148: sbp->f_blocks = (u_int32_t)(tquad / (u_quad_t)NFS_FABLKSIZE);
! 149: tquad = fxdr_hyper(&sfp->sf_fbytes);
! 150: sbp->f_bfree = (u_int32_t)(tquad / (u_quad_t)NFS_FABLKSIZE);
! 151: tquad = fxdr_hyper(&sfp->sf_abytes);
! 152: sbp->f_bavail = (int32_t)((quad_t)tquad / (quad_t)NFS_FABLKSIZE);
! 153: sbp->f_files = (fxdr_unsigned(int32_t,
! 154: sfp->sf_tfiles.nfsuquad[1]) & 0x7fffffff);
! 155: sbp->f_ffree = (fxdr_unsigned(int32_t,
! 156: sfp->sf_ffiles.nfsuquad[1]) & 0x7fffffff);
! 157: } else {
! 158: sbp->f_bsize = fxdr_unsigned(int32_t, sfp->sf_bsize);
! 159: sbp->f_blocks = fxdr_unsigned(int32_t, sfp->sf_blocks);
! 160: sbp->f_bfree = fxdr_unsigned(int32_t, sfp->sf_bfree);
! 161: sbp->f_bavail = fxdr_unsigned(int32_t, sfp->sf_bavail);
! 162: sbp->f_files = 0;
! 163: sbp->f_ffree = 0;
! 164: }
! 165: if (sbp != &mp->mnt_stat) {
! 166: bcopy(mp->mnt_stat.f_mntonname, sbp->f_mntonname, MNAMELEN);
! 167: bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN);
! 168: bcopy(&mp->mnt_stat.mount_info.nfs_args,
! 169: &sbp->mount_info.nfs_args, sizeof(struct nfs_args));
! 170: }
! 171: strncpy(&sbp->f_fstypename[0], mp->mnt_vfc->vfc_name, MFSNAMELEN);
! 172: nfsm_reqdone;
! 173: vrele(vp);
! 174: crfree(cred);
! 175: return (error);
! 176: }
! 177:
! 178: /*
! 179: * nfs version 3 fsinfo rpc call
! 180: */
! 181: int
! 182: 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;
! 189: caddr_t cp;
! 190: int32_t t1, t2;
! 191: u_int32_t *tl, pref, max;
! 192: caddr_t bpos, dpos, cp2;
! 193: int error = 0, retattr;
! 194: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
! 195:
! 196: nfsstats.rpccnt[NFSPROC_FSINFO]++;
! 197: nfsm_reqhead(vp, NFSPROC_FSINFO, NFSX_FH(1));
! 198: nfsm_fhtom(vp, 1);
! 199: nfsm_request(vp, NFSPROC_FSINFO, p, cred);
! 200: nfsm_postop_attr(vp, retattr);
! 201: if (!error) {
! 202: nfsm_dissect(fsp, struct nfsv3_fsinfo *, NFSX_V3FSINFO);
! 203: pref = fxdr_unsigned(u_int32_t, fsp->fs_wtpref);
! 204: if (pref < nmp->nm_wsize)
! 205: nmp->nm_wsize = (pref + NFS_FABLKSIZE - 1) &
! 206: ~(NFS_FABLKSIZE - 1);
! 207: max = fxdr_unsigned(u_int32_t, fsp->fs_wtmax);
! 208: if (max < nmp->nm_wsize) {
! 209: nmp->nm_wsize = max & ~(NFS_FABLKSIZE - 1);
! 210: if (nmp->nm_wsize == 0)
! 211: nmp->nm_wsize = max;
! 212: }
! 213: pref = fxdr_unsigned(u_int32_t, fsp->fs_rtpref);
! 214: if (pref < nmp->nm_rsize)
! 215: nmp->nm_rsize = (pref + NFS_FABLKSIZE - 1) &
! 216: ~(NFS_FABLKSIZE - 1);
! 217: max = fxdr_unsigned(u_int32_t, fsp->fs_rtmax);
! 218: if (max < nmp->nm_rsize) {
! 219: nmp->nm_rsize = max & ~(NFS_FABLKSIZE - 1);
! 220: if (nmp->nm_rsize == 0)
! 221: nmp->nm_rsize = max;
! 222: }
! 223: pref = fxdr_unsigned(u_int32_t, fsp->fs_dtpref);
! 224: if (pref < nmp->nm_readdirsize)
! 225: nmp->nm_readdirsize = (pref + NFS_DIRBLKSIZ - 1) &
! 226: ~(NFS_DIRBLKSIZ - 1);
! 227: if (max < nmp->nm_readdirsize) {
! 228: nmp->nm_readdirsize = max & ~(NFS_DIRBLKSIZ - 1);
! 229: if (nmp->nm_readdirsize == 0)
! 230: nmp->nm_readdirsize = max;
! 231: }
! 232: nmp->nm_flag |= NFSMNT_GOTFSINFO;
! 233: }
! 234: nfsm_reqdone;
! 235: return (error);
! 236: }
! 237:
! 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
! 247: 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;
! 256:
! 257: procp = curproc; /* XXX */
! 258:
! 259: /*
! 260: * Call nfs_boot_init() to fill in the nfs_diskless struct.
! 261: * Side effect: Finds and configures a network interface.
! 262: */
! 263: bzero((caddr_t) &nd, sizeof(nd));
! 264: nfs_boot_init(&nd, procp);
! 265:
! 266: /*
! 267: * Create the root mount point.
! 268: */
! 269: if (nfs_boot_getfh(&nd.nd_boot, "root", &nd.nd_root, -1))
! 270: panic("nfs_mountroot: root");
! 271: mp = nfs_mount_diskless(&nd.nd_root, "/", 0);
! 272: nfs_root(mp, &rootvp);
! 273: printf("root on %s\n", nd.nd_root.ndm_host);
! 274:
! 275: /*
! 276: * Link it into the mount list.
! 277: */
! 278: CIRCLEQ_INSERT_TAIL(&mountlist, mp, mnt_list);
! 279: vfs_unbusy(mp);
! 280:
! 281: /* Get root attributes (for the time). */
! 282: error = VOP_GETATTR(rootvp, &attr, procp->p_ucred, procp);
! 283: if (error) panic("nfs_mountroot: getattr for root");
! 284: n = attr.va_atime.tv_sec;
! 285: #ifdef DEBUG
! 286: printf("root time: 0x%lx\n", n);
! 287: #endif
! 288: inittodr(n);
! 289:
! 290: #ifdef notyet
! 291: /* Set up swap credentials. */
! 292: proc0.p_ucred->cr_uid = ntohl(nd.swap_ucred.cr_uid);
! 293: proc0.p_ucred->cr_gid = ntohl(nd.swap_ucred.cr_gid);
! 294: if ((proc0.p_ucred->cr_ngroups = ntohs(nd.swap_ucred.cr_ngroups)) >
! 295: NGROUPS)
! 296: proc0.p_ucred->cr_ngroups = NGROUPS;
! 297: for (i = 0; i < proc0.p_ucred->cr_ngroups; i++)
! 298: proc0.p_ucred->cr_groups[i] = ntohl(nd.swap_ucred.cr_groups[i]);
! 299: #endif
! 300:
! 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))
! 308: panic("nfs_mountroot: can't setup swap vp");
! 309: if (swdevt[0].sw_dev != NODEV) {
! 310: printf("swap on device 0x%x\n", swdevt[0].sw_dev);
! 311: return (0);
! 312: }
! 313:
! 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: */
! 321: error = nfs_boot_getfh(&nd.nd_boot, "swap", &nd.nd_swap, 5);
! 322: if (!error) {
! 323: mp = nfs_mount_diskless(&nd.nd_swap, "/swap", 0);
! 324: nfs_root(mp, &vp);
! 325: vfs_unbusy(mp);
! 326:
! 327: /*
! 328: * Since the swap file is not the root dir of a file system,
! 329: * hack it to a regular file.
! 330: */
! 331: vp->v_type = VREG;
! 332: vp->v_flag = 0;
! 333:
! 334: /*
! 335: * Next line is a hack to make swapmount() work on NFS swap files.
! 336: * XXX-smurph
! 337: */
! 338: swdevt[0].sw_dev = NETDEV;
! 339: /* end hack */
! 340: swdevt[0].sw_vp = vp;
! 341:
! 342: /*
! 343: * Find out how large the swap file is.
! 344: */
! 345: error = VOP_GETATTR(vp, &attr, procp->p_ucred, procp);
! 346: if (error)
! 347: printf("nfs_mountroot: getattr for swap\n");
! 348: n = (long) (attr.va_size >> DEV_BSHIFT);
! 349:
! 350: printf("swap on %s\n", nd.nd_swap.ndm_host);
! 351: #ifdef DEBUG
! 352: printf("swap size: 0x%lx (blocks)\n", n);
! 353: #endif
! 354: return (0);
! 355: }
! 356:
! 357: printf("WARNING: no swap\n");
! 358: swdevt[0].sw_dev = NODEV;
! 359: swdevt[0].sw_vp = NULL;
! 360:
! 361: return (0);
! 362: }
! 363:
! 364: /*
! 365: * Internal version of mount system call for diskless setup.
! 366: */
! 367: struct mount *
! 368: 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;
! 377:
! 378: if (vfs_rootmountalloc("nfs", mntname, &mp))
! 379: panic("nfs_mount_diskless: vfs_rootmountalloc failed");
! 380: mp->mnt_flag |= mntflag;
! 381:
! 382: /* Initialize mount args. */
! 383: bzero((caddr_t) &args, sizeof(args));
! 384: args.addr = (struct sockaddr *)&ndmntp->ndm_saddr;
! 385: args.addrlen = args.addr->sa_len;
! 386: args.sotype = SOCK_DGRAM;
! 387: args.fh = ndmntp->ndm_fh;
! 388: args.fhsize = NFSX_V2FH;
! 389: args.hostname = ndmntp->ndm_host;
! 390:
! 391: #ifdef NFS_BOOT_OPTIONS
! 392: 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: */
! 400: args.flags |= NFSMNT_WSIZE | NFSMNT_RSIZE;
! 401: args.wsize = NFS_BOOT_RWSIZE;
! 402: args.rsize = NFS_BOOT_RWSIZE;
! 403: #endif
! 404:
! 405: /* Get mbuf for server sockaddr. */
! 406: m = m_get(M_WAIT, MT_SONAME);
! 407: bcopy((caddr_t)args.addr, mtod(m, caddr_t),
! 408: (m->m_len = args.addr->sa_len));
! 409:
! 410: error = mountnfs(&args, mp, m, mntname, args.hostname);
! 411: if (error)
! 412: panic("nfs_mountroot: mount %s failed: %d", mntname, error);
! 413:
! 414: return (mp);
! 415: }
! 416:
! 417: void
! 418: 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;
! 426:
! 427: s = splsoftnet();
! 428:
! 429: #if 0
! 430: /* Re-bind if rsrvd port requested and wasn't on one */
! 431: 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 */
! 435: adjsock |= ((nmp->nm_flag & NFSMNT_NOCONN) !=
! 436: (argp->flags & NFSMNT_NOCONN));
! 437:
! 438: /* Update flags atomically. Don't change the lock bits. */
! 439: nmp->nm_flag =
! 440: (argp->flags & ~NFSMNT_INTERNAL) | (nmp->nm_flag & NFSMNT_INTERNAL);
! 441: splx(s);
! 442:
! 443: if ((argp->flags & NFSMNT_TIMEO) && argp->timeo > 0) {
! 444: nmp->nm_timeo = (argp->timeo * NFS_HZ + 5) / 10;
! 445: if (nmp->nm_timeo < NFS_MINTIMEO)
! 446: nmp->nm_timeo = NFS_MINTIMEO;
! 447: else if (nmp->nm_timeo > NFS_MAXTIMEO)
! 448: nmp->nm_timeo = NFS_MAXTIMEO;
! 449: }
! 450:
! 451: if ((argp->flags & NFSMNT_RETRANS) && argp->retrans > 1) {
! 452: nmp->nm_retry = argp->retrans;
! 453: if (nmp->nm_retry > NFS_MAXREXMIT)
! 454: nmp->nm_retry = NFS_MAXREXMIT;
! 455: }
! 456:
! 457: if (argp->flags & NFSMNT_NFSV3) {
! 458: if (argp->sotype == SOCK_DGRAM)
! 459: maxio = NFS_MAXDGRAMDATA;
! 460: else
! 461: maxio = NFS_MAXDATA;
! 462: } else
! 463: maxio = NFS_V2MAXDATA;
! 464:
! 465: if ((argp->flags & NFSMNT_WSIZE) && argp->wsize > 0) {
! 466: int osize = nmp->nm_wsize;
! 467: nmp->nm_wsize = argp->wsize;
! 468: /* Round down to multiple of blocksize */
! 469: nmp->nm_wsize &= ~(NFS_FABLKSIZE - 1);
! 470: if (nmp->nm_wsize <= 0)
! 471: nmp->nm_wsize = NFS_FABLKSIZE;
! 472: adjsock |= (nmp->nm_wsize != osize);
! 473: }
! 474: if (nmp->nm_wsize > maxio)
! 475: nmp->nm_wsize = maxio;
! 476: if (nmp->nm_wsize > MAXBSIZE)
! 477: nmp->nm_wsize = MAXBSIZE;
! 478:
! 479: if ((argp->flags & NFSMNT_RSIZE) && argp->rsize > 0) {
! 480: int osize = nmp->nm_rsize;
! 481: nmp->nm_rsize = argp->rsize;
! 482: /* Round down to multiple of blocksize */
! 483: nmp->nm_rsize &= ~(NFS_FABLKSIZE - 1);
! 484: if (nmp->nm_rsize <= 0)
! 485: nmp->nm_rsize = NFS_FABLKSIZE;
! 486: adjsock |= (nmp->nm_rsize != osize);
! 487: }
! 488: if (nmp->nm_rsize > maxio)
! 489: nmp->nm_rsize = maxio;
! 490: if (nmp->nm_rsize > MAXBSIZE)
! 491: nmp->nm_rsize = MAXBSIZE;
! 492:
! 493: if ((argp->flags & NFSMNT_READDIRSIZE) && argp->readdirsize > 0) {
! 494: nmp->nm_readdirsize = argp->readdirsize;
! 495: /* Round down to multiple of blocksize */
! 496: nmp->nm_readdirsize &= ~(NFS_DIRBLKSIZ - 1);
! 497: if (nmp->nm_readdirsize < NFS_DIRBLKSIZ)
! 498: nmp->nm_readdirsize = NFS_DIRBLKSIZ;
! 499: } else if (argp->flags & NFSMNT_RSIZE)
! 500: nmp->nm_readdirsize = nmp->nm_rsize;
! 501:
! 502: if (nmp->nm_readdirsize > maxio)
! 503: nmp->nm_readdirsize = maxio;
! 504:
! 505: if ((argp->flags & NFSMNT_MAXGRPS) && argp->maxgrouplist >= 0 &&
! 506: argp->maxgrouplist <= NFS_MAXGRPS)
! 507: nmp->nm_numgrps = argp->maxgrouplist;
! 508: if ((argp->flags & NFSMNT_READAHEAD) && argp->readahead >= 0 &&
! 509: argp->readahead <= NFS_MAXRAHEAD)
! 510: nmp->nm_readahead = argp->readahead;
! 511: if ((argp->flags & NFSMNT_DEADTHRESH) && argp->deadthresh >= 1 &&
! 512: argp->deadthresh <= NQ_NEVERDEAD)
! 513: nmp->nm_deadthresh = argp->deadthresh;
! 514: if (argp->flags & NFSMNT_ACREGMIN && argp->acregmin >= 0) {
! 515: if (argp->acregmin > 0xffff)
! 516: nmp->nm_acregmin = 0xffff;
! 517: else
! 518: nmp->nm_acregmin = argp->acregmin;
! 519: }
! 520: if (argp->flags & NFSMNT_ACREGMAX && argp->acregmax >= 0) {
! 521: if (argp->acregmax > 0xffff)
! 522: nmp->nm_acregmax = 0xffff;
! 523: else
! 524: nmp->nm_acregmax = argp->acregmax;
! 525: }
! 526: if (nmp->nm_acregmin > nmp->nm_acregmax)
! 527: nmp->nm_acregmin = nmp->nm_acregmax;
! 528:
! 529: if (argp->flags & NFSMNT_ACDIRMIN && argp->acdirmin >= 0) {
! 530: if (argp->acdirmin > 0xffff)
! 531: nmp->nm_acdirmin = 0xffff;
! 532: else
! 533: nmp->nm_acdirmin = argp->acdirmin;
! 534: }
! 535: if (argp->flags & NFSMNT_ACDIRMAX && argp->acdirmax >= 0) {
! 536: if (argp->acdirmax > 0xffff)
! 537: nmp->nm_acdirmax = 0xffff;
! 538: else
! 539: nmp->nm_acdirmax = argp->acdirmax;
! 540: }
! 541: if (nmp->nm_acdirmin > nmp->nm_acdirmax)
! 542: nmp->nm_acdirmin = nmp->nm_acdirmax;
! 543:
! 544: if (nmp->nm_so && adjsock) {
! 545: nfs_disconnect(nmp);
! 546: if (nmp->nm_sotype == SOCK_DGRAM)
! 547: while (nfs_connect(nmp, (struct nfsreq *)0)) {
! 548: printf("nfs_args: retrying connect\n");
! 549: (void) tsleep((caddr_t)&lbolt,
! 550: PSOCK, "nfscon", 0);
! 551: }
! 552: }
! 553:
! 554: /* Update nargp based on nmp */
! 555: nargp->wsize = nmp->nm_wsize;
! 556: nargp->rsize = nmp->nm_rsize;
! 557: nargp->readdirsize = nmp->nm_readdirsize;
! 558: nargp->timeo = nmp->nm_timeo;
! 559: nargp->retrans = nmp->nm_retry;
! 560: nargp->maxgrouplist = nmp->nm_numgrps;
! 561: nargp->readahead = nmp->nm_readahead;
! 562: nargp->deadthresh = nmp->nm_deadthresh;
! 563: nargp->acregmin = nmp->nm_acregmin;
! 564: nargp->acregmax = nmp->nm_acregmax;
! 565: nargp->acdirmin = nmp->nm_acdirmin;
! 566: nargp->acdirmax = nmp->nm_acdirmax;
! 567: }
! 568:
! 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
! 580: 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];
! 591: size_t len;
! 592: u_char nfh[NFSX_V3FHMAX];
! 593:
! 594: error = copyin (data, &args, sizeof (args.version));
! 595: if (error)
! 596: return (error);
! 597: if (args.version == 3) {
! 598: error = copyin (data, (caddr_t)&args,
! 599: sizeof (struct nfs_args3));
! 600: args.flags &= ~(NFSMNT_INTERNAL|NFSMNT_NOAC);
! 601: }
! 602: else if (args.version == NFS_ARGSVERSION) {
! 603: error = copyin(data, (caddr_t)&args, sizeof (struct nfs_args));
! 604: args.flags &= ~NFSMNT_NOAC; /* XXX - compatibility */
! 605: }
! 606: else
! 607: return (EPROGMISMATCH);
! 608: if (error)
! 609: return (error);
! 610:
! 611: if ((args.flags & (NFSMNT_NFSV3|NFSMNT_RDIRPLUS)) == NFSMNT_RDIRPLUS)
! 612: return (EINVAL);
! 613:
! 614: if (nfs_niothreads < 0) {
! 615: nfs_niothreads = 4;
! 616: nfs_getset_niothreads(TRUE);
! 617: }
! 618:
! 619: if (mp->mnt_flag & MNT_UPDATE) {
! 620: struct nfsmount *nmp = VFSTONFS(mp);
! 621:
! 622: if (nmp == NULL)
! 623: return (EIO);
! 624: /*
! 625: * When doing an update, we can't change from or to
! 626: * v3.
! 627: */
! 628: args.flags = (args.flags & ~(NFSMNT_NFSV3)) |
! 629: (nmp->nm_flag & (NFSMNT_NFSV3));
! 630: 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);
! 635: error = copyin((caddr_t)args.fh, (caddr_t)nfh, args.fhsize);
! 636: if (error)
! 637: return (error);
! 638: error = copyinstr(path, pth, MNAMELEN-1, &len);
! 639: if (error)
! 640: return (error);
! 641: bzero(&pth[len], MNAMELEN - len);
! 642: error = copyinstr(args.hostname, hst, MNAMELEN-1, &len);
! 643: if (error)
! 644: return (error);
! 645: bzero(&hst[len], MNAMELEN - len);
! 646: /* sockargs() call must be after above copyin() calls */
! 647: error = sockargs(&nam, args.addr, args.addrlen, MT_SONAME);
! 648: if (error)
! 649: return (error);
! 650: args.fh = nfh;
! 651: error = mountnfs(&args, mp, nam, pth, hst);
! 652: return (error);
! 653: }
! 654:
! 655: /*
! 656: * Common code for mount and mountroot
! 657: */
! 658: int
! 659: 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;
! 667:
! 668: if (mp->mnt_flag & MNT_UPDATE) {
! 669: nmp = VFSTONFS(mp);
! 670: /* update paths, file handles, etc, here XXX */
! 671: m_freem(nam);
! 672: return (0);
! 673: } else {
! 674: MALLOC(nmp, struct nfsmount *, sizeof (struct nfsmount),
! 675: M_NFSMNT, M_WAITOK);
! 676: bzero((caddr_t)nmp, sizeof (struct nfsmount));
! 677: mp->mnt_data = (qaddr_t)nmp;
! 678: TAILQ_INIT(&nmp->nm_uidlruhead);
! 679: }
! 680:
! 681: vfs_getnewfsid(mp);
! 682: nmp->nm_mountp = mp;
! 683: nmp->nm_timeo = NFS_TIMEO;
! 684: nmp->nm_retry = NFS_RETRANS;
! 685: nmp->nm_wsize = NFS_WSIZE;
! 686: nmp->nm_rsize = NFS_RSIZE;
! 687: nmp->nm_readdirsize = NFS_READDIRSIZE;
! 688: nmp->nm_numgrps = NFS_MAXGRPS;
! 689: nmp->nm_readahead = NFS_DEFRAHEAD;
! 690: nmp->nm_deadthresh = NQ_DEADTHRESH;
! 691: nmp->nm_fhsize = argp->fhsize;
! 692: nmp->nm_acregmin = NFS_MINATTRTIMO;
! 693: nmp->nm_acregmax = NFS_MAXATTRTIMO;
! 694: nmp->nm_acdirmin = NFS_MINATTRTIMO;
! 695: nmp->nm_acdirmax = NFS_MAXATTRTIMO;
! 696: bcopy((caddr_t)argp->fh, (caddr_t)nmp->nm_fh, argp->fhsize);
! 697: strncpy(&mp->mnt_stat.f_fstypename[0], mp->mnt_vfc->vfc_name, MFSNAMELEN);
! 698: bcopy(hst, mp->mnt_stat.f_mntfromname, MNAMELEN);
! 699: bcopy(pth, mp->mnt_stat.f_mntonname, MNAMELEN);
! 700: bcopy(argp, &mp->mnt_stat.mount_info.nfs_args, sizeof(*argp));
! 701: nmp->nm_nam = nam;
! 702: nfs_decode_args(nmp, argp, &mp->mnt_stat.mount_info.nfs_args);
! 703:
! 704: /* Set up the sockets and per-host congestion */
! 705: nmp->nm_sotype = argp->sotype;
! 706: nmp->nm_soproto = argp->proto;
! 707:
! 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;
! 715:
! 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: */
! 722: mp->mnt_stat.f_iosize = NFS_MAXDGRAMDATA;
! 723:
! 724: return (0);
! 725: bad:
! 726: nfs_disconnect(nmp);
! 727: free((caddr_t)nmp, M_NFSMNT);
! 728: m_freem(nam);
! 729: return (error);
! 730: }
! 731:
! 732: /* unmount system call */
! 733: int
! 734: nfs_unmount(struct mount *mp, int mntflags, struct proc *p)
! 735: {
! 736: struct nfsmount *nmp;
! 737: int error, flags;
! 738:
! 739: nmp = VFSTONFS(mp);
! 740: flags = 0;
! 741:
! 742: if (mntflags & MNT_FORCE)
! 743: flags |= FORCECLOSE;
! 744:
! 745: error = vflush(mp, NULL, flags);
! 746: if (error)
! 747: return (error);
! 748:
! 749: nfs_disconnect(nmp);
! 750: m_freem(nmp->nm_nam);
! 751: free(nmp, M_NFSMNT);
! 752: return (0);
! 753: }
! 754:
! 755: /*
! 756: * Return root of a filesystem
! 757: */
! 758: int
! 759: nfs_root(mp, vpp)
! 760: struct mount *mp;
! 761: struct vnode **vpp;
! 762: {
! 763: struct nfsmount *nmp;
! 764: struct nfsnode *np;
! 765: int error;
! 766:
! 767: nmp = VFSTONFS(mp);
! 768: 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: }
! 774:
! 775: /*
! 776: * Flush out the buffer cache
! 777: */
! 778: /* ARGSUSED */
! 779: int
! 780: 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;
! 788:
! 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);
! 794:
! 795: /*
! 796: * Force stale buffer cache information to be flushed.
! 797: */
! 798: loop:
! 799: for (vp = LIST_FIRST(&mp->mnt_vnodelist); vp != NULL;
! 800: 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;
! 811: error = VOP_FSYNC(vp, cred, waitfor, p);
! 812: if (error)
! 813: allerror = error;
! 814: vput(vp);
! 815: }
! 816:
! 817: return (allerror);
! 818: }
! 819:
! 820: /*
! 821: * NFS flat namespace lookup.
! 822: * Currently unsupported.
! 823: */
! 824: /* ARGSUSED */
! 825: int
! 826: nfs_vget(mp, ino, vpp)
! 827: struct mount *mp;
! 828: ino_t ino;
! 829: struct vnode **vpp;
! 830: {
! 831:
! 832: return (EOPNOTSUPP);
! 833: }
! 834:
! 835: /*
! 836: * Do that sysctl thang...
! 837: */
! 838: int
! 839: nfs_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
! 840: size_t newlen, struct proc *p)
! 841: {
! 842: int rv;
! 843:
! 844: /*
! 845: * All names at this level are terminal.
! 846: */
! 847: if(namelen > 1)
! 848: return ENOTDIR; /* overloaded */
! 849:
! 850: switch(name[0]) {
! 851: case NFS_NFSSTATS:
! 852: if(!oldp) {
! 853: *oldlenp = sizeof nfsstats;
! 854: return 0;
! 855: }
! 856:
! 857: if(*oldlenp < sizeof nfsstats) {
! 858: *oldlenp = sizeof nfsstats;
! 859: return ENOMEM;
! 860: }
! 861:
! 862: rv = copyout(&nfsstats, oldp, sizeof nfsstats);
! 863: if(rv) return rv;
! 864:
! 865: if(newp && newlen != sizeof nfsstats)
! 866: return EINVAL;
! 867:
! 868: if(newp) {
! 869: return copyin(newp, &nfsstats, sizeof nfsstats);
! 870: }
! 871: return 0;
! 872:
! 873: case NFS_NIOTHREADS:
! 874: nfs_getset_niothreads(0);
! 875:
! 876: rv = sysctl_int(oldp, oldlenp, newp, newlen, &nfs_niothreads);
! 877: if (newp)
! 878: nfs_getset_niothreads(1);
! 879:
! 880: return rv;
! 881:
! 882: default:
! 883: return EOPNOTSUPP;
! 884: }
! 885: }
! 886:
! 887:
! 888: /*
! 889: * At this point, this should never happen
! 890: */
! 891: /* ARGSUSED */
! 892: int
! 893: nfs_fhtovp(mp, fhp, vpp)
! 894: struct mount *mp;
! 895: struct fid *fhp;
! 896: struct vnode **vpp;
! 897: {
! 898:
! 899: return (EINVAL);
! 900: }
! 901:
! 902: /*
! 903: * Vnode pointer to File handle, should never happen either
! 904: */
! 905: /* ARGSUSED */
! 906: int
! 907: nfs_vptofh(vp, fhp)
! 908: struct vnode *vp;
! 909: struct fid *fhp;
! 910: {
! 911:
! 912: return (EINVAL);
! 913: }
! 914:
! 915: /*
! 916: * Vfs start routine, a no-op.
! 917: */
! 918: /* ARGSUSED */
! 919: int
! 920: nfs_start(mp, flags, p)
! 921: struct mount *mp;
! 922: int flags;
! 923: struct proc *p;
! 924: {
! 925:
! 926: return (0);
! 927: }
! 928:
! 929: /*
! 930: * Do operations associated with quotas, not supported
! 931: */
! 932: /* ARGSUSED */
! 933: int
! 934: nfs_quotactl(mp, cmd, uid, arg, p)
! 935: struct mount *mp;
! 936: int cmd;
! 937: uid_t uid;
! 938: caddr_t arg;
! 939: struct proc *p;
! 940: {
! 941:
! 942: return (EOPNOTSUPP);
! 943: }
! 944:
! 945: /*
! 946: * check export permission, not supported
! 947: */
! 948: /* ARGUSED */
! 949: int
! 950: 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: }
! 958:
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to nfs_vfsops.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / nfs