/*
* Copyright (c) 1989, 1993, 1995
* The Regents of the University of California. All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Rick Macklem at The University of Guelph.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* @(#)nfs_vfsops.c 8.12 (Berkeley) 5/20/95
*/
/*
* Mount a remote root fs via. NFS. It goes like this:
* - Call nfs_boot_init() to fill in the nfs_diskless struct
* - build the rootfs mount point and call mountnfs() to do the rest.
*/
int
nfs_mountroot(void)
{
struct timespec ts;
struct nfs_diskless *nd;
struct vattr attr;
struct mount *mp;
struct vnode *vp;
struct lwp *l;
time_t n;
int error;
l = curlwp; /* XXX */
if (device_class(root_device) != DV_IFNET)
return (ENODEV);
/*
* XXX time must be non-zero when we init the interface or else
* the arp code will wedge. [Fixed now in if_ether.c]
* However, the NFS attribute cache gives false "hits" when the
* current time < nfs_attrtimeo(nmp, np) so keep this in for now.
*/
if (time_second < NFS_MAXATTRTIMO) {
ts.tv_sec = NFS_MAXATTRTIMO;
ts.tv_nsec = 0;
tc_setclock(&ts);
}
/*
* Call nfs_boot_init() to fill in the nfs_diskless struct.
* Side effect: Finds and configures a network interface.
*/
nd = kmem_zalloc(sizeof(*nd), KM_SLEEP);
error = nfs_boot_init(nd, l);
if (error) {
kmem_free(nd, sizeof(*nd));
return (error);
}
/*
* Create the root mount point.
*/
error = nfs_mount_diskless(&nd->nd_root, "/", &mp, &vp, l);
if (error)
goto out;
printf("root on %s\n", nd->nd_root.ndm_host);
/*
* Link it into the mount list.
*/
mountlist_append(mp);
rootvp = vp;
mp->mnt_vnodecovered = NULLVP;
vfs_unbusy(mp);
/* Get root attributes (for the time). */
vn_lock(vp, LK_SHARED | LK_RETRY);
error = VOP_GETATTR(vp, &attr, l->l_cred);
VOP_UNLOCK(vp);
if (error)
panic("nfs_mountroot: getattr for root");
n = attr.va_atime.tv_sec;
#ifdef DEBUG
printf("root time: 0x%jx\n", (intmax_t)n);
#endif
setrootfstime(n);
out:
if (error)
nfs_boot_cleanup(nd, l);
kmem_free(nd, sizeof(*nd));
return (error);
}
/*
* Internal version of mount system call for diskless setup.
* Separate function because we used to call it twice.
* (once for root and once for swap)
*/
static int
nfs_mount_diskless(struct nfs_dlmount *ndmntp, const char *mntname, struct mount **mpp, struct vnode **vpp, struct lwp *l)
/* mntname: mount point name */
{
struct mount *mp;
struct mbuf *m;
int error;
vfs_rootmountalloc(MOUNT_NFS, mntname, &mp);
mp->mnt_op = &nfs_vfsops;
/*
* Historical practice expects NFS root file systems to
* be initially mounted r/w.
*/
mp->mnt_flag &= ~MNT_RDONLY;
/* Get mbuf for server sockaddr. */
m = m_get(M_WAIT, MT_SONAME);
if (m == NULL)
panic("nfs_mountroot: mget soname for %s", mntname);
MCLAIM(m, &nfs_mowner);
memcpy(mtod(m, void *), (void *)ndmntp->ndm_args.addr,
(m->m_len = ndmntp->ndm_args.addr->sa_len));
error = mountnfs(&ndmntp->ndm_args, mp, m, mntname,
ndmntp->ndm_args.hostname, vpp, l);
if (error) {
vfs_unbusy(mp);
vfs_rele(mp);
printf("nfs_mountroot: mount %s failed: %d\n",
mntname, error);
} else
*mpp = mp;
return (error);
}
void
nfs_decode_args(struct nfsmount *nmp, struct nfs_args *argp, struct lwp *l)
{
int s;
int adjsock;
int maxio;
s = splsoftnet();
/*
* Silently clear NFSMNT_NOCONN if it's a TCP mount, it makes
* no sense in that context.
*/
if (argp->sotype == SOCK_STREAM)
argp->flags &= ~NFSMNT_NOCONN;
/*
* Cookie translation is not needed for v2, silently ignore it.
*/
if ((argp->flags & (NFSMNT_XLATECOOKIE|NFSMNT_NFSV3)) ==
NFSMNT_XLATECOOKIE)
argp->flags &= ~NFSMNT_XLATECOOKIE;
/* Re-bind if rsrvd port requested and wasn't on one */
adjsock = !(nmp->nm_flag & NFSMNT_RESVPORT)
&& (argp->flags & NFSMNT_RESVPORT);
/* Also re-bind if we're switching to/from a connected UDP socket */
adjsock |= ((nmp->nm_flag & NFSMNT_NOCONN) !=
(argp->flags & NFSMNT_NOCONN));
if (nmp->nm_so && adjsock) {
nfs_safedisconnect(nmp);
if (nmp->nm_sotype == SOCK_DGRAM)
while (nfs_connect(nmp, (struct nfsreq *)0, l)) {
printf("nfs_args: retrying connect\n");
kpause("nfscn3", false, hz, NULL);
}
}
}
/*
* VFS Operations.
*
* mount system call
* It seems a bit dumb to copyinstr() the host and path here and then
* memcpy() them in mountnfs(), but I wanted to detect errors before
* doing the sockargs() call because sockargs() allocates an mbuf and
* an error after that means that I have to release the mbuf.
*/
/* ARGSUSED */
int
nfs_mount(struct mount *mp, const char *path, void *data, size_t *data_len)
{
struct lwp *l = curlwp;
int error;
struct nfs_args *args = data;
struct mbuf *nam;
struct nfsmount *nmp = VFSTONFS(mp);
struct sockaddr *sa;
struct vnode *vp;
char *pth, *hst;
size_t len;
u_char *nfh;
if (args == NULL)
return EINVAL;
if (*data_len < sizeof *args)
return EINVAL;
if (mp->mnt_flag & MNT_GETARGS) {
if (nmp == NULL)
return (EIO);
if (args->addr != NULL) {
sa = mtod(nmp->nm_nam, struct sockaddr *);
error = copyout(sa, args->addr, sa->sa_len);
if (error)
return (error);
args->addrlen = sa->sa_len;
} else
args->addrlen = 0;
/*
* For Connection based sockets (TCP,...) defer the connect until
* the first request, in case the server is not responding.
*/
if (nmp->nm_sotype == SOCK_DGRAM &&
(error = nfs_connect(nmp, (struct nfsreq *)0, l)))
goto bad;
/*
* This is silly, but it has to be set so that vinifod() works.
* We do not want to do an nfs_statvfs() here since we can get
* stuck on a dead server and we are holding a lock on the mount
* point.
*/
mp->mnt_stat.f_iosize = NFS_MAXDGRAMDATA;
error = nfs_nget(mp, (nfsfh_t *)argp->fh, argp->fhsize, &np);
if (error)
goto bad;
vp = NFSTOV(np);
attrs = malloc(sizeof(struct vattr), M_TEMP, M_WAITOK);
VOP_GETATTR(vp, attrs, l->l_cred);
if ((nmp->nm_flag & NFSMNT_NFSV3) && (vp->v_type == VDIR)) {
cr = kauth_cred_alloc();
kauth_cred_setuid(cr, attrs->va_uid);
kauth_cred_seteuid(cr, attrs->va_uid);
kauth_cred_setsvuid(cr, attrs->va_uid);
kauth_cred_setgid(cr, attrs->va_gid);
kauth_cred_setegid(cr, attrs->va_gid);
kauth_cred_setsvgid(cr, attrs->va_gid);
nfs_cookieheuristic(vp, &nmp->nm_iflag, l, cr);
kauth_cred_free(cr);
}
free(attrs, M_TEMP);
/*
* A reference count is needed on the nfsnode representing the
* remote root. If this object is not persistent, then backward
* traversals of the mount point (i.e. "..") will not work if
* the nfsnode gets flushed out of the cache. Ufs does not have
* this problem, because one can identify root inodes by their
* number == UFS_ROOTINO (2). So, just unlock, but no rele.
*/
/*
* Goes something like this..
* - Check for activity on the root vnode (other than ourselves).
* - Call vflush() to clear out vnodes for this file system,
* except for the root vnode.
* - Decrement reference on the vnode representing remote root.
* - Close the socket
* - Free up the data structures
*/
/*
* We need to decrement the ref. count on the nfsnode representing
* the remote root. See comment in mountnfs().
*/
vp = nmp->nm_vnode;
error = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
if (error != 0)
goto err;
/*
* We are now committed to the unmount; mark the mount structure
* as doomed so that any sleepers kicked awake by nfs_disconnect
* will go away cleanly.
*/
nmp->nm_iflag |= NFSMNT_DISMNT;
/*
* No new async I/O will be added, but await for pending
* ones to drain.
*/
while (nfs_iodbusy(nmp))
kpause("nfsumnt", false, hz, NULL);
/*
* Clean up the stats... note that we carefully avoid decrementing
* nfs_mount_count here for good reason - we may not be unmounting
* the last thing mounted.
*/
iostat_free(nmp->nm_stats);
/*
* There is one reference count to get rid of here
* (see comment in mountnfs()).
*/
VOP_UNLOCK(vp);
vgone(vp);
nfs_disconnect(nmp);
m_freem(nmp->nm_nam);
/*
* Return root of a filesystem
*/
int
nfs_root(struct mount *mp, int lktype, struct vnode **vpp)
{
struct vnode *vp;
struct nfsmount *nmp;
int error;
/*
* Flush out the buffer cache
*/
/* ARGSUSED */
int
nfs_sync(struct mount *mp, int waitfor, kauth_cred_t cred)
{
struct vnode *vp;
struct vnode_iterator *marker;
int error, allerror = 0;
/*
* Force stale buffer cache information to be flushed.
*/
vfs_vnode_iterator_init(mp, &marker);
while ((vp = vfs_vnode_iterator_next(marker, nfs_sync_selector,
NULL)))
{
error = vn_lock(vp, LK_EXCLUSIVE);
if (error) {
vrele(vp);
continue;
}
error = VOP_FSYNC(vp, cred,
waitfor == MNT_WAIT ? FSYNC_WAIT : 0, 0, 0);
if (error)
allerror = error;
vput(vp);
}
vfs_vnode_iterator_destroy(marker);
return allerror;
}
/*
* NFS flat namespace lookup.
* Currently unsupported.
*/
/* ARGSUSED */
int
nfs_vget(struct mount *mp, ino_t ino, int lktype, struct vnode **vpp)
{
return (EOPNOTSUPP);
}
/*
* Do that sysctl thang...
*/
static int
sysctl_vfs_nfs_iothreads(SYSCTLFN_ARGS)
{
struct sysctlnode node;
int val;
int error;
val = nfs_niothreads;
node = *rnode;
node.sysctl_data = &val;
error = sysctl_lookup(SYSCTLFN_CALL(&node));
if (error || newp == NULL)
return error;
return nfs_set_niothreads(val);
}
SYSCTL_SETUP(nfs_sysctl_init, "nfs sysctl")
{
sysctl_createv(clog, 0, NULL, NULL,
CTLFLAG_PERMANENT,
CTLTYPE_NODE, "nfs",
SYSCTL_DESCR("NFS vfs options"),
NULL, 0, NULL, 0,
CTL_VFS, 2, CTL_EOL);
/*
* XXX the "2" above could be dynamic, thereby eliminating one
* more instance of the "number to vfs" mapping problem, but
* "2" is the order as taken from sys/mount.h
*/
