![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to nfs_serv.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_serv.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
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_serv.c 8.7 (Berkeley) 5/14/95
59: * FreeBSD-Id: nfs_serv.c,v 1.52 1997/10/28 15:59:05 bde Exp $
60: */
61:
62: /*
63: * nfs version 2 and 3 server calls to vnode ops
64: * - these routines generally have 3 phases
65: * 1 - break down and validate rpc request in mbuf list
66: * 2 - do the vnode ops for the request
67: * (surprisingly ?? many are very similar to syscalls in vfs_syscalls.c)
68: * 3 - build the rpc reply in an mbuf list
69: * nb:
70: * - do not mix the phases, since the nfsm_?? macros can return failures
71: * on a bad rpc or similar and do not do any vrele() or vput()'s
72: *
73: * - the nfsm_reply() macro generates an nfs rpc reply with the nfs
74: * error number iff error != 0 whereas
75: * returning an error from the server function implies a fatal error
76: * such as a badly constructed rpc request that should be dropped without
77: * a reply.
78: * For Version 3, nfsm_reply() does not return for the error case, since
79: * most version 3 rpcs return more than the status for error cases.
80: */
81:
82: #include <mach_nbc.h>
83: #include <sys/param.h>
84: #include <sys/systm.h>
85: #include <sys/proc.h>
86: #include <sys/namei.h>
87: #include <sys/unistd.h>
88: #include <sys/malloc.h>
89: #include <sys/vnode.h>
90: #include <sys/mount.h>
91: #include <sys/socket.h>
92: #include <sys/socketvar.h>
93: #include <sys/mbuf.h>
94: #include <sys/dirent.h>
95: #include <sys/stat.h>
96: #include <sys/kernel.h>
97: #include <sys/sysctl.h>
98: #include <ufs/ufs/dir.h>
99:
100: #include <sys/vm.h>
101: #include <sys/vmparam.h>
102: #include <machine/spl.h>
103:
104: #include <kern/mapfs.h>
105:
106: #include <nfs/nfsproto.h>
107: #include <nfs/rpcv2.h>
108: #include <nfs/nfs.h>
109: #include <nfs/xdr_subs.h>
110: #include <nfs/nfsm_subs.h>
111: #include <nfs/nqnfs.h>
112:
113: nfstype nfsv3_type[9] = { NFNON, NFREG, NFDIR, NFBLK, NFCHR, NFLNK, NFSOCK,
114: NFFIFO, NFNON };
115: #ifndef NFS_NOSERVER
116: nfstype nfsv2_type[9] = { NFNON, NFREG, NFDIR, NFBLK, NFCHR, NFLNK, NFNON,
117: NFCHR, NFNON };
118: /* Global vars */
119: extern u_long nfs_xdrneg1;
120: extern u_long nfs_false, nfs_true;
121: extern enum vtype nv3tov_type[8];
122: extern struct nfsstats nfsstats;
123:
124: int nfsrvw_procrastinate = NFS_GATHERDELAY * 1000;
125: int nfsrvw_procrastinate_v3 = 0;
126:
127: int nfs_async = 0;
128: #ifdef notyet
129: /* XXX CSM 11/25/97 Upgrade sysctl.h someday */
130: SYSCTL_INT(_vfs_nfs, OID_AUTO, async, CTLFLAG_RW, &nfs_async, 0, "");
131: #endif
132:
133: static int nfsrv_access __P((struct vnode *,int,struct ucred *,int,
134: struct proc *));
135: static void nfsrvw_coalesce __P((struct nfsrv_descript *,
136: struct nfsrv_descript *));
137:
138: extern int vnode_uncache(struct vnode *vp);
139:
140: /*
141: * nfs v3 access service
142: */
143: int
144: nfsrv3_access(nfsd, slp, procp, mrq)
145: struct nfsrv_descript *nfsd;
146: struct nfssvc_sock *slp;
147: struct proc *procp;
148: struct mbuf **mrq;
149: {
150: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
151: struct mbuf *nam = nfsd->nd_nam;
152: caddr_t dpos = nfsd->nd_dpos;
153: struct ucred *cred = &nfsd->nd_cr;
154: struct vnode *vp;
155: nfsfh_t nfh;
156: fhandle_t *fhp;
157: register u_long *tl;
158: register long t1;
159: caddr_t bpos;
160: int error = 0, rdonly, cache, getret;
161: char *cp2;
162: struct mbuf *mb, *mreq, *mb2;
163: struct vattr vattr, *vap = &vattr;
164: u_long testmode, nfsmode;
165: u_quad_t frev;
166:
167: #ifndef nolint
168: cache = 0;
169: #endif
170: fhp = &nfh.fh_generic;
171: nfsm_srvmtofh(fhp);
172: nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
173: if ((error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam,
174: &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE))) {
175: nfsm_reply(NFSX_UNSIGNED);
176: nfsm_srvpostop_attr(1, (struct vattr *)0);
177: return (0);
178: }
179: nfsmode = fxdr_unsigned(u_long, *tl);
180: if ((nfsmode & NFSV3ACCESS_READ) &&
181: nfsrv_access(vp, VREAD, cred, rdonly, procp))
182: nfsmode &= ~NFSV3ACCESS_READ;
183: if (vp->v_type == VDIR)
184: testmode = (NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND |
185: NFSV3ACCESS_DELETE);
186: else
187: testmode = (NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND);
188: if ((nfsmode & testmode) &&
189: nfsrv_access(vp, VWRITE, cred, rdonly, procp))
190: nfsmode &= ~testmode;
191: if (vp->v_type == VDIR)
192: testmode = NFSV3ACCESS_LOOKUP;
193: else
194: testmode = NFSV3ACCESS_EXECUTE;
195: if ((nfsmode & testmode) &&
196: nfsrv_access(vp, VEXEC, cred, rdonly, procp))
197: nfsmode &= ~testmode;
198: getret = VOP_GETATTR(vp, vap, cred, procp);
199: vput(vp);
200: nfsm_reply(NFSX_POSTOPATTR(1) + NFSX_UNSIGNED);
201: nfsm_srvpostop_attr(getret, vap);
202: nfsm_build(tl, u_long *, NFSX_UNSIGNED);
203: *tl = txdr_unsigned(nfsmode);
204: nfsm_srvdone;
205: }
206:
207: /*
208: * nfs getattr service
209: */
210: int
211: nfsrv_getattr(nfsd, slp, procp, mrq)
212: struct nfsrv_descript *nfsd;
213: struct nfssvc_sock *slp;
214: struct proc *procp;
215: struct mbuf **mrq;
216: {
217: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
218: struct mbuf *nam = nfsd->nd_nam;
219: caddr_t dpos = nfsd->nd_dpos;
220: struct ucred *cred = &nfsd->nd_cr;
221: register struct nfs_fattr *fp;
222: struct vattr va;
223: register struct vattr *vap = &va;
224: struct vnode *vp;
225: nfsfh_t nfh;
226: fhandle_t *fhp;
227: register u_long *tl;
228: register long t1;
229: caddr_t bpos;
230: int error = 0, rdonly, cache;
231: char *cp2;
232: struct mbuf *mb, *mb2, *mreq;
233: u_quad_t frev;
234:
235: fhp = &nfh.fh_generic;
236: nfsm_srvmtofh(fhp);
237: if ((error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam,
238: &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE))) {
239: nfsm_reply(0);
240: return (0);
241: }
242: nqsrv_getl(vp, ND_READ);
243: error = VOP_GETATTR(vp, vap, cred, procp);
244: vput(vp);
245: nfsm_reply(NFSX_FATTR(nfsd->nd_flag & ND_NFSV3));
246: if (error)
247: return (0);
248: nfsm_build(fp, struct nfs_fattr *, NFSX_FATTR(nfsd->nd_flag & ND_NFSV3));
249: nfsm_srvfillattr(vap, fp);
250: nfsm_srvdone;
251: }
252:
253: /*
254: * nfs setattr service
255: */
256: int
257: nfsrv_setattr(nfsd, slp, procp, mrq)
258: struct nfsrv_descript *nfsd;
259: struct nfssvc_sock *slp;
260: struct proc *procp;
261: struct mbuf **mrq;
262: {
263: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
264: struct mbuf *nam = nfsd->nd_nam;
265: caddr_t dpos = nfsd->nd_dpos;
266: struct ucred *cred = &nfsd->nd_cr;
267: struct vattr va, preat;
268: register struct vattr *vap = &va;
269: register struct nfsv2_sattr *sp;
270: register struct nfs_fattr *fp;
271: struct vnode *vp;
272: nfsfh_t nfh;
273: fhandle_t *fhp;
274: register u_long *tl;
275: register long t1;
276: caddr_t bpos;
277: int error = 0, rdonly, cache, preat_ret = 1, postat_ret = 1;
278: int v3 = (nfsd->nd_flag & ND_NFSV3), gcheck = 0;
279: char *cp2;
280: struct mbuf *mb, *mb2, *mreq;
281: u_quad_t frev;
282: struct timespec guard;
283:
284: fhp = &nfh.fh_generic;
285: nfsm_srvmtofh(fhp);
286: VATTR_NULL(vap);
287: if (v3) {
288: nfsm_srvsattr(vap);
289: nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
290: gcheck = fxdr_unsigned(int, *tl);
291: if (gcheck) {
292: nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED);
293: fxdr_nfsv3time(tl, &guard);
294: }
295: } else {
296: nfsm_dissect(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
297: /*
298: * Nah nah nah nah na nah
299: * There is a bug in the Sun client that puts 0xffff in the mode
300: * field of sattr when it should put in 0xffffffff. The u_short
301: * doesn't sign extend.
302: * --> check the low order 2 bytes for 0xffff
303: */
304: if ((fxdr_unsigned(int, sp->sa_mode) & 0xffff) != 0xffff)
305: vap->va_mode = nfstov_mode(sp->sa_mode);
306: if (sp->sa_uid != nfs_xdrneg1)
307: vap->va_uid = fxdr_unsigned(uid_t, sp->sa_uid);
308: if (sp->sa_gid != nfs_xdrneg1)
309: vap->va_gid = fxdr_unsigned(gid_t, sp->sa_gid);
310: if (sp->sa_size != nfs_xdrneg1)
311: vap->va_size = fxdr_unsigned(u_quad_t, sp->sa_size);
312: if (sp->sa_atime.nfsv2_sec != nfs_xdrneg1) {
313: #ifdef notyet
314: fxdr_nfsv2time(&sp->sa_atime, &vap->va_atime);
315: #else
316: vap->va_atime.tv_sec =
317: fxdr_unsigned(long, sp->sa_atime.nfsv2_sec);
318: vap->va_atime.tv_nsec = 0;
319: #endif
320: }
321: if (sp->sa_mtime.nfsv2_sec != nfs_xdrneg1)
322: fxdr_nfsv2time(&sp->sa_mtime, &vap->va_mtime);
323:
324: }
325:
326: /*
327: * Now that we have all the fields, lets do it.
328: */
329: if ((error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam,
330: &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE))) {
331: nfsm_reply(2 * NFSX_UNSIGNED);
332: nfsm_srvwcc_data(preat_ret, &preat, postat_ret, vap);
333: return (0);
334: }
335: nqsrv_getl(vp, ND_WRITE);
336: if (v3) {
337: error = preat_ret = VOP_GETATTR(vp, &preat, cred, procp);
338: if (!error && gcheck &&
339: (preat.va_ctime.tv_sec != guard.tv_sec ||
340: preat.va_ctime.tv_nsec != guard.tv_nsec))
341: error = NFSERR_NOT_SYNC;
342: if (error) {
343: vput(vp);
344: nfsm_reply(NFSX_WCCDATA(v3));
345: nfsm_srvwcc_data(preat_ret, &preat, postat_ret, vap);
346: return (0);
347: }
348: }
349:
350: /*
351: * If the size is being changed write acces is required, otherwise
352: * just check for a read only file system.
353: */
354: if (vap->va_size == ((u_quad_t)((quad_t) -1))) {
355: if (rdonly || (vp->v_mount->mnt_flag & MNT_RDONLY)) {
356: error = EROFS;
357: goto out;
358: }
359: } else {
360: if (vp->v_type == VDIR) {
361: error = EISDIR;
362: goto out;
363: } else if ((error = nfsrv_access(vp, VWRITE, cred, rdonly,
364: procp)))
365: goto out;
366: }
367: error = VOP_SETATTR(vp, vap, cred, procp);
368: postat_ret = VOP_GETATTR(vp, vap, cred, procp);
369: if (!error)
370: error = postat_ret;
371: out:
372: vput(vp);
373: nfsm_reply(NFSX_WCCORFATTR(v3));
374: if (v3) {
375: nfsm_srvwcc_data(preat_ret, &preat, postat_ret, vap);
376: return (0);
377: } else {
378: nfsm_build(fp, struct nfs_fattr *, NFSX_V2FATTR);
379: nfsm_srvfillattr(vap, fp);
380: }
381: nfsm_srvdone;
382: }
383:
384: /*
385: * nfs lookup rpc
386: */
387: int
388: nfsrv_lookup(nfsd, slp, procp, mrq)
389: struct nfsrv_descript *nfsd;
390: struct nfssvc_sock *slp;
391: struct proc *procp;
392: struct mbuf **mrq;
393: {
394: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
395: struct mbuf *nam = nfsd->nd_nam;
396: caddr_t dpos = nfsd->nd_dpos;
397: struct ucred *cred = &nfsd->nd_cr;
398: register struct nfs_fattr *fp;
399: struct nameidata nd, *ndp = &nd;
400: #ifdef notdef
401: struct nameidata ind;
402: #endif
403: struct vnode *vp, *dirp;
404: nfsfh_t nfh;
405: fhandle_t *fhp;
406: register caddr_t cp;
407: register u_long *tl;
408: register long t1;
409: caddr_t bpos;
410: int error = 0, cache, len, dirattr_ret = 1;
411: int v3 = (nfsd->nd_flag & ND_NFSV3), pubflag;
412: char *cp2;
413: struct mbuf *mb, *mb2, *mreq;
414: struct vattr va, dirattr, *vap = &va;
415: u_quad_t frev;
416:
417: fhp = &nfh.fh_generic;
418: nfsm_srvmtofh(fhp);
419: nfsm_srvnamesiz(len);
420:
421: pubflag = nfs_ispublicfh(fhp);
422:
423: nd.ni_cnd.cn_cred = cred;
424: nd.ni_cnd.cn_nameiop = LOOKUP;
425: nd.ni_cnd.cn_flags = LOCKLEAF | SAVESTART;
426: error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos,
427: &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), pubflag);
428:
429: /* XXX CSM 12/4/97 Revisit when enabling WebNFS */
430: #ifdef notyet
431: if (!error && pubflag) {
432: if (nd.ni_vp->v_type == VDIR && nfs_pub.np_index != NULL) {
433: /*
434: * Setup call to lookup() to see if we can find
435: * the index file. Arguably, this doesn't belong
436: * in a kernel.. Ugh.
437: */
438: ind = nd;
439: VOP_UNLOCK(nd.ni_vp, 0, procp);
440: ind.ni_pathlen = strlen(nfs_pub.np_index);
441: ind.ni_cnd.cn_nameptr = ind.ni_cnd.cn_pnbuf =
442: nfs_pub.np_index;
443: ind.ni_startdir = nd.ni_vp;
444: VREF(ind.ni_startdir);
445: error = lookup(&ind);
446: if (!error) {
447: /*
448: * Found an index file. Get rid of
449: * the old references.
450: */
451: if (dirp)
452: vrele(dirp);
453: dirp = nd.ni_vp;
454: vrele(nd.ni_startdir);
455: ndp = &ind;
456: } else
457: error = 0;
458: }
459: /*
460: * If the public filehandle was used, check that this lookup
461: * didn't result in a filehandle outside the publicly exported
462: * filesystem.
463: */
464:
465: if (!error && ndp->ni_vp->v_mount != nfs_pub.np_mount) {
466: vput(nd.ni_vp);
467: error = EPERM;
468: }
469: }
470: #endif
471:
472: if (dirp) {
473: if (v3)
474: dirattr_ret = VOP_GETATTR(dirp, &dirattr, cred,
475: procp);
476: vrele(dirp);
477: }
478:
479: if (error) {
480: nfsm_reply(NFSX_POSTOPATTR(v3));
481: nfsm_srvpostop_attr(dirattr_ret, &dirattr);
482: return (0);
483: }
484:
485: nqsrv_getl(ndp->ni_startdir, ND_READ);
486: vrele(ndp->ni_startdir);
487: FREE_ZONE(nd.ni_cnd.cn_pnbuf, nd.ni_cnd.cn_pnlen, M_NAMEI);
488: vp = ndp->ni_vp;
489: bzero((caddr_t)fhp, sizeof(nfh));
490: fhp->fh_fsid = vp->v_mount->mnt_stat.f_fsid;
491: error = VFS_VPTOFH(vp, &fhp->fh_fid);
492: if (!error)
493: error = VOP_GETATTR(vp, vap, cred, procp);
494: vput(vp);
495: nfsm_reply(NFSX_SRVFH(v3) + NFSX_POSTOPORFATTR(v3) + NFSX_POSTOPATTR(v3));
496: if (error) {
497: nfsm_srvpostop_attr(dirattr_ret, &dirattr);
498: return (0);
499: }
500: nfsm_srvfhtom(fhp, v3);
501: if (v3) {
502: nfsm_srvpostop_attr(0, vap);
503: nfsm_srvpostop_attr(dirattr_ret, &dirattr);
504: } else {
505: nfsm_build(fp, struct nfs_fattr *, NFSX_V2FATTR);
506: nfsm_srvfillattr(vap, fp);
507: }
508: nfsm_srvdone;
509: }
510:
511: /*
512: * nfs readlink service
513: */
514: int
515: nfsrv_readlink(nfsd, slp, procp, mrq)
516: struct nfsrv_descript *nfsd;
517: struct nfssvc_sock *slp;
518: struct proc *procp;
519: struct mbuf **mrq;
520: {
521: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
522: struct mbuf *nam = nfsd->nd_nam;
523: caddr_t dpos = nfsd->nd_dpos;
524: struct ucred *cred = &nfsd->nd_cr;
525: struct iovec iv[(NFS_MAXPATHLEN+MLEN-1)/MLEN];
526: register struct iovec *ivp = iv;
527: register struct mbuf *mp;
528: register u_long *tl;
529: register long t1;
530: caddr_t bpos;
531: int error = 0, rdonly, cache, i, tlen, len, getret;
532: int v3 = (nfsd->nd_flag & ND_NFSV3);
533: char *cp2;
534: struct mbuf *mb, *mb2, *mp2, *mp3, *mreq;
535: struct vnode *vp;
536: struct vattr attr;
537: nfsfh_t nfh;
538: fhandle_t *fhp;
539: struct uio io, *uiop = &io;
540: u_quad_t frev;
541:
542: #ifndef nolint
543: mp2 = mp3 = (struct mbuf *)0;
544: #endif
545: fhp = &nfh.fh_generic;
546: nfsm_srvmtofh(fhp);
547: len = 0;
548: i = 0;
549: while (len < NFS_MAXPATHLEN) {
550: MGET(mp, M_WAIT, MT_DATA);
551: MCLGET(mp, M_WAIT);
552: mp->m_len = NFSMSIZ(mp);
553: if (len == 0)
554: mp3 = mp2 = mp;
555: else {
556: mp2->m_next = mp;
557: mp2 = mp;
558: }
559: if ((len+mp->m_len) > NFS_MAXPATHLEN) {
560: mp->m_len = NFS_MAXPATHLEN-len;
561: len = NFS_MAXPATHLEN;
562: } else
563: len += mp->m_len;
564: ivp->iov_base = mtod(mp, caddr_t);
565: ivp->iov_len = mp->m_len;
566: i++;
567: ivp++;
568: }
569: uiop->uio_iov = iv;
570: uiop->uio_iovcnt = i;
571: uiop->uio_offset = 0;
572: uiop->uio_resid = len;
573: uiop->uio_rw = UIO_READ;
574: uiop->uio_segflg = UIO_SYSSPACE;
575: uiop->uio_procp = (struct proc *)0;
576: if ((error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam,
577: &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE))) {
578: m_freem(mp3);
579: nfsm_reply(2 * NFSX_UNSIGNED);
580: nfsm_srvpostop_attr(1, (struct vattr *)0);
581: return (0);
582: }
583: if (vp->v_type != VLNK) {
584: if (v3)
585: error = EINVAL;
586: else
587: error = ENXIO;
588: goto out;
589: }
590: nqsrv_getl(vp, ND_READ);
591: error = VOP_READLINK(vp, uiop, cred);
592: out:
593: getret = VOP_GETATTR(vp, &attr, cred, procp);
594: vput(vp);
595: if (error)
596: m_freem(mp3);
597: nfsm_reply(NFSX_POSTOPATTR(v3) + NFSX_UNSIGNED);
598: if (v3) {
599: nfsm_srvpostop_attr(getret, &attr);
600: if (error)
601: return (0);
602: }
603: if (uiop->uio_resid > 0) {
604: len -= uiop->uio_resid;
605: tlen = nfsm_rndup(len);
606: nfsm_adj(mp3, NFS_MAXPATHLEN-tlen, tlen-len);
607: }
608: nfsm_build(tl, u_long *, NFSX_UNSIGNED);
609: *tl = txdr_unsigned(len);
610: mb->m_next = mp3;
611: nfsm_srvdone;
612: }
613:
614: /*
615: * nfs read service
616: */
617: int
618: nfsrv_read(nfsd, slp, procp, mrq)
619: struct nfsrv_descript *nfsd;
620: struct nfssvc_sock *slp;
621: struct proc *procp;
622: struct mbuf **mrq;
623: {
624: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
625: struct mbuf *nam = nfsd->nd_nam;
626: caddr_t dpos = nfsd->nd_dpos;
627: struct ucred *cred = &nfsd->nd_cr;
628: register struct iovec *iv;
629: struct iovec *iv2;
630: register struct mbuf *m;
631: register struct nfs_fattr *fp;
632: register u_long *tl;
633: register long t1;
634: register int i;
635: caddr_t bpos;
636: int error = 0, rdonly, cache, cnt, len, left, siz, tlen, getret;
637: int v3 = (nfsd->nd_flag & ND_NFSV3), reqlen;
638: char *cp2;
639: struct mbuf *mb, *mb2, *mreq;
640: struct mbuf *m2;
641: struct vnode *vp;
642: nfsfh_t nfh;
643: fhandle_t *fhp;
644: struct uio io, *uiop = &io;
645: struct vattr va, *vap = &va;
646: off_t off;
647: u_quad_t frev;
648:
649: fhp = &nfh.fh_generic;
650: nfsm_srvmtofh(fhp);
651: if (v3) {
652: nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED);
653: fxdr_hyper(tl, &off);
654: } else {
655: nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
656: off = (off_t)fxdr_unsigned(u_long, *tl);
657: }
658: nfsm_srvstrsiz(reqlen, NFS_SRVMAXDATA(nfsd));
659: if ((error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam,
660: &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE))) {
661: nfsm_reply(2 * NFSX_UNSIGNED);
662: nfsm_srvpostop_attr(1, (struct vattr *)0);
663: return (0);
664: }
665: if (vp->v_type != VREG) {
666: if (v3)
667: error = EINVAL;
668: else
669: error = (vp->v_type == VDIR) ? EISDIR : EACCES;
670: }
671: if (!error) {
672: nqsrv_getl(vp, ND_READ);
673: if ((error = nfsrv_access(vp, VREAD, cred, rdonly, procp)))
674: error = nfsrv_access(vp, VEXEC, cred, rdonly, procp);
675: }
676: getret = VOP_GETATTR(vp, vap, cred, procp);
677: if (!error)
678: error = getret;
679: if (error) {
680: vput(vp);
681: nfsm_reply(NFSX_POSTOPATTR(v3));
682: nfsm_srvpostop_attr(getret, vap);
683: return (0);
684: }
685: if (off >= vap->va_size)
686: cnt = 0;
687: else if ((off + reqlen) > vap->va_size)
688: cnt = nfsm_rndup(vap->va_size - off);
689: else
690: cnt = reqlen;
691: nfsm_reply(NFSX_POSTOPORFATTR(v3) + 3 * NFSX_UNSIGNED+nfsm_rndup(cnt));
692: if (v3) {
693: nfsm_build(tl, u_long *, NFSX_V3FATTR + 4 * NFSX_UNSIGNED);
694: *tl++ = nfs_true;
695: fp = (struct nfs_fattr *)tl;
696: tl += (NFSX_V3FATTR / sizeof (u_long));
697: } else {
698: nfsm_build(tl, u_long *, NFSX_V2FATTR + NFSX_UNSIGNED);
699: fp = (struct nfs_fattr *)tl;
700: tl += (NFSX_V2FATTR / sizeof (u_long));
701: }
702: len = left = cnt;
703: if (cnt > 0) {
704: /*
705: * Generate the mbuf list with the uio_iov ref. to it.
706: */
707: i = 0;
708: m = m2 = mb;
709: while (left > 0) {
710: siz = min(M_TRAILINGSPACE(m), left);
711: if (siz > 0) {
712: left -= siz;
713: i++;
714: }
715: if (left > 0) {
716: MGET(m, M_WAIT, MT_DATA);
717: MCLGET(m, M_WAIT);
718: m->m_len = 0;
719: m2->m_next = m;
720: m2 = m;
721: }
722: }
723: MALLOC(iv, struct iovec *, i * sizeof (struct iovec),
724: M_TEMP, M_WAITOK);
725: uiop->uio_iov = iv2 = iv;
726: m = mb;
727: left = cnt;
728: i = 0;
729: while (left > 0) {
730: if (m == NULL)
731: panic("nfsrv_read iov");
732: siz = min(M_TRAILINGSPACE(m), left);
733: if (siz > 0) {
734: iv->iov_base = mtod(m, caddr_t) + m->m_len;
735: iv->iov_len = siz;
736: m->m_len += siz;
737: left -= siz;
738: iv++;
739: i++;
740: }
741: m = m->m_next;
742: }
743: uiop->uio_iovcnt = i;
744: uiop->uio_offset = off;
745: uiop->uio_resid = cnt;
746: uiop->uio_rw = UIO_READ;
747: uiop->uio_segflg = UIO_SYSSPACE;
748: #if MACH_NBC
749: if (vp->v_type == VREG) {
750: uiop->uio_procp = procp;
751: map_vnode(vp, procp);
752: error = mapfs_io(vp, uiop, uiop->uio_rw,
753: IO_NODELOCKED, cred);
754: unmap_vnode(vp, procp);
755: } else
756: #endif /* MACH_NBC */
757: error = VOP_READ(vp, uiop, IO_NODELOCKED, cred);
758: off = uiop->uio_offset;
759: FREE((caddr_t)iv2, M_TEMP);
760: if (error || (getret = VOP_GETATTR(vp, vap, cred, procp))) {
761: if (!error)
762: error = getret;
763: m_freem(mreq);
764: vput(vp);
765: nfsm_reply(NFSX_POSTOPATTR(v3));
766: nfsm_srvpostop_attr(getret, vap);
767: return (0);
768: }
769: } else
770: uiop->uio_resid = 0;
771: vput(vp);
772: nfsm_srvfillattr(vap, fp);
773: len -= uiop->uio_resid;
774: tlen = nfsm_rndup(len);
775: if (cnt != tlen || tlen != len)
776: nfsm_adj(mb, cnt - tlen, tlen - len);
777: if (v3) {
778: *tl++ = txdr_unsigned(len);
779: if (len < reqlen)
780: *tl++ = nfs_true;
781: else
782: *tl++ = nfs_false;
783: }
784: *tl = txdr_unsigned(len);
785: nfsm_srvdone;
786: }
787:
788: /*
789: * nfs write service
790: */
791: int
792: nfsrv_write(nfsd, slp, procp, mrq)
793: struct nfsrv_descript *nfsd;
794: struct nfssvc_sock *slp;
795: struct proc *procp;
796: struct mbuf **mrq;
797: {
798: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
799: struct mbuf *nam = nfsd->nd_nam;
800: caddr_t dpos = nfsd->nd_dpos;
801: struct ucred *cred = &nfsd->nd_cr;
802: register struct iovec *ivp;
803: register int i, cnt;
804: register struct mbuf *mp;
805: register struct nfs_fattr *fp;
806: struct iovec *iv;
807: struct vattr va, forat;
808: register struct vattr *vap = &va;
809: register u_long *tl;
810: register long t1;
811: caddr_t bpos;
812: int error = 0, rdonly, cache, len, forat_ret = 1;
813: int ioflags, aftat_ret = 1, retlen, zeroing, adjust;
814: int stable = NFSV3WRITE_FILESYNC;
815: int v3 = (nfsd->nd_flag & ND_NFSV3);
816: char *cp2;
817: struct mbuf *mb, *mb2, *mreq;
818: struct vnode *vp;
819: nfsfh_t nfh;
820: fhandle_t *fhp;
821: struct uio io, *uiop = &io;
822: off_t off;
823: u_quad_t frev;
824:
825: if (mrep == NULL) {
826: *mrq = NULL;
827: return (0);
828: }
829: fhp = &nfh.fh_generic;
830: nfsm_srvmtofh(fhp);
831: if (v3) {
832: nfsm_dissect(tl, u_long *, 5 * NFSX_UNSIGNED);
833: fxdr_hyper(tl, &off);
834: tl += 3;
835: stable = fxdr_unsigned(int, *tl++);
836: } else {
837: nfsm_dissect(tl, u_long *, 4 * NFSX_UNSIGNED);
838: off = (off_t)fxdr_unsigned(u_long, *++tl);
839: tl += 2;
840: if (nfs_async)
841: stable = NFSV3WRITE_UNSTABLE;
842: }
843: retlen = len = fxdr_unsigned(long, *tl);
844: cnt = i = 0;
845:
846: /*
847: * For NFS Version 2, it is not obvious what a write of zero length
848: * should do, but I might as well be consistent with Version 3,
849: * which is to return ok so long as there are no permission problems.
850: */
851: if (len > 0) {
852: zeroing = 1;
853: mp = mrep;
854: while (mp) {
855: if (mp == md) {
856: zeroing = 0;
857: adjust = dpos - mtod(mp, caddr_t);
858: mp->m_len -= adjust;
859: if (mp->m_len > 0 && adjust > 0)
860: NFSMADV(mp, adjust);
861: }
862: if (zeroing)
863: mp->m_len = 0;
864: else if (mp->m_len > 0) {
865: i += mp->m_len;
866: if (i > len) {
867: mp->m_len -= (i - len);
868: zeroing = 1;
869: }
870: if (mp->m_len > 0)
871: cnt++;
872: }
873: mp = mp->m_next;
874: }
875: }
876: if (len > NFS_MAXDATA || len < 0 || i < len) {
877: error = EIO;
878: nfsm_reply(2 * NFSX_UNSIGNED);
879: nfsm_srvwcc_data(forat_ret, &forat, aftat_ret, vap);
880: return (0);
881: }
882: if ((error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam,
883: &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE))) {
884: nfsm_reply(2 * NFSX_UNSIGNED);
885: nfsm_srvwcc_data(forat_ret, &forat, aftat_ret, vap);
886: return (0);
887: }
888: if (v3)
889: forat_ret = VOP_GETATTR(vp, &forat, cred, procp);
890: if (vp->v_type != VREG) {
891: if (v3)
892: error = EINVAL;
893: else
894: error = (vp->v_type == VDIR) ? EISDIR : EACCES;
895: }
896: if (!error) {
897: nqsrv_getl(vp, ND_WRITE);
898: error = nfsrv_access(vp, VWRITE, cred, rdonly, procp);
899: }
900: if (error) {
901: vput(vp);
902: nfsm_reply(NFSX_WCCDATA(v3));
903: nfsm_srvwcc_data(forat_ret, &forat, aftat_ret, vap);
904: return (0);
905: }
906:
907: if (len > 0) {
908: MALLOC(ivp, struct iovec *, cnt * sizeof (struct iovec), M_TEMP,
909: M_WAITOK);
910: uiop->uio_iov = iv = ivp;
911: uiop->uio_iovcnt = cnt;
912: mp = mrep;
913: while (mp) {
914: if (mp->m_len > 0) {
915: ivp->iov_base = mtod(mp, caddr_t);
916: ivp->iov_len = mp->m_len;
917: ivp++;
918: }
919: mp = mp->m_next;
920: }
921:
922: /*
923: * XXX
924: * The IO_METASYNC flag indicates that all metadata (and not just
925: * enough to ensure data integrity) mus be written to stable storage
926: * synchronously.
927: * (IO_METASYNC is not yet implemented in 4.4BSD-Lite.)
928: */
929: if (stable == NFSV3WRITE_UNSTABLE)
930: ioflags = IO_NODELOCKED;
931: else if (stable == NFSV3WRITE_DATASYNC)
932: ioflags = (IO_SYNC | IO_NODELOCKED);
933: else
934: ioflags = (IO_METASYNC | IO_SYNC | IO_NODELOCKED);
935: uiop->uio_resid = len;
936: uiop->uio_rw = UIO_WRITE;
937: uiop->uio_segflg = UIO_SYSSPACE;
938: uiop->uio_procp = (struct proc *)0;
939: uiop->uio_offset = off;
940: #if MACH_NBC
941: if (vp->v_type == VREG) {
942: map_vnode(vp, procp);
943: error = mapfs_io(vp, uiop, uiop->uio_rw, ioflags, cred);
944: unmap_vnode(vp, procp);
945: } else
946: #endif /* MACH_NBC */
947: error = VOP_WRITE(vp, uiop, ioflags, cred);
948: nfsstats.srvvop_writes++;
949: FREE((caddr_t)iv, M_TEMP);
950: }
951: aftat_ret = VOP_GETATTR(vp, vap, cred, procp);
952: vput(vp);
953: if (!error)
954: error = aftat_ret;
955: nfsm_reply(NFSX_PREOPATTR(v3) + NFSX_POSTOPORFATTR(v3) +
956: 2 * NFSX_UNSIGNED + NFSX_WRITEVERF(v3));
957: if (v3) {
958: nfsm_srvwcc_data(forat_ret, &forat, aftat_ret, vap);
959: if (error)
960: return (0);
961: nfsm_build(tl, u_long *, 4 * NFSX_UNSIGNED);
962: *tl++ = txdr_unsigned(retlen);
963: /*
964: * If nfs_async is set, then pretend the write was FILESYNC.
965: */
966: if (stable == NFSV3WRITE_UNSTABLE && !nfs_async)
967: *tl++ = txdr_unsigned(stable);
968: else
969: *tl++ = txdr_unsigned(NFSV3WRITE_FILESYNC);
970: /*
971: * Actually, there is no need to txdr these fields,
972: * but it may make the values more human readable,
973: * for debugging purposes.
974: */
975: *tl++ = txdr_unsigned(boottime.tv_sec);
976: *tl = txdr_unsigned(boottime.tv_usec);
977: } else {
978: nfsm_build(fp, struct nfs_fattr *, NFSX_V2FATTR);
979: nfsm_srvfillattr(vap, fp);
980: }
981: nfsm_srvdone;
982: }
983:
984: /*
985: * NFS write service with write gathering support. Called when
986: * nfsrvw_procrastinate > 0.
987: * See: Chet Juszczak, "Improving the Write Performance of an NFS Server",
988: * in Proc. of the Winter 1994 Usenix Conference, pg. 247-259, San Franscisco,
989: * Jan. 1994.
990: */
991: int
992: nfsrv_writegather(ndp, slp, procp, mrq)
993: struct nfsrv_descript **ndp;
994: struct nfssvc_sock *slp;
995: struct proc *procp;
996: struct mbuf **mrq;
997: {
998: register struct iovec *ivp;
999: register struct mbuf *mp;
1000: register struct nfsrv_descript *wp, *nfsd, *owp, *swp;
1001: register struct nfs_fattr *fp;
1002: register int i;
1003: struct iovec *iov;
1004: struct nfsrvw_delayhash *wpp;
1005: struct ucred *cred;
1006: struct vattr va, forat;
1007: register u_long *tl;
1008: register long t1;
1009: caddr_t bpos, dpos;
1010: int error = 0, rdonly, cache, len, forat_ret = 1;
1011: int ioflags, aftat_ret = 1, s, adjust, v3, zeroing;
1012: char *cp2;
1013: struct mbuf *mb, *mb2, *mreq, *mrep, *md;
1014: struct vnode *vp;
1015: struct uio io, *uiop = &io;
1016: u_quad_t frev, cur_usec;
1017:
1018: #ifndef nolint
1019: i = 0;
1020: len = 0;
1021: #endif
1022: *mrq = NULL;
1023: if (*ndp) {
1024: nfsd = *ndp;
1025: *ndp = NULL;
1026: mrep = nfsd->nd_mrep;
1027: md = nfsd->nd_md;
1028: dpos = nfsd->nd_dpos;
1029: cred = &nfsd->nd_cr;
1030: v3 = (nfsd->nd_flag & ND_NFSV3);
1031: LIST_INIT(&nfsd->nd_coalesce);
1032: nfsd->nd_mreq = NULL;
1033: nfsd->nd_stable = NFSV3WRITE_FILESYNC;
1034: cur_usec = (u_quad_t)time.tv_sec * 1000000 + (u_quad_t)time.tv_usec;
1035: nfsd->nd_time = cur_usec +
1036: (v3 ? nfsrvw_procrastinate_v3 : nfsrvw_procrastinate);
1037:
1038: /*
1039: * Now, get the write header..
1040: */
1041: nfsm_srvmtofh(&nfsd->nd_fh);
1042: if (v3) {
1043: nfsm_dissect(tl, u_long *, 5 * NFSX_UNSIGNED);
1044: fxdr_hyper(tl, &nfsd->nd_off);
1045: tl += 3;
1046: nfsd->nd_stable = fxdr_unsigned(int, *tl++);
1047: } else {
1048: nfsm_dissect(tl, u_long *, 4 * NFSX_UNSIGNED);
1049: nfsd->nd_off = (off_t)fxdr_unsigned(u_long, *++tl);
1050: tl += 2;
1051: if (nfs_async)
1052: nfsd->nd_stable = NFSV3WRITE_UNSTABLE;
1053: }
1054: len = fxdr_unsigned(long, *tl);
1055: nfsd->nd_len = len;
1056: nfsd->nd_eoff = nfsd->nd_off + len;
1057:
1058: /*
1059: * Trim the header out of the mbuf list and trim off any trailing
1060: * junk so that the mbuf list has only the write data.
1061: */
1062: zeroing = 1;
1063: i = 0;
1064: mp = mrep;
1065: while (mp) {
1066: if (mp == md) {
1067: zeroing = 0;
1068: adjust = dpos - mtod(mp, caddr_t);
1069: mp->m_len -= adjust;
1070: if (mp->m_len > 0 && adjust > 0)
1071: NFSMADV(mp, adjust);
1072: }
1073: if (zeroing)
1074: mp->m_len = 0;
1075: else {
1076: i += mp->m_len;
1077: if (i > len) {
1078: mp->m_len -= (i - len);
1079: zeroing = 1;
1080: }
1081: }
1082: mp = mp->m_next;
1083: }
1084: if (len > NFS_MAXDATA || len < 0 || i < len) {
1085: nfsmout:
1086: m_freem(mrep);
1087: error = EIO;
1088: nfsm_writereply(2 * NFSX_UNSIGNED, v3);
1089: if (v3)
1090: nfsm_srvwcc_data(forat_ret, &forat, aftat_ret, &va);
1091: nfsd->nd_mreq = mreq;
1092: nfsd->nd_mrep = NULL;
1093: nfsd->nd_time = 0;
1094: }
1095:
1096: /*
1097: * Add this entry to the hash and time queues.
1098: */
1099: s = splsoftclock();
1100: owp = NULL;
1101: wp = slp->ns_tq.lh_first;
1102: while (wp && wp->nd_time < nfsd->nd_time) {
1103: owp = wp;
1104: wp = wp->nd_tq.le_next;
1105: }
1106: NFS_DPF(WG, ("Q%03x", nfsd->nd_retxid & 0xfff));
1107: if (owp) {
1108: LIST_INSERT_AFTER(owp, nfsd, nd_tq);
1109: } else {
1110: LIST_INSERT_HEAD(&slp->ns_tq, nfsd, nd_tq);
1111: }
1112: if (nfsd->nd_mrep) {
1113: wpp = NWDELAYHASH(slp, nfsd->nd_fh.fh_fid.fid_data);
1114: owp = NULL;
1115: wp = wpp->lh_first;
1116: while (wp &&
1117: bcmp((caddr_t)&nfsd->nd_fh,(caddr_t)&wp->nd_fh,NFSX_V3FH)) {
1118: owp = wp;
1119: wp = wp->nd_hash.le_next;
1120: }
1121: while (wp && wp->nd_off < nfsd->nd_off &&
1122: !bcmp((caddr_t)&nfsd->nd_fh,(caddr_t)&wp->nd_fh,NFSX_V3FH)) {
1123: owp = wp;
1124: wp = wp->nd_hash.le_next;
1125: }
1126: if (owp) {
1127: LIST_INSERT_AFTER(owp, nfsd, nd_hash);
1128:
1129: /*
1130: * Search the hash list for overlapping entries and
1131: * coalesce.
1132: */
1133: for(; nfsd && NFSW_CONTIG(owp, nfsd); nfsd = wp) {
1134: wp = nfsd->nd_hash.le_next;
1135: if (NFSW_SAMECRED(owp, nfsd))
1136: nfsrvw_coalesce(owp, nfsd);
1137: }
1138: } else {
1139: LIST_INSERT_HEAD(wpp, nfsd, nd_hash);
1140: }
1141: }
1142: splx(s);
1143: }
1144:
1145: /*
1146: * Now, do VOP_WRITE()s for any one(s) that need to be done now
1147: * and generate the associated reply mbuf list(s).
1148: */
1149: loop1:
1150: cur_usec = (u_quad_t)time.tv_sec * 1000000 + (u_quad_t)time.tv_usec;
1151: s = splsoftclock();
1152: for (nfsd = slp->ns_tq.lh_first; nfsd; nfsd = owp) {
1153: owp = nfsd->nd_tq.le_next;
1154: if (nfsd->nd_time > cur_usec)
1155: break;
1156: if (nfsd->nd_mreq)
1157: continue;
1158: NFS_DPF(WG, ("P%03x", nfsd->nd_retxid & 0xfff));
1159: LIST_REMOVE(nfsd, nd_tq);
1160: LIST_REMOVE(nfsd, nd_hash);
1161: splx(s);
1162: mrep = nfsd->nd_mrep;
1163: nfsd->nd_mrep = NULL;
1164: cred = &nfsd->nd_cr;
1165: v3 = (nfsd->nd_flag & ND_NFSV3);
1166: forat_ret = aftat_ret = 1;
1167: error = nfsrv_fhtovp(&nfsd->nd_fh, 1, &vp, cred, slp,
1168: nfsd->nd_nam, &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE);
1169: if (!error) {
1170: if (v3)
1171: forat_ret = VOP_GETATTR(vp, &forat, cred, procp);
1172: if (vp->v_type != VREG) {
1173: if (v3)
1174: error = EINVAL;
1175: else
1176: error = (vp->v_type == VDIR) ? EISDIR : EACCES;
1177: }
1178: } else
1179: vp = NULL;
1180: if (!error) {
1181: nqsrv_getl(vp, ND_WRITE);
1182: error = nfsrv_access(vp, VWRITE, cred, rdonly, procp);
1183: }
1184:
1185: if (nfsd->nd_stable == NFSV3WRITE_UNSTABLE)
1186: ioflags = IO_NODELOCKED;
1187: else if (nfsd->nd_stable == NFSV3WRITE_DATASYNC)
1188: ioflags = (IO_SYNC | IO_NODELOCKED);
1189: else
1190: ioflags = (IO_METASYNC | IO_SYNC | IO_NODELOCKED);
1191: uiop->uio_rw = UIO_WRITE;
1192: uiop->uio_segflg = UIO_SYSSPACE;
1193: uiop->uio_procp = (struct proc *)0;
1194: uiop->uio_offset = nfsd->nd_off;
1195: uiop->uio_resid = nfsd->nd_eoff - nfsd->nd_off;
1196: if (uiop->uio_resid > 0) {
1197: mp = mrep;
1198: i = 0;
1199: while (mp) {
1200: if (mp->m_len > 0)
1201: i++;
1202: mp = mp->m_next;
1203: }
1204: uiop->uio_iovcnt = i;
1205: MALLOC(iov, struct iovec *, i * sizeof (struct iovec),
1206: M_TEMP, M_WAITOK);
1207: uiop->uio_iov = ivp = iov;
1208: mp = mrep;
1209: while (mp) {
1210: if (mp->m_len > 0) {
1211: ivp->iov_base = mtod(mp, caddr_t);
1212: ivp->iov_len = mp->m_len;
1213: ivp++;
1214: }
1215: mp = mp->m_next;
1216: }
1217: if (!error) {
1218: #if MACH_NBC
1219: if (vp->v_type == VREG) {
1220: map_vnode(vp, procp);
1221: error = mapfs_io(vp, uiop, uiop->uio_rw,
1222: ioflags, cred);
1223: unmap_vnode(vp, procp);
1224: } else
1225: #endif /* MACH_NBC */
1226: error = VOP_WRITE(vp, uiop, ioflags, cred);
1227: nfsstats.srvvop_writes++;
1228: }
1229: FREE((caddr_t)iov, M_TEMP);
1230: }
1231: m_freem(mrep);
1232: if (vp) {
1233: aftat_ret = VOP_GETATTR(vp, &va, cred, procp);
1234: vput(vp);
1235: }
1236:
1237: /*
1238: * Loop around generating replies for all write rpcs that have
1239: * now been completed.
1240: */
1241: swp = nfsd;
1242: do {
1243: NFS_DPF(WG, ("R%03x", nfsd->nd_retxid & 0xfff));
1244: if (error) {
1245: nfsm_writereply(NFSX_WCCDATA(v3), v3);
1246: if (v3) {
1247: nfsm_srvwcc_data(forat_ret, &forat, aftat_ret, &va);
1248: }
1249: } else {
1250: nfsm_writereply(NFSX_PREOPATTR(v3) +
1251: NFSX_POSTOPORFATTR(v3) + 2 * NFSX_UNSIGNED +
1252: NFSX_WRITEVERF(v3), v3);
1253: if (v3) {
1254: nfsm_srvwcc_data(forat_ret, &forat, aftat_ret, &va);
1255: nfsm_build(tl, u_long *, 4 * NFSX_UNSIGNED);
1256: *tl++ = txdr_unsigned(nfsd->nd_len);
1257: *tl++ = txdr_unsigned(swp->nd_stable);
1258: /*
1259: * Actually, there is no need to txdr these fields,
1260: * but it may make the values more human readable,
1261: * for debugging purposes.
1262: */
1263: *tl++ = txdr_unsigned(boottime.tv_sec);
1264: *tl = txdr_unsigned(boottime.tv_usec);
1265: } else {
1266: nfsm_build(fp, struct nfs_fattr *, NFSX_V2FATTR);
1267: nfsm_srvfillattr(&va, fp);
1268: }
1269: }
1270: nfsd->nd_mreq = mreq;
1271: if (nfsd->nd_mrep)
1272: panic("nfsrv_write: nd_mrep not free");
1273:
1274: /*
1275: * Done. Put it at the head of the timer queue so that
1276: * the final phase can return the reply.
1277: */
1278: s = splsoftclock();
1279: if (nfsd != swp) {
1280: nfsd->nd_time = 0;
1281: LIST_INSERT_HEAD(&slp->ns_tq, nfsd, nd_tq);
1282: }
1283: nfsd = swp->nd_coalesce.lh_first;
1284: if (nfsd) {
1285: LIST_REMOVE(nfsd, nd_tq);
1286: }
1287: splx(s);
1288: } while (nfsd);
1289: s = splsoftclock();
1290: swp->nd_time = 0;
1291: LIST_INSERT_HEAD(&slp->ns_tq, swp, nd_tq);
1292: splx(s);
1293: goto loop1;
1294: }
1295: splx(s);
1296:
1297: /*
1298: * Search for a reply to return.
1299: */
1300: s = splsoftclock();
1301: for (nfsd = slp->ns_tq.lh_first; nfsd; nfsd = nfsd->nd_tq.le_next)
1302: if (nfsd->nd_mreq) {
1303: NFS_DPF(WG, ("X%03x", nfsd->nd_retxid & 0xfff));
1304: LIST_REMOVE(nfsd, nd_tq);
1305: *mrq = nfsd->nd_mreq;
1306: *ndp = nfsd;
1307: break;
1308: }
1309: splx(s);
1310: return (0);
1311: }
1312:
1313: /*
1314: * Coalesce the write request nfsd into owp. To do this we must:
1315: * - remove nfsd from the queues
1316: * - merge nfsd->nd_mrep into owp->nd_mrep
1317: * - update the nd_eoff and nd_stable for owp
1318: * - put nfsd on owp's nd_coalesce list
1319: * NB: Must be called at splsoftclock().
1320: */
1321: static void
1322: nfsrvw_coalesce(owp, nfsd)
1323: register struct nfsrv_descript *owp;
1324: register struct nfsrv_descript *nfsd;
1325: {
1326: register int overlap;
1327: register struct mbuf *mp;
1328: struct nfsrv_descript *p;
1329:
1330: NFS_DPF(WG, ("C%03x-%03x",
1331: nfsd->nd_retxid & 0xfff, owp->nd_retxid & 0xfff));
1332: LIST_REMOVE(nfsd, nd_hash);
1333: LIST_REMOVE(nfsd, nd_tq);
1334: if (owp->nd_eoff < nfsd->nd_eoff) {
1335: overlap = owp->nd_eoff - nfsd->nd_off;
1336: if (overlap < 0)
1337: panic("nfsrv_coalesce: bad off");
1338: if (overlap > 0)
1339: m_adj(nfsd->nd_mrep, overlap);
1340: mp = owp->nd_mrep;
1341: while (mp->m_next)
1342: mp = mp->m_next;
1343: mp->m_next = nfsd->nd_mrep;
1344: owp->nd_eoff = nfsd->nd_eoff;
1345: } else
1346: m_freem(nfsd->nd_mrep);
1347: nfsd->nd_mrep = NULL;
1348: if (nfsd->nd_stable == NFSV3WRITE_FILESYNC)
1349: owp->nd_stable = NFSV3WRITE_FILESYNC;
1350: else if (nfsd->nd_stable == NFSV3WRITE_DATASYNC &&
1351: owp->nd_stable == NFSV3WRITE_UNSTABLE)
1352: owp->nd_stable = NFSV3WRITE_DATASYNC;
1353: LIST_INSERT_HEAD(&owp->nd_coalesce, nfsd, nd_tq);
1354:
1355: /*
1356: * If nfsd had anything else coalesced into it, transfer them
1357: * to owp, otherwise their replies will never get sent.
1358: */
1359: for (p = nfsd->nd_coalesce.lh_first; p;
1360: p = nfsd->nd_coalesce.lh_first) {
1361: LIST_REMOVE(p, nd_tq);
1362: LIST_INSERT_HEAD(&owp->nd_coalesce, p, nd_tq);
1363: }
1364: }
1365:
1366: /*
1367: * Sort the group list in increasing numerical order.
1368: * (Insertion sort by Chris Torek, who was grossed out by the bubble sort
1369: * that used to be here.)
1370: */
1371: void
1372: nfsrvw_sort(list, num)
1373: register gid_t *list;
1374: register int num;
1375: {
1376: register int i, j;
1377: gid_t v;
1378:
1379: /* Insertion sort. */
1380: for (i = 1; i < num; i++) {
1381: v = list[i];
1382: /* find correct slot for value v, moving others up */
1383: for (j = i; --j >= 0 && v < list[j];)
1384: list[j + 1] = list[j];
1385: list[j + 1] = v;
1386: }
1387: }
1388:
1389: /*
1390: * copy credentials making sure that the result can be compared with bcmp().
1391: */
1392: void
1393: nfsrv_setcred(incred, outcred)
1394: register struct ucred *incred, *outcred;
1395: {
1396: register int i;
1397:
1398: bzero((caddr_t)outcred, sizeof (struct ucred));
1399: outcred->cr_ref = 1;
1400: outcred->cr_uid = incred->cr_uid;
1401: outcred->cr_ngroups = incred->cr_ngroups;
1402: for (i = 0; i < incred->cr_ngroups; i++)
1403: outcred->cr_groups[i] = incred->cr_groups[i];
1404: nfsrvw_sort(outcred->cr_groups, outcred->cr_ngroups);
1405: }
1406:
1407: /*
1408: * nfs create service
1409: * now does a truncate to 0 length via. setattr if it already exists
1410: */
1411: int
1412: nfsrv_create(nfsd, slp, procp, mrq)
1413: struct nfsrv_descript *nfsd;
1414: struct nfssvc_sock *slp;
1415: struct proc *procp;
1416: struct mbuf **mrq;
1417: {
1418: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
1419: struct mbuf *nam = nfsd->nd_nam;
1420: caddr_t dpos = nfsd->nd_dpos;
1421: struct ucred *cred = &nfsd->nd_cr;
1422: register struct nfs_fattr *fp;
1423: struct vattr va, dirfor, diraft;
1424: register struct vattr *vap = &va;
1425: register struct nfsv2_sattr *sp;
1426: register u_long *tl;
1427: struct nameidata nd;
1428: register caddr_t cp;
1429: register long t1;
1430: caddr_t bpos;
1431: int error = 0, rdev, cache, len, tsize, dirfor_ret = 1, diraft_ret = 1;
1432: int v3 = (nfsd->nd_flag & ND_NFSV3), how, exclusive_flag = 0;
1433: char *cp2;
1434: struct mbuf *mb, *mb2, *mreq;
1435: struct vnode *vp, *dirp = (struct vnode *)0;
1436: nfsfh_t nfh;
1437: fhandle_t *fhp;
1438: u_quad_t frev, tempsize;
1439: u_char cverf[NFSX_V3CREATEVERF];
1440:
1441: #ifndef nolint
1442: rdev = 0;
1443: #endif
1444: nd.ni_cnd.cn_nameiop = 0;
1445: fhp = &nfh.fh_generic;
1446: nfsm_srvmtofh(fhp);
1447: nfsm_srvnamesiz(len);
1448: nd.ni_cnd.cn_cred = cred;
1449: nd.ni_cnd.cn_nameiop = CREATE;
1450: nd.ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF | SAVESTART;
1451: error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos,
1452: &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE);
1453: if (dirp) {
1454: if (v3)
1455: dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred,
1456: procp);
1457: else {
1458: vrele(dirp);
1459: dirp = (struct vnode *)0;
1460: }
1461: }
1462: if (error) {
1463: nfsm_reply(NFSX_WCCDATA(v3));
1464: nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
1465: if (dirp)
1466: vrele(dirp);
1467: return (0);
1468: }
1469: VATTR_NULL(vap);
1470: if (v3) {
1471: nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
1472: how = fxdr_unsigned(int, *tl);
1473: switch (how) {
1474: case NFSV3CREATE_GUARDED:
1475: if (nd.ni_vp) {
1476: error = EEXIST;
1477: break;
1478: }
1479: case NFSV3CREATE_UNCHECKED:
1480: nfsm_srvsattr(vap);
1481: break;
1482: case NFSV3CREATE_EXCLUSIVE:
1483: nfsm_dissect(cp, caddr_t, NFSX_V3CREATEVERF);
1484: bcopy(cp, cverf, NFSX_V3CREATEVERF);
1485: exclusive_flag = 1;
1486: if (nd.ni_vp == NULL)
1487: vap->va_mode = 0;
1488: break;
1489: };
1490: vap->va_type = VREG;
1491: } else {
1492: nfsm_dissect(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
1493: vap->va_type = IFTOVT(fxdr_unsigned(u_long, sp->sa_mode));
1494: if (vap->va_type == VNON)
1495: vap->va_type = VREG;
1496: vap->va_mode = nfstov_mode(sp->sa_mode);
1497: switch (vap->va_type) {
1498: case VREG:
1499: tsize = fxdr_unsigned(long, sp->sa_size);
1500: if (tsize != -1)
1501: vap->va_size = (u_quad_t)tsize;
1502: break;
1503: case VCHR:
1504: case VBLK:
1505: case VFIFO:
1506: rdev = fxdr_unsigned(long, sp->sa_size);
1507: break;
1508: };
1509: }
1510:
1511: /*
1512: * Iff doesn't exist, create it
1513: * otherwise just truncate to 0 length
1514: * should I set the mode too ??
1515: */
1516: if (nd.ni_vp == NULL) {
1517: if (vap->va_type == VREG || vap->va_type == VSOCK) {
1518: vrele(nd.ni_startdir);
1519: nqsrv_getl(nd.ni_dvp, ND_WRITE);
1520: error = VOP_CREATE(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, vap);
1521: if (!error) {
1522: nfsrv_object_create(nd.ni_vp);
1523: FREE_ZONE(nd.ni_cnd.cn_pnbuf,
1524: nd.ni_cnd.cn_pnlen, M_NAMEI);
1525: if (exclusive_flag) {
1526: exclusive_flag = 0;
1527: VATTR_NULL(vap);
1528: bcopy(cverf, (caddr_t)&vap->va_atime,
1529: NFSX_V3CREATEVERF);
1530: error = VOP_SETATTR(nd.ni_vp, vap, cred,
1531: procp);
1532: }
1533: }
1534: } else if (vap->va_type == VCHR || vap->va_type == VBLK ||
1535: vap->va_type == VFIFO) {
1536: if (vap->va_type == VCHR && rdev == 0xffffffff)
1537: vap->va_type = VFIFO;
1538: if (vap->va_type != VFIFO &&
1539: (error = suser(cred, (u_short *)0))) {
1540: vrele(nd.ni_startdir);
1541: _FREE_ZONE(nd.ni_cnd.cn_pnbuf,
1542: nd.ni_cnd.cn_pnlen, M_NAMEI);
1543: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
1544: vput(nd.ni_dvp);
1545: nfsm_reply(0);
1546: return (error);
1547: } else
1548: vap->va_rdev = (dev_t)rdev;
1549: nqsrv_getl(nd.ni_dvp, ND_WRITE);
1550: if ((error = VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, vap))) {
1551: vrele(nd.ni_startdir);
1552: nfsm_reply(0);
1553: }
1554: nd.ni_cnd.cn_nameiop = LOOKUP;
1555: nd.ni_cnd.cn_flags &= ~(LOCKPARENT | SAVESTART);
1556: nd.ni_cnd.cn_proc = procp;
1557: nd.ni_cnd.cn_cred = cred;
1558: if ((error = lookup(&nd))) {
1559: _FREE_ZONE(nd.ni_cnd.cn_pnbuf,
1560: nd.ni_cnd.cn_pnlen, M_NAMEI);
1561: nfsm_reply(0);
1562: }
1563: nfsrv_object_create(nd.ni_vp);
1564: FREE_ZONE(nd.ni_cnd.cn_pnbuf,
1565: nd.ni_cnd.cn_pnlen, M_NAMEI);
1566: if (nd.ni_cnd.cn_flags & ISSYMLINK) {
1567: vrele(nd.ni_dvp);
1568: vput(nd.ni_vp);
1569: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
1570: error = EINVAL;
1571: nfsm_reply(0);
1572: }
1573: } else {
1574: vrele(nd.ni_startdir);
1575: _FREE_ZONE(nd.ni_cnd.cn_pnbuf,
1576: nd.ni_cnd.cn_pnlen, M_NAMEI);
1577: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
1578: vput(nd.ni_dvp);
1579: error = ENXIO;
1580: }
1581: vp = nd.ni_vp;
1582: } else {
1583: vrele(nd.ni_startdir);
1584: _FREE_ZONE(nd.ni_cnd.cn_pnbuf, nd.ni_cnd.cn_pnlen, M_NAMEI);
1585: vp = nd.ni_vp;
1586: if (nd.ni_dvp == vp)
1587: vrele(nd.ni_dvp);
1588: else
1589: vput(nd.ni_dvp);
1590: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
1591: if (vap->va_size != -1) {
1592: error = nfsrv_access(vp, VWRITE, cred,
1593: (nd.ni_cnd.cn_flags & RDONLY), procp);
1594: if (!error) {
1595: nqsrv_getl(vp, ND_WRITE);
1596: tempsize = vap->va_size;
1597: VATTR_NULL(vap);
1598: vap->va_size = tempsize;
1599: error = VOP_SETATTR(vp, vap, cred,
1600: procp);
1601: }
1602: if (error)
1603: vput(vp);
1604: } else {
1605: if (error)
1606: vput(vp); /* make sure we catch the EEXIST for nfsv3 */
1607: }
1608: }
1609: if (!error) {
1610: bzero((caddr_t)fhp, sizeof(nfh));
1611: fhp->fh_fsid = vp->v_mount->mnt_stat.f_fsid;
1612: error = VFS_VPTOFH(vp, &fhp->fh_fid);
1613: if (!error)
1614: error = VOP_GETATTR(vp, vap, cred, procp);
1615: vput(vp);
1616: }
1617: if (v3) {
1618: if (exclusive_flag && !error &&
1619: bcmp(cverf, (caddr_t)&vap->va_atime, NFSX_V3CREATEVERF))
1620: error = EEXIST;
1621: diraft_ret = VOP_GETATTR(dirp, &diraft, cred, procp);
1622: vrele(dirp);
1623: }
1624: nfsm_reply(NFSX_SRVFH(v3) + NFSX_FATTR(v3) + NFSX_WCCDATA(v3));
1625: if (v3) {
1626: if (!error) {
1627: nfsm_srvpostop_fh(fhp);
1628: nfsm_srvpostop_attr(0, vap);
1629: }
1630: nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
1631: } else {
1632: nfsm_srvfhtom(fhp, v3);
1633: nfsm_build(fp, struct nfs_fattr *, NFSX_V2FATTR);
1634: nfsm_srvfillattr(vap, fp);
1635: }
1636: return (error);
1637: nfsmout:
1638: if (dirp)
1639: vrele(dirp);
1640: if (nd.ni_cnd.cn_nameiop) {
1641: vrele(nd.ni_startdir);
1642: _FREE_ZONE((caddr_t)nd.ni_cnd.cn_pnbuf,
1643: nd.ni_cnd.cn_pnlen, M_NAMEI);
1644: }
1645: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
1646: if (nd.ni_dvp == nd.ni_vp)
1647: vrele(nd.ni_dvp);
1648: else
1649: vput(nd.ni_dvp);
1650: if (nd.ni_vp)
1651: vput(nd.ni_vp);
1652: return (error);
1653: }
1654:
1655: /*
1656: * nfs v3 mknod service
1657: */
1658: int
1659: nfsrv_mknod(nfsd, slp, procp, mrq)
1660: struct nfsrv_descript *nfsd;
1661: struct nfssvc_sock *slp;
1662: struct proc *procp;
1663: struct mbuf **mrq;
1664: {
1665: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
1666: struct mbuf *nam = nfsd->nd_nam;
1667: caddr_t dpos = nfsd->nd_dpos;
1668: struct ucred *cred = &nfsd->nd_cr;
1669: struct vattr va, dirfor, diraft;
1670: register struct vattr *vap = &va;
1671: register u_long *tl;
1672: struct nameidata nd;
1673: register long t1;
1674: caddr_t bpos;
1675: int error = 0, cache, len, dirfor_ret = 1, diraft_ret = 1;
1676: u_long major, minor;
1677: enum vtype vtyp;
1678: char *cp2;
1679: struct mbuf *mb, *mb2, *mreq;
1680: struct vnode *vp, *dirp = (struct vnode *)0;
1681: nfsfh_t nfh;
1682: fhandle_t *fhp;
1683: u_quad_t frev;
1684:
1685: nd.ni_cnd.cn_nameiop = 0;
1686: fhp = &nfh.fh_generic;
1687: nfsm_srvmtofh(fhp);
1688: nfsm_srvnamesiz(len);
1689: nd.ni_cnd.cn_cred = cred;
1690: nd.ni_cnd.cn_nameiop = CREATE;
1691: nd.ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF | SAVESTART;
1692: error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos,
1693: &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE);
1694: if (dirp)
1695: dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred, procp);
1696: if (error) {
1697: nfsm_reply(NFSX_WCCDATA(1));
1698: nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
1699: if (dirp)
1700: vrele(dirp);
1701: return (0);
1702: }
1703: nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
1704: vtyp = nfsv3tov_type(*tl);
1705: if (vtyp != VCHR && vtyp != VBLK && vtyp != VSOCK && vtyp != VFIFO) {
1706: vrele(nd.ni_startdir);
1707: _FREE_ZONE((caddr_t)nd.ni_cnd.cn_pnbuf,
1708: nd.ni_cnd.cn_pnlen, M_NAMEI);
1709: error = NFSERR_BADTYPE;
1710: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
1711: vput(nd.ni_dvp);
1712: goto out;
1713: }
1714: VATTR_NULL(vap);
1715: nfsm_srvsattr(vap);
1716: if (vtyp == VCHR || vtyp == VBLK) {
1717: nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED);
1718: major = fxdr_unsigned(u_long, *tl++);
1719: minor = fxdr_unsigned(u_long, *tl);
1720: vap->va_rdev = makedev(major, minor);
1721: }
1722:
1723: /*
1724: * Iff doesn't exist, create it.
1725: */
1726: if (nd.ni_vp) {
1727: vrele(nd.ni_startdir);
1728: _FREE_ZONE((caddr_t)nd.ni_cnd.cn_pnbuf,
1729: nd.ni_cnd.cn_pnlen, M_NAMEI);
1730: error = EEXIST;
1731: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
1732: vput(nd.ni_dvp);
1733: goto out;
1734: }
1735: vap->va_type = vtyp;
1736: if (vtyp == VSOCK) {
1737: vrele(nd.ni_startdir);
1738: nqsrv_getl(nd.ni_dvp, ND_WRITE);
1739: error = VOP_CREATE(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, vap);
1740: if (!error)
1741: FREE_ZONE(nd.ni_cnd.cn_pnbuf,
1742: nd.ni_cnd.cn_pnlen, M_NAMEI);
1743: } else {
1744: if (vtyp != VFIFO && (error = suser(cred, (u_short *)0))) {
1745: vrele(nd.ni_startdir);
1746: _FREE_ZONE((caddr_t)nd.ni_cnd.cn_pnbuf,
1747: nd.ni_cnd.cn_pnlen, M_NAMEI);
1748: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
1749: vput(nd.ni_dvp);
1750: goto out;
1751: }
1752: nqsrv_getl(nd.ni_dvp, ND_WRITE);
1753: if ((error = VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, vap))) {
1754: vrele(nd.ni_startdir);
1755: goto out;
1756: }
1757: nd.ni_cnd.cn_nameiop = LOOKUP;
1758: nd.ni_cnd.cn_flags &= ~(LOCKPARENT | SAVESTART);
1759: nd.ni_cnd.cn_proc = procp;
1760: nd.ni_cnd.cn_cred = procp->p_ucred;
1761: error = lookup(&nd);
1762: FREE_ZONE(nd.ni_cnd.cn_pnbuf, nd.ni_cnd.cn_pnlen, M_NAMEI);
1763: if (error)
1764: goto out;
1765: if (nd.ni_cnd.cn_flags & ISSYMLINK) {
1766: vrele(nd.ni_dvp);
1767: vput(nd.ni_vp);
1768: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
1769: error = EINVAL;
1770: }
1771: }
1772: out:
1773: vp = nd.ni_vp;
1774: if (!error) {
1775: bzero((caddr_t)fhp, sizeof(nfh));
1776: fhp->fh_fsid = vp->v_mount->mnt_stat.f_fsid;
1777: error = VFS_VPTOFH(vp, &fhp->fh_fid);
1778: if (!error)
1779: error = VOP_GETATTR(vp, vap, cred, procp);
1780: vput(vp);
1781: }
1782: diraft_ret = VOP_GETATTR(dirp, &diraft, cred, procp);
1783: vrele(dirp);
1784: nfsm_reply(NFSX_SRVFH(1) + NFSX_POSTOPATTR(1) + NFSX_WCCDATA(1));
1785: if (!error) {
1786: nfsm_srvpostop_fh(fhp);
1787: nfsm_srvpostop_attr(0, vap);
1788: }
1789: nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
1790: return (0);
1791: nfsmout:
1792: if (dirp)
1793: vrele(dirp);
1794: if (nd.ni_cnd.cn_nameiop) {
1795: vrele(nd.ni_startdir);
1796: _FREE_ZONE((caddr_t)nd.ni_cnd.cn_pnbuf,
1797: nd.ni_cnd.cn_pnlen, M_NAMEI);
1798: }
1799: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
1800: if (nd.ni_dvp == nd.ni_vp)
1801: vrele(nd.ni_dvp);
1802: else
1803: vput(nd.ni_dvp);
1804: if (nd.ni_vp)
1805: vput(nd.ni_vp);
1806: return (error);
1807: }
1808:
1809: /*
1810: * nfs remove service
1811: */
1812: int
1813: nfsrv_remove(nfsd, slp, procp, mrq)
1814: struct nfsrv_descript *nfsd;
1815: struct nfssvc_sock *slp;
1816: struct proc *procp;
1817: struct mbuf **mrq;
1818: {
1819: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
1820: struct mbuf *nam = nfsd->nd_nam;
1821: caddr_t dpos = nfsd->nd_dpos;
1822: struct ucred *cred = &nfsd->nd_cr;
1823: struct nameidata nd;
1824: register u_long *tl;
1825: register long t1;
1826: caddr_t bpos;
1827: int error = 0, cache, len, dirfor_ret = 1, diraft_ret = 1;
1828: int v3 = (nfsd->nd_flag & ND_NFSV3);
1829: char *cp2;
1830: struct mbuf *mb, *mreq;
1831: struct vnode *vp, *dirp;
1832: struct vattr dirfor, diraft;
1833: nfsfh_t nfh;
1834: fhandle_t *fhp;
1835: u_quad_t frev;
1836:
1837: #ifndef nolint
1838: vp = (struct vnode *)0;
1839: #endif
1840: fhp = &nfh.fh_generic;
1841: nfsm_srvmtofh(fhp);
1842: nfsm_srvnamesiz(len);
1843: nd.ni_cnd.cn_cred = cred;
1844: nd.ni_cnd.cn_nameiop = DELETE;
1845: nd.ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF;
1846: error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos,
1847: &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE);
1848: if (dirp) {
1849: if (v3)
1850: dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred,
1851: procp);
1852: else
1853: vrele(dirp);
1854: }
1855: if (!error) {
1856: vp = nd.ni_vp;
1857: if (vp->v_type == VDIR) {
1858: error = EPERM; /* POSIX */
1859: goto out;
1860: }
1861: /*
1862: * The root of a mounted filesystem cannot be deleted.
1863: */
1864: if (vp->v_flag & VROOT) {
1865: error = EBUSY;
1866: goto out;
1867: }
1868: out:
1869: if (!error) {
1870: (void) vnode_uncache(vp);
1871: nqsrv_getl(nd.ni_dvp, ND_WRITE);
1872: nqsrv_getl(vp, ND_WRITE);
1873:
1874: error = VOP_REMOVE(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd);
1875:
1876: } else {
1877: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
1878: if (nd.ni_dvp == vp)
1879: vrele(nd.ni_dvp);
1880: else
1881: vput(nd.ni_dvp);
1882: vput(vp);
1883: }
1884: }
1885: if (dirp && v3) {
1886: diraft_ret = VOP_GETATTR(dirp, &diraft, cred, procp);
1887: vrele(dirp);
1888: }
1889: nfsm_reply(NFSX_WCCDATA(v3));
1890: if (v3) {
1891: nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
1892: return (0);
1893: }
1894: nfsm_srvdone;
1895: }
1896:
1897: /*
1898: * nfs rename service
1899: */
1900: int
1901: nfsrv_rename(nfsd, slp, procp, mrq)
1902: struct nfsrv_descript *nfsd;
1903: struct nfssvc_sock *slp;
1904: struct proc *procp;
1905: struct mbuf **mrq;
1906: {
1907: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
1908: struct mbuf *nam = nfsd->nd_nam;
1909: caddr_t dpos = nfsd->nd_dpos;
1910: struct ucred *cred = &nfsd->nd_cr;
1911: register u_long *tl;
1912: register long t1;
1913: caddr_t bpos;
1914: int error = 0, cache, len, len2, fdirfor_ret = 1, fdiraft_ret = 1;
1915: int tdirfor_ret = 1, tdiraft_ret = 1;
1916: int v3 = (nfsd->nd_flag & ND_NFSV3);
1917: char *cp2;
1918: struct mbuf *mb, *mreq;
1919: struct nameidata fromnd, tond;
1920: struct vnode *fvp, *tvp, *tdvp, *fdirp = (struct vnode *)0;
1921: struct vnode *tdirp = (struct vnode *)0;
1922: struct vattr fdirfor, fdiraft, tdirfor, tdiraft;
1923: nfsfh_t fnfh, tnfh;
1924: fhandle_t *ffhp, *tfhp;
1925: u_quad_t frev;
1926: uid_t saved_uid;
1927:
1928: #ifndef nolint
1929: fvp = (struct vnode *)0;
1930: #endif
1931: ffhp = &fnfh.fh_generic;
1932: tfhp = &tnfh.fh_generic;
1933: fromnd.ni_cnd.cn_nameiop = 0;
1934: tond.ni_cnd.cn_nameiop = 0;
1935: nfsm_srvmtofh(ffhp);
1936: nfsm_srvnamesiz(len);
1937: /*
1938: * Remember our original uid so that we can reset cr_uid before
1939: * the second nfs_namei() call, in case it is remapped.
1940: */
1941: saved_uid = cred->cr_uid;
1942: fromnd.ni_cnd.cn_cred = cred;
1943: fromnd.ni_cnd.cn_nameiop = DELETE;
1944: fromnd.ni_cnd.cn_flags = WANTPARENT | SAVESTART;
1945: error = nfs_namei(&fromnd, ffhp, len, slp, nam, &md,
1946: &dpos, &fdirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE);
1947: if (fdirp) {
1948: if (v3)
1949: fdirfor_ret = VOP_GETATTR(fdirp, &fdirfor, cred,
1950: procp);
1951: else {
1952: vrele(fdirp);
1953: fdirp = (struct vnode *)0;
1954: }
1955: }
1956: if (error) {
1957: nfsm_reply(2 * NFSX_WCCDATA(v3));
1958: nfsm_srvwcc_data(fdirfor_ret, &fdirfor, fdiraft_ret, &fdiraft);
1959: nfsm_srvwcc_data(tdirfor_ret, &tdirfor, tdiraft_ret, &tdiraft);
1960: if (fdirp)
1961: vrele(fdirp);
1962: return (0);
1963: }
1964: fvp = fromnd.ni_vp;
1965: nfsm_srvmtofh(tfhp);
1966: nfsm_strsiz(len2, NFS_MAXNAMLEN);
1967: cred->cr_uid = saved_uid;
1968: tond.ni_cnd.cn_cred = cred;
1969: tond.ni_cnd.cn_nameiop = RENAME;
1970: tond.ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF | NOCACHE | SAVESTART;
1971: error = nfs_namei(&tond, tfhp, len2, slp, nam, &md,
1972: &dpos, &tdirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE);
1973: if (tdirp) {
1974: if (v3)
1975: tdirfor_ret = VOP_GETATTR(tdirp, &tdirfor, cred,
1976: procp);
1977: else {
1978: vrele(tdirp);
1979: tdirp = (struct vnode *)0;
1980: }
1981: }
1982: if (error) {
1983: VOP_ABORTOP(fromnd.ni_dvp, &fromnd.ni_cnd);
1984: vrele(fromnd.ni_dvp);
1985: vrele(fvp);
1986: goto out1;
1987: }
1988: tdvp = tond.ni_dvp;
1989: tvp = tond.ni_vp;
1990: if (tvp != NULL) {
1991: if (fvp->v_type == VDIR && tvp->v_type != VDIR) {
1992: if (v3)
1993: error = EEXIST;
1994: else
1995: error = EISDIR;
1996: goto out;
1997: } else if (fvp->v_type != VDIR && tvp->v_type == VDIR) {
1998: if (v3)
1999: error = EEXIST;
2000: else
2001: error = ENOTDIR;
2002: goto out;
2003: }
2004: if (tvp->v_type == VDIR && tvp->v_mountedhere) {
2005: if (v3)
2006: error = EXDEV;
2007: else
2008: error = ENOTEMPTY;
2009: goto out;
2010: }
2011: }
2012: if (fvp->v_type == VDIR && fvp->v_mountedhere) {
2013: if (v3)
2014: error = EXDEV;
2015: else
2016: error = ENOTEMPTY;
2017: goto out;
2018: }
2019: if (fvp->v_mount != tdvp->v_mount) {
2020: if (v3)
2021: error = EXDEV;
2022: else
2023: error = ENOTEMPTY;
2024: goto out;
2025: }
2026: if (fvp == tdvp)
2027: if (v3)
2028: error = EINVAL;
2029: else
2030: error = ENOTEMPTY;
2031: /*
2032: * If source is the same as the destination (that is the
2033: * same vnode) then there is nothing to do.
2034: * (fixed to have POSIX semantics - CSM 3/2/98)
2035: */
2036: if (fvp == tvp)
2037: error = -1;
2038: out:
2039: if (!error) {
2040: nqsrv_getl(fromnd.ni_dvp, ND_WRITE);
2041: nqsrv_getl(tdvp, ND_WRITE);
2042: if (tvp) {
2043: nqsrv_getl(tvp, ND_WRITE);
2044: (void) vnode_uncache(tvp);
2045: }
2046: error = VOP_RENAME(fromnd.ni_dvp, fromnd.ni_vp, &fromnd.ni_cnd,
2047: tond.ni_dvp, tond.ni_vp, &tond.ni_cnd);
2048: } else {
2049: VOP_ABORTOP(tond.ni_dvp, &tond.ni_cnd);
2050: if (tdvp == tvp)
2051: vrele(tdvp);
2052: else
2053: vput(tdvp);
2054: if (tvp)
2055: vput(tvp);
2056: VOP_ABORTOP(fromnd.ni_dvp, &fromnd.ni_cnd);
2057: vrele(fromnd.ni_dvp);
2058: vrele(fvp);
2059: if (error == -1)
2060: error = 0;
2061: }
2062: vrele(tond.ni_startdir);
2063: FREE_ZONE(tond.ni_cnd.cn_pnbuf, tond.ni_cnd.cn_pnlen, M_NAMEI);
2064: out1:
2065: if (fdirp) {
2066: fdiraft_ret = VOP_GETATTR(fdirp, &fdiraft, cred, procp);
2067: vrele(fdirp);
2068: }
2069: if (tdirp) {
2070: tdiraft_ret = VOP_GETATTR(tdirp, &tdiraft, cred, procp);
2071: vrele(tdirp);
2072: }
2073: vrele(fromnd.ni_startdir);
2074: FREE_ZONE(fromnd.ni_cnd.cn_pnbuf, fromnd.ni_cnd.cn_pnlen, M_NAMEI);
2075: nfsm_reply(2 * NFSX_WCCDATA(v3));
2076: if (v3) {
2077: nfsm_srvwcc_data(fdirfor_ret, &fdirfor, fdiraft_ret, &fdiraft);
2078: nfsm_srvwcc_data(tdirfor_ret, &tdirfor, tdiraft_ret, &tdiraft);
2079: }
2080: return (0);
2081:
2082: nfsmout:
2083: if (fdirp)
2084: vrele(fdirp);
2085: if (tdirp)
2086: vrele(tdirp);
2087: if (tond.ni_cnd.cn_nameiop) {
2088: vrele(tond.ni_startdir);
2089: FREE_ZONE(tond.ni_cnd.cn_pnbuf, tond.ni_cnd.cn_pnlen, M_NAMEI);
2090: }
2091: if (fromnd.ni_cnd.cn_nameiop) {
2092: vrele(fromnd.ni_startdir);
2093: FREE_ZONE(fromnd.ni_cnd.cn_pnbuf,
2094: fromnd.ni_cnd.cn_pnlen, M_NAMEI);
2095: VOP_ABORTOP(fromnd.ni_dvp, &fromnd.ni_cnd);
2096: vrele(fromnd.ni_dvp);
2097: vrele(fvp);
2098: }
2099: return (error);
2100: }
2101:
2102: /*
2103: * nfs link service
2104: */
2105: int
2106: nfsrv_link(nfsd, slp, procp, mrq)
2107: struct nfsrv_descript *nfsd;
2108: struct nfssvc_sock *slp;
2109: struct proc *procp;
2110: struct mbuf **mrq;
2111: {
2112: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
2113: struct mbuf *nam = nfsd->nd_nam;
2114: caddr_t dpos = nfsd->nd_dpos;
2115: struct ucred *cred = &nfsd->nd_cr;
2116: struct nameidata nd;
2117: register u_long *tl;
2118: register long t1;
2119: caddr_t bpos;
2120: int error = 0, rdonly, cache, len, dirfor_ret = 1, diraft_ret = 1;
2121: int getret = 1, v3 = (nfsd->nd_flag & ND_NFSV3);
2122: char *cp2;
2123: struct mbuf *mb, *mreq;
2124: struct vnode *vp, *xp, *dirp = (struct vnode *)0;
2125: struct vattr dirfor, diraft, at;
2126: nfsfh_t nfh, dnfh;
2127: fhandle_t *fhp, *dfhp;
2128: u_quad_t frev;
2129:
2130: fhp = &nfh.fh_generic;
2131: dfhp = &dnfh.fh_generic;
2132: nfsm_srvmtofh(fhp);
2133: nfsm_srvmtofh(dfhp);
2134: nfsm_srvnamesiz(len);
2135: if ((error = nfsrv_fhtovp(fhp, FALSE, &vp, cred, slp, nam,
2136: &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE))) {
2137: nfsm_reply(NFSX_POSTOPATTR(v3) + NFSX_WCCDATA(v3));
2138: nfsm_srvpostop_attr(getret, &at);
2139: nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
2140: return (0);
2141: }
2142: if (vp->v_type == VDIR) {
2143: error = EPERM; /* POSIX */
2144: goto out1;
2145: }
2146: nd.ni_cnd.cn_cred = cred;
2147: nd.ni_cnd.cn_nameiop = CREATE;
2148: nd.ni_cnd.cn_flags = LOCKPARENT;
2149: error = nfs_namei(&nd, dfhp, len, slp, nam, &md, &dpos,
2150: &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE);
2151: if (dirp) {
2152: if (v3)
2153: dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred,
2154: procp);
2155: else {
2156: vrele(dirp);
2157: dirp = (struct vnode *)0;
2158: }
2159: }
2160: if (error)
2161: goto out1;
2162: xp = nd.ni_vp;
2163: if (xp != NULL) {
2164: error = EEXIST;
2165: goto out;
2166: }
2167: xp = nd.ni_dvp;
2168: if (vp->v_mount != xp->v_mount)
2169: error = EXDEV;
2170: out:
2171: if (!error) {
2172: nqsrv_getl(vp, ND_WRITE);
2173: nqsrv_getl(xp, ND_WRITE);
2174: error = VOP_LINK(vp, nd.ni_dvp, &nd.ni_cnd);
2175: } else {
2176: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
2177: if (nd.ni_dvp == nd.ni_vp)
2178: vrele(nd.ni_dvp);
2179: else
2180: vput(nd.ni_dvp);
2181: if (nd.ni_vp)
2182: vrele(nd.ni_vp);
2183: }
2184: out1:
2185: if (v3)
2186: getret = VOP_GETATTR(vp, &at, cred, procp);
2187: if (dirp) {
2188: diraft_ret = VOP_GETATTR(dirp, &diraft, cred, procp);
2189: vrele(dirp);
2190: }
2191: vrele(vp);
2192: nfsm_reply(NFSX_POSTOPATTR(v3) + NFSX_WCCDATA(v3));
2193: if (v3) {
2194: nfsm_srvpostop_attr(getret, &at);
2195: nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
2196: return (0);
2197: }
2198: nfsm_srvdone;
2199: }
2200:
2201: /*
2202: * nfs symbolic link service
2203: */
2204: int
2205: nfsrv_symlink(nfsd, slp, procp, mrq)
2206: struct nfsrv_descript *nfsd;
2207: struct nfssvc_sock *slp;
2208: struct proc *procp;
2209: struct mbuf **mrq;
2210: {
2211: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
2212: struct mbuf *nam = nfsd->nd_nam;
2213: caddr_t dpos = nfsd->nd_dpos;
2214: struct ucred *cred = &nfsd->nd_cr;
2215: struct vattr va, dirfor, diraft;
2216: struct nameidata nd;
2217: register struct vattr *vap = &va;
2218: register u_long *tl;
2219: register long t1;
2220: struct nfsv2_sattr *sp;
2221: char *bpos, *pathcp = (char *)0, *cp2;
2222: struct uio io;
2223: struct iovec iv;
2224: int error = 0, cache, len, len2, dirfor_ret = 1, diraft_ret = 1;
2225: int v3 = (nfsd->nd_flag & ND_NFSV3);
2226: struct mbuf *mb, *mreq, *mb2;
2227: struct vnode *dirp = (struct vnode *)0;
2228: nfsfh_t nfh;
2229: fhandle_t *fhp;
2230: u_quad_t frev;
2231:
2232: nd.ni_cnd.cn_nameiop = 0;
2233: fhp = &nfh.fh_generic;
2234: nfsm_srvmtofh(fhp);
2235: nfsm_srvnamesiz(len);
2236: nd.ni_cnd.cn_cred = cred;
2237: nd.ni_cnd.cn_nameiop = CREATE;
2238: nd.ni_cnd.cn_flags = LOCKPARENT | SAVESTART;
2239: error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos,
2240: &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE);
2241: if (dirp) {
2242: if (v3)
2243: dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred,
2244: procp);
2245: else {
2246: vrele(dirp);
2247: dirp = (struct vnode *)0;
2248: }
2249: }
2250: if (error)
2251: goto out;
2252: VATTR_NULL(vap);
2253: if (v3)
2254: nfsm_srvsattr(vap);
2255: nfsm_strsiz(len2, NFS_MAXPATHLEN);
2256: MALLOC(pathcp, caddr_t, len2 + 1, M_TEMP, M_WAITOK);
2257: iv.iov_base = pathcp;
2258: iv.iov_len = len2;
2259: io.uio_resid = len2;
2260: io.uio_offset = 0;
2261: io.uio_iov = &iv;
2262: io.uio_iovcnt = 1;
2263: io.uio_segflg = UIO_SYSSPACE;
2264: io.uio_rw = UIO_READ;
2265: io.uio_procp = (struct proc *)0;
2266: nfsm_mtouio(&io, len2);
2267: if (!v3) {
2268: nfsm_dissect(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
2269: vap->va_mode = fxdr_unsigned(u_short, sp->sa_mode);
2270: }
2271: *(pathcp + len2) = '\0';
2272: if (nd.ni_vp) {
2273: vrele(nd.ni_startdir);
2274: _FREE_ZONE(nd.ni_cnd.cn_pnbuf, nd.ni_cnd.cn_pnlen, M_NAMEI);
2275: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
2276: if (nd.ni_dvp == nd.ni_vp)
2277: vrele(nd.ni_dvp);
2278: else
2279: vput(nd.ni_dvp);
2280: vrele(nd.ni_vp);
2281: error = EEXIST;
2282: goto out;
2283: }
2284: nqsrv_getl(nd.ni_dvp, ND_WRITE);
2285: error = VOP_SYMLINK(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, vap, pathcp);
2286: if (error)
2287: vrele(nd.ni_startdir);
2288: else {
2289: if (v3) {
2290: nd.ni_cnd.cn_nameiop = LOOKUP;
2291: nd.ni_cnd.cn_flags &= ~(LOCKPARENT | SAVESTART | FOLLOW);
2292: nd.ni_cnd.cn_flags |= (NOFOLLOW | LOCKLEAF);
2293: nd.ni_cnd.cn_proc = procp;
2294: nd.ni_cnd.cn_cred = cred;
2295: error = lookup(&nd);
2296: if (!error) {
2297: bzero((caddr_t)fhp, sizeof(nfh));
2298: fhp->fh_fsid = nd.ni_vp->v_mount->mnt_stat.f_fsid;
2299: error = VFS_VPTOFH(nd.ni_vp, &fhp->fh_fid);
2300: if (!error)
2301: error = VOP_GETATTR(nd.ni_vp, vap, cred,
2302: procp);
2303: vput(nd.ni_vp);
2304: }
2305: } else
2306: vrele(nd.ni_startdir);
2307: FREE_ZONE(nd.ni_cnd.cn_pnbuf, nd.ni_cnd.cn_pnlen, M_NAMEI);
2308: }
2309: out:
2310: if (pathcp)
2311: FREE(pathcp, M_TEMP);
2312: if (dirp) {
2313: diraft_ret = VOP_GETATTR(dirp, &diraft, cred, procp);
2314: vrele(dirp);
2315: }
2316: nfsm_reply(NFSX_SRVFH(v3) + NFSX_POSTOPATTR(v3) + NFSX_WCCDATA(v3));
2317: if (v3) {
2318: if (!error) {
2319: nfsm_srvpostop_fh(fhp);
2320: nfsm_srvpostop_attr(0, vap);
2321: }
2322: nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
2323: }
2324: return (0);
2325: nfsmout:
2326: if (nd.ni_cnd.cn_nameiop) {
2327: vrele(nd.ni_startdir);
2328: _FREE_ZONE(nd.ni_cnd.cn_pnbuf, nd.ni_cnd.cn_pnlen, M_NAMEI);
2329: }
2330: if (dirp)
2331: vrele(dirp);
2332: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
2333: if (nd.ni_dvp == nd.ni_vp)
2334: vrele(nd.ni_dvp);
2335: else
2336: vput(nd.ni_dvp);
2337: if (nd.ni_vp)
2338: vrele(nd.ni_vp);
2339: if (pathcp)
2340: FREE(pathcp, M_TEMP);
2341: return (error);
2342: }
2343:
2344: /*
2345: * nfs mkdir service
2346: */
2347: int
2348: nfsrv_mkdir(nfsd, slp, procp, mrq)
2349: struct nfsrv_descript *nfsd;
2350: struct nfssvc_sock *slp;
2351: struct proc *procp;
2352: struct mbuf **mrq;
2353: {
2354: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
2355: struct mbuf *nam = nfsd->nd_nam;
2356: caddr_t dpos = nfsd->nd_dpos;
2357: struct ucred *cred = &nfsd->nd_cr;
2358: struct vattr va, dirfor, diraft;
2359: register struct vattr *vap = &va;
2360: register struct nfs_fattr *fp;
2361: struct nameidata nd;
2362: register caddr_t cp;
2363: register u_long *tl;
2364: register long t1;
2365: caddr_t bpos;
2366: int error = 0, cache, len, dirfor_ret = 1, diraft_ret = 1;
2367: int v3 = (nfsd->nd_flag & ND_NFSV3);
2368: char *cp2;
2369: struct mbuf *mb, *mb2, *mreq;
2370: struct vnode *vp, *dirp = (struct vnode *)0;
2371: nfsfh_t nfh;
2372: fhandle_t *fhp;
2373: u_quad_t frev;
2374:
2375: fhp = &nfh.fh_generic;
2376: nfsm_srvmtofh(fhp);
2377: nfsm_srvnamesiz(len);
2378: nd.ni_cnd.cn_cred = cred;
2379: nd.ni_cnd.cn_nameiop = CREATE;
2380: nd.ni_cnd.cn_flags = LOCKPARENT;
2381: error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos,
2382: &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE);
2383: if (dirp) {
2384: if (v3)
2385: dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred,
2386: procp);
2387: else {
2388: vrele(dirp);
2389: dirp = (struct vnode *)0;
2390: }
2391: }
2392: if (error) {
2393: nfsm_reply(NFSX_WCCDATA(v3));
2394: nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
2395: if (dirp)
2396: vrele(dirp);
2397: return (0);
2398: }
2399: VATTR_NULL(vap);
2400: if (v3) {
2401: nfsm_srvsattr(vap);
2402: } else {
2403: nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
2404: vap->va_mode = nfstov_mode(*tl++);
2405: }
2406: vap->va_type = VDIR;
2407: vp = nd.ni_vp;
2408: if (vp != NULL) {
2409: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
2410: if (nd.ni_dvp == vp)
2411: vrele(nd.ni_dvp);
2412: else
2413: vput(nd.ni_dvp);
2414: vrele(vp);
2415: error = EEXIST;
2416: goto out;
2417: }
2418: nqsrv_getl(nd.ni_dvp, ND_WRITE);
2419: error = VOP_MKDIR(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, vap);
2420: if (!error) {
2421: vp = nd.ni_vp;
2422: bzero((caddr_t)fhp, sizeof(nfh));
2423: fhp->fh_fsid = vp->v_mount->mnt_stat.f_fsid;
2424: error = VFS_VPTOFH(vp, &fhp->fh_fid);
2425: if (!error)
2426: error = VOP_GETATTR(vp, vap, cred, procp);
2427: vput(vp);
2428: }
2429: out:
2430: if (dirp) {
2431: diraft_ret = VOP_GETATTR(dirp, &diraft, cred, procp);
2432: vrele(dirp);
2433: }
2434: nfsm_reply(NFSX_SRVFH(v3) + NFSX_POSTOPATTR(v3) + NFSX_WCCDATA(v3));
2435: if (v3) {
2436: if (!error) {
2437: nfsm_srvpostop_fh(fhp);
2438: nfsm_srvpostop_attr(0, vap);
2439: }
2440: nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
2441: } else {
2442: nfsm_srvfhtom(fhp, v3);
2443: nfsm_build(fp, struct nfs_fattr *, NFSX_V2FATTR);
2444: nfsm_srvfillattr(vap, fp);
2445: }
2446: return (0);
2447: nfsmout:
2448: if (dirp)
2449: vrele(dirp);
2450: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
2451: if (nd.ni_dvp == nd.ni_vp)
2452: vrele(nd.ni_dvp);
2453: else
2454: vput(nd.ni_dvp);
2455: if (nd.ni_vp)
2456: vrele(nd.ni_vp);
2457: return (error);
2458: }
2459:
2460: /*
2461: * nfs rmdir service
2462: */
2463: int
2464: nfsrv_rmdir(nfsd, slp, procp, mrq)
2465: struct nfsrv_descript *nfsd;
2466: struct nfssvc_sock *slp;
2467: struct proc *procp;
2468: struct mbuf **mrq;
2469: {
2470: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
2471: struct mbuf *nam = nfsd->nd_nam;
2472: caddr_t dpos = nfsd->nd_dpos;
2473: struct ucred *cred = &nfsd->nd_cr;
2474: register u_long *tl;
2475: register long t1;
2476: caddr_t bpos;
2477: int error = 0, cache, len, dirfor_ret = 1, diraft_ret = 1;
2478: int v3 = (nfsd->nd_flag & ND_NFSV3);
2479: char *cp2;
2480: struct mbuf *mb, *mreq;
2481: struct vnode *vp, *dirp = (struct vnode *)0;
2482: struct vattr dirfor, diraft;
2483: nfsfh_t nfh;
2484: fhandle_t *fhp;
2485: struct nameidata nd;
2486: u_quad_t frev;
2487:
2488: fhp = &nfh.fh_generic;
2489: nfsm_srvmtofh(fhp);
2490: nfsm_srvnamesiz(len);
2491: nd.ni_cnd.cn_cred = cred;
2492: nd.ni_cnd.cn_nameiop = DELETE;
2493: nd.ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF;
2494: error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos,
2495: &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE);
2496: if (dirp) {
2497: if (v3)
2498: dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred,
2499: procp);
2500: else {
2501: vrele(dirp);
2502: dirp = (struct vnode *)0;
2503: }
2504: }
2505: if (error) {
2506: nfsm_reply(NFSX_WCCDATA(v3));
2507: nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
2508: if (dirp)
2509: vrele(dirp);
2510: return (0);
2511: }
2512: vp = nd.ni_vp;
2513: if (vp->v_type != VDIR) {
2514: error = ENOTDIR;
2515: goto out;
2516: }
2517: /*
2518: * No rmdir "." please.
2519: */
2520: if (nd.ni_dvp == vp) {
2521: error = EINVAL;
2522: goto out;
2523: }
2524: /*
2525: * The root of a mounted filesystem cannot be deleted.
2526: */
2527: if (vp->v_flag & VROOT)
2528: error = EBUSY;
2529: out:
2530: if (!error) {
2531: nqsrv_getl(nd.ni_dvp, ND_WRITE);
2532: nqsrv_getl(vp, ND_WRITE);
2533: error = VOP_RMDIR(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd);
2534: } else {
2535: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
2536: if (nd.ni_dvp == nd.ni_vp)
2537: vrele(nd.ni_dvp);
2538: else
2539: vput(nd.ni_dvp);
2540: vput(vp);
2541: }
2542: if (dirp) {
2543: diraft_ret = VOP_GETATTR(dirp, &diraft, cred, procp);
2544: vrele(dirp);
2545: }
2546: nfsm_reply(NFSX_WCCDATA(v3));
2547: if (v3) {
2548: nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
2549: return (0);
2550: }
2551: nfsm_srvdone;
2552: }
2553:
2554: /*
2555: * nfs readdir service
2556: * - mallocs what it thinks is enough to read
2557: * count rounded up to a multiple of NFS_DIRBLKSIZ <= NFS_MAXREADDIR
2558: * - calls VOP_READDIR()
2559: * - loops around building the reply
2560: * if the output generated exceeds count break out of loop
2561: * The nfsm_clget macro is used here so that the reply will be packed
2562: * tightly in mbuf clusters.
2563: * - it only knows that it has encountered eof when the VOP_READDIR()
2564: * reads nothing
2565: * - as such one readdir rpc will return eof false although you are there
2566: * and then the next will return eof
2567: * - it trims out records with d_fileno == 0
2568: * this doesn't matter for Unix clients, but they might confuse clients
2569: * for other os'.
2570: * NB: It is tempting to set eof to true if the VOP_READDIR() reads less
2571: * than requested, but this may not apply to all filesystems. For
2572: * example, client NFS does not { although it is never remote mounted
2573: * anyhow }
2574: * The alternate call nfsrv_readdirplus() does lookups as well.
2575: * PS: The NFS protocol spec. does not clarify what the "count" byte
2576: * argument is a count of.. just name strings and file id's or the
2577: * entire reply rpc or ...
2578: * I tried just file name and id sizes and it confused the Sun client,
2579: * so I am using the full rpc size now. The "paranoia.." comment refers
2580: * to including the status longwords that are not a part of the dir.
2581: * "entry" structures, but are in the rpc.
2582: */
2583: struct flrep {
2584: nfsuint64 fl_off;
2585: u_long fl_postopok;
2586: u_long fl_fattr[NFSX_V3FATTR / sizeof (u_long)];
2587: u_long fl_fhok;
2588: u_long fl_fhsize;
2589: u_long fl_nfh[NFSX_V3FH / sizeof (u_long)];
2590: };
2591:
2592: int
2593: nfsrv_readdir(nfsd, slp, procp, mrq)
2594: struct nfsrv_descript *nfsd;
2595: struct nfssvc_sock *slp;
2596: struct proc *procp;
2597: struct mbuf **mrq;
2598: {
2599: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
2600: struct mbuf *nam = nfsd->nd_nam;
2601: caddr_t dpos = nfsd->nd_dpos;
2602: struct ucred *cred = &nfsd->nd_cr;
2603: register char *bp, *be;
2604: register struct mbuf *mp;
2605: register struct dirent *dp;
2606: register caddr_t cp;
2607: register u_long *tl;
2608: register long t1;
2609: caddr_t bpos;
2610: struct mbuf *mb, *mb2, *mreq, *mp2;
2611: char *cpos, *cend, *cp2, *rbuf;
2612: struct vnode *vp;
2613: struct vattr at;
2614: nfsfh_t nfh;
2615: fhandle_t *fhp;
2616: struct uio io;
2617: struct iovec iv;
2618: int len, nlen, rem, xfer, tsiz, i, error = 0, getret = 1;
2619: int siz, cnt, fullsiz, eofflag, rdonly, cache, ncookies;
2620: int v3 = (nfsd->nd_flag & ND_NFSV3);
2621: u_quad_t frev, off, toff, verf;
2622: u_long *cookies = NULL, *cookiep;
2623:
2624: fhp = &nfh.fh_generic;
2625: nfsm_srvmtofh(fhp);
2626: if (v3) {
2627: nfsm_dissect(tl, u_long *, 5 * NFSX_UNSIGNED);
2628: fxdr_hyper(tl, &toff);
2629: tl += 2;
2630: fxdr_hyper(tl, &verf);
2631: tl += 2;
2632: } else {
2633: nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED);
2634: toff = fxdr_unsigned(u_quad_t, *tl++);
2635: }
2636: off = toff;
2637: cnt = fxdr_unsigned(int, *tl);
2638: siz = ((cnt + DIRBLKSIZ - 1) & ~(DIRBLKSIZ - 1));
2639: xfer = NFS_SRVMAXDATA(nfsd);
2640: if (siz > xfer)
2641: siz = xfer;
2642: fullsiz = siz;
2643: if ((error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam,
2644: &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE))) {
2645: nfsm_reply(NFSX_UNSIGNED);
2646: nfsm_srvpostop_attr(getret, &at);
2647: return (0);
2648: }
2649: nqsrv_getl(vp, ND_READ);
2650: if (v3) {
2651: error = getret = VOP_GETATTR(vp, &at, cred, procp);
2652: if (!error && toff && verf && verf != at.va_filerev)
2653: error = NFSERR_BAD_COOKIE;
2654: }
2655: if (!error)
2656: error = nfsrv_access(vp, VEXEC, cred, rdonly, procp);
2657: if (error) {
2658: vput(vp);
2659: nfsm_reply(NFSX_POSTOPATTR(v3));
2660: nfsm_srvpostop_attr(getret, &at);
2661: return (0);
2662: }
2663: VOP_UNLOCK(vp, 0, procp);
2664: MALLOC(rbuf, caddr_t, siz, M_TEMP, M_WAITOK);
2665: again:
2666: iv.iov_base = rbuf;
2667: iv.iov_len = fullsiz;
2668: io.uio_iov = &iv;
2669: io.uio_iovcnt = 1;
2670: io.uio_offset = (off_t)off;
2671: io.uio_resid = fullsiz;
2672: io.uio_segflg = UIO_SYSSPACE;
2673: io.uio_rw = UIO_READ;
2674: io.uio_procp = (struct proc *)0;
2675: eofflag = 0;
2676: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, procp);
2677: if (cookies) {
2678: _FREE((caddr_t)cookies, M_TEMP);
2679: cookies = NULL;
2680: }
2681: error = VOP_READDIR(vp, &io, cred, &eofflag, &ncookies, &cookies);
2682: off = (off_t)io.uio_offset;
2683: if (!cookies && !error)
2684: error = NFSERR_PERM;
2685: if (v3) {
2686: getret = VOP_GETATTR(vp, &at, cred, procp);
2687: if (!error)
2688: error = getret;
2689: }
2690: VOP_UNLOCK(vp, 0, procp);
2691: if (error) {
2692: vrele(vp);
2693: _FREE((caddr_t)rbuf, M_TEMP);
2694: if (cookies)
2695: _FREE((caddr_t)cookies, M_TEMP);
2696: nfsm_reply(NFSX_POSTOPATTR(v3));
2697: nfsm_srvpostop_attr(getret, &at);
2698: return (0);
2699: }
2700: if (io.uio_resid) {
2701: siz -= io.uio_resid;
2702:
2703: /*
2704: * If nothing read, return eof
2705: * rpc reply
2706: */
2707: if (siz == 0) {
2708: vrele(vp);
2709: nfsm_reply(NFSX_POSTOPATTR(v3) + NFSX_COOKIEVERF(v3) +
2710: 2 * NFSX_UNSIGNED);
2711: if (v3) {
2712: nfsm_srvpostop_attr(getret, &at);
2713: nfsm_build(tl, u_long *, 4 * NFSX_UNSIGNED);
2714: txdr_hyper(&at.va_filerev, tl);
2715: tl += 2;
2716: } else
2717: nfsm_build(tl, u_long *, 2 * NFSX_UNSIGNED);
2718: *tl++ = nfs_false;
2719: *tl = nfs_true;
2720: FREE((caddr_t)rbuf, M_TEMP);
2721: FREE((caddr_t)cookies, M_TEMP);
2722: return (0);
2723: }
2724: }
2725:
2726: /*
2727: * Check for degenerate cases of nothing useful read.
2728: * If so go try again
2729: */
2730: cpos = rbuf;
2731: cend = rbuf + siz;
2732: dp = (struct dirent *)cpos;
2733: cookiep = cookies;
2734: #ifdef __FreeBSD__
2735: /*
2736: * For some reason FreeBSD's ufs_readdir() chooses to back the
2737: * directory offset up to a block boundary, so it is necessary to
2738: * skip over the records that preceed the requested offset. This
2739: * requires the assumption that file offset cookies monotonically
2740: * increase.
2741: */
2742: while (cpos < cend && ncookies > 0 &&
2743: (dp->d_fileno == 0 || ((u_quad_t)(*cookiep)) <= toff)) {
2744: #else
2745: while (dp->d_fileno == 0 && cpos < cend && ncookies > 0) {
2746: #endif
2747: cpos += dp->d_reclen;
2748: dp = (struct dirent *)cpos;
2749: cookiep++;
2750: ncookies--;
2751: }
2752: if (cpos >= cend || ncookies == 0) {
2753: toff = off;
2754: siz = fullsiz;
2755: goto again;
2756: }
2757:
2758: len = 3 * NFSX_UNSIGNED; /* paranoia, probably can be 0 */
2759: nfsm_reply(NFSX_POSTOPATTR(v3) + NFSX_COOKIEVERF(v3) + siz);
2760: if (v3) {
2761: nfsm_srvpostop_attr(getret, &at);
2762: nfsm_build(tl, u_long *, 2 * NFSX_UNSIGNED);
2763: txdr_hyper(&at.va_filerev, tl);
2764: }
2765: mp = mp2 = mb;
2766: bp = bpos;
2767: be = bp + M_TRAILINGSPACE(mp);
2768:
2769: /* Loop through the records and build reply */
2770: while (cpos < cend && ncookies > 0) {
2771: if (dp->d_fileno != 0) {
2772: nlen = dp->d_namlen;
2773: rem = nfsm_rndup(nlen)-nlen;
2774: len += (4 * NFSX_UNSIGNED + nlen + rem);
2775: if (v3)
2776: len += 2 * NFSX_UNSIGNED;
2777: if (len > cnt) {
2778: eofflag = 0;
2779: break;
2780: }
2781: /*
2782: * Build the directory record xdr from
2783: * the dirent entry.
2784: */
2785: nfsm_clget;
2786: *tl = nfs_true;
2787: bp += NFSX_UNSIGNED;
2788: if (v3) {
2789: nfsm_clget;
2790: *tl = 0;
2791: bp += NFSX_UNSIGNED;
2792: }
2793: nfsm_clget;
2794: *tl = txdr_unsigned(dp->d_fileno);
2795: bp += NFSX_UNSIGNED;
2796: nfsm_clget;
2797: *tl = txdr_unsigned(nlen);
2798: bp += NFSX_UNSIGNED;
2799:
2800: /* And loop around copying the name */
2801: xfer = nlen;
2802: cp = dp->d_name;
2803: while (xfer > 0) {
2804: nfsm_clget;
2805: if ((bp+xfer) > be)
2806: tsiz = be-bp;
2807: else
2808: tsiz = xfer;
2809: bcopy(cp, bp, tsiz);
2810: bp += tsiz;
2811: xfer -= tsiz;
2812: if (xfer > 0)
2813: cp += tsiz;
2814: }
2815: /* And null pad to a long boundary */
2816: for (i = 0; i < rem; i++)
2817: *bp++ = '\0';
2818: nfsm_clget;
2819:
2820: /* Finish off the record */
2821: if (v3) {
2822: *tl = 0;
2823: bp += NFSX_UNSIGNED;
2824: nfsm_clget;
2825: }
2826: *tl = txdr_unsigned(*cookiep);
2827: bp += NFSX_UNSIGNED;
2828: }
2829: cpos += dp->d_reclen;
2830: dp = (struct dirent *)cpos;
2831: cookiep++;
2832: ncookies--;
2833: }
2834: vrele(vp);
2835: nfsm_clget;
2836: *tl = nfs_false;
2837: bp += NFSX_UNSIGNED;
2838: nfsm_clget;
2839: if (eofflag)
2840: *tl = nfs_true;
2841: else
2842: *tl = nfs_false;
2843: bp += NFSX_UNSIGNED;
2844: if (mp != mb) {
2845: if (bp < be)
2846: mp->m_len = bp - mtod(mp, caddr_t);
2847: } else
2848: mp->m_len += bp - bpos;
2849: FREE((caddr_t)rbuf, M_TEMP);
2850: FREE((caddr_t)cookies, M_TEMP);
2851: nfsm_srvdone;
2852: }
2853:
2854: int
2855: nfsrv_readdirplus(nfsd, slp, procp, mrq)
2856: struct nfsrv_descript *nfsd;
2857: struct nfssvc_sock *slp;
2858: struct proc *procp;
2859: struct mbuf **mrq;
2860: {
2861: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
2862: struct mbuf *nam = nfsd->nd_nam;
2863: caddr_t dpos = nfsd->nd_dpos;
2864: struct ucred *cred = &nfsd->nd_cr;
2865: register char *bp, *be;
2866: register struct mbuf *mp;
2867: register struct dirent *dp;
2868: register caddr_t cp;
2869: register u_long *tl;
2870: register long t1;
2871: caddr_t bpos;
2872: struct mbuf *mb, *mb2, *mreq, *mp2;
2873: char *cpos, *cend, *cp2, *rbuf;
2874: struct vnode *vp, *nvp;
2875: struct flrep fl;
2876: nfsfh_t nfh;
2877: fhandle_t *fhp, *nfhp = (fhandle_t *)fl.fl_nfh;
2878: struct uio io;
2879: struct iovec iv;
2880: struct vattr va, at, *vap = &va;
2881: struct nfs_fattr *fp;
2882: int len, nlen, rem, xfer, tsiz, i, error = 0, getret = 1;
2883: int siz, cnt, fullsiz, eofflag, rdonly, cache, dirlen, ncookies;
2884: u_quad_t frev, off, toff, verf;
2885: u_long *cookies = NULL, *cookiep;
2886:
2887: fhp = &nfh.fh_generic;
2888: nfsm_srvmtofh(fhp);
2889: nfsm_dissect(tl, u_long *, 6 * NFSX_UNSIGNED);
2890: fxdr_hyper(tl, &toff);
2891: tl += 2;
2892: fxdr_hyper(tl, &verf);
2893: tl += 2;
2894: siz = fxdr_unsigned(int, *tl++);
2895: cnt = fxdr_unsigned(int, *tl);
2896: off = toff;
2897: siz = ((siz + DIRBLKSIZ - 1) & ~(DIRBLKSIZ - 1));
2898: xfer = NFS_SRVMAXDATA(nfsd);
2899: if (siz > xfer)
2900: siz = xfer;
2901: fullsiz = siz;
2902: if ((error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam,
2903: &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE))) {
2904: nfsm_reply(NFSX_UNSIGNED);
2905: nfsm_srvpostop_attr(getret, &at);
2906: return (0);
2907: }
2908: error = getret = VOP_GETATTR(vp, &at, cred, procp);
2909: if (!error && toff && verf && verf != at.va_filerev)
2910: error = NFSERR_BAD_COOKIE;
2911: if (!error) {
2912: nqsrv_getl(vp, ND_READ);
2913: error = nfsrv_access(vp, VEXEC, cred, rdonly, procp);
2914: }
2915: if (error) {
2916: vput(vp);
2917: nfsm_reply(NFSX_V3POSTOPATTR);
2918: nfsm_srvpostop_attr(getret, &at);
2919: return (0);
2920: }
2921: VOP_UNLOCK(vp, 0, procp);
2922: MALLOC(rbuf, caddr_t, siz, M_TEMP, M_WAITOK);
2923: again:
2924: iv.iov_base = rbuf;
2925: iv.iov_len = fullsiz;
2926: io.uio_iov = &iv;
2927: io.uio_iovcnt = 1;
2928: io.uio_offset = (off_t)off;
2929: io.uio_resid = fullsiz;
2930: io.uio_segflg = UIO_SYSSPACE;
2931: io.uio_rw = UIO_READ;
2932: io.uio_procp = (struct proc *)0;
2933: eofflag = 0;
2934: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, procp);
2935: if (cookies) {
2936: _FREE((caddr_t)cookies, M_TEMP);
2937: cookies = NULL;
2938: }
2939: error = VOP_READDIR(vp, &io, cred, &eofflag, &ncookies, &cookies);
2940: off = (u_quad_t)io.uio_offset;
2941: getret = VOP_GETATTR(vp, &at, cred, procp);
2942: VOP_UNLOCK(vp, 0, procp);
2943: if (!cookies && !error)
2944: error = NFSERR_PERM;
2945: if (!error)
2946: error = getret;
2947: if (error) {
2948: vrele(vp);
2949: if (cookies)
2950: _FREE((caddr_t)cookies, M_TEMP);
2951: _FREE((caddr_t)rbuf, M_TEMP);
2952: nfsm_reply(NFSX_V3POSTOPATTR);
2953: nfsm_srvpostop_attr(getret, &at);
2954: return (0);
2955: }
2956: if (io.uio_resid) {
2957: siz -= io.uio_resid;
2958:
2959: /*
2960: * If nothing read, return eof
2961: * rpc reply
2962: */
2963: if (siz == 0) {
2964: vrele(vp);
2965: nfsm_reply(NFSX_V3POSTOPATTR + NFSX_V3COOKIEVERF +
2966: 2 * NFSX_UNSIGNED);
2967: nfsm_srvpostop_attr(getret, &at);
2968: nfsm_build(tl, u_long *, 4 * NFSX_UNSIGNED);
2969: txdr_hyper(&at.va_filerev, tl);
2970: tl += 2;
2971: *tl++ = nfs_false;
2972: *tl = nfs_true;
2973: FREE((caddr_t)cookies, M_TEMP);
2974: FREE((caddr_t)rbuf, M_TEMP);
2975: return (0);
2976: }
2977: }
2978:
2979: /*
2980: * Check for degenerate cases of nothing useful read.
2981: * If so go try again
2982: */
2983: cpos = rbuf;
2984: cend = rbuf + siz;
2985: dp = (struct dirent *)cpos;
2986: cookiep = cookies;
2987: #ifdef __FreeBSD__
2988: /*
2989: * For some reason FreeBSD's ufs_readdir() chooses to back the
2990: * directory offset up to a block boundary, so it is necessary to
2991: * skip over the records that preceed the requested offset. This
2992: * requires the assumption that file offset cookies monotonically
2993: * increase.
2994: */
2995: while (cpos < cend && ncookies > 0 &&
2996: (dp->d_fileno == 0 || ((u_quad_t)(*cookiep)) <= toff)) {
2997: #else
2998: while (dp->d_fileno == 0 && cpos < cend && ncookies > 0) {
2999: #endif
3000: cpos += dp->d_reclen;
3001: dp = (struct dirent *)cpos;
3002: cookiep++;
3003: ncookies--;
3004: }
3005: if (cpos >= cend || ncookies == 0) {
3006: toff = off;
3007: siz = fullsiz;
3008: goto again;
3009: }
3010:
3011: /*
3012: * Probe one of the directory entries to see if the filesystem
3013: * supports VGET.
3014: */
3015: if (VFS_VGET(vp->v_mount, dp->d_fileno, &nvp) == EOPNOTSUPP) {
3016: error = NFSERR_NOTSUPP;
3017: vrele(vp);
3018: _FREE((caddr_t)cookies, M_TEMP);
3019: _FREE((caddr_t)rbuf, M_TEMP);
3020: nfsm_reply(NFSX_V3POSTOPATTR);
3021: nfsm_srvpostop_attr(getret, &at);
3022: return (0);
3023: }
3024: vput(nvp);
3025:
3026: dirlen = len = NFSX_V3POSTOPATTR + NFSX_V3COOKIEVERF + 2 * NFSX_UNSIGNED;
3027: nfsm_reply(cnt);
3028: nfsm_srvpostop_attr(getret, &at);
3029: nfsm_build(tl, u_long *, 2 * NFSX_UNSIGNED);
3030: txdr_hyper(&at.va_filerev, tl);
3031: mp = mp2 = mb;
3032: bp = bpos;
3033: be = bp + M_TRAILINGSPACE(mp);
3034:
3035: /* Loop through the records and build reply */
3036: while (cpos < cend && ncookies > 0) {
3037: if (dp->d_fileno != 0) {
3038: nlen = dp->d_namlen;
3039: rem = nfsm_rndup(nlen)-nlen;
3040:
3041: /*
3042: * For readdir_and_lookup get the vnode using
3043: * the file number.
3044: */
3045: if (VFS_VGET(vp->v_mount, dp->d_fileno, &nvp))
3046: goto invalid;
3047: bzero((caddr_t)nfhp, NFSX_V3FH);
3048: nfhp->fh_fsid =
3049: nvp->v_mount->mnt_stat.f_fsid;
3050: if (VFS_VPTOFH(nvp, &nfhp->fh_fid)) {
3051: vput(nvp);
3052: goto invalid;
3053: }
3054: if (VOP_GETATTR(nvp, vap, cred, procp)) {
3055: vput(nvp);
3056: goto invalid;
3057: }
3058: vput(nvp);
3059:
3060: /*
3061: * If either the dircount or maxcount will be
3062: * exceeded, get out now. Both of these lengths
3063: * are calculated conservatively, including all
3064: * XDR overheads.
3065: */
3066: len += (7 * NFSX_UNSIGNED + nlen + rem + NFSX_V3FH +
3067: NFSX_V3POSTOPATTR);
3068: dirlen += (6 * NFSX_UNSIGNED + nlen + rem);
3069: if (len > cnt || dirlen > fullsiz) {
3070: eofflag = 0;
3071: break;
3072: }
3073:
3074: /*
3075: * Build the directory record xdr from
3076: * the dirent entry.
3077: */
3078: fp = (struct nfs_fattr *)&fl.fl_fattr;
3079: nfsm_srvfillattr(vap, fp);
3080: fl.fl_fhsize = txdr_unsigned(NFSX_V3FH);
3081: fl.fl_fhok = nfs_true;
3082: fl.fl_postopok = nfs_true;
3083: fl.fl_off.nfsuquad[0] = 0;
3084: fl.fl_off.nfsuquad[1] = txdr_unsigned(*cookiep);
3085:
3086: nfsm_clget;
3087: *tl = nfs_true;
3088: bp += NFSX_UNSIGNED;
3089: nfsm_clget;
3090: *tl = 0;
3091: bp += NFSX_UNSIGNED;
3092: nfsm_clget;
3093: *tl = txdr_unsigned(dp->d_fileno);
3094: bp += NFSX_UNSIGNED;
3095: nfsm_clget;
3096: *tl = txdr_unsigned(nlen);
3097: bp += NFSX_UNSIGNED;
3098:
3099: /* And loop around copying the name */
3100: xfer = nlen;
3101: cp = dp->d_name;
3102: while (xfer > 0) {
3103: nfsm_clget;
3104: if ((bp + xfer) > be)
3105: tsiz = be - bp;
3106: else
3107: tsiz = xfer;
3108: bcopy(cp, bp, tsiz);
3109: bp += tsiz;
3110: xfer -= tsiz;
3111: if (xfer > 0)
3112: cp += tsiz;
3113: }
3114: /* And null pad to a long boundary */
3115: for (i = 0; i < rem; i++)
3116: *bp++ = '\0';
3117:
3118: /*
3119: * Now copy the flrep structure out.
3120: */
3121: xfer = sizeof (struct flrep);
3122: cp = (caddr_t)&fl;
3123: while (xfer > 0) {
3124: nfsm_clget;
3125: if ((bp + xfer) > be)
3126: tsiz = be - bp;
3127: else
3128: tsiz = xfer;
3129: bcopy(cp, bp, tsiz);
3130: bp += tsiz;
3131: xfer -= tsiz;
3132: if (xfer > 0)
3133: cp += tsiz;
3134: }
3135: }
3136: invalid:
3137: cpos += dp->d_reclen;
3138: dp = (struct dirent *)cpos;
3139: cookiep++;
3140: ncookies--;
3141: }
3142: vrele(vp);
3143: nfsm_clget;
3144: *tl = nfs_false;
3145: bp += NFSX_UNSIGNED;
3146: nfsm_clget;
3147: if (eofflag)
3148: *tl = nfs_true;
3149: else
3150: *tl = nfs_false;
3151: bp += NFSX_UNSIGNED;
3152: if (mp != mb) {
3153: if (bp < be)
3154: mp->m_len = bp - mtod(mp, caddr_t);
3155: } else
3156: mp->m_len += bp - bpos;
3157: FREE((caddr_t)cookies, M_TEMP);
3158: FREE((caddr_t)rbuf, M_TEMP);
3159: nfsm_srvdone;
3160: }
3161:
3162: /*
3163: * nfs commit service
3164: */
3165: int
3166: nfsrv_commit(nfsd, slp, procp, mrq)
3167: struct nfsrv_descript *nfsd;
3168: struct nfssvc_sock *slp;
3169: struct proc *procp;
3170: struct mbuf **mrq;
3171: {
3172: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
3173: struct mbuf *nam = nfsd->nd_nam;
3174: caddr_t dpos = nfsd->nd_dpos;
3175: struct ucred *cred = &nfsd->nd_cr;
3176: struct vattr bfor, aft;
3177: struct vnode *vp;
3178: nfsfh_t nfh;
3179: fhandle_t *fhp;
3180: register u_long *tl;
3181: register long t1;
3182: caddr_t bpos;
3183: int error = 0, rdonly, for_ret = 1, aft_ret = 1, cnt, cache;
3184: char *cp2;
3185: struct mbuf *mb, *mb2, *mreq;
3186: u_quad_t frev, off;
3187:
3188: #ifndef nolint
3189: cache = 0;
3190: #endif
3191: fhp = &nfh.fh_generic;
3192: nfsm_srvmtofh(fhp);
3193: nfsm_dissect(tl, u_long *, 3 * NFSX_UNSIGNED);
3194:
3195: /*
3196: * XXX At this time VOP_FSYNC() does not accept offset and byte
3197: * count parameters, so these arguments are useless (someday maybe).
3198: */
3199: fxdr_hyper(tl, &off);
3200: tl += 2;
3201: cnt = fxdr_unsigned(int, *tl);
3202: if ((error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam,
3203: &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE))) {
3204: nfsm_reply(2 * NFSX_UNSIGNED);
3205: nfsm_srvwcc_data(for_ret, &bfor, aft_ret, &aft);
3206: return (0);
3207: }
3208: for_ret = VOP_GETATTR(vp, &bfor, cred, procp);
3209: error = VOP_FSYNC(vp, cred, MNT_WAIT, procp);
3210: aft_ret = VOP_GETATTR(vp, &aft, cred, procp);
3211: vput(vp);
3212: nfsm_reply(NFSX_V3WCCDATA + NFSX_V3WRITEVERF);
3213: nfsm_srvwcc_data(for_ret, &bfor, aft_ret, &aft);
3214: if (!error) {
3215: nfsm_build(tl, u_long *, NFSX_V3WRITEVERF);
3216: *tl++ = txdr_unsigned(boottime.tv_sec);
3217: *tl = txdr_unsigned(boottime.tv_usec);
3218: } else
3219: return (0);
3220: nfsm_srvdone;
3221: }
3222:
3223: /*
3224: * nfs statfs service
3225: */
3226: int
3227: nfsrv_statfs(nfsd, slp, procp, mrq)
3228: struct nfsrv_descript *nfsd;
3229: struct nfssvc_sock *slp;
3230: struct proc *procp;
3231: struct mbuf **mrq;
3232: {
3233: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
3234: struct mbuf *nam = nfsd->nd_nam;
3235: caddr_t dpos = nfsd->nd_dpos;
3236: struct ucred *cred = &nfsd->nd_cr;
3237: register struct statfs *sf;
3238: register struct nfs_statfs *sfp;
3239: register u_long *tl;
3240: register long t1;
3241: caddr_t bpos;
3242: int error = 0, rdonly, cache, getret = 1;
3243: int v3 = (nfsd->nd_flag & ND_NFSV3);
3244: char *cp2;
3245: struct mbuf *mb, *mb2, *mreq;
3246: struct vnode *vp;
3247: struct vattr at;
3248: nfsfh_t nfh;
3249: fhandle_t *fhp;
3250: struct statfs statfs;
3251: u_quad_t frev, tval;
3252:
3253: #ifndef nolint
3254: cache = 0;
3255: #endif
3256: fhp = &nfh.fh_generic;
3257: nfsm_srvmtofh(fhp);
3258: if ((error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam,
3259: &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE))) {
3260: nfsm_reply(NFSX_UNSIGNED);
3261: nfsm_srvpostop_attr(getret, &at);
3262: return (0);
3263: }
3264: sf = &statfs;
3265: error = VFS_STATFS(vp->v_mount, sf, procp);
3266: getret = VOP_GETATTR(vp, &at, cred, procp);
3267: vput(vp);
3268: nfsm_reply(NFSX_POSTOPATTR(v3) + NFSX_STATFS(v3));
3269: if (v3)
3270: nfsm_srvpostop_attr(getret, &at);
3271: if (error)
3272: return (0);
3273: nfsm_build(sfp, struct nfs_statfs *, NFSX_STATFS(v3));
3274: if (v3) {
3275: tval = (u_quad_t)sf->f_blocks;
3276: tval *= (u_quad_t)sf->f_bsize;
3277: txdr_hyper(&tval, &sfp->sf_tbytes);
3278: tval = (u_quad_t)sf->f_bfree;
3279: tval *= (u_quad_t)sf->f_bsize;
3280: txdr_hyper(&tval, &sfp->sf_fbytes);
3281: tval = (u_quad_t)sf->f_bavail;
3282: tval *= (u_quad_t)sf->f_bsize;
3283: txdr_hyper(&tval, &sfp->sf_abytes);
3284: sfp->sf_tfiles.nfsuquad[0] = 0;
3285: sfp->sf_tfiles.nfsuquad[1] = txdr_unsigned(sf->f_files);
3286: sfp->sf_ffiles.nfsuquad[0] = 0;
3287: sfp->sf_ffiles.nfsuquad[1] = txdr_unsigned(sf->f_ffree);
3288: sfp->sf_afiles.nfsuquad[0] = 0;
3289: sfp->sf_afiles.nfsuquad[1] = txdr_unsigned(sf->f_ffree);
3290: sfp->sf_invarsec = 0;
3291: } else {
3292: sfp->sf_tsize = txdr_unsigned(NFS_MAXDGRAMDATA);
3293: sfp->sf_bsize = txdr_unsigned(sf->f_bsize);
3294: sfp->sf_blocks = txdr_unsigned(sf->f_blocks);
3295: sfp->sf_bfree = txdr_unsigned(sf->f_bfree);
3296: sfp->sf_bavail = txdr_unsigned(sf->f_bavail);
3297: }
3298: nfsm_srvdone;
3299: }
3300:
3301: /*
3302: * nfs fsinfo service
3303: */
3304: int
3305: nfsrv_fsinfo(nfsd, slp, procp, mrq)
3306: struct nfsrv_descript *nfsd;
3307: struct nfssvc_sock *slp;
3308: struct proc *procp;
3309: struct mbuf **mrq;
3310: {
3311: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
3312: struct mbuf *nam = nfsd->nd_nam;
3313: caddr_t dpos = nfsd->nd_dpos;
3314: struct ucred *cred = &nfsd->nd_cr;
3315: register u_long *tl;
3316: register struct nfsv3_fsinfo *sip;
3317: register long t1;
3318: caddr_t bpos;
3319: int error = 0, rdonly, cache, getret = 1, pref;
3320: char *cp2;
3321: struct mbuf *mb, *mb2, *mreq;
3322: struct vnode *vp;
3323: struct vattr at;
3324: nfsfh_t nfh;
3325: fhandle_t *fhp;
3326: u_quad_t frev;
3327:
3328: #ifndef nolint
3329: cache = 0;
3330: #endif
3331: fhp = &nfh.fh_generic;
3332: nfsm_srvmtofh(fhp);
3333: if ((error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam,
3334: &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE))) {
3335: nfsm_reply(NFSX_UNSIGNED);
3336: nfsm_srvpostop_attr(getret, &at);
3337: return (0);
3338: }
3339: getret = VOP_GETATTR(vp, &at, cred, procp);
3340: vput(vp);
3341: nfsm_reply(NFSX_V3POSTOPATTR + NFSX_V3FSINFO);
3342: nfsm_srvpostop_attr(getret, &at);
3343: nfsm_build(sip, struct nfsv3_fsinfo *, NFSX_V3FSINFO);
3344:
3345: /*
3346: * XXX
3347: * There should be file system VFS OP(s) to get this information.
3348: * For now, assume ufs.
3349: */
3350: if (slp->ns_so->so_type == SOCK_DGRAM)
3351: pref = NFS_MAXDGRAMDATA;
3352: else
3353: pref = NFS_MAXDATA;
3354: sip->fs_rtmax = txdr_unsigned(NFS_MAXDATA);
3355: sip->fs_rtpref = txdr_unsigned(pref);
3356: sip->fs_rtmult = txdr_unsigned(NFS_FABLKSIZE);
3357: sip->fs_wtmax = txdr_unsigned(NFS_MAXDATA);
3358: sip->fs_wtpref = txdr_unsigned(pref);
3359: sip->fs_wtmult = txdr_unsigned(NFS_FABLKSIZE);
3360: sip->fs_dtpref = txdr_unsigned(pref);
3361: sip->fs_maxfilesize.nfsuquad[0] = 0xffffffff;
3362: sip->fs_maxfilesize.nfsuquad[1] = 0xffffffff;
3363: sip->fs_timedelta.nfsv3_sec = 0;
3364: sip->fs_timedelta.nfsv3_nsec = txdr_unsigned(1);
3365: sip->fs_properties = txdr_unsigned(NFSV3FSINFO_LINK |
3366: NFSV3FSINFO_SYMLINK | NFSV3FSINFO_HOMOGENEOUS |
3367: NFSV3FSINFO_CANSETTIME);
3368: nfsm_srvdone;
3369: }
3370:
3371: /*
3372: * nfs pathconf service
3373: */
3374: int
3375: nfsrv_pathconf(nfsd, slp, procp, mrq)
3376: struct nfsrv_descript *nfsd;
3377: struct nfssvc_sock *slp;
3378: struct proc *procp;
3379: struct mbuf **mrq;
3380: {
3381: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
3382: struct mbuf *nam = nfsd->nd_nam;
3383: caddr_t dpos = nfsd->nd_dpos;
3384: struct ucred *cred = &nfsd->nd_cr;
3385: register u_long *tl;
3386: register struct nfsv3_pathconf *pc;
3387: register long t1;
3388: caddr_t bpos;
3389: int error = 0, rdonly, cache, getret = 1, linkmax, namemax;
3390: int chownres, notrunc;
3391: char *cp2;
3392: struct mbuf *mb, *mb2, *mreq;
3393: struct vnode *vp;
3394: struct vattr at;
3395: nfsfh_t nfh;
3396: fhandle_t *fhp;
3397: u_quad_t frev;
3398:
3399: #ifndef nolint
3400: cache = 0;
3401: #endif
3402: fhp = &nfh.fh_generic;
3403: nfsm_srvmtofh(fhp);
3404: if ((error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam,
3405: &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE))) {
3406: nfsm_reply(NFSX_UNSIGNED);
3407: nfsm_srvpostop_attr(getret, &at);
3408: return (0);
3409: }
3410: error = VOP_PATHCONF(vp, _PC_LINK_MAX, &linkmax);
3411: if (!error)
3412: error = VOP_PATHCONF(vp, _PC_NAME_MAX, &namemax);
3413: if (!error)
3414: error = VOP_PATHCONF(vp, _PC_CHOWN_RESTRICTED, &chownres);
3415: if (!error)
3416: error = VOP_PATHCONF(vp, _PC_NO_TRUNC, ¬runc);
3417: getret = VOP_GETATTR(vp, &at, cred, procp);
3418: vput(vp);
3419: nfsm_reply(NFSX_V3POSTOPATTR + NFSX_V3PATHCONF);
3420: nfsm_srvpostop_attr(getret, &at);
3421: if (error)
3422: return (0);
3423: nfsm_build(pc, struct nfsv3_pathconf *, NFSX_V3PATHCONF);
3424:
3425: pc->pc_linkmax = txdr_unsigned(linkmax);
3426: pc->pc_namemax = txdr_unsigned(namemax);
3427: pc->pc_notrunc = txdr_unsigned(notrunc);
3428: pc->pc_chownrestricted = txdr_unsigned(chownres);
3429:
3430: /*
3431: * These should probably be supported by VOP_PATHCONF(), but
3432: * until msdosfs is exportable (why would you want to?), the
3433: * Unix defaults should be ok.
3434: */
3435: pc->pc_caseinsensitive = nfs_false;
3436: pc->pc_casepreserving = nfs_true;
3437: nfsm_srvdone;
3438: }
3439:
3440: /*
3441: * Null operation, used by clients to ping server
3442: */
3443: /* ARGSUSED */
3444: int
3445: nfsrv_null(nfsd, slp, procp, mrq)
3446: struct nfsrv_descript *nfsd;
3447: struct nfssvc_sock *slp;
3448: struct proc *procp;
3449: struct mbuf **mrq;
3450: {
3451: struct mbuf *mrep = nfsd->nd_mrep;
3452: caddr_t bpos;
3453: int error = NFSERR_RETVOID, cache;
3454: struct mbuf *mb, *mreq;
3455: u_quad_t frev;
3456:
3457: #ifndef nolint
3458: cache = 0;
3459: #endif
3460: nfsm_reply(0);
3461: return (0);
3462: }
3463:
3464: /*
3465: * No operation, used for obsolete procedures
3466: */
3467: /* ARGSUSED */
3468: int
3469: nfsrv_noop(nfsd, slp, procp, mrq)
3470: struct nfsrv_descript *nfsd;
3471: struct nfssvc_sock *slp;
3472: struct proc *procp;
3473: struct mbuf **mrq;
3474: {
3475: struct mbuf *mrep = nfsd->nd_mrep;
3476: caddr_t bpos;
3477: int error, cache;
3478: struct mbuf *mb, *mreq;
3479: u_quad_t frev;
3480:
3481: #ifndef nolint
3482: cache = 0;
3483: #endif
3484: if (nfsd->nd_repstat)
3485: error = nfsd->nd_repstat;
3486: else
3487: error = EPROCUNAVAIL;
3488: nfsm_reply(0);
3489: return (0);
3490: }
3491:
3492: /*
3493: * Perform access checking for vnodes obtained from file handles that would
3494: * refer to files already opened by a Unix client. You cannot just use
3495: * vn_writechk() and VOP_ACCESS() for two reasons.
3496: * 1 - You must check for exported rdonly as well as MNT_RDONLY for the write case
3497: * 2 - The owner is to be given access irrespective of mode bits so that
3498: * processes that chmod after opening a file don't break. I don't like
3499: * this because it opens a security hole, but since the nfs server opens
3500: * a security hole the size of a barn door anyhow, what the heck.
3501: */
3502: static int
3503: nfsrv_access(vp, flags, cred, rdonly, p)
3504: register struct vnode *vp;
3505: int flags;
3506: register struct ucred *cred;
3507: int rdonly;
3508: struct proc *p;
3509: {
3510: struct vattr vattr;
3511: int error;
3512: if (flags & VWRITE) {
3513: /* Just vn_writechk() changed to check rdonly */
3514: /*
3515: * Disallow write attempts on read-only file systems;
3516: * unless the file is a socket or a block or character
3517: * device resident on the file system.
3518: */
3519: if (rdonly || (vp->v_mount->mnt_flag & MNT_RDONLY)) {
3520: switch (vp->v_type) {
3521: case VREG: case VDIR: case VLNK: case VCPLX:
3522: return (EROFS);
3523: }
3524: }
3525: /*
3526: * If there's shared text associated with
3527: * the inode, we can't allow writing.
3528: */
3529: if (vp->v_flag & VTEXT)
3530: return (ETXTBSY);
3531: }
3532: if ((error = VOP_GETATTR(vp, &vattr, cred, p)))
3533: return (error);
3534: if ((error = VOP_ACCESS(vp, flags, cred, p)) &&
3535: cred->cr_uid != vattr.va_uid)
3536: return (error);
3537: return (0);
3538: }
3539: #endif /* NFS_NOSERVER */
3540:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.