X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/316670eb35587141e969394ae8537d66b9211e80..eb6b6ca394357805f2bdba989abae309f718b4d8:/bsd/nfs/nfs_vfsops.c diff --git a/bsd/nfs/nfs_vfsops.c b/bsd/nfs/nfs_vfsops.c index 1c571a21f..ef5457410 100644 --- a/bsd/nfs/nfs_vfsops.c +++ b/bsd/nfs/nfs_vfsops.c @@ -1,8 +1,8 @@ /* - * Copyright (c) 2000-2011 Apple Inc. All rights reserved. + * Copyright (c) 2000-2019 Apple Inc. All rights reserved. * * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ - * + * * 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 @@ -11,10 +11,10 @@ * unlawful or unlicensed copies of an Apple operating system, or to * circumvent, violate, or enable the circumvention or violation of, any * terms of an Apple operating system software license agreement. - * + * * 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, @@ -22,7 +22,7 @@ * 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_OSREFERENCE_LICENSE_HEADER_END@ */ /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */ @@ -64,6 +64,10 @@ * @(#)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 +#if CONFIG_NFS_CLIENT + /* * NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce * support for mandatory and extensible security protections. This notice @@ -85,6 +89,7 @@ #include #include #include +#include #include #include #include @@ -119,6 +124,8 @@ #include +#define NFS_VFS_DBG(...) NFS_DBG(NFS_FAC_VFS, 7, ## __VA_ARGS__) + /* * NFS client globals */ @@ -138,7 +145,7 @@ lck_mtx_t *nfs_request_mutex; thread_call_t nfs_request_timer_call; int nfs_request_timer_on; u_int32_t nfs_xid = 0; -u_int32_t nfs_xidwrap = 0; /* to build a (non-wrapping) 64 bit xid */ +u_int32_t nfs_xidwrap = 0; /* to build a (non-wrapping) 64 bit xid */ thread_call_t nfs_buf_timer_call; @@ -148,6 +155,7 @@ uint32_t nfs_open_owner_seqnum = 0; uint32_t nfs_lock_owner_seqnum = 0; thread_call_t nfs4_callback_timer_call; int nfs4_callback_timer_on = 0; +char nfs4_default_domain[MAXPATHLEN]; /* nfsiod */ lck_grp_t *nfsiod_lck_grp; @@ -174,53 +182,49 @@ int nfs_tprintf_initial_delay = NFS_TPRINTF_INITIAL_DELAY; int nfs_tprintf_delay = NFS_TPRINTF_DELAY; -int mountnfs(char *, mount_t, vfs_context_t, vnode_t *); -static int nfs_mount_diskless(struct nfs_dlmount *, const char *, int, vnode_t *, mount_t *, vfs_context_t); +int mountnfs(char *, mount_t, vfs_context_t, vnode_t *); +#if CONFIG_NETBOOT +static int nfs_mount_diskless(struct nfs_dlmount *, const char *, int, vnode_t *, mount_t *, vfs_context_t); #if !defined(NO_MOUNT_PRIVATE) -static int nfs_mount_diskless_private(struct nfs_dlmount *, const char *, int, vnode_t *, mount_t *, vfs_context_t); +static int nfs_mount_diskless_private(struct nfs_dlmount *, const char *, int, vnode_t *, mount_t *, vfs_context_t); #endif /* NO_MOUNT_PRIVATE */ -int nfs_mount_connect(struct nfsmount *); -void nfs_mount_cleanup(struct nfsmount *); -int nfs_mountinfo_assemble(struct nfsmount *, struct xdrbuf *); -int nfs4_mount_update_path_with_symlink(struct nfsmount *, struct nfs_fs_path *, uint32_t, fhandle_t *, int *, fhandle_t *, vfs_context_t); +#endif +int nfs_mount_connect(struct nfsmount *); +void nfs_mount_drain_and_cleanup(struct nfsmount *); +void nfs_mount_cleanup(struct nfsmount *); +int nfs_mountinfo_assemble(struct nfsmount *, struct xdrbuf *); +int nfs4_mount_update_path_with_symlink(struct nfsmount *, struct nfs_fs_path *, uint32_t, fhandle_t *, int *, fhandle_t *, vfs_context_t); /* * NFS VFS operations. */ -int nfs_vfs_mount(mount_t, vnode_t, user_addr_t, vfs_context_t); -int nfs_vfs_start(mount_t, int, vfs_context_t); -int nfs_vfs_unmount(mount_t, int, vfs_context_t); -int nfs_vfs_root(mount_t, vnode_t *, vfs_context_t); -int nfs_vfs_quotactl(mount_t, int, uid_t, caddr_t, vfs_context_t); -int nfs_vfs_getattr(mount_t, struct vfs_attr *, vfs_context_t); -int nfs_vfs_sync(mount_t, int, vfs_context_t); -int nfs_vfs_vget(mount_t, ino64_t, vnode_t *, vfs_context_t); -int nfs_vfs_vptofh(vnode_t, int *, unsigned char *, vfs_context_t); -int nfs_vfs_fhtovp(mount_t, int, unsigned char *, vnode_t *, vfs_context_t); -int nfs_vfs_init(struct vfsconf *); -int nfs_vfs_sysctl(int *, u_int, user_addr_t, size_t *, user_addr_t, size_t, vfs_context_t); - -struct vfsops nfs_vfsops = { - nfs_vfs_mount, - nfs_vfs_start, - nfs_vfs_unmount, - nfs_vfs_root, - nfs_vfs_quotactl, - nfs_vfs_getattr, - nfs_vfs_sync, - nfs_vfs_vget, - nfs_vfs_fhtovp, - nfs_vfs_vptofh, - nfs_vfs_init, - nfs_vfs_sysctl, - NULL, /* setattr */ - { NULL, /* reserved */ - NULL, /* reserved */ - NULL, /* reserved */ - NULL, /* reserved */ - NULL, /* reserved */ - NULL, /* reserved */ - NULL } /* reserved */ +int nfs_vfs_mount(mount_t, vnode_t, user_addr_t, vfs_context_t); +int nfs_vfs_start(mount_t, int, vfs_context_t); +int nfs_vfs_unmount(mount_t, int, vfs_context_t); +int nfs_vfs_root(mount_t, vnode_t *, vfs_context_t); +int nfs_vfs_quotactl(mount_t, int, uid_t, caddr_t, vfs_context_t); +int nfs_vfs_getattr(mount_t, struct vfs_attr *, vfs_context_t); +int nfs_vfs_sync(mount_t, int, vfs_context_t); +int nfs_vfs_vget(mount_t, ino64_t, vnode_t *, vfs_context_t); +int nfs_vfs_vptofh(vnode_t, int *, unsigned char *, vfs_context_t); +int nfs_vfs_fhtovp(mount_t, int, unsigned char *, vnode_t *, vfs_context_t); +int nfs_vfs_init(struct vfsconf *); +int nfs_vfs_sysctl(int *, u_int, user_addr_t, size_t *, user_addr_t, size_t, vfs_context_t); + +const struct vfsops nfs_vfsops = { + .vfs_mount = nfs_vfs_mount, + .vfs_start = nfs_vfs_start, + .vfs_unmount = nfs_vfs_unmount, + .vfs_root = nfs_vfs_root, + .vfs_quotactl = nfs_vfs_quotactl, + .vfs_getattr = nfs_vfs_getattr, + .vfs_sync = nfs_vfs_sync, + .vfs_vget = nfs_vfs_vget, + .vfs_fhtovp = nfs_vfs_fhtovp, + .vfs_vptofh = nfs_vfs_vptofh, + .vfs_init = nfs_vfs_init, + .vfs_sysctl = nfs_vfs_sysctl, + // We do not support the remaining VFS ops }; @@ -233,55 +237,57 @@ int nfs3_fsinfo(struct nfsmount *, nfsnode_t, vfs_context_t); int nfs3_update_statfs(struct nfsmount *, vfs_context_t); int nfs4_update_statfs(struct nfsmount *, vfs_context_t); #if !QUOTA -#define nfs3_getquota NULL -#define nfs4_getquota NULL +#define nfs3_getquota NULL +#define nfs4_getquota NULL #else int nfs3_getquota(struct nfsmount *, vfs_context_t, uid_t, int, struct dqblk *); int nfs4_getquota(struct nfsmount *, vfs_context_t, uid_t, int, struct dqblk *); #endif -struct nfs_funcs nfs3_funcs = { - nfs3_mount, - nfs3_update_statfs, - nfs3_getquota, - nfs3_access_rpc, - nfs3_getattr_rpc, - nfs3_setattr_rpc, - nfs3_read_rpc_async, - nfs3_read_rpc_async_finish, - nfs3_readlink_rpc, - nfs3_write_rpc_async, - nfs3_write_rpc_async_finish, - nfs3_commit_rpc, - nfs3_lookup_rpc_async, - nfs3_lookup_rpc_async_finish, - nfs3_remove_rpc, - nfs3_rename_rpc, - nfs3_setlock_rpc, - nfs3_unlock_rpc, - nfs3_getlock_rpc - }; -struct nfs_funcs nfs4_funcs = { - nfs4_mount, - nfs4_update_statfs, - nfs4_getquota, - nfs4_access_rpc, - nfs4_getattr_rpc, - nfs4_setattr_rpc, - nfs4_read_rpc_async, - nfs4_read_rpc_async_finish, - nfs4_readlink_rpc, - nfs4_write_rpc_async, - nfs4_write_rpc_async_finish, - nfs4_commit_rpc, - nfs4_lookup_rpc_async, - nfs4_lookup_rpc_async_finish, - nfs4_remove_rpc, - nfs4_rename_rpc, - nfs4_setlock_rpc, - nfs4_unlock_rpc, - nfs4_getlock_rpc - }; +const struct nfs_funcs nfs3_funcs = { + .nf_mount = nfs3_mount, + .nf_update_statfs = nfs3_update_statfs, + .nf_getquota = nfs3_getquota, + .nf_access_rpc = nfs3_access_rpc, + .nf_getattr_rpc = nfs3_getattr_rpc, + .nf_setattr_rpc = nfs3_setattr_rpc, + .nf_read_rpc_async = nfs3_read_rpc_async, + .nf_read_rpc_async_finish = nfs3_read_rpc_async_finish, + .nf_readlink_rpc = nfs3_readlink_rpc, + .nf_write_rpc_async = nfs3_write_rpc_async, + .nf_write_rpc_async_finish = nfs3_write_rpc_async_finish, + .nf_commit_rpc = nfs3_commit_rpc, + .nf_lookup_rpc_async = nfs3_lookup_rpc_async, + .nf_lookup_rpc_async_finish = nfs3_lookup_rpc_async_finish, + .nf_remove_rpc = nfs3_remove_rpc, + .nf_rename_rpc = nfs3_rename_rpc, + .nf_setlock_rpc = nfs3_setlock_rpc, + .nf_unlock_rpc = nfs3_unlock_rpc, + .nf_getlock_rpc = nfs3_getlock_rpc +}; +#if CONFIG_NFS4 +const struct nfs_funcs nfs4_funcs = { + .nf_mount = nfs4_mount, + .nf_update_statfs = nfs4_update_statfs, + .nf_getquota = nfs4_getquota, + .nf_access_rpc = nfs4_access_rpc, + .nf_getattr_rpc = nfs4_getattr_rpc, + .nf_setattr_rpc = nfs4_setattr_rpc, + .nf_read_rpc_async = nfs4_read_rpc_async, + .nf_read_rpc_async_finish = nfs4_read_rpc_async_finish, + .nf_readlink_rpc = nfs4_readlink_rpc, + .nf_write_rpc_async = nfs4_write_rpc_async, + .nf_write_rpc_async_finish = nfs4_write_rpc_async_finish, + .nf_commit_rpc = nfs4_commit_rpc, + .nf_lookup_rpc_async = nfs4_lookup_rpc_async, + .nf_lookup_rpc_async_finish = nfs4_lookup_rpc_async_finish, + .nf_remove_rpc = nfs4_remove_rpc, + .nf_rename_rpc = nfs4_rename_rpc, + .nf_setlock_rpc = nfs4_setlock_rpc, + .nf_unlock_rpc = nfs4_unlock_rpc, + .nf_getlock_rpc = nfs4_getlock_rpc +}; +#endif /* * Called once to initialize data structures... @@ -289,21 +295,24 @@ struct nfs_funcs nfs4_funcs = { int nfs_vfs_init(__unused struct vfsconf *vfsp) { +#if CONFIG_NFS4 int i; - +#endif /* * Check to see if major data structures haven't bloated. */ - if (sizeof (struct nfsnode) > NFS_NODEALLOC) { + if (sizeof(struct nfsnode) > NFS_NODEALLOC) { printf("struct nfsnode bloated (> %dbytes)\n", NFS_NODEALLOC); printf("Try reducing NFS_SMALLFH\n"); } - if (sizeof (struct nfsmount) > NFS_MNTALLOC) + if (sizeof(struct nfsmount) > NFS_MNTALLOC) { printf("struct nfsmount bloated (> %dbytes)\n", NFS_MNTALLOC); + } nfs_ticks = (hz * NFS_TICKINTVL + 500) / 1000; - if (nfs_ticks < 1) + if (nfs_ticks < 1) { nfs_ticks = 1; + } /* init async I/O thread pool state */ TAILQ_INIT(&nfsiodfree); @@ -326,27 +335,34 @@ nfs_vfs_init(__unused struct vfsconf *vfsp) /* initialize NFS request list */ TAILQ_INIT(&nfs_reqq); - nfs_nbinit(); /* Init the nfsbuf table */ - nfs_nhinit(); /* Init the nfsnode table */ - nfs_lockinit(); /* Init the nfs lock state */ - nfs_gss_init(); /* Init RPCSEC_GSS security */ + nfs_nbinit(); /* Init the nfsbuf table */ + nfs_nhinit(); /* Init the nfsnode table */ + nfs_lockinit(); /* Init the nfs lock state */ +#if CONFIG_NFS_GSS + nfs_gss_init(); /* Init RPCSEC_GSS security */ +#endif +#if CONFIG_NFS4 /* NFSv4 stuff */ NFS4_PER_FS_ATTRIBUTES(nfs_fs_attr_bitmap); NFS4_PER_OBJECT_ATTRIBUTES(nfs_object_attr_bitmap); NFS4_DEFAULT_ATTRIBUTES(nfs_getattr_bitmap); - for (i=0; i < NFS_ATTR_BITMAP_LEN; i++) + for (i = 0; i < NFS_ATTR_BITMAP_LEN; i++) { nfs_getattr_bitmap[i] &= nfs_object_attr_bitmap[i]; + } TAILQ_INIT(&nfsclientids); +#endif /* initialize NFS timer callouts */ nfs_request_timer_call = thread_call_allocate(nfs_request_timer, NULL); nfs_buf_timer_call = thread_call_allocate(nfs_buf_timer, NULL); +#if CONFIG_NFS4 nfs4_callback_timer_call = thread_call_allocate(nfs4_callback_timer, NULL); - - return (0); +#endif + return 0; } + /* * nfs statfs call */ @@ -361,10 +377,12 @@ nfs3_update_statfs(struct nfsmount *nmp, vfs_context_t ctx) nfsvers = nmp->nm_vers; np = nmp->nm_dnp; - if (!np) - return (ENXIO); - if ((error = vnode_get(NFSTOV(np)))) - return (error); + if (!np) { + return ENXIO; + } + if ((error = vnode_get(NFSTOV(np)))) { + return error; + } nfsm_chain_null(&nmreq); nfsm_chain_null(&nmrep); @@ -373,15 +391,23 @@ nfs3_update_statfs(struct nfsmount *nmp, vfs_context_t ctx) nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize); nfsm_chain_build_done(error, &nmreq); nfsmout_if(error); - error = nfs_request(np, NULL, &nmreq, NFSPROC_FSSTAT, ctx, NULL, &nmrep, &xid, &status); - if ((lockerror = nfs_node_lock(np))) + error = nfs_request2(np, NULL, &nmreq, NFSPROC_FSSTAT, vfs_context_thread(ctx), + vfs_context_ucred(ctx), NULL, R_SOFT, &nmrep, &xid, &status); + if (error == ETIMEDOUT) { + goto nfsmout; + } + if ((lockerror = nfs_node_lock(np))) { error = lockerror; - if (nfsvers == NFS_VER3) + } + if (nfsvers == NFS_VER3) { nfsm_chain_postop_attr_update(error, &nmrep, np, &xid); - if (!lockerror) + } + if (!lockerror) { nfs_node_unlock(np); - if (!error) + } + if (!error) { error = status; + } nfsm_assert(error, NFSTONMP(np), ENXIO); nfsmout_if(error); lck_mtx_lock(&nmp->nm_lock); @@ -405,8 +431,9 @@ nfs3_update_statfs(struct nfsmount *nmp, vfs_context_t ctx) nfsm_chain_get_32(error, &nmrep, nmp->nm_fsattr.nfsa_bsize); nfsm_chain_get_32(error, &nmrep, val); nfsmout_if(error); - if (nmp->nm_fsattr.nfsa_bsize <= 0) + if (nmp->nm_fsattr.nfsa_bsize <= 0) { nmp->nm_fsattr.nfsa_bsize = NFS_FABLKSIZE; + } nmp->nm_fsattr.nfsa_space_total = (uint64_t)val * nmp->nm_fsattr.nfsa_bsize; nfsm_chain_get_32(error, &nmrep, val); nfsmout_if(error); @@ -420,9 +447,10 @@ nfsmout: nfsm_chain_cleanup(&nmreq); nfsm_chain_cleanup(&nmrep); vnode_put(NFSTOV(np)); - return (error); + return error; } +#if CONFIG_NFS4 int nfs4_update_statfs(struct nfsmount *nmp, vfs_context_t ctx) { @@ -436,10 +464,12 @@ nfs4_update_statfs(struct nfsmount *nmp, vfs_context_t ctx) nfsvers = nmp->nm_vers; np = nmp->nm_dnp; - if (!np) - return (ENXIO); - if ((error = vnode_get(NFSTOV(np)))) - return (error); + if (!np) { + return ENXIO; + } + if ((error = vnode_get(NFSTOV(np)))) { + return error; + } NFSREQ_SECINFO_SET(&si, np, NULL, 0, NULL, 0); NVATTR_INIT(&nvattr); @@ -449,7 +479,7 @@ nfs4_update_statfs(struct nfsmount *nmp, vfs_context_t ctx) // PUTFH + GETATTR numops = 2; nfsm_chain_build_alloc_init(error, &nmreq, 15 * NFSX_UNSIGNED); - nfsm_chain_add_compound_header(error, &nmreq, "statfs", numops); + nfsm_chain_add_compound_header(error, &nmreq, "statfs", nmp->nm_minor_vers, numops); numops--; nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH); nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize); @@ -461,7 +491,9 @@ nfs4_update_statfs(struct nfsmount *nmp, vfs_context_t ctx) nfsm_chain_build_done(error, &nmreq); nfsm_assert(error, (numops == 0), EPROTO); nfsmout_if(error); - error = nfs_request(np, NULL, &nmreq, NFSPROC4_COMPOUND, ctx, &si, &nmrep, &xid, &status); + error = nfs_request2(np, NULL, &nmreq, NFSPROC4_COMPOUND, + vfs_context_thread(ctx), vfs_context_ucred(ctx), + NULL, R_SOFT, &nmrep, &xid, &status); nfsm_chain_skip_tag(error, &nmrep); nfsm_chain_get_32(error, &nmrep, numops); nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH); @@ -472,12 +504,15 @@ nfs4_update_statfs(struct nfsmount *nmp, vfs_context_t ctx) error = nfs4_parsefattr(&nmrep, &nmp->nm_fsattr, &nvattr, NULL, NULL, NULL); lck_mtx_unlock(&nmp->nm_lock); nfsmout_if(error); - if ((lockerror = nfs_node_lock(np))) + if ((lockerror = nfs_node_lock(np))) { error = lockerror; - if (!error) + } + if (!error) { nfs_loadattrcache(np, &nvattr, &xid, 0); - if (!lockerror) + } + if (!lockerror) { nfs_node_unlock(np); + } nfsm_assert(error, NFSTONMP(np), ENXIO); nfsmout_if(error); nmp->nm_fsattr.nfsa_bsize = NFS_FABLKSIZE; @@ -486,7 +521,62 @@ nfsmout: nfsm_chain_cleanup(&nmreq); nfsm_chain_cleanup(&nmrep); vnode_put(NFSTOV(np)); - return (error); + return error; +} +#endif /* CONFIG_NFS4 */ + + +/* + * Return an NFS volume name from the mntfrom name. + */ +static void +nfs_get_volname(struct mount *mp, char *volname, size_t len, __unused vfs_context_t ctx) +{ + const char *ptr, *cptr; + const char *mntfrom = mp->mnt_vfsstat.f_mntfromname; + size_t mflen; + + + mflen = strnlen(mntfrom, MAXPATHLEN + 1); + + if (mflen > MAXPATHLEN || mflen == 0) { + strlcpy(volname, "Bad volname", len); + return; + } + + /* Move back over trailing slashes */ + for (ptr = &mntfrom[mflen - 1]; ptr != mntfrom && *ptr == '/'; ptr--) { + mflen--; + } + + /* Find first character after the last slash */ + cptr = ptr = NULL; + for (size_t i = 0; i < mflen; i++) { + if (mntfrom[i] == '/') { + ptr = &mntfrom[i + 1]; + } + /* And the first character after the first colon */ + else if (cptr == NULL && mntfrom[i] == ':') { + cptr = &mntfrom[i + 1]; + } + } + + /* + * No slash or nothing after the last slash + * use everything past the first colon + */ + if (ptr == NULL || *ptr == '\0') { + ptr = cptr; + } + /* Otherwise use the mntfrom name */ + if (ptr == NULL) { + ptr = mntfrom; + } + + mflen = &mntfrom[mflen] - ptr; + len = mflen + 1 < len ? mflen + 1 : len; + + strlcpy(volname, ptr, len); } @@ -502,17 +592,19 @@ nfs_vfs_getattr(mount_t mp, struct vfs_attr *fsap, vfs_context_t ctx) uint32_t bsize; int error = 0, nfsvers; - if (!(nmp = VFSTONFS(mp))) - return (ENXIO); + nmp = VFSTONFS(mp); + if (nfs_mount_gone(nmp)) { + return ENXIO; + } nfsvers = nmp->nm_vers; - if (VFSATTR_IS_ACTIVE(fsap, f_bsize) || + if (VFSATTR_IS_ACTIVE(fsap, f_bsize) || VFSATTR_IS_ACTIVE(fsap, f_iosize) || VFSATTR_IS_ACTIVE(fsap, f_blocks) || - VFSATTR_IS_ACTIVE(fsap, f_bfree) || + VFSATTR_IS_ACTIVE(fsap, f_bfree) || VFSATTR_IS_ACTIVE(fsap, f_bavail) || - VFSATTR_IS_ACTIVE(fsap, f_bused) || - VFSATTR_IS_ACTIVE(fsap, f_files) || + VFSATTR_IS_ACTIVE(fsap, f_bused) || + VFSATTR_IS_ACTIVE(fsap, f_files) || VFSATTR_IS_ACTIVE(fsap, f_ffree)) { int statfsrate = nfs_statfs_rate_limit; int refresh = 1; @@ -527,7 +619,7 @@ nfs_vfs_getattr(mount_t mp, struct vfs_attr *fsap, vfs_context_t ctx) microuptime(&now); lck_mtx_lock(&nmp->nm_lock); - stamp = (now.tv_sec * statfsrate) + (now.tv_usec / (1000000/statfsrate)); + stamp = (now.tv_sec * statfsrate) + (now.tv_usec / (1000000 / statfsrate)); if (stamp != nmp->nm_fsattrstamp) { refresh = 1; nmp->nm_fsattrstamp = stamp; @@ -537,79 +629,100 @@ nfs_vfs_getattr(mount_t mp, struct vfs_attr *fsap, vfs_context_t ctx) lck_mtx_unlock(&nmp->nm_lock); } - if (refresh) + if (refresh && !nfs_use_cache(nmp)) { error = nmp->nm_funcs->nf_update_statfs(nmp, ctx); - if ((error == ESTALE) || (error == ETIMEDOUT)) + } + if ((error == ESTALE) || (error == ETIMEDOUT)) { error = 0; - if (error) - return (error); + } + if (error) { + return error; + } lck_mtx_lock(&nmp->nm_lock); VFSATTR_RETURN(fsap, f_iosize, nfs_iosize); VFSATTR_RETURN(fsap, f_bsize, nmp->nm_fsattr.nfsa_bsize); bsize = nmp->nm_fsattr.nfsa_bsize; - if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_SPACE_TOTAL)) + if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_SPACE_TOTAL)) { VFSATTR_RETURN(fsap, f_blocks, nmp->nm_fsattr.nfsa_space_total / bsize); - if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_SPACE_FREE)) + } + if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_SPACE_FREE)) { VFSATTR_RETURN(fsap, f_bfree, nmp->nm_fsattr.nfsa_space_free / bsize); - if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_SPACE_AVAIL)) + } + if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_SPACE_AVAIL)) { VFSATTR_RETURN(fsap, f_bavail, nmp->nm_fsattr.nfsa_space_avail / bsize); + } if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_SPACE_TOTAL) && - NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_SPACE_FREE)) + NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_SPACE_FREE)) { VFSATTR_RETURN(fsap, f_bused, - (nmp->nm_fsattr.nfsa_space_total / bsize) - - (nmp->nm_fsattr.nfsa_space_free / bsize)); - if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_FILES_TOTAL)) + (nmp->nm_fsattr.nfsa_space_total / bsize) - + (nmp->nm_fsattr.nfsa_space_free / bsize)); + } + if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_FILES_TOTAL)) { VFSATTR_RETURN(fsap, f_files, nmp->nm_fsattr.nfsa_files_total); - if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_FILES_FREE)) + } + if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_FILES_FREE)) { VFSATTR_RETURN(fsap, f_ffree, nmp->nm_fsattr.nfsa_files_free); + } lck_mtx_unlock(&nmp->nm_lock); } - if (VFSATTR_IS_ACTIVE(fsap, f_capabilities)) { + if (VFSATTR_IS_ACTIVE(fsap, f_vol_name)) { + /*%%% IF fail over support is implemented we may need to take nm_lock */ + nfs_get_volname(mp, fsap->f_vol_name, MAXPATHLEN, ctx); + VFSATTR_SET_SUPPORTED(fsap, f_vol_name); + } + if (VFSATTR_IS_ACTIVE(fsap, f_capabilities) + ) { u_int32_t caps, valid; nfsnode_t np = nmp->nm_dnp; nfsm_assert(error, VFSTONFS(mp) && np, ENXIO); - if (error) - return (error); + if (error) { + return error; + } lck_mtx_lock(&nmp->nm_lock); /* * The capabilities[] array defines what this volume supports. * * The valid[] array defines which bits this code understands - * the meaning of (whether the volume has that capability or not). - * Any zero bits here means "I don't know what you're asking about" - * and the caller cannot tell whether that capability is - * present or not. + * the meaning of (whether the volume has that capability or + * not). Any zero bits here means "I don't know what you're + * asking about" and the caller cannot tell whether that + * capability is present or not. */ caps = valid = 0; if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_SYMLINK_SUPPORT)) { valid |= VOL_CAP_FMT_SYMBOLICLINKS; - if (nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_SYMLINK) + if (nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_SYMLINK) { caps |= VOL_CAP_FMT_SYMBOLICLINKS; + } } if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_LINK_SUPPORT)) { valid |= VOL_CAP_FMT_HARDLINKS; - if (nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_LINK) + if (nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_LINK) { caps |= VOL_CAP_FMT_HARDLINKS; + } } if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_CASE_INSENSITIVE)) { valid |= VOL_CAP_FMT_CASE_SENSITIVE; - if (!(nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_CASE_INSENSITIVE)) + if (!(nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_CASE_INSENSITIVE)) { caps |= VOL_CAP_FMT_CASE_SENSITIVE; + } } if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_CASE_PRESERVING)) { valid |= VOL_CAP_FMT_CASE_PRESERVING; - if (nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_CASE_PRESERVING) + if (nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_CASE_PRESERVING) { caps |= VOL_CAP_FMT_CASE_PRESERVING; + } } /* Note: VOL_CAP_FMT_2TB_FILESIZE is actually used to test for "large file support" */ if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_MAXFILESIZE)) { /* Is server's max file size at least 4GB? */ - if (nmp->nm_fsattr.nfsa_maxfilesize >= 0x100000000ULL) + if (nmp->nm_fsattr.nfsa_maxfilesize >= 0x100000000ULL) { caps |= VOL_CAP_FMT_2TB_FILESIZE; + } } else if (nfsvers >= NFS_VER3) { /* * NFSv3 and up supports 64 bits of file size. @@ -617,6 +730,7 @@ nfs_vfs_getattr(mount_t mp, struct vfs_attr *fsap, vfs_context_t ctx) */ caps |= VOL_CAP_FMT_2TB_FILESIZE; } +#if CONFIG_NFS4 if (nfsvers >= NFS_VER4) { caps |= VOL_CAP_FMT_HIDDEN_FILES; valid |= VOL_CAP_FMT_HIDDEN_FILES; @@ -624,67 +738,79 @@ nfs_vfs_getattr(mount_t mp, struct vfs_attr *fsap, vfs_context_t ctx) // caps |= VOL_CAP_FMT_OPENDENYMODES; // valid |= VOL_CAP_FMT_OPENDENYMODES; } +#endif + // no version of nfs supports immutable files + caps |= VOL_CAP_FMT_NO_IMMUTABLE_FILES; + valid |= VOL_CAP_FMT_NO_IMMUTABLE_FILES; + fsap->f_capabilities.capabilities[VOL_CAPABILITIES_FORMAT] = - // VOL_CAP_FMT_PERSISTENTOBJECTIDS | - // VOL_CAP_FMT_SYMBOLICLINKS | - // VOL_CAP_FMT_HARDLINKS | - // VOL_CAP_FMT_JOURNAL | - // VOL_CAP_FMT_JOURNAL_ACTIVE | - // VOL_CAP_FMT_NO_ROOT_TIMES | - // VOL_CAP_FMT_SPARSE_FILES | - // VOL_CAP_FMT_ZERO_RUNS | - // VOL_CAP_FMT_CASE_SENSITIVE | - // VOL_CAP_FMT_CASE_PRESERVING | - // VOL_CAP_FMT_FAST_STATFS | - // VOL_CAP_FMT_2TB_FILESIZE | - // VOL_CAP_FMT_OPENDENYMODES | - // VOL_CAP_FMT_HIDDEN_FILES | - caps; + // VOL_CAP_FMT_PERSISTENTOBJECTIDS | + // VOL_CAP_FMT_SYMBOLICLINKS | + // VOL_CAP_FMT_HARDLINKS | + // VOL_CAP_FMT_JOURNAL | + // VOL_CAP_FMT_JOURNAL_ACTIVE | + // VOL_CAP_FMT_NO_ROOT_TIMES | + // VOL_CAP_FMT_SPARSE_FILES | + // VOL_CAP_FMT_ZERO_RUNS | + // VOL_CAP_FMT_CASE_SENSITIVE | + // VOL_CAP_FMT_CASE_PRESERVING | + // VOL_CAP_FMT_FAST_STATFS | + // VOL_CAP_FMT_2TB_FILESIZE | + // VOL_CAP_FMT_OPENDENYMODES | + // VOL_CAP_FMT_HIDDEN_FILES | + caps; fsap->f_capabilities.valid[VOL_CAPABILITIES_FORMAT] = - VOL_CAP_FMT_PERSISTENTOBJECTIDS | - // VOL_CAP_FMT_SYMBOLICLINKS | - // VOL_CAP_FMT_HARDLINKS | - // VOL_CAP_FMT_JOURNAL | - // VOL_CAP_FMT_JOURNAL_ACTIVE | - // VOL_CAP_FMT_NO_ROOT_TIMES | - // VOL_CAP_FMT_SPARSE_FILES | - // VOL_CAP_FMT_ZERO_RUNS | - // VOL_CAP_FMT_CASE_SENSITIVE | - // VOL_CAP_FMT_CASE_PRESERVING | - VOL_CAP_FMT_FAST_STATFS | - VOL_CAP_FMT_2TB_FILESIZE | - // VOL_CAP_FMT_OPENDENYMODES | - // VOL_CAP_FMT_HIDDEN_FILES | - valid; + VOL_CAP_FMT_PERSISTENTOBJECTIDS | + // VOL_CAP_FMT_SYMBOLICLINKS | + // VOL_CAP_FMT_HARDLINKS | + // VOL_CAP_FMT_JOURNAL | + // VOL_CAP_FMT_JOURNAL_ACTIVE | + // VOL_CAP_FMT_NO_ROOT_TIMES | + // VOL_CAP_FMT_SPARSE_FILES | + // VOL_CAP_FMT_ZERO_RUNS | + // VOL_CAP_FMT_CASE_SENSITIVE | + // VOL_CAP_FMT_CASE_PRESERVING | + VOL_CAP_FMT_FAST_STATFS | + VOL_CAP_FMT_2TB_FILESIZE | + // VOL_CAP_FMT_OPENDENYMODES | + // VOL_CAP_FMT_HIDDEN_FILES | + valid; /* * We don't support most of the interfaces. * - * We MAY support locking, but we don't have any easy way of probing. - * We can tell if there's no lockd running or if locks have been - * disabled for a mount, so we can definitely answer NO in that case. - * Any attempt to send a request to lockd to test for locking support - * may cause the lazily-launched locking daemons to be started - * unnecessarily. So we avoid that. However, we do record if we ever - * successfully perform a lock operation on a mount point, so if it - * looks like lock ops have worked, we do report that we support them. + * We MAY support locking, but we don't have any easy way of + * probing. We can tell if there's no lockd running or if + * locks have been disabled for a mount, so we can definitely + * answer NO in that case. Any attempt to send a request to + * lockd to test for locking support may cause the lazily- + * launched locking daemons to be started unnecessarily. So + * we avoid that. However, we do record if we ever successfully + * perform a lock operation on a mount point, so if it looks + * like lock ops have worked, we do report that we support them. */ caps = valid = 0; +#if CONFIG_NFS4 if (nfsvers >= NFS_VER4) { caps = VOL_CAP_INT_ADVLOCK | VOL_CAP_INT_FLOCK; valid = VOL_CAP_INT_ADVLOCK | VOL_CAP_INT_FLOCK; - if (nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_ACL) + if (nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_ACL) { caps |= VOL_CAP_INT_EXTENDED_SECURITY; + } valid |= VOL_CAP_INT_EXTENDED_SECURITY; - if (nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_NAMED_ATTR) + if (nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_NAMED_ATTR) { caps |= VOL_CAP_INT_EXTENDED_ATTR; + } valid |= VOL_CAP_INT_EXTENDED_ATTR; #if NAMEDSTREAMS - if (nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_NAMED_ATTR) + if (nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_NAMED_ATTR) { caps |= VOL_CAP_INT_NAMEDSTREAMS; + } valid |= VOL_CAP_INT_NAMEDSTREAMS; #endif - } else if (nmp->nm_lockmode == NFS_LOCK_MODE_DISABLED) { + } else +#endif + if (nmp->nm_lockmode == NFS_LOCK_MODE_DISABLED) { /* locks disabled on this mount, so they definitely won't work */ valid = VOL_CAP_INT_ADVLOCK | VOL_CAP_INT_FLOCK; } else if (nmp->nm_state & NFSSTA_LOCKSWORK) { @@ -692,41 +818,41 @@ nfs_vfs_getattr(mount_t mp, struct vfs_attr *fsap, vfs_context_t ctx) valid = VOL_CAP_INT_ADVLOCK | VOL_CAP_INT_FLOCK; } fsap->f_capabilities.capabilities[VOL_CAPABILITIES_INTERFACES] = - // VOL_CAP_INT_SEARCHFS | - // VOL_CAP_INT_ATTRLIST | - // VOL_CAP_INT_NFSEXPORT | - // VOL_CAP_INT_READDIRATTR | - // VOL_CAP_INT_EXCHANGEDATA | - // VOL_CAP_INT_COPYFILE | - // VOL_CAP_INT_ALLOCATE | - // VOL_CAP_INT_VOL_RENAME | - // VOL_CAP_INT_ADVLOCK | - // VOL_CAP_INT_FLOCK | - // VOL_CAP_INT_EXTENDED_SECURITY | - // VOL_CAP_INT_USERACCESS | - // VOL_CAP_INT_MANLOCK | - // VOL_CAP_INT_NAMEDSTREAMS | - // VOL_CAP_INT_EXTENDED_ATTR | - VOL_CAP_INT_REMOTE_EVENT | - caps; + // VOL_CAP_INT_SEARCHFS | + // VOL_CAP_INT_ATTRLIST | + // VOL_CAP_INT_NFSEXPORT | + // VOL_CAP_INT_READDIRATTR | + // VOL_CAP_INT_EXCHANGEDATA | + // VOL_CAP_INT_COPYFILE | + // VOL_CAP_INT_ALLOCATE | + // VOL_CAP_INT_VOL_RENAME | + // VOL_CAP_INT_ADVLOCK | + // VOL_CAP_INT_FLOCK | + // VOL_CAP_INT_EXTENDED_SECURITY | + // VOL_CAP_INT_USERACCESS | + // VOL_CAP_INT_MANLOCK | + // VOL_CAP_INT_NAMEDSTREAMS | + // VOL_CAP_INT_EXTENDED_ATTR | + VOL_CAP_INT_REMOTE_EVENT | + caps; fsap->f_capabilities.valid[VOL_CAPABILITIES_INTERFACES] = - VOL_CAP_INT_SEARCHFS | - VOL_CAP_INT_ATTRLIST | - VOL_CAP_INT_NFSEXPORT | - VOL_CAP_INT_READDIRATTR | - VOL_CAP_INT_EXCHANGEDATA | - VOL_CAP_INT_COPYFILE | - VOL_CAP_INT_ALLOCATE | - VOL_CAP_INT_VOL_RENAME | - // VOL_CAP_INT_ADVLOCK | - // VOL_CAP_INT_FLOCK | - // VOL_CAP_INT_EXTENDED_SECURITY | - // VOL_CAP_INT_USERACCESS | - // VOL_CAP_INT_MANLOCK | - // VOL_CAP_INT_NAMEDSTREAMS | - // VOL_CAP_INT_EXTENDED_ATTR | - VOL_CAP_INT_REMOTE_EVENT | - valid; + VOL_CAP_INT_SEARCHFS | + VOL_CAP_INT_ATTRLIST | + VOL_CAP_INT_NFSEXPORT | + VOL_CAP_INT_READDIRATTR | + VOL_CAP_INT_EXCHANGEDATA | + VOL_CAP_INT_COPYFILE | + VOL_CAP_INT_ALLOCATE | + VOL_CAP_INT_VOL_RENAME | + // VOL_CAP_INT_ADVLOCK | + // VOL_CAP_INT_FLOCK | + // VOL_CAP_INT_EXTENDED_SECURITY | + // VOL_CAP_INT_USERACCESS | + // VOL_CAP_INT_MANLOCK | + // VOL_CAP_INT_NAMEDSTREAMS | + // VOL_CAP_INT_EXTENDED_ATTR | + VOL_CAP_INT_REMOTE_EVENT | + valid; fsap->f_capabilities.capabilities[VOL_CAPABILITIES_RESERVED1] = 0; fsap->f_capabilities.valid[VOL_CAPABILITIES_RESERVED1] = 0; @@ -741,14 +867,14 @@ nfs_vfs_getattr(mount_t mp, struct vfs_attr *fsap, vfs_context_t ctx) if (VFSATTR_IS_ACTIVE(fsap, f_attributes)) { fsap->f_attributes.validattr.commonattr = 0; fsap->f_attributes.validattr.volattr = - ATTR_VOL_CAPABILITIES | ATTR_VOL_ATTRIBUTES; + ATTR_VOL_NAME | ATTR_VOL_CAPABILITIES | ATTR_VOL_ATTRIBUTES; fsap->f_attributes.validattr.dirattr = 0; fsap->f_attributes.validattr.fileattr = 0; fsap->f_attributes.validattr.forkattr = 0; fsap->f_attributes.nativeattr.commonattr = 0; fsap->f_attributes.nativeattr.volattr = - ATTR_VOL_CAPABILITIES | ATTR_VOL_ATTRIBUTES; + ATTR_VOL_NAME | ATTR_VOL_CAPABILITIES | ATTR_VOL_ATTRIBUTES; fsap->f_attributes.nativeattr.dirattr = 0; fsap->f_attributes.nativeattr.fileattr = 0; fsap->f_attributes.nativeattr.forkattr = 0; @@ -756,7 +882,7 @@ nfs_vfs_getattr(mount_t mp, struct vfs_attr *fsap, vfs_context_t ctx) VFSATTR_SET_SUPPORTED(fsap, f_attributes); } - return (error); + return error; } /* @@ -778,13 +904,16 @@ nfs3_fsinfo(struct nfsmount *nmp, nfsnode_t np, vfs_context_t ctx) nfsm_chain_build_done(error, &nmreq); nfsmout_if(error); error = nfs_request(np, NULL, &nmreq, NFSPROC_FSINFO, ctx, NULL, &nmrep, &xid, &status); - if ((lockerror = nfs_node_lock(np))) + if ((lockerror = nfs_node_lock(np))) { error = lockerror; + } nfsm_chain_postop_attr_update(error, &nmrep, np, &xid); - if (!lockerror) + if (!lockerror) { nfs_node_unlock(np); - if (!error) + } + if (!error) { error = status; + } nfsmout_if(error); lck_mtx_lock(&nmp->nm_lock); @@ -794,13 +923,15 @@ nfs3_fsinfo(struct nfsmount *nmp, nfsnode_t np, vfs_context_t ctx) nfsm_chain_get_32(error, &nmrep, prefsize); nfsmout_if(error); nmp->nm_fsattr.nfsa_maxread = maxsize; - if (prefsize < nmp->nm_rsize) + if (prefsize < nmp->nm_rsize) { nmp->nm_rsize = (prefsize + NFS_FABLKSIZE - 1) & - ~(NFS_FABLKSIZE - 1); + ~(NFS_FABLKSIZE - 1); + } if ((maxsize > 0) && (maxsize < nmp->nm_rsize)) { nmp->nm_rsize = maxsize & ~(NFS_FABLKSIZE - 1); - if (nmp->nm_rsize == 0) + if (nmp->nm_rsize == 0) { nmp->nm_rsize = maxsize; + } } nfsm_chain_adv(error, &nmrep, NFSX_UNSIGNED); // skip rtmult @@ -808,23 +939,27 @@ nfs3_fsinfo(struct nfsmount *nmp, nfsnode_t np, vfs_context_t ctx) nfsm_chain_get_32(error, &nmrep, prefsize); nfsmout_if(error); nmp->nm_fsattr.nfsa_maxwrite = maxsize; - if (prefsize < nmp->nm_wsize) + if (prefsize < nmp->nm_wsize) { nmp->nm_wsize = (prefsize + NFS_FABLKSIZE - 1) & - ~(NFS_FABLKSIZE - 1); + ~(NFS_FABLKSIZE - 1); + } if ((maxsize > 0) && (maxsize < nmp->nm_wsize)) { nmp->nm_wsize = maxsize & ~(NFS_FABLKSIZE - 1); - if (nmp->nm_wsize == 0) + if (nmp->nm_wsize == 0) { nmp->nm_wsize = maxsize; + } } nfsm_chain_adv(error, &nmrep, NFSX_UNSIGNED); // skip wtmult nfsm_chain_get_32(error, &nmrep, prefsize); nfsmout_if(error); - if ((prefsize > 0) && (prefsize < nmp->nm_readdirsize)) + if ((prefsize > 0) && (prefsize < nmp->nm_readdirsize)) { nmp->nm_readdirsize = prefsize; + } if ((nmp->nm_fsattr.nfsa_maxread > 0) && - (nmp->nm_fsattr.nfsa_maxread < nmp->nm_readdirsize)) + (nmp->nm_fsattr.nfsa_maxread < nmp->nm_readdirsize)) { nmp->nm_readdirsize = nmp->nm_fsattr.nfsa_maxread; + } nfsm_chain_get_64(error, &nmrep, nmp->nm_fsattr.nfsa_maxfilesize); @@ -833,14 +968,18 @@ nfs3_fsinfo(struct nfsmount *nmp, nfsnode_t np, vfs_context_t ctx) /* convert FS properties to our own flags */ nfsm_chain_get_32(error, &nmrep, val); nfsmout_if(error); - if (val & NFSV3FSINFO_LINK) + if (val & NFSV3FSINFO_LINK) { nmp->nm_fsattr.nfsa_flags |= NFS_FSFLAG_LINK; - if (val & NFSV3FSINFO_SYMLINK) + } + if (val & NFSV3FSINFO_SYMLINK) { nmp->nm_fsattr.nfsa_flags |= NFS_FSFLAG_SYMLINK; - if (val & NFSV3FSINFO_HOMOGENEOUS) + } + if (val & NFSV3FSINFO_HOMOGENEOUS) { nmp->nm_fsattr.nfsa_flags |= NFS_FSFLAG_HOMOGENEOUS; - if (val & NFSV3FSINFO_CANSETTIME) + } + if (val & NFSV3FSINFO_CANSETTIME) { nmp->nm_fsattr.nfsa_flags |= NFS_FSFLAG_SET_TIME; + } nmp->nm_state |= NFSSTA_GOTFSINFO; NFS_BITMAP_SET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_MAXREAD); NFS_BITMAP_SET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_MAXWRITE); @@ -850,11 +989,12 @@ nfs3_fsinfo(struct nfsmount *nmp, nfsnode_t np, vfs_context_t ctx) NFS_BITMAP_SET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_HOMOGENEOUS); NFS_BITMAP_SET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_CANSETTIME); nfsmout: - if (nmlocked) + if (nmlocked) { lck_mtx_unlock(&nmp->nm_lock); + } nfsm_chain_cleanup(&nmreq); nfsm_chain_cleanup(&nmrep); - return (error); + return error; } /* @@ -870,6 +1010,7 @@ nfsmout: * if swdevt[0].sw_dev == NODEV * - build the rootfs mount point and call mountnfs() to do the rest. */ +#if CONFIG_NETBOOT int nfs_mountroot(void) { @@ -891,9 +1032,10 @@ nfs_mountroot(void) */ bzero((caddr_t) &nd, sizeof(nd)); error = nfs_boot_init(&nd); - if (error) + if (error) { panic("nfs_boot_init: unable to initialize NFS root system information, " - "error %d, check configuration: %s\n", error, PE_boot_args()); + "error %d, check configuration: %s\n", error, PE_boot_args()); + } /* * Try NFSv3 first, then fallback to NFSv2. @@ -906,19 +1048,23 @@ tryagain: error = nfs_boot_getfh(&nd, v3, sotype); if (error) { if (error == EHOSTDOWN || error == EHOSTUNREACH) { - if (nd.nd_root.ndm_mntfrom) + if (nd.nd_root.ndm_mntfrom) { FREE_ZONE(nd.nd_root.ndm_mntfrom, - MAXPATHLEN, M_NAMEI); - if (nd.nd_root.ndm_path) + MAXPATHLEN, M_NAMEI); + } + if (nd.nd_root.ndm_path) { FREE_ZONE(nd.nd_root.ndm_path, - MAXPATHLEN, M_NAMEI); - if (nd.nd_private.ndm_mntfrom) + MAXPATHLEN, M_NAMEI); + } + if (nd.nd_private.ndm_mntfrom) { FREE_ZONE(nd.nd_private.ndm_mntfrom, - MAXPATHLEN, M_NAMEI); - if (nd.nd_private.ndm_path) + MAXPATHLEN, M_NAMEI); + } + if (nd.nd_private.ndm_path) { FREE_ZONE(nd.nd_private.ndm_path, - MAXPATHLEN, M_NAMEI); - return (error); + MAXPATHLEN, M_NAMEI); + } + return error; } if (v3) { if (sotype == SOCK_STREAM) { @@ -937,7 +1083,7 @@ tryagain: } else { printf("NFS mount (v2,UDP) failed with error %d, giving up...\n", error); } - switch(error) { + switch (error) { case EPROGUNAVAIL: panic("NFS mount failed: NFS server mountd not responding, check server configuration: %s", PE_boot_args()); case EACCES: @@ -956,74 +1102,79 @@ tryagain: #if !defined(NO_MOUNT_PRIVATE) { //PWC hack until we have a real "mount" tool to remount root rw - int rw_root=0; - int flags = MNT_ROOTFS|MNT_RDONLY; - PE_parse_boot_argn("-rwroot_hack", &rw_root, sizeof (rw_root)); - if(rw_root) - { + int rw_root = 0; + int flags = MNT_ROOTFS | MNT_RDONLY; + PE_parse_boot_argn("-rwroot_hack", &rw_root, sizeof(rw_root)); + if (rw_root) { flags = MNT_ROOTFS; kprintf("-rwroot_hack in effect: mounting root fs read/write\n"); } - - if ((error = nfs_mount_diskless(&nd.nd_root, "/", flags, &vp, &mp, ctx))) + + if ((error = nfs_mount_diskless(&nd.nd_root, "/", flags, &vp, &mp, ctx))) #else if ((error = nfs_mount_diskless(&nd.nd_root, "/", MNT_ROOTFS, &vp, &mp, ctx))) #endif /* NO_MOUNT_PRIVATE */ - { - if (v3) { - if (sotype == SOCK_STREAM) { - printf("NFS root mount (v3,TCP) failed with %d, trying UDP...\n", error); + { + if (v3) { + if (sotype == SOCK_STREAM) { + printf("NFS root mount (v3,TCP) failed with %d, trying UDP...\n", error); + sotype = SOCK_DGRAM; + goto tryagain; + } + printf("NFS root mount (v3,UDP) failed with %d, trying v2...\n", error); + v3 = 0; + sotype = SOCK_STREAM; + goto tryagain; + } else if (sotype == SOCK_STREAM) { + printf("NFS root mount (v2,TCP) failed with %d, trying UDP...\n", error); sotype = SOCK_DGRAM; goto tryagain; + } else { + printf("NFS root mount (v2,UDP) failed with error %d, giving up...\n", error); } - printf("NFS root mount (v3,UDP) failed with %d, trying v2...\n", error); - v3 = 0; - sotype = SOCK_STREAM; - goto tryagain; - } else if (sotype == SOCK_STREAM) { - printf("NFS root mount (v2,TCP) failed with %d, trying UDP...\n", error); - sotype = SOCK_DGRAM; - goto tryagain; - } else { - printf("NFS root mount (v2,UDP) failed with error %d, giving up...\n", error); + panic("NFS root mount failed with error %d, check configuration: %s\n", error, PE_boot_args()); } - panic("NFS root mount failed with error %d, check configuration: %s\n", error, PE_boot_args()); - } } printf("root on %s\n", nd.nd_root.ndm_mntfrom); vfs_unbusy(mp); mount_list_add(mp); rootvp = vp; - + #if !defined(NO_MOUNT_PRIVATE) if (nd.nd_private.ndm_saddr.sin_addr.s_addr) { - error = nfs_mount_diskless_private(&nd.nd_private, "/private", - 0, &vppriv, &mppriv, ctx); - if (error) - panic("NFS /private mount failed with error %d, check configuration: %s\n", error, PE_boot_args()); - printf("private on %s\n", nd.nd_private.ndm_mntfrom); + error = nfs_mount_diskless_private(&nd.nd_private, "/private", + 0, &vppriv, &mppriv, ctx); + if (error) { + panic("NFS /private mount failed with error %d, check configuration: %s\n", error, PE_boot_args()); + } + printf("private on %s\n", nd.nd_private.ndm_mntfrom); - vfs_unbusy(mppriv); - mount_list_add(mppriv); + vfs_unbusy(mppriv); + mount_list_add(mppriv); } #endif /* NO_MOUNT_PRIVATE */ - if (nd.nd_root.ndm_mntfrom) + if (nd.nd_root.ndm_mntfrom) { FREE_ZONE(nd.nd_root.ndm_mntfrom, MAXPATHLEN, M_NAMEI); - if (nd.nd_root.ndm_path) + } + if (nd.nd_root.ndm_path) { FREE_ZONE(nd.nd_root.ndm_path, MAXPATHLEN, M_NAMEI); - if (nd.nd_private.ndm_mntfrom) + } + if (nd.nd_private.ndm_mntfrom) { FREE_ZONE(nd.nd_private.ndm_mntfrom, MAXPATHLEN, M_NAMEI); - if (nd.nd_private.ndm_path) + } + if (nd.nd_private.ndm_path) { FREE_ZONE(nd.nd_private.ndm_path, MAXPATHLEN, M_NAMEI); + } /* Get root attributes (for the time). */ error = nfs_getattr(VTONFS(vp), NULL, ctx, NGA_UNCACHED); - if (error) + if (error) { panic("NFS mount: failed to get attributes for root directory, error %d, check server", error); - return (0); + } + return 0; } /* @@ -1050,43 +1201,51 @@ nfs_mount_diskless( if ((error = vfs_rootmountalloc("nfs", ndmntp->ndm_mntfrom, &mp))) { printf("nfs_mount_diskless: NFS not configured\n"); - return (error); + return error; } mp->mnt_flag |= mntflag; - if (!(mntflag & MNT_RDONLY)) + if (!(mntflag & MNT_RDONLY)) { mp->mnt_flag &= ~MNT_RDONLY; + } /* find the server-side path being mounted */ frompath = ndmntp->ndm_mntfrom; if (*frompath == '[') { /* skip IPv6 literal address */ - while (*frompath && (*frompath != ']')) + while (*frompath && (*frompath != ']')) { frompath++; - if (*frompath == ']') + } + if (*frompath == ']') { frompath++; + } } - while (*frompath && (*frompath != ':')) + while (*frompath && (*frompath != ':')) { frompath++; + } endserverp = frompath; - while (*frompath && (*frompath == ':')) + while (*frompath && (*frompath == ':')) { frompath++; + } /* count fs location path components */ p = frompath; - while (*p && (*p == '/')) + while (*p && (*p == '/')) { p++; + } numcomps = 0; while (*p) { numcomps++; - while (*p && (*p != '/')) + while (*p && (*p != '/')) { p++; - while (*p && (*p == '/')) + } + while (*p && (*p == '/')) { p++; + } } /* convert address to universal address string */ if (inet_ntop(AF_INET, &ndmntp->ndm_saddr.sin_addr, uaddr, sizeof(uaddr)) != uaddr) { printf("nfs_mount_diskless: bad address\n"); - return (EINVAL); + return EINVAL; } /* prepare mount attributes */ @@ -1126,17 +1285,21 @@ nfs_mount_diskless( xb_add_32(error, &xb, 0); /* empty server info */ xb_add_32(error, &xb, numcomps); /* pathname component count */ p = frompath; - while (*p && (*p == '/')) + while (*p && (*p == '/')) { p++; + } while (*p) { cp = p; - while (*p && (*p != '/')) + while (*p && (*p != '/')) { p++; + } xb_add_string(error, &xb, cp, (p - cp)); /* component */ - if (error) + if (error) { break; - while (*p && (*p == '/')) + } + while (*p && (*p == '/')) { p++; + } } xb_add_32(error, &xb, 0); /* empty fsl info */ xb_add_32(error, &xb, mntflag); /* MNT flags */ @@ -1146,16 +1309,16 @@ nfs_mount_diskless( end_offset = xb_offset(&xb); if (!error) { error = xb_seek(&xb, argslength_offset); - xb_add_32(error, &xb, end_offset - argslength_offset + XDRWORD/*version*/); + xb_add_32(error, &xb, end_offset - argslength_offset + XDRWORD /*version*/); } if (!error) { error = xb_seek(&xb, attrslength_offset); - xb_add_32(error, &xb, end_offset - attrslength_offset - XDRWORD/*don't include length field*/); + xb_add_32(error, &xb, end_offset - attrslength_offset - XDRWORD /*don't include length field*/); } if (error) { printf("nfs_mount_diskless: error %d assembling mount args\n", error); xb_cleanup(&xb); - return (error); + return error; } /* grab the assembled buffer */ xdrbuf = xb_buffer_base(&xb); @@ -1178,7 +1341,7 @@ nfs_mount_diskless( *mpp = mp; } xb_cleanup(&xb); - return (error); + return error; } #if !defined(NO_MOUNT_PRIVATE) @@ -1209,20 +1372,21 @@ nfs_mount_diskless_private( uint32_t argslength_offset, attrslength_offset, end_offset; procp = current_proc(); /* XXX */ - xb_init(&xb, 0); + xb_init(&xb, XDRBUF_NONE); { - /* - * mimic main()!. Temporarily set up rootvnode and other stuff so - * that namei works. Need to undo this because main() does it, too - */ - struct filedesc *fdp; /* pointer to file descriptor state */ + /* + * mimic main()!. Temporarily set up rootvnode and other stuff so + * that namei works. Need to undo this because main() does it, too + */ + struct filedesc *fdp; /* pointer to file descriptor state */ fdp = procp->p_fd; mountlist.tqh_first->mnt_flag |= MNT_ROOTFS; /* Get the vnode for '/'. Set fdp->fd_cdir to reference it. */ - if (VFS_ROOT(mountlist.tqh_first, &rootvnode, NULL)) + if (VFS_ROOT(mountlist.tqh_first, &rootvnode, NULL)) { panic("cannot find root vnode"); + } error = vnode_ref(rootvnode); if (error) { printf("nfs_mountroot: vnode_ref() failed on root vnode!\n"); @@ -1258,9 +1422,11 @@ nfs_mount_diskless_private( error = ENOTDIR; goto out; } - for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next) - if (!strncmp(vfsp->vfc_name, "nfs", sizeof(vfsp->vfc_name))) + for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next) { + if (!strncmp(vfsp->vfc_name, "nfs", sizeof(vfsp->vfc_name))) { break; + } + } if (vfsp == NULL) { printf("nfs_mountroot: private NFS not configured\n"); vnode_put(vp); @@ -1290,7 +1456,7 @@ nfs_mount_diskless_private( mp->mnt_segreadcnt = mp->mnt_segwritecnt = 32; mp->mnt_ioflags = 0; mp->mnt_realrootvp = NULLVP; - mp->mnt_authcache_ttl = CACHED_LOOKUP_RIGHT_TTL; + mp->mnt_authcache_ttl = 0; /* Allways go to our lookup */ mount_lock_init(mp); TAILQ_INIT(&mp->mnt_vnodelist); @@ -1306,9 +1472,10 @@ nfs_mount_diskless_private( // mp->mnt_stat.f_type = vfsp->vfc_typenum; mp->mnt_flag = mntflag; mp->mnt_flag |= vfsp->vfc_flags & MNT_VISFLAGMASK; - strncpy(mp->mnt_vfsstat.f_fstypename, vfsp->vfc_name, MFSNAMELEN-1); + strncpy(mp->mnt_vfsstat.f_fstypename, vfsp->vfc_name, MFSNAMELEN - 1); vp->v_mountedhere = mp; mp->mnt_vnodecovered = vp; + vp = NULLVP; mp->mnt_vfsstat.f_owner = kauth_cred_getuid(kauth_cred_get()); (void) copystr(mntname, mp->mnt_vfsstat.f_mntonname, MAXPATHLEN - 1, 0); (void) copystr(ndmntp->ndm_mntfrom, mp->mnt_vfsstat.f_mntfromname, MAXPATHLEN - 1, 0); @@ -1320,27 +1487,34 @@ nfs_mount_diskless_private( /* find the server-side path being mounted */ frompath = ndmntp->ndm_mntfrom; if (*frompath == '[') { /* skip IPv6 literal address */ - while (*frompath && (*frompath != ']')) + while (*frompath && (*frompath != ']')) { frompath++; - if (*frompath == ']') + } + if (*frompath == ']') { frompath++; + } } - while (*frompath && (*frompath != ':')) + while (*frompath && (*frompath != ':')) { frompath++; + } endserverp = frompath; - while (*frompath && (*frompath == ':')) + while (*frompath && (*frompath == ':')) { frompath++; + } /* count fs location path components */ p = frompath; - while (*p && (*p == '/')) + while (*p && (*p == '/')) { p++; + } numcomps = 0; while (*p) { numcomps++; - while (*p && (*p != '/')) + while (*p && (*p != '/')) { p++; - while (*p && (*p == '/')) + } + while (*p && (*p == '/')) { p++; + } } /* convert address to universal address string */ @@ -1387,17 +1561,21 @@ nfs_mount_diskless_private( xb_add_32(error, &xb, 0); /* empty server info */ xb_add_32(error, &xb, numcomps); /* pathname component count */ p = frompath; - while (*p && (*p == '/')) + while (*p && (*p == '/')) { p++; + } while (*p) { cp = p; - while (*p && (*p != '/')) + while (*p && (*p != '/')) { p++; + } xb_add_string(error, &xb, cp, (p - cp)); /* component */ - if (error) + if (error) { break; - while (*p && (*p == '/')) + } + while (*p && (*p == '/')) { p++; + } } xb_add_32(error, &xb, 0); /* empty fsl info */ xb_add_32(error, &xb, mntflag); /* MNT flags */ @@ -1407,11 +1585,11 @@ nfs_mount_diskless_private( end_offset = xb_offset(&xb); if (!error) { error = xb_seek(&xb, argslength_offset); - xb_add_32(error, &xb, end_offset - argslength_offset + XDRWORD/*version*/); + xb_add_32(error, &xb, end_offset - argslength_offset + XDRWORD /*version*/); } if (!error) { error = xb_seek(&xb, attrslength_offset); - xb_add_32(error, &xb, end_offset - attrslength_offset - XDRWORD/*don't include length field*/); + xb_add_32(error, &xb, end_offset - attrslength_offset - XDRWORD /*don't include length field*/); } if (error) { printf("nfs_mountroot: error %d assembling mount args\n", error); @@ -1424,6 +1602,7 @@ nfs_mount_diskless_private( /* do the mount */ if ((error = mountnfs(xdrbuf, mp, ctx, &vp))) { printf("nfs_mountroot: mount %s failed: %d\n", mntname, error); + vnode_put(mp->mnt_vnodecovered); mount_list_lock(); vfsp->vfc_refcount--; mount_list_unlock(); @@ -1432,7 +1611,7 @@ nfs_mount_diskless_private( #if CONFIG_MACF mac_mount_label_destroy(mp); #endif - FREE_ZONE(mp, sizeof (struct mount), M_MOUNT); + FREE_ZONE(mp, sizeof(struct mount), M_MOUNT); goto out; } @@ -1440,10 +1619,12 @@ nfs_mount_diskless_private( *vpp = vp; out: xb_cleanup(&xb); - return (error); + return error; } #endif /* NO_MOUNT_PRIVATE */ +#endif + /* * Convert old style NFS mount args to XDR. */ @@ -1469,8 +1650,9 @@ nfs_convert_old_nfs_args(mount_t mp, user_addr_t data, vfs_context_t ctx, int ar /* allocate a temporary buffer for mntfrom */ MALLOC_ZONE(mntfrom, char*, MAXPATHLEN, M_NAMEI, M_WAITOK); - if (!mntfrom) - return (ENOMEM); + if (!mntfrom) { + return ENOMEM; + } args64bit = (inkernel || vfs_context_is64bit(ctx)); argsp = args64bit ? (void*)&args : (void*)&tempargs; @@ -1491,10 +1673,11 @@ nfs_convert_old_nfs_args(mount_t mp, user_addr_t data, vfs_context_t ctx, int ar } /* read in the structure */ - if (inkernel) + if (inkernel) { bcopy(CAST_DOWN(void *, data), argsp, argsize); - else + } else { error = copyin(data, argsp, argsize); + } nfsmout_if(error); if (!args64bit) { @@ -1521,10 +1704,12 @@ nfs_convert_old_nfs_args(mount_t mp, user_addr_t data, vfs_context_t ctx, int ar args.acdirmin = tempargs.acdirmin; args.acdirmax = tempargs.acdirmax; } - if (args.version >= 5) + if (args.version >= 5) { args.auth = tempargs.auth; - if (args.version >= 6) + } + if (args.version >= 6) { args.deadtimeout = tempargs.deadtimeout; + } } if ((args.fhsize < 0) || (args.fhsize > NFS4_FHSIZE)) { @@ -1532,65 +1717,76 @@ nfs_convert_old_nfs_args(mount_t mp, user_addr_t data, vfs_context_t ctx, int ar goto nfsmout; } if (args.fhsize > 0) { - if (inkernel) + if (inkernel) { bcopy(CAST_DOWN(void *, args.fh), (caddr_t)nfh, args.fhsize); - else + } else { error = copyin(args.fh, (caddr_t)nfh, args.fhsize); + } nfsmout_if(error); } - if (inkernel) - error = copystr(CAST_DOWN(void *, args.hostname), mntfrom, MAXPATHLEN-1, &len); - else - error = copyinstr(args.hostname, mntfrom, MAXPATHLEN-1, &len); + if (inkernel) { + error = copystr(CAST_DOWN(void *, args.hostname), mntfrom, MAXPATHLEN - 1, &len); + } else { + error = copyinstr(args.hostname, mntfrom, MAXPATHLEN - 1, &len); + } nfsmout_if(error); bzero(&mntfrom[len], MAXPATHLEN - len); /* find the server-side path being mounted */ frompath = mntfrom; if (*frompath == '[') { /* skip IPv6 literal address */ - while (*frompath && (*frompath != ']')) + while (*frompath && (*frompath != ']')) { frompath++; - if (*frompath == ']') + } + if (*frompath == ']') { frompath++; + } } - while (*frompath && (*frompath != ':')) + while (*frompath && (*frompath != ':')) { frompath++; + } endserverp = frompath; - while (*frompath && (*frompath == ':')) + while (*frompath && (*frompath == ':')) { frompath++; + } /* count fs location path components */ p = frompath; - while (*p && (*p == '/')) + while (*p && (*p == '/')) { p++; + } numcomps = 0; while (*p) { numcomps++; - while (*p && (*p != '/')) + while (*p && (*p != '/')) { p++; - while (*p && (*p == '/')) + } + while (*p && (*p == '/')) { p++; + } } /* copy socket address */ - if (inkernel) + if (inkernel) { bcopy(CAST_DOWN(void *, args.addr), &ss, args.addrlen); - else { - if ((size_t)args.addrlen > sizeof (struct sockaddr_storage)) + } else { + if ((size_t)args.addrlen > sizeof(struct sockaddr_storage)) { error = EINVAL; - else + } else { error = copyin(args.addr, &ss, args.addrlen); + } } nfsmout_if(error); ss.ss_len = args.addrlen; /* convert address to universal address string */ - if (ss.ss_family == AF_INET) + if (ss.ss_family == AF_INET) { sinaddr = &((struct sockaddr_in*)&ss)->sin_addr; - else if (ss.ss_family == AF_INET6) + } else if (ss.ss_family == AF_INET6) { sinaddr = &((struct sockaddr_in6*)&ss)->sin6_addr; - else + } else { sinaddr = NULL; + } if (!sinaddr || (inet_ntop(ss.ss_family, sinaddr, uaddr, sizeof(uaddr)) != uaddr)) { error = EINVAL; goto nfsmout; @@ -1609,26 +1805,36 @@ nfs_convert_old_nfs_args(mount_t mp, user_addr_t data, vfs_context_t ctx, int ar NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_NONEGNAMECACHE); NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_MUTEJUKEBOX); NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_NOQUOTA); - if (args.flags & NFSMNT_SOFT) + if (args.flags & NFSMNT_SOFT) { NFS_BITMAP_SET(mflags, NFS_MFLAG_SOFT); - if (args.flags & NFSMNT_INT) + } + if (args.flags & NFSMNT_INT) { NFS_BITMAP_SET(mflags, NFS_MFLAG_INTR); - if (args.flags & NFSMNT_RESVPORT) + } + if (args.flags & NFSMNT_RESVPORT) { NFS_BITMAP_SET(mflags, NFS_MFLAG_RESVPORT); - if (args.flags & NFSMNT_NOCONN) + } + if (args.flags & NFSMNT_NOCONN) { NFS_BITMAP_SET(mflags, NFS_MFLAG_NOCONNECT); - if (args.flags & NFSMNT_DUMBTIMR) + } + if (args.flags & NFSMNT_DUMBTIMR) { NFS_BITMAP_SET(mflags, NFS_MFLAG_DUMBTIMER); - if (args.flags & NFSMNT_CALLUMNT) + } + if (args.flags & NFSMNT_CALLUMNT) { NFS_BITMAP_SET(mflags, NFS_MFLAG_CALLUMNT); - if (args.flags & NFSMNT_RDIRPLUS) + } + if (args.flags & NFSMNT_RDIRPLUS) { NFS_BITMAP_SET(mflags, NFS_MFLAG_RDIRPLUS); - if (args.flags & NFSMNT_NONEGNAMECACHE) + } + if (args.flags & NFSMNT_NONEGNAMECACHE) { NFS_BITMAP_SET(mflags, NFS_MFLAG_NONEGNAMECACHE); - if (args.flags & NFSMNT_MUTEJUKEBOX) + } + if (args.flags & NFSMNT_MUTEJUKEBOX) { NFS_BITMAP_SET(mflags, NFS_MFLAG_MUTEJUKEBOX); - if (args.flags & NFSMNT_NOQUOTA) + } + if (args.flags & NFSMNT_NOQUOTA) { NFS_BITMAP_SET(mflags, NFS_MFLAG_NOQUOTA); + } /* prepare mount attributes */ NFS_BITMAP_ZERO(mattrs, NFS_MATTR_BITMAP_LEN); @@ -1640,53 +1846,68 @@ nfs_convert_old_nfs_args(mount_t mp, user_addr_t data, vfs_context_t ctx, int ar NFS_BITMAP_SET(mattrs, NFS_MATTR_FS_LOCATIONS); NFS_BITMAP_SET(mattrs, NFS_MATTR_MNTFLAGS); NFS_BITMAP_SET(mattrs, NFS_MATTR_MNTFROM); - if (args.flags & NFSMNT_NFSV4) + if (args.flags & NFSMNT_NFSV4) { nfsvers = 4; - else if (args.flags & NFSMNT_NFSV3) + } else if (args.flags & NFSMNT_NFSV3) { nfsvers = 3; - else + } else { nfsvers = 2; - if ((args.flags & NFSMNT_RSIZE) && (args.rsize > 0)) + } + if ((args.flags & NFSMNT_RSIZE) && (args.rsize > 0)) { NFS_BITMAP_SET(mattrs, NFS_MATTR_READ_SIZE); - if ((args.flags & NFSMNT_WSIZE) && (args.wsize > 0)) + } + if ((args.flags & NFSMNT_WSIZE) && (args.wsize > 0)) { NFS_BITMAP_SET(mattrs, NFS_MATTR_WRITE_SIZE); - if ((args.flags & NFSMNT_TIMEO) && (args.timeo > 0)) + } + if ((args.flags & NFSMNT_TIMEO) && (args.timeo > 0)) { NFS_BITMAP_SET(mattrs, NFS_MATTR_REQUEST_TIMEOUT); - if ((args.flags & NFSMNT_RETRANS) && (args.retrans > 0)) + } + if ((args.flags & NFSMNT_RETRANS) && (args.retrans > 0)) { NFS_BITMAP_SET(mattrs, NFS_MATTR_SOFT_RETRY_COUNT); - if ((args.flags & NFSMNT_MAXGRPS) && (args.maxgrouplist > 0)) + } + if ((args.flags & NFSMNT_MAXGRPS) && (args.maxgrouplist > 0)) { NFS_BITMAP_SET(mattrs, NFS_MATTR_MAX_GROUP_LIST); - if ((args.flags & NFSMNT_READAHEAD) && (args.readahead > 0)) + } + if ((args.flags & NFSMNT_READAHEAD) && (args.readahead > 0)) { NFS_BITMAP_SET(mattrs, NFS_MATTR_READAHEAD); - if ((args.flags & NFSMNT_READDIRSIZE) && (args.readdirsize > 0)) + } + if ((args.flags & NFSMNT_READDIRSIZE) && (args.readdirsize > 0)) { NFS_BITMAP_SET(mattrs, NFS_MATTR_READDIR_SIZE); + } if ((args.flags & NFSMNT_NOLOCKS) || (args.flags & NFSMNT_LOCALLOCKS)) { NFS_BITMAP_SET(mattrs, NFS_MATTR_LOCK_MODE); - if (args.flags & NFSMNT_NOLOCKS) + if (args.flags & NFSMNT_NOLOCKS) { nfslockmode = NFS_LOCK_MODE_DISABLED; - else if (args.flags & NFSMNT_LOCALLOCKS) + } else if (args.flags & NFSMNT_LOCALLOCKS) { nfslockmode = NFS_LOCK_MODE_LOCAL; - else + } else { nfslockmode = NFS_LOCK_MODE_ENABLED; + } } if (args.version >= 4) { - if ((args.flags & NFSMNT_ACREGMIN) && (args.acregmin > 0)) + if ((args.flags & NFSMNT_ACREGMIN) && (args.acregmin > 0)) { NFS_BITMAP_SET(mattrs, NFS_MATTR_ATTRCACHE_REG_MIN); - if ((args.flags & NFSMNT_ACREGMAX) && (args.acregmax > 0)) + } + if ((args.flags & NFSMNT_ACREGMAX) && (args.acregmax > 0)) { NFS_BITMAP_SET(mattrs, NFS_MATTR_ATTRCACHE_REG_MAX); - if ((args.flags & NFSMNT_ACDIRMIN) && (args.acdirmin > 0)) + } + if ((args.flags & NFSMNT_ACDIRMIN) && (args.acdirmin > 0)) { NFS_BITMAP_SET(mattrs, NFS_MATTR_ATTRCACHE_DIR_MIN); - if ((args.flags & NFSMNT_ACDIRMAX) && (args.acdirmax > 0)) + } + if ((args.flags & NFSMNT_ACDIRMAX) && (args.acdirmax > 0)) { NFS_BITMAP_SET(mattrs, NFS_MATTR_ATTRCACHE_DIR_MAX); + } } if (args.version >= 5) { - if ((args.flags & NFSMNT_SECFLAVOR) || (args.flags & NFSMNT_SECSYSOK)) + if ((args.flags & NFSMNT_SECFLAVOR) || (args.flags & NFSMNT_SECSYSOK)) { NFS_BITMAP_SET(mattrs, NFS_MATTR_SECURITY); + } } if (args.version >= 6) { - if ((args.flags & NFSMNT_DEADTIMEOUT) && (args.deadtimeout > 0)) + if ((args.flags & NFSMNT_DEADTIMEOUT) && (args.deadtimeout > 0)) { NFS_BITMAP_SET(mattrs, NFS_MATTR_DEAD_TIMEOUT); + } } /* build xdr buffer */ @@ -1701,14 +1922,18 @@ nfs_convert_old_nfs_args(mount_t mp, user_addr_t data, vfs_context_t ctx, int ar xb_add_bitmap(error, &xb, mflags_mask, NFS_MFLAG_BITMAP_LEN); /* mask */ xb_add_bitmap(error, &xb, mflags, NFS_MFLAG_BITMAP_LEN); /* value */ xb_add_32(error, &xb, nfsvers); - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_READ_SIZE)) + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_READ_SIZE)) { xb_add_32(error, &xb, args.rsize); - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_WRITE_SIZE)) + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_WRITE_SIZE)) { xb_add_32(error, &xb, args.wsize); - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_READDIR_SIZE)) + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_READDIR_SIZE)) { xb_add_32(error, &xb, args.readdirsize); - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_READAHEAD)) + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_READAHEAD)) { xb_add_32(error, &xb, args.readahead); + } if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_ATTRCACHE_REG_MIN)) { xb_add_32(error, &xb, args.acregmin); xb_add_32(error, &xb, 0); @@ -1725,38 +1950,46 @@ nfs_convert_old_nfs_args(mount_t mp, user_addr_t data, vfs_context_t ctx, int ar xb_add_32(error, &xb, args.acdirmax); xb_add_32(error, &xb, 0); } - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_LOCK_MODE)) + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_LOCK_MODE)) { xb_add_32(error, &xb, nfslockmode); + } if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_SECURITY)) { - uint32_t flavors[2], i=0; - if (args.flags & NFSMNT_SECFLAVOR) + uint32_t flavors[2], i = 0; + if (args.flags & NFSMNT_SECFLAVOR) { flavors[i++] = args.auth; - if ((args.flags & NFSMNT_SECSYSOK) && ((i == 0) || (flavors[0] != RPCAUTH_SYS))) + } + if ((args.flags & NFSMNT_SECSYSOK) && ((i == 0) || (flavors[0] != RPCAUTH_SYS))) { flavors[i++] = RPCAUTH_SYS; + } xb_add_word_array(error, &xb, flavors, i); } - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MAX_GROUP_LIST)) + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MAX_GROUP_LIST)) { xb_add_32(error, &xb, args.maxgrouplist); - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_SOCKET_TYPE)) + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_SOCKET_TYPE)) { xb_add_string(error, &xb, ((args.sotype == SOCK_DGRAM) ? "udp" : "tcp"), 3); - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_PORT)) - xb_add_32(error, &xb, ((ss.ss_family == AF_INET) ? - ntohs(((struct sockaddr_in*)&ss)->sin_port) : - ntohs(((struct sockaddr_in6*)&ss)->sin6_port))); + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_PORT)) { + xb_add_32(error, &xb, ((ss.ss_family == AF_INET) ? + ntohs(((struct sockaddr_in*)&ss)->sin_port) : + ntohs(((struct sockaddr_in6*)&ss)->sin6_port))); + } /* NFS_MATTR_MOUNT_PORT (not available in old args) */ if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_REQUEST_TIMEOUT)) { /* convert from .1s increments to time */ - xb_add_32(error, &xb, args.timeo/10); - xb_add_32(error, &xb, (args.timeo%10)*100000000); + xb_add_32(error, &xb, args.timeo / 10); + xb_add_32(error, &xb, (args.timeo % 10) * 100000000); } - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_SOFT_RETRY_COUNT)) + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_SOFT_RETRY_COUNT)) { xb_add_32(error, &xb, args.retrans); + } if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_DEAD_TIMEOUT)) { xb_add_32(error, &xb, args.deadtimeout); xb_add_32(error, &xb, 0); } - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_FH)) + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_FH)) { xb_add_fh(error, &xb, &nfh[0], args.fhsize); + } if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_FS_LOCATIONS)) { xb_add_32(error, &xb, 1); /* fs location count */ xb_add_32(error, &xb, 1); /* server count */ @@ -1767,32 +2000,37 @@ nfs_convert_old_nfs_args(mount_t mp, user_addr_t data, vfs_context_t ctx, int ar xb_add_32(error, &xb, numcomps); /* pathname component count */ nfsmout_if(error); p = frompath; - while (*p && (*p == '/')) + while (*p && (*p == '/')) { p++; + } while (*p) { cp = p; - while (*p && (*p != '/')) + while (*p && (*p != '/')) { p++; + } xb_add_string(error, &xb, cp, (p - cp)); /* component */ nfsmout_if(error); - while (*p && (*p == '/')) + while (*p && (*p == '/')) { p++; + } } xb_add_32(error, &xb, 0); /* empty fsl info */ } - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MNTFLAGS)) + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MNTFLAGS)) { xb_add_32(error, &xb, (vfs_flags(mp) & MNT_VISFLAGMASK)); /* VFS MNT_* flags */ - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MNTFROM)) + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MNTFROM)) { xb_add_string(error, &xb, mntfrom, strlen(mntfrom)); /* fixed f_mntfromname */ + } xb_build_done(error, &xb); /* update opaque counts */ end_offset = xb_offset(&xb); error = xb_seek(&xb, argslength_offset); - xb_add_32(error, &xb, end_offset - argslength_offset + XDRWORD/*version*/); + xb_add_32(error, &xb, end_offset - argslength_offset + XDRWORD /*version*/); nfsmout_if(error); error = xb_seek(&xb, attrslength_offset); - xb_add_32(error, &xb, end_offset - attrslength_offset - XDRWORD/*don't include length field*/); + xb_add_32(error, &xb, end_offset - attrslength_offset - XDRWORD /*don't include length field*/); if (!error) { /* grab the assembled buffer */ @@ -1802,7 +2040,7 @@ nfs_convert_old_nfs_args(mount_t mp, user_addr_t data, vfs_context_t ctx, int ar nfsmout: xb_cleanup(&xb); FREE_ZONE(mntfrom, MAXPATHLEN, M_NAMEI); - return (error); + return error; } /* @@ -1818,14 +2056,16 @@ nfs_vfs_mount(mount_t mp, vnode_t vp, user_addr_t data, vfs_context_t ctx) char *xdrbuf = NULL; /* read in version */ - if (inkernel) + if (inkernel) { bcopy(CAST_DOWN(void *, data), &argsversion, sizeof(argsversion)); - else if ((error = copyin(data, &argsversion, sizeof(argsversion)))) - return (error); + } else if ((error = copyin(data, &argsversion, sizeof(argsversion)))) { + return error; + } /* If we have XDR args, then all values in the buffer are in network order */ - if (argsversion == htonl(NFS_ARGSVERSION_XDR)) + if (argsversion == htonl(NFS_ARGSVERSION_XDR)) { argsversion = NFS_ARGSVERSION_XDR; + } switch (argsversion) { case 3: @@ -1837,15 +2077,17 @@ nfs_vfs_mount(mount_t mp, vnode_t vp, user_addr_t data, vfs_context_t ctx) break; case NFS_ARGSVERSION_XDR: /* copy in xdr buffer */ - if (inkernel) + if (inkernel) { bcopy(CAST_DOWN(void *, (data + XDRWORD)), &argslength, XDRWORD); - else + } else { error = copyin((data + XDRWORD), &argslength, XDRWORD); - if (error) + } + if (error) { break; + } argslength = ntohl(argslength); /* put a reasonable limit on the size of the XDR args */ - if (argslength > 16*1024) { + if (argslength > 16 * 1024) { error = E2BIG; break; } @@ -1855,22 +2097,24 @@ nfs_vfs_mount(mount_t mp, vnode_t vp, user_addr_t data, vfs_context_t ctx) error = ENOMEM; break; } - if (inkernel) + if (inkernel) { bcopy(CAST_DOWN(void *, data), xdrbuf, argslength); - else + } else { error = copyin(data, xdrbuf, argslength); + } break; default: error = EPROGMISMATCH; } if (error) { - if (xdrbuf) + if (xdrbuf) { xb_free(xdrbuf); - return (error); + } + return error; } error = mountnfs(xdrbuf, mp, ctx, &vp); - return (error); + return error; } /* @@ -1890,24 +2134,28 @@ nfs3_mount( *npp = NULL; - if (!nmp->nm_fh) - return (EINVAL); + if (!nmp->nm_fh) { + return EINVAL; + } /* * Get file attributes for the mountpoint. These are needed * in order to properly create the root vnode. */ error = nfs3_getattr_rpc(NULL, nmp->nm_mountp, nmp->nm_fh->fh_data, nmp->nm_fh->fh_len, 0, - ctx, &nvattr, &xid); - if (error) + ctx, &nvattr, &xid); + if (error) { goto out; + } error = nfs_nget(nmp->nm_mountp, NULL, NULL, nmp->nm_fh->fh_data, nmp->nm_fh->fh_len, - &nvattr, &xid, RPCAUTH_UNKNOWN, NG_MARKROOT, npp); - if (*npp) + &nvattr, &xid, RPCAUTH_UNKNOWN, NG_MARKROOT, npp); + if (*npp) { nfs_node_unlock(*npp); - if (error) + } + if (error) { goto out; + } /* * Try to make sure we have all the general info from the server. @@ -1918,8 +2166,9 @@ nfs3_mount( } else if (nmp->nm_vers == NFS_VER3) { /* get the NFSv3 FSINFO */ error = nfs3_fsinfo(nmp, *npp, ctx); - if (error) + if (error) { goto out; + } /* If the server indicates all pathconf info is */ /* the same, grab a copy of that info now */ if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_HOMOGENEOUS) && @@ -1939,9 +2188,10 @@ out: vnode_recycle(NFSTOV(*npp)); *npp = NULL; } - return (error); + return error; } +#if CONFIG_NFS4 /* * Update an NFSv4 mount path with the contents of the symlink. * @@ -1961,21 +2211,23 @@ nfs4_mount_update_path_with_symlink(struct nfsmount *nmp, struct nfs_fs_path *nf struct nfs_fs_path nfsp2; bzero(&nfsp2, sizeof(nfsp2)); - if (dirfhp->fh_len) + if (dirfhp->fh_len) { NFSREQ_SECINFO_SET(&si, NULL, dirfhp->fh_data, dirfhp->fh_len, nfsp->np_components[curcomp], 0); - else + } else { NFSREQ_SECINFO_SET(&si, NULL, NULL, 0, nfsp->np_components[curcomp], 0); + } nfsm_chain_null(&nmreq); nfsm_chain_null(&nmrep); - MALLOC_ZONE(link, char *, MAXPATHLEN, M_NAMEI, M_WAITOK); - if (!link) + MALLOC_ZONE(link, char *, MAXPATHLEN, M_NAMEI, M_WAITOK); + if (!link) { error = ENOMEM; + } // PUTFH, READLINK numops = 2; nfsm_chain_build_alloc_init(error, &nmreq, 12 * NFSX_UNSIGNED); - nfsm_chain_add_compound_header(error, &nmreq, "readlink", numops); + nfsm_chain_add_compound_header(error, &nmreq, "readlink", nmp->nm_minor_vers, numops); numops--; nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH); nfsm_chain_add_fh(error, &nmreq, NFS_VER4, fhp->fh_data, fhp->fh_len); @@ -1986,9 +2238,10 @@ nfs4_mount_update_path_with_symlink(struct nfsmount *nmp, struct nfs_fs_path *nf nfsmout_if(error); error = nfs_request_async(NULL, nmp->nm_mountp, &nmreq, NFSPROC4_COMPOUND, - vfs_context_thread(ctx), vfs_context_ucred(ctx), &si, 0, NULL, &req); - if (!error) + vfs_context_thread(ctx), vfs_context_ucred(ctx), &si, 0, NULL, &req); + if (!error) { error = nfs_request_async_finish(req, &nmrep, &xid, &status); + } nfsm_chain_skip_tag(error, &nmrep); nfsm_chain_get_32(error, &nmrep, numops); @@ -1996,10 +2249,11 @@ nfs4_mount_update_path_with_symlink(struct nfsmount *nmp, struct nfs_fs_path *nf nfsm_chain_op_check(error, &nmrep, NFS_OP_READLINK); nfsm_chain_get_32(error, &nmrep, len); nfsmout_if(error); - if (len == 0) + if (len == 0) { error = ENOENT; - else if (len >= MAXPATHLEN) + } else if (len >= MAXPATHLEN) { len = MAXPATHLEN - 1; + } nfsm_chain_get_opaque(error, &nmrep, len, link); nfsmout_if(error); /* make sure link string is terminated properly */ @@ -2007,19 +2261,22 @@ nfs4_mount_update_path_with_symlink(struct nfsmount *nmp, struct nfs_fs_path *nf /* count the number of components in link */ p = link; - while (*p && (*p == '/')) + while (*p && (*p == '/')) { p++; + } linkcompcount = 0; while (*p) { linkcompcount++; - while (*p && (*p != '/')) + while (*p && (*p != '/')) { p++; - while (*p && (*p == '/')) + } + while (*p && (*p == '/')) { p++; + } } /* free up used components */ - for (comp=0; comp <= curcomp; comp++) { + for (comp = 0; comp <= curcomp; comp++) { if (nfsp->np_components[comp]) { FREE(nfsp->np_components[comp], M_TEMP); nfsp->np_components[comp] = NULL; @@ -2028,7 +2285,7 @@ nfs4_mount_update_path_with_symlink(struct nfsmount *nmp, struct nfs_fs_path *nf /* set up new path */ nfsp2.np_compcount = nfsp->np_compcount - curcomp - 1 + linkcompcount; - MALLOC(nfsp2.np_components, char **, nfsp2.np_compcount*sizeof(char*), M_TEMP, M_WAITOK|M_ZERO); + MALLOC(nfsp2.np_components, char **, nfsp2.np_compcount * sizeof(char*), M_TEMP, M_WAITOK | M_ZERO); if (!nfsp2.np_components) { error = ENOMEM; goto nfsmout; @@ -2036,30 +2293,33 @@ nfs4_mount_update_path_with_symlink(struct nfsmount *nmp, struct nfs_fs_path *nf /* add link components */ p = link; - while (*p && (*p == '/')) + while (*p && (*p == '/')) { p++; - for (newcomp=0; newcomp < linkcompcount; newcomp++) { + } + for (newcomp = 0; newcomp < linkcompcount; newcomp++) { /* find end of component */ q = p; - while (*q && (*q != '/')) + while (*q && (*q != '/')) { q++; - MALLOC(nfsp2.np_components[newcomp], char *, q-p+1, M_TEMP, M_WAITOK|M_ZERO); + } + MALLOC(nfsp2.np_components[newcomp], char *, q - p + 1, M_TEMP, M_WAITOK | M_ZERO); if (!nfsp2.np_components[newcomp]) { error = ENOMEM; break; } ch = *q; *q = '\0'; - strlcpy(nfsp2.np_components[newcomp], p, q-p+1); + strlcpy(nfsp2.np_components[newcomp], p, q - p + 1); *q = ch; p = q; - while (*p && (*p == '/')) + while (*p && (*p == '/')) { p++; + } } nfsmout_if(error); /* add remaining components */ - for(comp = curcomp + 1; comp < nfsp->np_compcount; comp++,newcomp++) { + for (comp = curcomp + 1; comp < nfsp->np_compcount; comp++, newcomp++) { nfsp2.np_components[newcomp] = nfsp->np_components[comp]; nfsp->np_components[comp] = NULL; } @@ -2076,17 +2336,20 @@ nfs4_mount_update_path_with_symlink(struct nfsmount *nmp, struct nfs_fs_path *nf *depthp = 0; } nfsmout: - if (link) + if (link) { FREE_ZONE(link, MAXPATHLEN, M_NAMEI); + } if (nfsp2.np_components) { - for (comp=0; comp < nfsp2.np_compcount; comp++) - if (nfsp2.np_components[comp]) + for (comp = 0; comp < nfsp2.np_compcount; comp++) { + if (nfsp2.np_components[comp]) { FREE(nfsp2.np_components[comp], M_TEMP); + } + } FREE(nfsp2.np_components, M_TEMP); } nfsm_chain_cleanup(&nmreq); nfsm_chain_cleanup(&nmrep); - return (error); + return error; } /* Set up an NFSv4 mount */ @@ -2126,30 +2389,32 @@ nfs4_mount( * mounting. If we are mounting the server's root, we'll need to defer the * SECINFO call to the first successful LOOKUP request. */ - if (!nmp->nm_sec.count) + if (!nmp->nm_sec.count) { nmp->nm_state |= NFSSTA_NEEDSECINFO; + } /* make a copy of the current location's path */ nfsp = &nmp->nm_locations.nl_locations[nmp->nm_locations.nl_current.nli_loc]->nl_path; bzero(&fspath, sizeof(fspath)); fspath.np_compcount = nfsp->np_compcount; if (fspath.np_compcount > 0) { - MALLOC(fspath.np_components, char **, fspath.np_compcount*sizeof(char*), M_TEMP, M_WAITOK|M_ZERO); + MALLOC(fspath.np_components, char **, fspath.np_compcount * sizeof(char*), M_TEMP, M_WAITOK | M_ZERO); if (!fspath.np_components) { error = ENOMEM; goto nfsmout; } - for (comp=0; comp < nfsp->np_compcount; comp++) { + for (comp = 0; comp < nfsp->np_compcount; comp++) { int slen = strlen(nfsp->np_components[comp]); - MALLOC(fspath.np_components[comp], char *, slen+1, M_TEMP, M_WAITOK|M_ZERO); + MALLOC(fspath.np_components[comp], char *, slen + 1, M_TEMP, M_WAITOK | M_ZERO); if (!fspath.np_components[comp]) { error = ENOMEM; break; } - strlcpy(fspath.np_components[comp], nfsp->np_components[comp], slen+1); + strlcpy(fspath.np_components[comp], nfsp->np_components[comp], slen + 1); } - if (error) + if (error) { goto nfsmout; + } } /* for mirror mounts, we can just use the file handle passed in */ @@ -2169,7 +2434,7 @@ nocomponents: NFSREQ_SECINFO_SET(&si, NULL, NULL, 0, NULL, 0); numops = 2; nfsm_chain_build_alloc_init(error, &nmreq, 9 * NFSX_UNSIGNED); - nfsm_chain_add_compound_header(error, &nmreq, "mount", numops); + nfsm_chain_add_compound_header(error, &nmreq, "mount", nmp->nm_minor_vers, numops); numops--; nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTROOTFH); numops--; @@ -2182,9 +2447,10 @@ nocomponents: nfsm_assert(error, (numops == 0), EPROTO); nfsmout_if(error); error = nfs_request_async(NULL, nmp->nm_mountp, &nmreq, NFSPROC4_COMPOUND, - vfs_context_thread(ctx), vfs_context_ucred(ctx), &si, 0, NULL, &req); - if (!error) + vfs_context_thread(ctx), vfs_context_ucred(ctx), &si, 0, NULL, &req); + if (!error) { error = nfs_request_async_finish(req, &nmrep, &xid, &status); + } nfsm_chain_skip_tag(error, &nmrep); nfsm_chain_get_32(error, &nmrep, numops); nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTROOTFH); @@ -2204,7 +2470,7 @@ nocomponents: } /* look up each path component */ - for (comp=0; comp < fspath.np_compcount; ) { + for (comp = 0; comp < fspath.np_compcount;) { isdotdot = 0; if (fspath.np_components[comp][0] == '.') { if (fspath.np_components[comp][1] == '\0') { @@ -2214,8 +2480,9 @@ nocomponents: } /* treat ".." specially */ if ((fspath.np_components[comp][1] == '.') && - (fspath.np_components[comp][2] == '\0')) - isdotdot = 1; + (fspath.np_components[comp][2] == '\0')) { + isdotdot = 1; + } if (isdotdot && (dirfh.fh_len == 0)) { /* ".." in root directory is same as "." */ comp++; @@ -2223,13 +2490,14 @@ nocomponents: } } // PUT(ROOT)FH + LOOKUP(P) + GETFH + GETATTR - if (dirfh.fh_len == 0) + if (dirfh.fh_len == 0) { NFSREQ_SECINFO_SET(&si, NULL, NULL, 0, isdotdot ? NULL : fspath.np_components[comp], 0); - else + } else { NFSREQ_SECINFO_SET(&si, NULL, dirfh.fh_data, dirfh.fh_len, isdotdot ? NULL : fspath.np_components[comp], 0); + } numops = 4; nfsm_chain_build_alloc_init(error, &nmreq, 18 * NFSX_UNSIGNED); - nfsm_chain_add_compound_header(error, &nmreq, "mount", numops); + nfsm_chain_add_compound_header(error, &nmreq, "mount", nmp->nm_minor_vers, numops); numops--; if (dirfh.fh_len) { nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH); @@ -2243,7 +2511,7 @@ nocomponents: } else { nfsm_chain_add_32(error, &nmreq, NFS_OP_LOOKUP); nfsm_chain_add_name(error, &nmreq, - fspath.np_components[comp], strlen(fspath.np_components[comp]), nmp); + fspath.np_components[comp], strlen(fspath.np_components[comp]), nmp); } numops--; nfsm_chain_add_32(error, &nmreq, NFS_OP_GETFH); @@ -2252,16 +2520,18 @@ nocomponents: NFS_CLEAR_ATTRIBUTES(bitmap); NFS4_DEFAULT_ATTRIBUTES(bitmap); /* if no namedattr support or component is ".zfs", clear NFS_FATTR_NAMED_ATTR */ - if (NMFLAG(nmp, NONAMEDATTR) || !strcmp(fspath.np_components[comp], ".zfs")) + if (!NMFLAG(nmp, NAMEDATTR) || !strcmp(fspath.np_components[comp], ".zfs")) { NFS_BITMAP_CLR(bitmap, NFS_FATTR_NAMED_ATTR); + } nfsm_chain_add_bitmap(error, &nmreq, bitmap, NFS_ATTR_BITMAP_LEN); nfsm_chain_build_done(error, &nmreq); nfsm_assert(error, (numops == 0), EPROTO); nfsmout_if(error); error = nfs_request_async(NULL, nmp->nm_mountp, &nmreq, NFSPROC4_COMPOUND, - vfs_context_thread(ctx), vfs_context_ucred(ctx), &si, 0, NULL, &req); - if (!error) + vfs_context_thread(ctx), vfs_context_ucred(ctx), &si, 0, NULL, &req); + if (!error) { error = nfs_request_async_finish(req, &nmrep, &xid, &status); + } nfsm_chain_skip_tag(error, &nmrep); nfsm_chain_get_32(error, &nmrep, numops); nfsm_chain_op_check(error, &nmrep, dirfh.fh_len ? NFS_OP_PUTFH : NFS_OP_PUTROOTFH); @@ -2269,6 +2539,10 @@ nocomponents: nfsmout_if(error); nfsm_chain_op_check(error, &nmrep, NFS_OP_GETFH); nfsm_chain_get_32(error, &nmrep, fh.fh_len); + if (fh.fh_len > sizeof(fh.fh_data)) { + error = EBADRPC; + } + nfsmout_if(error); nfsm_chain_get_opaque(error, &nmrep, fh.fh_len, fh.fh_data); nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR); if (!error) { @@ -2282,8 +2556,9 @@ nocomponents: /* Try the lookup again with a getattr for fs_locations. */ nfs_fs_locations_cleanup(&nfsls); error = nfs4_get_fs_locations(nmp, NULL, dirfh.fh_data, dirfh.fh_len, fspath.np_components[comp], ctx, &nfsls); - if (!error && (nfsls.nl_numlocs < 1)) + if (!error && (nfsls.nl_numlocs < 1)) { error = ENOENT; + } nfsmout_if(error); if (++loopcnt > MAXSYMLINKS) { /* too many symlink/referral redirections */ @@ -2298,22 +2573,23 @@ nocomponents: bzero(&nfsls, sizeof(nfsls)); /* initiate a connection using the new fs locations */ error = nfs_mount_connect(nmp); - if (!error && !(nmp->nm_locations.nl_current.nli_flags & NLI_VALID)) + if (!error && !(nmp->nm_locations.nl_current.nli_flags & NLI_VALID)) { error = EIO; + } nfsmout_if(error); /* add new server's remote path to beginning of our path and continue */ nfsp = &nmp->nm_locations.nl_locations[nmp->nm_locations.nl_current.nli_loc]->nl_path; bzero(&fspath2, sizeof(fspath2)); fspath2.np_compcount = (fspath.np_compcount - comp - 1) + nfsp->np_compcount; if (fspath2.np_compcount > 0) { - MALLOC(fspath2.np_components, char **, fspath2.np_compcount*sizeof(char*), M_TEMP, M_WAITOK|M_ZERO); + MALLOC(fspath2.np_components, char **, fspath2.np_compcount * sizeof(char*), M_TEMP, M_WAITOK | M_ZERO); if (!fspath2.np_components) { error = ENOMEM; goto nfsmout; } - for (comp2=0; comp2 < nfsp->np_compcount; comp2++) { + for (comp2 = 0; comp2 < nfsp->np_compcount; comp2++) { int slen = strlen(nfsp->np_components[comp2]); - MALLOC(fspath2.np_components[comp2], char *, slen+1, M_TEMP, M_WAITOK|M_ZERO); + MALLOC(fspath2.np_components[comp2], char *, slen + 1, M_TEMP, M_WAITOK | M_ZERO); if (!fspath2.np_components[comp2]) { /* clean up fspath2, then error out */ while (comp2 > 0) { @@ -2324,10 +2600,11 @@ nocomponents: error = ENOMEM; goto nfsmout; } - strlcpy(fspath2.np_components[comp2], nfsp->np_components[comp2], slen+1); + strlcpy(fspath2.np_components[comp2], nfsp->np_components[comp2], slen + 1); + } + if ((fspath.np_compcount - comp - 1) > 0) { + bcopy(&fspath.np_components[comp + 1], &fspath2.np_components[nfsp->np_compcount], (fspath.np_compcount - comp - 1) * sizeof(char*)); } - if ((fspath.np_compcount - comp - 1) > 0) - bcopy(&fspath.np_components[comp+1], &fspath2.np_components[nfsp->np_compcount], (fspath.np_compcount - comp - 1)*sizeof(char*)); /* free up unused parts of old path (prior components and component array) */ do { FREE(fspath.np_components[comp], M_TEMP); @@ -2340,17 +2617,19 @@ nocomponents: dirfh.fh_len = 0; comp = 0; NVATTR_CLEANUP(&nvattr); - if (fspath.np_compcount == 0) + if (fspath.np_compcount == 0) { goto nocomponents; + } continue; } nfsmout_if(error); /* if file handle is for a symlink, then update the path with the symlink contents */ if (NFS_BITMAP_ISSET(&nvattr.nva_bitmap, NFS_FATTR_TYPE) && (nvattr.nva_type == VLNK)) { - if (++loopcnt > MAXSYMLINKS) + if (++loopcnt > MAXSYMLINKS) { error = ELOOP; - else + } else { error = nfs4_mount_update_path_with_symlink(nmp, &fspath, comp, &dirfh, &depth, &fh, ctx); + } nfsmout_if(error); /* directory file handle is either left the same or reset to root (if link was absolute) */ /* path traversal starts at beginning of the path again */ @@ -2362,37 +2641,41 @@ nocomponents: NVATTR_CLEANUP(&nvattr); nfs_fs_locations_cleanup(&nfsls); /* not a symlink... */ - if ((nmp->nm_state & NFSSTA_NEEDSECINFO) && (comp == (fspath.np_compcount-1)) && !isdotdot) { + if ((nmp->nm_state & NFSSTA_NEEDSECINFO) && (comp == (fspath.np_compcount - 1)) && !isdotdot) { /* need to get SECINFO for the directory being mounted */ - if (dirfh.fh_len == 0) + if (dirfh.fh_len == 0) { NFSREQ_SECINFO_SET(&si, NULL, NULL, 0, isdotdot ? NULL : fspath.np_components[comp], 0); - else + } else { NFSREQ_SECINFO_SET(&si, NULL, dirfh.fh_data, dirfh.fh_len, isdotdot ? NULL : fspath.np_components[comp], 0); + } sec.count = NX_MAX_SEC_FLAVORS; error = nfs4_secinfo_rpc(nmp, &si, vfs_context_ucred(ctx), sec.flavors, &sec.count); /* [sigh] some implementations return "illegal" error for unsupported ops */ - if (error == NFSERR_OP_ILLEGAL) + if (error == NFSERR_OP_ILLEGAL) { error = 0; + } nfsmout_if(error); /* set our default security flavor to the first in the list */ - if (sec.count) + if (sec.count) { nmp->nm_auth = sec.flavors[0]; + } nmp->nm_state &= ~NFSSTA_NEEDSECINFO; } /* advance directory file handle, component index, & update depth */ dirfh = fh; comp++; - if (!isdotdot) /* going down the hierarchy */ + if (!isdotdot) { /* going down the hierarchy */ depth++; - else if (--depth <= 0) /* going up the hierarchy */ + } else if (--depth <= 0) { /* going up the hierarchy */ dirfh.fh_len = 0; /* clear dirfh when we hit root */ + } } gotfh: /* get attrs for mount point root */ - numops = NMFLAG(nmp, NONAMEDATTR) ? 2 : 3; // PUTFH + GETATTR + OPENATTR + numops = NMFLAG(nmp, NAMEDATTR) ? 3 : 2; // PUTFH + GETATTR + OPENATTR nfsm_chain_build_alloc_init(error, &nmreq, 25 * NFSX_UNSIGNED); - nfsm_chain_add_compound_header(error, &nmreq, "mount", numops); + nfsm_chain_add_compound_header(error, &nmreq, "mount", nmp->nm_minor_vers, numops); numops--; nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH); nfsm_chain_add_fh(error, &nmreq, NFS_VER4, dirfh.fh_data, dirfh.fh_len); @@ -2401,10 +2684,11 @@ gotfh: NFS_CLEAR_ATTRIBUTES(bitmap); NFS4_DEFAULT_ATTRIBUTES(bitmap); /* if no namedattr support or last component is ".zfs", clear NFS_FATTR_NAMED_ATTR */ - if (NMFLAG(nmp, NONAMEDATTR) || ((fspath.np_compcount > 0) && !strcmp(fspath.np_components[fspath.np_compcount-1], ".zfs"))) + if (!NMFLAG(nmp, NAMEDATTR) || ((fspath.np_compcount > 0) && !strcmp(fspath.np_components[fspath.np_compcount - 1], ".zfs"))) { NFS_BITMAP_CLR(bitmap, NFS_FATTR_NAMED_ATTR); + } nfsm_chain_add_bitmap(error, &nmreq, bitmap, NFS_ATTR_BITMAP_LEN); - if (!NMFLAG(nmp, NONAMEDATTR)) { + if (NMFLAG(nmp, NAMEDATTR)) { numops--; nfsm_chain_add_32(error, &nmreq, NFS_OP_OPENATTR); nfsm_chain_add_32(error, &nmreq, 0); @@ -2413,9 +2697,10 @@ gotfh: nfsm_assert(error, (numops == 0), EPROTO); nfsmout_if(error); error = nfs_request_async(NULL, nmp->nm_mountp, &nmreq, NFSPROC4_COMPOUND, - vfs_context_thread(ctx), vfs_context_ucred(ctx), &si, 0, NULL, &req); - if (!error) + vfs_context_thread(ctx), vfs_context_ucred(ctx), &si, 0, NULL, &req); + if (!error) { error = nfs_request_async_finish(req, &nmrep, &xid, &status); + } nfsm_chain_skip_tag(error, &nmrep); nfsm_chain_get_32(error, &nmrep, numops); nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH); @@ -2424,10 +2709,11 @@ gotfh: NFS_CLEAR_ATTRIBUTES(nmp->nm_fsattr.nfsa_bitmap); error = nfs4_parsefattr(&nmrep, &nmp->nm_fsattr, &nvattr, NULL, NULL, NULL); nfsmout_if(error); - if (!NMFLAG(nmp, NONAMEDATTR)) { + if (NMFLAG(nmp, NAMEDATTR)) { nfsm_chain_op_check(error, &nmrep, NFS_OP_OPENATTR); - if (error == ENOENT) + if (error == ENOENT) { error = 0; + } /* [sigh] some implementations return "illegal" error for unsupported ops */ if (error || !NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_supp_attr, NFS_FATTR_NAMED_ATTR)) { nmp->nm_fsattr.nfsa_flags &= ~NFS_FSFLAG_NAMED_ATTR; @@ -2437,14 +2723,17 @@ gotfh: } else { nmp->nm_fsattr.nfsa_flags &= ~NFS_FSFLAG_NAMED_ATTR; } - if (NMFLAG(nmp, NOACL)) /* make sure ACL support is turned off */ + if (NMFLAG(nmp, NOACL)) { /* make sure ACL support is turned off */ nmp->nm_fsattr.nfsa_flags &= ~NFS_FSFLAG_ACL; - if (NMFLAG(nmp, ACLONLY) && !(nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_ACL)) + } + if (NMFLAG(nmp, ACLONLY) && !(nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_ACL)) { NFS_BITMAP_CLR(nmp->nm_flags, NFS_MFLAG_ACLONLY); + } if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_supp_attr, NFS_FATTR_FH_EXPIRE_TYPE)) { uint32_t fhtype = ((nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_FHTYPE_MASK) >> NFS_FSFLAG_FHTYPE_SHIFT); - if (fhtype != NFS_FH_PERSISTENT) + if (fhtype != NFS_FH_PERSISTENT) { printf("nfs: warning: non-persistent file handles! for %s\n", vfs_statfs(nmp->nm_mountp)->f_mntfromname); + } } /* make sure it's a directory */ @@ -2460,47 +2749,55 @@ gotfh: error = nfs_nget(nmp->nm_mountp, NULL, NULL, dirfh.fh_data, dirfh.fh_len, &nvattr, &xid, rq.r_auth, NG_MARKROOT, npp); nfsmout_if(error); - if (nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_ACL) + if (nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_ACL) { vfs_setextendedsecurity(nmp->nm_mountp); + } /* adjust I/O sizes to server limits */ if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_MAXREAD) && (nmp->nm_fsattr.nfsa_maxread > 0)) { if (nmp->nm_fsattr.nfsa_maxread < (uint64_t)nmp->nm_rsize) { nmp->nm_rsize = nmp->nm_fsattr.nfsa_maxread & ~(NFS_FABLKSIZE - 1); - if (nmp->nm_rsize == 0) + if (nmp->nm_rsize == 0) { nmp->nm_rsize = nmp->nm_fsattr.nfsa_maxread; + } } } if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_MAXWRITE) && (nmp->nm_fsattr.nfsa_maxwrite > 0)) { if (nmp->nm_fsattr.nfsa_maxwrite < (uint64_t)nmp->nm_wsize) { nmp->nm_wsize = nmp->nm_fsattr.nfsa_maxwrite & ~(NFS_FABLKSIZE - 1); - if (nmp->nm_wsize == 0) + if (nmp->nm_wsize == 0) { nmp->nm_wsize = nmp->nm_fsattr.nfsa_maxwrite; + } } } /* set up lease renew timer */ nmp->nm_renew_timer = thread_call_allocate(nfs4_renew_timer, nmp); interval = nmp->nm_fsattr.nfsa_lease / 2; - if (interval < 1) + if (interval < 1) { interval = 1; + } nfs_interval_timer_start(nmp->nm_renew_timer, interval * 1000); nfsmout: if (fspath.np_components) { - for (comp=0; comp < fspath.np_compcount; comp++) - if (fspath.np_components[comp]) + for (comp = 0; comp < fspath.np_compcount; comp++) { + if (fspath.np_components[comp]) { FREE(fspath.np_components[comp], M_TEMP); + } + } FREE(fspath.np_components, M_TEMP); } NVATTR_CLEANUP(&nvattr); nfs_fs_locations_cleanup(&nfsls); - if (*npp) + if (*npp) { nfs_node_unlock(*npp); + } nfsm_chain_cleanup(&nmreq); nfsm_chain_cleanup(&nmrep); - return (error); + return error; } +#endif /* CONFIG_NFS4 */ /* * Thread to handle initial NFS mount connection. @@ -2548,26 +2845,30 @@ nfs_mount_connect_thread(void *arg, __unused wait_result_t wr) } /* save the best error */ - if (nfs_connect_error_class(error) >= nfs_connect_error_class(savederror)) + if (nfs_connect_error_class(error) >= nfs_connect_error_class(savederror)) { savederror = error; + } if (done) { error = savederror; break; } /* pause before next attempt */ - if ((error = nfs_sigintr(nmp, NULL, current_thread(), 0))) + if ((error = nfs_sigintr(nmp, NULL, current_thread(), 0))) { break; - error = tsleep(nmp, PSOCK|slpflag, "nfs_mount_connect_retry", 2*hz); - if (error && (error != EWOULDBLOCK)) + } + error = tsleep(nmp, PSOCK | slpflag, "nfs_mount_connect_retry", 2 * hz); + if (error && (error != EWOULDBLOCK)) { break; + } error = savederror; } /* update status of mount connect */ lck_mtx_lock(&nmp->nm_lock); - if (!nmp->nm_mounterror) + if (!nmp->nm_mounterror) { nmp->nm_mounterror = error; + } nmp->nm_state &= ~NFSSTA_MOUNT_THREAD; lck_mtx_unlock(&nmp->nm_lock); wakeup(&nmp->nm_nss); @@ -2578,7 +2879,7 @@ nfs_mount_connect(struct nfsmount *nmp) { int error = 0, slpflag; thread_t thd; - struct timespec ts = { 2, 0 }; + struct timespec ts = { .tv_sec = 2, .tv_nsec = 0 }; /* * Set up the socket. Perform initial search for a location/server/address to @@ -2599,15 +2900,17 @@ nfs_mount_connect(struct nfsmount *nmp) /* wait until mount connect thread is finished/gone */ while (nmp->nm_state & NFSSTA_MOUNT_THREAD) { - error = msleep(&nmp->nm_nss, &nmp->nm_lock, slpflag|PSOCK, "nfsconnectthread", &ts); + error = msleep(&nmp->nm_nss, &nmp->nm_lock, slpflag | PSOCK, "nfsconnectthread", &ts); if ((error && (error != EWOULDBLOCK)) || ((error = nfs_sigintr(nmp, NULL, current_thread(), 1)))) { /* record error */ - if (!nmp->nm_mounterror) + if (!nmp->nm_mounterror) { nmp->nm_mounterror = error; + } /* signal the thread that we are aborting */ nmp->nm_sockflags |= NMSOCK_UNMOUNT; - if (nmp->nm_nss) + if (nmp->nm_nss) { wakeup(nmp->nm_nss); + } /* and continue waiting on it to finish */ slpflag = 0; } @@ -2617,9 +2920,24 @@ nfs_mount_connect(struct nfsmount *nmp) /* grab mount connect status */ error = nmp->nm_mounterror; - return (error); + return error; } +/* Table of maximum minor version for a given version */ +uint32_t maxminorverstab[] = { + 0, /* Version 0 (does not exist) */ + 0, /* Version 1 (does not exist) */ + 0, /* Version 2 */ + 0, /* Version 3 */ + 0, /* Version 4 */ +}; + +#define NFS_MAX_SUPPORTED_VERSION ((long)(sizeof (maxminorverstab) / sizeof (uint32_t) - 1)) +#define NFS_MAX_SUPPORTED_MINOR_VERSION(v) ((long)(maxminorverstab[(v)])) + +#define DEFAULT_NFS_MIN_VERS VER2PVER(2, 0) +#define DEFAULT_NFS_MAX_VERS VER2PVER(3, 0) + /* * Common code to mount an NFS file system. */ @@ -2635,31 +2953,45 @@ mountnfs( int error = 0; struct vfsstatfs *sbp; struct xdrbuf xb; - uint32_t i, val, vers = 0, minorvers, maxio, iosize, len; + uint32_t i, val, maxio, iosize, len; uint32_t *mattrs; uint32_t *mflags_mask; uint32_t *mflags; uint32_t argslength, attrslength; - struct nfs_location_index firstloc = { NLI_VALID, 0, 0, 0 }; + uid_t set_owner; + struct nfs_location_index firstloc = { + .nli_flags = NLI_VALID, + .nli_loc = 0, + .nli_serv = 0, + .nli_addr = 0 + }; + static const struct nfs_etype nfs_default_etypes = { + .count = NFS_MAX_ETYPES, + .selected = NFS_MAX_ETYPES, + .etypes = { NFS_AES256_CTS_HMAC_SHA1_96, + NFS_AES128_CTS_HMAC_SHA1_96, + NFS_DES3_CBC_SHA1_KD} + }; /* make sure mbuf constants are set up */ - if (!nfs_mbuf_mhlen) + if (!nfs_mbuf_mhlen) { nfs_mbuf_init(); + } if (vfs_flags(mp) & MNT_UPDATE) { nmp = VFSTONFS(mp); /* update paths, file handles, etc, here XXX */ xb_free(xdrbuf); - return (0); + return 0; } else { /* allocate an NFS mount structure for this mount */ MALLOC_ZONE(nmp, struct nfsmount *, - sizeof (struct nfsmount), M_NFSMNT, M_WAITOK); + sizeof(struct nfsmount), M_NFSMNT, M_WAITOK); if (!nmp) { xb_free(xdrbuf); - return (ENOMEM); + return ENOMEM; } - bzero((caddr_t)nmp, sizeof (struct nfsmount)); + bzero((caddr_t)nmp, sizeof(struct nfsmount)); lck_mtx_init(&nmp->nm_lock, nfs_mount_grp, LCK_ATTR_NULL); TAILQ_INIT(&nmp->nm_resendq); TAILQ_INIT(&nmp->nm_iodq); @@ -2669,13 +3001,23 @@ mountnfs( vfs_getnewfsid(mp); nmp->nm_mountp = mp; vfs_setauthopaque(mp); + /* + * Disable cache_lookup_path for NFS. NFS lookup always needs + * to be called to check if the directory attribute cache is + * valid and possibly purge the directory before calling + * cache_lookup. + */ + vfs_setauthcache_ttl(mp, 0); nfs_nhinit_finish(); nmp->nm_args = xdrbuf; /* set up defaults */ + nmp->nm_ref = 0; nmp->nm_vers = 0; + nmp->nm_min_vers = DEFAULT_NFS_MIN_VERS; + nmp->nm_max_vers = DEFAULT_NFS_MAX_VERS; nmp->nm_timeo = NFS_TIMEO; nmp->nm_retry = NFS_RETRANS; nmp->nm_sotype = 0; @@ -2687,19 +3029,27 @@ mountnfs( nmp->nm_numgrps = NFS_MAXGRPS; nmp->nm_readahead = NFS_DEFRAHEAD; nmp->nm_tprintf_delay = nfs_tprintf_delay; - if (nmp->nm_tprintf_delay < 0) + if (nmp->nm_tprintf_delay < 0) { nmp->nm_tprintf_delay = 0; + } nmp->nm_tprintf_initial_delay = nfs_tprintf_initial_delay; - if (nmp->nm_tprintf_initial_delay < 0) + if (nmp->nm_tprintf_initial_delay < 0) { nmp->nm_tprintf_initial_delay = 0; + } nmp->nm_acregmin = NFS_MINATTRTIMO; nmp->nm_acregmax = NFS_MAXATTRTIMO; nmp->nm_acdirmin = NFS_MINDIRATTRTIMO; nmp->nm_acdirmax = NFS_MAXDIRATTRTIMO; + nmp->nm_etype = nfs_default_etypes; nmp->nm_auth = RPCAUTH_SYS; + nmp->nm_iodlink.tqe_next = NFSNOLIST; nmp->nm_deadtimeout = 0; nmp->nm_curdeadtimeout = 0; + NFS_BITMAP_SET(nmp->nm_flags, NFS_MFLAG_RDIRPLUS); /* enable RDIRPLUS by default. It will be reverted later in case NFSv2 is used */ NFS_BITMAP_SET(nmp->nm_flags, NFS_MFLAG_NOACL); + nmp->nm_realm = NULL; + nmp->nm_principal = NULL; + nmp->nm_sprinc = NULL; } mattrs = nmp->nm_mattrs; @@ -2707,22 +3057,24 @@ mountnfs( mflags_mask = nmp->nm_mflags_mask; /* set up NFS mount with args */ - xb_init_buffer(&xb, xdrbuf, 2*XDRWORD); + xb_init_buffer(&xb, xdrbuf, 2 * XDRWORD); xb_get_32(error, &xb, val); /* version */ xb_get_32(error, &xb, argslength); /* args length */ nfsmerr_if(error); - xb_init_buffer(&xb, xdrbuf, argslength); /* restart parsing with actual buffer length */ + xb_init_buffer(&xb, xdrbuf, argslength); /* restart parsing with actual buffer length */ xb_get_32(error, &xb, val); /* version */ xb_get_32(error, &xb, argslength); /* args length */ xb_get_32(error, &xb, val); /* XDR args version */ - if (val != NFS_XDRARGS_VERSION_0) + if (val != NFS_XDRARGS_VERSION_0 || argslength < ((4 + NFS_MATTR_BITMAP_LEN + 1) * XDRWORD)) { error = EINVAL; + } len = NFS_MATTR_BITMAP_LEN; xb_get_bitmap(error, &xb, mattrs, len); /* mount attribute bitmap */ attrslength = 0; xb_get_32(error, &xb, attrslength); /* attrs length */ - if (!error && (attrslength > (argslength - ((4+NFS_MATTR_BITMAP_LEN+1)*XDRWORD)))) + if (!error && (attrslength > (argslength - ((4 + NFS_MATTR_BITMAP_LEN + 1) * XDRWORD)))) { error = EINVAL; + } nfsmerr_if(error); if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_FLAGS)) { len = NFS_MFLAG_BITMAP_LEN; @@ -2736,45 +3088,54 @@ mountnfs( } } if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_VERSION)) { - xb_get_32(error, &xb, vers); - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_MINOR_VERSION)) - xb_get_32(error, &xb, minorvers); - else - minorvers = 0; - nfsmerr_if(error); - switch (vers) { - case 2: - nmp->nm_vers = NFS_VER2; - break; - case 3: - nmp->nm_vers = NFS_VER3; - break; - case 4: - switch (minorvers) { - case 0: - nmp->nm_vers = NFS_VER4; - break; - default: - error = EINVAL; - } - break; - default: + /* Can't specify a single version and a range */ + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_VERSION_RANGE)) { error = EINVAL; } + xb_get_32(error, &xb, nmp->nm_vers); + if (nmp->nm_vers > NFS_MAX_SUPPORTED_VERSION || + nmp->nm_vers < NFS_VER2) { + error = EINVAL; + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_MINOR_VERSION)) { + xb_get_32(error, &xb, nmp->nm_minor_vers); + } else { + nmp->nm_minor_vers = maxminorverstab[nmp->nm_vers]; + } + if (nmp->nm_minor_vers > maxminorverstab[nmp->nm_vers]) { + error = EINVAL; + } + nmp->nm_max_vers = nmp->nm_min_vers = + VER2PVER(nmp->nm_vers, nmp->nm_minor_vers); } if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_MINOR_VERSION)) { - /* should have also gotten NFS version (and already gotten minorvers) */ - if (!NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_VERSION)) + /* should have also gotten NFS version (and already gotten minor version) */ + if (!NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_VERSION)) { + error = EINVAL; + } + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_VERSION_RANGE)) { + xb_get_32(error, &xb, nmp->nm_min_vers); + xb_get_32(error, &xb, nmp->nm_max_vers); + if ((nmp->nm_min_vers > nmp->nm_max_vers) || + (PVER2MAJOR(nmp->nm_max_vers) > NFS_MAX_SUPPORTED_VERSION) || + (PVER2MINOR(nmp->nm_min_vers) > maxminorverstab[PVER2MAJOR(nmp->nm_min_vers)]) || + (PVER2MINOR(nmp->nm_max_vers) > maxminorverstab[PVER2MAJOR(nmp->nm_max_vers)])) { error = EINVAL; + } } - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_READ_SIZE)) + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_READ_SIZE)) { xb_get_32(error, &xb, nmp->nm_rsize); - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_WRITE_SIZE)) + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_WRITE_SIZE)) { xb_get_32(error, &xb, nmp->nm_wsize); - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_READDIR_SIZE)) + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_READDIR_SIZE)) { xb_get_32(error, &xb, nmp->nm_readdirsize); - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_READAHEAD)) + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_READAHEAD)) { xb_get_32(error, &xb, nmp->nm_readahead); + } if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_ATTRCACHE_REG_MIN)) { xb_get_32(error, &xb, nmp->nm_acregmin); xb_skip(error, &xb, XDRWORD); @@ -2797,12 +3158,14 @@ mountnfs( switch (val) { case NFS_LOCK_MODE_DISABLED: case NFS_LOCK_MODE_LOCAL: +#if CONFIG_NFS4 if (nmp->nm_vers >= NFS_VER4) { /* disabled/local lock mode only allowed on v2/v3 */ error = EINVAL; break; } - /* FALLTHROUGH */ +#endif + /* FALLTHROUGH */ case NFS_LOCK_MODE_ENABLED: nmp->nm_lockmode = val; break; @@ -2814,11 +3177,12 @@ mountnfs( if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_SECURITY)) { uint32_t seccnt; xb_get_32(error, &xb, seccnt); - if (!error && ((seccnt < 1) || (seccnt > NX_MAX_SEC_FLAVORS))) + if (!error && ((seccnt < 1) || (seccnt > NX_MAX_SEC_FLAVORS))) { error = EINVAL; + } nfsmerr_if(error); nmp->nm_sec.count = seccnt; - for (i=0; i < seccnt; i++) { + for (i = 0; i < seccnt; i++) { xb_get_32(error, &xb, nmp->nm_sec.flavors[i]); /* Check for valid security flavor */ switch (nmp->nm_sec.flavors[i]) { @@ -2835,14 +3199,43 @@ mountnfs( /* start with the first flavor */ nmp->nm_auth = nmp->nm_sec.flavors[0]; } - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MAX_GROUP_LIST)) + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_KERB_ETYPE)) { + uint32_t etypecnt; + xb_get_32(error, &xb, etypecnt); + if (!error && ((etypecnt < 1) || (etypecnt > NFS_MAX_ETYPES))) { + error = EINVAL; + } + nfsmerr_if(error); + nmp->nm_etype.count = etypecnt; + xb_get_32(error, &xb, nmp->nm_etype.selected); + nfsmerr_if(error); + if (etypecnt) { + nmp->nm_etype.selected = etypecnt; /* Nothing is selected yet, so set selected to count */ + for (i = 0; i < etypecnt; i++) { + xb_get_32(error, &xb, nmp->nm_etype.etypes[i]); + /* Check for valid encryption type */ + switch (nmp->nm_etype.etypes[i]) { + case NFS_DES3_CBC_SHA1_KD: + case NFS_AES128_CTS_HMAC_SHA1_96: + case NFS_AES256_CTS_HMAC_SHA1_96: + break; + default: + error = EINVAL; + } + } + } + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MAX_GROUP_LIST)) { xb_get_32(error, &xb, nmp->nm_numgrps); + } if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_SOCKET_TYPE)) { - char sotype[6]; + char sotype[16]; + *sotype = '\0'; xb_get_32(error, &xb, val); - if (!error && ((val < 3) || (val > 5))) + if (!error && ((val < 3) || (val > sizeof(sotype)))) { error = EINVAL; + } nfsmerr_if(error); error = xb_get_bytes(&xb, sotype, val, 0); nfsmerr_if(error); @@ -2869,35 +3262,51 @@ mountnfs( nmp->nm_sofamily = AF_INET6; } else if (!strcmp(sotype, "inet")) { nmp->nm_sofamily = 0; /* ok */ + } else if (!strcmp(sotype, "ticotsord")) { + nmp->nm_sofamily = AF_LOCAL; + nmp->nm_sotype = SOCK_STREAM; + } else if (!strcmp(sotype, "ticlts")) { + nmp->nm_sofamily = AF_LOCAL; + nmp->nm_sotype = SOCK_DGRAM; } else { error = EINVAL; } +#if CONFIG_NFS4 if (!error && (nmp->nm_vers >= NFS_VER4) && nmp->nm_sotype && - (nmp->nm_sotype != SOCK_STREAM)) - error = EINVAL; /* NFSv4 is only allowed over TCP. */ + (nmp->nm_sotype != SOCK_STREAM)) { + error = EINVAL; /* NFSv4 is only allowed over TCP. */ + } +#endif + if (error) { + NFS_VFS_DBG("EINVAL sotype = \"%s\"\n", sotype); + } nfsmerr_if(error); } - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_PORT)) + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_PORT)) { xb_get_32(error, &xb, nmp->nm_nfsport); - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MOUNT_PORT)) + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MOUNT_PORT)) { xb_get_32(error, &xb, nmp->nm_mountport); + } if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_REQUEST_TIMEOUT)) { /* convert from time to 0.1s units */ xb_get_32(error, &xb, nmp->nm_timeo); xb_get_32(error, &xb, val); nfsmerr_if(error); - if (val >= 1000000000) + if (val >= 1000000000) { error = EINVAL; + } nfsmerr_if(error); nmp->nm_timeo *= 10; - nmp->nm_timeo += (val+100000000-1)/100000000; + nmp->nm_timeo += (val + 100000000 - 1) / 100000000; /* now convert to ticks */ nmp->nm_timeo = (nmp->nm_timeo * NFS_HZ + 5) / 10; } if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_SOFT_RETRY_COUNT)) { xb_get_32(error, &xb, val); - if (!error && (val > 1)) + if (!error && (val > 1)) { nmp->nm_retry = val; + } } if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_DEAD_TIMEOUT)) { xb_get_32(error, &xb, nmp->nm_deadtimeout); @@ -2905,12 +3314,17 @@ mountnfs( } if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_FH)) { nfsmerr_if(error); - MALLOC(nmp->nm_fh, fhandle_t *, sizeof(fhandle_t), M_TEMP, M_WAITOK|M_ZERO); - if (!nmp->nm_fh) + MALLOC(nmp->nm_fh, fhandle_t *, sizeof(fhandle_t), M_TEMP, M_WAITOK | M_ZERO); + if (!nmp->nm_fh) { error = ENOMEM; + } xb_get_32(error, &xb, nmp->nm_fh->fh_len); nfsmerr_if(error); - error = xb_get_bytes(&xb, (char*)&nmp->nm_fh->fh_data[0], nmp->nm_fh->fh_len, 0); + if ((size_t)nmp->nm_fh->fh_len > sizeof(nmp->nm_fh->fh_data)) { + error = EINVAL; + } else { + error = xb_get_bytes(&xb, (char*)&nmp->nm_fh->fh_data[0], nmp->nm_fh->fh_len, 0); + } } nfsmerr_if(error); if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_FS_LOCATIONS)) { @@ -2921,60 +3335,78 @@ mountnfs( xb_get_32(error, &xb, nmp->nm_locations.nl_numlocs); /* fs location count */ /* sanity check location count */ - if (!error && ((nmp->nm_locations.nl_numlocs < 1) || (nmp->nm_locations.nl_numlocs > 256))) + if (!error && ((nmp->nm_locations.nl_numlocs < 1) || (nmp->nm_locations.nl_numlocs > 256))) { + NFS_VFS_DBG("Invalid number of fs_locations: %d", nmp->nm_locations.nl_numlocs); error = EINVAL; + } nfsmerr_if(error); - MALLOC(nmp->nm_locations.nl_locations, struct nfs_fs_location **, nmp->nm_locations.nl_numlocs * sizeof(struct nfs_fs_location*), M_TEMP, M_WAITOK|M_ZERO); - if (!nmp->nm_locations.nl_locations) + MALLOC(nmp->nm_locations.nl_locations, struct nfs_fs_location **, nmp->nm_locations.nl_numlocs * sizeof(struct nfs_fs_location*), M_TEMP, M_WAITOK | M_ZERO); + if (!nmp->nm_locations.nl_locations) { error = ENOMEM; + } for (loc = 0; loc < nmp->nm_locations.nl_numlocs; loc++) { nfsmerr_if(error); - MALLOC(fsl, struct nfs_fs_location *, sizeof(struct nfs_fs_location), M_TEMP, M_WAITOK|M_ZERO); - if (!fsl) + MALLOC(fsl, struct nfs_fs_location *, sizeof(struct nfs_fs_location), M_TEMP, M_WAITOK | M_ZERO); + if (!fsl) { error = ENOMEM; + } nmp->nm_locations.nl_locations[loc] = fsl; xb_get_32(error, &xb, fsl->nl_servcount); /* server count */ /* sanity check server count */ - if (!error && ((fsl->nl_servcount < 1) || (fsl->nl_servcount > 256))) + if (!error && ((fsl->nl_servcount < 1) || (fsl->nl_servcount > 256))) { + NFS_VFS_DBG("Invalid server count %d", fsl->nl_servcount); error = EINVAL; + } nfsmerr_if(error); - MALLOC(fsl->nl_servers, struct nfs_fs_server **, fsl->nl_servcount * sizeof(struct nfs_fs_server*), M_TEMP, M_WAITOK|M_ZERO); - if (!fsl->nl_servers) + MALLOC(fsl->nl_servers, struct nfs_fs_server **, fsl->nl_servcount * sizeof(struct nfs_fs_server*), M_TEMP, M_WAITOK | M_ZERO); + if (!fsl->nl_servers) { error = ENOMEM; + NFS_VFS_DBG("Server count = %d, error = %d\n", fsl->nl_servcount, error); + } for (serv = 0; serv < fsl->nl_servcount; serv++) { nfsmerr_if(error); - MALLOC(fss, struct nfs_fs_server *, sizeof(struct nfs_fs_server), M_TEMP, M_WAITOK|M_ZERO); - if (!fss) + MALLOC(fss, struct nfs_fs_server *, sizeof(struct nfs_fs_server), M_TEMP, M_WAITOK | M_ZERO); + if (!fss) { error = ENOMEM; + } fsl->nl_servers[serv] = fss; xb_get_32(error, &xb, val); /* server name length */ /* sanity check server name length */ - if (!error && ((val < 1) || (val > MAXPATHLEN))) + if (!error && (val > MAXPATHLEN)) { + NFS_VFS_DBG("Invalid server name length %d", val); error = EINVAL; + } nfsmerr_if(error); - MALLOC(fss->ns_name, char *, val+1, M_TEMP, M_WAITOK|M_ZERO); - if (!fss->ns_name) + MALLOC(fss->ns_name, char *, val + 1, M_TEMP, M_WAITOK | M_ZERO); + if (!fss->ns_name) { error = ENOMEM; + } nfsmerr_if(error); error = xb_get_bytes(&xb, fss->ns_name, val, 0); /* server name */ xb_get_32(error, &xb, fss->ns_addrcount); /* address count */ /* sanity check address count (OK to be zero) */ - if (!error && (fss->ns_addrcount > 256)) + if (!error && (fss->ns_addrcount > 256)) { + NFS_VFS_DBG("Invalid address count %d", fss->ns_addrcount); error = EINVAL; + } nfsmerr_if(error); if (fss->ns_addrcount > 0) { - MALLOC(fss->ns_addresses, char **, fss->ns_addrcount * sizeof(char *), M_TEMP, M_WAITOK|M_ZERO); - if (!fss->ns_addresses) + MALLOC(fss->ns_addresses, char **, fss->ns_addrcount * sizeof(char *), M_TEMP, M_WAITOK | M_ZERO); + if (!fss->ns_addresses) { error = ENOMEM; + } for (addr = 0; addr < fss->ns_addrcount; addr++) { xb_get_32(error, &xb, val); /* address length */ /* sanity check address length */ - if (!error && ((val < 1) || (val > 128))) + if (!error && val > 128) { + NFS_VFS_DBG("Invalid address length %d", val); error = EINVAL; + } nfsmerr_if(error); - MALLOC(fss->ns_addresses[addr], char *, val+1, M_TEMP, M_WAITOK|M_ZERO); - if (!fss->ns_addresses[addr]) + MALLOC(fss->ns_addresses[addr], char *, val + 1, M_TEMP, M_WAITOK | M_ZERO); + if (!fss->ns_addresses[addr]) { error = ENOMEM; + } nfsmerr_if(error); error = xb_get_bytes(&xb, fss->ns_addresses[addr], val, 0); /* address */ } @@ -2986,13 +3418,16 @@ mountnfs( fsp = &fsl->nl_path; xb_get_32(error, &xb, fsp->np_compcount); /* component count */ /* sanity check component count */ - if (!error && (fsp->np_compcount > MAXPATHLEN)) + if (!error && (fsp->np_compcount > MAXPATHLEN)) { + NFS_VFS_DBG("Invalid component count %d", fsp->np_compcount); error = EINVAL; + } nfsmerr_if(error); if (fsp->np_compcount) { - MALLOC(fsp->np_components, char **, fsp->np_compcount * sizeof(char*), M_TEMP, M_WAITOK|M_ZERO); - if (!fsp->np_components) + MALLOC(fsp->np_components, char **, fsp->np_compcount * sizeof(char*), M_TEMP, M_WAITOK | M_ZERO); + if (!fsp->np_components) { error = ENOMEM; + } } for (comp = 0; comp < fsp->np_compcount; comp++) { xb_get_32(error, &xb, val); /* component length */ @@ -3011,148 +3446,308 @@ mountnfs( } continue; } - if (!error && ((val < 1) || (val > MAXPATHLEN))) + if (!error && ((val < 1) || (val > MAXPATHLEN))) { + NFS_VFS_DBG("Invalid component path length %d", val); error = EINVAL; + } nfsmerr_if(error); - MALLOC(fsp->np_components[comp], char *, val+1, M_TEMP, M_WAITOK|M_ZERO); - if (!fsp->np_components[comp]) + MALLOC(fsp->np_components[comp], char *, val + 1, M_TEMP, M_WAITOK | M_ZERO); + if (!fsp->np_components[comp]) { error = ENOMEM; + } nfsmerr_if(error); error = xb_get_bytes(&xb, fsp->np_components[comp], val, 0); /* component */ } xb_get_32(error, &xb, val); /* fs location info length */ - xb_skip(error, &xb, val); /* skip fs location info */ + NFS_VFS_DBG("Skipping fs location info bytes %d", val); + xb_skip(error, &xb, xdr_rndup(val)); /* skip fs location info */ } } - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MNTFLAGS)) + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MNTFLAGS)) { xb_skip(error, &xb, XDRWORD); + } if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MNTFROM)) { xb_get_32(error, &xb, len); nfsmerr_if(error); val = len; - if (val >= sizeof(vfs_statfs(mp)->f_mntfromname)) + if (val >= sizeof(vfs_statfs(mp)->f_mntfromname)) { val = sizeof(vfs_statfs(mp)->f_mntfromname) - 1; + } error = xb_get_bytes(&xb, vfs_statfs(mp)->f_mntfromname, val, 0); - if ((len - val) > 0) + if ((len - val) > 0) { xb_skip(error, &xb, len - val); + } nfsmerr_if(error); vfs_statfs(mp)->f_mntfromname[val] = '\0'; } nfsmerr_if(error); + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_REALM)) { + xb_get_32(error, &xb, len); + if (!error && ((len < 1) || (len > MAXPATHLEN))) { + error = EINVAL; + } + nfsmerr_if(error); + /* allocate an extra byte for a leading '@' if its not already prepended to the realm */ + MALLOC(nmp->nm_realm, char *, len + 2, M_TEMP, M_WAITOK | M_ZERO); + if (!nmp->nm_realm) { + error = ENOMEM; + } + nfsmerr_if(error); + error = xb_get_bytes(&xb, nmp->nm_realm, len, 0); + if (error == 0 && *nmp->nm_realm != '@') { + bcopy(nmp->nm_realm, &nmp->nm_realm[1], len); + nmp->nm_realm[0] = '@'; + } + } + nfsmerr_if(error); + + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_PRINCIPAL)) { + xb_get_32(error, &xb, len); + if (!error && ((len < 1) || (len > MAXPATHLEN))) { + error = EINVAL; + } + nfsmerr_if(error); + MALLOC(nmp->nm_principal, char *, len + 1, M_TEMP, M_WAITOK | M_ZERO); + if (!nmp->nm_principal) { + error = ENOMEM; + } + nfsmerr_if(error); + error = xb_get_bytes(&xb, nmp->nm_principal, len, 0); + } + nfsmerr_if(error); + + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_SVCPRINCIPAL)) { + xb_get_32(error, &xb, len); + if (!error && ((len < 1) || (len > MAXPATHLEN))) { + error = EINVAL; + } + nfsmerr_if(error); + MALLOC(nmp->nm_sprinc, char *, len + 1, M_TEMP, M_WAITOK | M_ZERO); + if (!nmp->nm_sprinc) { + error = ENOMEM; + } + nfsmerr_if(error); + error = xb_get_bytes(&xb, nmp->nm_sprinc, len, 0); + } + nfsmerr_if(error); + + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_LOCAL_NFS_PORT)) { + if (nmp->nm_nfsport) { + error = EINVAL; + NFS_VFS_DBG("Can't have ports specified over incompatible socket families"); + } + nfsmerr_if(error); + xb_get_32(error, &xb, len); + if (!error && ((len < 1) || (len > sizeof(((struct sockaddr_un *)0)->sun_path)))) { + error = EINVAL; + } + nfsmerr_if(error); + MALLOC(nmp->nm_nfs_localport, char *, len + 1, M_TEMP, M_WAITOK | M_ZERO); + if (!nmp->nm_nfs_localport) { + error = ENOMEM; + } + nfsmerr_if(error); + error = xb_get_bytes(&xb, nmp->nm_nfs_localport, len, 0); + nmp->nm_sofamily = AF_LOCAL; + nmp->nm_nfsport = 1; /* We use the now deprecated tpcmux port to indcate that we have an AF_LOCAL port */ + NFS_VFS_DBG("Setting nfs local port %s (%d)\n", nmp->nm_nfs_localport, nmp->nm_nfsport); + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_LOCAL_MOUNT_PORT)) { + if (nmp->nm_mountport) { + error = EINVAL; + NFS_VFS_DBG("Can't have ports specified over mulitple socket families"); + } + nfsmerr_if(error); + xb_get_32(error, &xb, len); + if (!error && ((len < 1) || (len > sizeof(((struct sockaddr_un *)0)->sun_path)))) { + error = EINVAL; + } + nfsmerr_if(error); + MALLOC(nmp->nm_mount_localport, char *, len + 1, M_TEMP, M_WAITOK | M_ZERO); + if (!nmp->nm_mount_localport) { + error = ENOMEM; + } + nfsmerr_if(error); + error = xb_get_bytes(&xb, nmp->nm_mount_localport, len, 0); + nmp->nm_sofamily = AF_LOCAL; + nmp->nm_mountport = 1; /* We use the now deprecated tpcmux port to indcate that we have an AF_LOCAL port */ + NFS_VFS_DBG("Setting mount local port %s (%d)\n", nmp->nm_mount_localport, nmp->nm_mountport); + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_SET_MOUNT_OWNER)) { + xb_get_32(error, &xb, set_owner); + nfsmerr_if(error); + error = vfs_context_suser(ctx); + /* + * root can set owner to whatever, user can set owner to self + */ + if ((error) && (set_owner == kauth_cred_getuid(vfs_context_ucred(ctx)))) { + /* ok for non-root can set owner to self */ + error = 0; + } + nfsmerr_if(error); + } + /* * Sanity check/finalize settings. */ - if (nmp->nm_timeo < NFS_MINTIMEO) + if (nmp->nm_timeo < NFS_MINTIMEO) { nmp->nm_timeo = NFS_MINTIMEO; - else if (nmp->nm_timeo > NFS_MAXTIMEO) + } else if (nmp->nm_timeo > NFS_MAXTIMEO) { nmp->nm_timeo = NFS_MAXTIMEO; - if (nmp->nm_retry > NFS_MAXREXMIT) + } + if (nmp->nm_retry > NFS_MAXREXMIT) { nmp->nm_retry = NFS_MAXREXMIT; + } - if (nmp->nm_numgrps > NFS_MAXGRPS) + if (nmp->nm_numgrps > NFS_MAXGRPS) { nmp->nm_numgrps = NFS_MAXGRPS; - if (nmp->nm_readahead > NFS_MAXRAHEAD) + } + if (nmp->nm_readahead > NFS_MAXRAHEAD) { nmp->nm_readahead = NFS_MAXRAHEAD; - if (nmp->nm_acregmin > nmp->nm_acregmax) + } + if (nmp->nm_acregmin > nmp->nm_acregmax) { nmp->nm_acregmin = nmp->nm_acregmax; - if (nmp->nm_acdirmin > nmp->nm_acdirmax) + } + if (nmp->nm_acdirmin > nmp->nm_acdirmax) { nmp->nm_acdirmin = nmp->nm_acdirmax; + } /* need at least one fs location */ - if (nmp->nm_locations.nl_numlocs < 1) + if (nmp->nm_locations.nl_numlocs < 1) { error = EINVAL; + } nfsmerr_if(error); - /* init mount's mntfromname to first location */ - if (!NM_OMATTR_GIVEN(nmp, MNTFROM)) + if (!NM_OMATTR_GIVEN(nmp, MNTFROM)) { + /* init mount's mntfromname to first location */ nfs_location_mntfromname(&nmp->nm_locations, firstloc, - vfs_statfs(mp)->f_mntfromname, sizeof(vfs_statfs(mp)->f_mntfromname), 0); + vfs_statfs(mp)->f_mntfromname, + sizeof(vfs_statfs(mp)->f_mntfromname), 0); + } /* Need to save the mounting credential for v4. */ nmp->nm_mcred = vfs_context_ucred(ctx); - if (IS_VALID_CRED(nmp->nm_mcred)) + if (IS_VALID_CRED(nmp->nm_mcred)) { kauth_cred_ref(nmp->nm_mcred); + } /* * If a reserved port is required, check for that privilege. * (Note that mirror mounts are exempt because the privilege was * already checked for the original mount.) */ - if (NMFLAG(nmp, RESVPORT) && !vfs_iskernelmount(mp)) + if (NMFLAG(nmp, RESVPORT) && !vfs_iskernelmount(mp)) { error = priv_check_cred(nmp->nm_mcred, PRIV_NETINET_RESERVEDPORT, 0); - nfsmerr_if(error); - - /* do mount's initial socket connection */ - error = nfs_mount_connect(nmp); + } nfsmerr_if(error); /* set up the version-specific function tables */ - if (nmp->nm_vers < NFS_VER4) + if (nmp->nm_vers < NFS_VER4) { nmp->nm_funcs = &nfs3_funcs; - else + } else { +#if CONFIG_NFS4 nmp->nm_funcs = &nfs4_funcs; +#else + /* don't go any further if we don't support NFS4 */ + nmp->nm_funcs = NULL; + error = ENOTSUP; + nfsmerr_if(error); +#endif + } + + /* do mount's initial socket connection */ + error = nfs_mount_connect(nmp); + nfsmerr_if(error); /* sanity check settings now that version/connection is set */ - if (nmp->nm_vers == NFS_VER2) /* ignore RDIRPLUS on NFSv2 */ + if (nmp->nm_vers == NFS_VER2) { /* ignore RDIRPLUS on NFSv2 */ NFS_BITMAP_CLR(nmp->nm_flags, NFS_MFLAG_RDIRPLUS); + } +#if CONFIG_NFS4 if (nmp->nm_vers >= NFS_VER4) { - if (NFS_BITMAP_ISSET(nmp->nm_flags, NFS_MFLAG_ACLONLY)) /* aclonly trumps noacl */ + if (NFS_BITMAP_ISSET(nmp->nm_flags, NFS_MFLAG_ACLONLY)) { /* aclonly trumps noacl */ NFS_BITMAP_CLR(nmp->nm_flags, NFS_MFLAG_NOACL); + } NFS_BITMAP_CLR(nmp->nm_flags, NFS_MFLAG_CALLUMNT); - if (nmp->nm_lockmode != NFS_LOCK_MODE_ENABLED) + if (nmp->nm_lockmode != NFS_LOCK_MODE_ENABLED) { error = EINVAL; /* disabled/local lock mode only allowed on v2/v3 */ + } } else { - /* ignore these if not v4 */ - NFS_BITMAP_CLR(nmp->nm_flags, NFS_MFLAG_NOCALLBACK); - NFS_BITMAP_CLR(nmp->nm_flags, NFS_MFLAG_NONAMEDATTR); - NFS_BITMAP_CLR(nmp->nm_flags, NFS_MFLAG_NOACL); - NFS_BITMAP_CLR(nmp->nm_flags, NFS_MFLAG_ACLONLY); - if (IS_VALID_CRED(nmp->nm_mcred)) - kauth_cred_unref(&nmp->nm_mcred); - } +#endif + /* ignore these if not v4 */ + NFS_BITMAP_CLR(nmp->nm_flags, NFS_MFLAG_NOCALLBACK); + NFS_BITMAP_CLR(nmp->nm_flags, NFS_MFLAG_NAMEDATTR); + NFS_BITMAP_CLR(nmp->nm_flags, NFS_MFLAG_NOACL); + NFS_BITMAP_CLR(nmp->nm_flags, NFS_MFLAG_ACLONLY); +#if CONFIG_NFS4 +} +#endif nfsmerr_if(error); if (nmp->nm_sotype == SOCK_DGRAM) { /* I/O size defaults for UDP are different */ - if (!NFS_BITMAP_ISSET(mattrs, NFS_MATTR_READ_SIZE)) + if (!NFS_BITMAP_ISSET(mattrs, NFS_MATTR_READ_SIZE)) { nmp->nm_rsize = NFS_DGRAM_RSIZE; - if (!NFS_BITMAP_ISSET(mattrs, NFS_MATTR_WRITE_SIZE)) + } + if (!NFS_BITMAP_ISSET(mattrs, NFS_MATTR_WRITE_SIZE)) { nmp->nm_wsize = NFS_DGRAM_WSIZE; + } } /* round down I/O sizes to multiple of NFS_FABLKSIZE */ nmp->nm_rsize &= ~(NFS_FABLKSIZE - 1); - if (nmp->nm_rsize <= 0) + if (nmp->nm_rsize <= 0) { nmp->nm_rsize = NFS_FABLKSIZE; + } nmp->nm_wsize &= ~(NFS_FABLKSIZE - 1); - if (nmp->nm_wsize <= 0) + if (nmp->nm_wsize <= 0) { nmp->nm_wsize = NFS_FABLKSIZE; + } /* and limit I/O sizes to maximum allowed */ maxio = (nmp->nm_vers == NFS_VER2) ? NFS_V2MAXDATA : - (nmp->nm_sotype == SOCK_DGRAM) ? NFS_MAXDGRAMDATA : NFS_MAXDATA; - if (maxio > NFS_MAXBSIZE) + (nmp->nm_sotype == SOCK_DGRAM) ? NFS_MAXDGRAMDATA : NFS_MAXDATA; + if (maxio > NFS_MAXBSIZE) { maxio = NFS_MAXBSIZE; - if (nmp->nm_rsize > maxio) + } + if (nmp->nm_rsize > maxio) { nmp->nm_rsize = maxio; - if (nmp->nm_wsize > maxio) + } + if (nmp->nm_wsize > maxio) { nmp->nm_wsize = maxio; + } - if (nmp->nm_readdirsize > maxio) + if (nmp->nm_readdirsize > maxio) { nmp->nm_readdirsize = maxio; - if (nmp->nm_readdirsize > nmp->nm_rsize) + } + if (nmp->nm_readdirsize > nmp->nm_rsize) { nmp->nm_readdirsize = nmp->nm_rsize; + } /* Set up the sockets and related info */ - if (nmp->nm_sotype == SOCK_DGRAM) + if (nmp->nm_sotype == SOCK_DGRAM) { TAILQ_INIT(&nmp->nm_cwndq); + } - /* - * Get the root node/attributes from the NFS server and - * do any basic, version-specific setup. - */ + if (nmp->nm_saddr->sa_family == AF_LOCAL) { + struct sockaddr_un *un = (struct sockaddr_un *)nmp->nm_saddr; + size_t size; + int n = snprintf(vfs_statfs(mp)->f_mntfromname, sizeof(vfs_statfs(mp)->f_mntfromname), "<%s>:", un->sun_path); + + if (n > 0 && (size_t)n < sizeof(vfs_statfs(mp)->f_mntfromname)) { + size = sizeof(vfs_statfs(mp)->f_mntfromname) - n; + nfs_location_mntfromname(&nmp->nm_locations, firstloc, + &vfs_statfs(mp)->f_mntfromname[n], size, 1); + } + } + + + /* + * Get the root node/attributes from the NFS server and + * do any basic, version-specific setup. + */ error = nmp->nm_funcs->nf_mount(nmp, ctx, &np); nfsmerr_if(error); @@ -3164,6 +3759,8 @@ mountnfs( */ nmp->nm_dnp = np; *vpp = NFSTOV(np); + + /* get usecount and drop iocount */ error = vnode_ref(*vpp); vnode_put(*vpp); @@ -3178,8 +3775,9 @@ mountnfs( if ((error = nmp->nm_funcs->nf_update_statfs(nmp, ctx))) { int error2 = vnode_getwithref(*vpp); vnode_rele(*vpp); - if (!error2) + if (!error2) { vnode_put(*vpp); + } vnode_recycle(*vpp); goto nfsmerr; } @@ -3189,11 +3787,15 @@ mountnfs( sbp->f_bfree = nmp->nm_fsattr.nfsa_space_free / sbp->f_bsize; sbp->f_bavail = nmp->nm_fsattr.nfsa_space_avail / sbp->f_bsize; sbp->f_bused = (nmp->nm_fsattr.nfsa_space_total / sbp->f_bsize) - - (nmp->nm_fsattr.nfsa_space_free / sbp->f_bsize); + (nmp->nm_fsattr.nfsa_space_free / sbp->f_bsize); sbp->f_files = nmp->nm_fsattr.nfsa_files_total; sbp->f_ffree = nmp->nm_fsattr.nfsa_files_free; sbp->f_iosize = nfs_iosize; + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_SET_MOUNT_OWNER)) { + sbp->f_owner = set_owner; + } + /* * Calculate the size used for I/O buffers. Use the larger * of the two sizes to minimise NFS requests but make sure @@ -3204,13 +3806,16 @@ mountnfs( * larger than the I/O size. */ iosize = max(nmp->nm_rsize, nmp->nm_wsize); - if (iosize < PAGE_SIZE) + if (iosize < PAGE_SIZE) { iosize = PAGE_SIZE; + } nmp->nm_biosize = trunc_page_32(iosize); /* For NFSv3 and greater, there is a (relatively) reliable ACCESS call. */ - if (nmp->nm_vers > NFS_VER2) + if (nmp->nm_vers > NFS_VER2 && !NMFLAG(nmp, NOOPAQUE_AUTH) + ) { vfs_setauthopaqueaccess(mp); + } switch (nmp->nm_lockmode) { case NFS_LOCK_MODE_DISABLED: @@ -3220,19 +3825,21 @@ mountnfs( break; case NFS_LOCK_MODE_ENABLED: default: - if (nmp->nm_vers <= NFS_VER3) + if (nmp->nm_vers <= NFS_VER3) { nfs_lockd_mount_register(nmp); + } break; } + /* success! */ lck_mtx_lock(&nmp->nm_lock); nmp->nm_state |= NFSSTA_MOUNTED; lck_mtx_unlock(&nmp->nm_lock); - return (0); + return 0; nfsmerr: - nfs_mount_cleanup(nmp); - return (error); + nfs_mount_drain_and_cleanup(nmp); + return error; } #if CONFIG_TRIGGERS @@ -3248,7 +3855,9 @@ int nfs_mirror_mount_domount(vnode_t dvp, vnode_t vp, vfs_context_t ctx) { nfsnode_t np = VTONFS(vp); +#if CONFIG_NFS4 nfsnode_t dnp = VTONFS(dvp); +#endif struct nfsmount *nmp = NFSTONMP(np); char fstype[MFSTYPENAMELEN], *mntfromname = NULL, *path = NULL, *relpath, *p, *cp; int error = 0, pathbuflen = MAXPATHLEN, i, mntflags = 0, referral, skipcopy = 0; @@ -3265,21 +3874,23 @@ nfs_mirror_mount_domount(vnode_t dvp, vnode_t vp, vfs_context_t ctx) struct nfs_fs_locations nfsls; referral = (np->n_vattr.nva_flags & NFS_FFLAG_TRIGGER_REFERRAL); - if (referral) + if (referral) { bzero(&nfsls, sizeof(nfsls)); + } - xb_init(&xbnew, 0); + xb_init(&xbnew, XDRBUF_NONE); - if (!nmp || (nmp->nm_state & NFSSTA_FORCE)) - return (ENXIO); + if (!nmp || (nmp->nm_state & (NFSSTA_FORCE | NFSSTA_DEAD))) { + return ENXIO; + } /* allocate a couple path buffers we need */ - MALLOC_ZONE(mntfromname, char *, pathbuflen, M_NAMEI, M_WAITOK); + MALLOC_ZONE(mntfromname, char *, pathbuflen, M_NAMEI, M_WAITOK); if (!mntfromname) { error = ENOMEM; goto nfsmerr; } - MALLOC_ZONE(path, char *, pathbuflen, M_NAMEI, M_WAITOK); + MALLOC_ZONE(path, char *, pathbuflen, M_NAMEI, M_WAITOK); if (!path) { error = ENOMEM; goto nfsmerr; @@ -3301,8 +3912,8 @@ nfs_mirror_mount_domount(vnode_t dvp, vnode_t vp, vfs_context_t ctx) * We'll be adding those to each fs location path in the new args. */ nlen = strlcpy(mntfromname, vfs_statfs(nmp->nm_mountp)->f_mntfromname, MAXPATHLEN); - if ((nlen > 0) && (mntfromname[nlen-1] == '/')) { /* avoid double '/' in new name */ - mntfromname[nlen-1] = '\0'; + if ((nlen > 0) && (mntfromname[nlen - 1] == '/')) { /* avoid double '/' in new name */ + mntfromname[nlen - 1] = '\0'; nlen--; } relpath = mntfromname + nlen; @@ -3313,15 +3924,18 @@ nfs_mirror_mount_domount(vnode_t dvp, vnode_t vp, vfs_context_t ctx) } /* count the number of components in relpath */ p = relpath; - while (*p && (*p == '/')) + while (*p && (*p == '/')) { p++; + } relpathcomps = 0; while (*p) { relpathcomps++; - while (*p && (*p != '/')) + while (*p && (*p != '/')) { p++; - while (*p && (*p == '/')) + } + while (*p && (*p == '/')) { p++; + } } /* grab a copy of the file system type */ @@ -3332,12 +3946,16 @@ nfs_mirror_mount_domount(vnode_t dvp, vnode_t vp, vfs_context_t ctx) const char *vname = vnode_getname(NFSTOV(np)); if (!vname) { error = ENOENT; - } else { + } +#if CONFIG_NFS4 + else { error = nfs4_get_fs_locations(nmp, dnp, NULL, 0, vname, ctx, &nfsls); vnode_putname(vname); - if (!error && (nfsls.nl_numlocs < 1)) + if (!error && (nfsls.nl_numlocs < 1)) { error = ENOENT; + } } +#endif nfsmerr_if(error); } @@ -3345,23 +3963,23 @@ nfs_mirror_mount_domount(vnode_t dvp, vnode_t vp, vfs_context_t ctx) #define xb_copy_32(E, XBSRC, XBDST, V) \ do { \ - if (E) break; \ - xb_get_32((E), (XBSRC), (V)); \ - if (skipcopy) break; \ - xb_add_32((E), (XBDST), (V)); \ + if (E) break; \ + xb_get_32((E), (XBSRC), (V)); \ + if (skipcopy) break; \ + xb_add_32((E), (XBDST), (V)); \ } while (0) #define xb_copy_opaque(E, XBSRC, XBDST) \ do { \ - uint32_t __count, __val; \ - xb_copy_32((E), (XBSRC), (XBDST), __count); \ - if (E) break; \ - __count = nfsm_rndup(__count); \ - __count /= XDRWORD; \ - while (__count-- > 0) \ - xb_copy_32((E), (XBSRC), (XBDST), __val); \ + uint32_t __count, __val; \ + xb_copy_32((E), (XBSRC), (XBDST), __count); \ + if (E) break; \ + __count = nfsm_rndup(__count); \ + __count /= XDRWORD; \ + while (__count-- > 0) \ + xb_copy_32((E), (XBSRC), (XBDST), __val); \ } while (0) - xb_init_buffer(&xb, nmp->nm_args, 2*XDRWORD); + xb_init_buffer(&xb, nmp->nm_args, 2 * XDRWORD); xb_get_32(error, &xb, val); /* version */ xb_get_32(error, &xb, argslength); /* args length */ xb_init_buffer(&xb, nmp->nm_args, argslength); @@ -3374,15 +3992,18 @@ nfs_mirror_mount_domount(vnode_t dvp, vnode_t vp, vfs_context_t ctx) count = NFS_MATTR_BITMAP_LEN; xb_get_bitmap(error, &xb, mattrs, count); /* mount attribute bitmap */ nfsmerr_if(error); - for (i = 0; i < NFS_MATTR_BITMAP_LEN; i++) + for (i = 0; i < NFS_MATTR_BITMAP_LEN; i++) { newmattrs[i] = mattrs[i]; - if (referral) + } + if (referral) { NFS_BITMAP_SET(newmattrs, NFS_MATTR_FS_LOCATIONS); - else + NFS_BITMAP_CLR(newmattrs, NFS_MATTR_MNTFROM); + } else { NFS_BITMAP_SET(newmattrs, NFS_MATTR_FH); + } NFS_BITMAP_SET(newmattrs, NFS_MATTR_FLAGS); NFS_BITMAP_SET(newmattrs, NFS_MATTR_MNTFLAGS); - NFS_BITMAP_CLR(newmattrs, NFS_MATTR_MNTFROM); + NFS_BITMAP_SET(newmattrs, NFS_MATTR_SET_MOUNT_OWNER); xb_add_bitmap(error, &xbnew, newmattrs, NFS_MATTR_BITMAP_LEN); attrslength_offset = xb_offset(&xbnew); xb_copy_32(error, &xb, &xbnew, val); /* attrs length */ @@ -3398,18 +4019,28 @@ nfs_mirror_mount_domount(vnode_t dvp, vnode_t vp, vfs_context_t ctx) NFS_BITMAP_SET(newmflags, NFS_MFLAG_EPHEMERAL); xb_add_bitmap(error, &xbnew, newmflags_mask, NFS_MFLAG_BITMAP_LEN); xb_add_bitmap(error, &xbnew, newmflags, NFS_MFLAG_BITMAP_LEN); - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_VERSION)) + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_VERSION)) { + xb_copy_32(error, &xb, &xbnew, val); + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_MINOR_VERSION)) { + xb_copy_32(error, &xb, &xbnew, val); + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_VERSION_RANGE)) { xb_copy_32(error, &xb, &xbnew, val); - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_MINOR_VERSION)) xb_copy_32(error, &xb, &xbnew, val); - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_READ_SIZE)) + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_READ_SIZE)) { xb_copy_32(error, &xb, &xbnew, val); - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_WRITE_SIZE)) + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_WRITE_SIZE)) { xb_copy_32(error, &xb, &xbnew, val); - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_READDIR_SIZE)) + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_READDIR_SIZE)) { xb_copy_32(error, &xb, &xbnew, val); - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_READAHEAD)) + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_READAHEAD)) { xb_copy_32(error, &xb, &xbnew, val); + } if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_ATTRCACHE_REG_MIN)) { xb_copy_32(error, &xb, &xbnew, val); xb_copy_32(error, &xb, &xbnew, val); @@ -3426,27 +4057,41 @@ nfs_mirror_mount_domount(vnode_t dvp, vnode_t vp, vfs_context_t ctx) xb_copy_32(error, &xb, &xbnew, val); xb_copy_32(error, &xb, &xbnew, val); } - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_LOCK_MODE)) + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_LOCK_MODE)) { xb_copy_32(error, &xb, &xbnew, val); + } if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_SECURITY)) { xb_copy_32(error, &xb, &xbnew, count); - while (!error && (count-- > 0)) + while (!error && (count-- > 0)) { + xb_copy_32(error, &xb, &xbnew, val); + } + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_KERB_ETYPE)) { + xb_copy_32(error, &xb, &xbnew, count); + xb_add_32(error, &xbnew, -1); + while (!error && (count-- > 0)) { xb_copy_32(error, &xb, &xbnew, val); + } } - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MAX_GROUP_LIST)) + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MAX_GROUP_LIST)) { xb_copy_32(error, &xb, &xbnew, val); - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_SOCKET_TYPE)) + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_SOCKET_TYPE)) { xb_copy_opaque(error, &xb, &xbnew); - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_PORT)) + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_PORT)) { xb_copy_32(error, &xb, &xbnew, val); - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MOUNT_PORT)) + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MOUNT_PORT)) { xb_copy_32(error, &xb, &xbnew, val); + } if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_REQUEST_TIMEOUT)) { xb_copy_32(error, &xb, &xbnew, val); xb_copy_32(error, &xb, &xbnew, val); } - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_SOFT_RETRY_COUNT)) + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_SOFT_RETRY_COUNT)) { xb_copy_32(error, &xb, &xbnew, val); + } if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_DEAD_TIMEOUT)) { xb_copy_32(error, &xb, &xbnew, val); xb_copy_32(error, &xb, &xbnew, val); @@ -3462,66 +4107,82 @@ nfs_mirror_mount_domount(vnode_t dvp, vnode_t vp, vfs_context_t ctx) /* copy/extend/skip fs locations */ if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_FS_LOCATIONS)) { numlocs = numserv = numaddr = numcomp = 0; - if (referral) /* don't copy the fs locations for a referral */ + if (referral) { /* don't copy the fs locations for a referral */ skipcopy = 1; + } xb_copy_32(error, &xb, &xbnew, numlocs); /* location count */ for (loc = 0; !error && (loc < numlocs); loc++) { xb_copy_32(error, &xb, &xbnew, numserv); /* server count */ for (serv = 0; !error && (serv < numserv); serv++) { xb_copy_opaque(error, &xb, &xbnew); /* server name */ xb_copy_32(error, &xb, &xbnew, numaddr); /* address count */ - for (addr = 0; !error && (addr < numaddr); addr++) + for (addr = 0; !error && (addr < numaddr); addr++) { xb_copy_opaque(error, &xb, &xbnew); /* address */ + } xb_copy_opaque(error, &xb, &xbnew); /* server info */ } /* pathname */ xb_get_32(error, &xb, numcomp); /* component count */ - if (!skipcopy) - xb_add_32(error, &xbnew, numcomp+relpathcomps); /* new component count */ - for (comp = 0; !error && (comp < numcomp); comp++) + if (!skipcopy) { + uint64_t totalcomps = numcomp + relpathcomps; + + /* set error to ERANGE in the event of overflow */ + if (totalcomps > UINT32_MAX) { + nfsmerr_if((error = ERANGE)); + } + + xb_add_32(error, &xbnew, (uint32_t) totalcomps); /* new component count */ + } + for (comp = 0; !error && (comp < numcomp); comp++) { xb_copy_opaque(error, &xb, &xbnew); /* component */ + } /* add additional components */ - for (comp = 0; !skipcopy && !error && (comp < relpathcomps); comp++) { - p = relpath; - while (*p && (*p == '/')) + p = relpath; + while (*p && (*p == '/')) { + p++; + } + while (*p && !error) { + cp = p; + while (*p && (*p != '/')) { + p++; + } + xb_add_string(error, &xbnew, cp, (p - cp)); /* component */ + while (*p && (*p == '/')) { p++; - while (*p && !error) { - cp = p; - while (*p && (*p != '/')) - p++; - xb_add_string(error, &xbnew, cp, (p - cp)); /* component */ - while (*p && (*p == '/')) - p++; } } xb_copy_opaque(error, &xb, &xbnew); /* fs location info */ } - if (referral) + if (referral) { skipcopy = 0; + } } if (referral) { /* add referral's fs locations */ - xb_add_32(error, &xbnew, nfsls.nl_numlocs); /* FS_LOCATIONS */ + xb_add_32(error, &xbnew, nfsls.nl_numlocs); /* FS_LOCATIONS */ for (loc = 0; !error && (loc < nfsls.nl_numlocs); loc++) { xb_add_32(error, &xbnew, nfsls.nl_locations[loc]->nl_servcount); for (serv = 0; !error && (serv < nfsls.nl_locations[loc]->nl_servcount); serv++) { xb_add_string(error, &xbnew, nfsls.nl_locations[loc]->nl_servers[serv]->ns_name, - strlen(nfsls.nl_locations[loc]->nl_servers[serv]->ns_name)); + strlen(nfsls.nl_locations[loc]->nl_servers[serv]->ns_name)); xb_add_32(error, &xbnew, nfsls.nl_locations[loc]->nl_servers[serv]->ns_addrcount); - for (addr = 0; !error && (addr < nfsls.nl_locations[loc]->nl_servers[serv]->ns_addrcount); addr++) + for (addr = 0; !error && (addr < nfsls.nl_locations[loc]->nl_servers[serv]->ns_addrcount); addr++) { xb_add_string(error, &xbnew, nfsls.nl_locations[loc]->nl_servers[serv]->ns_addresses[addr], - strlen(nfsls.nl_locations[loc]->nl_servers[serv]->ns_addresses[addr])); + strlen(nfsls.nl_locations[loc]->nl_servers[serv]->ns_addresses[addr])); + } xb_add_32(error, &xbnew, 0); /* empty server info */ } xb_add_32(error, &xbnew, nfsls.nl_locations[loc]->nl_path.np_compcount); - for (comp = 0; !error && (comp < nfsls.nl_locations[loc]->nl_path.np_compcount); comp++) + for (comp = 0; !error && (comp < nfsls.nl_locations[loc]->nl_path.np_compcount); comp++) { xb_add_string(error, &xbnew, nfsls.nl_locations[loc]->nl_path.np_components[comp], - strlen(nfsls.nl_locations[loc]->nl_path.np_components[comp])); + strlen(nfsls.nl_locations[loc]->nl_path.np_components[comp])); + } xb_add_32(error, &xbnew, 0); /* empty fs location info */ } } - if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MNTFLAGS)) + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MNTFLAGS)) { xb_get_32(error, &xb, mntflags); + } /* * We add the following mount flags to the ones for the mounted-on mount: * MNT_DONTBROWSE - to keep the mount from showing up as a separate volume @@ -3537,14 +4198,16 @@ nfs_mirror_mount_domount(vnode_t dvp, vnode_t vp, vfs_context_t ctx) nfsmerr_if(error); mlen2 = mlen + ((relpath[0] != '/') ? 1 : 0) + rlen; xb_add_32(error, &xbnew, mlen2); - count = mlen/XDRWORD; + count = mlen / XDRWORD; /* copy the original string */ - while (count-- > 0) + while (count-- > 0) { xb_copy_32(error, &xb, &xbnew, val); + } if (!error && (mlen % XDRWORD)) { - error = xb_get_bytes(&xb, buf, mlen%XDRWORD, 0); - if (!error) - error = xb_add_bytes(&xbnew, buf, mlen%XDRWORD, 1); + error = xb_get_bytes(&xb, buf, mlen % XDRWORD, 0); + if (!error) { + error = xb_add_bytes(&xbnew, buf, mlen % XDRWORD, 1); + } } /* insert a '/' if the relative path doesn't start with one */ if (!error && (relpath[0] != '/')) { @@ -3552,8 +4215,9 @@ nfs_mirror_mount_domount(vnode_t dvp, vnode_t vp, vfs_context_t ctx) error = xb_add_bytes(&xbnew, buf, 1, 1); } /* add the additional relative path */ - if (!error) + if (!error) { error = xb_add_bytes(&xbnew, relpath, rlen, 1); + } /* make sure the resulting string has the right number of pad bytes */ if (!error && (mlen2 != nfsm_rndup(mlen2))) { bzero(buf, sizeof(buf)); @@ -3561,53 +4225,87 @@ nfs_mirror_mount_domount(vnode_t dvp, vnode_t vp, vfs_context_t ctx) error = xb_add_bytes(&xbnew, buf, count, 1); } } + /* + * The following string copies rely on the fact that we already validated + * these data when creating the initial mount point. + */ + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_REALM)) { + xb_add_string(error, &xbnew, nmp->nm_realm, strlen(nmp->nm_realm)); + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_PRINCIPAL)) { + xb_add_string(error, &xbnew, nmp->nm_principal, strlen(nmp->nm_principal)); + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_SVCPRINCIPAL)) { + xb_add_string(error, &xbnew, nmp->nm_sprinc, strlen(nmp->nm_sprinc)); + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_LOCAL_NFS_PORT)) { + xb_add_string(error, &xbnew, nmp->nm_nfs_localport, strlen(nmp->nm_nfs_localport)); + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_LOCAL_MOUNT_PORT)) { + xb_add_string(error, &xbnew, nmp->nm_mount_localport, strlen(nmp->nm_mount_localport)); + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_SET_MOUNT_OWNER)) { + /* drop embedded owner value */ + xb_get_32(error, &xb, count); + } + /* New mount always gets same owner as this mount */ + xb_add_32(error, &xbnew, vnode_mount(vp)->mnt_vfsstat.f_owner); xb_build_done(error, &xbnew); /* update opaque counts */ end_offset = xb_offset(&xbnew); if (!error) { error = xb_seek(&xbnew, argslength_offset); - argslength = end_offset - argslength_offset + XDRWORD/*version*/; + argslength = end_offset - argslength_offset + XDRWORD /*version*/; xb_add_32(error, &xbnew, argslength); } if (!error) { error = xb_seek(&xbnew, attrslength_offset); - xb_add_32(error, &xbnew, end_offset - attrslength_offset - XDRWORD/*don't include length field*/); + xb_add_32(error, &xbnew, end_offset - attrslength_offset - XDRWORD /*don't include length field*/); } nfsmerr_if(error); /* * For kernel_mount() call, use the existing mount flags (instead of the * original flags) because flags like MNT_NOSUID and MNT_NODEV may have - * been silently enforced. + * been silently enforced. Also, in terms of MACF, the _kernel_ is + * performing the mount (and enforcing all of the mount options), so we + * use the kernel context for the mount call. */ mntflags = vnode_vfsvisflags(vp); mntflags |= (MNT_AUTOMOUNTED | MNT_DONTBROWSE); + ctx = vfs_context_kernel(); /* do the mount */ error = kernel_mount(fstype, dvp, vp, path, xb_buffer_base(&xbnew), argslength, - mntflags, KERNEL_MOUNT_PERMIT_UNMOUNT | KERNEL_MOUNT_NOAUTH, ctx); + mntflags, KERNEL_MOUNT_PERMIT_UNMOUNT | KERNEL_MOUNT_NOAUTH, ctx); nfsmerr: - if (error) + if (error) { printf("nfs: mirror mount of %s on %s failed (%d)\n", - mntfromname, path, error); + mntfromname, path, error); + } /* clean up */ xb_cleanup(&xbnew); - if (referral) + if (referral) { nfs_fs_locations_cleanup(&nfsls); - if (path) + } + if (path) { FREE_ZONE(path, MAXPATHLEN, M_NAMEI); - if (mntfromname) + } + if (mntfromname) { FREE_ZONE(mntfromname, MAXPATHLEN, M_NAMEI); - if (!error) + } + if (!error) { nfs_ephemeral_mount_harvester_start(); - return (error); + } + return error; } /* * trigger vnode functions */ +#define NFS_TRIGGER_DEBUG 1 resolver_result_t nfs_mirror_mount_trigger_resolve( @@ -3618,9 +4316,10 @@ nfs_mirror_mount_trigger_resolve( __unused void *data, vfs_context_t ctx) { - nfsnode_t np = VTONFS(vp); - vnode_t pvp = NULLVP; - int error = 0; + nfsnode_t np = VTONFS(vp); + vnode_t pvp = NULLVP; + int error = 0; + int didBusy = 0; resolver_result_t result; /* @@ -3651,9 +4350,9 @@ nfs_mirror_mount_trigger_resolve( result = vfs_resolver_result(np->n_trigseq, RESOLVER_NOCHANGE, 0); #ifdef NFS_TRIGGER_DEBUG NP(np, "nfs trigger RESOLVE: no change, last %d nameiop %d, seq %d", - (cnp->cn_flags & ISLASTCN) ? 1 : 0, cnp->cn_nameiop, np->n_trigseq); + (cnp->cn_flags & ISLASTCN) ? 1 : 0, cnp->cn_nameiop, np->n_trigseq); #endif - return (result); + return result; case OP_OPEN: case OP_CHDIR: case OP_CHROOT: @@ -3686,30 +4385,51 @@ nfs_mirror_mount_trigger_resolve( result = vfs_resolver_result(np->n_trigseq, RESOLVER_ERROR, error); #ifdef NFS_TRIGGER_DEBUG NP(np, "nfs trigger RESOLVE: busy error %d, last %d nameiop %d, seq %d", - error, (cnp->cn_flags & ISLASTCN) ? 1 : 0, cnp->cn_nameiop, np->n_trigseq); + error, (cnp->cn_flags & ISLASTCN) ? 1 : 0, cnp->cn_nameiop, np->n_trigseq); #endif - return (result); + return result; + } + didBusy = 1; + + /* Check again, in case the mount happened while we were setting busy */ + if (vnode_mountedhere(vp) != NULL) { + /* Been there. Done that. Let's just say it succeeded. */ + error = 0; + goto skipmount; + } + nfs_node_lock_force(np); + if (np->n_flag & NDISARMTRIGGER) { + error = ECANCELED; + nfs_node_unlock(np); + goto skipmount; } + nfs_node_unlock(np); pvp = vnode_getparent(vp); - if (pvp == NULLVP) + if (pvp == NULLVP) { error = EINVAL; - if (!error) + } + if (!error) { error = nfs_mirror_mount_domount(pvp, vp, ctx); + } skipmount: - if (!error) + if (!error) { np->n_trigseq++; + } result = vfs_resolver_result(np->n_trigseq, error ? RESOLVER_ERROR : RESOLVER_RESOLVED, error); #ifdef NFS_TRIGGER_DEBUG NP(np, "nfs trigger RESOLVE: %s %d, last %d nameiop %d, seq %d", - error ? "error" : "resolved", error, - (cnp->cn_flags & ISLASTCN) ? 1 : 0, cnp->cn_nameiop, np->n_trigseq); + error ? "error" : "resolved", error, + (cnp->cn_flags & ISLASTCN) ? 1 : 0, cnp->cn_nameiop, np->n_trigseq); #endif - if (pvp != NULLVP) + if (pvp != NULLVP) { vnode_put(pvp); - nfs_node_clear_busy(np); - return (result); + } + if (didBusy) { + nfs_node_clear_busy(np); + } + return result; } resolver_result_t @@ -3729,23 +4449,26 @@ nfs_mirror_mount_trigger_unresolve( #ifdef NFS_TRIGGER_DEBUG NP(np, "nfs trigger UNRESOLVE: busy error %d, seq %d", error, np->n_trigseq); #endif - return (result); + return result; } mp = vnode_mountedhere(vp); - if (!mp) + if (!mp) { error = EINVAL; - if (!error) + } + if (!error) { error = vfs_unmountbyfsid(&(vfs_statfs(mp)->f_fsid), flags, ctx); - if (!error) + } + if (!error) { np->n_trigseq++; + } result = vfs_resolver_result(np->n_trigseq, error ? RESOLVER_ERROR : RESOLVER_UNRESOLVED, error); #ifdef NFS_TRIGGER_DEBUG NP(np, "nfs trigger UNRESOLVE: %s %d, seq %d", - error ? "error" : "unresolved", error, np->n_trigseq); + error ? "error" : "unresolved", error, np->n_trigseq); #endif nfs_node_clear_busy(np); - return (result); + return result; } resolver_result_t @@ -3764,18 +4487,18 @@ nfs_mirror_mount_trigger_rearm( #ifdef NFS_TRIGGER_DEBUG NP(np, "nfs trigger REARM: busy error %d, seq %d", error, np->n_trigseq); #endif - return (result); + return result; } np->n_trigseq++; result = vfs_resolver_result(np->n_trigseq, - vnode_mountedhere(vp) ? RESOLVER_RESOLVED : RESOLVER_UNRESOLVED, 0); + vnode_mountedhere(vp) ? RESOLVER_RESOLVED : RESOLVER_UNRESOLVED, 0); #ifdef NFS_TRIGGER_DEBUG NP(np, "nfs trigger REARM: %s, seq %d", - vnode_mountedhere(vp) ? "resolved" : "unresolved", np->n_trigseq); + vnode_mountedhere(vp) ? "resolved" : "unresolved", np->n_trigseq); #endif nfs_node_clear_busy(np); - return (result); + return result; } /* @@ -3783,11 +4506,11 @@ nfs_mirror_mount_trigger_rearm( * the number of unused mounts. */ -#define NFS_EPHEMERAL_MOUNT_HARVEST_INTERVAL 120 /* how often the harvester runs */ +#define NFS_EPHEMERAL_MOUNT_HARVEST_INTERVAL 120 /* how often the harvester runs */ struct nfs_ephemeral_mount_harvester_info { - fsid_t fsid; /* FSID that we need to try to unmount */ - uint32_t mountcount; /* count of ephemeral mounts seen in scan */ - }; + fsid_t fsid; /* FSID that we need to try to unmount */ + uint32_t mountcount; /* count of ephemeral mounts seen in scan */ +}; /* various globals for the harvester */ static thread_call_t nfs_ephemeral_mount_harvester_timer = NULL; static int nfs_ephemeral_mount_harvester_on = 0; @@ -3801,17 +4524,21 @@ nfs_ephemeral_mount_harvester_callback(mount_t mp, void *arg) struct nfsmount *nmp; struct timeval now; - if (strcmp(mp->mnt_vfsstat.f_fstypename, "nfs")) - return (VFS_RETURNED); + if (strcmp(mp->mnt_vfsstat.f_fstypename, "nfs")) { + return VFS_RETURNED; + } nmp = VFSTONFS(mp); - if (!nmp || !NMFLAG(nmp, EPHEMERAL)) - return (VFS_RETURNED); + if (!nmp || !NMFLAG(nmp, EPHEMERAL) + ) { + return VFS_RETURNED; + } hinfo->mountcount++; /* avoid unmounting mounts that have been triggered within the last harvest interval */ microtime(&now); - if ((nmp->nm_mounttime >> 32) > ((uint32_t)now.tv_sec - NFS_EPHEMERAL_MOUNT_HARVEST_INTERVAL)) - return (VFS_RETURNED); + if ((nmp->nm_mounttime >> 32) > ((uint32_t)now.tv_sec - NFS_EPHEMERAL_MOUNT_HARVEST_INTERVAL)) { + return VFS_RETURNED; + } if (hinfo->fsid.val[0] || hinfo->fsid.val[1]) { /* attempt to unmount previously-found ephemeral mount */ @@ -3826,7 +4553,7 @@ nfs_ephemeral_mount_harvester_callback(mount_t mp, void *arg) hinfo->fsid.val[0] = mp->mnt_vfsstat.f_fsid.val[0]; hinfo->fsid.val[1] = mp->mnt_vfsstat.f_fsid.val[1]; - return (VFS_RETURNED); + return VFS_RETURNED; } /* @@ -3837,8 +4564,9 @@ nfs_ephemeral_mount_harvester_timer_func(void) { thread_t thd; - if (kernel_thread_start(nfs_ephemeral_mount_harvester, NULL, &thd) == KERN_SUCCESS) + if (kernel_thread_start(nfs_ephemeral_mount_harvester, NULL, &thd) == KERN_SUCCESS) { thread_deallocate(thd); + } } /* @@ -3887,8 +4615,9 @@ nfs_ephemeral_mount_harvester_start(void) lck_mtx_unlock(nfs_global_mutex); return; } - if (nfs_ephemeral_mount_harvester_timer == NULL) + if (nfs_ephemeral_mount_harvester_timer == NULL) { nfs_ephemeral_mount_harvester_timer = thread_call_allocate((thread_call_func_t)nfs_ephemeral_mount_harvester_timer_func, NULL); + } clock_interval_to_deadline(NFS_EPHEMERAL_MOUNT_HARVEST_INTERVAL, NSEC_PER_SEC, &deadline); thread_call_enter_delayed(nfs_ephemeral_mount_harvester_timer, deadline); nfs_ephemeral_mount_harvester_on = 1; @@ -3912,6 +4641,7 @@ nfs3_mount_rpc(struct nfsmount *nmp, struct sockaddr *sa, int sotype, int nfsver uint32_t mntvers, mntport, val; struct sockaddr_storage ss; struct sockaddr *saddr = (struct sockaddr*)&ss; + struct sockaddr_un *sun = (struct sockaddr_un*)saddr; nfsm_chain_null(&nmreq); nfsm_chain_null(&nmrep); @@ -3922,22 +4652,31 @@ nfs3_mount_rpc(struct nfsmount *nmp, struct sockaddr *sa, int sotype, int nfsver bcopy(sa, saddr, min(sizeof(ss), sa->sa_len)); if (saddr->sa_family == AF_INET) { - if (nmp->nm_mountport) + if (nmp->nm_mountport) { ((struct sockaddr_in*)saddr)->sin_port = htons(nmp->nm_mountport); + } mntport = ntohs(((struct sockaddr_in*)saddr)->sin_port); - } else { - if (nmp->nm_mountport) + } else if (saddr->sa_family == AF_INET6) { + if (nmp->nm_mountport) { ((struct sockaddr_in6*)saddr)->sin6_port = htons(nmp->nm_mountport); + } mntport = ntohs(((struct sockaddr_in6*)saddr)->sin6_port); + } else { /* Local domain socket */ + mntport = ((struct sockaddr_un *)saddr)->sun_path[0]; /* Do we have and address? */ + mntproto = IPPROTO_TCP; /* XXX rpcbind only listens on streams sockets for now */ } while (!mntport) { - error = nfs_portmap_lookup(nmp, ctx, saddr, NULL, RPCPROG_MNT, mntvers, mntproto, timeo); + error = nfs_portmap_lookup(nmp, ctx, saddr, NULL, RPCPROG_MNT, mntvers, + mntproto == IPPROTO_UDP ? SOCK_DGRAM : SOCK_STREAM, timeo); nfsmout_if(error); - if (saddr->sa_family == AF_INET) + if (saddr->sa_family == AF_INET) { mntport = ntohs(((struct sockaddr_in*)saddr)->sin_port); - else + } else if (saddr->sa_family == AF_INET6) { mntport = ntohs(((struct sockaddr_in6*)saddr)->sin6_port); + } else if (saddr->sa_family == AF_LOCAL) { + mntport = ((struct sockaddr_un*)saddr)->sun_path[0]; + } if (!mntport) { /* if not found and TCP, then retry with UDP */ if (mntproto == IPPROTO_UDP) { @@ -3946,6 +4685,9 @@ nfs3_mount_rpc(struct nfsmount *nmp, struct sockaddr *sa, int sotype, int nfsver } mntproto = IPPROTO_UDP; bcopy(sa, saddr, min(sizeof(ss), sa->sa_len)); + if (saddr->sa_family == AF_LOCAL) { + strlcpy(sun->sun_path, RPCB_TICLTS_PATH, sizeof(sun->sun_path)); + } } } nfsmout_if(error || !mntport); @@ -3957,17 +4699,18 @@ nfs3_mount_rpc(struct nfsmount *nmp, struct sockaddr *sa, int sotype, int nfsver nfsm_chain_build_done(error, &nmreq); nfsmout_if(error); error = nfsm_rpchead2(nmp, (mntproto == IPPROTO_UDP) ? SOCK_DGRAM : SOCK_STREAM, - RPCPROG_MNT, mntvers, RPCMNT_MOUNT, - RPCAUTH_SYS, cred, NULL, nmreq.nmc_mhead, &xid, &mreq); + RPCPROG_MNT, mntvers, RPCMNT_MOUNT, + RPCAUTH_SYS, cred, NULL, nmreq.nmc_mhead, &xid, &mreq); nfsmout_if(error); nmreq.nmc_mhead = NULL; error = nfs_aux_request(nmp, thd, saddr, NULL, - ((mntproto == IPPROTO_UDP) ? SOCK_DGRAM : SOCK_STREAM), - mreq, R_XID32(xid), 1, timeo, &nmrep); + ((mntproto == IPPROTO_UDP) ? SOCK_DGRAM : SOCK_STREAM), + mreq, R_XID32(xid), 1, timeo, &nmrep); nfsmout_if(error); nfsm_chain_get_32(error, &nmrep, val); - if (!error && val) + if (!error && val) { error = val; + } nfsm_chain_get_fh(error, &nmrep, nfsvers, fh); if (!error && (nfsvers > NFS_VER2)) { sec->count = NX_MAX_SEC_FLAVORS; @@ -3976,7 +4719,7 @@ nfs3_mount_rpc(struct nfsmount *nmp, struct sockaddr *sa, int sotype, int nfsver nfsmout: nfsm_chain_cleanup(&nmreq); nfsm_chain_cleanup(&nmrep); - return (error); + return error; } @@ -3997,8 +4740,9 @@ nfs3_umount_rpc(struct nfsmount *nmp, vfs_context_t ctx, int timeo) struct sockaddr_storage ss; struct sockaddr *saddr = (struct sockaddr*)&ss; - if (!nmp->nm_saddr) + if (!nmp->nm_saddr) { return; + } nfsm_chain_null(&nmreq); nfsm_chain_null(&nmrep); @@ -4008,18 +4752,24 @@ nfs3_umount_rpc(struct nfsmount *nmp, vfs_context_t ctx, int timeo) mntport = nmp->nm_mountport; bcopy(nmp->nm_saddr, saddr, min(sizeof(ss), nmp->nm_saddr->sa_len)); - if (saddr->sa_family == AF_INET) + if (saddr->sa_family == AF_INET) { ((struct sockaddr_in*)saddr)->sin_port = htons(mntport); - else + } else if (saddr->sa_family == AF_INET6) { ((struct sockaddr_in6*)saddr)->sin6_port = htons(mntport); + } else { /* Local domain socket */ + mntport = ((struct sockaddr_un *)saddr)->sun_path[0]; /* Do we have and address? */ + } while (!mntport) { error = nfs_portmap_lookup(nmp, ctx, saddr, NULL, RPCPROG_MNT, mntvers, mntproto, timeo); - nfsmout_if(error); - if (saddr->sa_family == AF_INET) + nfsmout_if(error); + if (saddr->sa_family == AF_INET) { mntport = ntohs(((struct sockaddr_in*)saddr)->sin_port); - else + } else if (saddr->sa_family == AF_INET6) { mntport = ntohs(((struct sockaddr_in6*)saddr)->sin6_port); + } else { /* Local domain socket */ + mntport = ((struct sockaddr_un *)saddr)->sun_path[0]; /* Do we have and address? */ + } /* if not found and mntvers > VER1, then retry with VER1 */ if (!mntport) { if (mntvers > RPCMNT_VER1) { @@ -4037,21 +4787,22 @@ nfs3_umount_rpc(struct nfsmount *nmp, vfs_context_t ctx, int timeo) /* MOUNT protocol UNMOUNT request */ path = &vfs_statfs(nmp->nm_mountp)->f_mntfromname[0]; - while (*path && (*path != '/')) + while (*path && (*path != '/')) { path++; + } slen = strlen(path); nfsm_chain_build_alloc_init(error, &nmreq, NFSX_UNSIGNED + nfsm_rndup(slen)); nfsm_chain_add_name(error, &nmreq, path, slen, nmp); nfsm_chain_build_done(error, &nmreq); nfsmout_if(error); error = nfsm_rpchead2(nmp, (mntproto == IPPROTO_UDP) ? SOCK_DGRAM : SOCK_STREAM, - RPCPROG_MNT, RPCMNT_VER1, RPCMNT_UMOUNT, - RPCAUTH_SYS, cred, NULL, nmreq.nmc_mhead, &xid, &mreq); + RPCPROG_MNT, RPCMNT_VER1, RPCMNT_UMOUNT, + RPCAUTH_SYS, cred, NULL, nmreq.nmc_mhead, &xid, &mreq); nfsmout_if(error); nmreq.nmc_mhead = NULL; error = nfs_aux_request(nmp, thd, saddr, NULL, - ((mntproto == IPPROTO_UDP) ? SOCK_DGRAM : SOCK_STREAM), - mreq, R_XID32(xid), 1, timeo, &nmrep); + ((mntproto == IPPROTO_UDP) ? SOCK_DGRAM : SOCK_STREAM), + mreq, R_XID32(xid), 1, timeo, &nmrep); nfsmout: nfsm_chain_cleanup(&nmreq); nfsm_chain_cleanup(&nmrep); @@ -4069,7 +4820,7 @@ nfs_vfs_unmount( struct nfsmount *nmp; vnode_t vp; int error, flags = 0; - struct timespec ts = { 1, 0 }; + struct timespec ts = { .tv_sec = 1, .tv_nsec = 0 }; nmp = VFSTONFS(mp); lck_mtx_lock(&nmp->nm_lock); @@ -4090,8 +4841,9 @@ nfs_vfs_unmount( /* * Wait for any in-progress monitored node scan to complete. */ - while (nmp->nm_state & NFSSTA_MONITOR_SCAN) - msleep(&nmp->nm_state, &nmp->nm_lock, PZERO-1, "nfswaitmonscan", &ts); + while (nmp->nm_state & NFSSTA_MONITOR_SCAN) { + msleep(&nmp->nm_state, &nmp->nm_lock, PZERO - 1, "nfswaitmonscan", &ts); + } /* * Goes something like this.. * - Call vflush() to clear out vnodes for this file system, @@ -4111,16 +4863,17 @@ nfs_vfs_unmount( if (mntflags & MNT_FORCE) { error = vflush(mp, NULLVP, flags); /* locks vp in the process */ } else { - if (vnode_isinuse(vp, 1)) + if (vnode_isinuse(vp, 1)) { error = EBUSY; - else + } else { error = vflush(mp, vp, flags); + } } if (error) { lck_mtx_lock(&nmp->nm_lock); nmp->nm_state &= ~NFSSTA_UNMOUNTING; lck_mtx_unlock(&nmp->nm_lock); - return (error); + return error; } lck_mtx_lock(&nmp->nm_lock); @@ -4132,13 +4885,16 @@ nfs_vfs_unmount( */ error = vnode_get(vp); vnode_rele(vp); - if (!error) + if (!error) { vnode_put(vp); + } vflush(mp, NULLVP, FORCECLOSE); - nfs_mount_cleanup(nmp); - return (0); + /* Wait for all other references to be released and free the mount */ + nfs_mount_drain_and_cleanup(nmp); + + return 0; } /* @@ -4153,21 +4909,25 @@ nfs_fs_locations_cleanup(struct nfs_fs_locations *nfslsp) uint32_t loc, serv, addr, comp; /* free up fs locations */ - if (!nfslsp->nl_numlocs || !nfslsp->nl_locations) + if (!nfslsp->nl_numlocs || !nfslsp->nl_locations) { return; + } for (loc = 0; loc < nfslsp->nl_numlocs; loc++) { fsl = nfslsp->nl_locations[loc]; - if (!fsl) + if (!fsl) { continue; + } if ((fsl->nl_servcount > 0) && fsl->nl_servers) { for (serv = 0; serv < fsl->nl_servcount; serv++) { fss = fsl->nl_servers[serv]; - if (!fss) + if (!fss) { continue; + } if ((fss->ns_addrcount > 0) && fss->ns_addresses) { - for (addr = 0; addr < fss->ns_addrcount; addr++) + for (addr = 0; addr < fss->ns_addrcount; addr++) { FREE(fss->ns_addresses[addr], M_TEMP); + } FREE(fss->ns_addresses, M_TEMP); } FREE(fss->ns_name, M_TEMP); @@ -4177,9 +4937,11 @@ nfs_fs_locations_cleanup(struct nfs_fs_locations *nfslsp) } fsp = &fsl->nl_path; if (fsp->np_compcount && fsp->np_components) { - for (comp = 0; comp < fsp->np_compcount; comp++) - if (fsp->np_components[comp]) + for (comp = 0; comp < fsp->np_compcount; comp++) { + if (fsp->np_components[comp]) { FREE(fsp->np_components[comp], M_TEMP); + } + } FREE(fsp->np_components, M_TEMP); } FREE(fsl, M_TEMP); @@ -4189,26 +4951,65 @@ nfs_fs_locations_cleanup(struct nfs_fs_locations *nfslsp) nfslsp->nl_locations = NULL; } +void +nfs_mount_rele(struct nfsmount *nmp) +{ + int wup = 0; + + lck_mtx_lock(&nmp->nm_lock); + if (nmp->nm_ref < 1) { + panic("nfs zombie mount underflow\n"); + } + nmp->nm_ref--; + if (nmp->nm_ref == 0) { + wup = nmp->nm_state & NFSSTA_MOUNT_DRAIN; + } + lck_mtx_unlock(&nmp->nm_lock); + if (wup) { + wakeup(&nmp->nm_ref); + } +} + +void +nfs_mount_drain_and_cleanup(struct nfsmount *nmp) +{ + lck_mtx_lock(&nmp->nm_lock); + nmp->nm_state |= NFSSTA_MOUNT_DRAIN; + while (nmp->nm_ref > 0) { + msleep(&nmp->nm_ref, &nmp->nm_lock, PZERO - 1, "nfs_mount_drain", NULL); + } + assert(nmp->nm_ref == 0); + lck_mtx_unlock(&nmp->nm_lock); + nfs_mount_cleanup(nmp); +} + /* - * cleanup/destroy an nfsmount + * nfs_mount_zombie */ void -nfs_mount_cleanup(struct nfsmount *nmp) +nfs_mount_zombie(struct nfsmount *nmp, int nm_state_flags) { struct nfsreq *req, *treq; - struct nfs_reqqhead iodq; - struct timespec ts = { 1, 0 }; + struct nfs_reqqhead iodq, resendq; + struct timespec ts = { .tv_sec = 1, .tv_nsec = 0 }; struct nfs_open_owner *noop, *nextnoop; nfsnode_t np; int docallback; + lck_mtx_lock(&nmp->nm_lock); + nmp->nm_state |= nm_state_flags; + nmp->nm_ref++; + lck_mtx_unlock(&nmp->nm_lock); +#if CONFIG_NFS4 /* stop callbacks */ - if ((nmp->nm_vers >= NFS_VER4) && !NMFLAG(nmp, NOCALLBACK) && nmp->nm_cbid) + if ((nmp->nm_vers >= NFS_VER4) && !NMFLAG(nmp, NOCALLBACK) && nmp->nm_cbid) { nfs4_mount_callback_shutdown(nmp); - + } +#endif +#if CONFIG_NFS_GSS /* Destroy any RPCSEC_GSS contexts */ - if (!TAILQ_EMPTY(&nmp->nm_gsscl)) - nfs_gss_clnt_ctx_unmount(nmp); + nfs_gss_clnt_ctx_unmount(nmp); +#endif /* mark the socket for termination */ lck_mtx_lock(&nmp->nm_lock); @@ -4216,25 +5017,23 @@ nfs_mount_cleanup(struct nfsmount *nmp) /* Have the socket thread send the unmount RPC, if requested/appropriate. */ if ((nmp->nm_vers < NFS_VER4) && (nmp->nm_state & NFSSTA_MOUNTED) && - !(nmp->nm_state & NFSSTA_FORCE) && NMFLAG(nmp, CALLUMNT)) + !(nmp->nm_state & (NFSSTA_FORCE | NFSSTA_DEAD)) && NMFLAG(nmp, CALLUMNT)) { nfs_mount_sock_thread_wake(nmp); + } /* wait for the socket thread to terminate */ - while (nmp->nm_sockthd) { + while (nmp->nm_sockthd && current_thread() != nmp->nm_sockthd) { wakeup(&nmp->nm_sockthd); - msleep(&nmp->nm_sockthd, &nmp->nm_lock, PZERO-1, "nfswaitsockthd", &ts); + msleep(&nmp->nm_sockthd, &nmp->nm_lock, PZERO - 1, "nfswaitsockthd", &ts); } - lck_mtx_unlock(&nmp->nm_lock); /* tear down the socket */ nfs_disconnect(nmp); - if (nmp->nm_mountp) - vfs_setfsprivate(nmp->nm_mountp, NULL); - lck_mtx_lock(&nmp->nm_lock); +#if CONFIG_NFS4 if ((nmp->nm_vers >= NFS_VER4) && !NMFLAG(nmp, NOCALLBACK) && nmp->nm_cbid) { /* clear out any pending delegation return requests */ while ((np = TAILQ_FIRST(&nmp->nm_dreturnq))) { @@ -4247,100 +5046,149 @@ nfs_mount_cleanup(struct nfsmount *nmp) if ((nmp->nm_vers >= NFS_VER4) && nmp->nm_renew_timer) { thread_call_cancel(nmp->nm_renew_timer); thread_call_free(nmp->nm_renew_timer); + nmp->nm_renew_timer = NULL; } - - if (nmp->nm_saddr) - FREE(nmp->nm_saddr, M_SONAME); - if ((nmp->nm_vers < NFS_VER4) && nmp->nm_rqsaddr) - FREE(nmp->nm_rqsaddr, M_SONAME); +#endif lck_mtx_unlock(&nmp->nm_lock); - if (nmp->nm_state & NFSSTA_MOUNTED) + if (nmp->nm_state & NFSSTA_MOUNTED) { switch (nmp->nm_lockmode) { case NFS_LOCK_MODE_DISABLED: case NFS_LOCK_MODE_LOCAL: break; case NFS_LOCK_MODE_ENABLED: default: - if (nmp->nm_vers <= NFS_VER3) + if (nmp->nm_vers <= NFS_VER3) { nfs_lockd_mount_unregister(nmp); + nmp->nm_lockmode = NFS_LOCK_MODE_DISABLED; + } break; } + } +#if CONFIG_NFS4 if ((nmp->nm_vers >= NFS_VER4) && nmp->nm_longid) { /* remove/deallocate the client ID data */ lck_mtx_lock(nfs_global_mutex); TAILQ_REMOVE(&nfsclientids, nmp->nm_longid, nci_link); - if (nmp->nm_longid->nci_id) + if (nmp->nm_longid->nci_id) { FREE(nmp->nm_longid->nci_id, M_TEMP); + } FREE(nmp->nm_longid, M_TEMP); + nmp->nm_longid = NULL; lck_mtx_unlock(nfs_global_mutex); } - +#endif /* - * Loop through outstanding request list and remove dangling - * references to defunct nfsmount struct + * Be sure all requests for this mount are completed + * and removed from the resend queue. */ - TAILQ_INIT(&iodq); + TAILQ_INIT(&resendq); lck_mtx_lock(nfs_request_mutex); TAILQ_FOREACH(req, &nfs_reqq, r_chain) { if (req->r_nmp == nmp) { lck_mtx_lock(&req->r_mtx); - req->r_nmp = NULL; - lck_mtx_unlock(&req->r_mtx); - if (req->r_callback.rcb_func) { - /* async I/O RPC needs to be finished */ - lck_mtx_lock(nfsiod_mutex); - if (req->r_achain.tqe_next == NFSREQNOLIST) - TAILQ_INSERT_TAIL(&iodq, req, r_achain); - lck_mtx_unlock(nfsiod_mutex); + if (!req->r_error && req->r_nmrep.nmc_mhead == NULL) { + req->r_error = EIO; } - lck_mtx_lock(&req->r_mtx); - lck_mtx_lock(&nmp->nm_lock); if (req->r_flags & R_RESENDQ) { + lck_mtx_lock(&nmp->nm_lock); + req->r_flags &= ~R_RESENDQ; if (req->r_rchain.tqe_next != NFSREQNOLIST) { TAILQ_REMOVE(&nmp->nm_resendq, req, r_rchain); - req->r_rchain.tqe_next = NFSREQNOLIST; + /* + * Queue up the request so that we can unreference them + * with out holding nfs_request_mutex + */ + TAILQ_INSERT_TAIL(&resendq, req, r_rchain); } - req->r_flags &= ~R_RESENDQ; + lck_mtx_unlock(&nmp->nm_lock); } - lck_mtx_unlock(&nmp->nm_lock); - lck_mtx_unlock(&req->r_mtx); wakeup(req); + lck_mtx_unlock(&req->r_mtx); } } lck_mtx_unlock(nfs_request_mutex); - /* finish any async I/O RPCs queued up */ + /* Since we've drop the request mutex we can now safely unreference the request */ + TAILQ_FOREACH_SAFE(req, &resendq, r_rchain, treq) { + TAILQ_REMOVE(&resendq, req, r_rchain); + /* Make sure we don't try and remove again in nfs_request_destroy */ + req->r_rchain.tqe_next = NFSREQNOLIST; + nfs_request_rele(req); + } + + /* + * Now handle and outstanding async requests. We need to walk the + * request queue again this time with the nfsiod_mutex held. No + * other iods can grab our requests until we've put them on our own + * local iod queue for processing. + */ + TAILQ_INIT(&iodq); + lck_mtx_lock(nfs_request_mutex); lck_mtx_lock(nfsiod_mutex); + TAILQ_FOREACH(req, &nfs_reqq, r_chain) { + if (req->r_nmp == nmp) { + lck_mtx_lock(&req->r_mtx); + if (req->r_callback.rcb_func + && !(req->r_flags & R_WAITSENT) && !(req->r_flags & R_IOD)) { + /* + * Since R_IOD is not set then we need to handle it. If + * we're not on a list add it to our iod queue. Otherwise + * we must already be on nm_iodq which is added to our + * local queue below. + * %%% We should really keep a back pointer to our iod queue + * that we're on. + */ + req->r_flags |= R_IOD; + if (req->r_achain.tqe_next == NFSREQNOLIST) { + TAILQ_INSERT_TAIL(&iodq, req, r_achain); + } + } + lck_mtx_unlock(&req->r_mtx); + } + } + + /* finish any async I/O RPCs queued up */ + if (nmp->nm_iodlink.tqe_next != NFSNOLIST) { + TAILQ_REMOVE(&nfsiodmounts, nmp, nm_iodlink); + } TAILQ_CONCAT(&iodq, &nmp->nm_iodq, r_achain); lck_mtx_unlock(nfsiod_mutex); + lck_mtx_unlock(nfs_request_mutex); + TAILQ_FOREACH_SAFE(req, &iodq, r_achain, treq) { TAILQ_REMOVE(&iodq, req, r_achain); req->r_achain.tqe_next = NFSREQNOLIST; lck_mtx_lock(&req->r_mtx); - req->r_error = ENXIO; docallback = !(req->r_flags & R_WAITSENT); lck_mtx_unlock(&req->r_mtx); - if (docallback) + if (docallback) { req->r_callback.rcb_func(req); + } } /* clean up common state */ lck_mtx_lock(&nmp->nm_lock); - while ((np = LIST_FIRST(&nmp->nm_monlist))) { - LIST_REMOVE(np, n_monlink); - np->n_monlink.le_next = NFSNOLIST; - } + while ((np = LIST_FIRST(&nmp->nm_monlist))) { + LIST_REMOVE(np, n_monlink); + np->n_monlink.le_next = NFSNOLIST; + } TAILQ_FOREACH_SAFE(noop, &nmp->nm_open_owners, noo_link, nextnoop) { + os_ref_count_t newcount; + TAILQ_REMOVE(&nmp->nm_open_owners, noop, noo_link); noop->noo_flags &= ~NFS_OPEN_OWNER_LINK; - if (noop->noo_refcnt) + newcount = os_ref_release_locked(&noop->noo_refcnt); + + if (newcount) { continue; + } nfs_open_owner_destroy(noop); } lck_mtx_unlock(&nmp->nm_lock); +#if CONFIG_NFS4 /* clean up NFSv4 state */ if (nmp->nm_vers >= NFS_VER4) { lck_mtx_lock(&nmp->nm_lock); @@ -4350,44 +5198,104 @@ nfs_mount_cleanup(struct nfsmount *nmp) } lck_mtx_unlock(&nmp->nm_lock); } - if (IS_VALID_CRED(nmp->nm_mcred)) - kauth_cred_unref(&nmp->nm_mcred); - - nfs_fs_locations_cleanup(&nmp->nm_locations); - - if (nmp->nm_args) - xb_free(nmp->nm_args); - lck_mtx_destroy(&nmp->nm_lock, nfs_mount_grp); - if (nmp->nm_fh) - FREE(nmp->nm_fh, M_TEMP); - FREE_ZONE((caddr_t)nmp, sizeof (struct nfsmount), M_NFSMNT); +#endif + nfs_mount_rele(nmp); } /* - * Return root of a filesystem + * cleanup/destroy an nfsmount */ -int -nfs_vfs_root(mount_t mp, vnode_t *vpp, __unused vfs_context_t ctx) +void +nfs_mount_cleanup(struct nfsmount *nmp) { - vnode_t vp; - struct nfsmount *nmp; - int error; - u_int32_t vpid; + if (!nmp) { + return; + } - nmp = VFSTONFS(mp); - if (!nmp || !nmp->nm_dnp) - return (ENXIO); + nfs_mount_zombie(nmp, 0); + + NFS_VFS_DBG("Unmounting %s from %s\n", + vfs_statfs(nmp->nm_mountp)->f_mntfromname, + vfs_statfs(nmp->nm_mountp)->f_mntonname); + NFS_VFS_DBG("nfs state = 0x%8.8x\n", nmp->nm_state); + NFS_VFS_DBG("nfs socket flags = 0x%8.8x\n", nmp->nm_sockflags); + NFS_VFS_DBG("nfs mount ref count is %d\n", nmp->nm_ref); + NFS_VFS_DBG("mount ref count is %d\n", nmp->nm_mountp->mnt_count); + + if (nmp->nm_mountp) { + vfs_setfsprivate(nmp->nm_mountp, NULL); + } + + lck_mtx_lock(&nmp->nm_lock); + if (nmp->nm_ref) { + panic("Some one has grabbed a ref %d state flags = 0x%8.8x\n", nmp->nm_ref, nmp->nm_state); + } + + if (nmp->nm_saddr) { + FREE(nmp->nm_saddr, M_SONAME); + } + if ((nmp->nm_vers < NFS_VER4) && nmp->nm_rqsaddr) { + FREE(nmp->nm_rqsaddr, M_SONAME); + } + + if (IS_VALID_CRED(nmp->nm_mcred)) { + kauth_cred_unref(&nmp->nm_mcred); + } + + nfs_fs_locations_cleanup(&nmp->nm_locations); + + if (nmp->nm_realm) { + FREE(nmp->nm_realm, M_TEMP); + } + if (nmp->nm_principal) { + FREE(nmp->nm_principal, M_TEMP); + } + if (nmp->nm_sprinc) { + FREE(nmp->nm_sprinc, M_TEMP); + } + + if (nmp->nm_args) { + xb_free(nmp->nm_args); + } + + lck_mtx_unlock(&nmp->nm_lock); + + lck_mtx_destroy(&nmp->nm_lock, nfs_mount_grp); + if (nmp->nm_fh) { + FREE(nmp->nm_fh, M_TEMP); + } + + + FREE_ZONE(nmp, sizeof(struct nfsmount), M_NFSMNT); +} + +/* + * Return root of a filesystem + */ +int +nfs_vfs_root(mount_t mp, vnode_t *vpp, __unused vfs_context_t ctx) +{ + vnode_t vp; + struct nfsmount *nmp; + int error; + u_int32_t vpid; + + nmp = VFSTONFS(mp); + if (!nmp || !nmp->nm_dnp) { + return ENXIO; + } vp = NFSTOV(nmp->nm_dnp); vpid = vnode_vid(vp); while ((error = vnode_getwithvid(vp, vpid))) { /* vnode_get() may return ENOENT if the dir changes. */ /* If that happens, just try it again, else return the error. */ - if ((error != ENOENT) || (vnode_vid(vp) == vpid)) - return (error); + if ((error != ENOENT) || (vnode_vid(vp) == vpid)) { + return error; + } vpid = vnode_vid(vp); } *vpp = vp; - return (0); + return 0; } /* @@ -4402,10 +5310,36 @@ nfs_vfs_quotactl( __unused caddr_t datap, __unused vfs_context_t context) { - return (ENOTSUP); + return ENOTSUP; } #else +static int +nfs_sa_getport(struct sockaddr *sa, int *error) +{ + int port = 0; + + if (sa->sa_family == AF_INET6) { + port = ntohs(((struct sockaddr_in6*)sa)->sin6_port); + } else if (sa->sa_family == AF_INET) { + port = ntohs(((struct sockaddr_in*)sa)->sin_port); + } else if (error) { + *error = EIO; + } + + return port; +} + +static void +nfs_sa_setport(struct sockaddr *sa, int port) +{ + if (sa->sa_family == AF_INET6) { + ((struct sockaddr_in6*)sa)->sin6_port = htons(port); + } else if (sa->sa_family == AF_INET) { + ((struct sockaddr_in*)sa)->sin_port = htons(port); + } +} + int nfs3_getquota(struct nfsmount *nmp, vfs_context_t ctx, uid_t id, int type, struct dqblk *dqb) { @@ -4420,79 +5354,143 @@ nfs3_getquota(struct nfsmount *nmp, vfs_context_t ctx, uid_t id, int type, struc uint32_t val = 0, bsize = 0; struct sockaddr *rqsaddr; struct timeval now; + struct timespec ts = { .tv_sec = 1, .tv_nsec = 0 }; - if (!nmp->nm_saddr) - return (ENXIO); + if (!nmp->nm_saddr) { + return ENXIO; + } - if (NMFLAG(nmp, NOQUOTA)) - return (ENOTSUP); + if (NMFLAG(nmp, NOQUOTA) || nmp->nm_saddr->sa_family == AF_LOCAL /* XXX for now */) { + return ENOTSUP; + } - if (!nmp->nm_rqsaddr) - MALLOC(nmp->nm_rqsaddr, struct sockaddr *, sizeof(struct sockaddr_storage), M_SONAME, M_WAITOK|M_ZERO); - if (!nmp->nm_rqsaddr) - return (ENOMEM); - rqsaddr = nmp->nm_rqsaddr; - if (rqsaddr->sa_family == AF_INET6) - rqport = ntohs(((struct sockaddr_in6*)rqsaddr)->sin6_port); - else if (rqsaddr->sa_family == AF_INET) - rqport = ntohs(((struct sockaddr_in*)rqsaddr)->sin_port); + /* + * Allocate an address for rquotad if needed + */ + if (!nmp->nm_rqsaddr) { + int need_free = 0; + + MALLOC(rqsaddr, struct sockaddr *, sizeof(struct sockaddr_storage), M_SONAME, M_WAITOK | M_ZERO); + bcopy(nmp->nm_saddr, rqsaddr, min(sizeof(struct sockaddr_storage), nmp->nm_saddr->sa_len)); + /* Set the port to zero, will call rpcbind to get the port below */ + nfs_sa_setport(rqsaddr, 0); + microuptime(&now); + + lck_mtx_lock(&nmp->nm_lock); + if (!nmp->nm_rqsaddr) { + nmp->nm_rqsaddr = rqsaddr; + nmp->nm_rqsaddrstamp = now.tv_sec; + } else { + need_free = 1; + } + lck_mtx_unlock(&nmp->nm_lock); + if (need_free) { + FREE(rqsaddr, M_SONAME); + } + } timeo = NMFLAG(nmp, SOFT) ? 10 : 60; rqproto = IPPROTO_UDP; /* XXX should prefer TCP if mount is TCP */ /* check if we have a recently cached rquota port */ microuptime(&now); - if (!rqport || ((nmp->nm_rqsaddrstamp + 60) >= (uint32_t)now.tv_sec)) { + lck_mtx_lock(&nmp->nm_lock); + rqsaddr = nmp->nm_rqsaddr; + rqport = nfs_sa_getport(rqsaddr, &error); + while (!error && (!rqport || ((nmp->nm_rqsaddrstamp + 60) <= (uint32_t)now.tv_sec))) { + error = nfs_sigintr(nmp, NULL, thd, 1); + if (error) { + lck_mtx_unlock(&nmp->nm_lock); + return error; + } + if (nmp->nm_state & NFSSTA_RQUOTAINPROG) { + nmp->nm_state |= NFSSTA_WANTRQUOTA; + msleep(&nmp->nm_rqsaddr, &nmp->nm_lock, PZERO - 1, "nfswaitrquotaaddr", &ts); + rqport = nfs_sa_getport(rqsaddr, &error); + continue; + } + nmp->nm_state |= NFSSTA_RQUOTAINPROG; + lck_mtx_unlock(&nmp->nm_lock); + /* send portmap request to get rquota port */ - bcopy(nmp->nm_saddr, rqsaddr, min(sizeof(struct sockaddr_storage), nmp->nm_saddr->sa_len)); error = nfs_portmap_lookup(nmp, ctx, rqsaddr, NULL, RPCPROG_RQUOTA, rqvers, rqproto, timeo); - if (error) - return (error); - if (rqsaddr->sa_family == AF_INET6) - rqport = ntohs(((struct sockaddr_in6*)rqsaddr)->sin6_port); - else if (rqsaddr->sa_family == AF_INET) - rqport = ntohs(((struct sockaddr_in*)rqsaddr)->sin_port); - else - return (EIO); - if (!rqport) - return (ENOTSUP); + if (error) { + goto out; + } + rqport = nfs_sa_getport(rqsaddr, &error); + if (error) { + goto out; + } + + if (!rqport) { + /* + * We overload PMAPPORT for the port if rquotad is not + * currently registered or up at the server. In the + * while loop above, port will be set and we will defer + * for a bit. Perhaps the service isn't online yet. + * + * Note that precludes using indirect, but we're not doing + * that here. + */ + rqport = PMAPPORT; + nfs_sa_setport(rqsaddr, rqport); + } microuptime(&now); nmp->nm_rqsaddrstamp = now.tv_sec; +out: + lck_mtx_lock(&nmp->nm_lock); + nmp->nm_state &= ~NFSSTA_RQUOTAINPROG; + if (nmp->nm_state & NFSSTA_WANTRQUOTA) { + nmp->nm_state &= ~NFSSTA_WANTRQUOTA; + wakeup(&nmp->nm_rqsaddr); + } + } + lck_mtx_unlock(&nmp->nm_lock); + if (error) { + return error; + } + + /* Using PMAPPORT for unavailabe rquota service */ + if (rqport == PMAPPORT) { + return ENOTSUP; } /* rquota request */ nfsm_chain_null(&nmreq); nfsm_chain_null(&nmrep); path = &vfs_statfs(nmp->nm_mountp)->f_mntfromname[0]; - while (*path && (*path != '/')) + while (*path && (*path != '/')) { path++; + } slen = strlen(path); nfsm_chain_build_alloc_init(error, &nmreq, 3 * NFSX_UNSIGNED + nfsm_rndup(slen)); nfsm_chain_add_name(error, &nmreq, path, slen, nmp); - if (type == GRPQUOTA) + if (type == GRPQUOTA) { nfsm_chain_add_32(error, &nmreq, type); + } nfsm_chain_add_32(error, &nmreq, id); nfsm_chain_build_done(error, &nmreq); nfsmout_if(error); error = nfsm_rpchead2(nmp, (rqproto == IPPROTO_UDP) ? SOCK_DGRAM : SOCK_STREAM, - RPCPROG_RQUOTA, rqvers, RPCRQUOTA_GET, - RPCAUTH_SYS, cred, NULL, nmreq.nmc_mhead, &xid, &mreq); + RPCPROG_RQUOTA, rqvers, RPCRQUOTA_GET, + RPCAUTH_SYS, cred, NULL, nmreq.nmc_mhead, &xid, &mreq); nfsmout_if(error); nmreq.nmc_mhead = NULL; error = nfs_aux_request(nmp, thd, rqsaddr, NULL, - (rqproto == IPPROTO_UDP) ? SOCK_DGRAM : SOCK_STREAM, - mreq, R_XID32(xid), 0, timeo, &nmrep); + (rqproto == IPPROTO_UDP) ? SOCK_DGRAM : SOCK_STREAM, + mreq, R_XID32(xid), 0, timeo, &nmrep); nfsmout_if(error); /* parse rquota response */ nfsm_chain_get_32(error, &nmrep, val); if (!error && (val != RQUOTA_STAT_OK)) { - if (val == RQUOTA_STAT_NOQUOTA) + if (val == RQUOTA_STAT_NOQUOTA) { error = ENOENT; - else if (val == RQUOTA_STAT_EPERM) + } else if (val == RQUOTA_STAT_EPERM) { error = EPERM; - else + } else { error = EIO; + } } nfsm_chain_get_32(error, &nmrep, bsize); nfsm_chain_adv(error, &nmrep, NFSX_UNSIGNED); @@ -4515,9 +5513,9 @@ nfs3_getquota(struct nfsmount *nmp, vfs_context_t ctx, uid_t id, int type, struc nfsmout: nfsm_chain_cleanup(&nmreq); nfsm_chain_cleanup(&nmrep); - return (error); + return error; } - +#if CONFIG_NFS4 int nfs4_getquota(struct nfsmount *nmp, vfs_context_t ctx, uid_t id, int type, struct dqblk *dqb) { @@ -4530,14 +5528,16 @@ nfs4_getquota(struct nfsmount *nmp, vfs_context_t ctx, uid_t id, int type, struc kauth_cred_t cred = vfs_context_ucred(ctx); struct nfsreq_secinfo_args si; - if (type != USRQUOTA) /* NFSv4 only supports user quotas */ - return (ENOTSUP); + if (type != USRQUOTA) { /* NFSv4 only supports user quotas */ + return ENOTSUP; + } /* first check that the server supports any of the quota attributes */ if (!NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_supp_attr, NFS_FATTR_QUOTA_AVAIL_HARD) && !NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_supp_attr, NFS_FATTR_QUOTA_AVAIL_SOFT) && - !NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_supp_attr, NFS_FATTR_QUOTA_USED)) - return (ENOTSUP); + !NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_supp_attr, NFS_FATTR_QUOTA_USED)) { + return ENOTSUP; + } /* * The credential passed to the server needs to have @@ -4551,19 +5551,21 @@ nfs4_getquota(struct nfsmount *nmp, vfs_context_t ctx, uid_t id, int type, struc temp_pcred.cr_ngroups = pcred->cr_ngroups; bcopy(pcred->cr_groups, temp_pcred.cr_groups, sizeof(temp_pcred.cr_groups)); cred = posix_cred_create(&temp_pcred); - if (!IS_VALID_CRED(cred)) - return (ENOMEM); + if (!IS_VALID_CRED(cred)) { + return ENOMEM; + } } else { kauth_cred_ref(cred); } nfsvers = nmp->nm_vers; np = nmp->nm_dnp; - if (!np) + if (!np) { error = ENXIO; + } if (error || ((error = vnode_get(NFSTOV(np))))) { kauth_cred_unref(&cred); - return(error); + return error; } NFSREQ_SECINFO_SET(&si, np, NULL, 0, NULL, 0); @@ -4573,7 +5575,7 @@ nfs4_getquota(struct nfsmount *nmp, vfs_context_t ctx, uid_t id, int type, struc // PUTFH + GETATTR numops = 2; nfsm_chain_build_alloc_init(error, &nmreq, 15 * NFSX_UNSIGNED); - nfsm_chain_add_compound_header(error, &nmreq, "quota", numops); + nfsm_chain_add_compound_header(error, &nmreq, "quota", nmp->nm_minor_vers, numops); numops--; nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH); nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize); @@ -4602,9 +5604,9 @@ nfsmout: nfsm_chain_cleanup(&nmrep); vnode_put(NFSTOV(np)); kauth_cred_unref(&cred); - return (error); + return error; } - +#endif /* CONFIG_NFS4 */ int nfs_vfs_quotactl(mount_t mp, int cmds, uid_t uid, caddr_t datap, vfs_context_t ctx) { @@ -4613,12 +5615,15 @@ nfs_vfs_quotactl(mount_t mp, int cmds, uid_t uid, caddr_t datap, vfs_context_t c uid_t euid = kauth_cred_getuid(vfs_context_ucred(ctx)); struct dqblk *dqb = (struct dqblk*)datap; - if (!(nmp = VFSTONFS(mp))) - return (ENXIO); + nmp = VFSTONFS(mp); + if (nfs_mount_gone(nmp)) { + return ENXIO; + } nfsvers = nmp->nm_vers; - if (uid == ~0U) + if (uid == ~0U) { uid = euid; + } /* we can only support Q_GETQUOTA */ cmd = cmds >> SUBCMDSHIFT; @@ -4631,23 +5636,26 @@ nfs_vfs_quotactl(mount_t mp, int cmds, uid_t uid, caddr_t datap, vfs_context_t c case Q_SETUSE: case Q_SYNC: case Q_QUOTASTAT: - return (ENOTSUP); + return ENOTSUP; default: - return (EINVAL); + return EINVAL; } type = cmds & SUBCMDMASK; - if ((u_int)type >= MAXQUOTAS) - return (EINVAL); - if ((uid != euid) && ((error = vfs_context_suser(ctx)))) - return (error); + if ((u_int)type >= MAXQUOTAS) { + return EINVAL; + } + if ((uid != euid) && ((error = vfs_context_suser(ctx)))) { + return error; + } - if (vfs_busy(mp, LK_NOWAIT)) - return (0); + if (vfs_busy(mp, LK_NOWAIT)) { + return 0; + } bzero(dqb, sizeof(*dqb)); error = nmp->nm_funcs->nf_getquota(nmp, ctx, uid, type, dqb); vfs_unbusy(mp); - return (error); + return error; } #endif @@ -4657,9 +5665,9 @@ nfs_vfs_quotactl(mount_t mp, int cmds, uid_t uid, caddr_t datap, vfs_context_t c int nfs_sync_callout(vnode_t, void *); struct nfs_sync_cargs { - vfs_context_t ctx; - int waitfor; - int error; + vfs_context_t ctx; + int waitfor; + int error; }; int @@ -4671,21 +5679,25 @@ nfs_sync_callout(vnode_t vp, void *arg) if (np->n_flag & NREVOKE) { vn_revoke(vp, REVOKEALL, cargs->ctx); - return (VNODE_RETURNED); + return VNODE_RETURNED; } - if (LIST_EMPTY(&np->n_dirtyblkhd)) - return (VNODE_RETURNED); - if (np->n_wrbusy > 0) - return (VNODE_RETURNED); - if (np->n_bflag & (NBFLUSHINPROG|NBINVALINPROG)) - return (VNODE_RETURNED); + if (LIST_EMPTY(&np->n_dirtyblkhd)) { + return VNODE_RETURNED; + } + if (np->n_wrbusy > 0) { + return VNODE_RETURNED; + } + if (np->n_bflag & (NBFLUSHINPROG | NBINVALINPROG)) { + return VNODE_RETURNED; + } error = nfs_flush(np, cargs->waitfor, vfs_context_thread(cargs->ctx), 0); - if (error) + if (error) { cargs->error = error; + } - return (VNODE_RETURNED); + return VNODE_RETURNED; } int @@ -4699,7 +5711,7 @@ nfs_vfs_sync(mount_t mp, int waitfor, vfs_context_t ctx) vnode_iterate(mp, 0, nfs_sync_callout, &cargs); - return (cargs.error); + return cargs.error; } /* @@ -4714,8 +5726,7 @@ nfs_vfs_vget( __unused vnode_t *vpp, __unused vfs_context_t ctx) { - - return (ENOTSUP); + return ENOTSUP; } /* @@ -4730,8 +5741,7 @@ nfs_vfs_fhtovp( __unused vnode_t *vpp, __unused vfs_context_t ctx) { - - return (ENOTSUP); + return ENOTSUP; } /* @@ -4745,8 +5755,7 @@ nfs_vfs_vptofh( __unused unsigned char *fhp, __unused vfs_context_t ctx) { - - return (ENOTSUP); + return ENOTSUP; } /* @@ -4759,8 +5768,7 @@ nfs_vfs_start( __unused int flags, __unused vfs_context_t ctx) { - - return (0); + return 0; } /* @@ -4770,7 +5778,7 @@ int nfs_mountinfo_assemble(struct nfsmount *nmp, struct xdrbuf *xb) { struct xdrbuf xbinfo, xborig; - char sotype[6]; + char sotype[16]; uint32_t origargsvers, origargslength; uint32_t infolength_offset, curargsopaquelength_offset, curargslength_offset, attrslength_offset, curargs_end_offset, end_offset; uint32_t miattrs[NFS_MIATTR_BITMAP_LEN]; @@ -4793,16 +5801,19 @@ nfs_mountinfo_assemble(struct nfsmount *nmp, struct xdrbuf *xb) NFS_BITMAP_SET(miflags_mask, NFS_MIFLAG_DEAD); NFS_BITMAP_SET(miflags_mask, NFS_MIFLAG_NOTRESP); NFS_BITMAP_SET(miflags_mask, NFS_MIFLAG_RECOVERY); - if (nmp->nm_state & NFSSTA_DEAD) + if (nmp->nm_state & NFSSTA_DEAD) { NFS_BITMAP_SET(miflags, NFS_MIFLAG_DEAD); - if ((nmp->nm_state & (NFSSTA_TIMEO|NFSSTA_JUKEBOXTIMEO)) || - ((nmp->nm_state & NFSSTA_LOCKTIMEO) && (nmp->nm_lockmode == NFS_LOCK_MODE_ENABLED))) + } + if ((nmp->nm_state & (NFSSTA_TIMEO | NFSSTA_JUKEBOXTIMEO)) || + ((nmp->nm_state & NFSSTA_LOCKTIMEO) && (nmp->nm_lockmode == NFS_LOCK_MODE_ENABLED))) { NFS_BITMAP_SET(miflags, NFS_MIFLAG_NOTRESP); - if (nmp->nm_state & NFSSTA_RECOVER) + } + if (nmp->nm_state & NFSSTA_RECOVER) { NFS_BITMAP_SET(miflags, NFS_MIFLAG_RECOVERY); + } /* get original mount args length */ - xb_init_buffer(&xborig, nmp->nm_args, 2*XDRWORD); + xb_init_buffer(&xborig, nmp->nm_args, 2 * XDRWORD); xb_get_32(error, &xborig, origargsvers); /* version */ xb_get_32(error, &xborig, origargslength); /* args length */ nfsmerr_if(error); @@ -4811,8 +5822,11 @@ nfs_mountinfo_assemble(struct nfsmount *nmp, struct xdrbuf *xb) NFS_BITMAP_ZERO(mattrs, NFS_MATTR_BITMAP_LEN); NFS_BITMAP_SET(mattrs, NFS_MATTR_FLAGS); NFS_BITMAP_SET(mattrs, NFS_MATTR_NFS_VERSION); - if (nmp->nm_vers >= NFS_VER4) +#if CONFIG_NFS4 + if (nmp->nm_vers >= NFS_VER4) { NFS_BITMAP_SET(mattrs, NFS_MATTR_NFS_MINOR_VERSION); + } +#endif NFS_BITMAP_SET(mattrs, NFS_MATTR_READ_SIZE); NFS_BITMAP_SET(mattrs, NFS_MATTR_WRITE_SIZE); NFS_BITMAP_SET(mattrs, NFS_MATTR_READDIR_SIZE); @@ -4823,22 +5837,47 @@ nfs_mountinfo_assemble(struct nfsmount *nmp, struct xdrbuf *xb) NFS_BITMAP_SET(mattrs, NFS_MATTR_ATTRCACHE_DIR_MAX); NFS_BITMAP_SET(mattrs, NFS_MATTR_LOCK_MODE); NFS_BITMAP_SET(mattrs, NFS_MATTR_SECURITY); + if (nmp->nm_etype.selected < nmp->nm_etype.count) { + NFS_BITMAP_SET(mattrs, NFS_MATTR_KERB_ETYPE); + } NFS_BITMAP_SET(mattrs, NFS_MATTR_MAX_GROUP_LIST); NFS_BITMAP_SET(mattrs, NFS_MATTR_SOCKET_TYPE); - NFS_BITMAP_SET(mattrs, NFS_MATTR_NFS_PORT); - if ((nmp->nm_vers < NFS_VER4) && nmp->nm_mountport) + if (nmp->nm_saddr->sa_family != AF_LOCAL) { + NFS_BITMAP_SET(mattrs, NFS_MATTR_NFS_PORT); + } + if ((nmp->nm_vers < NFS_VER4) && nmp->nm_mountport && !nmp->nm_mount_localport) { NFS_BITMAP_SET(mattrs, NFS_MATTR_MOUNT_PORT); + } NFS_BITMAP_SET(mattrs, NFS_MATTR_REQUEST_TIMEOUT); - if (NMFLAG(nmp, SOFT)) + if (NMFLAG(nmp, SOFT)) { NFS_BITMAP_SET(mattrs, NFS_MATTR_SOFT_RETRY_COUNT); - if (nmp->nm_deadtimeout) + } + if (nmp->nm_deadtimeout) { NFS_BITMAP_SET(mattrs, NFS_MATTR_DEAD_TIMEOUT); - if (nmp->nm_fh) + } + if (nmp->nm_fh) { NFS_BITMAP_SET(mattrs, NFS_MATTR_FH); + } NFS_BITMAP_SET(mattrs, NFS_MATTR_FS_LOCATIONS); NFS_BITMAP_SET(mattrs, NFS_MATTR_MNTFLAGS); - if (origargsvers < NFS_ARGSVERSION_XDR) + if (origargsvers < NFS_ARGSVERSION_XDR) { NFS_BITMAP_SET(mattrs, NFS_MATTR_MNTFROM); + } + if (nmp->nm_realm) { + NFS_BITMAP_SET(mattrs, NFS_MATTR_REALM); + } + if (nmp->nm_principal) { + NFS_BITMAP_SET(mattrs, NFS_MATTR_PRINCIPAL); + } + if (nmp->nm_sprinc) { + NFS_BITMAP_SET(mattrs, NFS_MATTR_SVCPRINCIPAL); + } + if (nmp->nm_nfs_localport) { + NFS_BITMAP_SET(mattrs, NFS_MATTR_LOCAL_NFS_PORT); + } + if ((nmp->nm_vers < NFS_VER4) && nmp->nm_mount_localport) { + NFS_BITMAP_SET(mattrs, NFS_MATTR_LOCAL_MOUNT_PORT); + } /* set up current mount flags bitmap */ /* first set the flags that we will be setting - either on OR off */ @@ -4846,70 +5885,96 @@ nfs_mountinfo_assemble(struct nfsmount *nmp, struct xdrbuf *xb) NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_SOFT); NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_INTR); NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_RESVPORT); - if (nmp->nm_sotype == SOCK_DGRAM) + if (nmp->nm_sotype == SOCK_DGRAM) { NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_NOCONNECT); + } NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_DUMBTIMER); - if (nmp->nm_vers < NFS_VER4) + if (nmp->nm_vers < NFS_VER4) { NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_CALLUMNT); - if (nmp->nm_vers >= NFS_VER3) + } + if (nmp->nm_vers >= NFS_VER3) { NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_RDIRPLUS); + } NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_NONEGNAMECACHE); NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_MUTEJUKEBOX); +#if CONFIG_NFS4 if (nmp->nm_vers >= NFS_VER4) { NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_EPHEMERAL); NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_NOCALLBACK); - NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_NONAMEDATTR); + NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_NAMEDATTR); NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_NOACL); NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_ACLONLY); } +#endif NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_NFC); NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_NOQUOTA); - if (nmp->nm_vers < NFS_VER4) + if (nmp->nm_vers < NFS_VER4) { NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_MNTUDP); + } NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_MNTQUICK); /* now set the flags that should be set */ NFS_BITMAP_ZERO(mflags, NFS_MFLAG_BITMAP_LEN); - if (NMFLAG(nmp, SOFT)) + if (NMFLAG(nmp, SOFT)) { NFS_BITMAP_SET(mflags, NFS_MFLAG_SOFT); - if (NMFLAG(nmp, INTR)) + } + if (NMFLAG(nmp, INTR)) { NFS_BITMAP_SET(mflags, NFS_MFLAG_INTR); - if (NMFLAG(nmp, RESVPORT)) + } + if (NMFLAG(nmp, RESVPORT)) { NFS_BITMAP_SET(mflags, NFS_MFLAG_RESVPORT); - if ((nmp->nm_sotype == SOCK_DGRAM) && NMFLAG(nmp, NOCONNECT)) + } + if ((nmp->nm_sotype == SOCK_DGRAM) && NMFLAG(nmp, NOCONNECT)) { NFS_BITMAP_SET(mflags, NFS_MFLAG_NOCONNECT); - if (NMFLAG(nmp, DUMBTIMER)) + } + if (NMFLAG(nmp, DUMBTIMER)) { NFS_BITMAP_SET(mflags, NFS_MFLAG_DUMBTIMER); - if ((nmp->nm_vers < NFS_VER4) && NMFLAG(nmp, CALLUMNT)) + } + if ((nmp->nm_vers < NFS_VER4) && NMFLAG(nmp, CALLUMNT)) { NFS_BITMAP_SET(mflags, NFS_MFLAG_CALLUMNT); - if ((nmp->nm_vers >= NFS_VER3) && NMFLAG(nmp, RDIRPLUS)) + } + if ((nmp->nm_vers >= NFS_VER3) && NMFLAG(nmp, RDIRPLUS)) { NFS_BITMAP_SET(mflags, NFS_MFLAG_RDIRPLUS); - if (NMFLAG(nmp, NONEGNAMECACHE)) + } + if (NMFLAG(nmp, NONEGNAMECACHE)) { NFS_BITMAP_SET(mflags, NFS_MFLAG_NONEGNAMECACHE); - if (NMFLAG(nmp, MUTEJUKEBOX)) + } + if (NMFLAG(nmp, MUTEJUKEBOX)) { NFS_BITMAP_SET(mflags, NFS_MFLAG_MUTEJUKEBOX); + } +#if CONFIG_NFS4 if (nmp->nm_vers >= NFS_VER4) { - if (NMFLAG(nmp, EPHEMERAL)) + if (NMFLAG(nmp, EPHEMERAL)) { NFS_BITMAP_SET(mflags, NFS_MFLAG_EPHEMERAL); - if (NMFLAG(nmp, NOCALLBACK)) + } + if (NMFLAG(nmp, NOCALLBACK)) { NFS_BITMAP_SET(mflags, NFS_MFLAG_NOCALLBACK); - if (NMFLAG(nmp, NONAMEDATTR)) - NFS_BITMAP_SET(mflags, NFS_MFLAG_NONAMEDATTR); - if (NMFLAG(nmp, NOACL)) + } + if (NMFLAG(nmp, NAMEDATTR)) { + NFS_BITMAP_SET(mflags, NFS_MFLAG_NAMEDATTR); + } + if (NMFLAG(nmp, NOACL)) { NFS_BITMAP_SET(mflags, NFS_MFLAG_NOACL); - if (NMFLAG(nmp, ACLONLY)) + } + if (NMFLAG(nmp, ACLONLY)) { NFS_BITMAP_SET(mflags, NFS_MFLAG_ACLONLY); + } } - if (NMFLAG(nmp, NFC)) +#endif + if (NMFLAG(nmp, NFC)) { NFS_BITMAP_SET(mflags, NFS_MFLAG_NFC); + } if (NMFLAG(nmp, NOQUOTA) || ((nmp->nm_vers >= NFS_VER4) && !NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_supp_attr, NFS_FATTR_QUOTA_AVAIL_HARD) && !NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_supp_attr, NFS_FATTR_QUOTA_AVAIL_SOFT) && - !NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_supp_attr, NFS_FATTR_QUOTA_USED))) + !NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_supp_attr, NFS_FATTR_QUOTA_USED))) { NFS_BITMAP_SET(mflags, NFS_MFLAG_NOQUOTA); - if ((nmp->nm_vers < NFS_VER4) && NMFLAG(nmp, MNTUDP)) + } + if ((nmp->nm_vers < NFS_VER4) && NMFLAG(nmp, MNTUDP)) { NFS_BITMAP_SET(mflags, NFS_MFLAG_MNTUDP); - if (NMFLAG(nmp, MNTQUICK)) + } + if (NMFLAG(nmp, MNTQUICK)) { NFS_BITMAP_SET(mflags, NFS_MFLAG_MNTQUICK); + } /* assemble info buffer: */ xb_init_buffer(&xbinfo, NULL, 0); @@ -4919,8 +5984,9 @@ nfs_mountinfo_assemble(struct nfsmount *nmp, struct xdrbuf *xb) xb_add_bitmap(error, &xbinfo, miattrs, NFS_MIATTR_BITMAP_LEN); xb_add_bitmap(error, &xbinfo, miflags, NFS_MIFLAG_BITMAP_LEN); xb_add_32(error, &xbinfo, origargslength); - if (!error) + if (!error) { error = xb_add_bytes(&xbinfo, nmp->nm_args, origargslength, 0); + } /* the opaque byte count for the current mount args values: */ curargsopaquelength_offset = xb_offset(&xbinfo); @@ -4936,77 +6002,128 @@ nfs_mountinfo_assemble(struct nfsmount *nmp, struct xdrbuf *xb) xb_add_32(error, &xbinfo, 0); xb_add_bitmap(error, &xbinfo, mflags_mask, NFS_MFLAG_BITMAP_LEN); xb_add_bitmap(error, &xbinfo, mflags, NFS_MFLAG_BITMAP_LEN); - xb_add_32(error, &xbinfo, nmp->nm_vers); /* NFS_VERSION */ - if (nmp->nm_vers >= NFS_VER4) - xb_add_32(error, &xbinfo, 0); /* NFS_MINOR_VERSION */ - xb_add_32(error, &xbinfo, nmp->nm_rsize); /* READ_SIZE */ - xb_add_32(error, &xbinfo, nmp->nm_wsize); /* WRITE_SIZE */ - xb_add_32(error, &xbinfo, nmp->nm_readdirsize); /* READDIR_SIZE */ - xb_add_32(error, &xbinfo, nmp->nm_readahead); /* READAHEAD */ - xb_add_32(error, &xbinfo, nmp->nm_acregmin); /* ATTRCACHE_REG_MIN */ - xb_add_32(error, &xbinfo, 0); /* ATTRCACHE_REG_MIN */ - xb_add_32(error, &xbinfo, nmp->nm_acregmax); /* ATTRCACHE_REG_MAX */ - xb_add_32(error, &xbinfo, 0); /* ATTRCACHE_REG_MAX */ - xb_add_32(error, &xbinfo, nmp->nm_acdirmin); /* ATTRCACHE_DIR_MIN */ - xb_add_32(error, &xbinfo, 0); /* ATTRCACHE_DIR_MIN */ - xb_add_32(error, &xbinfo, nmp->nm_acdirmax); /* ATTRCACHE_DIR_MAX */ - xb_add_32(error, &xbinfo, 0); /* ATTRCACHE_DIR_MAX */ - xb_add_32(error, &xbinfo, nmp->nm_lockmode); /* LOCK_MODE */ + xb_add_32(error, &xbinfo, nmp->nm_vers); /* NFS_VERSION */ +#if CONFIG_NFS4 + if (nmp->nm_vers >= NFS_VER4) { + xb_add_32(error, &xbinfo, nmp->nm_minor_vers); /* NFS_MINOR_VERSION */ + } +#endif + xb_add_32(error, &xbinfo, nmp->nm_rsize); /* READ_SIZE */ + xb_add_32(error, &xbinfo, nmp->nm_wsize); /* WRITE_SIZE */ + xb_add_32(error, &xbinfo, nmp->nm_readdirsize); /* READDIR_SIZE */ + xb_add_32(error, &xbinfo, nmp->nm_readahead); /* READAHEAD */ + xb_add_32(error, &xbinfo, nmp->nm_acregmin); /* ATTRCACHE_REG_MIN */ + xb_add_32(error, &xbinfo, 0); /* ATTRCACHE_REG_MIN */ + xb_add_32(error, &xbinfo, nmp->nm_acregmax); /* ATTRCACHE_REG_MAX */ + xb_add_32(error, &xbinfo, 0); /* ATTRCACHE_REG_MAX */ + xb_add_32(error, &xbinfo, nmp->nm_acdirmin); /* ATTRCACHE_DIR_MIN */ + xb_add_32(error, &xbinfo, 0); /* ATTRCACHE_DIR_MIN */ + xb_add_32(error, &xbinfo, nmp->nm_acdirmax); /* ATTRCACHE_DIR_MAX */ + xb_add_32(error, &xbinfo, 0); /* ATTRCACHE_DIR_MAX */ + xb_add_32(error, &xbinfo, nmp->nm_lockmode); /* LOCK_MODE */ if (nmp->nm_sec.count) { - xb_add_32(error, &xbinfo, nmp->nm_sec.count); /* SECURITY */ + xb_add_32(error, &xbinfo, nmp->nm_sec.count); /* SECURITY */ nfsmerr_if(error); - for (i=0; i < nmp->nm_sec.count; i++) + for (i = 0; i < nmp->nm_sec.count; i++) { xb_add_32(error, &xbinfo, nmp->nm_sec.flavors[i]); + } } else if (nmp->nm_servsec.count) { - xb_add_32(error, &xbinfo, nmp->nm_servsec.count); /* SECURITY */ + xb_add_32(error, &xbinfo, nmp->nm_servsec.count); /* SECURITY */ nfsmerr_if(error); - for (i=0; i < nmp->nm_servsec.count; i++) + for (i = 0; i < nmp->nm_servsec.count; i++) { xb_add_32(error, &xbinfo, nmp->nm_servsec.flavors[i]); + } } else { - xb_add_32(error, &xbinfo, 1); /* SECURITY */ + xb_add_32(error, &xbinfo, 1); /* SECURITY */ xb_add_32(error, &xbinfo, nmp->nm_auth); } - xb_add_32(error, &xbinfo, nmp->nm_numgrps); /* MAX_GROUP_LIST */ + if (nmp->nm_etype.selected < nmp->nm_etype.count) { + xb_add_32(error, &xbinfo, nmp->nm_etype.count); + xb_add_32(error, &xbinfo, nmp->nm_etype.selected); + for (uint32_t j = 0; j < nmp->nm_etype.count; j++) { + xb_add_32(error, &xbinfo, nmp->nm_etype.etypes[j]); + } + nfsmerr_if(error); + } + xb_add_32(error, &xbinfo, nmp->nm_numgrps); /* MAX_GROUP_LIST */ nfsmerr_if(error); - snprintf(sotype, sizeof(sotype), "%s%s", (nmp->nm_sotype == SOCK_DGRAM) ? "udp" : "tcp", - nmp->nm_sofamily ? (nmp->nm_sofamily == AF_INET) ? "4" : "6" : ""); - xb_add_string(error, &xbinfo, sotype, strlen(sotype)); /* SOCKET_TYPE */ - xb_add_32(error, &xbinfo, ntohs(((struct sockaddr_in*)nmp->nm_saddr)->sin_port)); /* NFS_PORT */ - if ((nmp->nm_vers < NFS_VER4) && nmp->nm_mountport) - xb_add_32(error, &xbinfo, nmp->nm_mountport); /* MOUNT_PORT */ + + switch (nmp->nm_saddr->sa_family) { + case AF_INET: + case AF_INET6: + snprintf(sotype, sizeof(sotype), "%s%s", (nmp->nm_sotype == SOCK_DGRAM) ? "udp" : "tcp", + nmp->nm_sofamily ? (nmp->nm_sofamily == AF_INET) ? "4" : "6" : ""); + xb_add_string(error, &xbinfo, sotype, strlen(sotype)); /* SOCKET_TYPE */ + xb_add_32(error, &xbinfo, ntohs(((struct sockaddr_in*)nmp->nm_saddr)->sin_port)); /* NFS_PORT */ + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MOUNT_PORT)) { + xb_add_32(error, &xbinfo, nmp->nm_mountport); /* MOUNT_PORT */ + } + break; + case AF_LOCAL: + strlcpy(sotype, (nmp->nm_sotype == SOCK_DGRAM) ? "ticlts" : "ticotsord", sizeof(sotype)); + xb_add_string(error, &xbinfo, sotype, strlen(sotype)); + break; + default: + NFS_VFS_DBG("Unsupported address family %d\n", nmp->nm_saddr->sa_family); + printf("Unsupported address family %d\n", nmp->nm_saddr->sa_family); + error = EINVAL; + break; + } + timeo = (nmp->nm_timeo * 10) / NFS_HZ; - xb_add_32(error, &xbinfo, timeo/10); /* REQUEST_TIMEOUT */ - xb_add_32(error, &xbinfo, (timeo%10)*100000000); /* REQUEST_TIMEOUT */ - if (NMFLAG(nmp, SOFT)) - xb_add_32(error, &xbinfo, nmp->nm_retry); /* SOFT_RETRY_COUNT */ + xb_add_32(error, &xbinfo, timeo / 10); /* REQUEST_TIMEOUT */ + xb_add_32(error, &xbinfo, (timeo % 10) * 100000000); /* REQUEST_TIMEOUT */ + if (NMFLAG(nmp, SOFT)) { + xb_add_32(error, &xbinfo, nmp->nm_retry); /* SOFT_RETRY_COUNT */ + } if (nmp->nm_deadtimeout) { - xb_add_32(error, &xbinfo, nmp->nm_deadtimeout); /* DEAD_TIMEOUT */ - xb_add_32(error, &xbinfo, 0); /* DEAD_TIMEOUT */ + xb_add_32(error, &xbinfo, nmp->nm_deadtimeout); /* DEAD_TIMEOUT */ + xb_add_32(error, &xbinfo, 0); /* DEAD_TIMEOUT */ } - if (nmp->nm_fh) + if (nmp->nm_fh) { xb_add_fh(error, &xbinfo, &nmp->nm_fh->fh_data[0], nmp->nm_fh->fh_len); /* FH */ - xb_add_32(error, &xbinfo, nmp->nm_locations.nl_numlocs); /* FS_LOCATIONS */ + } + xb_add_32(error, &xbinfo, nmp->nm_locations.nl_numlocs); /* FS_LOCATIONS */ for (loc = 0; !error && (loc < nmp->nm_locations.nl_numlocs); loc++) { xb_add_32(error, &xbinfo, nmp->nm_locations.nl_locations[loc]->nl_servcount); for (serv = 0; !error && (serv < nmp->nm_locations.nl_locations[loc]->nl_servcount); serv++) { xb_add_string(error, &xbinfo, nmp->nm_locations.nl_locations[loc]->nl_servers[serv]->ns_name, - strlen(nmp->nm_locations.nl_locations[loc]->nl_servers[serv]->ns_name)); + strlen(nmp->nm_locations.nl_locations[loc]->nl_servers[serv]->ns_name)); xb_add_32(error, &xbinfo, nmp->nm_locations.nl_locations[loc]->nl_servers[serv]->ns_addrcount); - for (addr = 0; !error && (addr < nmp->nm_locations.nl_locations[loc]->nl_servers[serv]->ns_addrcount); addr++) + for (addr = 0; !error && (addr < nmp->nm_locations.nl_locations[loc]->nl_servers[serv]->ns_addrcount); addr++) { xb_add_string(error, &xbinfo, nmp->nm_locations.nl_locations[loc]->nl_servers[serv]->ns_addresses[addr], - strlen(nmp->nm_locations.nl_locations[loc]->nl_servers[serv]->ns_addresses[addr])); + strlen(nmp->nm_locations.nl_locations[loc]->nl_servers[serv]->ns_addresses[addr])); + } xb_add_32(error, &xbinfo, 0); /* empty server info */ } xb_add_32(error, &xbinfo, nmp->nm_locations.nl_locations[loc]->nl_path.np_compcount); - for (comp = 0; !error && (comp < nmp->nm_locations.nl_locations[loc]->nl_path.np_compcount); comp++) + for (comp = 0; !error && (comp < nmp->nm_locations.nl_locations[loc]->nl_path.np_compcount); comp++) { xb_add_string(error, &xbinfo, nmp->nm_locations.nl_locations[loc]->nl_path.np_components[comp], - strlen(nmp->nm_locations.nl_locations[loc]->nl_path.np_components[comp])); + strlen(nmp->nm_locations.nl_locations[loc]->nl_path.np_components[comp])); + } xb_add_32(error, &xbinfo, 0); /* empty fs location info */ } - xb_add_32(error, &xbinfo, vfs_flags(nmp->nm_mountp)); /* MNTFLAGS */ - if (origargsvers < NFS_ARGSVERSION_XDR) + xb_add_32(error, &xbinfo, vfs_flags(nmp->nm_mountp)); /* MNTFLAGS */ + if (origargsvers < NFS_ARGSVERSION_XDR) { xb_add_string(error, &xbinfo, vfs_statfs(nmp->nm_mountp)->f_mntfromname, - strlen(vfs_statfs(nmp->nm_mountp)->f_mntfromname)); /* MNTFROM */ + strlen(vfs_statfs(nmp->nm_mountp)->f_mntfromname)); /* MNTFROM */ + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_REALM)) { + xb_add_string(error, &xbinfo, nmp->nm_realm, strlen(nmp->nm_realm)); + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_PRINCIPAL)) { + xb_add_string(error, &xbinfo, nmp->nm_principal, strlen(nmp->nm_principal)); + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_SVCPRINCIPAL)) { + xb_add_string(error, &xbinfo, nmp->nm_sprinc, strlen(nmp->nm_sprinc)); + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_LOCAL_NFS_PORT)) { + struct sockaddr_un *un = (struct sockaddr_un *)nmp->nm_saddr; + xb_add_string(error, &xbinfo, un->sun_path, strlen(un->sun_path)); + } + if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_LOCAL_MOUNT_PORT)) { + xb_add_string(error, &xbinfo, nmp->nm_mount_localport, strlen(nmp->nm_mount_localport)); + } curargs_end_offset = xb_offset(&xbinfo); /* NFS_MIATTR_CUR_LOC_INDEX */ @@ -5021,19 +6138,19 @@ nfs_mountinfo_assemble(struct nfsmount *nmp, struct xdrbuf *xb) end_offset = xb_offset(&xbinfo); if (!error) { error = xb_seek(&xbinfo, attrslength_offset); - xb_add_32(error, &xbinfo, curargs_end_offset - attrslength_offset - XDRWORD/*don't include length field*/); + xb_add_32(error, &xbinfo, curargs_end_offset - attrslength_offset - XDRWORD /*don't include length field*/); } if (!error) { error = xb_seek(&xbinfo, curargslength_offset); - xb_add_32(error, &xbinfo, curargs_end_offset - curargslength_offset + XDRWORD/*version*/); + xb_add_32(error, &xbinfo, curargs_end_offset - curargslength_offset + XDRWORD /*version*/); } if (!error) { error = xb_seek(&xbinfo, curargsopaquelength_offset); - xb_add_32(error, &xbinfo, curargs_end_offset - curargslength_offset + XDRWORD/*version*/); + xb_add_32(error, &xbinfo, curargs_end_offset - curargslength_offset + XDRWORD /*version*/); } if (!error) { error = xb_seek(&xbinfo, infolength_offset); - xb_add_32(error, &xbinfo, end_offset - infolength_offset + XDRWORD/*version*/); + xb_add_32(error, &xbinfo, end_offset - infolength_offset + XDRWORD /*version*/); } nfsmerr_if(error); @@ -5044,7 +6161,7 @@ nfs_mountinfo_assemble(struct nfsmount *nmp, struct xdrbuf *xb) xbinfo.xb_flags &= ~XB_CLEANUP; nfsmerr: xb_cleanup(&xbinfo); - return (error); + return error; } /* @@ -5052,54 +6169,71 @@ nfsmerr: */ int nfs_vfs_sysctl(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp, - user_addr_t newp, size_t newlen, vfs_context_t ctx) + user_addr_t newp, size_t newlen, vfs_context_t ctx) { - int error = 0, val, softnobrowse; + int error = 0, val; +#ifndef CONFIG_EMBEDDED + int softnobrowse; +#endif struct sysctl_req *req = NULL; union union_vfsidctl vc; mount_t mp; struct nfsmount *nmp = NULL; struct vfsquery vq; + struct nfsreq *rq; boolean_t is_64_bit; fsid_t fsid; struct xdrbuf xb; -#if NFSSERVER + struct netfs_status *nsp = NULL; + int timeoutmask; + uint totlen, count, numThreads; +#if CONFIG_NFS_SERVER + uint pos; struct nfs_exportfs *nxfs; struct nfs_export *nx; struct nfs_active_user_list *ulist; - struct nfs_export_stat_desc stat_desc; + struct nfs_export_stat_desc stat_desc = {}; struct nfs_export_stat_rec statrec; struct nfs_user_stat_node *unode, *unode_next; - struct nfs_user_stat_desc ustat_desc; + struct nfs_user_stat_desc ustat_desc = {}; struct nfs_user_stat_user_rec ustat_rec; struct nfs_user_stat_path_rec upath_rec; uint bytes_avail, bytes_total, recs_copied; - uint numExports, totlen, pos, numRecs, count; -#endif /* NFSSERVER */ + uint numExports, numRecs; +#endif /* CONFIG_NFS_SERVER */ /* * All names at this level are terminal. */ - if (namelen > 1) - return (ENOTDIR); /* overloaded */ - + if (namelen > 1) { + return ENOTDIR; /* overloaded */ + } is_64_bit = vfs_context_is64bit(ctx); /* common code for "new style" VFS_CTL sysctl, get the mount. */ switch (name[0]) { case VFS_CTL_TIMEO: - case VFS_CTL_QUERY: case VFS_CTL_NOLOCKS: + case VFS_CTL_NSTATUS: +#ifndef CONFIG_EMBEDDED + case VFS_CTL_QUERY: +#endif req = CAST_DOWN(struct sysctl_req *, oldp); + if (req == NULL) { + return EFAULT; + } error = SYSCTL_IN(req, &vc, is_64_bit? sizeof(vc.vc64):sizeof(vc.vc32)); - if (error) - return (error); + if (error) { + return error; + } mp = vfs_getvfs(&vc.vc32.vc_fsid); /* works for 32 and 64 */ - if (mp == NULL) - return (ENOENT); + if (mp == NULL) { + return ENOENT; + } nmp = VFSTONFS(mp); - if (nmp == NULL) - return (ENOENT); + if (!nmp) { + return ENOENT; + } bzero(&vq, sizeof(vq)); req->newidx = 0; if (is_64_bit) { @@ -5109,75 +6243,91 @@ nfs_vfs_sysctl(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp, req->newptr = CAST_USER_ADDR_T(vc.vc32.vc_ptr); req->newlen = vc.vc32.vc_len; } + break; +#if CONFIG_EMBEDDED + case VFS_CTL_QUERY: + return EPERM; +#endif } - switch(name[0]) { + switch (name[0]) { case NFS_NFSSTATS: if (!oldp) { *oldlenp = sizeof nfsstats; - return (0); + return 0; } if (*oldlenp < sizeof nfsstats) { *oldlenp = sizeof nfsstats; - return (ENOMEM); + return ENOMEM; } error = copyout(&nfsstats, oldp, sizeof nfsstats); - if (error) - return (error); + if (error) { + return error; + } - if (newp && newlen != sizeof nfsstats) - return (EINVAL); + if (newp && newlen != sizeof nfsstats) { + return EINVAL; + } - if (newp) + if (newp) { return copyin(newp, &nfsstats, sizeof nfsstats); - return (0); + } + return 0; case NFS_MOUNTINFO: /* read in the fsid */ - if (*oldlenp < sizeof(fsid)) - return (EINVAL); - if ((error = copyin(oldp, &fsid, sizeof(fsid)))) - return (error); + if (*oldlenp < sizeof(fsid)) { + return EINVAL; + } + if ((error = copyin(oldp, &fsid, sizeof(fsid)))) { + return error; + } /* swizzle it back to host order */ fsid.val[0] = ntohl(fsid.val[0]); fsid.val[1] = ntohl(fsid.val[1]); /* find mount and make sure it's NFS */ - if (((mp = vfs_getvfs(&fsid))) == NULL) - return (ENOENT); - if (strcmp(mp->mnt_vfsstat.f_fstypename, "nfs")) - return (EINVAL); - if (((nmp = VFSTONFS(mp))) == NULL) - return (ENOENT); - xb_init(&xb, 0); - if ((error = nfs_mountinfo_assemble(nmp, &xb))) - return (error); - if (*oldlenp < xb.xb_u.xb_buffer.xbb_len) + if (((mp = vfs_getvfs(&fsid))) == NULL) { + return ENOENT; + } + if (strcmp(mp->mnt_vfsstat.f_fstypename, "nfs")) { + return EINVAL; + } + if (((nmp = VFSTONFS(mp))) == NULL) { + return ENOENT; + } + xb_init(&xb, XDRBUF_NONE); + if ((error = nfs_mountinfo_assemble(nmp, &xb))) { + return error; + } + if (*oldlenp < xb.xb_u.xb_buffer.xbb_len) { error = ENOMEM; - else + } else { error = copyout(xb_buffer_base(&xb), oldp, xb.xb_u.xb_buffer.xbb_len); + } *oldlenp = xb.xb_u.xb_buffer.xbb_len; xb_cleanup(&xb); break; -#if NFSSERVER +#if CONFIG_NFS_SERVER case NFS_EXPORTSTATS: /* setup export stat descriptor */ stat_desc.rec_vers = NFS_EXPORT_STAT_REC_VERSION; if (!nfsrv_is_initialized()) { stat_desc.rec_count = 0; - if (oldp && (*oldlenp >= sizeof(struct nfs_export_stat_desc))) + if (oldp && (*oldlenp >= sizeof(struct nfs_export_stat_desc))) { error = copyout(&stat_desc, oldp, sizeof(struct nfs_export_stat_desc)); + } *oldlenp = sizeof(struct nfs_export_stat_desc); - return (error); + return error; } /* Count the number of exported directories */ lck_rw_lock_shared(&nfsrv_export_rwlock); numExports = 0; LIST_FOREACH(nxfs, &nfsrv_exports, nxfs_next) - LIST_FOREACH(nx, &nxfs->nxfs_exports, nx_next) - numExports += 1; + LIST_FOREACH(nx, &nxfs->nxfs_exports, nx_next) + numExports += 1; /* update stat descriptor's export record count */ stat_desc.rec_count = numExports; @@ -5190,7 +6340,7 @@ nfs_vfs_sysctl(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp, lck_rw_done(&nfsrv_export_rwlock); /* indicate required buffer len */ *oldlenp = totlen; - return (0); + return 0; } /* We require the caller's buffer to be at least large enough to hold the descriptor */ @@ -5198,7 +6348,7 @@ nfs_vfs_sysctl(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp, lck_rw_done(&nfsrv_export_rwlock); /* indicate required buffer len */ *oldlenp = totlen; - return (ENOMEM); + return ENOMEM; } /* indicate required buffer len */ @@ -5208,7 +6358,7 @@ nfs_vfs_sysctl(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp, if (!numExports) { lck_rw_done(&nfsrv_export_rwlock); error = copyout(&stat_desc, oldp, sizeof(struct nfs_export_stat_desc)); - return (error); + return error; } /* calculate how many actual export stat records fit into caller's buffer */ @@ -5219,12 +6369,13 @@ nfs_vfs_sysctl(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp, lck_rw_done(&nfsrv_export_rwlock); stat_desc.rec_count = 0; error = copyout(&stat_desc, oldp, sizeof(struct nfs_export_stat_desc)); - return (error); + return error; } /* adjust to actual number of records to copyout to caller's buffer */ - if (numRecs > numExports) + if (numRecs > numExports) { numRecs = numExports; + } /* set actual number of records we are returning */ stat_desc.rec_count = numRecs; @@ -5234,7 +6385,7 @@ nfs_vfs_sysctl(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp, error = copyout(&stat_desc, oldp + pos, sizeof(struct nfs_export_stat_desc)); if (error) { lck_rw_done(&nfsrv_export_rwlock); - return (error); + return error; } pos += sizeof(struct nfs_export_stat_desc); @@ -5242,26 +6393,27 @@ nfs_vfs_sysctl(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp, count = 0; LIST_FOREACH(nxfs, &nfsrv_exports, nxfs_next) { LIST_FOREACH(nx, &nxfs->nxfs_exports, nx_next) { - - if (count >= numRecs) + if (count >= numRecs) { break; + } /* build exported filesystem path */ + memset(statrec.path, 0, sizeof(statrec.path)); snprintf(statrec.path, sizeof(statrec.path), "%s%s%s", - nxfs->nxfs_path, ((nxfs->nxfs_path[1] && nx->nx_path[0]) ? "/" : ""), - nx->nx_path); + nxfs->nxfs_path, ((nxfs->nxfs_path[1] && nx->nx_path[0]) ? "/" : ""), + nx->nx_path); /* build the 64-bit export stat counters */ statrec.ops = ((uint64_t)nx->nx_stats.ops.hi << 32) | - nx->nx_stats.ops.lo; + nx->nx_stats.ops.lo; statrec.bytes_read = ((uint64_t)nx->nx_stats.bytes_read.hi << 32) | - nx->nx_stats.bytes_read.lo; + nx->nx_stats.bytes_read.lo; statrec.bytes_written = ((uint64_t)nx->nx_stats.bytes_written.hi << 32) | - nx->nx_stats.bytes_written.lo; + nx->nx_stats.bytes_written.lo; error = copyout(&statrec, oldp + pos, sizeof(statrec)); if (error) { lck_rw_done(&nfsrv_export_rwlock); - return (error); + return error; } /* advance buffer position */ pos += sizeof(statrec); @@ -5280,17 +6432,19 @@ nfs_vfs_sysctl(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp, bytes_avail = *oldlenp; recs_copied = 0; - if (!nfsrv_is_initialized()) /* NFS server not initialized, so no stats */ + if (!nfsrv_is_initialized()) { /* NFS server not initialized, so no stats */ goto ustat_skip; + } /* reclaim old expired user nodes */ nfsrv_active_user_list_reclaim(); /* reserve space for the buffer descriptor */ - if (bytes_avail >= sizeof(struct nfs_user_stat_desc)) + if (bytes_avail >= sizeof(struct nfs_user_stat_desc)) { bytes_avail -= sizeof(struct nfs_user_stat_desc); - else + } else { bytes_avail = 0; + } /* put buffer position past the buffer descriptor */ pos = sizeof(struct nfs_user_stat_desc); @@ -5301,6 +6455,7 @@ nfs_vfs_sysctl(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp, LIST_FOREACH(nx, &nxfs->nxfs_exports, nx_next) { /* copy out path */ if (bytes_avail >= sizeof(struct nfs_user_stat_path_rec)) { + memset(upath_rec.path, 0, sizeof(upath_rec.path)); snprintf(upath_rec.path, sizeof(upath_rec.path), "%s%s%s", nxfs->nxfs_path, ((nxfs->nxfs_path[1] && nx->nx_path[0]) ? "/" : ""), nx->nx_path); @@ -5314,8 +6469,7 @@ nfs_vfs_sysctl(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp, pos += sizeof(struct nfs_user_stat_path_rec); bytes_avail -= sizeof(struct nfs_user_stat_path_rec); recs_copied++; - } - else { + } else { /* Caller's buffer is exhausted */ bytes_avail = 0; } @@ -5332,6 +6486,7 @@ nfs_vfs_sysctl(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp, if (bytes_avail >= sizeof(struct nfs_user_stat_user_rec)) { /* prepare a user stat rec for copying out */ ustat_rec.uid = unode->uid; + memset(&ustat_rec.sock, 0, sizeof(ustat_rec.sock)); bcopy(&unode->sock, &ustat_rec.sock, unode->sock.ss_len); ustat_rec.ops = unode->ops; ustat_rec.bytes_read = unode->bytes_read; @@ -5350,8 +6505,7 @@ nfs_vfs_sysctl(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp, pos += sizeof(struct nfs_user_stat_user_rec); bytes_avail -= sizeof(struct nfs_user_stat_user_rec); recs_copied++; - } - else { + } else { /* Caller's buffer is exhausted */ bytes_avail = 0; } @@ -5372,10 +6526,11 @@ ustat_skip: if (!error) { /* check if there was enough room for the buffer descriptor */ - if (*oldlenp >= sizeof(struct nfs_user_stat_desc)) + if (*oldlenp >= sizeof(struct nfs_user_stat_desc)) { error = copyout(&ustat_desc, oldp, sizeof(struct nfs_user_stat_desc)); - else + } else { error = ENOMEM; + } /* always indicate required buffer size */ *oldlenp = bytes_total; @@ -5384,12 +6539,12 @@ ustat_skip: case NFS_USERCOUNT: if (!oldp) { *oldlenp = sizeof(nfsrv_user_stat_node_count); - return (0); + return 0; } if (*oldlenp < sizeof(nfsrv_user_stat_node_count)) { *oldlenp = sizeof(nfsrv_user_stat_node_count); - return (ENOMEM); + return ENOMEM; } if (nfsrv_is_initialized()) { @@ -5399,79 +6554,183 @@ ustat_skip: error = copyout(&nfsrv_user_stat_node_count, oldp, sizeof(nfsrv_user_stat_node_count)); break; -#endif /* NFSSERVER */ +#endif /* CONFIG_NFS_SERVER */ case VFS_CTL_NOLOCKS: - if (req->oldptr != USER_ADDR_NULL) { + if (req->oldptr != USER_ADDR_NULL) { lck_mtx_lock(&nmp->nm_lock); val = (nmp->nm_lockmode == NFS_LOCK_MODE_DISABLED) ? 1 : 0; lck_mtx_unlock(&nmp->nm_lock); - error = SYSCTL_OUT(req, &val, sizeof(val)); - if (error) - return (error); - } - if (req->newptr != USER_ADDR_NULL) { - error = SYSCTL_IN(req, &val, sizeof(val)); - if (error) - return (error); + error = SYSCTL_OUT(req, &val, sizeof(val)); + if (error) { + return error; + } + } + if (req->newptr != USER_ADDR_NULL) { + error = SYSCTL_IN(req, &val, sizeof(val)); + if (error) { + return error; + } lck_mtx_lock(&nmp->nm_lock); if (nmp->nm_lockmode == NFS_LOCK_MODE_LOCAL) { /* can't toggle locks when using local locks */ error = EINVAL; +#if CONFIG_NFS4 } else if ((nmp->nm_vers >= NFS_VER4) && val) { /* can't disable locks for NFSv4 */ error = EINVAL; +#endif } else if (val) { - if ((nmp->nm_vers <= NFS_VER3) && (nmp->nm_lockmode == NFS_LOCK_MODE_ENABLED)) + if ((nmp->nm_vers <= NFS_VER3) && (nmp->nm_lockmode == NFS_LOCK_MODE_ENABLED)) { nfs_lockd_mount_unregister(nmp); + } nmp->nm_lockmode = NFS_LOCK_MODE_DISABLED; nmp->nm_state &= ~NFSSTA_LOCKTIMEO; } else { - if ((nmp->nm_vers <= NFS_VER3) && (nmp->nm_lockmode == NFS_LOCK_MODE_DISABLED)) + if ((nmp->nm_vers <= NFS_VER3) && (nmp->nm_lockmode == NFS_LOCK_MODE_DISABLED)) { nfs_lockd_mount_register(nmp); + } nmp->nm_lockmode = NFS_LOCK_MODE_ENABLED; } lck_mtx_unlock(&nmp->nm_lock); - } + } break; +#ifndef CONFIG_EMBEDDED case VFS_CTL_QUERY: lck_mtx_lock(&nmp->nm_lock); /* XXX don't allow users to know about/disconnect unresponsive, soft, nobrowse mounts */ softnobrowse = (NMFLAG(nmp, SOFT) && (vfs_flags(nmp->nm_mountp) & MNT_DONTBROWSE)); - if (!softnobrowse && (nmp->nm_state & NFSSTA_TIMEO)) + if (!softnobrowse && (nmp->nm_state & NFSSTA_TIMEO)) { vq.vq_flags |= VQ_NOTRESP; - if (!softnobrowse && (nmp->nm_state & NFSSTA_JUKEBOXTIMEO) && !NMFLAG(nmp, MUTEJUKEBOX)) + } + if (!softnobrowse && (nmp->nm_state & NFSSTA_JUKEBOXTIMEO) && !NMFLAG(nmp, MUTEJUKEBOX)) { vq.vq_flags |= VQ_NOTRESP; + } if (!softnobrowse && (nmp->nm_state & NFSSTA_LOCKTIMEO) && - (nmp->nm_lockmode == NFS_LOCK_MODE_ENABLED)) + (nmp->nm_lockmode == NFS_LOCK_MODE_ENABLED)) { vq.vq_flags |= VQ_NOTRESP; - if (nmp->nm_state & NFSSTA_DEAD) + } + if (nmp->nm_state & NFSSTA_DEAD) { vq.vq_flags |= VQ_DEAD; + } lck_mtx_unlock(&nmp->nm_lock); error = SYSCTL_OUT(req, &vq, sizeof(vq)); break; - case VFS_CTL_TIMEO: - if (req->oldptr != USER_ADDR_NULL) { +#endif + case VFS_CTL_TIMEO: + if (req->oldptr != USER_ADDR_NULL) { lck_mtx_lock(&nmp->nm_lock); val = nmp->nm_tprintf_initial_delay; lck_mtx_unlock(&nmp->nm_lock); - error = SYSCTL_OUT(req, &val, sizeof(val)); - if (error) - return (error); - } - if (req->newptr != USER_ADDR_NULL) { - error = SYSCTL_IN(req, &val, sizeof(val)); - if (error) - return (error); + error = SYSCTL_OUT(req, &val, sizeof(val)); + if (error) { + return error; + } + } + if (req->newptr != USER_ADDR_NULL) { + error = SYSCTL_IN(req, &val, sizeof(val)); + if (error) { + return error; + } lck_mtx_lock(&nmp->nm_lock); - if (val < 0) - nmp->nm_tprintf_initial_delay = 0; - else + if (val < 0) { + nmp->nm_tprintf_initial_delay = 0; + } else { nmp->nm_tprintf_initial_delay = val; + } lck_mtx_unlock(&nmp->nm_lock); - } + } + break; + case VFS_CTL_NSTATUS: + /* + * Return the status of this mount. This is much more + * information than VFS_CTL_QUERY. In addition to the + * vq_flags return the significant mount options along + * with the list of threads blocked on the mount and + * how long the threads have been waiting. + */ + + lck_mtx_lock(nfs_request_mutex); + lck_mtx_lock(&nmp->nm_lock); + + /* + * Count the number of requests waiting for a reply. + * Note: there could be multiple requests from the same thread. + */ + numThreads = 0; + TAILQ_FOREACH(rq, &nfs_reqq, r_chain) { + if (rq->r_nmp == nmp) { + numThreads++; + } + } + + /* Calculate total size of result buffer */ + totlen = sizeof(struct netfs_status) + (numThreads * sizeof(uint64_t)); + + if (req->oldptr == USER_ADDR_NULL) { // Caller is querying buffer size + lck_mtx_unlock(&nmp->nm_lock); + lck_mtx_unlock(nfs_request_mutex); + return SYSCTL_OUT(req, NULL, totlen); + } + if (req->oldlen < totlen) { // Check if caller's buffer is big enough + lck_mtx_unlock(&nmp->nm_lock); + lck_mtx_unlock(nfs_request_mutex); + return ERANGE; + } + + MALLOC(nsp, struct netfs_status *, totlen, M_TEMP, M_WAITOK | M_ZERO); + if (nsp == NULL) { + lck_mtx_unlock(&nmp->nm_lock); + lck_mtx_unlock(nfs_request_mutex); + return ENOMEM; + } + timeoutmask = NFSSTA_TIMEO | NFSSTA_LOCKTIMEO | NFSSTA_JUKEBOXTIMEO; + if (nmp->nm_state & timeoutmask) { + nsp->ns_status |= VQ_NOTRESP; + } + if (nmp->nm_state & NFSSTA_DEAD) { + nsp->ns_status |= VQ_DEAD; + } + + (void) nfs_mountopts(nmp, nsp->ns_mountopts, sizeof(nsp->ns_mountopts)); + nsp->ns_threadcount = numThreads; + + /* + * Get the thread ids of threads waiting for a reply + * and find the longest wait time. + */ + if (numThreads > 0) { + struct timeval now; + time_t sendtime; + + microuptime(&now); + count = 0; + sendtime = now.tv_sec; + TAILQ_FOREACH(rq, &nfs_reqq, r_chain) { + if (rq->r_nmp == nmp) { + if (rq->r_start < sendtime) { + sendtime = rq->r_start; + } + // A thread_id of zero is used to represent an async I/O request. + nsp->ns_threadids[count] = + rq->r_thread ? thread_tid(rq->r_thread) : 0; + if (++count >= numThreads) { + break; + } + } + } + nsp->ns_waittime = now.tv_sec - sendtime; + } + + lck_mtx_unlock(&nmp->nm_lock); + lck_mtx_unlock(nfs_request_mutex); + + error = SYSCTL_OUT(req, nsp, totlen); + FREE(nsp, M_TEMP); break; default: - return (ENOTSUP); + return ENOTSUP; } - return (error); + return error; } + +#endif /* CONFIG_NFS_CLIENT */