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