Commit | Line | Data |
---|---|---|
984263bc MD |
1 | /* |
2 | * Copyright (c) 1989, 1993 | |
3 | * The Regents of the University of California. All rights reserved. | |
4 | * | |
5 | * This code is derived from software contributed to Berkeley by | |
6 | * Rick Macklem at The University of Guelph. | |
7 | * | |
8 | * Redistribution and use in source and binary forms, with or without | |
9 | * modification, are permitted provided that the following conditions | |
10 | * are met: | |
11 | * 1. Redistributions of source code must retain the above copyright | |
12 | * notice, this list of conditions and the following disclaimer. | |
13 | * 2. Redistributions in binary form must reproduce the above copyright | |
14 | * notice, this list of conditions and the following disclaimer in the | |
15 | * documentation and/or other materials provided with the distribution. | |
16 | * 3. All advertising materials mentioning features or use of this software | |
17 | * must display the following acknowledgement: | |
18 | * This product includes software developed by the University of | |
19 | * California, Berkeley and its contributors. | |
20 | * 4. Neither the name of the University nor the names of its contributors | |
21 | * may be used to endorse or promote products derived from this software | |
22 | * without specific prior written permission. | |
23 | * | |
24 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | |
25 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
26 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
27 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | |
28 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
29 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |
30 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
31 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | |
32 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | |
33 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | |
34 | * SUCH DAMAGE. | |
35 | * | |
36 | * @(#)nfs_subs.c 8.8 (Berkeley) 5/22/95 | |
79e5012e | 37 | * $FreeBSD: /repoman/r/ncvs/src/sys/nfsclient/nfs_subs.c,v 1.128 2004/04/14 23:23:55 peadar Exp $ |
67863d04 | 38 | * $DragonFly: src/sys/vfs/nfs/nfs_subs.c,v 1.48 2008/09/17 21:44:24 dillon Exp $ |
984263bc MD |
39 | */ |
40 | ||
41 | /* | |
42 | * These functions support the macros and help fiddle mbuf chains for | |
43 | * the nfs op functions. They do things like create the rpc header and | |
44 | * copy data between mbuf chains and uio lists. | |
45 | */ | |
46 | #include <sys/param.h> | |
47 | #include <sys/systm.h> | |
48 | #include <sys/kernel.h> | |
49 | #include <sys/buf.h> | |
50 | #include <sys/proc.h> | |
51 | #include <sys/mount.h> | |
52 | #include <sys/vnode.h> | |
fad57d0e | 53 | #include <sys/nlookup.h> |
984263bc MD |
54 | #include <sys/namei.h> |
55 | #include <sys/mbuf.h> | |
56 | #include <sys/socket.h> | |
57 | #include <sys/stat.h> | |
58 | #include <sys/malloc.h> | |
59 | #include <sys/sysent.h> | |
60 | #include <sys/syscall.h> | |
61 | #include <sys/conf.h> | |
70aac194 | 62 | #include <sys/objcache.h> |
984263bc MD |
63 | |
64 | #include <vm/vm.h> | |
65 | #include <vm/vm_object.h> | |
66 | #include <vm/vm_extern.h> | |
67 | #include <vm/vm_zone.h> | |
68 | ||
3020e3be MD |
69 | #include <sys/buf2.h> |
70 | ||
1f2de5d4 MD |
71 | #include "rpcv2.h" |
72 | #include "nfsproto.h" | |
73 | #include "nfs.h" | |
c1cf1e59 | 74 | #include "nfsmount.h" |
1f2de5d4 MD |
75 | #include "nfsnode.h" |
76 | #include "xdr_subs.h" | |
77 | #include "nfsm_subs.h" | |
1f2de5d4 | 78 | #include "nfsrtt.h" |
984263bc MD |
79 | |
80 | #include <netinet/in.h> | |
81 | ||
82 | /* | |
83 | * Data items converted to xdr at startup, since they are constant | |
84 | * This is kinda hokey, but may save a little time doing byte swaps | |
85 | */ | |
86 | u_int32_t nfs_xdrneg1; | |
e97453f3 MD |
87 | u_int32_t rpc_reply, rpc_msgdenied, rpc_mismatch, rpc_vers; |
88 | u_int32_t rpc_auth_unix, rpc_msgaccepted, rpc_call, rpc_autherr; | |
89 | u_int32_t rpc_auth_kerb; | |
e07fef60 | 90 | u_int32_t nfs_prog, nfs_true, nfs_false; |
984263bc MD |
91 | |
92 | /* And other global data */ | |
984263bc MD |
93 | static enum vtype nv2tov_type[8]= { |
94 | VNON, VREG, VDIR, VBLK, VCHR, VLNK, VNON, VNON | |
95 | }; | |
96 | enum vtype nv3tov_type[8]= { | |
97 | VNON, VREG, VDIR, VBLK, VCHR, VLNK, VSOCK, VFIFO | |
98 | }; | |
99 | ||
100 | int nfs_ticks; | |
e97453f3 MD |
101 | |
102 | static int nfs_pbuf_freecnt = -1; /* start out unlimited */ | |
984263bc | 103 | |
49433307 | 104 | struct nfsmount_head nfs_mountq = TAILQ_HEAD_INITIALIZER(nfs_mountq); |
984263bc MD |
105 | struct nfssvc_sockhead nfssvc_sockhead; |
106 | int nfssvc_sockhead_flag; | |
107 | struct nfsd_head nfsd_head; | |
108 | int nfsd_head_flag; | |
109 | struct nfs_bufq nfs_bufq; | |
984263bc MD |
110 | struct nqfhhashhead *nqfhhashtbl; |
111 | u_long nqfhhash; | |
112 | ||
984263bc MD |
113 | static int nfs_prev_nfssvc_sy_narg; |
114 | static sy_call_t *nfs_prev_nfssvc_sy_call; | |
115 | ||
116 | #ifndef NFS_NOSERVER | |
117 | ||
984263bc MD |
118 | /* |
119 | * Mapping of old NFS Version 2 RPC numbers to generic numbers. | |
120 | */ | |
121 | int nfsv3_procid[NFS_NPROCS] = { | |
122 | NFSPROC_NULL, | |
123 | NFSPROC_GETATTR, | |
124 | NFSPROC_SETATTR, | |
125 | NFSPROC_NOOP, | |
126 | NFSPROC_LOOKUP, | |
127 | NFSPROC_READLINK, | |
128 | NFSPROC_READ, | |
129 | NFSPROC_NOOP, | |
130 | NFSPROC_WRITE, | |
131 | NFSPROC_CREATE, | |
132 | NFSPROC_REMOVE, | |
133 | NFSPROC_RENAME, | |
134 | NFSPROC_LINK, | |
135 | NFSPROC_SYMLINK, | |
136 | NFSPROC_MKDIR, | |
137 | NFSPROC_RMDIR, | |
138 | NFSPROC_READDIR, | |
139 | NFSPROC_FSSTAT, | |
140 | NFSPROC_NOOP, | |
141 | NFSPROC_NOOP, | |
142 | NFSPROC_NOOP, | |
143 | NFSPROC_NOOP, | |
144 | NFSPROC_NOOP, | |
145 | NFSPROC_NOOP, | |
146 | NFSPROC_NOOP, | |
147 | NFSPROC_NOOP | |
148 | }; | |
149 | ||
150 | #endif /* NFS_NOSERVER */ | |
151 | /* | |
152 | * and the reverse mapping from generic to Version 2 procedure numbers | |
153 | */ | |
154 | int nfsv2_procid[NFS_NPROCS] = { | |
155 | NFSV2PROC_NULL, | |
156 | NFSV2PROC_GETATTR, | |
157 | NFSV2PROC_SETATTR, | |
158 | NFSV2PROC_LOOKUP, | |
159 | NFSV2PROC_NOOP, | |
160 | NFSV2PROC_READLINK, | |
161 | NFSV2PROC_READ, | |
162 | NFSV2PROC_WRITE, | |
163 | NFSV2PROC_CREATE, | |
164 | NFSV2PROC_MKDIR, | |
165 | NFSV2PROC_SYMLINK, | |
166 | NFSV2PROC_CREATE, | |
167 | NFSV2PROC_REMOVE, | |
168 | NFSV2PROC_RMDIR, | |
169 | NFSV2PROC_RENAME, | |
170 | NFSV2PROC_LINK, | |
171 | NFSV2PROC_READDIR, | |
172 | NFSV2PROC_NOOP, | |
173 | NFSV2PROC_STATFS, | |
174 | NFSV2PROC_NOOP, | |
175 | NFSV2PROC_NOOP, | |
176 | NFSV2PROC_NOOP, | |
177 | NFSV2PROC_NOOP, | |
178 | NFSV2PROC_NOOP, | |
179 | NFSV2PROC_NOOP, | |
180 | NFSV2PROC_NOOP, | |
181 | }; | |
182 | ||
183 | #ifndef NFS_NOSERVER | |
184 | /* | |
185 | * Maps errno values to nfs error numbers. | |
186 | * Use NFSERR_IO as the catch all for ones not specifically defined in | |
187 | * RFC 1094. | |
188 | */ | |
189 | static u_char nfsrv_v2errmap[ELAST] = { | |
190 | NFSERR_PERM, NFSERR_NOENT, NFSERR_IO, NFSERR_IO, NFSERR_IO, | |
191 | NFSERR_NXIO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, | |
192 | NFSERR_IO, NFSERR_IO, NFSERR_ACCES, NFSERR_IO, NFSERR_IO, | |
193 | NFSERR_IO, NFSERR_EXIST, NFSERR_IO, NFSERR_NODEV, NFSERR_NOTDIR, | |
194 | NFSERR_ISDIR, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, | |
195 | NFSERR_IO, NFSERR_FBIG, NFSERR_NOSPC, NFSERR_IO, NFSERR_ROFS, | |
196 | NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, | |
197 | NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, | |
198 | NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, | |
199 | NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, | |
200 | NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, | |
201 | NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, | |
202 | NFSERR_IO, NFSERR_IO, NFSERR_NAMETOL, NFSERR_IO, NFSERR_IO, | |
203 | NFSERR_NOTEMPTY, NFSERR_IO, NFSERR_IO, NFSERR_DQUOT, NFSERR_STALE, | |
204 | NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, | |
205 | NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, | |
206 | NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, NFSERR_IO, | |
207 | NFSERR_IO /* << Last is 86 */ | |
208 | }; | |
209 | ||
210 | /* | |
211 | * Maps errno values to nfs error numbers. | |
212 | * Although it is not obvious whether or not NFS clients really care if | |
213 | * a returned error value is in the specified list for the procedure, the | |
214 | * safest thing to do is filter them appropriately. For Version 2, the | |
215 | * X/Open XNFS document is the only specification that defines error values | |
216 | * for each RPC (The RFC simply lists all possible error values for all RPCs), | |
217 | * so I have decided to not do this for Version 2. | |
218 | * The first entry is the default error return and the rest are the valid | |
219 | * errors for that RPC in increasing numeric order. | |
220 | */ | |
221 | static short nfsv3err_null[] = { | |
222 | 0, | |
223 | 0, | |
224 | }; | |
225 | ||
226 | static short nfsv3err_getattr[] = { | |
227 | NFSERR_IO, | |
228 | NFSERR_IO, | |
229 | NFSERR_STALE, | |
230 | NFSERR_BADHANDLE, | |
231 | NFSERR_SERVERFAULT, | |
232 | 0, | |
233 | }; | |
234 | ||
235 | static short nfsv3err_setattr[] = { | |
236 | NFSERR_IO, | |
237 | NFSERR_PERM, | |
238 | NFSERR_IO, | |
239 | NFSERR_ACCES, | |
240 | NFSERR_INVAL, | |
241 | NFSERR_NOSPC, | |
242 | NFSERR_ROFS, | |
243 | NFSERR_DQUOT, | |
244 | NFSERR_STALE, | |
245 | NFSERR_BADHANDLE, | |
246 | NFSERR_NOT_SYNC, | |
247 | NFSERR_SERVERFAULT, | |
248 | 0, | |
249 | }; | |
250 | ||
251 | static short nfsv3err_lookup[] = { | |
252 | NFSERR_IO, | |
253 | NFSERR_NOENT, | |
254 | NFSERR_IO, | |
255 | NFSERR_ACCES, | |
256 | NFSERR_NOTDIR, | |
257 | NFSERR_NAMETOL, | |
258 | NFSERR_STALE, | |
259 | NFSERR_BADHANDLE, | |
260 | NFSERR_SERVERFAULT, | |
261 | 0, | |
262 | }; | |
263 | ||
264 | static short nfsv3err_access[] = { | |
265 | NFSERR_IO, | |
266 | NFSERR_IO, | |
267 | NFSERR_STALE, | |
268 | NFSERR_BADHANDLE, | |
269 | NFSERR_SERVERFAULT, | |
270 | 0, | |
271 | }; | |
272 | ||
273 | static short nfsv3err_readlink[] = { | |
274 | NFSERR_IO, | |
275 | NFSERR_IO, | |
276 | NFSERR_ACCES, | |
277 | NFSERR_INVAL, | |
278 | NFSERR_STALE, | |
279 | NFSERR_BADHANDLE, | |
280 | NFSERR_NOTSUPP, | |
281 | NFSERR_SERVERFAULT, | |
282 | 0, | |
283 | }; | |
284 | ||
285 | static short nfsv3err_read[] = { | |
286 | NFSERR_IO, | |
287 | NFSERR_IO, | |
288 | NFSERR_NXIO, | |
289 | NFSERR_ACCES, | |
290 | NFSERR_INVAL, | |
291 | NFSERR_STALE, | |
292 | NFSERR_BADHANDLE, | |
293 | NFSERR_SERVERFAULT, | |
294 | 0, | |
295 | }; | |
296 | ||
297 | static short nfsv3err_write[] = { | |
298 | NFSERR_IO, | |
299 | NFSERR_IO, | |
300 | NFSERR_ACCES, | |
301 | NFSERR_INVAL, | |
302 | NFSERR_FBIG, | |
303 | NFSERR_NOSPC, | |
304 | NFSERR_ROFS, | |
305 | NFSERR_DQUOT, | |
306 | NFSERR_STALE, | |
307 | NFSERR_BADHANDLE, | |
308 | NFSERR_SERVERFAULT, | |
309 | 0, | |
310 | }; | |
311 | ||
312 | static short nfsv3err_create[] = { | |
313 | NFSERR_IO, | |
314 | NFSERR_IO, | |
315 | NFSERR_ACCES, | |
316 | NFSERR_EXIST, | |
317 | NFSERR_NOTDIR, | |
318 | NFSERR_NOSPC, | |
319 | NFSERR_ROFS, | |
320 | NFSERR_NAMETOL, | |
321 | NFSERR_DQUOT, | |
322 | NFSERR_STALE, | |
323 | NFSERR_BADHANDLE, | |
324 | NFSERR_NOTSUPP, | |
325 | NFSERR_SERVERFAULT, | |
326 | 0, | |
327 | }; | |
328 | ||
329 | static short nfsv3err_mkdir[] = { | |
330 | NFSERR_IO, | |
331 | NFSERR_IO, | |
332 | NFSERR_ACCES, | |
333 | NFSERR_EXIST, | |
334 | NFSERR_NOTDIR, | |
335 | NFSERR_NOSPC, | |
336 | NFSERR_ROFS, | |
337 | NFSERR_NAMETOL, | |
338 | NFSERR_DQUOT, | |
339 | NFSERR_STALE, | |
340 | NFSERR_BADHANDLE, | |
341 | NFSERR_NOTSUPP, | |
342 | NFSERR_SERVERFAULT, | |
343 | 0, | |
344 | }; | |
345 | ||
346 | static short nfsv3err_symlink[] = { | |
347 | NFSERR_IO, | |
348 | NFSERR_IO, | |
349 | NFSERR_ACCES, | |
350 | NFSERR_EXIST, | |
351 | NFSERR_NOTDIR, | |
352 | NFSERR_NOSPC, | |
353 | NFSERR_ROFS, | |
354 | NFSERR_NAMETOL, | |
355 | NFSERR_DQUOT, | |
356 | NFSERR_STALE, | |
357 | NFSERR_BADHANDLE, | |
358 | NFSERR_NOTSUPP, | |
359 | NFSERR_SERVERFAULT, | |
360 | 0, | |
361 | }; | |
362 | ||
363 | static short nfsv3err_mknod[] = { | |
364 | NFSERR_IO, | |
365 | NFSERR_IO, | |
366 | NFSERR_ACCES, | |
367 | NFSERR_EXIST, | |
368 | NFSERR_NOTDIR, | |
369 | NFSERR_NOSPC, | |
370 | NFSERR_ROFS, | |
371 | NFSERR_NAMETOL, | |
372 | NFSERR_DQUOT, | |
373 | NFSERR_STALE, | |
374 | NFSERR_BADHANDLE, | |
375 | NFSERR_NOTSUPP, | |
376 | NFSERR_SERVERFAULT, | |
377 | NFSERR_BADTYPE, | |
378 | 0, | |
379 | }; | |
380 | ||
381 | static short nfsv3err_remove[] = { | |
382 | NFSERR_IO, | |
383 | NFSERR_NOENT, | |
384 | NFSERR_IO, | |
385 | NFSERR_ACCES, | |
386 | NFSERR_NOTDIR, | |
387 | NFSERR_ROFS, | |
388 | NFSERR_NAMETOL, | |
389 | NFSERR_STALE, | |
390 | NFSERR_BADHANDLE, | |
391 | NFSERR_SERVERFAULT, | |
392 | 0, | |
393 | }; | |
394 | ||
395 | static short nfsv3err_rmdir[] = { | |
396 | NFSERR_IO, | |
397 | NFSERR_NOENT, | |
398 | NFSERR_IO, | |
399 | NFSERR_ACCES, | |
400 | NFSERR_EXIST, | |
401 | NFSERR_NOTDIR, | |
402 | NFSERR_INVAL, | |
403 | NFSERR_ROFS, | |
404 | NFSERR_NAMETOL, | |
405 | NFSERR_NOTEMPTY, | |
406 | NFSERR_STALE, | |
407 | NFSERR_BADHANDLE, | |
408 | NFSERR_NOTSUPP, | |
409 | NFSERR_SERVERFAULT, | |
410 | 0, | |
411 | }; | |
412 | ||
413 | static short nfsv3err_rename[] = { | |
414 | NFSERR_IO, | |
415 | NFSERR_NOENT, | |
416 | NFSERR_IO, | |
417 | NFSERR_ACCES, | |
418 | NFSERR_EXIST, | |
419 | NFSERR_XDEV, | |
420 | NFSERR_NOTDIR, | |
421 | NFSERR_ISDIR, | |
422 | NFSERR_INVAL, | |
423 | NFSERR_NOSPC, | |
424 | NFSERR_ROFS, | |
425 | NFSERR_MLINK, | |
426 | NFSERR_NAMETOL, | |
427 | NFSERR_NOTEMPTY, | |
428 | NFSERR_DQUOT, | |
429 | NFSERR_STALE, | |
430 | NFSERR_BADHANDLE, | |
431 | NFSERR_NOTSUPP, | |
432 | NFSERR_SERVERFAULT, | |
433 | 0, | |
434 | }; | |
435 | ||
436 | static short nfsv3err_link[] = { | |
437 | NFSERR_IO, | |
438 | NFSERR_IO, | |
439 | NFSERR_ACCES, | |
440 | NFSERR_EXIST, | |
441 | NFSERR_XDEV, | |
442 | NFSERR_NOTDIR, | |
443 | NFSERR_INVAL, | |
444 | NFSERR_NOSPC, | |
445 | NFSERR_ROFS, | |
446 | NFSERR_MLINK, | |
447 | NFSERR_NAMETOL, | |
448 | NFSERR_DQUOT, | |
449 | NFSERR_STALE, | |
450 | NFSERR_BADHANDLE, | |
451 | NFSERR_NOTSUPP, | |
452 | NFSERR_SERVERFAULT, | |
453 | 0, | |
454 | }; | |
455 | ||
456 | static short nfsv3err_readdir[] = { | |
457 | NFSERR_IO, | |
458 | NFSERR_IO, | |
459 | NFSERR_ACCES, | |
460 | NFSERR_NOTDIR, | |
461 | NFSERR_STALE, | |
462 | NFSERR_BADHANDLE, | |
463 | NFSERR_BAD_COOKIE, | |
464 | NFSERR_TOOSMALL, | |
465 | NFSERR_SERVERFAULT, | |
466 | 0, | |
467 | }; | |
468 | ||
469 | static short nfsv3err_readdirplus[] = { | |
470 | NFSERR_IO, | |
471 | NFSERR_IO, | |
472 | NFSERR_ACCES, | |
473 | NFSERR_NOTDIR, | |
474 | NFSERR_STALE, | |
475 | NFSERR_BADHANDLE, | |
476 | NFSERR_BAD_COOKIE, | |
477 | NFSERR_NOTSUPP, | |
478 | NFSERR_TOOSMALL, | |
479 | NFSERR_SERVERFAULT, | |
480 | 0, | |
481 | }; | |
482 | ||
483 | static short nfsv3err_fsstat[] = { | |
484 | NFSERR_IO, | |
485 | NFSERR_IO, | |
486 | NFSERR_STALE, | |
487 | NFSERR_BADHANDLE, | |
488 | NFSERR_SERVERFAULT, | |
489 | 0, | |
490 | }; | |
491 | ||
492 | static short nfsv3err_fsinfo[] = { | |
493 | NFSERR_STALE, | |
494 | NFSERR_STALE, | |
495 | NFSERR_BADHANDLE, | |
496 | NFSERR_SERVERFAULT, | |
497 | 0, | |
498 | }; | |
499 | ||
500 | static short nfsv3err_pathconf[] = { | |
501 | NFSERR_STALE, | |
502 | NFSERR_STALE, | |
503 | NFSERR_BADHANDLE, | |
504 | NFSERR_SERVERFAULT, | |
505 | 0, | |
506 | }; | |
507 | ||
508 | static short nfsv3err_commit[] = { | |
509 | NFSERR_IO, | |
510 | NFSERR_IO, | |
511 | NFSERR_STALE, | |
512 | NFSERR_BADHANDLE, | |
513 | NFSERR_SERVERFAULT, | |
514 | 0, | |
515 | }; | |
516 | ||
517 | static short *nfsrv_v3errmap[] = { | |
518 | nfsv3err_null, | |
519 | nfsv3err_getattr, | |
520 | nfsv3err_setattr, | |
521 | nfsv3err_lookup, | |
522 | nfsv3err_access, | |
523 | nfsv3err_readlink, | |
524 | nfsv3err_read, | |
525 | nfsv3err_write, | |
526 | nfsv3err_create, | |
527 | nfsv3err_mkdir, | |
528 | nfsv3err_symlink, | |
529 | nfsv3err_mknod, | |
530 | nfsv3err_remove, | |
531 | nfsv3err_rmdir, | |
532 | nfsv3err_rename, | |
533 | nfsv3err_link, | |
534 | nfsv3err_readdir, | |
535 | nfsv3err_readdirplus, | |
536 | nfsv3err_fsstat, | |
537 | nfsv3err_fsinfo, | |
538 | nfsv3err_pathconf, | |
539 | nfsv3err_commit, | |
540 | }; | |
541 | ||
542 | #endif /* NFS_NOSERVER */ | |
543 | ||
984263bc | 544 | struct nfssvc_args; |
753fd850 | 545 | extern int sys_nfssvc(struct proc *, struct nfssvc_args *, int *); |
984263bc | 546 | |
2cb16efc MD |
547 | /* |
548 | * This needs to return a monotonically increasing or close to monotonically | |
549 | * increasing result, otherwise the write gathering queues won't work | |
550 | * properly. | |
551 | */ | |
984263bc | 552 | u_quad_t |
e851b29e | 553 | nfs_curusec(void) |
984263bc MD |
554 | { |
555 | struct timeval tv; | |
556 | ||
2cb16efc | 557 | getmicrouptime(&tv); |
984263bc MD |
558 | return ((u_quad_t)tv.tv_sec * 1000000 + (u_quad_t)tv.tv_usec); |
559 | } | |
560 | ||
984263bc MD |
561 | /* |
562 | * Called once to initialize data structures... | |
563 | */ | |
564 | int | |
e851b29e | 565 | nfs_init(struct vfsconf *vfsp) |
984263bc | 566 | { |
f786cc86 | 567 | callout_init(&nfs_timer_handle); |
984263bc MD |
568 | nfsmount_zone = zinit("NFSMOUNT", sizeof(struct nfsmount), 0, 0, 1); |
569 | ||
570 | nfs_mount_type = vfsp->vfc_typenum; | |
571 | nfsrtt.pos = 0; | |
572 | rpc_vers = txdr_unsigned(RPC_VER2); | |
573 | rpc_call = txdr_unsigned(RPC_CALL); | |
574 | rpc_reply = txdr_unsigned(RPC_REPLY); | |
575 | rpc_msgdenied = txdr_unsigned(RPC_MSGDENIED); | |
576 | rpc_msgaccepted = txdr_unsigned(RPC_MSGACCEPTED); | |
577 | rpc_mismatch = txdr_unsigned(RPC_MISMATCH); | |
578 | rpc_autherr = txdr_unsigned(RPC_AUTHERR); | |
579 | rpc_auth_unix = txdr_unsigned(RPCAUTH_UNIX); | |
580 | rpc_auth_kerb = txdr_unsigned(RPCAUTH_KERB4); | |
581 | nfs_prog = txdr_unsigned(NFS_PROG); | |
984263bc MD |
582 | nfs_true = txdr_unsigned(TRUE); |
583 | nfs_false = txdr_unsigned(FALSE); | |
584 | nfs_xdrneg1 = txdr_unsigned(-1); | |
585 | nfs_ticks = (hz * NFS_TICKINTVL + 500) / 1000; | |
586 | if (nfs_ticks < 1) | |
587 | nfs_ticks = 1; | |
984263bc MD |
588 | nfs_nhinit(); /* Init the nfsnode table */ |
589 | #ifndef NFS_NOSERVER | |
590 | nfsrv_init(0); /* Init server data structures */ | |
591 | nfsrv_initcache(); /* Init the server request cache */ | |
592 | #endif | |
593 | ||
b9a7a2bd MD |
594 | /* |
595 | * Mainly for vkernel operation. If memory is severely limited | |
596 | */ | |
597 | if (nfs_maxasyncbio > nmbclusters * MCLBYTES / NFS_MAXDATA / 3) | |
598 | nfs_maxasyncbio = nmbclusters * MCLBYTES / NFS_MAXDATA / 3; | |
599 | if (nfs_maxasyncbio < 4) | |
600 | nfs_maxasyncbio = 4; | |
601 | ||
984263bc MD |
602 | /* |
603 | * Initialize reply list and start timer | |
604 | */ | |
984263bc MD |
605 | nfs_timer(0); |
606 | ||
984263bc MD |
607 | nfs_prev_nfssvc_sy_narg = sysent[SYS_nfssvc].sy_narg; |
608 | sysent[SYS_nfssvc].sy_narg = 2; | |
609 | nfs_prev_nfssvc_sy_call = sysent[SYS_nfssvc].sy_call; | |
753fd850 | 610 | sysent[SYS_nfssvc].sy_call = (sy_call_t *)sys_nfssvc; |
984263bc MD |
611 | |
612 | nfs_pbuf_freecnt = nswbuf / 2 + 1; | |
613 | ||
614 | return (0); | |
615 | } | |
616 | ||
617 | int | |
e851b29e | 618 | nfs_uninit(struct vfsconf *vfsp) |
984263bc | 619 | { |
f786cc86 | 620 | callout_stop(&nfs_timer_handle); |
984263bc | 621 | nfs_mount_type = -1; |
984263bc MD |
622 | sysent[SYS_nfssvc].sy_narg = nfs_prev_nfssvc_sy_narg; |
623 | sysent[SYS_nfssvc].sy_call = nfs_prev_nfssvc_sy_call; | |
624 | return (0); | |
625 | } | |
626 | ||
627 | /* | |
628 | * Attribute cache routines. | |
629 | * nfs_loadattrcache() - loads or updates the cache contents from attributes | |
630 | * that are on the mbuf list | |
631 | * nfs_getattrcache() - returns valid attributes if found in cache, returns | |
632 | * error otherwise | |
633 | */ | |
634 | ||
635 | /* | |
636 | * Load the attribute cache (that lives in the nfsnode entry) with | |
5a9187cb MD |
637 | * the values on the mbuf list. Load *vaper with the attributes. vaper |
638 | * may be NULL. | |
639 | * | |
640 | * As a side effect n_mtime, which we use to determine if the file was | |
641 | * modified by some other host, is set to the attribute timestamp and | |
642 | * NRMODIFIED is set if the two values differ. | |
643 | * | |
644 | * WARNING: the mtime loaded into vaper does not necessarily represent | |
645 | * n_mtime or n_attr.mtime due to NACC and NUPD. | |
984263bc MD |
646 | */ |
647 | int | |
42edf14f | 648 | nfs_loadattrcache(struct vnode *vp, struct mbuf **mdp, caddr_t *dposp, |
5a9187cb | 649 | struct vattr *vaper, int lattr_flags) |
984263bc | 650 | { |
40393ded RG |
651 | struct vattr *vap; |
652 | struct nfs_fattr *fp; | |
653 | struct nfsnode *np; | |
654 | int32_t t1; | |
984263bc | 655 | caddr_t cp2; |
e4c9c0c8 | 656 | int error = 0; |
0e9b9130 | 657 | int rmajor, rminor; |
e4c9c0c8 | 658 | udev_t rdev; |
984263bc MD |
659 | struct mbuf *md; |
660 | enum vtype vtyp; | |
661 | u_short vmode; | |
662 | struct timespec mtime; | |
663 | int v3 = NFS_ISV3(vp); | |
664 | ||
665 | md = *mdp; | |
666 | t1 = (mtod(md, caddr_t) + md->m_len) - *dposp; | |
667 | if ((error = nfsm_disct(mdp, dposp, NFSX_FATTR(v3), t1, &cp2)) != 0) | |
668 | return (error); | |
669 | fp = (struct nfs_fattr *)cp2; | |
670 | if (v3) { | |
671 | vtyp = nfsv3tov_type(fp->fa_type); | |
672 | vmode = fxdr_unsigned(u_short, fp->fa_mode); | |
0e9b9130 MD |
673 | rmajor = (int)fxdr_unsigned(int, fp->fa3_rdev.specdata1); |
674 | rminor = (int)fxdr_unsigned(int, fp->fa3_rdev.specdata2); | |
984263bc MD |
675 | fxdr_nfsv3time(&fp->fa3_mtime, &mtime); |
676 | } else { | |
677 | vtyp = nfsv2tov_type(fp->fa_type); | |
678 | vmode = fxdr_unsigned(u_short, fp->fa_mode); | |
679 | /* | |
680 | * XXX | |
681 | * | |
682 | * The duplicate information returned in fa_type and fa_mode | |
683 | * is an ambiguity in the NFS version 2 protocol. | |
684 | * | |
685 | * VREG should be taken literally as a regular file. If a | |
686 | * server intents to return some type information differently | |
687 | * in the upper bits of the mode field (e.g. for sockets, or | |
688 | * FIFOs), NFSv2 mandates fa_type to be VNON. Anyway, we | |
689 | * leave the examination of the mode bits even in the VREG | |
690 | * case to avoid breakage for bogus servers, but we make sure | |
691 | * that there are actually type bits set in the upper part of | |
692 | * fa_mode (and failing that, trust the va_type field). | |
693 | * | |
694 | * NFSv3 cleared the issue, and requires fa_mode to not | |
695 | * contain any type information (while also introduing sockets | |
696 | * and FIFOs for fa_type). | |
697 | */ | |
698 | if (vtyp == VNON || (vtyp == VREG && (vmode & S_IFMT) != 0)) | |
699 | vtyp = IFTOVT(vmode); | |
700 | rdev = fxdr_unsigned(int32_t, fp->fa2_rdev); | |
0e9b9130 MD |
701 | rmajor = umajor(rdev); |
702 | rminor = uminor(rdev); | |
984263bc MD |
703 | fxdr_nfsv2time(&fp->fa2_mtime, &mtime); |
704 | ||
705 | /* | |
706 | * Really ugly NFSv2 kludge. | |
707 | */ | |
e4c9c0c8 | 708 | if (vtyp == VCHR && rdev == (udev_t)0xffffffff) |
984263bc MD |
709 | vtyp = VFIFO; |
710 | } | |
711 | ||
712 | /* | |
713 | * If v_type == VNON it is a new node, so fill in the v_type, | |
714 | * n_mtime fields. Check to see if it represents a special | |
715 | * device, and if so, check for a possible alias. Once the | |
716 | * correct vnode has been obtained, fill in the rest of the | |
717 | * information. | |
718 | */ | |
719 | np = VTONFS(vp); | |
720 | if (vp->v_type != vtyp) { | |
1c843a13 | 721 | nfs_setvtype(vp, vtyp); |
984263bc | 722 | if (vp->v_type == VFIFO) { |
6ddb7618 | 723 | vp->v_ops = &vp->v_mount->mnt_vn_fifo_ops; |
0961aa92 | 724 | } else if (vp->v_type == VCHR || vp->v_type == VBLK) { |
6ddb7618 | 725 | vp->v_ops = &vp->v_mount->mnt_vn_spec_ops; |
0e9b9130 | 726 | addaliasu(vp, rmajor, rminor); |
0961aa92 | 727 | } else { |
6ddb7618 | 728 | vp->v_ops = &vp->v_mount->mnt_vn_use_ops; |
984263bc MD |
729 | } |
730 | np->n_mtime = mtime.tv_sec; | |
5a9187cb | 731 | } else if (np->n_mtime != mtime.tv_sec) { |
9793c819 | 732 | /* |
5a9187cb MD |
733 | * If we haven't modified the file locally and the server |
734 | * timestamp does not match, then the server probably | |
735 | * modified the file. We must flag this condition so | |
736 | * the proper syncnronization can be done. We do not | |
737 | * try to synchronize the state here because that | |
738 | * could lead to an endless recursion. | |
739 | * | |
740 | * XXX loadattrcache can be set during the reply to a write, | |
741 | * before the write timestamp is properly processed. To | |
742 | * avoid unconditionally setting the rmodified bit (which | |
743 | * has the effect of flushing the cache), we only do this | |
744 | * check if the lmodified bit is not set. | |
9793c819 MD |
745 | */ |
746 | np->n_mtime = mtime.tv_sec; | |
5a9187cb MD |
747 | if ((lattr_flags & NFS_LATTR_NOMTIMECHECK) == 0) |
748 | np->n_flag |= NRMODIFIED; | |
984263bc MD |
749 | } |
750 | vap = &np->n_vattr; | |
751 | vap->va_type = vtyp; | |
752 | vap->va_mode = (vmode & 07777); | |
0e9b9130 MD |
753 | vap->va_rmajor = rmajor; |
754 | vap->va_rminor = rminor; | |
984263bc MD |
755 | vap->va_mtime = mtime; |
756 | vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0]; | |
757 | if (v3) { | |
758 | vap->va_nlink = fxdr_unsigned(u_short, fp->fa_nlink); | |
759 | vap->va_uid = fxdr_unsigned(uid_t, fp->fa_uid); | |
760 | vap->va_gid = fxdr_unsigned(gid_t, fp->fa_gid); | |
761 | vap->va_size = fxdr_hyper(&fp->fa3_size); | |
762 | vap->va_blocksize = NFS_FABLKSIZE; | |
763 | vap->va_bytes = fxdr_hyper(&fp->fa3_used); | |
50626622 | 764 | vap->va_fileid = fxdr_hyper(&fp->fa3_fileid); |
984263bc MD |
765 | fxdr_nfsv3time(&fp->fa3_atime, &vap->va_atime); |
766 | fxdr_nfsv3time(&fp->fa3_ctime, &vap->va_ctime); | |
767 | vap->va_flags = 0; | |
768 | vap->va_filerev = 0; | |
769 | } else { | |
770 | vap->va_nlink = fxdr_unsigned(u_short, fp->fa_nlink); | |
771 | vap->va_uid = fxdr_unsigned(uid_t, fp->fa_uid); | |
772 | vap->va_gid = fxdr_unsigned(gid_t, fp->fa_gid); | |
773 | vap->va_size = fxdr_unsigned(u_int32_t, fp->fa2_size); | |
774 | vap->va_blocksize = fxdr_unsigned(int32_t, fp->fa2_blocksize); | |
775 | vap->va_bytes = (u_quad_t)fxdr_unsigned(int32_t, fp->fa2_blocks) | |
776 | * NFS_FABLKSIZE; | |
777 | vap->va_fileid = fxdr_unsigned(int32_t, fp->fa2_fileid); | |
778 | fxdr_nfsv2time(&fp->fa2_atime, &vap->va_atime); | |
779 | vap->va_flags = 0; | |
780 | vap->va_ctime.tv_sec = fxdr_unsigned(u_int32_t, | |
781 | fp->fa2_ctime.nfsv2_sec); | |
782 | vap->va_ctime.tv_nsec = 0; | |
783 | vap->va_gen = fxdr_unsigned(u_int32_t,fp->fa2_ctime.nfsv2_usec); | |
784 | vap->va_filerev = 0; | |
785 | } | |
786 | np->n_attrstamp = time_second; | |
787 | if (vap->va_size != np->n_size) { | |
788 | if (vap->va_type == VREG) { | |
5a9187cb MD |
789 | if ((lattr_flags & NFS_LATTR_NOSHRINK) && |
790 | vap->va_size < np->n_size) { | |
984263bc MD |
791 | /* |
792 | * We've been told not to shrink the file; | |
793 | * zero np->n_attrstamp to indicate that | |
794 | * the attributes are stale. | |
5a9187cb MD |
795 | * |
796 | * This occurs primarily due to recursive | |
797 | * NFS ops that are executed during periods | |
798 | * where we cannot safely reduce the size of | |
799 | * the file. | |
800 | * | |
801 | * Additionally, write rpcs are broken down | |
802 | * into buffers and np->n_size is | |
803 | * pre-extended. Setting NRMODIFIED here | |
804 | * can result in n_size getting reset to a | |
805 | * lower value, which is NOT what we want. | |
806 | * XXX this needs to be cleaned up a lot | |
807 | * more. | |
984263bc MD |
808 | */ |
809 | vap->va_size = np->n_size; | |
810 | np->n_attrstamp = 0; | |
5a9187cb MD |
811 | if ((np->n_flag & NLMODIFIED) == 0) |
812 | np->n_flag |= NRMODIFIED; | |
813 | } else if (np->n_flag & NLMODIFIED) { | |
79e5012e MD |
814 | /* |
815 | * We've modified the file: Use the larger | |
5a9187cb MD |
816 | * of our size, and the server's size. At |
817 | * this point the cache coherency is all | |
818 | * shot to hell. To try to handle multiple | |
819 | * clients appending to the file at the same | |
820 | * time mark that the server has changed | |
821 | * the file if the server's notion of the | |
822 | * file size is larger then our notion. | |
823 | * | |
824 | * XXX this needs work. | |
79e5012e MD |
825 | */ |
826 | if (vap->va_size < np->n_size) { | |
984263bc | 827 | vap->va_size = np->n_size; |
79e5012e | 828 | } else { |
984263bc | 829 | np->n_size = vap->va_size; |
5a9187cb | 830 | np->n_flag |= NRMODIFIED; |
79e5012e | 831 | } |
984263bc | 832 | } else { |
5a9187cb MD |
833 | /* |
834 | * Someone changed the file's size on the | |
835 | * server and there are no local changes | |
836 | * to get in the way, set the size and mark | |
837 | * it. | |
838 | */ | |
984263bc | 839 | np->n_size = vap->va_size; |
5a9187cb | 840 | np->n_flag |= NRMODIFIED; |
984263bc MD |
841 | } |
842 | vnode_pager_setsize(vp, np->n_size); | |
843 | } else { | |
844 | np->n_size = vap->va_size; | |
845 | } | |
846 | } | |
847 | if (vaper != NULL) { | |
848 | bcopy((caddr_t)vap, (caddr_t)vaper, sizeof(*vap)); | |
849 | if (np->n_flag & NCHG) { | |
850 | if (np->n_flag & NACC) | |
851 | vaper->va_atime = np->n_atim; | |
852 | if (np->n_flag & NUPD) | |
853 | vaper->va_mtime = np->n_mtim; | |
854 | } | |
855 | } | |
856 | return (0); | |
857 | } | |
858 | ||
859 | #ifdef NFS_ACDEBUG | |
860 | #include <sys/sysctl.h> | |
861 | SYSCTL_DECL(_vfs_nfs); | |
862 | static int nfs_acdebug; | |
863 | SYSCTL_INT(_vfs_nfs, OID_AUTO, acdebug, CTLFLAG_RW, &nfs_acdebug, 0, ""); | |
864 | #endif | |
865 | ||
866 | /* | |
867 | * Check the time stamp | |
868 | * If the cache is valid, copy contents to *vap and return 0 | |
869 | * otherwise return an error | |
870 | */ | |
871 | int | |
e851b29e | 872 | nfs_getattrcache(struct vnode *vp, struct vattr *vaper) |
984263bc | 873 | { |
40393ded RG |
874 | struct nfsnode *np; |
875 | struct vattr *vap; | |
984263bc MD |
876 | struct nfsmount *nmp; |
877 | int timeo; | |
878 | ||
879 | np = VTONFS(vp); | |
880 | vap = &np->n_vattr; | |
881 | nmp = VFSTONFS(vp->v_mount); | |
fad57d0e MD |
882 | |
883 | /* | |
884 | * Dynamic timeout based on how recently the file was modified. | |
5a9187cb | 885 | * n_mtime is always valid. |
fad57d0e | 886 | */ |
97100839 | 887 | timeo = (get_approximate_time_t() - np->n_mtime) / 60; |
984263bc MD |
888 | |
889 | #ifdef NFS_ACDEBUG | |
890 | if (nfs_acdebug>1) | |
086c1d7e | 891 | kprintf("nfs_getattrcache: initial timeo = %d\n", timeo); |
984263bc MD |
892 | #endif |
893 | ||
894 | if (vap->va_type == VDIR) { | |
5a9187cb | 895 | if ((np->n_flag & NLMODIFIED) || timeo < nmp->nm_acdirmin) |
984263bc MD |
896 | timeo = nmp->nm_acdirmin; |
897 | else if (timeo > nmp->nm_acdirmax) | |
898 | timeo = nmp->nm_acdirmax; | |
899 | } else { | |
5a9187cb | 900 | if ((np->n_flag & NLMODIFIED) || timeo < nmp->nm_acregmin) |
984263bc MD |
901 | timeo = nmp->nm_acregmin; |
902 | else if (timeo > nmp->nm_acregmax) | |
903 | timeo = nmp->nm_acregmax; | |
904 | } | |
905 | ||
906 | #ifdef NFS_ACDEBUG | |
907 | if (nfs_acdebug > 2) | |
086c1d7e | 908 | kprintf("acregmin %d; acregmax %d; acdirmin %d; acdirmax %d\n", |
984263bc MD |
909 | nmp->nm_acregmin, nmp->nm_acregmax, |
910 | nmp->nm_acdirmin, nmp->nm_acdirmax); | |
911 | ||
912 | if (nfs_acdebug) | |
086c1d7e | 913 | kprintf("nfs_getattrcache: age = %d; final timeo = %d\n", |
9793c819 | 914 | (int)(time_second - np->n_attrstamp), timeo); |
984263bc MD |
915 | #endif |
916 | ||
9793c819 | 917 | if (np->n_attrstamp == 0 || (time_second - np->n_attrstamp) >= timeo) { |
984263bc MD |
918 | nfsstats.attrcache_misses++; |
919 | return (ENOENT); | |
920 | } | |
921 | nfsstats.attrcache_hits++; | |
5a9187cb MD |
922 | |
923 | /* | |
924 | * Our attribute cache can be stale due to modifications made on | |
925 | * this host. XXX this is a bad hack. We need a more deterministic | |
926 | * means of finding out which np fields are valid verses attr cache | |
927 | * fields. We really should update the vattr info on the fly when | |
928 | * making local changes. | |
929 | */ | |
984263bc MD |
930 | if (vap->va_size != np->n_size) { |
931 | if (vap->va_type == VREG) { | |
5a9187cb | 932 | if (np->n_flag & NLMODIFIED) { |
984263bc MD |
933 | if (vap->va_size < np->n_size) |
934 | vap->va_size = np->n_size; | |
935 | else | |
936 | np->n_size = vap->va_size; | |
937 | } else { | |
938 | np->n_size = vap->va_size; | |
939 | } | |
940 | vnode_pager_setsize(vp, np->n_size); | |
941 | } else { | |
942 | np->n_size = vap->va_size; | |
943 | } | |
944 | } | |
945 | bcopy((caddr_t)vap, (caddr_t)vaper, sizeof(struct vattr)); | |
946 | if (np->n_flag & NCHG) { | |
947 | if (np->n_flag & NACC) | |
948 | vaper->va_atime = np->n_atim; | |
949 | if (np->n_flag & NUPD) | |
950 | vaper->va_mtime = np->n_mtim; | |
951 | } | |
952 | return (0); | |
953 | } | |
954 | ||
955 | #ifndef NFS_NOSERVER | |
fad57d0e | 956 | |
984263bc MD |
957 | /* |
958 | * Set up nameidata for a lookup() call and do it. | |
959 | * | |
960 | * If pubflag is set, this call is done for a lookup operation on the | |
961 | * public filehandle. In that case we allow crossing mountpoints and | |
962 | * absolute pathnames. However, the caller is expected to check that | |
963 | * the lookup result is within the public fs, and deny access if | |
964 | * it is not. | |
965 | * | |
984263bc MD |
966 | * dirp may be set whether an error is returned or not, and must be |
967 | * released by the caller. | |
fad57d0e | 968 | * |
28623bf9 | 969 | * On return nd->nl_nch usually points to the target ncp, which may represent |
fad57d0e MD |
970 | * a negative hit. |
971 | * | |
972 | * NOTE: the caller must call nlookup_done(nd) unconditionally on return | |
973 | * to cleanup. | |
984263bc MD |
974 | */ |
975 | int | |
3a907475 | 976 | nfs_namei(struct nlookupdata *nd, struct ucred *cred, int nflags, |
fad57d0e MD |
977 | struct vnode **dvpp, struct vnode **vpp, |
978 | fhandle_t *fhp, int len, | |
979 | struct nfssvc_sock *slp, struct sockaddr *nam, struct mbuf **mdp, | |
980 | caddr_t *dposp, struct vnode **dirpp, struct thread *td, | |
981 | int kerbflag, int pubflag) | |
984263bc | 982 | { |
40393ded RG |
983 | int i, rem; |
984 | struct mbuf *md; | |
985 | char *fromcp, *tocp, *cp; | |
fad57d0e | 986 | char *namebuf; |
28623bf9 | 987 | struct nchandle nch; |
984263bc | 988 | struct vnode *dp; |
67863d04 | 989 | struct mount *mp; |
fad57d0e | 990 | int error, rdonly; |
984263bc | 991 | |
70aac194 | 992 | namebuf = objcache_get(namei_oc, M_WAITOK); |
fad57d0e | 993 | *dirpp = NULL; |
984263bc MD |
994 | |
995 | /* | |
fad57d0e | 996 | * Copy the name from the mbuf list to namebuf. |
984263bc MD |
997 | */ |
998 | fromcp = *dposp; | |
fad57d0e | 999 | tocp = namebuf; |
984263bc MD |
1000 | md = *mdp; |
1001 | rem = mtod(md, caddr_t) + md->m_len - fromcp; | |
1002 | for (i = 0; i < len; i++) { | |
1003 | while (rem == 0) { | |
1004 | md = md->m_next; | |
1005 | if (md == NULL) { | |
1006 | error = EBADRPC; | |
1007 | goto out; | |
1008 | } | |
1009 | fromcp = mtod(md, caddr_t); | |
1010 | rem = md->m_len; | |
1011 | } | |
1012 | if (*fromcp == '\0' || (!pubflag && *fromcp == '/')) { | |
1013 | error = EACCES; | |
1014 | goto out; | |
1015 | } | |
1016 | *tocp++ = *fromcp++; | |
1017 | rem--; | |
1018 | } | |
1019 | *tocp = '\0'; | |
1020 | *mdp = md; | |
1021 | *dposp = fromcp; | |
1022 | len = nfsm_rndup(len)-len; | |
1023 | if (len > 0) { | |
1024 | if (rem >= len) | |
1025 | *dposp += len; | |
1026 | else if ((error = nfs_adv(mdp, dposp, len, rem)) != 0) | |
1027 | goto out; | |
1028 | } | |
1029 | ||
1030 | /* | |
fad57d0e MD |
1031 | * Extract and set starting directory. The returned dp is refd |
1032 | * but not locked. | |
984263bc | 1033 | */ |
67863d04 | 1034 | error = nfsrv_fhtovp(fhp, FALSE, &mp, &dp, cred, slp, |
fad57d0e | 1035 | nam, &rdonly, kerbflag, pubflag); |
984263bc MD |
1036 | if (error) |
1037 | goto out; | |
1038 | if (dp->v_type != VDIR) { | |
1039 | vrele(dp); | |
1040 | error = ENOTDIR; | |
1041 | goto out; | |
1042 | } | |
1043 | ||
984263bc MD |
1044 | /* |
1045 | * Set return directory. Reference to dp is implicitly transfered | |
fad57d0e MD |
1046 | * to the returned pointer. This must be set before we potentially |
1047 | * goto out below. | |
984263bc | 1048 | */ |
fad57d0e | 1049 | *dirpp = dp; |
984263bc | 1050 | |
d64fd6d3 MD |
1051 | /* |
1052 | * read-only - NLC_DELETE, NLC_RENAME_DST are disallowed. NLC_CREATE | |
1053 | * is passed through to nlookup() and will be disallowed | |
1054 | * if the file does not already exist. | |
1055 | */ | |
1056 | if (rdonly) { | |
1057 | nflags |= NLC_NFS_RDONLY; | |
1058 | if (nflags & (NLC_DELETE | NLC_RENAME_DST)) { | |
1059 | error = EROFS; | |
1060 | goto out; | |
1061 | } | |
1062 | } | |
1063 | ||
1064 | /* | |
1065 | * Oh joy. For WebNFS, handle those pesky '%' escapes, | |
1066 | * and the 'native path' indicator. | |
1067 | */ | |
984263bc | 1068 | if (pubflag) { |
70aac194 | 1069 | cp = objcache_get(namei_oc, M_WAITOK); |
fad57d0e | 1070 | fromcp = namebuf; |
984263bc MD |
1071 | tocp = cp; |
1072 | if ((unsigned char)*fromcp >= WEBNFS_SPECCHAR_START) { | |
1073 | switch ((unsigned char)*fromcp) { | |
1074 | case WEBNFS_NATIVE_CHAR: | |
1075 | /* | |
1076 | * 'Native' path for us is the same | |
1077 | * as a path according to the NFS spec, | |
1078 | * just skip the escape char. | |
1079 | */ | |
1080 | fromcp++; | |
1081 | break; | |
1082 | /* | |
1083 | * More may be added in the future, range 0x80-0xff | |
1084 | */ | |
1085 | default: | |
1086 | error = EIO; | |
70aac194 | 1087 | objcache_put(namei_oc, cp); |
984263bc MD |
1088 | goto out; |
1089 | } | |
1090 | } | |
1091 | /* | |
1092 | * Translate the '%' escapes, URL-style. | |
1093 | */ | |
1094 | while (*fromcp != '\0') { | |
1095 | if (*fromcp == WEBNFS_ESC_CHAR) { | |
1096 | if (fromcp[1] != '\0' && fromcp[2] != '\0') { | |
1097 | fromcp++; | |
1098 | *tocp++ = HEXSTRTOI(fromcp); | |
1099 | fromcp += 2; | |
1100 | continue; | |
1101 | } else { | |
1102 | error = ENOENT; | |
70aac194 | 1103 | objcache_put(namei_oc, cp); |
984263bc MD |
1104 | goto out; |
1105 | } | |
1106 | } else | |
1107 | *tocp++ = *fromcp++; | |
1108 | } | |
1109 | *tocp = '\0'; | |
70aac194 | 1110 | objcache_put(namei_oc, namebuf); |
fad57d0e | 1111 | namebuf = cp; |
984263bc MD |
1112 | } |
1113 | ||
fad57d0e MD |
1114 | /* |
1115 | * Setup for search. We need to get a start directory from dp. Note | |
1116 | * that dp is ref'd, but we no longer 'own' the ref (*dirpp owns it). | |
1117 | */ | |
1118 | if (pubflag == 0) { | |
3a907475 MD |
1119 | nflags |= NLC_NFS_NOSOFTLINKTRAV; |
1120 | nflags |= NLC_NOCROSSMOUNT; | |
984263bc MD |
1121 | } |
1122 | ||
1123 | /* | |
fad57d0e MD |
1124 | * We need a starting ncp from the directory vnode dp. dp must not |
1125 | * be locked. The returned ncp will be refd but not locked. | |
1126 | * | |
1127 | * If no suitable ncp is found we instruct cache_fromdvp() to create | |
1128 | * one. If this fails the directory has probably been removed while | |
1129 | * the target was chdir'd into it and any further lookup will fail. | |
984263bc | 1130 | */ |
28623bf9 | 1131 | if ((error = cache_fromdvp(dp, cred, 1, &nch)) != 0) |
fad57d0e | 1132 | goto out; |
3a907475 | 1133 | nlookup_init_raw(nd, namebuf, UIO_SYSSPACE, nflags, cred, &nch); |
28623bf9 | 1134 | cache_drop(&nch); |
984263bc | 1135 | |
fad57d0e MD |
1136 | /* |
1137 | * Ok, do the lookup. | |
1138 | */ | |
1139 | error = nlookup(nd); | |
984263bc | 1140 | |
fad57d0e MD |
1141 | /* |
1142 | * If no error occured return the requested dvpp and vpp. If | |
28623bf9 | 1143 | * NLC_CREATE was specified nd->nl_nch may represent a negative |
fad57d0e MD |
1144 | * cache hit in which case we do not attempt to obtain the vp. |
1145 | */ | |
1146 | if (error == 0) { | |
fad57d0e | 1147 | if (dvpp) { |
443472eb | 1148 | if (nd->nl_nch.ncp->nc_parent) { |
28623bf9 MD |
1149 | nch = nd->nl_nch; |
1150 | nch.ncp = nch.ncp->nc_parent; | |
1151 | error = cache_vget(&nch, nd->nl_cred, | |
1152 | LK_EXCLUSIVE, dvpp); | |
fad57d0e MD |
1153 | } else { |
1154 | error = ENXIO; | |
1155 | } | |
984263bc | 1156 | } |
28623bf9 MD |
1157 | if (vpp && nd->nl_nch.ncp->nc_vp) { |
1158 | error = cache_vget(&nd->nl_nch, nd->nl_cred, LK_EXCLUSIVE, vpp); | |
984263bc | 1159 | } |
984263bc | 1160 | if (error) { |
fad57d0e MD |
1161 | if (dvpp && *dvpp) { |
1162 | vput(*dvpp); | |
1163 | *dvpp = NULL; | |
1164 | } | |
1165 | if (vpp && *vpp) { | |
1166 | vput(*vpp); | |
1167 | *vpp = NULL; | |
1168 | } | |
984263bc | 1169 | } |
984263bc MD |
1170 | } |
1171 | ||
1172 | /* | |
fad57d0e | 1173 | * Finish up. |
984263bc MD |
1174 | */ |
1175 | out: | |
70aac194 | 1176 | objcache_put(namei_oc, namebuf); |
984263bc MD |
1177 | return (error); |
1178 | } | |
1179 | ||
984263bc MD |
1180 | /* |
1181 | * nfsrv_fhtovp() - convert a fh to a vnode ptr (optionally locked) | |
1182 | * - look up fsid in mount list (if not found ret error) | |
1183 | * - get vp and export rights by calling VFS_FHTOVP() | |
1184 | * - if cred->cr_uid == 0 or MNT_EXPORTANON set it to credanon | |
a11aaa81 | 1185 | * - if not lockflag unlock it with vn_unlock() |
984263bc MD |
1186 | */ |
1187 | int | |
67863d04 MD |
1188 | nfsrv_fhtovp(fhandle_t *fhp, int lockflag, |
1189 | struct mount **mpp, struct vnode **vpp, | |
e851b29e CP |
1190 | struct ucred *cred, struct nfssvc_sock *slp, struct sockaddr *nam, |
1191 | int *rdonlyp, int kerbflag, int pubflag) | |
984263bc | 1192 | { |
40393ded RG |
1193 | struct mount *mp; |
1194 | int i; | |
984263bc MD |
1195 | struct ucred *credanon; |
1196 | int error, exflags; | |
1197 | #ifdef MNT_EXNORESPORT /* XXX needs mountd and /etc/exports help yet */ | |
1198 | struct sockaddr_int *saddr; | |
1199 | #endif | |
1200 | ||
67863d04 MD |
1201 | *vpp = NULL; |
1202 | *mpp = NULL; | |
984263bc MD |
1203 | |
1204 | if (nfs_ispublicfh(fhp)) { | |
1205 | if (!pubflag || !nfs_pub.np_valid) | |
1206 | return (ESTALE); | |
1207 | fhp = &nfs_pub.np_handle; | |
1208 | } | |
1209 | ||
67863d04 MD |
1210 | mp = *mpp = vfs_getvfs(&fhp->fh_fsid); |
1211 | if (mp == NULL) | |
984263bc MD |
1212 | return (ESTALE); |
1213 | error = VFS_CHECKEXP(mp, nam, &exflags, &credanon); | |
1214 | if (error) | |
1215 | return (error); | |
67863d04 | 1216 | error = VFS_FHTOVP(mp, NULL, &fhp->fh_fid, vpp); |
984263bc MD |
1217 | if (error) |
1218 | return (error); | |
1219 | #ifdef MNT_EXNORESPORT | |
1220 | if (!(exflags & (MNT_EXNORESPORT|MNT_EXPUBLIC))) { | |
1221 | saddr = (struct sockaddr_in *)nam; | |
1222 | if (saddr->sin_family == AF_INET && | |
1223 | ntohs(saddr->sin_port) >= IPPORT_RESERVED) { | |
1224 | vput(*vpp); | |
1225 | *vpp = NULL; | |
1226 | return (NFSERR_AUTHERR | AUTH_TOOWEAK); | |
1227 | } | |
1228 | } | |
1229 | #endif | |
1230 | /* | |
1231 | * Check/setup credentials. | |
1232 | */ | |
1233 | if (exflags & MNT_EXKERB) { | |
1234 | if (!kerbflag) { | |
1235 | vput(*vpp); | |
1236 | *vpp = NULL; | |
1237 | return (NFSERR_AUTHERR | AUTH_TOOWEAK); | |
1238 | } | |
1239 | } else if (kerbflag) { | |
1240 | vput(*vpp); | |
1241 | *vpp = NULL; | |
1242 | return (NFSERR_AUTHERR | AUTH_TOOWEAK); | |
1243 | } else if (cred->cr_uid == 0 || (exflags & MNT_EXPORTANON)) { | |
1244 | cred->cr_uid = credanon->cr_uid; | |
1245 | for (i = 0; i < credanon->cr_ngroups && i < NGROUPS; i++) | |
1246 | cred->cr_groups[i] = credanon->cr_groups[i]; | |
1247 | cred->cr_ngroups = i; | |
1248 | } | |
1249 | if (exflags & MNT_EXRDONLY) | |
1250 | *rdonlyp = 1; | |
1251 | else | |
1252 | *rdonlyp = 0; | |
1253 | ||
984263bc | 1254 | if (!lockflag) |
a11aaa81 | 1255 | vn_unlock(*vpp); |
984263bc MD |
1256 | return (0); |
1257 | } | |
1258 | ||
984263bc MD |
1259 | /* |
1260 | * WebNFS: check if a filehandle is a public filehandle. For v3, this | |
1261 | * means a length of 0, for v2 it means all zeroes. nfsm_srvmtofh has | |
1262 | * transformed this to all zeroes in both cases, so check for it. | |
1263 | */ | |
1264 | int | |
e851b29e | 1265 | nfs_ispublicfh(fhandle_t *fhp) |
984263bc MD |
1266 | { |
1267 | char *cp = (char *)fhp; | |
1268 | int i; | |
1269 | ||
1270 | for (i = 0; i < NFSX_V3FH; i++) | |
1271 | if (*cp++ != 0) | |
1272 | return (FALSE); | |
1273 | return (TRUE); | |
1274 | } | |
1275 | ||
1276 | #endif /* NFS_NOSERVER */ | |
1277 | /* | |
1278 | * This function compares two net addresses by family and returns TRUE | |
1279 | * if they are the same host. | |
1280 | * If there is any doubt, return FALSE. | |
1281 | * The AF_INET family is handled as a special case so that address mbufs | |
1282 | * don't need to be saved to store "struct in_addr", which is only 4 bytes. | |
1283 | */ | |
1284 | int | |
e851b29e | 1285 | netaddr_match(int family, union nethostaddr *haddr, struct sockaddr *nam) |
984263bc | 1286 | { |
40393ded | 1287 | struct sockaddr_in *inetaddr; |
984263bc MD |
1288 | |
1289 | switch (family) { | |
1290 | case AF_INET: | |
1291 | inetaddr = (struct sockaddr_in *)nam; | |
1292 | if (inetaddr->sin_family == AF_INET && | |
1293 | inetaddr->sin_addr.s_addr == haddr->had_inetaddr) | |
1294 | return (1); | |
1295 | break; | |
1296 | default: | |
1297 | break; | |
1298 | }; | |
1299 | return (0); | |
1300 | } | |
1301 | ||
1302 | static nfsuint64 nfs_nullcookie = { { 0, 0 } }; | |
1303 | /* | |
1304 | * This function finds the directory cookie that corresponds to the | |
1305 | * logical byte offset given. | |
1306 | */ | |
1307 | nfsuint64 * | |
e851b29e | 1308 | nfs_getcookie(struct nfsnode *np, off_t off, int add) |
984263bc | 1309 | { |
40393ded RG |
1310 | struct nfsdmap *dp, *dp2; |
1311 | int pos; | |
984263bc MD |
1312 | |
1313 | pos = (uoff_t)off / NFS_DIRBLKSIZ; | |
1314 | if (pos == 0 || off < 0) { | |
1315 | #ifdef DIAGNOSTIC | |
1316 | if (add) | |
1317 | panic("nfs getcookie add at <= 0"); | |
1318 | #endif | |
1319 | return (&nfs_nullcookie); | |
1320 | } | |
1321 | pos--; | |
1322 | dp = np->n_cookies.lh_first; | |
1323 | if (!dp) { | |
1324 | if (add) { | |
1325 | MALLOC(dp, struct nfsdmap *, sizeof (struct nfsdmap), | |
1326 | M_NFSDIROFF, M_WAITOK); | |
1327 | dp->ndm_eocookie = 0; | |
1328 | LIST_INSERT_HEAD(&np->n_cookies, dp, ndm_list); | |
1329 | } else | |
60233e58 | 1330 | return (NULL); |
984263bc MD |
1331 | } |
1332 | while (pos >= NFSNUMCOOKIES) { | |
1333 | pos -= NFSNUMCOOKIES; | |
1334 | if (dp->ndm_list.le_next) { | |
1335 | if (!add && dp->ndm_eocookie < NFSNUMCOOKIES && | |
1336 | pos >= dp->ndm_eocookie) | |
60233e58 | 1337 | return (NULL); |
984263bc MD |
1338 | dp = dp->ndm_list.le_next; |
1339 | } else if (add) { | |
1340 | MALLOC(dp2, struct nfsdmap *, sizeof (struct nfsdmap), | |
1341 | M_NFSDIROFF, M_WAITOK); | |
1342 | dp2->ndm_eocookie = 0; | |
1343 | LIST_INSERT_AFTER(dp, dp2, ndm_list); | |
1344 | dp = dp2; | |
1345 | } else | |
60233e58 | 1346 | return (NULL); |
984263bc MD |
1347 | } |
1348 | if (pos >= dp->ndm_eocookie) { | |
1349 | if (add) | |
1350 | dp->ndm_eocookie = pos + 1; | |
1351 | else | |
60233e58 | 1352 | return (NULL); |
984263bc MD |
1353 | } |
1354 | return (&dp->ndm_cookies[pos]); | |
1355 | } | |
1356 | ||
1357 | /* | |
1358 | * Invalidate cached directory information, except for the actual directory | |
1359 | * blocks (which are invalidated separately). | |
1360 | * Done mainly to avoid the use of stale offset cookies. | |
1361 | */ | |
1362 | void | |
e851b29e | 1363 | nfs_invaldir(struct vnode *vp) |
984263bc | 1364 | { |
40393ded | 1365 | struct nfsnode *np = VTONFS(vp); |
984263bc MD |
1366 | |
1367 | #ifdef DIAGNOSTIC | |
1368 | if (vp->v_type != VDIR) | |
1369 | panic("nfs: invaldir not dir"); | |
1370 | #endif | |
1371 | np->n_direofoffset = 0; | |
1372 | np->n_cookieverf.nfsuquad[0] = 0; | |
1373 | np->n_cookieverf.nfsuquad[1] = 0; | |
1374 | if (np->n_cookies.lh_first) | |
1375 | np->n_cookies.lh_first->ndm_eocookie = 0; | |
1376 | } | |
1377 | ||
1c843a13 MD |
1378 | /* |
1379 | * Set the v_type field for an NFS client's vnode and initialize for | |
1380 | * buffer cache operations if necessary. | |
1381 | */ | |
1382 | void | |
1383 | nfs_setvtype(struct vnode *vp, enum vtype vtyp) | |
1384 | { | |
1385 | vp->v_type = vtyp; | |
1386 | ||
1387 | switch(vtyp) { | |
1388 | case VREG: | |
1389 | case VDIR: | |
1390 | case VLNK: | |
1391 | vinitvmio(vp, 0); /* needs VMIO, size not yet known */ | |
1392 | break; | |
1393 | default: | |
1394 | break; | |
1395 | } | |
1396 | } | |
1397 | ||
984263bc MD |
1398 | /* |
1399 | * The write verifier has changed (probably due to a server reboot), so all | |
1400 | * B_NEEDCOMMIT blocks will have to be written again. Since they are on the | |
1401 | * dirty block list as B_DELWRI, all this takes is clearing the B_NEEDCOMMIT | |
1402 | * and B_CLUSTEROK flags. Once done the new write verifier can be set for the | |
1403 | * mount point. | |
1404 | * | |
1405 | * B_CLUSTEROK must be cleared along with B_NEEDCOMMIT because stage 1 data | |
1406 | * writes are not clusterable. | |
1407 | */ | |
6bae6177 MD |
1408 | |
1409 | static int nfs_clearcommit_bp(struct buf *bp, void *data __unused); | |
0202303b MD |
1410 | static int nfs_clearcommit_callback(struct mount *mp, struct vnode *vp, |
1411 | void *data __unused); | |
6bae6177 | 1412 | |
984263bc | 1413 | void |
e851b29e | 1414 | nfs_clearcommit(struct mount *mp) |
984263bc | 1415 | { |
0202303b MD |
1416 | vmntvnodescan(mp, VMSC_NOWAIT, nfs_clearcommit_callback, NULL, NULL); |
1417 | } | |
1418 | ||
1419 | static int | |
1420 | nfs_clearcommit_callback(struct mount *mp, struct vnode *vp, | |
1421 | void *data __unused) | |
1422 | { | |
1423 | lwkt_tokref vlock; | |
1424 | ||
1425 | vhold(vp); | |
1426 | lwkt_gettoken(&vlock, &vp->v_token); | |
1427 | RB_SCAN(buf_rb_tree, &vp->v_rbdirty_tree, NULL, | |
1428 | nfs_clearcommit_bp, NULL); | |
1429 | lwkt_reltoken(&vlock); | |
1430 | vdrop(vp); | |
1431 | return(0); | |
984263bc MD |
1432 | } |
1433 | ||
6bae6177 MD |
1434 | static int |
1435 | nfs_clearcommit_bp(struct buf *bp, void *data __unused) | |
1436 | { | |
1437 | if (BUF_REFCNT(bp) == 0 && | |
1438 | (bp->b_flags & (B_DELWRI | B_NEEDCOMMIT)) | |
1439 | == (B_DELWRI | B_NEEDCOMMIT)) { | |
1440 | bp->b_flags &= ~(B_NEEDCOMMIT | B_CLUSTEROK); | |
1441 | } | |
1442 | return(0); | |
1443 | } | |
1444 | ||
984263bc MD |
1445 | #ifndef NFS_NOSERVER |
1446 | /* | |
1447 | * Map errnos to NFS error numbers. For Version 3 also filter out error | |
1448 | * numbers not specified for the associated procedure. | |
1449 | */ | |
1450 | int | |
e851b29e | 1451 | nfsrv_errmap(struct nfsrv_descript *nd, int err) |
984263bc | 1452 | { |
40393ded | 1453 | short *defaulterrp, *errp; |
984263bc MD |
1454 | |
1455 | if (nd->nd_flag & ND_NFSV3) { | |
1456 | if (nd->nd_procnum <= NFSPROC_COMMIT) { | |
1457 | errp = defaulterrp = nfsrv_v3errmap[nd->nd_procnum]; | |
1458 | while (*++errp) { | |
1459 | if (*errp == err) | |
1460 | return (err); | |
1461 | else if (*errp > err) | |
1462 | break; | |
1463 | } | |
1464 | return ((int)*defaulterrp); | |
1465 | } else | |
1466 | return (err & 0xffff); | |
1467 | } | |
1468 | if (err <= ELAST) | |
1469 | return ((int)nfsrv_v2errmap[err - 1]); | |
1470 | return (NFSERR_IO); | |
1471 | } | |
1472 | ||
984263bc MD |
1473 | /* |
1474 | * Sort the group list in increasing numerical order. | |
1475 | * (Insertion sort by Chris Torek, who was grossed out by the bubble sort | |
1476 | * that used to be here.) | |
1477 | */ | |
1478 | void | |
e851b29e | 1479 | nfsrvw_sort(gid_t *list, int num) |
984263bc | 1480 | { |
40393ded | 1481 | int i, j; |
984263bc MD |
1482 | gid_t v; |
1483 | ||
1484 | /* Insertion sort. */ | |
1485 | for (i = 1; i < num; i++) { | |
1486 | v = list[i]; | |
1487 | /* find correct slot for value v, moving others up */ | |
1488 | for (j = i; --j >= 0 && v < list[j];) | |
1489 | list[j + 1] = list[j]; | |
1490 | list[j + 1] = v; | |
1491 | } | |
1492 | } | |
1493 | ||
1494 | /* | |
1495 | * copy credentials making sure that the result can be compared with bcmp(). | |
1496 | */ | |
1497 | void | |
e851b29e | 1498 | nfsrv_setcred(struct ucred *incred, struct ucred *outcred) |
984263bc | 1499 | { |
40393ded | 1500 | int i; |
984263bc MD |
1501 | |
1502 | bzero((caddr_t)outcred, sizeof (struct ucred)); | |
1503 | outcred->cr_ref = 1; | |
1504 | outcred->cr_uid = incred->cr_uid; | |
1505 | outcred->cr_ngroups = incred->cr_ngroups; | |
1506 | for (i = 0; i < incred->cr_ngroups; i++) | |
1507 | outcred->cr_groups[i] = incred->cr_groups[i]; | |
1508 | nfsrvw_sort(outcred->cr_groups, outcred->cr_ngroups); | |
1509 | } | |
1510 | #endif /* NFS_NOSERVER */ |