![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to nfs_subs.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_subs.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_subs.c 8.8 (Berkeley) 5/22/95
62: * FreeBSD-Id: nfs_subs.c,v 1.47 1997/11/07 08:53:24 phk Exp $
63: */
64:
65: /*
66: * These functions support the macros and help fiddle mbuf chains for
67: * the nfs op functions. They do things like create the rpc header and
68: * copy data between mbuf chains and uio lists.
69: */
70: #include <mach_nbc.h>
71: #include <sys/param.h>
72: #include <sys/proc.h>
73: #include <sys/systm.h>
74: #include <sys/kernel.h>
75: #include <sys/mount.h>
76: #include <sys/vnode.h>
77: #include <sys/namei.h>
78: #include <sys/mbuf.h>
79: #include <sys/socket.h>
80: #include <sys/stat.h>
81: #include <sys/malloc.h>
82: #include <sys/syscall.h>
83:
84: #include <sys/vm.h>
85: #include <sys/vmparam.h>
86: #include <vm/vnode_pager.h>
87: #include <machine/spl.h>
88:
89: #include <kern/lock.h>
90:
91: #include <nfs/rpcv2.h>
92: #include <nfs/nfsproto.h>
93: #include <nfs/nfs.h>
94: #include <nfs/nfsnode.h>
95: #include <nfs/xdr_subs.h>
96: #include <nfs/nfsm_subs.h>
97: #include <nfs/nfsmount.h>
98: #include <nfs/nqnfs.h>
99: #include <nfs/nfsrtt.h>
100:
101: #include <miscfs/specfs/specdev.h>
102:
103: #include <netinet/in.h>
104: #if ISO
105: #include <netiso/iso.h>
106: #endif
107:
108: #if MACH_NBC
109: #include <kern/mapfs.h>
110: #endif /* MACH_NBC */
111:
112: /*
113: * Data items converted to xdr at startup, since they are constant
114: * This is kinda hokey, but may save a little time doing byte swaps
115: */
116: u_long nfs_xdrneg1;
117: u_long rpc_call, rpc_vers, rpc_reply, rpc_msgdenied, rpc_autherr,
118: rpc_mismatch, rpc_auth_unix, rpc_msgaccepted,
119: rpc_auth_kerb;
120: u_long nfs_prog, nqnfs_prog, nfs_true, nfs_false;
121:
122: /* And other global data */
123: static u_long nfs_xid = 0;
124: static enum vtype nv2tov_type[8]= {
125: VNON, VREG, VDIR, VBLK, VCHR, VLNK, VNON, VNON
126: };
127: enum vtype nv3tov_type[8]= {
128: VNON, VREG, VDIR, VBLK, VCHR, VLNK, VSOCK, VFIFO
129: };
130:
131: int nfs_mount_type;
132: int nfs_ticks;
133:
134: struct nfs_reqq nfs_reqq;
135: struct nfssvc_sockhead nfssvc_sockhead;
136: int nfssvc_sockhead_flag;
137: struct nfsd_head nfsd_head;
138: int nfsd_head_flag;
139: struct nfs_bufq nfs_bufq;
140: struct nqtimerhead nqtimerhead;
141: struct nqfhhashhead *nqfhhashtbl;
142: u_long nqfhhash;
143:
144: #ifndef NFS_NOSERVER
145: /*
146: * Mapping of old NFS Version 2 RPC numbers to generic numbers.
147: */
148: int nfsv3_procid[NFS_NPROCS] = {
149: NFSPROC_NULL,
150: NFSPROC_GETATTR,
151: NFSPROC_SETATTR,
152: NFSPROC_NOOP,
153: NFSPROC_LOOKUP,
154: NFSPROC_READLINK,
155: NFSPROC_READ,
156: NFSPROC_NOOP,
157: NFSPROC_WRITE,
158: NFSPROC_CREATE,
159: NFSPROC_REMOVE,
160: NFSPROC_RENAME,
161: NFSPROC_LINK,
162: NFSPROC_SYMLINK,
163: NFSPROC_MKDIR,
164: NFSPROC_RMDIR,
165: NFSPROC_READDIR,
166: NFSPROC_FSSTAT,
167: NFSPROC_NOOP,
168: NFSPROC_NOOP,
169: NFSPROC_NOOP,
170: NFSPROC_NOOP,
171: NFSPROC_NOOP,
172: NFSPROC_NOOP,
173: NFSPROC_NOOP,
174: NFSPROC_NOOP
175: };
176:
177: #endif /* NFS_NOSERVER */
178: /*
179: * and the reverse mapping from generic to Version 2 procedure numbers
180: */
181: int nfsv2_procid[NFS_NPROCS] = {
182: NFSV2PROC_NULL,
183: NFSV2PROC_GETATTR,
184: NFSV2PROC_SETATTR,
185: NFSV2PROC_LOOKUP,
186: NFSV2PROC_NOOP,
187: NFSV2PROC_READLINK,
188: NFSV2PROC_READ,
189: NFSV2PROC_WRITE,
190: NFSV2PROC_CREATE,
191: NFSV2PROC_MKDIR,
192: NFSV2PROC_SYMLINK,
193: NFSV2PROC_CREATE,
194: NFSV2PROC_REMOVE,
195: NFSV2PROC_RMDIR,
196: NFSV2PROC_RENAME,
197: NFSV2PROC_LINK,
198: NFSV2PROC_READDIR,
199: NFSV2PROC_NOOP,
200: NFSV2PROC_STATFS,
201: NFSV2PROC_NOOP,
202: NFSV2PROC_NOOP,
203: NFSV2PROC_NOOP,
204: NFSV2PROC_NOOP,
205: NFSV2PROC_NOOP,
206: NFSV2PROC_NOOP,
207: NFSV2PROC_NOOP,
208: };
209:
210: #ifndef NFS_NOSERVER
211: /*
212: * Maps errno values to nfs error numbers.
213: * Use NFSERR_IO as the catch all for ones not specifically defined in
214: * RFC 1094.
215: */
216: static u_char nfsrv_v2errmap[ELAST] = {
217: NFSERR_PERM, NFSERR_NOENT, NFSERR_IO, NFSERR_IO, NFSERR_IO,
218: NFSERR_NXIO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
219: NFSERR_IO, NFSERR_IO, NFSERR_ACCES, NFSERR_IO, NFSERR_IO,
220: NFSERR_IO, NFSERR_EXIST, NFSERR_IO, NFSERR_NODEV, NFSERR_NOTDIR,
221: NFSERR_ISDIR, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
222: NFSERR_IO, NFSERR_FBIG, NFSERR_NOSPC, NFSERR_IO, NFSERR_ROFS,
223: NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
224: NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
225: NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
226: NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
227: NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
228: NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
229: NFSERR_IO, NFSERR_IO, NFSERR_NAMETOL, NFSERR_IO, NFSERR_IO,
230: NFSERR_NOTEMPTY, NFSERR_IO, NFSERR_IO, NFSERR_DQUOT, NFSERR_STALE,
231: NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
232: NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO,
233: NFSERR_IO,
234: };
235:
236: /*
237: * Maps errno values to nfs error numbers.
238: * Although it is not obvious whether or not NFS clients really care if
239: * a returned error value is in the specified list for the procedure, the
240: * safest thing to do is filter them appropriately. For Version 2, the
241: * X/Open XNFS document is the only specification that defines error values
242: * for each RPC (The RFC simply lists all possible error values for all RPCs),
243: * so I have decided to not do this for Version 2.
244: * The first entry is the default error return and the rest are the valid
245: * errors for that RPC in increasing numeric order.
246: */
247: static short nfsv3err_null[] = {
248: 0,
249: 0,
250: };
251:
252: static short nfsv3err_getattr[] = {
253: NFSERR_IO,
254: NFSERR_IO,
255: NFSERR_STALE,
256: NFSERR_BADHANDLE,
257: NFSERR_SERVERFAULT,
258: 0,
259: };
260:
261: static short nfsv3err_setattr[] = {
262: NFSERR_IO,
263: NFSERR_PERM,
264: NFSERR_IO,
265: NFSERR_ACCES,
266: NFSERR_INVAL,
267: NFSERR_NOSPC,
268: NFSERR_ROFS,
269: NFSERR_DQUOT,
270: NFSERR_STALE,
271: NFSERR_BADHANDLE,
272: NFSERR_NOT_SYNC,
273: NFSERR_SERVERFAULT,
274: 0,
275: };
276:
277: static short nfsv3err_lookup[] = {
278: NFSERR_IO,
279: NFSERR_NOENT,
280: NFSERR_IO,
281: NFSERR_ACCES,
282: NFSERR_NOTDIR,
283: NFSERR_NAMETOL,
284: NFSERR_STALE,
285: NFSERR_BADHANDLE,
286: NFSERR_SERVERFAULT,
287: 0,
288: };
289:
290: static short nfsv3err_access[] = {
291: NFSERR_IO,
292: NFSERR_IO,
293: NFSERR_STALE,
294: NFSERR_BADHANDLE,
295: NFSERR_SERVERFAULT,
296: 0,
297: };
298:
299: static short nfsv3err_readlink[] = {
300: NFSERR_IO,
301: NFSERR_IO,
302: NFSERR_ACCES,
303: NFSERR_INVAL,
304: NFSERR_STALE,
305: NFSERR_BADHANDLE,
306: NFSERR_NOTSUPP,
307: NFSERR_SERVERFAULT,
308: 0,
309: };
310:
311: static short nfsv3err_read[] = {
312: NFSERR_IO,
313: NFSERR_IO,
314: NFSERR_NXIO,
315: NFSERR_ACCES,
316: NFSERR_INVAL,
317: NFSERR_STALE,
318: NFSERR_BADHANDLE,
319: NFSERR_SERVERFAULT,
320: 0,
321: };
322:
323: static short nfsv3err_write[] = {
324: NFSERR_IO,
325: NFSERR_IO,
326: NFSERR_ACCES,
327: NFSERR_INVAL,
328: NFSERR_FBIG,
329: NFSERR_NOSPC,
330: NFSERR_ROFS,
331: NFSERR_DQUOT,
332: NFSERR_STALE,
333: NFSERR_BADHANDLE,
334: NFSERR_SERVERFAULT,
335: 0,
336: };
337:
338: static short nfsv3err_create[] = {
339: NFSERR_IO,
340: NFSERR_IO,
341: NFSERR_ACCES,
342: NFSERR_EXIST,
343: NFSERR_NOTDIR,
344: NFSERR_NOSPC,
345: NFSERR_ROFS,
346: NFSERR_NAMETOL,
347: NFSERR_DQUOT,
348: NFSERR_STALE,
349: NFSERR_BADHANDLE,
350: NFSERR_NOTSUPP,
351: NFSERR_SERVERFAULT,
352: 0,
353: };
354:
355: static short nfsv3err_mkdir[] = {
356: NFSERR_IO,
357: NFSERR_IO,
358: NFSERR_ACCES,
359: NFSERR_EXIST,
360: NFSERR_NOTDIR,
361: NFSERR_NOSPC,
362: NFSERR_ROFS,
363: NFSERR_NAMETOL,
364: NFSERR_DQUOT,
365: NFSERR_STALE,
366: NFSERR_BADHANDLE,
367: NFSERR_NOTSUPP,
368: NFSERR_SERVERFAULT,
369: 0,
370: };
371:
372: static short nfsv3err_symlink[] = {
373: NFSERR_IO,
374: NFSERR_IO,
375: NFSERR_ACCES,
376: NFSERR_EXIST,
377: NFSERR_NOTDIR,
378: NFSERR_NOSPC,
379: NFSERR_ROFS,
380: NFSERR_NAMETOL,
381: NFSERR_DQUOT,
382: NFSERR_STALE,
383: NFSERR_BADHANDLE,
384: NFSERR_NOTSUPP,
385: NFSERR_SERVERFAULT,
386: 0,
387: };
388:
389: static short nfsv3err_mknod[] = {
390: NFSERR_IO,
391: NFSERR_IO,
392: NFSERR_ACCES,
393: NFSERR_EXIST,
394: NFSERR_NOTDIR,
395: NFSERR_NOSPC,
396: NFSERR_ROFS,
397: NFSERR_NAMETOL,
398: NFSERR_DQUOT,
399: NFSERR_STALE,
400: NFSERR_BADHANDLE,
401: NFSERR_NOTSUPP,
402: NFSERR_SERVERFAULT,
403: NFSERR_BADTYPE,
404: 0,
405: };
406:
407: static short nfsv3err_remove[] = {
408: NFSERR_IO,
409: NFSERR_NOENT,
410: NFSERR_IO,
411: NFSERR_ACCES,
412: NFSERR_NOTDIR,
413: NFSERR_ROFS,
414: NFSERR_NAMETOL,
415: NFSERR_STALE,
416: NFSERR_BADHANDLE,
417: NFSERR_SERVERFAULT,
418: 0,
419: };
420:
421: static short nfsv3err_rmdir[] = {
422: NFSERR_IO,
423: NFSERR_NOENT,
424: NFSERR_IO,
425: NFSERR_ACCES,
426: NFSERR_EXIST,
427: NFSERR_NOTDIR,
428: NFSERR_INVAL,
429: NFSERR_ROFS,
430: NFSERR_NAMETOL,
431: NFSERR_NOTEMPTY,
432: NFSERR_STALE,
433: NFSERR_BADHANDLE,
434: NFSERR_NOTSUPP,
435: NFSERR_SERVERFAULT,
436: 0,
437: };
438:
439: static short nfsv3err_rename[] = {
440: NFSERR_IO,
441: NFSERR_NOENT,
442: NFSERR_IO,
443: NFSERR_ACCES,
444: NFSERR_EXIST,
445: NFSERR_XDEV,
446: NFSERR_NOTDIR,
447: NFSERR_ISDIR,
448: NFSERR_INVAL,
449: NFSERR_NOSPC,
450: NFSERR_ROFS,
451: NFSERR_MLINK,
452: NFSERR_NAMETOL,
453: NFSERR_NOTEMPTY,
454: NFSERR_DQUOT,
455: NFSERR_STALE,
456: NFSERR_BADHANDLE,
457: NFSERR_NOTSUPP,
458: NFSERR_SERVERFAULT,
459: 0,
460: };
461:
462: static short nfsv3err_link[] = {
463: NFSERR_IO,
464: NFSERR_IO,
465: NFSERR_ACCES,
466: NFSERR_EXIST,
467: NFSERR_XDEV,
468: NFSERR_NOTDIR,
469: NFSERR_INVAL,
470: NFSERR_NOSPC,
471: NFSERR_ROFS,
472: NFSERR_MLINK,
473: NFSERR_NAMETOL,
474: NFSERR_DQUOT,
475: NFSERR_STALE,
476: NFSERR_BADHANDLE,
477: NFSERR_NOTSUPP,
478: NFSERR_SERVERFAULT,
479: 0,
480: };
481:
482: static short nfsv3err_readdir[] = {
483: NFSERR_IO,
484: NFSERR_IO,
485: NFSERR_ACCES,
486: NFSERR_NOTDIR,
487: NFSERR_STALE,
488: NFSERR_BADHANDLE,
489: NFSERR_BAD_COOKIE,
490: NFSERR_TOOSMALL,
491: NFSERR_SERVERFAULT,
492: 0,
493: };
494:
495: static short nfsv3err_readdirplus[] = {
496: NFSERR_IO,
497: NFSERR_IO,
498: NFSERR_ACCES,
499: NFSERR_NOTDIR,
500: NFSERR_STALE,
501: NFSERR_BADHANDLE,
502: NFSERR_BAD_COOKIE,
503: NFSERR_NOTSUPP,
504: NFSERR_TOOSMALL,
505: NFSERR_SERVERFAULT,
506: 0,
507: };
508:
509: static short nfsv3err_fsstat[] = {
510: NFSERR_IO,
511: NFSERR_IO,
512: NFSERR_STALE,
513: NFSERR_BADHANDLE,
514: NFSERR_SERVERFAULT,
515: 0,
516: };
517:
518: static short nfsv3err_fsinfo[] = {
519: NFSERR_STALE,
520: NFSERR_STALE,
521: NFSERR_BADHANDLE,
522: NFSERR_SERVERFAULT,
523: 0,
524: };
525:
526: static short nfsv3err_pathconf[] = {
527: NFSERR_STALE,
528: NFSERR_STALE,
529: NFSERR_BADHANDLE,
530: NFSERR_SERVERFAULT,
531: 0,
532: };
533:
534: static short nfsv3err_commit[] = {
535: NFSERR_IO,
536: NFSERR_IO,
537: NFSERR_STALE,
538: NFSERR_BADHANDLE,
539: NFSERR_SERVERFAULT,
540: 0,
541: };
542:
543: static short *nfsrv_v3errmap[] = {
544: nfsv3err_null,
545: nfsv3err_getattr,
546: nfsv3err_setattr,
547: nfsv3err_lookup,
548: nfsv3err_access,
549: nfsv3err_readlink,
550: nfsv3err_read,
551: nfsv3err_write,
552: nfsv3err_create,
553: nfsv3err_mkdir,
554: nfsv3err_symlink,
555: nfsv3err_mknod,
556: nfsv3err_remove,
557: nfsv3err_rmdir,
558: nfsv3err_rename,
559: nfsv3err_link,
560: nfsv3err_readdir,
561: nfsv3err_readdirplus,
562: nfsv3err_fsstat,
563: nfsv3err_fsinfo,
564: nfsv3err_pathconf,
565: nfsv3err_commit,
566: };
567:
568: #endif /* NFS_NOSERVER */
569:
570: extern struct nfsrtt nfsrtt;
571: extern time_t nqnfsstarttime;
572: extern int nqsrv_clockskew;
573: extern int nqsrv_writeslack;
574: extern int nqsrv_maxlease;
575: extern struct nfsstats nfsstats;
576: extern int nqnfs_piggy[NFS_NPROCS];
577: extern nfstype nfsv2_type[9];
578: extern nfstype nfsv3_type[9];
579: extern struct nfsnodehashhead *nfsnodehashtbl;
580: extern u_long nfsnodehash;
581:
582: struct getfh_args;
583: extern int getfh(struct proc *, struct getfh_args *, int *);
584: struct nfssvc_args;
585: extern int nfssvc(struct proc *, struct nfssvc_args *, int *);
586:
587: extern void mapfs_memfree __P((struct vm_info *, boolean_t));
588:
589: LIST_HEAD(nfsnodehashhead, nfsnode);
590:
591: int nfs_webnamei __P((struct nameidata *, struct vnode *, struct proc *));
592:
593: /*
594: * Create the header for an rpc request packet
595: * The hsiz is the size of the rest of the nfs request header.
596: * (just used to decide if a cluster is a good idea)
597: */
598: struct mbuf *
599: nfsm_reqh(vp, procid, hsiz, bposp)
600: struct vnode *vp;
601: u_long procid;
602: int hsiz;
603: caddr_t *bposp;
604: {
605: register struct mbuf *mb;
606: register u_long *tl;
607: register caddr_t bpos;
608: struct mbuf *mb2;
609: struct nfsmount *nmp;
610: int nqflag;
611:
612: MGET(mb, M_WAIT, MT_DATA);
613: if (hsiz >= MINCLSIZE)
614: MCLGET(mb, M_WAIT);
615: mb->m_len = 0;
616: bpos = mtod(mb, caddr_t);
617:
618: /*
619: * For NQNFS, add lease request.
620: */
621: if (vp) {
622: nmp = VFSTONFS(vp->v_mount);
623: if (nmp->nm_flag & NFSMNT_NQNFS) {
624: nqflag = NQNFS_NEEDLEASE(vp, procid);
625: if (nqflag) {
626: nfsm_build(tl, u_long *, 2*NFSX_UNSIGNED);
627: *tl++ = txdr_unsigned(nqflag);
628: *tl = txdr_unsigned(nmp->nm_leaseterm);
629: } else {
630: nfsm_build(tl, u_long *, NFSX_UNSIGNED);
631: *tl = 0;
632: }
633: }
634: }
635: /* Finally, return values */
636: *bposp = bpos;
637: return (mb);
638: }
639:
640: /*
641: * Build the RPC header and fill in the authorization info.
642: * The authorization string argument is only used when the credentials
643: * come from outside of the kernel.
644: * Returns the head of the mbuf list.
645: */
646: struct mbuf *
647: nfsm_rpchead(cr, nmflag, procid, auth_type, auth_len, auth_str, verf_len,
648: verf_str, mrest, mrest_len, mbp, xidp)
649: register struct ucred *cr;
650: int nmflag;
651: int procid;
652: int auth_type;
653: int auth_len;
654: char *auth_str;
655: int verf_len;
656: char *verf_str;
657: struct mbuf *mrest;
658: int mrest_len;
659: struct mbuf **mbp;
660: u_long *xidp;
661: {
662: register struct mbuf *mb;
663: register u_long *tl;
664: register caddr_t bpos;
665: register int i;
666: struct mbuf *mreq, *mb2;
667: int siz, grpsiz, authsiz;
668: struct timeval tv;
669: static u_long base;
670:
671: authsiz = nfsm_rndup(auth_len);
672: MGETHDR(mb, M_WAIT, MT_DATA);
673: if ((authsiz + 10 * NFSX_UNSIGNED) >= MINCLSIZE) {
674: MCLGET(mb, M_WAIT);
675: } else if ((authsiz + 10 * NFSX_UNSIGNED) < MHLEN) {
676: MH_ALIGN(mb, authsiz + 10 * NFSX_UNSIGNED);
677: } else {
678: MH_ALIGN(mb, 8 * NFSX_UNSIGNED);
679: }
680: mb->m_len = 0;
681: mreq = mb;
682: bpos = mtod(mb, caddr_t);
683:
684: /*
685: * First the RPC header.
686: */
687: nfsm_build(tl, u_long *, 8 * NFSX_UNSIGNED);
688:
689: /*
690: * derive initial xid from system time
691: * XXX time is invalid if root not yet mounted
692: */
693: if (!base && (rootvp)) {
694: microtime(&tv);
695: base = tv.tv_sec << 12;
696: nfs_xid = base;
697: }
698: /*
699: * Skip zero xid if it should ever happen.
700: */
701: if (++nfs_xid == 0)
702: nfs_xid++;
703:
704: *tl++ = *xidp = txdr_unsigned(nfs_xid);
705: *tl++ = rpc_call;
706: *tl++ = rpc_vers;
707: if (nmflag & NFSMNT_NQNFS) {
708: *tl++ = txdr_unsigned(NQNFS_PROG);
709: *tl++ = txdr_unsigned(NQNFS_VER3);
710: } else {
711: *tl++ = txdr_unsigned(NFS_PROG);
712: if (nmflag & NFSMNT_NFSV3)
713: *tl++ = txdr_unsigned(NFS_VER3);
714: else
715: *tl++ = txdr_unsigned(NFS_VER2);
716: }
717: if (nmflag & NFSMNT_NFSV3)
718: *tl++ = txdr_unsigned(procid);
719: else
720: *tl++ = txdr_unsigned(nfsv2_procid[procid]);
721:
722: /*
723: * And then the authorization cred.
724: */
725: *tl++ = txdr_unsigned(auth_type);
726: *tl = txdr_unsigned(authsiz);
727: switch (auth_type) {
728: case RPCAUTH_UNIX:
729: nfsm_build(tl, u_long *, auth_len);
730: *tl++ = 0; /* stamp ?? */
731: *tl++ = 0; /* NULL hostname */
732: *tl++ = txdr_unsigned(cr->cr_uid);
733: *tl++ = txdr_unsigned(cr->cr_groups[0]);
734: grpsiz = (auth_len >> 2) - 5;
735: *tl++ = txdr_unsigned(grpsiz);
736: for (i = 1; i <= grpsiz; i++)
737: *tl++ = txdr_unsigned(cr->cr_groups[i]);
738: break;
739: case RPCAUTH_KERB4:
740: siz = auth_len;
741: while (siz > 0) {
742: if (M_TRAILINGSPACE(mb) == 0) {
743: MGET(mb2, M_WAIT, MT_DATA);
744: if (siz >= MINCLSIZE)
745: MCLGET(mb2, M_WAIT);
746: mb->m_next = mb2;
747: mb = mb2;
748: mb->m_len = 0;
749: bpos = mtod(mb, caddr_t);
750: }
751: i = min(siz, M_TRAILINGSPACE(mb));
752: bcopy(auth_str, bpos, i);
753: mb->m_len += i;
754: auth_str += i;
755: bpos += i;
756: siz -= i;
757: }
758: if ((siz = (nfsm_rndup(auth_len) - auth_len)) > 0) {
759: for (i = 0; i < siz; i++)
760: *bpos++ = '\0';
761: mb->m_len += siz;
762: }
763: break;
764: };
765:
766: /*
767: * And the verifier...
768: */
769: nfsm_build(tl, u_long *, 2 * NFSX_UNSIGNED);
770: if (verf_str) {
771: *tl++ = txdr_unsigned(RPCAUTH_KERB4);
772: *tl = txdr_unsigned(verf_len);
773: siz = verf_len;
774: while (siz > 0) {
775: if (M_TRAILINGSPACE(mb) == 0) {
776: MGET(mb2, M_WAIT, MT_DATA);
777: if (siz >= MINCLSIZE)
778: MCLGET(mb2, M_WAIT);
779: mb->m_next = mb2;
780: mb = mb2;
781: mb->m_len = 0;
782: bpos = mtod(mb, caddr_t);
783: }
784: i = min(siz, M_TRAILINGSPACE(mb));
785: bcopy(verf_str, bpos, i);
786: mb->m_len += i;
787: verf_str += i;
788: bpos += i;
789: siz -= i;
790: }
791: if ((siz = (nfsm_rndup(verf_len) - verf_len)) > 0) {
792: for (i = 0; i < siz; i++)
793: *bpos++ = '\0';
794: mb->m_len += siz;
795: }
796: } else {
797: *tl++ = txdr_unsigned(RPCAUTH_NULL);
798: *tl = 0;
799: }
800: mb->m_next = mrest;
801: mreq->m_pkthdr.len = authsiz + 10 * NFSX_UNSIGNED + mrest_len;
802: mreq->m_pkthdr.rcvif = (struct ifnet *)0;
803: *mbp = mb;
804: return (mreq);
805: }
806:
807: /*
808: * copies mbuf chain to the uio scatter/gather list
809: */
810: int
811: nfsm_mbuftouio(mrep, uiop, siz, dpos)
812: struct mbuf **mrep;
813: register struct uio *uiop;
814: int siz;
815: caddr_t *dpos;
816: {
817: register char *mbufcp, *uiocp;
818: register int xfer, left, len;
819: register struct mbuf *mp;
820: long uiosiz, rem;
821: int error = 0;
822:
823: mp = *mrep;
824: mbufcp = *dpos;
825: len = mtod(mp, caddr_t)+mp->m_len-mbufcp;
826: rem = nfsm_rndup(siz)-siz;
827: while (siz > 0) {
828: if (uiop->uio_iovcnt <= 0 || uiop->uio_iov == NULL)
829: return (EFBIG);
830: left = uiop->uio_iov->iov_len;
831: uiocp = uiop->uio_iov->iov_base;
832: if (left > siz)
833: left = siz;
834: uiosiz = left;
835: while (left > 0) {
836: while (len == 0) {
837: mp = mp->m_next;
838: if (mp == NULL)
839: return (EBADRPC);
840: mbufcp = mtod(mp, caddr_t);
841: len = mp->m_len;
842: }
843: xfer = (left > len) ? len : left;
844: #ifdef notdef
845: /* Not Yet.. */
846: if (uiop->uio_iov->iov_op != NULL)
847: (*(uiop->uio_iov->iov_op))
848: (mbufcp, uiocp, xfer);
849: else
850: #endif
851: if (uiop->uio_segflg == UIO_SYSSPACE)
852: bcopy(mbufcp, uiocp, xfer);
853: else
854: copyout(mbufcp, uiocp, xfer);
855: left -= xfer;
856: len -= xfer;
857: mbufcp += xfer;
858: uiocp += xfer;
859: uiop->uio_offset += xfer;
860: uiop->uio_resid -= xfer;
861: }
862: if (uiop->uio_iov->iov_len <= siz) {
863: uiop->uio_iovcnt--;
864: uiop->uio_iov++;
865: } else {
866: uiop->uio_iov->iov_base += uiosiz;
867: uiop->uio_iov->iov_len -= uiosiz;
868: }
869: siz -= uiosiz;
870: }
871: *dpos = mbufcp;
872: *mrep = mp;
873: if (rem > 0) {
874: if (len < rem)
875: error = nfs_adv(mrep, dpos, rem, len);
876: else
877: *dpos += rem;
878: }
879: return (error);
880: }
881:
882: /*
883: * copies a uio scatter/gather list to an mbuf chain.
884: * NOTE: can ony handle iovcnt == 1
885: */
886: int
887: nfsm_uiotombuf(uiop, mq, siz, bpos)
888: register struct uio *uiop;
889: struct mbuf **mq;
890: int siz;
891: caddr_t *bpos;
892: {
893: register char *uiocp;
894: register struct mbuf *mp, *mp2;
895: register int xfer, left, mlen;
896: int uiosiz, clflg, rem;
897: char *cp;
898:
899: if (uiop->uio_iovcnt != 1)
900: panic("nfsm_uiotombuf: iovcnt != 1");
901:
902: if (siz > MLEN) /* or should it >= MCLBYTES ?? */
903: clflg = 1;
904: else
905: clflg = 0;
906: rem = nfsm_rndup(siz)-siz;
907: mp = mp2 = *mq;
908: while (siz > 0) {
909: left = uiop->uio_iov->iov_len;
910: uiocp = uiop->uio_iov->iov_base;
911: if (left > siz)
912: left = siz;
913: uiosiz = left;
914: while (left > 0) {
915: mlen = M_TRAILINGSPACE(mp);
916: if (mlen == 0) {
917: MGET(mp, M_WAIT, MT_DATA);
918: if (clflg)
919: MCLGET(mp, M_WAIT);
920: mp->m_len = 0;
921: mp2->m_next = mp;
922: mp2 = mp;
923: mlen = M_TRAILINGSPACE(mp);
924: }
925: xfer = (left > mlen) ? mlen : left;
926: #ifdef notdef
927: /* Not Yet.. */
928: if (uiop->uio_iov->iov_op != NULL)
929: (*(uiop->uio_iov->iov_op))
930: (uiocp, mtod(mp, caddr_t)+mp->m_len, xfer);
931: else
932: #endif
933: if (uiop->uio_segflg == UIO_SYSSPACE)
934: bcopy(uiocp, mtod(mp, caddr_t)+mp->m_len, xfer);
935: else
936: copyin(uiocp, mtod(mp, caddr_t)+mp->m_len, xfer);
937: mp->m_len += xfer;
938: left -= xfer;
939: uiocp += xfer;
940: uiop->uio_offset += xfer;
941: uiop->uio_resid -= xfer;
942: }
943: uiop->uio_iov->iov_base += uiosiz;
944: uiop->uio_iov->iov_len -= uiosiz;
945: siz -= uiosiz;
946: }
947: if (rem > 0) {
948: if (rem > M_TRAILINGSPACE(mp)) {
949: MGET(mp, M_WAIT, MT_DATA);
950: mp->m_len = 0;
951: mp2->m_next = mp;
952: }
953: cp = mtod(mp, caddr_t)+mp->m_len;
954: for (left = 0; left < rem; left++)
955: *cp++ = '\0';
956: mp->m_len += rem;
957: *bpos = cp;
958: } else
959: *bpos = mtod(mp, caddr_t)+mp->m_len;
960: *mq = mp;
961: return (0);
962: }
963:
964: /*
965: * Help break down an mbuf chain by setting the first siz bytes contiguous
966: * pointed to by returned val.
967: * This is used by the macros nfsm_dissect and nfsm_dissecton for tough
968: * cases. (The macros use the vars. dpos and dpos2)
969: */
970: int
971: nfsm_disct(mdp, dposp, siz, left, cp2)
972: struct mbuf **mdp;
973: caddr_t *dposp;
974: int siz;
975: int left;
976: caddr_t *cp2;
977: {
978: register struct mbuf *mp, *mp2;
979: register int siz2, xfer;
980: register caddr_t p;
981:
982: mp = *mdp;
983: while (left == 0) {
984: *mdp = mp = mp->m_next;
985: if (mp == NULL)
986: return (EBADRPC);
987: left = mp->m_len;
988: *dposp = mtod(mp, caddr_t);
989: }
990: if (left >= siz) {
991: *cp2 = *dposp;
992: *dposp += siz;
993: } else if (mp->m_next == NULL) {
994: return (EBADRPC);
995: } else if (siz > MHLEN) {
996: panic("nfs S too big");
997: } else {
998: MGET(mp2, M_WAIT, MT_DATA);
999: mp2->m_next = mp->m_next;
1000: mp->m_next = mp2;
1001: mp->m_len -= left;
1002: mp = mp2;
1003: *cp2 = p = mtod(mp, caddr_t);
1004: bcopy(*dposp, p, left); /* Copy what was left */
1005: siz2 = siz-left;
1006: p += left;
1007: mp2 = mp->m_next;
1008: /* Loop around copying up the siz2 bytes */
1009: while (siz2 > 0) {
1010: if (mp2 == NULL)
1011: return (EBADRPC);
1012: xfer = (siz2 > mp2->m_len) ? mp2->m_len : siz2;
1013: if (xfer > 0) {
1014: bcopy(mtod(mp2, caddr_t), p, xfer);
1015: NFSMADV(mp2, xfer);
1016: mp2->m_len -= xfer;
1017: p += xfer;
1018: siz2 -= xfer;
1019: }
1020: if (siz2 > 0)
1021: mp2 = mp2->m_next;
1022: }
1023: mp->m_len = siz;
1024: *mdp = mp2;
1025: *dposp = mtod(mp2, caddr_t);
1026: }
1027: return (0);
1028: }
1029:
1030: /*
1031: * Advance the position in the mbuf chain.
1032: */
1033: int
1034: nfs_adv(mdp, dposp, offs, left)
1035: struct mbuf **mdp;
1036: caddr_t *dposp;
1037: int offs;
1038: int left;
1039: {
1040: register struct mbuf *m;
1041: register int s;
1042:
1043: m = *mdp;
1044: s = left;
1045: while (s < offs) {
1046: offs -= s;
1047: m = m->m_next;
1048: if (m == NULL)
1049: return (EBADRPC);
1050: s = m->m_len;
1051: }
1052: *mdp = m;
1053: *dposp = mtod(m, caddr_t)+offs;
1054: return (0);
1055: }
1056:
1057: /*
1058: * Copy a string into mbufs for the hard cases...
1059: */
1060: int
1061: nfsm_strtmbuf(mb, bpos, cp, siz)
1062: struct mbuf **mb;
1063: char **bpos;
1064: char *cp;
1065: long siz;
1066: {
1067: register struct mbuf *m1 = 0, *m2;
1068: long left, xfer, len, tlen;
1069: u_long *tl;
1070: int putsize;
1071:
1072: putsize = 1;
1073: m2 = *mb;
1074: left = M_TRAILINGSPACE(m2);
1075: if (left > 0) {
1076: tl = ((u_long *)(*bpos));
1077: *tl++ = txdr_unsigned(siz);
1078: putsize = 0;
1079: left -= NFSX_UNSIGNED;
1080: m2->m_len += NFSX_UNSIGNED;
1081: if (left > 0) {
1082: bcopy(cp, (caddr_t) tl, left);
1083: siz -= left;
1084: cp += left;
1085: m2->m_len += left;
1086: left = 0;
1087: }
1088: }
1089: /* Loop around adding mbufs */
1090: while (siz > 0) {
1091: MGET(m1, M_WAIT, MT_DATA);
1092: if (siz > MLEN)
1093: MCLGET(m1, M_WAIT);
1094: m1->m_len = NFSMSIZ(m1);
1095: m2->m_next = m1;
1096: m2 = m1;
1097: tl = mtod(m1, u_long *);
1098: tlen = 0;
1099: if (putsize) {
1100: *tl++ = txdr_unsigned(siz);
1101: m1->m_len -= NFSX_UNSIGNED;
1102: tlen = NFSX_UNSIGNED;
1103: putsize = 0;
1104: }
1105: if (siz < m1->m_len) {
1106: len = nfsm_rndup(siz);
1107: xfer = siz;
1108: if (xfer < len)
1109: *(tl+(xfer>>2)) = 0;
1110: } else {
1111: xfer = len = m1->m_len;
1112: }
1113: bcopy(cp, (caddr_t) tl, xfer);
1114: m1->m_len = len+tlen;
1115: siz -= xfer;
1116: cp += xfer;
1117: }
1118: *mb = m1;
1119: *bpos = mtod(m1, caddr_t)+m1->m_len;
1120: return (0);
1121: }
1122:
1123: /*
1124: * Called once to initialize data structures...
1125: */
1126: int
1127: nfs_init(vfsp)
1128: struct vfsconf *vfsp;
1129: {
1130: register int i;
1131:
1132: /*
1133: * Check to see if major data structures haven't bloated.
1134: */
1135: if (sizeof (struct nfsnode) > NFS_NODEALLOC) {
1136: printf("struct nfsnode bloated (> %dbytes)\n", NFS_NODEALLOC);
1137: printf("Try reducing NFS_SMALLFH\n");
1138: }
1139: if (sizeof (struct nfsmount) > NFS_MNTALLOC) {
1140: printf("struct nfsmount bloated (> %dbytes)\n", NFS_MNTALLOC);
1141: printf("Try reducing NFS_MUIDHASHSIZ\n");
1142: }
1143: if (sizeof (struct nfssvc_sock) > NFS_SVCALLOC) {
1144: printf("struct nfssvc_sock bloated (> %dbytes)\n",NFS_SVCALLOC);
1145: printf("Try reducing NFS_UIDHASHSIZ\n");
1146: }
1147: if (sizeof (struct nfsuid) > NFS_UIDALLOC) {
1148: printf("struct nfsuid bloated (> %dbytes)\n",NFS_UIDALLOC);
1149: printf("Try unionizing the nu_nickname and nu_flag fields\n");
1150: }
1151: nfs_mount_type = vfsp->vfc_typenum;
1152: nfsrtt.pos = 0;
1153: rpc_vers = txdr_unsigned(RPC_VER2);
1154: rpc_call = txdr_unsigned(RPC_CALL);
1155: rpc_reply = txdr_unsigned(RPC_REPLY);
1156: rpc_msgdenied = txdr_unsigned(RPC_MSGDENIED);
1157: rpc_msgaccepted = txdr_unsigned(RPC_MSGACCEPTED);
1158: rpc_mismatch = txdr_unsigned(RPC_MISMATCH);
1159: rpc_autherr = txdr_unsigned(RPC_AUTHERR);
1160: rpc_auth_unix = txdr_unsigned(RPCAUTH_UNIX);
1161: rpc_auth_kerb = txdr_unsigned(RPCAUTH_KERB4);
1162: nfs_prog = txdr_unsigned(NFS_PROG);
1163: nqnfs_prog = txdr_unsigned(NQNFS_PROG);
1164: nfs_true = txdr_unsigned(TRUE);
1165: nfs_false = txdr_unsigned(FALSE);
1166: nfs_xdrneg1 = txdr_unsigned(-1);
1167: nfs_ticks = (hz * NFS_TICKINTVL + 500) / 1000;
1168: if (nfs_ticks < 1)
1169: nfs_ticks = 1;
1170: /* Ensure async daemons disabled */
1171: for (i = 0; i < NFS_MAXASYNCDAEMON; i++) {
1172: nfs_iodwant[i] = (struct proc *)0;
1173: nfs_iodmount[i] = (struct nfsmount *)0;
1174: }
1175: nfs_nhinit(); /* Init the nfsnode table */
1176: #ifndef NFS_NOSERVER
1177: nfsrv_init(0); /* Init server data structures */
1178: nfsrv_initcache(); /* Init the server request cache */
1179: #endif
1180:
1181: /*
1182: * Initialize the nqnfs server stuff.
1183: */
1184: if (nqnfsstarttime == 0) {
1185: nqnfsstarttime = boottime.tv_sec + nqsrv_maxlease
1186: + nqsrv_clockskew + nqsrv_writeslack;
1187: NQLOADNOVRAM(nqnfsstarttime);
1188: CIRCLEQ_INIT(&nqtimerhead);
1189: nqfhhashtbl = hashinit(NQLCHSZ, M_NQLEASE, &nqfhhash);
1190: }
1191:
1192: /*
1193: * Initialize reply list and start timer
1194: */
1195: TAILQ_INIT(&nfs_reqq);
1196:
1197: nfs_timer(0);
1198:
1199:
1200: /* XXX CSM 12/4/97 Where are these declared in FreeBSD? */
1201: #ifdef notyet
1202: /*
1203: * Set up lease_check and lease_updatetime so that other parts
1204: * of the system can call us, if we are loadable.
1205: */
1206: #ifndef NFS_NOSERVER
1207: default_vnodeop_p[VOFFSET(vop_lease)] = (vop_t *)nqnfs_vop_lease_check;
1208: #endif
1209: lease_updatetime = nfs_lease_updatetime;
1210: #endif
1211: vfsp->vfc_refcount++; /* make us non-unloadable */
1212: sysent[SYS_nfssvc].sy_narg = 2;
1213: sysent[SYS_nfssvc].sy_call = nfssvc;
1214: #ifndef NFS_NOSERVER
1215: sysent[SYS_getfh].sy_narg = 2;
1216: sysent[SYS_getfh].sy_call = getfh;
1217: #endif
1218:
1219: return (0);
1220: }
1221:
1222: /*
1223: * Attribute cache routines.
1224: * nfs_loadattrcache() - loads or updates the cache contents from attributes
1225: * that are on the mbuf list
1226: * nfs_getattrcache() - returns valid attributes if found in cache, returns
1227: * error otherwise
1228: */
1229:
1230: /*
1231: * Load the attribute cache (that lives in the nfsnode entry) with
1232: * the values on the mbuf list and
1233: * Iff vap not NULL
1234: * copy the attributes to *vaper
1235: */
1236: int
1237: nfs_loadattrcache(vpp, mdp, dposp, vaper)
1238: struct vnode **vpp;
1239: struct mbuf **mdp;
1240: caddr_t *dposp;
1241: struct vattr *vaper;
1242: {
1243: register struct vnode *vp = *vpp;
1244: register struct vattr *vap;
1245: register struct nfs_fattr *fp;
1246: register struct nfsnode *np;
1247: register long t1;
1248: caddr_t cp2;
1249: int error = 0, rdev;
1250: struct mbuf *md;
1251: enum vtype vtyp;
1252: u_short vmode;
1253: struct timespec mtime;
1254: struct vnode *nvp;
1255: int v3 = NFS_ISV3(vp);
1256:
1257: NFSTRACE(NFSTRC_LAC, vp);
1258: md = *mdp;
1259: t1 = (mtod(md, caddr_t) + md->m_len) - *dposp;
1260: if ((error = nfsm_disct(mdp, dposp, NFSX_FATTR(v3), t1, &cp2)))
1261: return (error);
1262: fp = (struct nfs_fattr *)cp2;
1263: if (v3) {
1264: vtyp = nfsv3tov_type(fp->fa_type);
1265: vmode = fxdr_unsigned(u_short, fp->fa_mode);
1266: rdev = makedev(fxdr_unsigned(int, fp->fa3_rdev.specdata1),
1267: fxdr_unsigned(int, fp->fa3_rdev.specdata2));
1268: fxdr_nfsv3time(&fp->fa3_mtime, &mtime);
1269: } else {
1270: vtyp = nfsv2tov_type(fp->fa_type);
1271: vmode = fxdr_unsigned(u_short, fp->fa_mode);
1272: /*
1273: * XXX
1274: *
1275: * The duplicate information returned in fa_type and fa_mode
1276: * is an ambiguity in the NFS version 2 protocol.
1277: *
1278: * VREG should be taken literally as a regular file. If a
1279: * server intents to return some type information differently
1280: * in the upper bits of the mode field (e.g. for sockets, or
1281: * FIFOs), NFSv2 mandates fa_type to be VNON. Anyway, we
1282: * leave the examination of the mode bits even in the VREG
1283: * case to avoid breakage for bogus servers, but we make sure
1284: * that there are actually type bits set in the upper part of
1285: * fa_mode (and failing that, trust the va_type field).
1286: *
1287: * NFSv3 cleared the issue, and requires fa_mode to not
1288: * contain any type information (while also introduing sockets
1289: * and FIFOs for fa_type).
1290: */
1291: if (vtyp == VNON || (vtyp == VREG && (vmode & S_IFMT) != 0))
1292: vtyp = IFTOVT(vmode);
1293: rdev = fxdr_unsigned(long, fp->fa2_rdev);
1294: fxdr_nfsv2time(&fp->fa2_mtime, &mtime);
1295:
1296: /*
1297: * Really ugly NFSv2 kludge.
1298: */
1299: if (vtyp == VCHR && rdev == 0xffffffff)
1300: vtyp = VFIFO;
1301: }
1302:
1303: /*
1304: * If v_type == VNON it is a new node, so fill in the v_type,
1305: * n_mtime fields. Check to see if it represents a special
1306: * device, and if so, check for a possible alias. Once the
1307: * correct vnode has been obtained, fill in the rest of the
1308: * information.
1309: */
1310: np = VTONFS(vp);
1311: if (vp->v_type != vtyp) {
1312: vp->v_type = vtyp;
1313: #if MACH_NBC
1314: if ((vp->v_type == VREG) && !(vp->v_vm_info)){
1315: vm_info_init(vp);
1316: }
1317: #endif /* MACH_NBC */
1318: if (vp->v_type == VFIFO) {
1319: vp->v_op = fifo_nfsv2nodeop_p;
1320: }
1321: if (vp->v_type == VCHR || vp->v_type == VBLK) {
1322: vp->v_op = spec_nfsv2nodeop_p;
1323: nvp = checkalias(vp, (dev_t)rdev, vp->v_mount);
1324: if (nvp) {
1325: /*
1326: * Discard unneeded vnode, but save its nfsnode.
1327: * Since the nfsnode does not have a lock, its
1328: * vnode lock has to be carried over.
1329: */
1330: nvp->v_vnlock = vp->v_vnlock;
1331: vp->v_vnlock = NULL;
1332: nvp->v_data = vp->v_data;
1333: vp->v_data = NULL;
1334: vp->v_op = spec_vnodeop_p;
1335: vrele(vp);
1336: vgone(vp);
1337: /*
1338: * Reinitialize aliased node.
1339: */
1340: np->n_vnode = nvp;
1341: *vpp = vp = nvp;
1342: }
1343: }
1344: np->n_mtime = mtime.tv_sec;
1345: NFSTRACE(NFSTRC_LAC_INIT, vp);
1346: }
1347: vap = &np->n_vattr;
1348: vap->va_type = vtyp;
1349: vap->va_mode = (vmode & 07777);
1350: vap->va_rdev = (dev_t)rdev;
1351: vap->va_mtime = mtime;
1352: vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0];
1353: if (v3) {
1354: vap->va_nlink = fxdr_unsigned(u_short, fp->fa_nlink);
1355: vap->va_uid = fxdr_unsigned(uid_t, fp->fa_uid);
1356: vap->va_gid = fxdr_unsigned(gid_t, fp->fa_gid);
1357: fxdr_hyper(&fp->fa3_size, &vap->va_size);
1358: vap->va_blocksize = NFS_FABLKSIZE;
1359: fxdr_hyper(&fp->fa3_used, &vap->va_bytes);
1360: vap->va_fileid = fxdr_unsigned(int, fp->fa3_fileid.nfsuquad[1]);
1361: fxdr_nfsv3time(&fp->fa3_atime, &vap->va_atime);
1362: fxdr_nfsv3time(&fp->fa3_ctime, &vap->va_ctime);
1363: vap->va_flags = 0;
1364: vap->va_filerev = 0;
1365: } else {
1366: vap->va_nlink = fxdr_unsigned(u_short, fp->fa_nlink);
1367: vap->va_uid = fxdr_unsigned(uid_t, fp->fa_uid);
1368: vap->va_gid = fxdr_unsigned(gid_t, fp->fa_gid);
1369: vap->va_size = fxdr_unsigned(u_long, fp->fa2_size);
1370: vap->va_blocksize = fxdr_unsigned(long, fp->fa2_blocksize);
1371: vap->va_bytes = fxdr_unsigned(long, fp->fa2_blocks) * NFS_FABLKSIZE;
1372: vap->va_fileid = fxdr_unsigned(long, fp->fa2_fileid);
1373: fxdr_nfsv2time(&fp->fa2_atime, &vap->va_atime);
1374: vap->va_flags = 0;
1375: vap->va_ctime.tv_sec = fxdr_unsigned(long, fp->fa2_ctime.nfsv2_sec);
1376: vap->va_ctime.tv_nsec = 0;
1377: vap->va_gen = fxdr_unsigned(u_long, fp->fa2_ctime.nfsv2_usec);
1378: vap->va_filerev = 0;
1379: }
1380:
1381: if (vap->va_size != np->n_size) {
1382: NFSTRACE4(NFSTRC_LAC_NP, vp, vap->va_size, np->n_size,
1383: (vap->va_type == VREG) |
1384: (np->n_flag & NMODIFIED ? 2 : 0));
1385: if (vap->va_type == VREG) {
1386: if (np->n_flag & NMODIFIED) {
1387: if (vap->va_size < np->n_size)
1388: vap->va_size = np->n_size;
1389: else
1390: np->n_size = vap->va_size;
1391: } else
1392: np->n_size = vap->va_size;
1393: #if !MACH_NBC
1394: vnode_pager_setsize(vp, (u_long)np->n_size);
1395: #endif /* MACH_NBC */
1396: } else
1397: np->n_size = vap->va_size;
1398: }
1399:
1400: #if MACH_NBC
1401: if (vap->va_type == VREG && vp->v_vm_info && vp->v_vm_info->mapped &&
1402: vap->va_size != vp->v_vm_info->vnode_size) {
1403: struct vm_info *vmp = vp->v_vm_info;
1404:
1405: NFSTRACE4(NFSTRC_LAC_MAP, vp, vap->va_size, vmp->vnode_size,
1406: ((long)(vmp->lock.thread) > 0 ? 0x1000 : 0) |
1407: (vmp->lock.thread == current_thread() ? 0x2000 : 0) |
1408: (vmp->lock.want_write ? 0x0100 : 0) |
1409: (vmp->lock.want_upgrade ? 0x0200 : 0) |
1410: (vmp->lock.read_count ? 0x0400 : 0) |
1411: (vmp->nfsdirty ? 0x0010 : 0) |
1412: (np->n_flag & NMODIFIED ? 0x0001 : 0));
1413: if (vmp->nfsdirty || np->n_flag & NMODIFIED) {
1414: np->n_size = vap->va_size = vmp->vnode_size;
1415: } else if (vmp->lock.want_write || vmp->lock.want_upgrade ||
1416: vmp->lock.read_count) {
1417: vmp->invalidate = TRUE; /* vmp_put will do it */
1418: #if DIAGNOSTIC
1419: kprintf("nfs_loadattrcache: invalidate vp %x\n",
1420: (unsigned)vp);
1421: #endif /* DIAGNOSTIC */
1422: } else { /* clear the way for server's dirt */
1423: mapfs_memfree(vmp, TRUE);
1424: vmp->vnode_size = vap->va_size;
1425: #if DIAGNOSTIC
1426: kprintf("nfs_loadattrcache: memfree vp %x\n",
1427: (unsigned)vp);
1428: #endif /* DIAGNOSTIC */
1429: }
1430: }
1431: #endif /* MACH_NBC */
1432:
1433: np->n_attrstamp = time.tv_sec;
1434: if (vaper != NULL) {
1435: bcopy((caddr_t)vap, (caddr_t)vaper, sizeof(*vap));
1436: if (np->n_flag & NCHG) {
1437: if (np->n_flag & NACC)
1438: vaper->va_atime = np->n_atim;
1439: if (np->n_flag & NUPD)
1440: vaper->va_mtime = np->n_mtim;
1441: }
1442: }
1443: return (0);
1444: }
1445:
1446: /*
1447: * Check the time stamp
1448: * If the cache is valid, copy contents to *vap and return 0
1449: * otherwise return an error
1450: */
1451: int
1452: nfs_getattrcache(vp, vaper)
1453: register struct vnode *vp;
1454: struct vattr *vaper;
1455: {
1456: register struct nfsnode *np = VTONFS(vp);
1457: register struct vattr *vap;
1458:
1459: if ((time.tv_sec - np->n_attrstamp) >= NFS_ATTRTIMEO(np)) {
1460: NFSTRACE(NFSTRC_GAC_MISS, vp);
1461: nfsstats.attrcache_misses++;
1462: return (ENOENT);
1463: }
1464: NFSTRACE(NFSTRC_GAC_HIT, vp);
1465: nfsstats.attrcache_hits++;
1466: vap = &np->n_vattr;
1467:
1468: if (vap->va_size != np->n_size) {
1469: NFSTRACE4(NFSTRC_GAC_NP, vp, vap->va_size, np->n_size,
1470: (vap->va_type == VREG) |
1471: (np->n_flag & NMODIFIED ? 2 : 0));
1472: if (vap->va_type == VREG) {
1473: if (np->n_flag & NMODIFIED) {
1474: if (vap->va_size < np->n_size)
1475: vap->va_size = np->n_size;
1476: else
1477: np->n_size = vap->va_size;
1478: } else
1479: np->n_size = vap->va_size;
1480: #if !MACH_NBC
1481: vnode_pager_setsize(vp, (u_long)np->n_size);
1482: #endif /* !MACH_NBC */
1483: } else
1484: np->n_size = vap->va_size;
1485: }
1486:
1487: #if MACH_NBC
1488: if (vap->va_type == VREG && vp->v_vm_info && vp->v_vm_info->mapped &&
1489: vap->va_size != vp->v_vm_info->vnode_size) {
1490: struct vm_info *vmp = vp->v_vm_info;
1491:
1492: NFSTRACE4(NFSTRC_GAC_MAP, vp, vap->va_size, vmp->vnode_size,
1493: ((long)(vmp->lock.thread) > 0 ? 0x1000 : 0) |
1494: (vmp->lock.thread == current_thread() ? 0x2000 : 0) |
1495: (vmp->lock.want_write ? 0x0100 : 0) |
1496: (vmp->lock.want_upgrade ? 0x0200 : 0) |
1497: (vmp->lock.read_count ? 0x0400 : 0) |
1498: (vmp->nfsdirty ? 0x0010 : 0) |
1499: (np->n_flag & NMODIFIED ? 0x0001 : 0));
1500: if (vmp->nfsdirty || np->n_flag & NMODIFIED) {
1501: /* keep eating our own dirt */
1502: np->n_size = vap->va_size = vmp->vnode_size;
1503: } else if (vmp->lock.want_write || vmp->lock.want_upgrade ||
1504: vmp->lock.read_count) {
1505: vmp->invalidate = TRUE; /* vmp_put will do it */
1506: #if DIAGNOSTIC
1507: kprintf("nfs_getattrcache: invalidate vp %x\n",
1508: (unsigned)vp);
1509: #endif /* DIAGNOSTIC */
1510: } else { /* clear the way for server's dirt */
1511: mapfs_memfree(vmp, TRUE);
1512: vmp->vnode_size = vap->va_size;
1513: #if DIAGNOSTIC
1514: kprintf("nfs_getattrcache: memfree vp %x\n",
1515: (unsigned)vp);
1516: #endif /* DIAGNOSTIC */
1517: }
1518: }
1519: #endif /* MACH_NBC */
1520:
1521: bcopy((caddr_t)vap, (caddr_t)vaper, sizeof(struct vattr));
1522: if (np->n_flag & NCHG) {
1523: if (np->n_flag & NACC)
1524: vaper->va_atime = np->n_atim;
1525: if (np->n_flag & NUPD)
1526: vaper->va_mtime = np->n_mtim;
1527: }
1528: return (0);
1529: }
1530:
1531: #ifndef NFS_NOSERVER
1532: /*
1533: * Set up nameidata for a lookup() call and do it.
1534: *
1535: * If pubflag is set, this call is done for a lookup operation on the
1536: * public filehandle. In that case we allow crossing mountpoints and
1537: * absolute pathnames. However, the caller is expected to check that
1538: * the lookup result is within the public fs, and deny access if
1539: * it is not.
1540: */
1541: int
1542: nfs_namei(ndp, fhp, len, slp, nam, mdp, dposp, retdirp, p, kerbflag, pubflag)
1543: register struct nameidata *ndp;
1544: fhandle_t *fhp;
1545: int len;
1546: struct nfssvc_sock *slp;
1547: struct mbuf *nam;
1548: struct mbuf **mdp;
1549: caddr_t *dposp;
1550: struct vnode **retdirp;
1551: struct proc *p;
1552: int kerbflag, pubflag;
1553: {
1554: register int i, rem;
1555: register struct mbuf *md;
1556: register char *fromcp, *tocp, *cp;
1557: struct iovec aiov;
1558: struct uio auio;
1559: struct vnode *dp;
1560: int error, rdonly, linklen;
1561: struct componentname *cnp = &ndp->ni_cnd;
1562: int olen = len;
1563:
1564: *retdirp = (struct vnode *)0;
1565: MALLOC_ZONE(cnp->cn_pnbuf, char *, len + 1, M_NAMEI, M_WAITOK);
1566: cnp->cn_pnlen = len + 1;
1567:
1568: /*
1569: * Copy the name from the mbuf list to ndp->ni_pnbuf
1570: * and set the various ndp fields appropriately.
1571: */
1572: fromcp = *dposp;
1573: tocp = cnp->cn_pnbuf;
1574: md = *mdp;
1575: rem = mtod(md, caddr_t) + md->m_len - fromcp;
1576: cnp->cn_hash = 0;
1577: for (i = 1; i <= len; i++) {
1578: while (rem == 0) {
1579: md = md->m_next;
1580: if (md == NULL) {
1581: error = EBADRPC;
1582: goto out;
1583: }
1584: fromcp = mtod(md, caddr_t);
1585: rem = md->m_len;
1586: }
1587: /* XXX CSM 12/4/97 Revisit when enabling WebNFS */
1588: #ifdef notdef
1589: if (*fromcp == '\0' || (!pubflag && *fromcp == '/')) {
1590: #else
1591: if (*fromcp == '\0' || *fromcp == '/') {
1592: #endif
1593: error = EACCES;
1594: goto out;
1595: }
1596: cnp->cn_hash += (unsigned char)*fromcp * i;
1597: *tocp++ = *fromcp++;
1598: rem--;
1599: }
1600: *tocp = '\0';
1601: *mdp = md;
1602: *dposp = fromcp;
1603: len = nfsm_rndup(len)-len;
1604: if (len > 0) {
1605: if (rem >= len)
1606: *dposp += len;
1607: else if ((error = nfs_adv(mdp, dposp, len, rem)) != 0)
1608: goto out;
1609: }
1610:
1611: /*
1612: * Extract and set starting directory.
1613: */
1614: error = nfsrv_fhtovp(fhp, FALSE, &dp, ndp->ni_cnd.cn_cred, slp,
1615: nam, &rdonly, kerbflag, pubflag);
1616: if (error)
1617: goto out;
1618: if (dp->v_type != VDIR) {
1619: vrele(dp);
1620: error = ENOTDIR;
1621: goto out;
1622: }
1623:
1624: if (rdonly)
1625: cnp->cn_flags |= RDONLY;
1626:
1627: *retdirp = dp;
1628:
1629: /* XXX CSM 12/4/97 Revisit when enabling WebNFS */
1630: /* XXX debo 12/15/97 Need to fix M_NAMEI allocations to use zone protocol */
1631: #ifdef notyet
1632: if (pubflag) {
1633: /*
1634: * Oh joy. For WebNFS, handle those pesky '%' escapes,
1635: * and the 'native path' indicator.
1636: */
1637: MALLOC(cp, char *, olen + 1, M_NAMEI, M_WAITOK);
1638: fromcp = cnp->cn_pnbuf;
1639: tocp = cp;
1640: if ((unsigned char)*fromcp >= WEBNFS_SPECCHAR_START) {
1641: switch ((unsigned char)*fromcp) {
1642: case WEBNFS_NATIVE_CHAR:
1643: /*
1644: * 'Native' path for us is the same
1645: * as a path according to the NFS spec,
1646: * just skip the escape char.
1647: */
1648: fromcp++;
1649: break;
1650: /*
1651: * More may be added in the future, range 0x80-0xff
1652: */
1653: default:
1654: error = EIO;
1655: FREE(cp, M_NAMEI);
1656: goto out;
1657: }
1658: }
1659: /*
1660: * Translate the '%' escapes, URL-style.
1661: */
1662: while (*fromcp != '\0') {
1663: if (*fromcp == WEBNFS_ESC_CHAR) {
1664: if (fromcp[1] != '\0' && fromcp[2] != '\0') {
1665: fromcp++;
1666: *tocp++ = HEXSTRTOI(fromcp);
1667: fromcp += 2;
1668: continue;
1669: } else {
1670: error = ENOENT;
1671: FREE(cp, M_NAMEI);
1672: goto out;
1673: }
1674: } else
1675: *tocp++ = *fromcp++;
1676: }
1677: *tocp = '\0';
1678: FREE(cnp->cn_pnbuf, M_NAMEI);
1679: cnp->cn_pnbuf = cp;
1680: }
1681: #endif
1682:
1683: ndp->ni_pathlen = (tocp - cnp->cn_pnbuf) + 1;
1684: ndp->ni_segflg = UIO_SYSSPACE;
1685:
1686: /* XXX CSM 12/4/97 Revisit when enabling WebNFS */
1687: #ifdef notyet
1688: if (pubflag) {
1689: ndp->ni_rootdir = rootvnode;
1690: ndp->ni_loopcnt = 0;
1691: if (cnp->cn_pnbuf[0] == '/')
1692: dp = rootvnode;
1693: } else {
1694: cnp->cn_flags |= NOCROSSMOUNT;
1695: }
1696: #else
1697: cnp->cn_flags |= NOCROSSMOUNT;
1698: #endif
1699:
1700: cnp->cn_proc = p;
1701: VREF(dp);
1702:
1703: for (;;) {
1704: cnp->cn_nameptr = cnp->cn_pnbuf;
1705: ndp->ni_startdir = dp;
1706: /*
1707: * And call lookup() to do the real work
1708: */
1709: error = lookup(ndp);
1710: if (error)
1711: break;
1712: /*
1713: * Check for encountering a symbolic link
1714: */
1715: if ((cnp->cn_flags & ISSYMLINK) == 0) {
1716: nfsrv_object_create(ndp->ni_vp);
1717: if (cnp->cn_flags & (SAVENAME | SAVESTART)) {
1718: cnp->cn_flags |= HASBUF;
1719: return (0);
1720: }
1721: break;
1722: } else {
1723: if ((cnp->cn_flags & LOCKPARENT) && ndp->ni_pathlen == 1)
1724: VOP_UNLOCK(ndp->ni_dvp, 0, p);
1725: /* XXX CSM 12/4/97 Revisit when enabling WebNFS */
1726: #ifdef notyet
1727: if (!pubflag) {
1728: #endif
1729: vrele(ndp->ni_dvp);
1730: vput(ndp->ni_vp);
1731: ndp->ni_vp = NULL;
1732: error = EINVAL;
1733: break;
1734: /* XXX CSM 12/4/97 Revisit when enabling WebNFS */
1735: /* XXX debo 12/15/97 Need to fix M_NAMEI allocations to use zone protocol */
1736: #ifdef notyet
1737: }
1738:
1739: if (ndp->ni_loopcnt++ >= MAXSYMLINKS) {
1740: error = ELOOP;
1741: break;
1742: }
1743: if (ndp->ni_pathlen > 1)
1744: MALLOC(cp, char *, olen + 1, M_NAMEI, M_WAITOK);
1745: else
1746: cp = cnp->cn_pnbuf;
1747: aiov.iov_base = cp;
1748: aiov.iov_len = MAXPATHLEN;
1749: auio.uio_iov = &aiov;
1750: auio.uio_iovcnt = 1;
1751: auio.uio_offset = 0;
1752: auio.uio_rw = UIO_READ;
1753: auio.uio_segflg = UIO_SYSSPACE;
1754: auio.uio_procp = (struct proc *)0;
1755: auio.uio_resid = MAXPATHLEN;
1756: error = VOP_READLINK(ndp->ni_vp, &auio, cnp->cn_cred);
1757: if (error) {
1758: badlink:
1759: if (ndp->ni_pathlen > 1)
1760: FREE(cp, M_NAMEI);
1761: break;
1762: }
1763: linklen = MAXPATHLEN - auio.uio_resid;
1764: if (linklen == 0) {
1765: error = ENOENT;
1766: goto badlink;
1767: }
1768: if (linklen + ndp->ni_pathlen >= MAXPATHLEN) {
1769: error = ENAMETOOLONG;
1770: goto badlink;
1771: }
1772: if (ndp->ni_pathlen > 1) {
1773: bcopy(ndp->ni_next, cp + linklen, ndp->ni_pathlen);
1774: FREE(cnp->cn_pnbuf, M_NAMEI);
1775: cnp->cn_pnbuf = cp;
1776: } else
1777: cnp->cn_pnbuf[linklen] = '\0';
1778: ndp->ni_pathlen += linklen;
1779: vput(ndp->ni_vp);
1780: dp = ndp->ni_dvp;
1781: /*
1782: * Check if root directory should replace current directory.
1783: */
1784: if (cnp->cn_pnbuf[0] == '/') {
1785: vrele(dp);
1786: dp = ndp->ni_rootdir;
1787: VREF(dp);
1788: }
1789: #endif
1790: }
1791: }
1792: out:
1793: FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI);
1794: return (error);
1795: }
1796:
1797: /*
1798: * A fiddled version of m_adj() that ensures null fill to a long
1799: * boundary and only trims off the back end
1800: */
1801: void
1802: nfsm_adj(mp, len, nul)
1803: struct mbuf *mp;
1804: register int len;
1805: int nul;
1806: {
1807: register struct mbuf *m;
1808: register int count, i;
1809: register char *cp;
1810:
1811: /*
1812: * Trim from tail. Scan the mbuf chain,
1813: * calculating its length and finding the last mbuf.
1814: * If the adjustment only affects this mbuf, then just
1815: * adjust and return. Otherwise, rescan and truncate
1816: * after the remaining size.
1817: */
1818: count = 0;
1819: m = mp;
1820: for (;;) {
1821: count += m->m_len;
1822: if (m->m_next == (struct mbuf *)0)
1823: break;
1824: m = m->m_next;
1825: }
1826: if (m->m_len > len) {
1827: m->m_len -= len;
1828: if (nul > 0) {
1829: cp = mtod(m, caddr_t)+m->m_len-nul;
1830: for (i = 0; i < nul; i++)
1831: *cp++ = '\0';
1832: }
1833: return;
1834: }
1835: count -= len;
1836: if (count < 0)
1837: count = 0;
1838: /*
1839: * Correct length for chain is "count".
1840: * Find the mbuf with last data, adjust its length,
1841: * and toss data from remaining mbufs on chain.
1842: */
1843: for (m = mp; m; m = m->m_next) {
1844: if (m->m_len >= count) {
1845: m->m_len = count;
1846: if (nul > 0) {
1847: cp = mtod(m, caddr_t)+m->m_len-nul;
1848: for (i = 0; i < nul; i++)
1849: *cp++ = '\0';
1850: }
1851: break;
1852: }
1853: count -= m->m_len;
1854: }
1855: for (m = m->m_next;m;m = m->m_next)
1856: m->m_len = 0;
1857: }
1858:
1859: /*
1860: * Make these functions instead of macros, so that the kernel text size
1861: * doesn't get too big...
1862: */
1863: void
1864: nfsm_srvwcc(nfsd, before_ret, before_vap, after_ret, after_vap, mbp, bposp)
1865: struct nfsrv_descript *nfsd;
1866: int before_ret;
1867: register struct vattr *before_vap;
1868: int after_ret;
1869: struct vattr *after_vap;
1870: struct mbuf **mbp;
1871: char **bposp;
1872: {
1873: register struct mbuf *mb = *mbp, *mb2;
1874: register char *bpos = *bposp;
1875: register u_long *tl;
1876:
1877: if (before_ret) {
1878: nfsm_build(tl, u_long *, NFSX_UNSIGNED);
1879: *tl = nfs_false;
1880: } else {
1881: nfsm_build(tl, u_long *, 7 * NFSX_UNSIGNED);
1882: *tl++ = nfs_true;
1883: txdr_hyper(&(before_vap->va_size), tl);
1884: tl += 2;
1885: txdr_nfsv3time(&(before_vap->va_mtime), tl);
1886: tl += 2;
1887: txdr_nfsv3time(&(before_vap->va_ctime), tl);
1888: }
1889: *bposp = bpos;
1890: *mbp = mb;
1891: nfsm_srvpostopattr(nfsd, after_ret, after_vap, mbp, bposp);
1892: }
1893:
1894: void
1895: nfsm_srvpostopattr(nfsd, after_ret, after_vap, mbp, bposp)
1896: struct nfsrv_descript *nfsd;
1897: int after_ret;
1898: struct vattr *after_vap;
1899: struct mbuf **mbp;
1900: char **bposp;
1901: {
1902: register struct mbuf *mb = *mbp, *mb2;
1903: register char *bpos = *bposp;
1904: register u_long *tl;
1905: register struct nfs_fattr *fp;
1906:
1907: if (after_ret) {
1908: nfsm_build(tl, u_long *, NFSX_UNSIGNED);
1909: *tl = nfs_false;
1910: } else {
1911: nfsm_build(tl, u_long *, NFSX_UNSIGNED + NFSX_V3FATTR);
1912: *tl++ = nfs_true;
1913: fp = (struct nfs_fattr *)tl;
1914: nfsm_srvfattr(nfsd, after_vap, fp);
1915: }
1916: *mbp = mb;
1917: *bposp = bpos;
1918: }
1919:
1920: void
1921: nfsm_srvfattr(nfsd, vap, fp)
1922: register struct nfsrv_descript *nfsd;
1923: register struct vattr *vap;
1924: register struct nfs_fattr *fp;
1925: {
1926:
1927: fp->fa_nlink = txdr_unsigned(vap->va_nlink);
1928: fp->fa_uid = txdr_unsigned(vap->va_uid);
1929: fp->fa_gid = txdr_unsigned(vap->va_gid);
1930: if (nfsd->nd_flag & ND_NFSV3) {
1931: fp->fa_type = vtonfsv3_type(vap->va_type);
1932: fp->fa_mode = vtonfsv3_mode(vap->va_mode);
1933: txdr_hyper(&vap->va_size, &fp->fa3_size);
1934: txdr_hyper(&vap->va_bytes, &fp->fa3_used);
1935: fp->fa3_rdev.specdata1 = txdr_unsigned(major(vap->va_rdev));
1936: fp->fa3_rdev.specdata2 = txdr_unsigned(minor(vap->va_rdev));
1937: fp->fa3_fsid.nfsuquad[0] = 0;
1938: fp->fa3_fsid.nfsuquad[1] = txdr_unsigned(vap->va_fsid);
1939: fp->fa3_fileid.nfsuquad[0] = 0;
1940: fp->fa3_fileid.nfsuquad[1] = txdr_unsigned(vap->va_fileid);
1941: txdr_nfsv3time(&vap->va_atime, &fp->fa3_atime);
1942: txdr_nfsv3time(&vap->va_mtime, &fp->fa3_mtime);
1943: txdr_nfsv3time(&vap->va_ctime, &fp->fa3_ctime);
1944: } else {
1945: fp->fa_type = vtonfsv2_type(vap->va_type);
1946: fp->fa_mode = vtonfsv2_mode(vap->va_type, vap->va_mode);
1947: fp->fa2_size = txdr_unsigned(vap->va_size);
1948: fp->fa2_blocksize = txdr_unsigned(vap->va_blocksize);
1949: if (vap->va_type == VFIFO)
1950: fp->fa2_rdev = 0xffffffff;
1951: else
1952: fp->fa2_rdev = txdr_unsigned(vap->va_rdev);
1953: fp->fa2_blocks = txdr_unsigned(vap->va_bytes / NFS_FABLKSIZE);
1954: fp->fa2_fsid = txdr_unsigned(vap->va_fsid);
1955: fp->fa2_fileid = txdr_unsigned(vap->va_fileid);
1956: txdr_nfsv2time(&vap->va_atime, &fp->fa2_atime);
1957: txdr_nfsv2time(&vap->va_mtime, &fp->fa2_mtime);
1958: txdr_nfsv2time(&vap->va_ctime, &fp->fa2_ctime);
1959: }
1960: }
1961:
1962: /*
1963: * nfsrv_fhtovp() - convert a fh to a vnode ptr (optionally locked)
1964: * - look up fsid in mount list (if not found ret error)
1965: * - get vp and export rights by calling VFS_FHTOVP()
1966: * - if cred->cr_uid == 0 or MNT_EXPORTANON set it to credanon
1967: * - if not lockflag unlock it with VOP_UNLOCK()
1968: */
1969: int
1970: nfsrv_fhtovp(fhp, lockflag, vpp, cred, slp, nam, rdonlyp, kerbflag, pubflag)
1971: fhandle_t *fhp;
1972: int lockflag;
1973: struct vnode **vpp;
1974: struct ucred *cred;
1975: struct nfssvc_sock *slp;
1976: struct mbuf *nam;
1977: int *rdonlyp;
1978: int kerbflag;
1979: int pubflag;
1980: {
1981: struct proc *p = current_proc(); /* XXX */
1982: register struct mount *mp;
1983: register int i;
1984: struct ucred *credanon;
1985: int error, exflags;
1986:
1987: *vpp = (struct vnode *)0;
1988:
1989: /* XXX CSM 12/4/97 Revisit when enabling WebNFS */
1990: #ifdef notyet
1991: if (nfs_ispublicfh(fhp)) {
1992: if (!pubflag || !nfs_pub.np_valid)
1993: return (ESTALE);
1994: fhp = &nfs_pub.np_handle;
1995: }
1996: #endif
1997:
1998: mp = vfs_getvfs(&fhp->fh_fsid);
1999: if (!mp)
2000: return (ESTALE);
2001: error = VFS_FHTOVP(mp, &fhp->fh_fid, nam, vpp, &exflags, &credanon);
2002: if (error)
2003: return (error);
2004: /*
2005: * Check/setup credentials.
2006: */
2007: if (exflags & MNT_EXKERB) {
2008: if (!kerbflag) {
2009: vput(*vpp);
2010: return (NFSERR_AUTHERR | AUTH_TOOWEAK);
2011: }
2012: } else if (kerbflag) {
2013: vput(*vpp);
2014: return (NFSERR_AUTHERR | AUTH_TOOWEAK);
2015: } else if (cred->cr_uid == 0 || (exflags & MNT_EXPORTANON)) {
2016: cred->cr_uid = credanon->cr_uid;
2017: for (i = 0; i < credanon->cr_ngroups && i < NGROUPS; i++)
2018: cred->cr_groups[i] = credanon->cr_groups[i];
2019: cred->cr_ngroups = i;
2020: }
2021: if (exflags & MNT_EXRDONLY)
2022: *rdonlyp = 1;
2023: else
2024: *rdonlyp = 0;
2025:
2026: nfsrv_object_create(*vpp);
2027:
2028: if (!lockflag)
2029: VOP_UNLOCK(*vpp, 0, p);
2030: return (0);
2031: }
2032:
2033:
2034: /*
2035: * WebNFS: check if a filehandle is a public filehandle. For v3, this
2036: * means a length of 0, for v2 it means all zeroes. nfsm_srvmtofh has
2037: * transformed this to all zeroes in both cases, so check for it.
2038: */
2039: int
2040: nfs_ispublicfh(fhp)
2041: fhandle_t *fhp;
2042: {
2043: char *cp = (char *)fhp;
2044: int i;
2045:
2046: for (i = 0; i < NFSX_V3FH; i++)
2047: if (*cp++ != 0)
2048: return (FALSE);
2049: return (TRUE);
2050: }
2051:
2052: #endif /* NFS_NOSERVER */
2053: /*
2054: * This function compares two net addresses by family and returns TRUE
2055: * if they are the same host.
2056: * If there is any doubt, return FALSE.
2057: * The AF_INET family is handled as a special case so that address mbufs
2058: * don't need to be saved to store "struct in_addr", which is only 4 bytes.
2059: */
2060: int
2061: netaddr_match(family, haddr, nam)
2062: int family;
2063: union nethostaddr *haddr;
2064: struct mbuf *nam;
2065: {
2066: register struct sockaddr_in *inetaddr;
2067:
2068: switch (family) {
2069: case AF_INET:
2070: inetaddr = mtod(nam, struct sockaddr_in *);
2071: if (inetaddr->sin_family == AF_INET &&
2072: inetaddr->sin_addr.s_addr == haddr->had_inetaddr)
2073: return (1);
2074: break;
2075: #if ISO
2076: case AF_ISO:
2077: {
2078: register struct sockaddr_iso *isoaddr1, *isoaddr2;
2079:
2080: isoaddr1 = mtod(nam, struct sockaddr_iso *);
2081: isoaddr2 = mtod(haddr->had_nam, struct sockaddr_iso *);
2082: if (isoaddr1->siso_family == AF_ISO &&
2083: isoaddr1->siso_nlen > 0 &&
2084: isoaddr1->siso_nlen == isoaddr2->siso_nlen &&
2085: SAME_ISOADDR(isoaddr1, isoaddr2))
2086: return (1);
2087: break;
2088: }
2089: #endif /* ISO */
2090: default:
2091: break;
2092: };
2093: return (0);
2094: }
2095:
2096: static nfsuint64 nfs_nullcookie = { 0, 0 };
2097: /*
2098: * This function finds the directory cookie that corresponds to the
2099: * logical byte offset given.
2100: */
2101: nfsuint64 *
2102: nfs_getcookie(np, off, add)
2103: register struct nfsnode *np;
2104: off_t off;
2105: int add;
2106: {
2107: register struct nfsdmap *dp, *dp2;
2108: register int pos;
2109:
2110: pos = off / NFS_DIRBLKSIZ;
2111: if (pos == 0) {
2112: #if DIAGNOSTIC
2113: if (add)
2114: panic("nfs getcookie add at 0");
2115: #endif
2116: return (&nfs_nullcookie);
2117: }
2118: pos--;
2119: dp = np->n_cookies.lh_first;
2120: if (!dp) {
2121: if (add) {
2122: MALLOC_ZONE(dp, struct nfsdmap *,
2123: sizeof (struct nfsdmap),
2124: M_NFSDIROFF, M_WAITOK);
2125: dp->ndm_eocookie = 0;
2126: LIST_INSERT_HEAD(&np->n_cookies, dp, ndm_list);
2127: } else
2128: return ((nfsuint64 *)0);
2129: }
2130: while (pos >= NFSNUMCOOKIES) {
2131: pos -= NFSNUMCOOKIES;
2132: if (dp->ndm_list.le_next) {
2133: if (!add && dp->ndm_eocookie < NFSNUMCOOKIES &&
2134: pos >= dp->ndm_eocookie)
2135: return ((nfsuint64 *)0);
2136: dp = dp->ndm_list.le_next;
2137: } else if (add) {
2138: MALLOC_ZONE(dp2, struct nfsdmap *,
2139: sizeof (struct nfsdmap),
2140: M_NFSDIROFF, M_WAITOK);
2141: dp2->ndm_eocookie = 0;
2142: LIST_INSERT_AFTER(dp, dp2, ndm_list);
2143: dp = dp2;
2144: } else
2145: return ((nfsuint64 *)0);
2146: }
2147: if (pos >= dp->ndm_eocookie) {
2148: if (add)
2149: dp->ndm_eocookie = pos + 1;
2150: else
2151: return ((nfsuint64 *)0);
2152: }
2153: return (&dp->ndm_cookies[pos]);
2154: }
2155:
2156: /*
2157: * Invalidate cached directory information, except for the actual directory
2158: * blocks (which are invalidated separately).
2159: * Done mainly to avoid the use of stale offset cookies.
2160: */
2161: void
2162: nfs_invaldir(vp)
2163: register struct vnode *vp;
2164: {
2165: register struct nfsnode *np = VTONFS(vp);
2166:
2167: #if DIAGNOSTIC
2168: if (vp->v_type != VDIR)
2169: panic("nfs: invaldir not dir");
2170: #endif
2171: np->n_direofoffset = 0;
2172: np->n_cookieverf.nfsuquad[0] = 0;
2173: np->n_cookieverf.nfsuquad[1] = 0;
2174: if (np->n_cookies.lh_first)
2175: np->n_cookies.lh_first->ndm_eocookie = 0;
2176: }
2177:
2178: /*
2179: * The write verifier has changed (probably due to a server reboot), so all
2180: * B_NEEDCOMMIT blocks will have to be written again. Since they are on the
2181: * dirty block list as B_DELWRI, all this takes is clearing the B_NEEDCOMMIT
2182: * flag. Once done the new write verifier can be set for the mount point.
2183: */
2184: void
2185: nfs_clearcommit(mp)
2186: struct mount *mp;
2187: {
2188: register struct vnode *vp, *nvp;
2189: register struct buf *bp, *nbp;
2190: int s;
2191:
2192: s = splbio();
2193: loop:
2194: for (vp = mp->mnt_vnodelist.lh_first; vp; vp = nvp) {
2195: if (vp->v_mount != mp) /* Paranoia */
2196: goto loop;
2197: nvp = vp->v_mntvnodes.le_next;
2198: for (bp = vp->v_dirtyblkhd.lh_first; bp; bp = nbp) {
2199: nbp = bp->b_vnbufs.le_next;
2200: if ((bp->b_flags & (B_BUSY | B_DELWRI | B_NEEDCOMMIT))
2201: == (B_DELWRI | B_NEEDCOMMIT))
2202: bp->b_flags &= ~B_NEEDCOMMIT;
2203: }
2204: }
2205: splx(s);
2206: }
2207:
2208: #ifndef NFS_NOSERVER
2209: /*
2210: * Map errnos to NFS error numbers. For Version 3 also filter out error
2211: * numbers not specified for the associated procedure.
2212: */
2213: int
2214: nfsrv_errmap(nd, err)
2215: struct nfsrv_descript *nd;
2216: register int err;
2217: {
2218: register short *defaulterrp, *errp;
2219:
2220: if (nd->nd_flag & ND_NFSV3) {
2221: if (nd->nd_procnum <= NFSPROC_COMMIT) {
2222: errp = defaulterrp = nfsrv_v3errmap[nd->nd_procnum];
2223: while (*++errp) {
2224: if (*errp == err)
2225: return (err);
2226: else if (*errp > err)
2227: break;
2228: }
2229: return ((int)*defaulterrp);
2230: } else
2231: return (err & 0xffff);
2232: }
2233: if (err <= ELAST)
2234: return ((int)nfsrv_v2errmap[err - 1]);
2235: return (NFSERR_IO);
2236: }
2237:
2238: /* XXX CSM 11/25/97 Revisit when Ramesh merges vm with buffer cache */
2239: #define vfs_object_create(v, p, c, l) (0)
2240:
2241: int
2242: nfsrv_object_create(struct vnode *vp) {
2243: struct proc *curproc = current_proc();
2244:
2245: if ((vp == NULL) || (vp->v_type != VREG))
2246: return 1;
2247: return vfs_object_create(vp, curproc, curproc?curproc->p_ucred:NULL, 1);
2248: }
2249: #endif /* NFS_NOSERVER */
2250:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.