![[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 Darwin 0.x] / kernel / bsd / nfs|
Return to nfs_serv.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / nfs |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
26: /*
27: * Copyright (c) 1989, 1993
28: * The Regents of the University of California. All rights reserved.
29: *
30: * This code is derived from software contributed to Berkeley by
31: * Rick Macklem at The University of Guelph.
32: *
33: * Redistribution and use in source and binary forms, with or without
34: * modification, are permitted provided that the following conditions
35: * are met:
36: * 1. Redistributions of source code must retain the above copyright
37: * notice, this list of conditions and the following disclaimer.
38: * 2. Redistributions in binary form must reproduce the above copyright
39: * notice, this list of conditions and the following disclaimer in the
40: * documentation and/or other materials provided with the distribution.
41: * 3. All advertising materials mentioning features or use of this software
42: * must display the following acknowledgement:
43: * This product includes software developed by the University of
44: * California, Berkeley and its contributors.
45: * 4. Neither the name of the University nor the names of its contributors
46: * may be used to endorse or promote products derived from this software
47: * without specific prior written permission.
48: *
49: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
50: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
51: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
52: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
53: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
54: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
55: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
56: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
57: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
58: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
59: * SUCH DAMAGE.
60: *
61: * @(#)nfs_serv.c 8.7 (Berkeley) 5/14/95
62: * FreeBSD-Id: nfs_serv.c,v 1.52 1997/10/28 15:59:05 bde Exp $
63: */
64:
65: /*
66: * nfs version 2 and 3 server calls to vnode ops
67: * - these routines generally have 3 phases
68: * 1 - break down and validate rpc request in mbuf list
69: * 2 - do the vnode ops for the request
70: * (surprisingly ?? many are very similar to syscalls in vfs_syscalls.c)
71: * 3 - build the rpc reply in an mbuf list
72: * nb:
73: * - do not mix the phases, since the nfsm_?? macros can return failures
74: * on a bad rpc or similar and do not do any vrele() or vput()'s
75: *
76: * - the nfsm_reply() macro generates an nfs rpc reply with the nfs
77: * error number iff error != 0 whereas
78: * returning an error from the server function implies a fatal error
79: * such as a badly constructed rpc request that should be dropped without
80: * a reply.
81: * For Version 3, nfsm_reply() does not return for the error case, since
82: * most version 3 rpcs return more than the status for error cases.
83: */
84:
85: #include <mach_nbc.h>
86: #include <sys/param.h>
87: #include <sys/systm.h>
88: #include <sys/proc.h>
89: #include <sys/namei.h>
90: #include <sys/unistd.h>
91: #include <sys/malloc.h>
92: #include <sys/vnode.h>
93: #include <sys/mount.h>
94: #include <sys/socket.h>
95: #include <sys/socketvar.h>
96: #include <sys/mbuf.h>
97: #include <sys/dirent.h>
98: #include <sys/stat.h>
99: #include <sys/kernel.h>
100: #include <sys/sysctl.h>
101: #include <ufs/ufs/dir.h>
102:
103: #include <sys/vm.h>
104: #include <sys/vmparam.h>
105: #include <machine/spl.h>
106:
107: #include <kern/mapfs.h>
108:
109: #include <nfs/nfsproto.h>
110: #include <nfs/rpcv2.h>
111: #include <nfs/nfs.h>
112: #include <nfs/xdr_subs.h>
113: #include <nfs/nfsm_subs.h>
114: #include <nfs/nqnfs.h>
115:
116: nfstype nfsv3_type[9] = { NFNON, NFREG, NFDIR, NFBLK, NFCHR, NFLNK, NFSOCK,
117: NFFIFO, NFNON };
118: #ifndef NFS_NOSERVER
119: nfstype nfsv2_type[9] = { NFNON, NFREG, NFDIR, NFBLK, NFCHR, NFLNK, NFNON,
120: NFCHR, NFNON };
121: /* Global vars */
122: extern u_long nfs_xdrneg1;
123: extern u_long nfs_false, nfs_true;
124: extern enum vtype nv3tov_type[8];
125: extern struct nfsstats nfsstats;
126:
127: int nfsrvw_procrastinate = NFS_GATHERDELAY * 1000;
128: int nfsrvw_procrastinate_v3 = 0;
129:
130: int nfs_async = 0;
131: #ifdef notyet
132: /* XXX CSM 11/25/97 Upgrade sysctl.h someday */
133: SYSCTL_INT(_vfs_nfs, OID_AUTO, async, CTLFLAG_RW, &nfs_async, 0, "");
134: #endif
135:
136: static int nfsrv_access __P((struct vnode *,int,struct ucred *,int,
137: struct proc *));
138: static void nfsrvw_coalesce __P((struct nfsrv_descript *,
139: struct nfsrv_descript *));
140:
141: extern int vnode_uncache(struct vnode *vp);
142:
143: /*
144: * nfs v3 access service
145: */
146: int
147: nfsrv3_access(nfsd, slp, procp, mrq)
148: struct nfsrv_descript *nfsd;
149: struct nfssvc_sock *slp;
150: struct proc *procp;
151: struct mbuf **mrq;
152: {
153: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
154: struct mbuf *nam = nfsd->nd_nam;
155: caddr_t dpos = nfsd->nd_dpos;
156: struct ucred *cred = &nfsd->nd_cr;
157: struct vnode *vp;
158: nfsfh_t nfh;
159: fhandle_t *fhp;
160: register u_long *tl;
161: register long t1;
162: caddr_t bpos;
163: int error = 0, rdonly, cache, getret;
164: char *cp2;
165: struct mbuf *mb, *mreq, *mb2;
166: struct vattr vattr, *vap = &vattr;
167: u_long testmode, nfsmode;
168: u_quad_t frev;
169:
170: #ifndef nolint
171: cache = 0;
172: #endif
173: fhp = &nfh.fh_generic;
174: nfsm_srvmtofh(fhp);
175: nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
176: if ((error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam,
177: &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE))) {
178: nfsm_reply(NFSX_UNSIGNED);
179: nfsm_srvpostop_attr(1, (struct vattr *)0);
180: return (0);
181: }
182: nfsmode = fxdr_unsigned(u_long, *tl);
183: if ((nfsmode & NFSV3ACCESS_READ) &&
184: nfsrv_access(vp, VREAD, cred, rdonly, procp))
185: nfsmode &= ~NFSV3ACCESS_READ;
186: if (vp->v_type == VDIR)
187: testmode = (NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND |
188: NFSV3ACCESS_DELETE);
189: else
190: testmode = (NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND);
191: if ((nfsmode & testmode) &&
192: nfsrv_access(vp, VWRITE, cred, rdonly, procp))
193: nfsmode &= ~testmode;
194: if (vp->v_type == VDIR)
195: testmode = NFSV3ACCESS_LOOKUP;
196: else
197: testmode = NFSV3ACCESS_EXECUTE;
198: if ((nfsmode & testmode) &&
199: nfsrv_access(vp, VEXEC, cred, rdonly, procp))
200: nfsmode &= ~testmode;
201: getret = VOP_GETATTR(vp, vap, cred, procp);
202: vput(vp);
203: nfsm_reply(NFSX_POSTOPATTR(1) + NFSX_UNSIGNED);
204: nfsm_srvpostop_attr(getret, vap);
205: nfsm_build(tl, u_long *, NFSX_UNSIGNED);
206: *tl = txdr_unsigned(nfsmode);
207: nfsm_srvdone;
208: }
209:
210: /*
211: * nfs getattr service
212: */
213: int
214: nfsrv_getattr(nfsd, slp, procp, mrq)
215: struct nfsrv_descript *nfsd;
216: struct nfssvc_sock *slp;
217: struct proc *procp;
218: struct mbuf **mrq;
219: {
220: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
221: struct mbuf *nam = nfsd->nd_nam;
222: caddr_t dpos = nfsd->nd_dpos;
223: struct ucred *cred = &nfsd->nd_cr;
224: register struct nfs_fattr *fp;
225: struct vattr va;
226: register struct vattr *vap = &va;
227: struct vnode *vp;
228: nfsfh_t nfh;
229: fhandle_t *fhp;
230: register u_long *tl;
231: register long t1;
232: caddr_t bpos;
233: int error = 0, rdonly, cache;
234: char *cp2;
235: struct mbuf *mb, *mb2, *mreq;
236: u_quad_t frev;
237:
238: fhp = &nfh.fh_generic;
239: nfsm_srvmtofh(fhp);
240: if ((error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam,
241: &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE))) {
242: nfsm_reply(0);
243: return (0);
244: }
245: nqsrv_getl(vp, ND_READ);
246: error = VOP_GETATTR(vp, vap, cred, procp);
247: vput(vp);
248: nfsm_reply(NFSX_FATTR(nfsd->nd_flag & ND_NFSV3));
249: if (error)
250: return (0);
251: nfsm_build(fp, struct nfs_fattr *, NFSX_FATTR(nfsd->nd_flag & ND_NFSV3));
252: nfsm_srvfillattr(vap, fp);
253: nfsm_srvdone;
254: }
255:
256: /*
257: * nfs setattr service
258: */
259: int
260: nfsrv_setattr(nfsd, slp, procp, mrq)
261: struct nfsrv_descript *nfsd;
262: struct nfssvc_sock *slp;
263: struct proc *procp;
264: struct mbuf **mrq;
265: {
266: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
267: struct mbuf *nam = nfsd->nd_nam;
268: caddr_t dpos = nfsd->nd_dpos;
269: struct ucred *cred = &nfsd->nd_cr;
270: struct vattr va, preat;
271: register struct vattr *vap = &va;
272: register struct nfsv2_sattr *sp;
273: register struct nfs_fattr *fp;
274: struct vnode *vp;
275: nfsfh_t nfh;
276: fhandle_t *fhp;
277: register u_long *tl;
278: register long t1;
279: caddr_t bpos;
280: int error = 0, rdonly, cache, preat_ret = 1, postat_ret = 1;
281: int v3 = (nfsd->nd_flag & ND_NFSV3), gcheck = 0;
282: char *cp2;
283: struct mbuf *mb, *mb2, *mreq;
284: u_quad_t frev;
285: struct timespec guard;
286:
287: fhp = &nfh.fh_generic;
288: nfsm_srvmtofh(fhp);
289: VATTR_NULL(vap);
290: if (v3) {
291: nfsm_srvsattr(vap);
292: nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
293: gcheck = fxdr_unsigned(int, *tl);
294: if (gcheck) {
295: nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED);
296: fxdr_nfsv3time(tl, &guard);
297: }
298: } else {
299: nfsm_dissect(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
300: /*
301: * Nah nah nah nah na nah
302: * There is a bug in the Sun client that puts 0xffff in the mode
303: * field of sattr when it should put in 0xffffffff. The u_short
304: * doesn't sign extend.
305: * --> check the low order 2 bytes for 0xffff
306: */
307: if ((fxdr_unsigned(int, sp->sa_mode) & 0xffff) != 0xffff)
308: vap->va_mode = nfstov_mode(sp->sa_mode);
309: if (sp->sa_uid != nfs_xdrneg1)
310: vap->va_uid = fxdr_unsigned(uid_t, sp->sa_uid);
311: if (sp->sa_gid != nfs_xdrneg1)
312: vap->va_gid = fxdr_unsigned(gid_t, sp->sa_gid);
313: if (sp->sa_size != nfs_xdrneg1)
314: vap->va_size = fxdr_unsigned(u_quad_t, sp->sa_size);
315: if (sp->sa_atime.nfsv2_sec != nfs_xdrneg1) {
316: #ifdef notyet
317: fxdr_nfsv2time(&sp->sa_atime, &vap->va_atime);
318: #else
319: vap->va_atime.tv_sec =
320: fxdr_unsigned(long, sp->sa_atime.nfsv2_sec);
321: vap->va_atime.tv_nsec = 0;
322: #endif
323: }
324: if (sp->sa_mtime.nfsv2_sec != nfs_xdrneg1)
325: fxdr_nfsv2time(&sp->sa_mtime, &vap->va_mtime);
326:
327: }
328:
329: /*
330: * Now that we have all the fields, lets do it.
331: */
332: if ((error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam,
333: &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE))) {
334: nfsm_reply(2 * NFSX_UNSIGNED);
335: nfsm_srvwcc_data(preat_ret, &preat, postat_ret, vap);
336: return (0);
337: }
338: nqsrv_getl(vp, ND_WRITE);
339: if (v3) {
340: error = preat_ret = VOP_GETATTR(vp, &preat, cred, procp);
341: if (!error && gcheck &&
342: (preat.va_ctime.tv_sec != guard.tv_sec ||
343: preat.va_ctime.tv_nsec != guard.tv_nsec))
344: error = NFSERR_NOT_SYNC;
345: if (error) {
346: vput(vp);
347: nfsm_reply(NFSX_WCCDATA(v3));
348: nfsm_srvwcc_data(preat_ret, &preat, postat_ret, vap);
349: return (0);
350: }
351: }
352:
353: /*
354: * If the size is being changed write acces is required, otherwise
355: * just check for a read only file system.
356: */
357: if (vap->va_size == ((u_quad_t)((quad_t) -1))) {
358: if (rdonly || (vp->v_mount->mnt_flag & MNT_RDONLY)) {
359: error = EROFS;
360: goto out;
361: }
362: } else {
363: if (vp->v_type == VDIR) {
364: error = EISDIR;
365: goto out;
366: } else if ((error = nfsrv_access(vp, VWRITE, cred, rdonly,
367: procp)))
368: goto out;
369: }
370: error = VOP_SETATTR(vp, vap, cred, procp);
371: postat_ret = VOP_GETATTR(vp, vap, cred, procp);
372: if (!error)
373: error = postat_ret;
374: out:
375: vput(vp);
376: nfsm_reply(NFSX_WCCORFATTR(v3));
377: if (v3) {
378: nfsm_srvwcc_data(preat_ret, &preat, postat_ret, vap);
379: return (0);
380: } else {
381: nfsm_build(fp, struct nfs_fattr *, NFSX_V2FATTR);
382: nfsm_srvfillattr(vap, fp);
383: }
384: nfsm_srvdone;
385: }
386:
387: /*
388: * nfs lookup rpc
389: */
390: int
391: nfsrv_lookup(nfsd, slp, procp, mrq)
392: struct nfsrv_descript *nfsd;
393: struct nfssvc_sock *slp;
394: struct proc *procp;
395: struct mbuf **mrq;
396: {
397: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
398: struct mbuf *nam = nfsd->nd_nam;
399: caddr_t dpos = nfsd->nd_dpos;
400: struct ucred *cred = &nfsd->nd_cr;
401: register struct nfs_fattr *fp;
402: struct nameidata nd, *ndp = &nd;
403: #ifdef notdef
404: struct nameidata ind;
405: #endif
406: struct vnode *vp, *dirp;
407: nfsfh_t nfh;
408: fhandle_t *fhp;
409: register caddr_t cp;
410: register u_long *tl;
411: register long t1;
412: caddr_t bpos;
413: int error = 0, cache, len, dirattr_ret = 1;
414: int v3 = (nfsd->nd_flag & ND_NFSV3), pubflag;
415: char *cp2;
416: struct mbuf *mb, *mb2, *mreq;
417: struct vattr va, dirattr, *vap = &va;
418: u_quad_t frev;
419:
420: fhp = &nfh.fh_generic;
421: nfsm_srvmtofh(fhp);
422: nfsm_srvnamesiz(len);
423:
424: pubflag = nfs_ispublicfh(fhp);
425:
426: nd.ni_cnd.cn_cred = cred;
427: nd.ni_cnd.cn_nameiop = LOOKUP;
428: nd.ni_cnd.cn_flags = LOCKLEAF | SAVESTART;
429: error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos,
430: &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), pubflag);
431:
432: /* XXX CSM 12/4/97 Revisit when enabling WebNFS */
433: #ifdef notyet
434: if (!error && pubflag) {
435: if (nd.ni_vp->v_type == VDIR && nfs_pub.np_index != NULL) {
436: /*
437: * Setup call to lookup() to see if we can find
438: * the index file. Arguably, this doesn't belong
439: * in a kernel.. Ugh.
440: */
441: ind = nd;
442: VOP_UNLOCK(nd.ni_vp, 0, procp);
443: ind.ni_pathlen = strlen(nfs_pub.np_index);
444: ind.ni_cnd.cn_nameptr = ind.ni_cnd.cn_pnbuf =
445: nfs_pub.np_index;
446: ind.ni_startdir = nd.ni_vp;
447: VREF(ind.ni_startdir);
448: error = lookup(&ind);
449: if (!error) {
450: /*
451: * Found an index file. Get rid of
452: * the old references.
453: */
454: if (dirp)
455: vrele(dirp);
456: dirp = nd.ni_vp;
457: vrele(nd.ni_startdir);
458: ndp = &ind;
459: } else
460: error = 0;
461: }
462: /*
463: * If the public filehandle was used, check that this lookup
464: * didn't result in a filehandle outside the publicly exported
465: * filesystem.
466: */
467:
468: if (!error && ndp->ni_vp->v_mount != nfs_pub.np_mount) {
469: vput(nd.ni_vp);
470: error = EPERM;
471: }
472: }
473: #endif
474:
475: if (dirp) {
476: if (v3)
477: dirattr_ret = VOP_GETATTR(dirp, &dirattr, cred,
478: procp);
479: vrele(dirp);
480: }
481:
482: if (error) {
483: nfsm_reply(NFSX_POSTOPATTR(v3));
484: nfsm_srvpostop_attr(dirattr_ret, &dirattr);
485: return (0);
486: }
487:
488: nqsrv_getl(ndp->ni_startdir, ND_READ);
489: vrele(ndp->ni_startdir);
490: FREE_ZONE(nd.ni_cnd.cn_pnbuf, nd.ni_cnd.cn_pnlen, M_NAMEI);
491: vp = ndp->ni_vp;
492: bzero((caddr_t)fhp, sizeof(nfh));
493: fhp->fh_fsid = vp->v_mount->mnt_stat.f_fsid;
494: error = VFS_VPTOFH(vp, &fhp->fh_fid);
495: if (!error)
496: error = VOP_GETATTR(vp, vap, cred, procp);
497: vput(vp);
498: nfsm_reply(NFSX_SRVFH(v3) + NFSX_POSTOPORFATTR(v3) + NFSX_POSTOPATTR(v3));
499: if (error) {
500: nfsm_srvpostop_attr(dirattr_ret, &dirattr);
501: return (0);
502: }
503: nfsm_srvfhtom(fhp, v3);
504: if (v3) {
505: nfsm_srvpostop_attr(0, vap);
506: nfsm_srvpostop_attr(dirattr_ret, &dirattr);
507: } else {
508: nfsm_build(fp, struct nfs_fattr *, NFSX_V2FATTR);
509: nfsm_srvfillattr(vap, fp);
510: }
511: nfsm_srvdone;
512: }
513:
514: /*
515: * nfs readlink service
516: */
517: int
518: nfsrv_readlink(nfsd, slp, procp, mrq)
519: struct nfsrv_descript *nfsd;
520: struct nfssvc_sock *slp;
521: struct proc *procp;
522: struct mbuf **mrq;
523: {
524: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
525: struct mbuf *nam = nfsd->nd_nam;
526: caddr_t dpos = nfsd->nd_dpos;
527: struct ucred *cred = &nfsd->nd_cr;
528: struct iovec iv[(NFS_MAXPATHLEN+MLEN-1)/MLEN];
529: register struct iovec *ivp = iv;
530: register struct mbuf *mp;
531: register u_long *tl;
532: register long t1;
533: caddr_t bpos;
534: int error = 0, rdonly, cache, i, tlen, len, getret;
535: int v3 = (nfsd->nd_flag & ND_NFSV3);
536: char *cp2;
537: struct mbuf *mb, *mb2, *mp2, *mp3, *mreq;
538: struct vnode *vp;
539: struct vattr attr;
540: nfsfh_t nfh;
541: fhandle_t *fhp;
542: struct uio io, *uiop = &io;
543: u_quad_t frev;
544:
545: #ifndef nolint
546: mp2 = mp3 = (struct mbuf *)0;
547: #endif
548: fhp = &nfh.fh_generic;
549: nfsm_srvmtofh(fhp);
550: len = 0;
551: i = 0;
552: while (len < NFS_MAXPATHLEN) {
553: MGET(mp, M_WAIT, MT_DATA);
554: MCLGET(mp, M_WAIT);
555: mp->m_len = NFSMSIZ(mp);
556: if (len == 0)
557: mp3 = mp2 = mp;
558: else {
559: mp2->m_next = mp;
560: mp2 = mp;
561: }
562: if ((len+mp->m_len) > NFS_MAXPATHLEN) {
563: mp->m_len = NFS_MAXPATHLEN-len;
564: len = NFS_MAXPATHLEN;
565: } else
566: len += mp->m_len;
567: ivp->iov_base = mtod(mp, caddr_t);
568: ivp->iov_len = mp->m_len;
569: i++;
570: ivp++;
571: }
572: uiop->uio_iov = iv;
573: uiop->uio_iovcnt = i;
574: uiop->uio_offset = 0;
575: uiop->uio_resid = len;
576: uiop->uio_rw = UIO_READ;
577: uiop->uio_segflg = UIO_SYSSPACE;
578: uiop->uio_procp = (struct proc *)0;
579: if ((error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam,
580: &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE))) {
581: m_freem(mp3);
582: nfsm_reply(2 * NFSX_UNSIGNED);
583: nfsm_srvpostop_attr(1, (struct vattr *)0);
584: return (0);
585: }
586: if (vp->v_type != VLNK) {
587: if (v3)
588: error = EINVAL;
589: else
590: error = ENXIO;
591: goto out;
592: }
593: nqsrv_getl(vp, ND_READ);
594: error = VOP_READLINK(vp, uiop, cred);
595: out:
596: getret = VOP_GETATTR(vp, &attr, cred, procp);
597: vput(vp);
598: if (error)
599: m_freem(mp3);
600: nfsm_reply(NFSX_POSTOPATTR(v3) + NFSX_UNSIGNED);
601: if (v3) {
602: nfsm_srvpostop_attr(getret, &attr);
603: if (error)
604: return (0);
605: }
606: if (uiop->uio_resid > 0) {
607: len -= uiop->uio_resid;
608: tlen = nfsm_rndup(len);
609: nfsm_adj(mp3, NFS_MAXPATHLEN-tlen, tlen-len);
610: }
611: nfsm_build(tl, u_long *, NFSX_UNSIGNED);
612: *tl = txdr_unsigned(len);
613: mb->m_next = mp3;
614: nfsm_srvdone;
615: }
616:
617: /*
618: * nfs read service
619: */
620: int
621: nfsrv_read(nfsd, slp, procp, mrq)
622: struct nfsrv_descript *nfsd;
623: struct nfssvc_sock *slp;
624: struct proc *procp;
625: struct mbuf **mrq;
626: {
627: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
628: struct mbuf *nam = nfsd->nd_nam;
629: caddr_t dpos = nfsd->nd_dpos;
630: struct ucred *cred = &nfsd->nd_cr;
631: register struct iovec *iv;
632: struct iovec *iv2;
633: register struct mbuf *m;
634: register struct nfs_fattr *fp;
635: register u_long *tl;
636: register long t1;
637: register int i;
638: caddr_t bpos;
639: int error = 0, rdonly, cache, cnt, len, left, siz, tlen, getret;
640: int v3 = (nfsd->nd_flag & ND_NFSV3), reqlen;
641: char *cp2;
642: struct mbuf *mb, *mb2, *mreq;
643: struct mbuf *m2;
644: struct vnode *vp;
645: nfsfh_t nfh;
646: fhandle_t *fhp;
647: struct uio io, *uiop = &io;
648: struct vattr va, *vap = &va;
649: off_t off;
650: u_quad_t frev;
651:
652: fhp = &nfh.fh_generic;
653: nfsm_srvmtofh(fhp);
654: if (v3) {
655: nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED);
656: fxdr_hyper(tl, &off);
657: } else {
658: nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
659: off = (off_t)fxdr_unsigned(u_long, *tl);
660: }
661: nfsm_srvstrsiz(reqlen, NFS_SRVMAXDATA(nfsd));
662: if ((error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam,
663: &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE))) {
664: nfsm_reply(2 * NFSX_UNSIGNED);
665: nfsm_srvpostop_attr(1, (struct vattr *)0);
666: return (0);
667: }
668: if (vp->v_type != VREG) {
669: if (v3)
670: error = EINVAL;
671: else
672: error = (vp->v_type == VDIR) ? EISDIR : EACCES;
673: }
674: if (!error) {
675: nqsrv_getl(vp, ND_READ);
676: if ((error = nfsrv_access(vp, VREAD, cred, rdonly, procp)))
677: error = nfsrv_access(vp, VEXEC, cred, rdonly, procp);
678: }
679: getret = VOP_GETATTR(vp, vap, cred, procp);
680: if (!error)
681: error = getret;
682: if (error) {
683: vput(vp);
684: nfsm_reply(NFSX_POSTOPATTR(v3));
685: nfsm_srvpostop_attr(getret, vap);
686: return (0);
687: }
688: if (off >= vap->va_size)
689: cnt = 0;
690: else if ((off + reqlen) > vap->va_size)
691: cnt = nfsm_rndup(vap->va_size - off);
692: else
693: cnt = reqlen;
694: nfsm_reply(NFSX_POSTOPORFATTR(v3) + 3 * NFSX_UNSIGNED+nfsm_rndup(cnt));
695: if (v3) {
696: nfsm_build(tl, u_long *, NFSX_V3FATTR + 4 * NFSX_UNSIGNED);
697: *tl++ = nfs_true;
698: fp = (struct nfs_fattr *)tl;
699: tl += (NFSX_V3FATTR / sizeof (u_long));
700: } else {
701: nfsm_build(tl, u_long *, NFSX_V2FATTR + NFSX_UNSIGNED);
702: fp = (struct nfs_fattr *)tl;
703: tl += (NFSX_V2FATTR / sizeof (u_long));
704: }
705: len = left = cnt;
706: if (cnt > 0) {
707: /*
708: * Generate the mbuf list with the uio_iov ref. to it.
709: */
710: i = 0;
711: m = m2 = mb;
712: while (left > 0) {
713: siz = min(M_TRAILINGSPACE(m), left);
714: if (siz > 0) {
715: left -= siz;
716: i++;
717: }
718: if (left > 0) {
719: MGET(m, M_WAIT, MT_DATA);
720: MCLGET(m, M_WAIT);
721: m->m_len = 0;
722: m2->m_next = m;
723: m2 = m;
724: }
725: }
726: MALLOC(iv, struct iovec *, i * sizeof (struct iovec),
727: M_TEMP, M_WAITOK);
728: uiop->uio_iov = iv2 = iv;
729: m = mb;
730: left = cnt;
731: i = 0;
732: while (left > 0) {
733: if (m == NULL)
734: panic("nfsrv_read iov");
735: siz = min(M_TRAILINGSPACE(m), left);
736: if (siz > 0) {
737: iv->iov_base = mtod(m, caddr_t) + m->m_len;
738: iv->iov_len = siz;
739: m->m_len += siz;
740: left -= siz;
741: iv++;
742: i++;
743: }
744: m = m->m_next;
745: }
746: uiop->uio_iovcnt = i;
747: uiop->uio_offset = off;
748: uiop->uio_resid = cnt;
749: uiop->uio_rw = UIO_READ;
750: uiop->uio_segflg = UIO_SYSSPACE;
751: #if MACH_NBC
752: if (vp->v_type == VREG) {
753: uiop->uio_procp = procp;
754: map_vnode(vp, procp);
755: error = mapfs_io(vp, uiop, uiop->uio_rw,
756: IO_NODELOCKED, cred);
757: unmap_vnode(vp, procp);
758: } else
759: #endif /* MACH_NBC */
760: error = VOP_READ(vp, uiop, IO_NODELOCKED, cred);
761: off = uiop->uio_offset;
762: FREE((caddr_t)iv2, M_TEMP);
763: if (error || (getret = VOP_GETATTR(vp, vap, cred, procp))) {
764: if (!error)
765: error = getret;
766: m_freem(mreq);
767: vput(vp);
768: nfsm_reply(NFSX_POSTOPATTR(v3));
769: nfsm_srvpostop_attr(getret, vap);
770: return (0);
771: }
772: } else
773: uiop->uio_resid = 0;
774: vput(vp);
775: nfsm_srvfillattr(vap, fp);
776: len -= uiop->uio_resid;
777: tlen = nfsm_rndup(len);
778: if (cnt != tlen || tlen != len)
779: nfsm_adj(mb, cnt - tlen, tlen - len);
780: if (v3) {
781: *tl++ = txdr_unsigned(len);
782: if (len < reqlen)
783: *tl++ = nfs_true;
784: else
785: *tl++ = nfs_false;
786: }
787: *tl = txdr_unsigned(len);
788: nfsm_srvdone;
789: }
790:
791: /*
792: * nfs write service
793: */
794: int
795: nfsrv_write(nfsd, slp, procp, mrq)
796: struct nfsrv_descript *nfsd;
797: struct nfssvc_sock *slp;
798: struct proc *procp;
799: struct mbuf **mrq;
800: {
801: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
802: struct mbuf *nam = nfsd->nd_nam;
803: caddr_t dpos = nfsd->nd_dpos;
804: struct ucred *cred = &nfsd->nd_cr;
805: register struct iovec *ivp;
806: register int i, cnt;
807: register struct mbuf *mp;
808: register struct nfs_fattr *fp;
809: struct iovec *iv;
810: struct vattr va, forat;
811: register struct vattr *vap = &va;
812: register u_long *tl;
813: register long t1;
814: caddr_t bpos;
815: int error = 0, rdonly, cache, len, forat_ret = 1;
816: int ioflags, aftat_ret = 1, retlen, zeroing, adjust;
817: int stable = NFSV3WRITE_FILESYNC;
818: int v3 = (nfsd->nd_flag & ND_NFSV3);
819: char *cp2;
820: struct mbuf *mb, *mb2, *mreq;
821: struct vnode *vp;
822: nfsfh_t nfh;
823: fhandle_t *fhp;
824: struct uio io, *uiop = &io;
825: off_t off;
826: u_quad_t frev;
827:
828: if (mrep == NULL) {
829: *mrq = NULL;
830: return (0);
831: }
832: fhp = &nfh.fh_generic;
833: nfsm_srvmtofh(fhp);
834: if (v3) {
835: nfsm_dissect(tl, u_long *, 5 * NFSX_UNSIGNED);
836: fxdr_hyper(tl, &off);
837: tl += 3;
838: stable = fxdr_unsigned(int, *tl++);
839: } else {
840: nfsm_dissect(tl, u_long *, 4 * NFSX_UNSIGNED);
841: off = (off_t)fxdr_unsigned(u_long, *++tl);
842: tl += 2;
843: if (nfs_async)
844: stable = NFSV3WRITE_UNSTABLE;
845: }
846: retlen = len = fxdr_unsigned(long, *tl);
847: cnt = i = 0;
848:
849: /*
850: * For NFS Version 2, it is not obvious what a write of zero length
851: * should do, but I might as well be consistent with Version 3,
852: * which is to return ok so long as there are no permission problems.
853: */
854: if (len > 0) {
855: zeroing = 1;
856: mp = mrep;
857: while (mp) {
858: if (mp == md) {
859: zeroing = 0;
860: adjust = dpos - mtod(mp, caddr_t);
861: mp->m_len -= adjust;
862: if (mp->m_len > 0 && adjust > 0)
863: NFSMADV(mp, adjust);
864: }
865: if (zeroing)
866: mp->m_len = 0;
867: else if (mp->m_len > 0) {
868: i += mp->m_len;
869: if (i > len) {
870: mp->m_len -= (i - len);
871: zeroing = 1;
872: }
873: if (mp->m_len > 0)
874: cnt++;
875: }
876: mp = mp->m_next;
877: }
878: }
879: if (len > NFS_MAXDATA || len < 0 || i < len) {
880: error = EIO;
881: nfsm_reply(2 * NFSX_UNSIGNED);
882: nfsm_srvwcc_data(forat_ret, &forat, aftat_ret, vap);
883: return (0);
884: }
885: if ((error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam,
886: &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE))) {
887: nfsm_reply(2 * NFSX_UNSIGNED);
888: nfsm_srvwcc_data(forat_ret, &forat, aftat_ret, vap);
889: return (0);
890: }
891: if (v3)
892: forat_ret = VOP_GETATTR(vp, &forat, cred, procp);
893: if (vp->v_type != VREG) {
894: if (v3)
895: error = EINVAL;
896: else
897: error = (vp->v_type == VDIR) ? EISDIR : EACCES;
898: }
899: if (!error) {
900: nqsrv_getl(vp, ND_WRITE);
901: error = nfsrv_access(vp, VWRITE, cred, rdonly, procp);
902: }
903: if (error) {
904: vput(vp);
905: nfsm_reply(NFSX_WCCDATA(v3));
906: nfsm_srvwcc_data(forat_ret, &forat, aftat_ret, vap);
907: return (0);
908: }
909:
910: if (len > 0) {
911: MALLOC(ivp, struct iovec *, cnt * sizeof (struct iovec), M_TEMP,
912: M_WAITOK);
913: uiop->uio_iov = iv = ivp;
914: uiop->uio_iovcnt = cnt;
915: mp = mrep;
916: while (mp) {
917: if (mp->m_len > 0) {
918: ivp->iov_base = mtod(mp, caddr_t);
919: ivp->iov_len = mp->m_len;
920: ivp++;
921: }
922: mp = mp->m_next;
923: }
924:
925: /*
926: * XXX
927: * The IO_METASYNC flag indicates that all metadata (and not just
928: * enough to ensure data integrity) mus be written to stable storage
929: * synchronously.
930: * (IO_METASYNC is not yet implemented in 4.4BSD-Lite.)
931: */
932: if (stable == NFSV3WRITE_UNSTABLE)
933: ioflags = IO_NODELOCKED;
934: else if (stable == NFSV3WRITE_DATASYNC)
935: ioflags = (IO_SYNC | IO_NODELOCKED);
936: else
937: ioflags = (IO_METASYNC | IO_SYNC | IO_NODELOCKED);
938: uiop->uio_resid = len;
939: uiop->uio_rw = UIO_WRITE;
940: uiop->uio_segflg = UIO_SYSSPACE;
941: uiop->uio_procp = (struct proc *)0;
942: uiop->uio_offset = off;
943: #if MACH_NBC
944: if (vp->v_type == VREG) {
945: map_vnode(vp, procp);
946: error = mapfs_io(vp, uiop, uiop->uio_rw, ioflags, cred);
947: unmap_vnode(vp, procp);
948: } else
949: #endif /* MACH_NBC */
950: error = VOP_WRITE(vp, uiop, ioflags, cred);
951: nfsstats.srvvop_writes++;
952: FREE((caddr_t)iv, M_TEMP);
953: }
954: aftat_ret = VOP_GETATTR(vp, vap, cred, procp);
955: vput(vp);
956: if (!error)
957: error = aftat_ret;
958: nfsm_reply(NFSX_PREOPATTR(v3) + NFSX_POSTOPORFATTR(v3) +
959: 2 * NFSX_UNSIGNED + NFSX_WRITEVERF(v3));
960: if (v3) {
961: nfsm_srvwcc_data(forat_ret, &forat, aftat_ret, vap);
962: if (error)
963: return (0);
964: nfsm_build(tl, u_long *, 4 * NFSX_UNSIGNED);
965: *tl++ = txdr_unsigned(retlen);
966: /*
967: * If nfs_async is set, then pretend the write was FILESYNC.
968: */
969: if (stable == NFSV3WRITE_UNSTABLE && !nfs_async)
970: *tl++ = txdr_unsigned(stable);
971: else
972: *tl++ = txdr_unsigned(NFSV3WRITE_FILESYNC);
973: /*
974: * Actually, there is no need to txdr these fields,
975: * but it may make the values more human readable,
976: * for debugging purposes.
977: */
978: *tl++ = txdr_unsigned(boottime.tv_sec);
979: *tl = txdr_unsigned(boottime.tv_usec);
980: } else {
981: nfsm_build(fp, struct nfs_fattr *, NFSX_V2FATTR);
982: nfsm_srvfillattr(vap, fp);
983: }
984: nfsm_srvdone;
985: }
986:
987: /*
988: * NFS write service with write gathering support. Called when
989: * nfsrvw_procrastinate > 0.
990: * See: Chet Juszczak, "Improving the Write Performance of an NFS Server",
991: * in Proc. of the Winter 1994 Usenix Conference, pg. 247-259, San Franscisco,
992: * Jan. 1994.
993: */
994: int
995: nfsrv_writegather(ndp, slp, procp, mrq)
996: struct nfsrv_descript **ndp;
997: struct nfssvc_sock *slp;
998: struct proc *procp;
999: struct mbuf **mrq;
1000: {
1001: register struct iovec *ivp;
1002: register struct mbuf *mp;
1003: register struct nfsrv_descript *wp, *nfsd, *owp, *swp;
1004: register struct nfs_fattr *fp;
1005: register int i;
1006: struct iovec *iov;
1007: struct nfsrvw_delayhash *wpp;
1008: struct ucred *cred;
1009: struct vattr va, forat;
1010: register u_long *tl;
1011: register long t1;
1012: caddr_t bpos, dpos;
1013: int error = 0, rdonly, cache, len, forat_ret = 1;
1014: int ioflags, aftat_ret = 1, s, adjust, v3, zeroing;
1015: char *cp2;
1016: struct mbuf *mb, *mb2, *mreq, *mrep, *md;
1017: struct vnode *vp;
1018: struct uio io, *uiop = &io;
1019: u_quad_t frev, cur_usec;
1020:
1021: #ifndef nolint
1022: i = 0;
1023: len = 0;
1024: #endif
1025: *mrq = NULL;
1026: if (*ndp) {
1027: nfsd = *ndp;
1028: *ndp = NULL;
1029: mrep = nfsd->nd_mrep;
1030: md = nfsd->nd_md;
1031: dpos = nfsd->nd_dpos;
1032: cred = &nfsd->nd_cr;
1033: v3 = (nfsd->nd_flag & ND_NFSV3);
1034: LIST_INIT(&nfsd->nd_coalesce);
1035: nfsd->nd_mreq = NULL;
1036: nfsd->nd_stable = NFSV3WRITE_FILESYNC;
1037: cur_usec = (u_quad_t)time.tv_sec * 1000000 + (u_quad_t)time.tv_usec;
1038: nfsd->nd_time = cur_usec +
1039: (v3 ? nfsrvw_procrastinate_v3 : nfsrvw_procrastinate);
1040:
1041: /*
1042: * Now, get the write header..
1043: */
1044: nfsm_srvmtofh(&nfsd->nd_fh);
1045: if (v3) {
1046: nfsm_dissect(tl, u_long *, 5 * NFSX_UNSIGNED);
1047: fxdr_hyper(tl, &nfsd->nd_off);
1048: tl += 3;
1049: nfsd->nd_stable = fxdr_unsigned(int, *tl++);
1050: } else {
1051: nfsm_dissect(tl, u_long *, 4 * NFSX_UNSIGNED);
1052: nfsd->nd_off = (off_t)fxdr_unsigned(u_long, *++tl);
1053: tl += 2;
1054: if (nfs_async)
1055: nfsd->nd_stable = NFSV3WRITE_UNSTABLE;
1056: }
1057: len = fxdr_unsigned(long, *tl);
1058: nfsd->nd_len = len;
1059: nfsd->nd_eoff = nfsd->nd_off + len;
1060:
1061: /*
1062: * Trim the header out of the mbuf list and trim off any trailing
1063: * junk so that the mbuf list has only the write data.
1064: */
1065: zeroing = 1;
1066: i = 0;
1067: mp = mrep;
1068: while (mp) {
1069: if (mp == md) {
1070: zeroing = 0;
1071: adjust = dpos - mtod(mp, caddr_t);
1072: mp->m_len -= adjust;
1073: if (mp->m_len > 0 && adjust > 0)
1074: NFSMADV(mp, adjust);
1075: }
1076: if (zeroing)
1077: mp->m_len = 0;
1078: else {
1079: i += mp->m_len;
1080: if (i > len) {
1081: mp->m_len -= (i - len);
1082: zeroing = 1;
1083: }
1084: }
1085: mp = mp->m_next;
1086: }
1087: if (len > NFS_MAXDATA || len < 0 || i < len) {
1088: nfsmout:
1089: m_freem(mrep);
1090: error = EIO;
1091: nfsm_writereply(2 * NFSX_UNSIGNED, v3);
1092: if (v3)
1093: nfsm_srvwcc_data(forat_ret, &forat, aftat_ret, &va);
1094: nfsd->nd_mreq = mreq;
1095: nfsd->nd_mrep = NULL;
1096: nfsd->nd_time = 0;
1097: }
1098:
1099: /*
1100: * Add this entry to the hash and time queues.
1101: */
1102: s = splsoftclock();
1103: owp = NULL;
1104: wp = slp->ns_tq.lh_first;
1105: while (wp && wp->nd_time < nfsd->nd_time) {
1106: owp = wp;
1107: wp = wp->nd_tq.le_next;
1108: }
1109: NFS_DPF(WG, ("Q%03x", nfsd->nd_retxid & 0xfff));
1110: if (owp) {
1111: LIST_INSERT_AFTER(owp, nfsd, nd_tq);
1112: } else {
1113: LIST_INSERT_HEAD(&slp->ns_tq, nfsd, nd_tq);
1114: }
1115: if (nfsd->nd_mrep) {
1116: wpp = NWDELAYHASH(slp, nfsd->nd_fh.fh_fid.fid_data);
1117: owp = NULL;
1118: wp = wpp->lh_first;
1119: while (wp &&
1120: bcmp((caddr_t)&nfsd->nd_fh,(caddr_t)&wp->nd_fh,NFSX_V3FH)) {
1121: owp = wp;
1122: wp = wp->nd_hash.le_next;
1123: }
1124: while (wp && wp->nd_off < nfsd->nd_off &&
1125: !bcmp((caddr_t)&nfsd->nd_fh,(caddr_t)&wp->nd_fh,NFSX_V3FH)) {
1126: owp = wp;
1127: wp = wp->nd_hash.le_next;
1128: }
1129: if (owp) {
1130: LIST_INSERT_AFTER(owp, nfsd, nd_hash);
1131:
1132: /*
1133: * Search the hash list for overlapping entries and
1134: * coalesce.
1135: */
1136: for(; nfsd && NFSW_CONTIG(owp, nfsd); nfsd = wp) {
1137: wp = nfsd->nd_hash.le_next;
1138: if (NFSW_SAMECRED(owp, nfsd))
1139: nfsrvw_coalesce(owp, nfsd);
1140: }
1141: } else {
1142: LIST_INSERT_HEAD(wpp, nfsd, nd_hash);
1143: }
1144: }
1145: splx(s);
1146: }
1147:
1148: /*
1149: * Now, do VOP_WRITE()s for any one(s) that need to be done now
1150: * and generate the associated reply mbuf list(s).
1151: */
1152: loop1:
1153: cur_usec = (u_quad_t)time.tv_sec * 1000000 + (u_quad_t)time.tv_usec;
1154: s = splsoftclock();
1155: for (nfsd = slp->ns_tq.lh_first; nfsd; nfsd = owp) {
1156: owp = nfsd->nd_tq.le_next;
1157: if (nfsd->nd_time > cur_usec)
1158: break;
1159: if (nfsd->nd_mreq)
1160: continue;
1161: NFS_DPF(WG, ("P%03x", nfsd->nd_retxid & 0xfff));
1162: LIST_REMOVE(nfsd, nd_tq);
1163: LIST_REMOVE(nfsd, nd_hash);
1164: splx(s);
1165: mrep = nfsd->nd_mrep;
1166: nfsd->nd_mrep = NULL;
1167: cred = &nfsd->nd_cr;
1168: v3 = (nfsd->nd_flag & ND_NFSV3);
1169: forat_ret = aftat_ret = 1;
1170: error = nfsrv_fhtovp(&nfsd->nd_fh, 1, &vp, cred, slp,
1171: nfsd->nd_nam, &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE);
1172: if (!error) {
1173: if (v3)
1174: forat_ret = VOP_GETATTR(vp, &forat, cred, procp);
1175: if (vp->v_type != VREG) {
1176: if (v3)
1177: error = EINVAL;
1178: else
1179: error = (vp->v_type == VDIR) ? EISDIR : EACCES;
1180: }
1181: } else
1182: vp = NULL;
1183: if (!error) {
1184: nqsrv_getl(vp, ND_WRITE);
1185: error = nfsrv_access(vp, VWRITE, cred, rdonly, procp);
1186: }
1187:
1188: if (nfsd->nd_stable == NFSV3WRITE_UNSTABLE)
1189: ioflags = IO_NODELOCKED;
1190: else if (nfsd->nd_stable == NFSV3WRITE_DATASYNC)
1191: ioflags = (IO_SYNC | IO_NODELOCKED);
1192: else
1193: ioflags = (IO_METASYNC | IO_SYNC | IO_NODELOCKED);
1194: uiop->uio_rw = UIO_WRITE;
1195: uiop->uio_segflg = UIO_SYSSPACE;
1196: uiop->uio_procp = (struct proc *)0;
1197: uiop->uio_offset = nfsd->nd_off;
1198: uiop->uio_resid = nfsd->nd_eoff - nfsd->nd_off;
1199: if (uiop->uio_resid > 0) {
1200: mp = mrep;
1201: i = 0;
1202: while (mp) {
1203: if (mp->m_len > 0)
1204: i++;
1205: mp = mp->m_next;
1206: }
1207: uiop->uio_iovcnt = i;
1208: MALLOC(iov, struct iovec *, i * sizeof (struct iovec),
1209: M_TEMP, M_WAITOK);
1210: uiop->uio_iov = ivp = iov;
1211: mp = mrep;
1212: while (mp) {
1213: if (mp->m_len > 0) {
1214: ivp->iov_base = mtod(mp, caddr_t);
1215: ivp->iov_len = mp->m_len;
1216: ivp++;
1217: }
1218: mp = mp->m_next;
1219: }
1220: if (!error) {
1221: #if MACH_NBC
1222: if (vp->v_type == VREG) {
1223: map_vnode(vp, procp);
1224: error = mapfs_io(vp, uiop, uiop->uio_rw,
1225: ioflags, cred);
1226: unmap_vnode(vp, procp);
1227: } else
1228: #endif /* MACH_NBC */
1229: error = VOP_WRITE(vp, uiop, ioflags, cred);
1230: nfsstats.srvvop_writes++;
1231: }
1232: FREE((caddr_t)iov, M_TEMP);
1233: }
1234: m_freem(mrep);
1235: if (vp) {
1236: aftat_ret = VOP_GETATTR(vp, &va, cred, procp);
1237: vput(vp);
1238: }
1239:
1240: /*
1241: * Loop around generating replies for all write rpcs that have
1242: * now been completed.
1243: */
1244: swp = nfsd;
1245: do {
1246: NFS_DPF(WG, ("R%03x", nfsd->nd_retxid & 0xfff));
1247: if (error) {
1248: nfsm_writereply(NFSX_WCCDATA(v3), v3);
1249: if (v3) {
1250: nfsm_srvwcc_data(forat_ret, &forat, aftat_ret, &va);
1251: }
1252: } else {
1253: nfsm_writereply(NFSX_PREOPATTR(v3) +
1254: NFSX_POSTOPORFATTR(v3) + 2 * NFSX_UNSIGNED +
1255: NFSX_WRITEVERF(v3), v3);
1256: if (v3) {
1257: nfsm_srvwcc_data(forat_ret, &forat, aftat_ret, &va);
1258: nfsm_build(tl, u_long *, 4 * NFSX_UNSIGNED);
1259: *tl++ = txdr_unsigned(nfsd->nd_len);
1260: *tl++ = txdr_unsigned(swp->nd_stable);
1261: /*
1262: * Actually, there is no need to txdr these fields,
1263: * but it may make the values more human readable,
1264: * for debugging purposes.
1265: */
1266: *tl++ = txdr_unsigned(boottime.tv_sec);
1267: *tl = txdr_unsigned(boottime.tv_usec);
1268: } else {
1269: nfsm_build(fp, struct nfs_fattr *, NFSX_V2FATTR);
1270: nfsm_srvfillattr(&va, fp);
1271: }
1272: }
1273: nfsd->nd_mreq = mreq;
1274: if (nfsd->nd_mrep)
1275: panic("nfsrv_write: nd_mrep not free");
1276:
1277: /*
1278: * Done. Put it at the head of the timer queue so that
1279: * the final phase can return the reply.
1280: */
1281: s = splsoftclock();
1282: if (nfsd != swp) {
1283: nfsd->nd_time = 0;
1284: LIST_INSERT_HEAD(&slp->ns_tq, nfsd, nd_tq);
1285: }
1286: nfsd = swp->nd_coalesce.lh_first;
1287: if (nfsd) {
1288: LIST_REMOVE(nfsd, nd_tq);
1289: }
1290: splx(s);
1291: } while (nfsd);
1292: s = splsoftclock();
1293: swp->nd_time = 0;
1294: LIST_INSERT_HEAD(&slp->ns_tq, swp, nd_tq);
1295: splx(s);
1296: goto loop1;
1297: }
1298: splx(s);
1299:
1300: /*
1301: * Search for a reply to return.
1302: */
1303: s = splsoftclock();
1304: for (nfsd = slp->ns_tq.lh_first; nfsd; nfsd = nfsd->nd_tq.le_next)
1305: if (nfsd->nd_mreq) {
1306: NFS_DPF(WG, ("X%03x", nfsd->nd_retxid & 0xfff));
1307: LIST_REMOVE(nfsd, nd_tq);
1308: *mrq = nfsd->nd_mreq;
1309: *ndp = nfsd;
1310: break;
1311: }
1312: splx(s);
1313: return (0);
1314: }
1315:
1316: /*
1317: * Coalesce the write request nfsd into owp. To do this we must:
1318: * - remove nfsd from the queues
1319: * - merge nfsd->nd_mrep into owp->nd_mrep
1320: * - update the nd_eoff and nd_stable for owp
1321: * - put nfsd on owp's nd_coalesce list
1322: * NB: Must be called at splsoftclock().
1323: */
1324: static void
1325: nfsrvw_coalesce(owp, nfsd)
1326: register struct nfsrv_descript *owp;
1327: register struct nfsrv_descript *nfsd;
1328: {
1329: register int overlap;
1330: register struct mbuf *mp;
1331: struct nfsrv_descript *p;
1332:
1333: NFS_DPF(WG, ("C%03x-%03x",
1334: nfsd->nd_retxid & 0xfff, owp->nd_retxid & 0xfff));
1335: LIST_REMOVE(nfsd, nd_hash);
1336: LIST_REMOVE(nfsd, nd_tq);
1337: if (owp->nd_eoff < nfsd->nd_eoff) {
1338: overlap = owp->nd_eoff - nfsd->nd_off;
1339: if (overlap < 0)
1340: panic("nfsrv_coalesce: bad off");
1341: if (overlap > 0)
1342: m_adj(nfsd->nd_mrep, overlap);
1343: mp = owp->nd_mrep;
1344: while (mp->m_next)
1345: mp = mp->m_next;
1346: mp->m_next = nfsd->nd_mrep;
1347: owp->nd_eoff = nfsd->nd_eoff;
1348: } else
1349: m_freem(nfsd->nd_mrep);
1350: nfsd->nd_mrep = NULL;
1351: if (nfsd->nd_stable == NFSV3WRITE_FILESYNC)
1352: owp->nd_stable = NFSV3WRITE_FILESYNC;
1353: else if (nfsd->nd_stable == NFSV3WRITE_DATASYNC &&
1354: owp->nd_stable == NFSV3WRITE_UNSTABLE)
1355: owp->nd_stable = NFSV3WRITE_DATASYNC;
1356: LIST_INSERT_HEAD(&owp->nd_coalesce, nfsd, nd_tq);
1357:
1358: /*
1359: * If nfsd had anything else coalesced into it, transfer them
1360: * to owp, otherwise their replies will never get sent.
1361: */
1362: for (p = nfsd->nd_coalesce.lh_first; p;
1363: p = nfsd->nd_coalesce.lh_first) {
1364: LIST_REMOVE(p, nd_tq);
1365: LIST_INSERT_HEAD(&owp->nd_coalesce, p, nd_tq);
1366: }
1367: }
1368:
1369: /*
1370: * Sort the group list in increasing numerical order.
1371: * (Insertion sort by Chris Torek, who was grossed out by the bubble sort
1372: * that used to be here.)
1373: */
1374: void
1375: nfsrvw_sort(list, num)
1376: register gid_t *list;
1377: register int num;
1378: {
1379: register int i, j;
1380: gid_t v;
1381:
1382: /* Insertion sort. */
1383: for (i = 1; i < num; i++) {
1384: v = list[i];
1385: /* find correct slot for value v, moving others up */
1386: for (j = i; --j >= 0 && v < list[j];)
1387: list[j + 1] = list[j];
1388: list[j + 1] = v;
1389: }
1390: }
1391:
1392: /*
1393: * copy credentials making sure that the result can be compared with bcmp().
1394: */
1395: void
1396: nfsrv_setcred(incred, outcred)
1397: register struct ucred *incred, *outcred;
1398: {
1399: register int i;
1400:
1401: bzero((caddr_t)outcred, sizeof (struct ucred));
1402: outcred->cr_ref = 1;
1403: outcred->cr_uid = incred->cr_uid;
1404: outcred->cr_ngroups = incred->cr_ngroups;
1405: for (i = 0; i < incred->cr_ngroups; i++)
1406: outcred->cr_groups[i] = incred->cr_groups[i];
1407: nfsrvw_sort(outcred->cr_groups, outcred->cr_ngroups);
1408: }
1409:
1410: /*
1411: * nfs create service
1412: * now does a truncate to 0 length via. setattr if it already exists
1413: */
1414: int
1415: nfsrv_create(nfsd, slp, procp, mrq)
1416: struct nfsrv_descript *nfsd;
1417: struct nfssvc_sock *slp;
1418: struct proc *procp;
1419: struct mbuf **mrq;
1420: {
1421: struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
1422: struct mbuf *nam = nfsd->nd_nam;
1423: caddr_t dpos = nfsd->nd_dpos;
1424: struct ucred *cred = &nfsd->nd_cr;
1425: register struct nfs_fattr *fp;
1426: struct vattr va, dirfor, diraft;
1427: register struct vattr *vap = &va;
1428: register struct nfsv2_sattr *sp;
1429: register u_long *tl;
1430: struct nameidata nd;
1431: register caddr_t cp;
1432: register long t1;
1433: caddr_t bpos;
1434: int error = 0, rdev, cache, len, tsize, dirfor_ret = 1, diraft_ret = 1;
1435: int v3 = (nfsd->nd_flag & ND_NFSV3), how, exclusive_flag = 0;
1436: char *cp2;
1437: struct mbuf *mb, *mb2, *mreq;
1438: struct vnode *vp, *dirp = (struct vnode *)0;
1439: nfsfh_t nfh;
1440: fhandle_t *fhp;
1441: u_quad_t frev, tempsize;
1442: u_char cverf[NFSX_V3CREATEVERF];
1443:
1444: #ifndef nolint
1445: rdev = 0;
1446: #endif
1447: nd.ni_cnd.cn_nameiop = 0;
1448: fhp = &nfh.fh_generic;
1449: nfsm_srvmtofh(fhp);
1450: nfsm_srvnamesiz(len);
1451: nd.ni_cnd.cn_cred = cred;
1452: nd.ni_cnd.cn_nameiop = CREATE;
1453: nd.ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF | SAVESTART;
1454: error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos,
1455: &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE);
1456: if (dirp) {
1457: if (v3)
1458: dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred,
1459: procp);
1460: else {
1461: vrele(dirp);
1462: dirp = (struct vnode *)0;
1463: }
1464: }
1465: if (error) {
1466: nfsm_reply(NFSX_WCCDATA(v3));
1467: nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
1468: if (dirp)
1469: vrele(dirp);
1470: return (0);
1471: }
1472: VATTR_NULL(vap);
1473: if (v3) {
1474: nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
1475: how = fxdr_unsigned(int, *tl);
1476: switch (how) {
1477: case NFSV3CREATE_GUARDED:
1478: if (nd.ni_vp) {
1479: error = EEXIST;
1480: break;
1481: }
1482: case NFSV3CREATE_UNCHECKED:
1483: nfsm_srvsattr(vap);
1484: break;
1485: case NFSV3CREATE_EXCLUSIVE:
1486: nfsm_dissect(cp, caddr_t, NFSX_V3CREATEVERF);
1487: bcopy(cp, cverf, NFSX_V3CREATEVERF);
1488: exclusive_flag = 1;
1489: if (nd.ni_vp == NULL)
1490: vap->va_mode = 0;
1491: break;
1492: };
1493: vap->va_type = VREG;
1494: } else {
1495: nfsm_dissect(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
1496: vap->va_type = IFTOVT(fxdr_unsigned(u_long, sp->sa_mode));
1497: if (vap->va_type == VNON)
1498: vap->va_type = VREG;
1499: vap->va_mode = nfstov_mode(sp->sa_mode);
1500: switch (vap->va_type) {
1501: case VREG:
1502: tsize = fxdr_unsigned(long, sp->sa_size);
1503: if (tsize != -1)
1504: vap->va_size = (u_quad_t)tsize;
1505: break;
1506: case VCHR:
1507: case VBLK:
1508: case VFIFO:
1509: rdev = fxdr_unsigned(long, sp->sa_size);
1510: break;
1511: };
1512: }
1513:
1514: /*
1515: * Iff doesn't exist, create it
1516: * otherwise just truncate to 0 length
1517: * should I set the mode too ??
1518: */
1519: if (nd.ni_vp == NULL) {
1520: if (vap->va_type == VREG || vap->va_type == VSOCK) {
1521: vrele(nd.ni_startdir);
1522: nqsrv_getl(nd.ni_dvp, ND_WRITE);
1523: error = VOP_CREATE(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, vap);
1524: if (!error) {
1525: nfsrv_object_create(nd.ni_vp);
1526: FREE_ZONE(nd.ni_cnd.cn_pnbuf,
1527: nd.ni_cnd.cn_pnlen, M_NAMEI);
1528: if (exclusive_flag) {
1529: exclusive_flag = 0;
1530: VATTR_NULL(vap);
1531: bcopy(cverf, (caddr_t)&vap->va_atime,
1532: NFSX_V3CREATEVERF);
1533: error = VOP_SETATTR(nd.ni_vp, vap, cred,
1534: procp);
1535: }
1536: }
1537: } else if (vap->va_type == VCHR || vap->va_type == VBLK ||
1538: vap->va_type == VFIFO) {
1539: if (vap->va_type == VCHR && rdev == 0xffffffff)
1540: vap->va_type = VFIFO;
1541: if (vap->va_type != VFIFO &&
1542: (error = suser(cred, (u_short *)0))) {
1543: vrele(nd.ni_startdir);
1544: _FREE_ZONE(nd.ni_cnd.cn_pnbuf,
1545: nd.ni_cnd.cn_pnlen, M_NAMEI);
1546: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
1547: vput(nd.ni_dvp);
1548: nfsm_reply(0);
1549: return (error);
1550: } else
1551: vap->va_rdev = (dev_t)rdev;
1552: nqsrv_getl(nd.ni_dvp, ND_WRITE);
1553: if ((error = VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, vap))) {
1554: vrele(nd.ni_startdir);
1555: nfsm_reply(0);
1556: }
1557: nd.ni_cnd.cn_nameiop = LOOKUP;
1558: nd.ni_cnd.cn_flags &= ~(LOCKPARENT | SAVESTART);
1559: nd.ni_cnd.cn_proc = procp;
1560: nd.ni_cnd.cn_cred = cred;
1561: if ((error = lookup(&nd))) {
1562: _FREE_ZONE(nd.ni_cnd.cn_pnbuf,
1563: nd.ni_cnd.cn_pnlen, M_NAMEI);
1564: nfsm_reply(0);
1565: }
1566: nfsrv_object_create(nd.ni_vp);
1567: FREE_ZONE(nd.ni_cnd.cn_pnbuf,
1568: nd.ni_cnd.cn_pnlen, M_NAMEI);
1569: if (nd.ni_cnd.cn_flags & ISSYMLINK) {
1570: vrele(nd.ni_dvp);
1571: vput(nd.ni_vp);
1572: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
1573: error = EINVAL;
1574: nfsm_reply(0);
1575: }
1576: } else {
1577: vrele(nd.ni_startdir);
1578: _FREE_ZONE(nd.ni_cnd.cn_pnbuf,
1579: nd.ni_cnd.cn_pnlen, M_NAMEI);
1580: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
1581: vput(nd.ni_dvp);
1582: error = ENXIO;
1583: }
1584: vp = nd.ni_vp;
1585: } else {
1586: vrele(nd.ni_startdir);
1587: _FREE_ZONE(nd.ni_cnd.cn_pnbuf, nd.ni_cnd.cn_pnlen, M_NAMEI);
1588: vp = nd.ni_vp;
1589: if (nd.ni_dvp == vp)
1590: vrele(nd.ni_dvp);
1591: else
1592: vput(nd.ni_dvp);
1593: VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
1594: if (vap->va_size != -1) {
1595: error = nfsrv_access(vp, VWRITE, cred,
1596: (nd.ni_cnd.cn_flags & RDONLY), procp);
1597: if (!error) {
1598: nqsrv_getl(vp, ND_WRITE);
1599: tempsize = vap->va_size;
1600: VATTR_NULL(vap);
1601: vap->va_size = tempsize;
1602: error = VOP_SETATTR(vp, vap, cred,
1603: procp);
1604: }
1605: if (error)
1606: vput(vp);
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 (0);
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.