/* * Copyright (c) 2000-2003 Apple Computer, Inc. All rights reserved. * * @APPLE_LICENSE_HEADER_START@ * * Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved. * * This file contains Original Code and/or Modifications of Original Code * as defined in and that are subject to the Apple Public Source License * Version 2.0 (the 'License'). You may not use this file except in * compliance with the License. Please obtain a copy of the License at * http://www.opensource.apple.com/apsl/ and read it before using this * file. * * The Original Code and all software distributed under the License are * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. * Please see the License for the specific language governing rights and * limitations under the License. * * @APPLE_LICENSE_HEADER_END@ */ /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */ /* * Copyright (c) 1989, 1993, 1995 * The Regents of the University of California. All rights reserved. * * This code is derived from software contributed to Berkeley by * Rick Macklem at The University of Guelph. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * @(#)nfs_vfsops.c 8.12 (Berkeley) 5/20/95 * FreeBSD-Id: nfs_vfsops.c,v 1.52 1997/11/12 05:42:21 julian Exp $ */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #if !defined(NO_MOUNT_PRIVATE) #include #endif /* NO_MOUNT_PRIVATE */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include extern int nfsx_mountroot __P((void)); extern int nfs_ticks; /* XXXMARIUS: name collision */ struct nfsstats nfsstats_nfsx; #define nfsstats nfsstats_nfsx /* XXX CSM 11/25/97 Upgrade sysctl.h someday */ #ifdef notyet SYSCTL_NODE(_vfs, MOUNT_NFS, nfs, CTLFLAG_RW, 0, "NFS filesystem"); SYSCTL_STRUCT(_vfs_nfs, NFS_NFSSTATS, nfsstats, CTLFLAG_RD, &nfsstats, nfsstats, ""); #endif #if NFSDIAG int nfs_debug; /* XXX CSM 11/25/97 Upgrade sysctl.h someday */ #ifdef notyet SYSCTL_INT(_vfs_nfs, OID_AUTO, debug, CTLFLAG_RW, &nfs_debug, 0, ""); #endif #endif SYSCTL_DECL(_vfs_generic_nfs); SYSCTL_NODE(_vfs_generic_nfs, OID_AUTO, client, CTLFLAG_RW, 0, "nfs client hinge"); /* how long NFS will wait before signalling vfs that it's down. */ static int nfs_tprintf_initial_delay = NFS_TPRINTF_INITIAL_DELAY; SYSCTL_INT(_vfs_generic_nfs_client, NFS_TPRINTF_INITIAL_DELAY, initialdowndelay, CTLFLAG_RW, &nfs_tprintf_initial_delay, 0, ""); /* how long between console messages "nfs server foo not responding" */ static int nfs_tprintf_delay = NFS_TPRINTF_DELAY; SYSCTL_INT(_vfs_generic_nfs_client, NFS_TPRINTF_DELAY, nextdowndelay, CTLFLAG_RW, &nfs_tprintf_delay, 0, ""); /* XXX CSM 11/25/97 Mysterious kernel.h ld crud */ #ifdef notyet VFS_SET(nfs_vfsops, nfs, MOUNT_NFS, VFCF_NETWORK); #endif void nfsargs_ntoh __P((struct nfs_args *)); /* XXXMARIUS: *mount*diskless* callbacks */ /* static int */ /* nfs_mount_diskless __P((struct nfs_dlmount *, char *, int, struct vnode **, */ /* struct mount **)); */ #if !defined(NO_MOUNT_PRIVATE) /* static int */ /* nfs_mount_diskless_private __P((struct nfs_dlmount *, char *, int, */ /* struct vnode **, struct mount **)); */ #endif /* NO_MOUNT_PRIVATE */ #if NFSDIAG int nfsreqqusers = 0; extern int nfsbtlen, nfsbtcpu, nfsbtthread, nfsbt[32]; #endif int nfsx_iosize(nmp) struct nfsmount* nmp; { int iosize; /* * Calculate the size used for io buffers. Use the larger * of the two sizes to minimise nfs requests but make sure * that it is at least one VM page to avoid wasting buffer * space and to allow easy mmapping of I/O buffers. * The read/write rpc calls handle the splitting up of * buffers into multiple requests if the buffer size is * larger than the I/O size. */ iosize = max(nmp->nm_rsize, nmp->nm_wsize); if (iosize < PAGE_SIZE) iosize = PAGE_SIZE; return (trunc_page_32(iosize)); } void nfsx_convert_oargs(args, oargs) struct nfs_args *args; struct onfs_args *oargs; { args->version = NFS_ARGSVERSION; args->addr = oargs->addr; args->addrlen = oargs->addrlen; args->sotype = oargs->sotype; args->proto = oargs->proto; args->fh = oargs->fh; args->fhsize = oargs->fhsize; args->flags = oargs->flags; args->wsize = oargs->wsize; args->rsize = oargs->rsize; args->readdirsize = oargs->readdirsize; args->timeo = oargs->timeo; args->retrans = oargs->retrans; args->maxgrouplist = oargs->maxgrouplist; args->readahead = oargs->readahead; args->leaseterm = oargs->leaseterm; args->deadthresh = oargs->deadthresh; args->hostname = oargs->hostname; } /* * Return root of a filesystem */ int nfsx_root(mp, vpp) struct mount *mp; struct vnode **vpp; { register struct vnode *vp; struct nfsmount *nmp; int error, vpid; nmp = VFSTONFS(mp); vp = nmp->nm_dvp; vpid = vp->v_id; while ((error = vget(vp, LK_EXCLUSIVE, current_proc()))) { /* vget may return ENOENT if the dir changes while in vget */ /* If that happens, try vget again, else return the error */ if ((error != ENOENT) || (vp->v_id == vpid)) return (error); vpid = vp->v_id; } if (vp->v_type == VNON) vp->v_type = VDIR; vp->v_flag |= VROOT; *vpp = vp; return (0); } extern int syncprt; /* * Flush out the buffer cache */ /* ARGSUSED */ int nfsx_sync(mp, waitfor, cred, p) struct mount *mp; int waitfor; struct ucred *cred; struct proc *p; { register struct vnode *vp; int error, allerror = 0; /* * Force stale buffer cache information to be flushed. */ loop: LIST_FOREACH(vp, &mp->mnt_vnodelist, v_mntvnodes) { int didhold; /* * If the vnode that we are about to sync is no longer * associated with this mount point, start over. */ if (vp->v_mount != mp) goto loop; if (VOP_ISLOCKED(vp) || LIST_FIRST(&VTONFS(vp)->n_dirtyblkhd) == NULL) continue; if (vget(vp, LK_EXCLUSIVE, p)) goto loop; didhold = ubc_hold(vp); error = VOP_FSYNC(vp, cred, waitfor, p); if (error) allerror = error; VOP_UNLOCK(vp, 0, p); if (didhold) ubc_rele(vp); vrele(vp); } return (allerror); } /* * NFS flat namespace lookup. * Currently unsupported. */ /* ARGSUSED */ int nfsx_vget(mp, ino, vpp) struct mount *mp; void *ino; /* XXX void* or ino_t? */ struct vnode **vpp; { return (EOPNOTSUPP); } /* * At this point, this should never happen */ /* ARGSUSED */ int nfsx_fhtovp(mp, fhp, nam, vpp, exflagsp, credanonp) register struct mount *mp; struct fid *fhp; struct mbuf *nam; struct vnode **vpp; int *exflagsp; struct ucred **credanonp; { return (EINVAL); } /* * Vnode pointer to File handle, should never happen either */ /* ARGSUSED */ int nfsx_vptofh(vp, fhp) struct vnode *vp; struct fid *fhp; { return (EINVAL); } /* * Vfs start routine, a no-op. */ /* ARGSUSED */ int nfsx_start(mp, flags, p) struct mount *mp; int flags; struct proc *p; { return (0); } /* * Do operations associated with quotas, not supported */ /* ARGSUSED */ int nfsx_quotactl(mp, cmd, uid, arg, p) struct mount *mp; int cmd; uid_t uid; caddr_t arg; struct proc *p; { return (EOPNOTSUPP); } /* * Do that sysctl thang... */ int nfsx_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp, size_t newlen, struct proc *p) { int error; struct sysctl_req *req; struct vfsidctl vc; struct mount *mp; struct nfsmount *nmp; struct vfsquery vq; /* * All names at this level are terminal. */ if(namelen > 1) return ENOTDIR; /* overloaded */ /* common code for "new style" VFS_CTL sysctl, get the mount. */ switch (name[0]) { case VFS_CTL_TIMEO: case VFS_CTL_QUERY: req = oldp; error = SYSCTL_IN(req, &vc, sizeof(vc)); if (error) return (error); mp = vfs_getvfs(&vc.vc_fsid); if (mp == NULL) return (ENOENT); nmp = VFSTONFS(mp); if (nmp == NULL) return (ENOENT); bzero(&vq, sizeof(vq)); VCTLTOREQ(&vc, req); } switch(name[0]) { case NFS_NFSSTATS: if(!oldp) { *oldlenp = sizeof nfsstats; return 0; } if(*oldlenp < sizeof nfsstats) { *oldlenp = sizeof nfsstats; return ENOMEM; } error = copyout(&nfsstats, oldp, sizeof nfsstats); if (error) return (error); if(newp && newlen != sizeof nfsstats) return EINVAL; if(newp) { return copyin(newp, &nfsstats, sizeof nfsstats); } return 0; case VFS_CTL_QUERY: if ((nmp->nm_state & NFSSTA_TIMEO)) vq.vq_flags |= VQ_NOTRESP; error = SYSCTL_OUT(req, &vq, sizeof(vq)); break; case VFS_CTL_TIMEO: if (req->oldptr != NULL) { error = SYSCTL_OUT(req, &nmp->nm_tprintf_initial_delay, sizeof(nmp->nm_tprintf_initial_delay)); if (error) return (error); } if (req->newptr != NULL) { error = SYSCTL_IN(req, &nmp->nm_tprintf_initial_delay, sizeof(nmp->nm_tprintf_initial_delay)); if (error) return (error); if (nmp->nm_tprintf_initial_delay < 0) nmp->nm_tprintf_initial_delay = 0; } break; default: return (ENOTSUP); } return (error); }