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