![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to nfs_vfsops.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / nfs|
Return to nfs_vfsops.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / nfs |
1.1 ! root 1: /* ! 2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights ! 7: * Reserved. This file contains Original Code and/or Modifications of ! 8: * Original Code as defined in and that are subject to the Apple Public ! 9: * Source License Version 1.1 (the "License"). You may not use this file ! 10: * except in compliance with the License. Please obtain a copy of the ! 11: * License at http://www.apple.com/publicsource and read it before using ! 12: * this file. ! 13: * ! 14: * The Original Code and all software distributed under the License are ! 15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 19: * License for the specific language governing rights and limitations ! 20: * under the License. ! 21: * ! 22: * @APPLE_LICENSE_HEADER_END@ ! 23: */ ! 24: ! 25: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */ ! 26: /* ! 27: * Copyright (c) 1989, 1993, 1995 ! 28: * The Regents of the University of California. All rights reserved. ! 29: * ! 30: * This code is derived from software contributed to Berkeley by ! 31: * Rick Macklem at The University of Guelph. ! 32: * ! 33: * Redistribution and use in source and binary forms, with or without ! 34: * modification, are permitted provided that the following conditions ! 35: * are met: ! 36: * 1. Redistributions of source code must retain the above copyright ! 37: * notice, this list of conditions and the following disclaimer. ! 38: * 2. Redistributions in binary form must reproduce the above copyright ! 39: * notice, this list of conditions and the following disclaimer in the ! 40: * documentation and/or other materials provided with the distribution. ! 41: * 3. All advertising materials mentioning features or use of this software ! 42: * must display the following acknowledgement: ! 43: * This product includes software developed by the University of ! 44: * California, Berkeley and its contributors. ! 45: * 4. Neither the name of the University nor the names of its contributors ! 46: * may be used to endorse or promote products derived from this software ! 47: * without specific prior written permission. ! 48: * ! 49: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 50: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 51: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 52: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 53: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 54: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 55: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 56: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 57: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 58: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 59: * SUCH DAMAGE. ! 60: * ! 61: * @(#)nfs_vfsops.c 8.12 (Berkeley) 5/20/95 ! 62: * FreeBSD-Id: nfs_vfsops.c,v 1.52 1997/11/12 05:42:21 julian Exp $ ! 63: * ! 64: * History: ! 65: * ! 66: * ! 67: * 23-May-97 Umesh Vaishampayan ([email protected]) ! 68: * Added the ability to mount "/private" separately. ! 69: * Fixed bug which caused incorrect reporting of "mounted on" ! 70: * directory name in case of nfs root. ! 71: */ ! 72: ! 73: #include <sys/param.h> ! 74: #include <sys/conf.h> ! 75: #include <sys/ioctl.h> ! 76: #include <sys/signal.h> ! 77: #include <sys/proc.h> ! 78: #include <sys/namei.h> ! 79: #include <sys/vnode.h> ! 80: #include <sys/malloc.h> ! 81: #include <sys/kernel.h> ! 82: #include <sys/sysctl.h> ! 83: #include <sys/mount.h> ! 84: #include <sys/buf.h> ! 85: #include <sys/mbuf.h> ! 86: #include <sys/socket.h> ! 87: #include <sys/socketvar.h> ! 88: #include <sys/systm.h> ! 89: ! 90: #include <sys/vm.h> ! 91: #include <sys/vmparam.h> ! 92: ! 93: #if !defined(NO_MOUNT_PRIVATE) ! 94: #include <sys/filedesc.h> ! 95: #endif /* NO_MOUNT_PRIVATE */ ! 96: ! 97: #include <net/if.h> ! 98: #include <net/route.h> ! 99: #include <netinet/in.h> ! 100: ! 101: #include <nfs/rpcv2.h> ! 102: #include <nfs/nfsproto.h> ! 103: #include <nfs/nfs.h> ! 104: #include <nfs/nfsnode.h> ! 105: #include <nfs/nfsmount.h> ! 106: #include <nfs/xdr_subs.h> ! 107: #include <nfs/nfsm_subs.h> ! 108: #include <nfs/nfsdiskless.h> ! 109: #include <nfs/nqnfs.h> ! 110: ! 111: extern int nfs_mountroot __P((void)); ! 112: ! 113: extern int nfs_ticks; ! 114: ! 115: struct nfsstats nfsstats; ! 116: static int nfs_sysctl(int *, u_int, void *, size_t *, void *, size_t, ! 117: struct proc *); ! 118: /* XXX CSM 11/25/97 Upgrade sysctl.h someday */ ! 119: #ifdef notyet ! 120: SYSCTL_NODE(_vfs, MOUNT_NFS, nfs, CTLFLAG_RW, 0, "NFS filesystem"); ! 121: SYSCTL_STRUCT(_vfs_nfs, NFS_NFSSTATS, nfsstats, CTLFLAG_RD, ! 122: &nfsstats, nfsstats, ""); ! 123: #endif ! 124: #ifdef NFS_DEBUG ! 125: int nfs_debug; ! 126: /* XXX CSM 11/25/97 Upgrade sysctl.h someday */ ! 127: #ifdef notyet ! 128: SYSCTL_INT(_vfs_nfs, OID_AUTO, debug, CTLFLAG_RW, &nfs_debug, 0, ""); ! 129: #endif ! 130: #endif ! 131: ! 132: static int nfs_iosize __P((struct nfsmount *nmp)); ! 133: static int mountnfs __P((struct nfs_args *,struct mount *, ! 134: struct mbuf *,char *,char *,struct vnode **)); ! 135: static int nfs_mount __P(( struct mount *mp, char *path, caddr_t data, ! 136: struct nameidata *ndp, struct proc *p)); ! 137: static int nfs_start __P(( struct mount *mp, int flags, ! 138: struct proc *p)); ! 139: static int nfs_unmount __P(( struct mount *mp, int mntflags, ! 140: struct proc *p)); ! 141: static int nfs_root __P(( struct mount *mp, struct vnode **vpp)); ! 142: static int nfs_quotactl __P(( struct mount *mp, int cmds, uid_t uid, ! 143: caddr_t arg, struct proc *p)); ! 144: static int nfs_statfs __P(( struct mount *mp, struct statfs *sbp, ! 145: struct proc *p)); ! 146: static int nfs_sync __P(( struct mount *mp, int waitfor, ! 147: struct ucred *cred, struct proc *p)); ! 148: static int nfs_vptofh __P(( struct vnode *vp, struct fid *fhp)); ! 149: static int nfs_fhtovp __P((struct mount *mp, struct fid *fhp, ! 150: struct mbuf *nam, struct vnode **vpp, ! 151: int *exflagsp, struct ucred **credanonp)); ! 152: static int nfs_vget __P((struct mount *, ino_t, struct vnode **)); ! 153: ! 154: ! 155: /* ! 156: * nfs vfs operations. ! 157: */ ! 158: struct vfsops nfs_vfsops = { ! 159: nfs_mount, ! 160: nfs_start, ! 161: nfs_unmount, ! 162: nfs_root, ! 163: nfs_quotactl, ! 164: nfs_statfs, ! 165: nfs_sync, ! 166: nfs_vget, ! 167: nfs_fhtovp, ! 168: nfs_vptofh, ! 169: nfs_init, ! 170: nfs_sysctl ! 171: }; ! 172: /* XXX CSM 11/25/97 Mysterious kernel.h ld crud */ ! 173: #ifdef notyet ! 174: VFS_SET(nfs_vfsops, nfs, MOUNT_NFS, VFCF_NETWORK); ! 175: #endif ! 176: ! 177: /* ! 178: * This structure must be filled in by a primary bootstrap or bootstrap ! 179: * server for a diskless/dataless machine. It is initialized below just ! 180: * to ensure that it is allocated to initialized data (.data not .bss). ! 181: */ ! 182: struct nfs_diskless nfs_diskless = { 0 }; ! 183: int nfs_diskless_valid = 0; ! 184: ! 185: /* XXX CSM 11/25/97 Upgrade sysctl.h someday */ ! 186: #ifdef notyet ! 187: SYSCTL_INT(_vfs_nfs, OID_AUTO, diskless_valid, CTLFLAG_RD, ! 188: &nfs_diskless_valid, 0, ""); ! 189: ! 190: SYSCTL_STRING(_vfs_nfs, OID_AUTO, diskless_rootpath, CTLFLAG_RD, ! 191: nfs_diskless.root_hostnam, 0, ""); ! 192: ! 193: SYSCTL_OPAQUE(_vfs_nfs, OID_AUTO, diskless_rootaddr, CTLFLAG_RD, ! 194: &nfs_diskless.root_saddr, sizeof nfs_diskless.root_saddr, ! 195: "%Ssockaddr_in", ""); ! 196: ! 197: SYSCTL_STRING(_vfs_nfs, OID_AUTO, diskless_swappath, CTLFLAG_RD, ! 198: nfs_diskless.swap_hostnam, 0, ""); ! 199: ! 200: SYSCTL_OPAQUE(_vfs_nfs, OID_AUTO, diskless_swapaddr, CTLFLAG_RD, ! 201: &nfs_diskless.swap_saddr, sizeof nfs_diskless.swap_saddr, ! 202: "%Ssockaddr_in",""); ! 203: #endif ! 204: ! 205: ! 206: void nfsargs_ntoh __P((struct nfs_args *)); ! 207: static int ! 208: nfs_mount_diskless __P((struct nfs_dlmount *, char *, int, struct vnode **, ! 209: struct mount **)); ! 210: #if !defined(NO_MOUNT_PRIVATE) ! 211: static int ! 212: nfs_mount_diskless_private __P((struct nfs_dlmount *, char *, int, ! 213: struct vnode **, struct mount **)); ! 214: #endif /* NO_MOUNT_PRIVATE */ ! 215: static void nfs_convert_oargs __P((struct nfs_args *args, ! 216: struct onfs_args *oargs)); ! 217: ! 218: static int nfs_iosize(nmp) ! 219: struct nfsmount* nmp; ! 220: { ! 221: int iosize; ! 222: ! 223: /* ! 224: * Calculate the size used for io buffers. Use the larger ! 225: * of the two sizes to minimise nfs requests but make sure ! 226: * that it is at least one VM page to avoid wasting buffer ! 227: * space. ! 228: */ ! 229: iosize = max(nmp->nm_rsize, nmp->nm_wsize); ! 230: if (iosize < PAGE_SIZE) iosize = PAGE_SIZE; ! 231: return iosize; ! 232: } ! 233: ! 234: static void nfs_convert_oargs(args,oargs) ! 235: struct nfs_args *args; ! 236: struct onfs_args *oargs; ! 237: { ! 238: args->version = NFS_ARGSVERSION; ! 239: args->addr = oargs->addr; ! 240: args->addrlen = oargs->addrlen; ! 241: args->sotype = oargs->sotype; ! 242: args->proto = oargs->proto; ! 243: args->fh = oargs->fh; ! 244: args->fhsize = oargs->fhsize; ! 245: args->flags = oargs->flags; ! 246: args->wsize = oargs->wsize; ! 247: args->rsize = oargs->rsize; ! 248: args->readdirsize = oargs->readdirsize; ! 249: args->timeo = oargs->timeo; ! 250: args->retrans = oargs->retrans; ! 251: args->maxgrouplist = oargs->maxgrouplist; ! 252: args->readahead = oargs->readahead; ! 253: args->leaseterm = oargs->leaseterm; ! 254: args->deadthresh = oargs->deadthresh; ! 255: args->hostname = oargs->hostname; ! 256: } ! 257: ! 258: /* ! 259: * nfs statfs call ! 260: */ ! 261: int ! 262: nfs_statfs(mp, sbp, p) ! 263: struct mount *mp; ! 264: register struct statfs *sbp; ! 265: struct proc *p; ! 266: { ! 267: register struct vnode *vp; ! 268: register struct nfs_statfs *sfp; ! 269: register caddr_t cp; ! 270: register u_long *tl; ! 271: register long t1, t2; ! 272: caddr_t bpos, dpos, cp2; ! 273: struct nfsmount *nmp = VFSTONFS(mp); ! 274: int error = 0, v3 = (nmp->nm_flag & NFSMNT_NFSV3), retattr; ! 275: struct mbuf *mreq, *mrep, *md, *mb, *mb2; ! 276: struct ucred *cred; ! 277: struct nfsnode *np; ! 278: u_quad_t tquad; ! 279: extern int nfs_mount_type; ! 280: ! 281: #ifndef nolint ! 282: sfp = (struct nfs_statfs *)0; ! 283: #endif ! 284: error = nfs_nget(mp, (nfsfh_t *)nmp->nm_fh, nmp->nm_fhsize, &np); ! 285: if (error) ! 286: return (error); ! 287: vp = NFSTOV(np); ! 288: cred = crget(); ! 289: cred->cr_ngroups = 1; ! 290: if (v3 && (nmp->nm_flag & NFSMNT_GOTFSINFO) == 0) ! 291: (void)nfs_fsinfo(nmp, vp, cred, p); ! 292: nfsstats.rpccnt[NFSPROC_FSSTAT]++; ! 293: nfsm_reqhead(vp, NFSPROC_FSSTAT, NFSX_FH(v3)); ! 294: nfsm_fhtom(vp, v3); ! 295: nfsm_request(vp, NFSPROC_FSSTAT, p, cred); ! 296: if (v3) ! 297: nfsm_postop_attr(vp, retattr); ! 298: if (!error) { ! 299: nfsm_dissect(sfp, struct nfs_statfs *, NFSX_STATFS(v3)); ! 300: } else ! 301: goto nfsmout; ! 302: ! 303: /* XXX CSM 12/2/97 Cleanup when/if we integrate FreeBSD mount.h */ ! 304: #ifdef notyet ! 305: sbp->f_type = MOUNT_NFS; ! 306: #else ! 307: sbp->f_type = nfs_mount_type; ! 308: #endif ! 309: sbp->f_flags = nmp->nm_flag; ! 310: sbp->f_iosize = nfs_iosize(nmp); ! 311: if (v3) { ! 312: sbp->f_bsize = NFS_FABLKSIZE; ! 313: fxdr_hyper(&sfp->sf_tbytes, &tquad); ! 314: sbp->f_blocks = (long)(tquad / ((u_quad_t)NFS_FABLKSIZE)); ! 315: fxdr_hyper(&sfp->sf_fbytes, &tquad); ! 316: sbp->f_bfree = (long)(tquad / ((u_quad_t)NFS_FABLKSIZE)); ! 317: fxdr_hyper(&sfp->sf_abytes, &tquad); ! 318: sbp->f_bavail = (long)(tquad / ((u_quad_t)NFS_FABLKSIZE)); ! 319: sbp->f_files = (fxdr_unsigned(long, sfp->sf_tfiles.nfsuquad[1]) ! 320: & 0x7fffffff); ! 321: sbp->f_ffree = (fxdr_unsigned(long, sfp->sf_ffiles.nfsuquad[1]) ! 322: & 0x7fffffff); ! 323: } else { ! 324: sbp->f_bsize = fxdr_unsigned(long, sfp->sf_bsize); ! 325: sbp->f_blocks = fxdr_unsigned(long, sfp->sf_blocks); ! 326: sbp->f_bfree = fxdr_unsigned(long, sfp->sf_bfree); ! 327: sbp->f_bavail = fxdr_unsigned(long, sfp->sf_bavail); ! 328: sbp->f_files = 0; ! 329: sbp->f_ffree = 0; ! 330: } ! 331: if (sbp != &mp->mnt_stat) { ! 332: bcopy(mp->mnt_stat.f_mntonname, sbp->f_mntonname, MNAMELEN); ! 333: bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN); ! 334: } ! 335: nfsm_reqdone; ! 336: vput(vp); ! 337: crfree(cred); ! 338: return (error); ! 339: } ! 340: ! 341: /* ! 342: * nfs version 3 fsinfo rpc call ! 343: */ ! 344: int ! 345: nfs_fsinfo(nmp, vp, cred, p) ! 346: register struct nfsmount *nmp; ! 347: register struct vnode *vp; ! 348: struct ucred *cred; ! 349: struct proc *p; ! 350: { ! 351: register struct nfsv3_fsinfo *fsp; ! 352: register caddr_t cp; ! 353: register long t1, t2; ! 354: register u_long *tl, pref, max; ! 355: caddr_t bpos, dpos, cp2; ! 356: int error = 0, retattr; ! 357: struct mbuf *mreq, *mrep, *md, *mb, *mb2; ! 358: ! 359: nfsstats.rpccnt[NFSPROC_FSINFO]++; ! 360: nfsm_reqhead(vp, NFSPROC_FSINFO, NFSX_FH(1)); ! 361: nfsm_fhtom(vp, 1); ! 362: nfsm_request(vp, NFSPROC_FSINFO, p, cred); ! 363: nfsm_postop_attr(vp, retattr); ! 364: if (!error) { ! 365: nfsm_dissect(fsp, struct nfsv3_fsinfo *, NFSX_V3FSINFO); ! 366: pref = fxdr_unsigned(u_long, fsp->fs_wtpref); ! 367: if (pref < nmp->nm_wsize) ! 368: nmp->nm_wsize = (pref + NFS_FABLKSIZE - 1) & ! 369: ~(NFS_FABLKSIZE - 1); ! 370: max = fxdr_unsigned(u_long, fsp->fs_wtmax); ! 371: if (max < nmp->nm_wsize) { ! 372: nmp->nm_wsize = max & ~(NFS_FABLKSIZE - 1); ! 373: if (nmp->nm_wsize == 0) ! 374: nmp->nm_wsize = max; ! 375: } ! 376: pref = fxdr_unsigned(u_long, fsp->fs_rtpref); ! 377: if (pref < nmp->nm_rsize) ! 378: nmp->nm_rsize = (pref + NFS_FABLKSIZE - 1) & ! 379: ~(NFS_FABLKSIZE - 1); ! 380: max = fxdr_unsigned(u_long, fsp->fs_rtmax); ! 381: if (max < nmp->nm_rsize) { ! 382: nmp->nm_rsize = max & ~(NFS_FABLKSIZE - 1); ! 383: if (nmp->nm_rsize == 0) ! 384: nmp->nm_rsize = max; ! 385: } ! 386: pref = fxdr_unsigned(u_long, fsp->fs_dtpref); ! 387: if (pref < nmp->nm_readdirsize) ! 388: nmp->nm_readdirsize = pref; ! 389: if (max < nmp->nm_readdirsize) { ! 390: nmp->nm_readdirsize = max; ! 391: } ! 392: nmp->nm_flag |= NFSMNT_GOTFSINFO; ! 393: } ! 394: nfsm_reqdone; ! 395: return (error); ! 396: } ! 397: ! 398: /* ! 399: * Mount a remote root fs via. nfs. This depends on the info in the ! 400: * nfs_diskless structure that has been filled in properly by some primary ! 401: * bootstrap. ! 402: * It goes something like this: ! 403: * - do enough of "ifconfig" by calling ifioctl() so that the system ! 404: * can talk to the server ! 405: * - If nfs_diskless.mygateway is filled in, use that address as ! 406: * a default gateway. ! 407: * - hand craft the swap nfs vnode hanging off a fake mount point ! 408: * if swdevt[0].sw_dev == NODEV ! 409: * - build the rootfs mount point and call mountnfs() to do the rest. ! 410: */ ! 411: int ! 412: nfs_mountroot() ! 413: { ! 414: struct nfs_diskless nd; ! 415: struct vattr attr; ! 416: struct mount *mp; ! 417: struct vnode *vp; ! 418: struct proc *procp; ! 419: long n; ! 420: int error; ! 421: #if !defined(NO_MOUNT_PRIVATE) ! 422: struct mount *mppriv; ! 423: struct vnode *vppriv; ! 424: #endif /* NO_MOUNT_PRIVATE */ ! 425: ! 426: procp = current_proc(); /* XXX */ ! 427: ! 428: /* ! 429: * Call nfs_boot_init() to fill in the nfs_diskless struct. ! 430: * Side effect: Finds and configures a network interface. ! 431: */ ! 432: bzero((caddr_t) &nd, sizeof(nd)); ! 433: nfs_boot_init(&nd, procp); ! 434: ! 435: /* ! 436: * Create the root mount point. ! 437: */ ! 438: #if !defined(NO_MOUNT_PRIVATE) ! 439: if ((error = nfs_mount_diskless(&nd.nd_root, "/", MNT_RDONLY, &vp, &mp))) { ! 440: #else ! 441: if (error = nfs_mount_diskless(&nd.nd_root, "/", NULL, &vp, &mp)) { ! 442: #endif /* NO_MOUNT_PRIVATE */ ! 443: return(error); ! 444: } ! 445: printf("root on %s\n", (char *)&nd.nd_root.ndm_host); ! 446: ! 447: simple_lock(&mountlist_slock); ! 448: CIRCLEQ_INSERT_TAIL(&mountlist, mp, mnt_list); ! 449: simple_unlock(&mountlist_slock); ! 450: vfs_unbusy(mp, procp); ! 451: rootvp = vp; ! 452: ! 453: #if !defined(NO_MOUNT_PRIVATE) ! 454: if ((error = nfs_mount_diskless_private(&nd.nd_private, "/private", ! 455: NULL, &vppriv, &mppriv))) { ! 456: return(error); ! 457: } ! 458: printf("private on %s\n", (char *)&nd.nd_private.ndm_host); ! 459: ! 460: simple_lock(&mountlist_slock); ! 461: CIRCLEQ_INSERT_TAIL(&mountlist, mppriv, mnt_list); ! 462: simple_unlock(&mountlist_slock); ! 463: vfs_unbusy(mppriv, procp); ! 464: ! 465: #endif /* NO_MOUNT_PRIVATE */ ! 466: ! 467: /* Get root attributes (for the time). */ ! 468: error = VOP_GETATTR(vp, &attr, procp->p_ucred, procp); ! 469: if (error) panic("nfs_mountroot: getattr for root"); ! 470: n = attr.va_mtime.tv_sec; ! 471: inittodr(n); ! 472: return (0); ! 473: } ! 474: ! 475: /* ! 476: * Internal version of mount system call for diskless setup. ! 477: */ ! 478: static int ! 479: nfs_mount_diskless(ndmntp, mntname, mntflag, vpp, mpp) ! 480: struct nfs_dlmount *ndmntp; ! 481: char *mntname; ! 482: int mntflag; ! 483: struct vnode **vpp; ! 484: struct mount **mpp; ! 485: { ! 486: struct nfs_args args; ! 487: struct mount *mp; ! 488: struct mbuf *m; ! 489: int error; ! 490: struct proc *procp; ! 491: ! 492: procp = current_proc(); /* XXX */ ! 493: ! 494: if ((error = vfs_rootmountalloc("nfs", ndmntp->ndm_host, &mp))) { ! 495: printf("nfs_mountroot: NFS not configured"); ! 496: return (error); ! 497: } ! 498: mp->mnt_flag = mntflag; ! 499: ! 500: /* Initialize mount args. */ ! 501: bzero((caddr_t) &args, sizeof(args)); ! 502: args.addr = (struct sockaddr *)&ndmntp->ndm_saddr; ! 503: args.addrlen = args.addr->sa_len; ! 504: args.sotype = SOCK_DGRAM; ! 505: args.fh = ndmntp->ndm_fh; ! 506: args.fhsize = NFSX_V2FH; ! 507: args.hostname = ndmntp->ndm_host; ! 508: args.flags = NFSMNT_RESVPORT; ! 509: ! 510: MGET(m, M_DONTWAIT, MT_SONAME); ! 511: bcopy((caddr_t)args.addr, mtod(m, caddr_t), ! 512: (m->m_len = args.addr->sa_len)); ! 513: if ((error = mountnfs(&args, mp, m, mntname, args.hostname, vpp))) { ! 514: printf("nfs_mountroot: mount %s failed: %d", mntname, error); ! 515: mp->mnt_vfc->vfc_refcount--; ! 516: vfs_unbusy(mp, procp); ! 517: _FREE_ZONE(mp, sizeof (struct mount), M_MOUNT); ! 518: return (error); ! 519: } ! 520: #if 0 /* Causes incorrect reporting of "mounted on" */ ! 521: (void) copystr(args.hostname, mp->mnt_stat.f_mntonname, MNAMELEN - 1, 0); ! 522: #endif /* 0 */ ! 523: *mpp = mp; ! 524: return (0); ! 525: } ! 526: ! 527: #if !defined(NO_MOUNT_PRIVATE) ! 528: /* ! 529: * Internal version of mount system call to mount "/private" ! 530: * separately in diskless setup ! 531: */ ! 532: static int ! 533: nfs_mount_diskless_private(ndmntp, mntname, mntflag, vpp, mpp) ! 534: struct nfs_dlmount *ndmntp; ! 535: char *mntname; ! 536: int mntflag; ! 537: struct vnode **vpp; ! 538: struct mount **mpp; ! 539: { ! 540: struct nfs_args args; ! 541: struct mount *mp; ! 542: struct mbuf *m; ! 543: int error; ! 544: struct proc *procp; ! 545: struct vfsconf *vfsp; ! 546: struct nameidata nd; ! 547: struct vnode *vp; ! 548: ! 549: procp = current_proc(); /* XXX */ ! 550: ! 551: { ! 552: /* ! 553: * mimic main()!. Temporarily set up rootvnode and other stuff so ! 554: * that namei works. Need to undo this because main() does it, too ! 555: */ ! 556: struct filedesc *fdp; /* pointer to file descriptor state */ ! 557: fdp = procp->p_fd; ! 558: mountlist.cqh_first->mnt_flag |= MNT_ROOTFS; ! 559: ! 560: /* Get the vnode for '/'. Set fdp->fd_cdir to reference it. */ ! 561: if (VFS_ROOT(mountlist.cqh_first, &rootvnode)) ! 562: panic("cannot find root vnode"); ! 563: fdp->fd_cdir = rootvnode; ! 564: VREF(fdp->fd_cdir); ! 565: VOP_UNLOCK(rootvnode, 0, procp); ! 566: fdp->fd_rdir = NULL; ! 567: } ! 568: ! 569: /* ! 570: * Get vnode to be covered ! 571: */ ! 572: NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, ! 573: mntname, procp); ! 574: if ((error = namei(&nd))) { ! 575: printf("nfs_mountroot: private namei failed!"); ! 576: return (error); ! 577: } ! 578: { ! 579: /* undo VREF in mimic main()! */ ! 580: vrele(rootvnode); ! 581: } ! 582: vp = nd.ni_vp; ! 583: if ((error = vinvalbuf(vp, V_SAVE, procp->p_ucred, procp, 0, 0))) { ! 584: vput(vp); ! 585: return (error); ! 586: } ! 587: if (vp->v_type != VDIR) { ! 588: vput(vp); ! 589: return (ENOTDIR); ! 590: } ! 591: for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next) ! 592: if (!strcmp(vfsp->vfc_name, "nfs")) ! 593: break; ! 594: if (vfsp == NULL) { ! 595: printf("nfs_mountroot: private NFS not configured"); ! 596: vput(vp); ! 597: return (ENODEV); ! 598: } ! 599: if (vp->v_mountedhere != NULL) { ! 600: vput(vp); ! 601: return (EBUSY); ! 602: } ! 603: ! 604: /* ! 605: * Allocate and initialize the filesystem. ! 606: */ ! 607: mp = _MALLOC_ZONE((u_long)sizeof(struct mount), M_MOUNT, M_WAITOK); ! 608: lockinit(&mp->mnt_lock, PVFS, "vfslock", 0, 0); ! 609: (void)vfs_busy(mp, LK_NOWAIT, 0, procp); ! 610: LIST_INIT(&mp->mnt_vnodelist); ! 611: mp->mnt_op = vfsp->vfc_vfsops; ! 612: mp->mnt_vfc = vfsp; ! 613: vfsp->vfc_refcount++; ! 614: mp->mnt_stat.f_type = vfsp->vfc_typenum; ! 615: mp->mnt_flag = mntflag; ! 616: mp->mnt_flag |= vfsp->vfc_flags & MNT_VISFLAGMASK; ! 617: strncpy(mp->mnt_stat.f_fstypename, vfsp->vfc_name, MFSNAMELEN); ! 618: vp->v_mountedhere = mp; ! 619: mp->mnt_vnodecovered = vp; ! 620: mp->mnt_stat.f_owner = procp->p_ucred->cr_uid; ! 621: (void) copystr(mntname, mp->mnt_stat.f_mntonname, MNAMELEN - 1, 0); ! 622: (void) copystr(ndmntp->ndm_host, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, 0); ! 623: ! 624: /* Initialize mount args. */ ! 625: bzero((caddr_t) &args, sizeof(args)); ! 626: args.addr = (struct sockaddr *)&ndmntp->ndm_saddr; ! 627: args.addrlen = args.addr->sa_len; ! 628: args.sotype = SOCK_DGRAM; ! 629: args.fh = ndmntp->ndm_fh; ! 630: args.fhsize = NFSX_V2FH; ! 631: args.hostname = ndmntp->ndm_host; ! 632: args.flags = NFSMNT_RESVPORT; ! 633: ! 634: MGET(m, M_DONTWAIT, MT_SONAME); ! 635: bcopy((caddr_t)args.addr, mtod(m, caddr_t), ! 636: (m->m_len = args.addr->sa_len)); ! 637: if ((error = mountnfs(&args, mp, m, mntname, args.hostname, &vp))) { ! 638: printf("nfs_mountroot: mount %s failed: %d", mntname, error); ! 639: mp->mnt_vfc->vfc_refcount--; ! 640: vfs_unbusy(mp, procp); ! 641: _FREE_ZONE(mp, sizeof (struct mount), M_MOUNT); ! 642: return (error); ! 643: } ! 644: ! 645: *mpp = mp; ! 646: *vpp = vp; ! 647: return (0); ! 648: } ! 649: #endif /* NO_MOUNT_PRIVATE */ ! 650: ! 651: /* ! 652: * VFS Operations. ! 653: * ! 654: * mount system call ! 655: * It seems a bit dumb to copyinstr() the host and path here and then ! 656: * bcopy() them in mountnfs(), but I wanted to detect errors before ! 657: * doing the sockargs() call because sockargs() allocates an mbuf and ! 658: * an error after that means that I have to release the mbuf. ! 659: */ ! 660: /* ARGSUSED */ ! 661: static int ! 662: nfs_mount(mp, path, data, ndp, p) ! 663: struct mount *mp; ! 664: char *path; ! 665: caddr_t data; ! 666: struct nameidata *ndp; ! 667: struct proc *p; ! 668: { ! 669: int error; ! 670: struct nfs_args args; ! 671: struct mbuf *nam; ! 672: struct vnode *vp; ! 673: char pth[MNAMELEN], hst[MNAMELEN]; ! 674: u_int len; ! 675: u_char nfh[NFSX_V3FHMAX]; ! 676: ! 677: error = copyin(data, (caddr_t)&args, sizeof (struct nfs_args)); ! 678: if (error) ! 679: return (error); ! 680: if (args.version != NFS_ARGSVERSION) { ! 681: #ifndef NO_COMPAT_PRELITE2 ! 682: /* ! 683: * If the argument version is unknown, then assume the ! 684: * caller is a pre-lite2 4.4BSD client and convert its ! 685: * arguments. ! 686: */ ! 687: struct onfs_args oargs; ! 688: error = copyin(data, (caddr_t)&oargs, sizeof (struct onfs_args)); ! 689: if (error) ! 690: return (error); ! 691: nfs_convert_oargs(&args,&oargs); ! 692: #else /* NO_COMPAT_PRELITE2 */ ! 693: return (EPROGMISMATCH); ! 694: #endif /* !NO_COMPAT_PRELITE2 */ ! 695: } ! 696: if (args.fhsize > NFSX_V3FHMAX) ! 697: return (EINVAL); ! 698: error = copyin((caddr_t)args.fh, (caddr_t)nfh, args.fhsize); ! 699: if (error) ! 700: return (error); ! 701: error = copyinstr(path, pth, MNAMELEN-1, &len); ! 702: if (error) ! 703: return (error); ! 704: bzero(&pth[len], MNAMELEN - len); ! 705: error = copyinstr(args.hostname, hst, MNAMELEN-1, &len); ! 706: if (error) ! 707: return (error); ! 708: bzero(&hst[len], MNAMELEN - len); ! 709: /* sockargs() call must be after above copyin() calls */ ! 710: error = sockargs(&nam, (caddr_t)args.addr, args.addrlen, MT_SONAME); ! 711: if (error) ! 712: return (error); ! 713: args.fh = nfh; ! 714: error = mountnfs(&args, mp, nam, pth, hst, &vp); ! 715: return (error); ! 716: } ! 717: ! 718: /* ! 719: * Common code for mount and mountroot ! 720: */ ! 721: static int ! 722: mountnfs(argp, mp, nam, pth, hst, vpp) ! 723: register struct nfs_args *argp; ! 724: register struct mount *mp; ! 725: struct mbuf *nam; ! 726: char *pth, *hst; ! 727: struct vnode **vpp; ! 728: { ! 729: register struct nfsmount *nmp; ! 730: struct nfsnode *np; ! 731: int error, maxio; ! 732: struct vattr attrs; ! 733: struct proc *curproc; ! 734: ! 735: if (mp->mnt_flag & MNT_UPDATE) { ! 736: nmp = VFSTONFS(mp); ! 737: /* update paths, file handles, etc, here XXX */ ! 738: m_freem(nam); ! 739: return (0); ! 740: } else { ! 741: MALLOC_ZONE(nmp, struct nfsmount *, ! 742: sizeof (struct nfsmount), M_NFSMNT, M_WAITOK); ! 743: bzero((caddr_t)nmp, sizeof (struct nfsmount)); ! 744: TAILQ_INIT(&nmp->nm_uidlruhead); ! 745: TAILQ_INIT(&nmp->nm_bufq); ! 746: mp->mnt_data = (qaddr_t)nmp; ! 747: } ! 748: vfs_getnewfsid(mp); ! 749: nmp->nm_mountp = mp; ! 750: nmp->nm_flag = argp->flags; ! 751: if (nmp->nm_flag & NFSMNT_NQNFS) ! 752: /* ! 753: * We have to set mnt_maxsymlink to a non-zero value so ! 754: * that COMPAT_43 routines will know that we are setting ! 755: * the d_type field in directories (and can zero it for ! 756: * unsuspecting binaries). ! 757: */ ! 758: mp->mnt_maxsymlinklen = 1; ! 759: nmp->nm_timeo = NFS_TIMEO; ! 760: nmp->nm_retry = NFS_RETRANS; ! 761: nmp->nm_wsize = NFS_WSIZE; ! 762: nmp->nm_rsize = NFS_RSIZE; ! 763: nmp->nm_readdirsize = NFS_READDIRSIZE; ! 764: nmp->nm_numgrps = NFS_MAXGRPS; ! 765: nmp->nm_readahead = NFS_DEFRAHEAD; ! 766: nmp->nm_leaseterm = NQ_DEFLEASE; ! 767: nmp->nm_deadthresh = NQ_DEADTHRESH; ! 768: CIRCLEQ_INIT(&nmp->nm_timerhead); ! 769: nmp->nm_inprog = NULLVP; ! 770: nmp->nm_fhsize = argp->fhsize; ! 771: bcopy((caddr_t)argp->fh, (caddr_t)nmp->nm_fh, argp->fhsize); ! 772: bcopy(hst, mp->mnt_stat.f_mntfromname, MNAMELEN); ! 773: bcopy(pth, mp->mnt_stat.f_mntonname, MNAMELEN); ! 774: nmp->nm_nam = nam; ! 775: ! 776: /* ! 777: * Silently clear NFSMNT_NOCONN if it's a TCP mount, it makes ! 778: * no sense in that context. ! 779: */ ! 780: if (argp->sotype == SOCK_STREAM) ! 781: argp->flags &= ~NFSMNT_NOCONN; ! 782: ! 783: if ((argp->flags & NFSMNT_TIMEO) && argp->timeo > 0) { ! 784: nmp->nm_timeo = (argp->timeo * NFS_HZ + 5) / 10; ! 785: if (nmp->nm_timeo < NFS_MINTIMEO) ! 786: nmp->nm_timeo = NFS_MINTIMEO; ! 787: else if (nmp->nm_timeo > NFS_MAXTIMEO) ! 788: nmp->nm_timeo = NFS_MAXTIMEO; ! 789: } ! 790: ! 791: if ((argp->flags & NFSMNT_RETRANS) && argp->retrans > 1) { ! 792: nmp->nm_retry = argp->retrans; ! 793: if (nmp->nm_retry > NFS_MAXREXMIT) ! 794: nmp->nm_retry = NFS_MAXREXMIT; ! 795: } ! 796: ! 797: if (argp->flags & NFSMNT_NFSV3) { ! 798: if (argp->sotype == SOCK_DGRAM) ! 799: maxio = NFS_MAXDGRAMDATA; ! 800: else ! 801: maxio = NFS_MAXDATA; ! 802: } else ! 803: maxio = NFS_V2MAXDATA; ! 804: ! 805: if ((argp->flags & NFSMNT_WSIZE) && argp->wsize > 0) { ! 806: nmp->nm_wsize = argp->wsize; ! 807: /* Round down to multiple of blocksize */ ! 808: nmp->nm_wsize &= ~(NFS_FABLKSIZE - 1); ! 809: if (nmp->nm_wsize <= 0) ! 810: nmp->nm_wsize = NFS_FABLKSIZE; ! 811: } ! 812: if (nmp->nm_wsize > maxio) ! 813: nmp->nm_wsize = maxio; ! 814: if (nmp->nm_wsize > MAXBSIZE) ! 815: nmp->nm_wsize = MAXBSIZE; ! 816: ! 817: if ((argp->flags & NFSMNT_RSIZE) && argp->rsize > 0) { ! 818: nmp->nm_rsize = argp->rsize; ! 819: /* Round down to multiple of blocksize */ ! 820: nmp->nm_rsize &= ~(NFS_FABLKSIZE - 1); ! 821: if (nmp->nm_rsize <= 0) ! 822: nmp->nm_rsize = NFS_FABLKSIZE; ! 823: } ! 824: if (nmp->nm_rsize > maxio) ! 825: nmp->nm_rsize = maxio; ! 826: if (nmp->nm_rsize > MAXBSIZE) ! 827: nmp->nm_rsize = MAXBSIZE; ! 828: ! 829: if ((argp->flags & NFSMNT_READDIRSIZE) && argp->readdirsize > 0) { ! 830: nmp->nm_readdirsize = argp->readdirsize; ! 831: } ! 832: if (nmp->nm_readdirsize > maxio) ! 833: nmp->nm_readdirsize = maxio; ! 834: if (nmp->nm_readdirsize > nmp->nm_rsize) ! 835: nmp->nm_readdirsize = nmp->nm_rsize; ! 836: ! 837: if ((argp->flags & NFSMNT_MAXGRPS) && argp->maxgrouplist >= 0 && ! 838: argp->maxgrouplist <= NFS_MAXGRPS) ! 839: nmp->nm_numgrps = argp->maxgrouplist; ! 840: if ((argp->flags & NFSMNT_READAHEAD) && argp->readahead >= 0 && ! 841: argp->readahead <= NFS_MAXRAHEAD) ! 842: nmp->nm_readahead = argp->readahead; ! 843: if ((argp->flags & NFSMNT_LEASETERM) && argp->leaseterm >= 2 && ! 844: argp->leaseterm <= NQ_MAXLEASE) ! 845: nmp->nm_leaseterm = argp->leaseterm; ! 846: if ((argp->flags & NFSMNT_DEADTHRESH) && argp->deadthresh >= 1 && ! 847: argp->deadthresh <= NQ_NEVERDEAD) ! 848: nmp->nm_deadthresh = argp->deadthresh; ! 849: /* Set up the sockets and per-host congestion */ ! 850: nmp->nm_sotype = argp->sotype; ! 851: nmp->nm_soproto = argp->proto; ! 852: ! 853: /* ! 854: * For Connection based sockets (TCP,...) defer the connect until ! 855: * the first request, in case the server is not responding. ! 856: */ ! 857: if (nmp->nm_sotype == SOCK_DGRAM && ! 858: (error = nfs_connect(nmp, (struct nfsreq *)0))) ! 859: goto bad; ! 860: ! 861: /* ! 862: * This is silly, but it has to be set so that vinifod() works. ! 863: * We do not want to do an nfs_statfs() here since we can get ! 864: * stuck on a dead server and we are holding a lock on the mount ! 865: * point. ! 866: */ ! 867: mp->mnt_stat.f_iosize = nfs_iosize(nmp); ! 868: /* ! 869: * A reference count is needed on the nfsnode representing the ! 870: * remote root. If this object is not persistent, then backward ! 871: * traversals of the mount point (i.e. "..") will not work if ! 872: * the nfsnode gets flushed out of the cache. Ufs does not have ! 873: * this problem, because one can identify root inodes by their ! 874: * number == ROOTINO (2). ! 875: */ ! 876: error = nfs_nget(mp, (nfsfh_t *)nmp->nm_fh, nmp->nm_fhsize, &np); ! 877: if (error) ! 878: goto bad; ! 879: *vpp = NFSTOV(np); ! 880: ! 881: /* ! 882: * Get file attributes for the mountpoint. This has the side ! 883: * effect of filling in (*vpp)->v_type with the correct value. ! 884: */ ! 885: curproc = current_proc(); ! 886: VOP_GETATTR(*vpp, &attrs, curproc->p_ucred, curproc); ! 887: ! 888: /* ! 889: * Lose the lock but keep the ref. ! 890: */ ! 891: VOP_UNLOCK(*vpp, 0, curproc); ! 892: ! 893: return (0); ! 894: bad: ! 895: nfs_disconnect(nmp); ! 896: _FREE_ZONE((caddr_t)nmp, sizeof (struct nfsmount), M_NFSMNT); ! 897: m_freem(nam); ! 898: return (error); ! 899: } ! 900: ! 901: /* ! 902: * unmount system call ! 903: */ ! 904: static int ! 905: nfs_unmount(mp, mntflags, p) ! 906: struct mount *mp; ! 907: int mntflags; ! 908: struct proc *p; ! 909: { ! 910: register struct nfsmount *nmp; ! 911: struct nfsnode *np; ! 912: struct vnode *vp; ! 913: int error, flags = 0; ! 914: ! 915: if (mntflags & MNT_FORCE) ! 916: flags |= FORCECLOSE; ! 917: nmp = VFSTONFS(mp); ! 918: /* ! 919: * Goes something like this.. ! 920: * - Check for activity on the root vnode (other than ourselves). ! 921: * - Call vflush() to clear out vnodes for this file system, ! 922: * except for the root vnode. ! 923: * - Decrement reference on the vnode representing remote root. ! 924: * - Close the socket ! 925: * - Free up the data structures ! 926: */ ! 927: /* ! 928: * We need to decrement the ref. count on the nfsnode representing ! 929: * the remote root. See comment in mountnfs(). The VFS unmount() ! 930: * has done vput on this vnode, otherwise we would get deadlock! ! 931: */ ! 932: error = nfs_nget(mp, (nfsfh_t *)nmp->nm_fh, nmp->nm_fhsize, &np); ! 933: if (error) ! 934: return(error); ! 935: vp = NFSTOV(np); ! 936: if (vp->v_usecount > 2) { ! 937: vput(vp); ! 938: return (EBUSY); ! 939: } ! 940: ! 941: /* ! 942: * Must handshake with nqnfs_clientd() if it is active. ! 943: */ ! 944: nmp->nm_flag |= NFSMNT_DISMINPROG; ! 945: while (nmp->nm_inprog != NULLVP) ! 946: (void) tsleep((caddr_t)&lbolt, PSOCK, "nfsdism", 0); ! 947: error = vflush(mp, vp, flags); ! 948: if (error) { ! 949: vput(vp); ! 950: nmp->nm_flag &= ~NFSMNT_DISMINPROG; ! 951: return (error); ! 952: } ! 953: ! 954: /* ! 955: * We are now committed to the unmount. ! 956: * For NQNFS, let the server daemon free the nfsmount structure. ! 957: */ ! 958: if (nmp->nm_flag & (NFSMNT_NQNFS | NFSMNT_KERB)) ! 959: nmp->nm_flag |= NFSMNT_DISMNT; ! 960: ! 961: /* ! 962: * There are two reference counts and one lock to get rid of here. ! 963: */ ! 964: vput(vp); ! 965: vrele(vp); ! 966: vgone(vp); ! 967: nfs_disconnect(nmp); ! 968: m_freem(nmp->nm_nam); ! 969: ! 970: if ((nmp->nm_flag & (NFSMNT_NQNFS | NFSMNT_KERB)) == 0) { ! 971: register struct nfsreq *rp; ! 972: /* ! 973: * Loop through outstanding request list and remove dangling ! 974: * references to defunct nfsmount struct ! 975: */ ! 976: for (rp = nfs_reqq.tqh_first; rp; rp = rp->r_chain.tqe_next) ! 977: if (rp->r_nmp == nmp) ! 978: rp->r_nmp = (struct nfsmount *)0; ! 979: _FREE_ZONE((caddr_t)nmp, sizeof (struct nfsmount), M_NFSMNT); ! 980: } ! 981: return (0); ! 982: } ! 983: ! 984: /* ! 985: * Return root of a filesystem ! 986: */ ! 987: static int ! 988: nfs_root(mp, vpp) ! 989: struct mount *mp; ! 990: struct vnode **vpp; ! 991: { ! 992: register struct vnode *vp; ! 993: struct nfsmount *nmp; ! 994: struct nfsnode *np; ! 995: int error; ! 996: ! 997: nmp = VFSTONFS(mp); ! 998: error = nfs_nget(mp, (nfsfh_t *)nmp->nm_fh, nmp->nm_fhsize, &np); ! 999: if (error) ! 1000: return (error); ! 1001: vp = NFSTOV(np); ! 1002: if (vp->v_type == VNON) ! 1003: vp->v_type = VDIR; ! 1004: vp->v_flag = VROOT; ! 1005: *vpp = vp; ! 1006: return (0); ! 1007: } ! 1008: ! 1009: extern int syncprt; ! 1010: ! 1011: /* ! 1012: * Flush out the buffer cache ! 1013: */ ! 1014: /* ARGSUSED */ ! 1015: static int ! 1016: nfs_sync(mp, waitfor, cred, p) ! 1017: struct mount *mp; ! 1018: int waitfor; ! 1019: struct ucred *cred; ! 1020: struct proc *p; ! 1021: { ! 1022: register struct vnode *vp; ! 1023: int error, allerror = 0; ! 1024: ! 1025: /* ! 1026: * Force stale buffer cache information to be flushed. ! 1027: */ ! 1028: loop: ! 1029: for (vp = mp->mnt_vnodelist.lh_first; ! 1030: vp != NULL; ! 1031: vp = vp->v_mntvnodes.le_next) { ! 1032: /* ! 1033: * If the vnode that we are about to sync is no longer ! 1034: * associated with this mount point, start over. ! 1035: */ ! 1036: if (vp->v_mount != mp) ! 1037: goto loop; ! 1038: if (VOP_ISLOCKED(vp) || vp->v_dirtyblkhd.lh_first == NULL) ! 1039: continue; ! 1040: if (vget(vp, LK_EXCLUSIVE, p)) ! 1041: goto loop; ! 1042: error = VOP_FSYNC(vp, cred, waitfor, p); ! 1043: if (error) ! 1044: allerror = error; ! 1045: vput(vp); ! 1046: } ! 1047: return (allerror); ! 1048: } ! 1049: ! 1050: /* ! 1051: * NFS flat namespace lookup. ! 1052: * Currently unsupported. ! 1053: */ ! 1054: /* ARGSUSED */ ! 1055: static int ! 1056: nfs_vget(mp, ino, vpp) ! 1057: struct mount *mp; ! 1058: ino_t ino; ! 1059: struct vnode **vpp; ! 1060: { ! 1061: ! 1062: return (EOPNOTSUPP); ! 1063: } ! 1064: ! 1065: /* ! 1066: * At this point, this should never happen ! 1067: */ ! 1068: /* ARGSUSED */ ! 1069: static int ! 1070: nfs_fhtovp(mp, fhp, nam, vpp, exflagsp, credanonp) ! 1071: register struct mount *mp; ! 1072: struct fid *fhp; ! 1073: struct mbuf *nam; ! 1074: struct vnode **vpp; ! 1075: int *exflagsp; ! 1076: struct ucred **credanonp; ! 1077: { ! 1078: ! 1079: return (EINVAL); ! 1080: } ! 1081: ! 1082: /* ! 1083: * Vnode pointer to File handle, should never happen either ! 1084: */ ! 1085: /* ARGSUSED */ ! 1086: static int ! 1087: nfs_vptofh(vp, fhp) ! 1088: struct vnode *vp; ! 1089: struct fid *fhp; ! 1090: { ! 1091: ! 1092: return (EINVAL); ! 1093: } ! 1094: ! 1095: /* ! 1096: * Vfs start routine, a no-op. ! 1097: */ ! 1098: /* ARGSUSED */ ! 1099: static int ! 1100: nfs_start(mp, flags, p) ! 1101: struct mount *mp; ! 1102: int flags; ! 1103: struct proc *p; ! 1104: { ! 1105: ! 1106: return (0); ! 1107: } ! 1108: ! 1109: /* ! 1110: * Do operations associated with quotas, not supported ! 1111: */ ! 1112: /* ARGSUSED */ ! 1113: static int ! 1114: nfs_quotactl(mp, cmd, uid, arg, p) ! 1115: struct mount *mp; ! 1116: int cmd; ! 1117: uid_t uid; ! 1118: caddr_t arg; ! 1119: struct proc *p; ! 1120: { ! 1121: ! 1122: return (EOPNOTSUPP); ! 1123: } ! 1124: ! 1125: /* ! 1126: * Do that sysctl thang... ! 1127: */ ! 1128: static int ! 1129: nfs_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp, ! 1130: size_t newlen, struct proc *p) ! 1131: { ! 1132: int rv; ! 1133: ! 1134: /* ! 1135: * All names at this level are terminal. ! 1136: */ ! 1137: if(namelen > 1) ! 1138: return ENOTDIR; /* overloaded */ ! 1139: ! 1140: switch(name[0]) { ! 1141: case NFS_NFSSTATS: ! 1142: if(!oldp) { ! 1143: *oldlenp = sizeof nfsstats; ! 1144: return 0; ! 1145: } ! 1146: ! 1147: if(*oldlenp < sizeof nfsstats) { ! 1148: *oldlenp = sizeof nfsstats; ! 1149: return ENOMEM; ! 1150: } ! 1151: ! 1152: rv = copyout(&nfsstats, oldp, sizeof nfsstats); ! 1153: if(rv) return rv; ! 1154: ! 1155: if(newp && newlen != sizeof nfsstats) ! 1156: return EINVAL; ! 1157: ! 1158: if(newp) { ! 1159: return copyin(newp, &nfsstats, sizeof nfsstats); ! 1160: } ! 1161: return 0; ! 1162: ! 1163: default: ! 1164: return EOPNOTSUPP; ! 1165: } ! 1166: } ! 1167:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.