X-Git-Url: https://git.subgeniuskitty.com/unix-history/.git/blobdiff_plain/4f76a9f0c03b4b1c5e8c99bb38f8a4e2c5279416..5548a02fb5c1a0399f9e8d8d90b4a0370bea6070:/usr/src/sys/nfs/nfs_vfsops.c diff --git a/usr/src/sys/nfs/nfs_vfsops.c b/usr/src/sys/nfs/nfs_vfsops.c index 5d22b04307..351486fb25 100644 --- a/usr/src/sys/nfs/nfs_vfsops.c +++ b/usr/src/sys/nfs/nfs_vfsops.c @@ -7,33 +7,36 @@ * * %sccs.include.redist.c% * - * @(#)nfs_vfsops.c 7.30 (Berkeley) %G% + * @(#)nfs_vfsops.c 7.48 (Berkeley) %G% */ -#include "param.h" -#include "conf.h" -#include "ioctl.h" -#include "signal.h" -#include "proc.h" -#include "namei.h" -#include "vnode.h" -#include "mount.h" -#include "buf.h" -#include "mbuf.h" -#include "socket.h" -#include "systm.h" - -#include "../net/if.h" -#include "../net/route.h" -#include "../netinet/in.h" - -#include "nfsv2.h" -#include "nfsnode.h" -#include "nfsmount.h" -#include "nfs.h" -#include "xdr_subs.h" -#include "nfsm_subs.h" -#include "nfsdiskless.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include /* * nfs vfs operations. @@ -46,16 +49,26 @@ struct vfsops nfs_vfsops = { nfs_quotactl, nfs_statfs, nfs_sync, + nfs_vget, nfs_fhtovp, nfs_vptofh, nfs_init, }; +/* + * This structure must be filled in by a primary bootstrap or bootstrap + * server for a diskless/dataless machine. It is initialized below just + * to ensure that it is allocated to initialized data (.data not .bss). + */ +struct nfs_diskless nfs_diskless = { 0 }; + static u_char nfs_mntid; extern u_long nfs_procids[NFS_NPROCS]; extern u_long nfs_prog, nfs_vers; -struct nfs_diskless nfs_diskless; -void nfs_disconnect(); +void nfs_disconnect __P((struct nfsmount *)); +void nfsargs_ntoh __P((struct nfs_args *)); +static struct mount *nfs_mountdiskless __P((char *, char *, int, + struct sockaddr_in *, struct nfs_args *, register struct vnode **)); #define TRUE 1 #define FALSE 0 @@ -63,6 +76,7 @@ void nfs_disconnect(); /* * nfs statfs call */ +int nfs_statfs(mp, sbp, p) struct mount *mp; register struct statfs *sbp; @@ -73,39 +87,44 @@ nfs_statfs(mp, sbp, p) register caddr_t cp; register long t1; caddr_t bpos, dpos, cp2; - u_long xid; - int error = 0; + int error = 0, isnq; struct mbuf *mreq, *mrep, *md, *mb, *mb2; struct nfsmount *nmp; struct ucred *cred; struct nfsnode *np; nmp = VFSTONFS(mp); + isnq = (nmp->nm_flag & NFSMNT_NQNFS); if (error = nfs_nget(mp, &nmp->nm_fh, &np)) return (error); vp = NFSTOV(np); nfsstats.rpccnt[NFSPROC_STATFS]++; cred = crget(); cred->cr_ngroups = 1; - nfsm_reqhead(nfs_procids[NFSPROC_STATFS], cred, NFSX_FH); + nfsm_reqhead(vp, NFSPROC_STATFS, NFSX_FH); nfsm_fhtom(vp); - nfsm_request(vp, NFSPROC_STATFS, p, 0); - nfsm_disect(sfp, struct nfsv2_statfs *, NFSX_STATFS); + nfsm_request(vp, NFSPROC_STATFS, p, cred); + nfsm_dissect(sfp, struct nfsv2_statfs *, NFSX_STATFS(isnq)); sbp->f_type = MOUNT_NFS; sbp->f_flags = nmp->nm_flag; - sbp->f_bsize = fxdr_unsigned(long, sfp->sf_tsize); - sbp->f_fsize = fxdr_unsigned(long, sfp->sf_bsize); + sbp->f_iosize = NFS_MAXDGRAMDATA; + sbp->f_bsize = fxdr_unsigned(long, sfp->sf_bsize); sbp->f_blocks = fxdr_unsigned(long, sfp->sf_blocks); sbp->f_bfree = fxdr_unsigned(long, sfp->sf_bfree); sbp->f_bavail = fxdr_unsigned(long, sfp->sf_bavail); - sbp->f_files = 0; - sbp->f_ffree = 0; + if (isnq) { + sbp->f_files = fxdr_unsigned(long, sfp->sf_files); + sbp->f_ffree = fxdr_unsigned(long, sfp->sf_ffree); + } else { + sbp->f_files = 0; + sbp->f_ffree = 0; + } if (sbp != &mp->mnt_stat) { bcopy(mp->mnt_stat.f_mntonname, sbp->f_mntonname, MNAMELEN); bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN); } nfsm_reqdone; - nfs_nput(vp); + vrele(vp); crfree(cred); return (error); } @@ -119,47 +138,59 @@ nfs_statfs(mp, sbp, p) * can talk to the server * - If nfs_diskless.mygateway is filled in, use that address as * a default gateway. - * (This is done the 4.3 way with rtioctl() and should be changed) * - hand craft the swap nfs vnode hanging off a fake mount point + * if swdevt[0].sw_dev == NODEV * - build the rootfs mount point and call mountnfs() to do the rest. */ +int nfs_mountroot() { register struct mount *mp; - register struct mbuf *m; + register struct nfs_diskless *nd = &nfs_diskless; struct socket *so; struct vnode *vp; - int error; + struct proc *p = curproc; /* XXX */ + int error, i; /* - * Do enough of ifconfig(8) so that critical net interface can + * XXX time must be non-zero when we init the interface or else + * the arp code will wedge... + */ + if (time.tv_sec == 0) + time.tv_sec = 1; + +#ifdef notyet + /* Set up swap credentials. */ + *proc0.p_ucred = nfs_diskless.swap_ucred; +#endif + + /* + * Do enough of ifconfig(8) so that the critical net interface can * talk to the server. */ - if (socreate(nfs_diskless.myif.ifra_addr.sa_family, &so, SOCK_DGRAM, 0)) - panic("nfs ifconf"); - if (ifioctl(so, SIOCAIFADDR, &nfs_diskless.myif)) - panic("nfs ifconf2"); + if (error = socreate(nd->myif.ifra_addr.sa_family, &so, SOCK_DGRAM, 0)) + panic("nfs_mountroot: socreate: %d", error); + if (error = ifioctl(so, SIOCAIFADDR, (caddr_t)&nd->myif, p)) + panic("nfs_mountroot: SIOCAIFADDR: %d", error); soclose(so); /* * If the gateway field is filled in, set it as the default route. */ -#ifdef COMPAT_43 - if (nfs_diskless.mygateway.sa_family == AF_INET) { - struct ortentry rt; - struct sockaddr_in *sin; - - sin = (struct sockaddr_in *) &rt.rt_dst; - sin->sin_len = sizeof (struct sockaddr_in); - sin->sin_family = AF_INET; - sin->sin_addr.s_addr = 0; /* default */ - bcopy((caddr_t)&nfs_diskless.mygateway, (caddr_t)&rt.rt_gateway, - sizeof (struct sockaddr_in)); - rt.rt_flags = (RTF_UP | RTF_GATEWAY); - if (rtioctl(SIOCADDRT, (caddr_t)&rt)) - panic("nfs root route"); + if (nd->mygateway.sin_len != 0) { + struct sockaddr_in sin; + extern struct sockaddr_in icmpmask; + + sin.sin_len = sizeof (struct sockaddr_in); + sin.sin_family = AF_INET; + sin.sin_addr.s_addr = 0; /* default */ + in_sockmaskof(sin.sin_addr, &icmpmask); + if (error = rtrequest(RTM_ADD, (struct sockaddr *)&sin, + (struct sockaddr *)&nd->mygateway, + (struct sockaddr *)&icmpmask, + RTF_UP | RTF_GATEWAY, (struct rtentry **)0)) + panic("nfs_mountroot: RTM_ADD: %d", error); } -#endif /* COMPAT_43 */ /* * If swapping to an nfs node (indicated by swdevt[0].sw_dev == NODEV): @@ -167,77 +198,112 @@ nfs_mountroot() * swap file can be on a different server from the rootfs. */ if (swdevt[0].sw_dev == NODEV) { - mp = (struct mount *)malloc((u_long)sizeof(struct mount), - M_MOUNT, M_NOWAIT); - if (mp == NULL) - panic("nfs root mount"); - mp->mnt_op = &nfs_vfsops; - mp->mnt_flag = 0; - mp->mnt_exroot = 0; - mp->mnt_mounth = NULLVP; + nd->swap_args.fh = (nfsv2fh_t *)nd->swap_fh; + (void) nfs_mountdiskless(nd->swap_hostnam, "/swap", 0, + &nd->swap_saddr, &nd->swap_args, &vp); /* - * Set up the diskless nfs_args for the swap mount point - * and then call mountnfs() to mount it. * Since the swap file is not the root dir of a file system, * hack it to a regular file. */ - nfs_diskless.swap_args.fh = (nfsv2fh_t *)nfs_diskless.swap_fh; - MGET(m, MT_SONAME, M_DONTWAIT); - if (m == NULL) - panic("nfs root mbuf"); - bcopy((caddr_t)&nfs_diskless.swap_saddr, mtod(m, caddr_t), - nfs_diskless.swap_saddr.sa_len); - m->m_len = nfs_diskless.swap_saddr.sa_len; - if (mountnfs(&nfs_diskless.swap_args, mp, m, "/swap", - nfs_diskless.swap_hostnam, &vp)) - panic("nfs swap"); vp->v_type = VREG; vp->v_flag = 0; swapdev_vp = vp; VREF(vp); swdevt[0].sw_vp = vp; - VREF(vp); - argdev_vp = vp; - } + swdevt[0].sw_nblks = ntohl(nd->swap_nblks); + } else if (bdevvp(swapdev, &swapdev_vp)) + panic("nfs_mountroot: can't setup swapdev_vp"); /* * Create the rootfs mount point. */ - mp = (struct mount *)malloc((u_long)sizeof(struct mount), - M_MOUNT, M_NOWAIT); - if (mp == NULL) - panic("nfs root mount2"); - mp->mnt_op = &nfs_vfsops; - mp->mnt_flag = MNT_RDONLY; - mp->mnt_exroot = 0; - mp->mnt_mounth = NULLVP; + nd->root_args.fh = (nfsv2fh_t *)nd->root_fh; + mp = nfs_mountdiskless(nd->root_hostnam, "/", MNT_RDONLY, + &nd->root_saddr, &nd->root_args, &vp); - /* - * Set up the root fs args and call mountnfs() to do the rest. - */ - nfs_diskless.root_args.fh = (nfsv2fh_t *)nfs_diskless.root_fh; - MGET(m, MT_SONAME, M_DONTWAIT); - if (m == NULL) - panic("nfs root mbuf2"); - bcopy((caddr_t)&nfs_diskless.root_saddr, mtod(m, caddr_t), - nfs_diskless.root_saddr.sa_len); - m->m_len = nfs_diskless.root_saddr.sa_len; - if (mountnfs(&nfs_diskless.root_args, mp, m, "/", - nfs_diskless.root_hostnam, &vp)) - panic("nfs root"); if (vfs_lock(mp)) - panic("nfs root2"); + panic("nfs_mountroot: vfs_lock"); rootfs = mp; mp->mnt_next = mp; mp->mnt_prev = mp; mp->mnt_vnodecovered = NULLVP; vfs_unlock(mp); rootvp = vp; - inittodr((time_t)0); /* There is no time in the nfs fsstat so ?? */ + + /* + * This is not really an nfs issue, but it is much easier to + * set hostname here and then let the "/etc/rc.xxx" files + * mount the right /var based upon its preset value. + */ + bcopy(nd->my_hostnam, hostname, MAXHOSTNAMELEN); + hostname[MAXHOSTNAMELEN - 1] = '\0'; + for (i = 0; i < MAXHOSTNAMELEN; i++) + if (hostname[i] == '\0') + break; + hostnamelen = i; + inittodr(nfs_diskless.root_time); return (0); } +/* + * Internal version of mount system call for diskless setup. + */ +static struct mount * +nfs_mountdiskless(path, which, mountflag, sin, args, vpp) + char *path; + char *which; + int mountflag; + struct sockaddr_in *sin; + struct nfs_args *args; + register struct vnode **vpp; +{ + register struct mount *mp; + register struct mbuf *m; + register int error; + + mp = (struct mount *)malloc((u_long)sizeof(struct mount), + M_MOUNT, M_NOWAIT); + if (mp == NULL) + panic("nfs_mountroot: %s mount malloc", which); + mp->mnt_op = &nfs_vfsops; + mp->mnt_flag = mountflag; + mp->mnt_mounth = NULLVP; + + MGET(m, MT_SONAME, M_DONTWAIT); + if (m == NULL) + panic("nfs_mountroot: %s mount mbuf", which); + bcopy((caddr_t)sin, mtod(m, caddr_t), sin->sin_len); + m->m_len = sin->sin_len; + nfsargs_ntoh(args); + if (error = mountnfs(args, mp, m, which, path, vpp)) + panic("nfs_mountroot: mount %s on %s: %d", path, which, error); + + return (mp); +} + +/* + * Convert the integer fields of the nfs_args structure from net byte order + * to host byte order. Called by nfs_mountroot() above. + */ +void +nfsargs_ntoh(nfsp) + register struct nfs_args *nfsp; +{ + + NTOHL(nfsp->sotype); + NTOHL(nfsp->proto); + NTOHL(nfsp->flags); + NTOHL(nfsp->wsize); + NTOHL(nfsp->rsize); + NTOHL(nfsp->timeo); + NTOHL(nfsp->retrans); + NTOHL(nfsp->maxgrouplist); + NTOHL(nfsp->readahead); + NTOHL(nfsp->leaseterm); + NTOHL(nfsp->deadthresh); +} + /* * VFS Operations. * @@ -248,6 +314,7 @@ nfs_mountroot() * an error after that means that I have to release the mbuf. */ /* ARGSUSED */ +int nfs_mount(mp, path, data, ndp, p) struct mount *mp; char *path; @@ -263,8 +330,6 @@ nfs_mount(mp, path, data, ndp, p) u_int len; nfsv2fh_t nfh; - if (mp->mnt_flag & MNT_UPDATE) - return (0); if (error = copyin(data, (caddr_t)&args, sizeof (struct nfs_args))) return (error); if (error = copyin((caddr_t)args.fh, (caddr_t)&nfh, sizeof (nfsv2fh_t))) @@ -277,7 +342,7 @@ nfs_mount(mp, path, data, ndp, p) bzero(&hst[len], MNAMELEN - len); /* sockargs() call must be after above copyin() calls */ if (error = sockargs(&nam, (caddr_t)args.addr, - sizeof (struct sockaddr), MT_SONAME)) + args.addrlen, MT_SONAME)) return (error); args.fh = &nfh; error = mountnfs(&args, mp, nam, pth, hst, &vp); @@ -287,6 +352,7 @@ nfs_mount(mp, path, data, ndp, p) /* * Common code for mount and mountroot */ +int mountnfs(argp, mp, nam, pth, hst, vpp) register struct nfs_args *argp; register struct mount *mp; @@ -295,51 +361,53 @@ mountnfs(argp, mp, nam, pth, hst, vpp) struct vnode **vpp; { register struct nfsmount *nmp; - struct proc *p = curproc; /* XXX */ struct nfsnode *np; int error; fsid_t tfsid; - MALLOC(nmp, struct nfsmount *, sizeof *nmp, M_NFSMNT, M_WAITOK); - bzero((caddr_t)nmp, sizeof *nmp); - mp->mnt_data = (qaddr_t)nmp; - /* - * Generate a unique nfs mount id. The problem is that a dev number - * is not unique across multiple systems. The techique is as follows: - * 1) Set to nblkdev,0 which will never be used otherwise - * 2) Generate a first guess as nblkdev,nfs_mntid where nfs_mntid is - * NOT 0 - * 3) Loop searching the mount list for another one with same id - * If a match, increment val[0] and try again - * NB: I increment val[0] { a long } instead of nfs_mntid { a u_char } - * so that nfs is not limited to 255 mount points - * Incrementing the high order bits does no real harm, since it - * simply makes the major dev number tick up. The upper bound is - * set to major dev 127 to avoid any sign extention problems - */ - mp->mnt_stat.f_fsid.val[0] = makedev(nblkdev, 0); - mp->mnt_stat.f_fsid.val[1] = MOUNT_NFS; - if (++nfs_mntid == 0) - ++nfs_mntid; - tfsid.val[0] = makedev(nblkdev, nfs_mntid); - tfsid.val[1] = MOUNT_NFS; - while (rootfs && getvfs(&tfsid)) { - tfsid.val[0]++; - nfs_mntid++; - } - if (major(tfsid.val[0]) > 127) { - error = ENOENT; - goto bad; + if (mp->mnt_flag & MNT_UPDATE) { + nmp = VFSTONFS(mp); + /* update paths, file handles, etc, here XXX */ + m_freem(nam); + return (0); + } else { + MALLOC(nmp, struct nfsmount *, sizeof (struct nfsmount), + M_NFSMNT, M_WAITOK); + bzero((caddr_t)nmp, sizeof (struct nfsmount)); + mp->mnt_data = (qaddr_t)nmp; } - mp->mnt_stat.f_fsid.val[0] = tfsid.val[0]; + getnewfsid(mp, MOUNT_NFS); nmp->nm_mountp = mp; nmp->nm_flag = argp->flags; - nmp->nm_rto = NFS_TIMEO; - nmp->nm_rtt = -1; - nmp->nm_rttvar = nmp->nm_rto << 1; + if ((nmp->nm_flag & (NFSMNT_NQNFS | NFSMNT_MYWRITE)) == + (NFSMNT_NQNFS | NFSMNT_MYWRITE)) { + error = EPERM; + goto bad; + } + if (nmp->nm_flag & (NFSMNT_RDIRALOOK | NFSMNT_LEASETERM)) { + if ((nmp->nm_flag & NFSMNT_NQNFS) == 0) { + error = EPERM; + goto bad; + } + /* + * We have to set mnt_maxsymlink to a non-zero value so + * that COMPAT_43 routines will know that we are setting + * the d_type field in directories (and can zero it for + * unsuspecting binaries). + */ + mp->mnt_maxsymlinklen = 1; + } + nmp->nm_timeo = NFS_TIMEO; nmp->nm_retry = NFS_RETRANS; nmp->nm_wsize = NFS_WSIZE; nmp->nm_rsize = NFS_RSIZE; + nmp->nm_numgrps = NFS_MAXGRPS; + nmp->nm_readahead = NFS_DEFRAHEAD; + nmp->nm_leaseterm = NQ_DEFLEASE; + nmp->nm_deadthresh = NQ_DEADTHRESH; + nmp->nm_tnext = (struct nfsnode *)nmp; + nmp->nm_tprev = (struct nfsnode *)nmp; + nmp->nm_inprog = NULLVP; bcopy((caddr_t)argp->fh, (caddr_t)&nmp->nm_fh, sizeof(nfsv2fh_t)); mp->mnt_stat.f_type = MOUNT_NFS; bcopy(hst, mp->mnt_stat.f_mntfromname, MNAMELEN); @@ -347,14 +415,11 @@ mountnfs(argp, mp, nam, pth, hst, vpp) nmp->nm_nam = nam; if ((argp->flags & NFSMNT_TIMEO) && argp->timeo > 0) { - nmp->nm_rto = argp->timeo; - /* NFS timeouts are specified in 1/10 sec. */ - nmp->nm_rto = (nmp->nm_rto * 10) / NFS_HZ; - if (nmp->nm_rto < NFS_MINTIMEO) - nmp->nm_rto = NFS_MINTIMEO; - else if (nmp->nm_rto > NFS_MAXTIMEO) - nmp->nm_rto = NFS_MAXTIMEO; - nmp->nm_rttvar = nmp->nm_rto << 1; + nmp->nm_timeo = (argp->timeo * NFS_HZ + 5) / 10; + if (nmp->nm_timeo < NFS_MINTIMEO) + nmp->nm_timeo = NFS_MINTIMEO; + else if (nmp->nm_timeo > NFS_MAXTIMEO) + nmp->nm_timeo = NFS_MAXTIMEO; } if ((argp->flags & NFSMNT_RETRANS) && argp->retrans > 1) { @@ -386,14 +451,37 @@ mountnfs(argp, mp, nam, pth, hst, vpp) } if (nmp->nm_rsize > MAXBSIZE) nmp->nm_rsize = MAXBSIZE; + if ((argp->flags & NFSMNT_MAXGRPS) && argp->maxgrouplist >= 0 && + argp->maxgrouplist <= NFS_MAXGRPS) + nmp->nm_numgrps = argp->maxgrouplist; + if ((argp->flags & NFSMNT_READAHEAD) && argp->readahead >= 0 && + argp->readahead <= NFS_MAXRAHEAD) + nmp->nm_readahead = argp->readahead; + if ((argp->flags & NFSMNT_LEASETERM) && argp->leaseterm >= 2 && + argp->leaseterm <= NQ_MAXLEASE) + nmp->nm_leaseterm = argp->leaseterm; + if ((argp->flags & NFSMNT_DEADTHRESH) && argp->deadthresh >= 1 && + argp->deadthresh <= NQ_NEVERDEAD) + nmp->nm_deadthresh = argp->deadthresh; /* Set up the sockets and per-host congestion */ nmp->nm_sotype = argp->sotype; nmp->nm_soproto = argp->proto; - if (error = nfs_connect(nmp)) - goto bad; - if (error = nfs_statfs(mp, &mp->mnt_stat, p)) + /* + * 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))) goto bad; + + /* + * This is silly, but it has to be set so that vinifod() works. + * We do not want to do an nfs_statfs() 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; /* * A reference count is needed on the nfsnode representing the * remote root. If this object is not persistent, then backward @@ -404,16 +492,12 @@ mountnfs(argp, mp, nam, pth, hst, vpp) */ if (error = nfs_nget(mp, &nmp->nm_fh, &np)) goto bad; - /* - * Unlock it, but keep the reference count. - */ - nfs_unlock(NFSTOV(np)); *vpp = NFSTOV(np); return (0); bad: nfs_disconnect(nmp); - FREE(nmp, M_NFSMNT); + free((caddr_t)nmp, M_NFSMNT); m_freem(nam); return (error); } @@ -421,6 +505,7 @@ bad: /* * unmount system call */ +int nfs_unmount(mp, mntflags, p) struct mount *mp; int mntflags; @@ -438,12 +523,6 @@ nfs_unmount(mp, mntflags, p) flags |= FORCECLOSE; } nmp = VFSTONFS(mp); - /* - * Clear out the buffer cache - */ - mntflushbuf(mp, 0); - if (mntinvalbuf(mp)) - return (EBUSY); /* * Goes something like this.. * - Check for activity on the root vnode (other than ourselves). @@ -465,24 +544,44 @@ nfs_unmount(mp, mntflags, p) vput(vp); return (EBUSY); } + + /* + * Must handshake with nqnfs_clientd() if it is active. + */ + nmp->nm_flag |= NFSMNT_DISMINPROG; + while (nmp->nm_inprog != NULLVP) + (void) tsleep((caddr_t)&lbolt, PSOCK, "nfsdism", 0); if (error = vflush(mp, vp, flags)) { vput(vp); + nmp->nm_flag &= ~NFSMNT_DISMINPROG; return (error); } + + /* + * We are now committed to the unmount. + * For NQNFS, let the server daemon free the nfsmount structure. + */ + if (nmp->nm_flag & (NFSMNT_NQNFS | NFSMNT_KERB)) + nmp->nm_flag |= NFSMNT_DISMNT; + /* - * Get rid of two reference counts, and unlock it on the second. + * There are two reference counts to get rid of here. */ vrele(vp); - vput(vp); + vrele(vp); + vgone(vp); nfs_disconnect(nmp); m_freem(nmp->nm_nam); - free((caddr_t)nmp, M_NFSMNT); + + if ((nmp->nm_flag & (NFSMNT_NQNFS | NFSMNT_KERB)) == 0) + free((caddr_t)nmp, M_NFSMNT); return (0); } /* * Return root of a filesystem */ +int nfs_root(mp, vpp) struct mount *mp; struct vnode **vpp; @@ -508,27 +607,65 @@ extern int syncprt; * Flush out the buffer cache */ /* ARGSUSED */ -nfs_sync(mp, waitfor) +int +nfs_sync(mp, waitfor, cred, p) struct mount *mp; int waitfor; + struct ucred *cred; + struct proc *p; { - if (syncprt) - bufstats(); + register struct vnode *vp; + int error, allerror = 0; + /* * Force stale buffer cache information to be flushed. */ - mntflushbuf(mp, waitfor == MNT_WAIT ? B_SYNC : 0); - return (0); +loop: + for (vp = mp->mnt_mounth; vp; vp = vp->v_mountf) { + /* + * If the vnode that we are about to sync is no longer + * associated with this mount point, start over. + */ + if (vp->v_mount != mp) + goto loop; + if (VOP_ISLOCKED(vp) || vp->v_dirtyblkhd.le_next == NULL) + continue; + if (vget(vp)) + goto loop; + if (error = VOP_FSYNC(vp, cred, waitfor, p)) + allerror = error; + vput(vp); + } + return (allerror); } /* - * At this point, this should never happen + * NFS flat namespace lookup. + * Currently unsupported. */ /* ARGSUSED */ -nfs_fhtovp(mp, fhp, vpp) +int +nfs_vget(mp, ino, vpp) struct mount *mp; + ino_t ino; + struct vnode **vpp; +{ + + return (EOPNOTSUPP); +} + +/* + * At this point, this should never happen + */ +/* ARGSUSED */ +int +nfs_fhtovp(mp, fhp, nam, vpp, exflagsp, credanonp) + register struct mount *mp; struct fid *fhp; + struct mbuf *nam; struct vnode **vpp; + int *exflagsp; + struct ucred **credanonp; { return (EINVAL); @@ -538,6 +675,7 @@ nfs_fhtovp(mp, fhp, vpp) * Vnode pointer to File handle, should never happen either */ /* ARGSUSED */ +int nfs_vptofh(vp, fhp) struct vnode *vp; struct fid *fhp; @@ -550,6 +688,7 @@ nfs_vptofh(vp, fhp) * Vfs start routine, a no-op. */ /* ARGSUSED */ +int nfs_start(mp, flags, p) struct mount *mp; int flags; @@ -562,6 +701,8 @@ nfs_start(mp, flags, p) /* * Do operations associated with quotas, not supported */ +/* ARGSUSED */ +int nfs_quotactl(mp, cmd, uid, arg, p) struct mount *mp; int cmd; @@ -569,8 +710,6 @@ nfs_quotactl(mp, cmd, uid, arg, p) caddr_t arg; struct proc *p; { -#ifdef lint - mp = mp; cmd = cmd; uid = uid; arg = arg; -#endif /* lint */ + return (EOPNOTSUPP); }