xref: /openbmc/linux/fs/nfsd/nfsproc.c (revision 94cdda6b)
1 /*
2  * Process version 2 NFS requests.
3  *
4  * Copyright (C) 1995-1997 Olaf Kirch <okir@monad.swb.de>
5  */
6 
7 #include <linux/namei.h>
8 
9 #include "cache.h"
10 #include "xdr.h"
11 #include "vfs.h"
12 
13 typedef struct svc_rqst	svc_rqst;
14 typedef struct svc_buf	svc_buf;
15 
16 #define NFSDDBG_FACILITY		NFSDDBG_PROC
17 
18 
19 static __be32
20 nfsd_proc_null(struct svc_rqst *rqstp, void *argp, void *resp)
21 {
22 	return nfs_ok;
23 }
24 
25 static __be32
26 nfsd_return_attrs(__be32 err, struct nfsd_attrstat *resp)
27 {
28 	if (err) return err;
29 	return fh_getattr(&resp->fh, &resp->stat);
30 }
31 static __be32
32 nfsd_return_dirop(__be32 err, struct nfsd_diropres *resp)
33 {
34 	if (err) return err;
35 	return fh_getattr(&resp->fh, &resp->stat);
36 }
37 /*
38  * Get a file's attributes
39  * N.B. After this call resp->fh needs an fh_put
40  */
41 static __be32
42 nfsd_proc_getattr(struct svc_rqst *rqstp, struct nfsd_fhandle  *argp,
43 					  struct nfsd_attrstat *resp)
44 {
45 	__be32 nfserr;
46 	dprintk("nfsd: GETATTR  %s\n", SVCFH_fmt(&argp->fh));
47 
48 	fh_copy(&resp->fh, &argp->fh);
49 	nfserr = fh_verify(rqstp, &resp->fh, 0,
50 			NFSD_MAY_NOP | NFSD_MAY_BYPASS_GSS_ON_ROOT);
51 	return nfsd_return_attrs(nfserr, resp);
52 }
53 
54 /*
55  * Set a file's attributes
56  * N.B. After this call resp->fh needs an fh_put
57  */
58 static __be32
59 nfsd_proc_setattr(struct svc_rqst *rqstp, struct nfsd_sattrargs *argp,
60 					  struct nfsd_attrstat  *resp)
61 {
62 	__be32 nfserr;
63 	dprintk("nfsd: SETATTR  %s, valid=%x, size=%ld\n",
64 		SVCFH_fmt(&argp->fh),
65 		argp->attrs.ia_valid, (long) argp->attrs.ia_size);
66 
67 	fh_copy(&resp->fh, &argp->fh);
68 	nfserr = nfsd_setattr(rqstp, &resp->fh, &argp->attrs,0, (time_t)0);
69 	return nfsd_return_attrs(nfserr, resp);
70 }
71 
72 /*
73  * Look up a path name component
74  * Note: the dentry in the resp->fh may be negative if the file
75  * doesn't exist yet.
76  * N.B. After this call resp->fh needs an fh_put
77  */
78 static __be32
79 nfsd_proc_lookup(struct svc_rqst *rqstp, struct nfsd_diropargs *argp,
80 					 struct nfsd_diropres  *resp)
81 {
82 	__be32	nfserr;
83 
84 	dprintk("nfsd: LOOKUP   %s %.*s\n",
85 		SVCFH_fmt(&argp->fh), argp->len, argp->name);
86 
87 	fh_init(&resp->fh, NFS_FHSIZE);
88 	nfserr = nfsd_lookup(rqstp, &argp->fh, argp->name, argp->len,
89 				 &resp->fh);
90 
91 	fh_put(&argp->fh);
92 	return nfsd_return_dirop(nfserr, resp);
93 }
94 
95 /*
96  * Read a symlink.
97  */
98 static __be32
99 nfsd_proc_readlink(struct svc_rqst *rqstp, struct nfsd_readlinkargs *argp,
100 					   struct nfsd_readlinkres *resp)
101 {
102 	__be32	nfserr;
103 
104 	dprintk("nfsd: READLINK %s\n", SVCFH_fmt(&argp->fh));
105 
106 	/* Read the symlink. */
107 	resp->len = NFS_MAXPATHLEN;
108 	nfserr = nfsd_readlink(rqstp, &argp->fh, argp->buffer, &resp->len);
109 
110 	fh_put(&argp->fh);
111 	return nfserr;
112 }
113 
114 /*
115  * Read a portion of a file.
116  * N.B. After this call resp->fh needs an fh_put
117  */
118 static __be32
119 nfsd_proc_read(struct svc_rqst *rqstp, struct nfsd_readargs *argp,
120 				       struct nfsd_readres  *resp)
121 {
122 	__be32	nfserr;
123 
124 	dprintk("nfsd: READ    %s %d bytes at %d\n",
125 		SVCFH_fmt(&argp->fh),
126 		argp->count, argp->offset);
127 
128 	/* Obtain buffer pointer for payload. 19 is 1 word for
129 	 * status, 17 words for fattr, and 1 word for the byte count.
130 	 */
131 
132 	if (NFSSVC_MAXBLKSIZE_V2 < argp->count) {
133 		char buf[RPC_MAX_ADDRBUFLEN];
134 		printk(KERN_NOTICE
135 			"oversized read request from %s (%d bytes)\n",
136 				svc_print_addr(rqstp, buf, sizeof(buf)),
137 				argp->count);
138 		argp->count = NFSSVC_MAXBLKSIZE_V2;
139 	}
140 	svc_reserve_auth(rqstp, (19<<2) + argp->count + 4);
141 
142 	resp->count = argp->count;
143 	nfserr = nfsd_read(rqstp, fh_copy(&resp->fh, &argp->fh),
144 				  argp->offset,
145 			   	  rqstp->rq_vec, argp->vlen,
146 				  &resp->count);
147 
148 	if (nfserr) return nfserr;
149 	return fh_getattr(&resp->fh, &resp->stat);
150 }
151 
152 /*
153  * Write data to a file
154  * N.B. After this call resp->fh needs an fh_put
155  */
156 static __be32
157 nfsd_proc_write(struct svc_rqst *rqstp, struct nfsd_writeargs *argp,
158 					struct nfsd_attrstat  *resp)
159 {
160 	__be32	nfserr;
161 	int	stable = 1;
162 	unsigned long cnt = argp->len;
163 
164 	dprintk("nfsd: WRITE    %s %d bytes at %d\n",
165 		SVCFH_fmt(&argp->fh),
166 		argp->len, argp->offset);
167 
168 	nfserr = nfsd_write(rqstp, fh_copy(&resp->fh, &argp->fh), NULL,
169 				   argp->offset,
170 				   rqstp->rq_vec, argp->vlen,
171 			           &cnt,
172 				   &stable);
173 	return nfsd_return_attrs(nfserr, resp);
174 }
175 
176 /*
177  * CREATE processing is complicated. The keyword here is `overloaded.'
178  * The parent directory is kept locked between the check for existence
179  * and the actual create() call in compliance with VFS protocols.
180  * N.B. After this call _both_ argp->fh and resp->fh need an fh_put
181  */
182 static __be32
183 nfsd_proc_create(struct svc_rqst *rqstp, struct nfsd_createargs *argp,
184 					 struct nfsd_diropres   *resp)
185 {
186 	svc_fh		*dirfhp = &argp->fh;
187 	svc_fh		*newfhp = &resp->fh;
188 	struct iattr	*attr = &argp->attrs;
189 	struct inode	*inode;
190 	struct dentry	*dchild;
191 	int		type, mode;
192 	__be32		nfserr;
193 	int		hosterr;
194 	dev_t		rdev = 0, wanted = new_decode_dev(attr->ia_size);
195 
196 	dprintk("nfsd: CREATE   %s %.*s\n",
197 		SVCFH_fmt(dirfhp), argp->len, argp->name);
198 
199 	/* First verify the parent file handle */
200 	nfserr = fh_verify(rqstp, dirfhp, S_IFDIR, NFSD_MAY_EXEC);
201 	if (nfserr)
202 		goto done; /* must fh_put dirfhp even on error */
203 
204 	/* Check for NFSD_MAY_WRITE in nfsd_create if necessary */
205 
206 	nfserr = nfserr_acces;
207 	if (!argp->len)
208 		goto done;
209 	nfserr = nfserr_exist;
210 	if (isdotent(argp->name, argp->len))
211 		goto done;
212 	hosterr = fh_want_write(dirfhp);
213 	if (hosterr) {
214 		nfserr = nfserrno(hosterr);
215 		goto done;
216 	}
217 
218 	fh_lock_nested(dirfhp, I_MUTEX_PARENT);
219 	dchild = lookup_one_len(argp->name, dirfhp->fh_dentry, argp->len);
220 	if (IS_ERR(dchild)) {
221 		nfserr = nfserrno(PTR_ERR(dchild));
222 		goto out_unlock;
223 	}
224 	fh_init(newfhp, NFS_FHSIZE);
225 	nfserr = fh_compose(newfhp, dirfhp->fh_export, dchild, dirfhp);
226 	if (!nfserr && d_really_is_negative(dchild))
227 		nfserr = nfserr_noent;
228 	dput(dchild);
229 	if (nfserr) {
230 		if (nfserr != nfserr_noent)
231 			goto out_unlock;
232 		/*
233 		 * If the new file handle wasn't verified, we can't tell
234 		 * whether the file exists or not. Time to bail ...
235 		 */
236 		nfserr = nfserr_acces;
237 		if (!newfhp->fh_dentry) {
238 			printk(KERN_WARNING
239 				"nfsd_proc_create: file handle not verified\n");
240 			goto out_unlock;
241 		}
242 	}
243 
244 	inode = d_inode(newfhp->fh_dentry);
245 
246 	/* Unfudge the mode bits */
247 	if (attr->ia_valid & ATTR_MODE) {
248 		type = attr->ia_mode & S_IFMT;
249 		mode = attr->ia_mode & ~S_IFMT;
250 		if (!type) {
251 			/* no type, so if target exists, assume same as that,
252 			 * else assume a file */
253 			if (inode) {
254 				type = inode->i_mode & S_IFMT;
255 				switch(type) {
256 				case S_IFCHR:
257 				case S_IFBLK:
258 					/* reserve rdev for later checking */
259 					rdev = inode->i_rdev;
260 					attr->ia_valid |= ATTR_SIZE;
261 
262 					/* FALLTHROUGH */
263 				case S_IFIFO:
264 					/* this is probably a permission check..
265 					 * at least IRIX implements perm checking on
266 					 *   echo thing > device-special-file-or-pipe
267 					 * by doing a CREATE with type==0
268 					 */
269 					nfserr = nfsd_permission(rqstp,
270 								 newfhp->fh_export,
271 								 newfhp->fh_dentry,
272 								 NFSD_MAY_WRITE|NFSD_MAY_LOCAL_ACCESS);
273 					if (nfserr && nfserr != nfserr_rofs)
274 						goto out_unlock;
275 				}
276 			} else
277 				type = S_IFREG;
278 		}
279 	} else if (inode) {
280 		type = inode->i_mode & S_IFMT;
281 		mode = inode->i_mode & ~S_IFMT;
282 	} else {
283 		type = S_IFREG;
284 		mode = 0;	/* ??? */
285 	}
286 
287 	attr->ia_valid |= ATTR_MODE;
288 	attr->ia_mode = mode;
289 
290 	/* Special treatment for non-regular files according to the
291 	 * gospel of sun micro
292 	 */
293 	if (type != S_IFREG) {
294 		if (type != S_IFBLK && type != S_IFCHR) {
295 			rdev = 0;
296 		} else if (type == S_IFCHR && !(attr->ia_valid & ATTR_SIZE)) {
297 			/* If you think you've seen the worst, grok this. */
298 			type = S_IFIFO;
299 		} else {
300 			/* Okay, char or block special */
301 			if (!rdev)
302 				rdev = wanted;
303 		}
304 
305 		/* we've used the SIZE information, so discard it */
306 		attr->ia_valid &= ~ATTR_SIZE;
307 
308 		/* Make sure the type and device matches */
309 		nfserr = nfserr_exist;
310 		if (inode && type != (inode->i_mode & S_IFMT))
311 			goto out_unlock;
312 	}
313 
314 	nfserr = 0;
315 	if (!inode) {
316 		/* File doesn't exist. Create it and set attrs */
317 		nfserr = nfsd_create(rqstp, dirfhp, argp->name, argp->len,
318 					attr, type, rdev, newfhp);
319 	} else if (type == S_IFREG) {
320 		dprintk("nfsd:   existing %s, valid=%x, size=%ld\n",
321 			argp->name, attr->ia_valid, (long) attr->ia_size);
322 		/* File already exists. We ignore all attributes except
323 		 * size, so that creat() behaves exactly like
324 		 * open(..., O_CREAT|O_TRUNC|O_WRONLY).
325 		 */
326 		attr->ia_valid &= ATTR_SIZE;
327 		if (attr->ia_valid)
328 			nfserr = nfsd_setattr(rqstp, newfhp, attr, 0, (time_t)0);
329 	}
330 
331 out_unlock:
332 	/* We don't really need to unlock, as fh_put does it. */
333 	fh_unlock(dirfhp);
334 	fh_drop_write(dirfhp);
335 done:
336 	fh_put(dirfhp);
337 	return nfsd_return_dirop(nfserr, resp);
338 }
339 
340 static __be32
341 nfsd_proc_remove(struct svc_rqst *rqstp, struct nfsd_diropargs *argp,
342 					 void		       *resp)
343 {
344 	__be32	nfserr;
345 
346 	dprintk("nfsd: REMOVE   %s %.*s\n", SVCFH_fmt(&argp->fh),
347 		argp->len, argp->name);
348 
349 	/* Unlink. -SIFDIR means file must not be a directory */
350 	nfserr = nfsd_unlink(rqstp, &argp->fh, -S_IFDIR, argp->name, argp->len);
351 	fh_put(&argp->fh);
352 	return nfserr;
353 }
354 
355 static __be32
356 nfsd_proc_rename(struct svc_rqst *rqstp, struct nfsd_renameargs *argp,
357 				  	 void		        *resp)
358 {
359 	__be32	nfserr;
360 
361 	dprintk("nfsd: RENAME   %s %.*s -> \n",
362 		SVCFH_fmt(&argp->ffh), argp->flen, argp->fname);
363 	dprintk("nfsd:        ->  %s %.*s\n",
364 		SVCFH_fmt(&argp->tfh), argp->tlen, argp->tname);
365 
366 	nfserr = nfsd_rename(rqstp, &argp->ffh, argp->fname, argp->flen,
367 				    &argp->tfh, argp->tname, argp->tlen);
368 	fh_put(&argp->ffh);
369 	fh_put(&argp->tfh);
370 	return nfserr;
371 }
372 
373 static __be32
374 nfsd_proc_link(struct svc_rqst *rqstp, struct nfsd_linkargs *argp,
375 				void			    *resp)
376 {
377 	__be32	nfserr;
378 
379 	dprintk("nfsd: LINK     %s ->\n",
380 		SVCFH_fmt(&argp->ffh));
381 	dprintk("nfsd:    %s %.*s\n",
382 		SVCFH_fmt(&argp->tfh),
383 		argp->tlen,
384 		argp->tname);
385 
386 	nfserr = nfsd_link(rqstp, &argp->tfh, argp->tname, argp->tlen,
387 				  &argp->ffh);
388 	fh_put(&argp->ffh);
389 	fh_put(&argp->tfh);
390 	return nfserr;
391 }
392 
393 static __be32
394 nfsd_proc_symlink(struct svc_rqst *rqstp, struct nfsd_symlinkargs *argp,
395 				          void			  *resp)
396 {
397 	struct svc_fh	newfh;
398 	__be32		nfserr;
399 
400 	dprintk("nfsd: SYMLINK  %s %.*s -> %.*s\n",
401 		SVCFH_fmt(&argp->ffh), argp->flen, argp->fname,
402 		argp->tlen, argp->tname);
403 
404 	fh_init(&newfh, NFS_FHSIZE);
405 	/*
406 	 * Crazy hack: the request fits in a page, and already-decoded
407 	 * attributes follow argp->tname, so it's safe to just write a
408 	 * null to ensure it's null-terminated:
409 	 */
410 	argp->tname[argp->tlen] = '\0';
411 	nfserr = nfsd_symlink(rqstp, &argp->ffh, argp->fname, argp->flen,
412 						 argp->tname, &newfh);
413 
414 	fh_put(&argp->ffh);
415 	fh_put(&newfh);
416 	return nfserr;
417 }
418 
419 /*
420  * Make directory. This operation is not idempotent.
421  * N.B. After this call resp->fh needs an fh_put
422  */
423 static __be32
424 nfsd_proc_mkdir(struct svc_rqst *rqstp, struct nfsd_createargs *argp,
425 					struct nfsd_diropres   *resp)
426 {
427 	__be32	nfserr;
428 
429 	dprintk("nfsd: MKDIR    %s %.*s\n", SVCFH_fmt(&argp->fh), argp->len, argp->name);
430 
431 	if (resp->fh.fh_dentry) {
432 		printk(KERN_WARNING
433 			"nfsd_proc_mkdir: response already verified??\n");
434 	}
435 
436 	argp->attrs.ia_valid &= ~ATTR_SIZE;
437 	fh_init(&resp->fh, NFS_FHSIZE);
438 	nfserr = nfsd_create(rqstp, &argp->fh, argp->name, argp->len,
439 				    &argp->attrs, S_IFDIR, 0, &resp->fh);
440 	fh_put(&argp->fh);
441 	return nfsd_return_dirop(nfserr, resp);
442 }
443 
444 /*
445  * Remove a directory
446  */
447 static __be32
448 nfsd_proc_rmdir(struct svc_rqst *rqstp, struct nfsd_diropargs *argp,
449 				 	void		      *resp)
450 {
451 	__be32	nfserr;
452 
453 	dprintk("nfsd: RMDIR    %s %.*s\n", SVCFH_fmt(&argp->fh), argp->len, argp->name);
454 
455 	nfserr = nfsd_unlink(rqstp, &argp->fh, S_IFDIR, argp->name, argp->len);
456 	fh_put(&argp->fh);
457 	return nfserr;
458 }
459 
460 /*
461  * Read a portion of a directory.
462  */
463 static __be32
464 nfsd_proc_readdir(struct svc_rqst *rqstp, struct nfsd_readdirargs *argp,
465 					  struct nfsd_readdirres  *resp)
466 {
467 	int		count;
468 	__be32		nfserr;
469 	loff_t		offset;
470 
471 	dprintk("nfsd: READDIR  %s %d bytes at %d\n",
472 		SVCFH_fmt(&argp->fh),
473 		argp->count, argp->cookie);
474 
475 	/* Shrink to the client read size */
476 	count = (argp->count >> 2) - 2;
477 
478 	/* Make sure we've room for the NULL ptr & eof flag */
479 	count -= 2;
480 	if (count < 0)
481 		count = 0;
482 
483 	resp->buffer = argp->buffer;
484 	resp->offset = NULL;
485 	resp->buflen = count;
486 	resp->common.err = nfs_ok;
487 	/* Read directory and encode entries on the fly */
488 	offset = argp->cookie;
489 	nfserr = nfsd_readdir(rqstp, &argp->fh, &offset,
490 			      &resp->common, nfssvc_encode_entry);
491 
492 	resp->count = resp->buffer - argp->buffer;
493 	if (resp->offset)
494 		*resp->offset = htonl(offset);
495 
496 	fh_put(&argp->fh);
497 	return nfserr;
498 }
499 
500 /*
501  * Get file system info
502  */
503 static __be32
504 nfsd_proc_statfs(struct svc_rqst * rqstp, struct nfsd_fhandle   *argp,
505 					  struct nfsd_statfsres *resp)
506 {
507 	__be32	nfserr;
508 
509 	dprintk("nfsd: STATFS   %s\n", SVCFH_fmt(&argp->fh));
510 
511 	nfserr = nfsd_statfs(rqstp, &argp->fh, &resp->stats,
512 			NFSD_MAY_BYPASS_GSS_ON_ROOT);
513 	fh_put(&argp->fh);
514 	return nfserr;
515 }
516 
517 /*
518  * NFSv2 Server procedures.
519  * Only the results of non-idempotent operations are cached.
520  */
521 struct nfsd_void { int dummy; };
522 
523 #define ST 1		/* status */
524 #define FH 8		/* filehandle */
525 #define	AT 18		/* attributes */
526 
527 static struct svc_procedure		nfsd_procedures2[18] = {
528 	[NFSPROC_NULL] = {
529 		.pc_func = (svc_procfunc) nfsd_proc_null,
530 		.pc_decode = (kxdrproc_t) nfssvc_decode_void,
531 		.pc_encode = (kxdrproc_t) nfssvc_encode_void,
532 		.pc_argsize = sizeof(struct nfsd_void),
533 		.pc_ressize = sizeof(struct nfsd_void),
534 		.pc_cachetype = RC_NOCACHE,
535 		.pc_xdrressize = ST,
536 	},
537 	[NFSPROC_GETATTR] = {
538 		.pc_func = (svc_procfunc) nfsd_proc_getattr,
539 		.pc_decode = (kxdrproc_t) nfssvc_decode_fhandle,
540 		.pc_encode = (kxdrproc_t) nfssvc_encode_attrstat,
541 		.pc_release = (kxdrproc_t) nfssvc_release_fhandle,
542 		.pc_argsize = sizeof(struct nfsd_fhandle),
543 		.pc_ressize = sizeof(struct nfsd_attrstat),
544 		.pc_cachetype = RC_NOCACHE,
545 		.pc_xdrressize = ST+AT,
546 	},
547 	[NFSPROC_SETATTR] = {
548 		.pc_func = (svc_procfunc) nfsd_proc_setattr,
549 		.pc_decode = (kxdrproc_t) nfssvc_decode_sattrargs,
550 		.pc_encode = (kxdrproc_t) nfssvc_encode_attrstat,
551 		.pc_release = (kxdrproc_t) nfssvc_release_fhandle,
552 		.pc_argsize = sizeof(struct nfsd_sattrargs),
553 		.pc_ressize = sizeof(struct nfsd_attrstat),
554 		.pc_cachetype = RC_REPLBUFF,
555 		.pc_xdrressize = ST+AT,
556 	},
557 	[NFSPROC_ROOT] = {
558 		.pc_decode = (kxdrproc_t) nfssvc_decode_void,
559 		.pc_encode = (kxdrproc_t) nfssvc_encode_void,
560 		.pc_argsize = sizeof(struct nfsd_void),
561 		.pc_ressize = sizeof(struct nfsd_void),
562 		.pc_cachetype = RC_NOCACHE,
563 		.pc_xdrressize = ST,
564 	},
565 	[NFSPROC_LOOKUP] = {
566 		.pc_func = (svc_procfunc) nfsd_proc_lookup,
567 		.pc_decode = (kxdrproc_t) nfssvc_decode_diropargs,
568 		.pc_encode = (kxdrproc_t) nfssvc_encode_diropres,
569 		.pc_release = (kxdrproc_t) nfssvc_release_fhandle,
570 		.pc_argsize = sizeof(struct nfsd_diropargs),
571 		.pc_ressize = sizeof(struct nfsd_diropres),
572 		.pc_cachetype = RC_NOCACHE,
573 		.pc_xdrressize = ST+FH+AT,
574 	},
575 	[NFSPROC_READLINK] = {
576 		.pc_func = (svc_procfunc) nfsd_proc_readlink,
577 		.pc_decode = (kxdrproc_t) nfssvc_decode_readlinkargs,
578 		.pc_encode = (kxdrproc_t) nfssvc_encode_readlinkres,
579 		.pc_argsize = sizeof(struct nfsd_readlinkargs),
580 		.pc_ressize = sizeof(struct nfsd_readlinkres),
581 		.pc_cachetype = RC_NOCACHE,
582 		.pc_xdrressize = ST+1+NFS_MAXPATHLEN/4,
583 	},
584 	[NFSPROC_READ] = {
585 		.pc_func = (svc_procfunc) nfsd_proc_read,
586 		.pc_decode = (kxdrproc_t) nfssvc_decode_readargs,
587 		.pc_encode = (kxdrproc_t) nfssvc_encode_readres,
588 		.pc_release = (kxdrproc_t) nfssvc_release_fhandle,
589 		.pc_argsize = sizeof(struct nfsd_readargs),
590 		.pc_ressize = sizeof(struct nfsd_readres),
591 		.pc_cachetype = RC_NOCACHE,
592 		.pc_xdrressize = ST+AT+1+NFSSVC_MAXBLKSIZE_V2/4,
593 	},
594 	[NFSPROC_WRITECACHE] = {
595 		.pc_decode = (kxdrproc_t) nfssvc_decode_void,
596 		.pc_encode = (kxdrproc_t) nfssvc_encode_void,
597 		.pc_argsize = sizeof(struct nfsd_void),
598 		.pc_ressize = sizeof(struct nfsd_void),
599 		.pc_cachetype = RC_NOCACHE,
600 		.pc_xdrressize = ST,
601 	},
602 	[NFSPROC_WRITE] = {
603 		.pc_func = (svc_procfunc) nfsd_proc_write,
604 		.pc_decode = (kxdrproc_t) nfssvc_decode_writeargs,
605 		.pc_encode = (kxdrproc_t) nfssvc_encode_attrstat,
606 		.pc_release = (kxdrproc_t) nfssvc_release_fhandle,
607 		.pc_argsize = sizeof(struct nfsd_writeargs),
608 		.pc_ressize = sizeof(struct nfsd_attrstat),
609 		.pc_cachetype = RC_REPLBUFF,
610 		.pc_xdrressize = ST+AT,
611 	},
612 	[NFSPROC_CREATE] = {
613 		.pc_func = (svc_procfunc) nfsd_proc_create,
614 		.pc_decode = (kxdrproc_t) nfssvc_decode_createargs,
615 		.pc_encode = (kxdrproc_t) nfssvc_encode_diropres,
616 		.pc_release = (kxdrproc_t) nfssvc_release_fhandle,
617 		.pc_argsize = sizeof(struct nfsd_createargs),
618 		.pc_ressize = sizeof(struct nfsd_diropres),
619 		.pc_cachetype = RC_REPLBUFF,
620 		.pc_xdrressize = ST+FH+AT,
621 	},
622 	[NFSPROC_REMOVE] = {
623 		.pc_func = (svc_procfunc) nfsd_proc_remove,
624 		.pc_decode = (kxdrproc_t) nfssvc_decode_diropargs,
625 		.pc_encode = (kxdrproc_t) nfssvc_encode_void,
626 		.pc_argsize = sizeof(struct nfsd_diropargs),
627 		.pc_ressize = sizeof(struct nfsd_void),
628 		.pc_cachetype = RC_REPLSTAT,
629 		.pc_xdrressize = ST,
630 	},
631 	[NFSPROC_RENAME] = {
632 		.pc_func = (svc_procfunc) nfsd_proc_rename,
633 		.pc_decode = (kxdrproc_t) nfssvc_decode_renameargs,
634 		.pc_encode = (kxdrproc_t) nfssvc_encode_void,
635 		.pc_argsize = sizeof(struct nfsd_renameargs),
636 		.pc_ressize = sizeof(struct nfsd_void),
637 		.pc_cachetype = RC_REPLSTAT,
638 		.pc_xdrressize = ST,
639 	},
640 	[NFSPROC_LINK] = {
641 		.pc_func = (svc_procfunc) nfsd_proc_link,
642 		.pc_decode = (kxdrproc_t) nfssvc_decode_linkargs,
643 		.pc_encode = (kxdrproc_t) nfssvc_encode_void,
644 		.pc_argsize = sizeof(struct nfsd_linkargs),
645 		.pc_ressize = sizeof(struct nfsd_void),
646 		.pc_cachetype = RC_REPLSTAT,
647 		.pc_xdrressize = ST,
648 	},
649 	[NFSPROC_SYMLINK] = {
650 		.pc_func = (svc_procfunc) nfsd_proc_symlink,
651 		.pc_decode = (kxdrproc_t) nfssvc_decode_symlinkargs,
652 		.pc_encode = (kxdrproc_t) nfssvc_encode_void,
653 		.pc_argsize = sizeof(struct nfsd_symlinkargs),
654 		.pc_ressize = sizeof(struct nfsd_void),
655 		.pc_cachetype = RC_REPLSTAT,
656 		.pc_xdrressize = ST,
657 	},
658 	[NFSPROC_MKDIR] = {
659 		.pc_func = (svc_procfunc) nfsd_proc_mkdir,
660 		.pc_decode = (kxdrproc_t) nfssvc_decode_createargs,
661 		.pc_encode = (kxdrproc_t) nfssvc_encode_diropres,
662 		.pc_release = (kxdrproc_t) nfssvc_release_fhandle,
663 		.pc_argsize = sizeof(struct nfsd_createargs),
664 		.pc_ressize = sizeof(struct nfsd_diropres),
665 		.pc_cachetype = RC_REPLBUFF,
666 		.pc_xdrressize = ST+FH+AT,
667 	},
668 	[NFSPROC_RMDIR] = {
669 		.pc_func = (svc_procfunc) nfsd_proc_rmdir,
670 		.pc_decode = (kxdrproc_t) nfssvc_decode_diropargs,
671 		.pc_encode = (kxdrproc_t) nfssvc_encode_void,
672 		.pc_argsize = sizeof(struct nfsd_diropargs),
673 		.pc_ressize = sizeof(struct nfsd_void),
674 		.pc_cachetype = RC_REPLSTAT,
675 		.pc_xdrressize = ST,
676 	},
677 	[NFSPROC_READDIR] = {
678 		.pc_func = (svc_procfunc) nfsd_proc_readdir,
679 		.pc_decode = (kxdrproc_t) nfssvc_decode_readdirargs,
680 		.pc_encode = (kxdrproc_t) nfssvc_encode_readdirres,
681 		.pc_argsize = sizeof(struct nfsd_readdirargs),
682 		.pc_ressize = sizeof(struct nfsd_readdirres),
683 		.pc_cachetype = RC_NOCACHE,
684 	},
685 	[NFSPROC_STATFS] = {
686 		.pc_func = (svc_procfunc) nfsd_proc_statfs,
687 		.pc_decode = (kxdrproc_t) nfssvc_decode_fhandle,
688 		.pc_encode = (kxdrproc_t) nfssvc_encode_statfsres,
689 		.pc_argsize = sizeof(struct nfsd_fhandle),
690 		.pc_ressize = sizeof(struct nfsd_statfsres),
691 		.pc_cachetype = RC_NOCACHE,
692 		.pc_xdrressize = ST+5,
693 	},
694 };
695 
696 
697 struct svc_version	nfsd_version2 = {
698 		.vs_vers	= 2,
699 		.vs_nproc	= 18,
700 		.vs_proc	= nfsd_procedures2,
701 		.vs_dispatch	= nfsd_dispatch,
702 		.vs_xdrsize	= NFS2_SVC_XDRSIZE,
703 };
704 
705 /*
706  * Map errnos to NFS errnos.
707  */
708 __be32
709 nfserrno (int errno)
710 {
711 	static struct {
712 		__be32	nfserr;
713 		int	syserr;
714 	} nfs_errtbl[] = {
715 		{ nfs_ok, 0 },
716 		{ nfserr_perm, -EPERM },
717 		{ nfserr_noent, -ENOENT },
718 		{ nfserr_io, -EIO },
719 		{ nfserr_nxio, -ENXIO },
720 		{ nfserr_fbig, -E2BIG },
721 		{ nfserr_acces, -EACCES },
722 		{ nfserr_exist, -EEXIST },
723 		{ nfserr_xdev, -EXDEV },
724 		{ nfserr_mlink, -EMLINK },
725 		{ nfserr_nodev, -ENODEV },
726 		{ nfserr_notdir, -ENOTDIR },
727 		{ nfserr_isdir, -EISDIR },
728 		{ nfserr_inval, -EINVAL },
729 		{ nfserr_fbig, -EFBIG },
730 		{ nfserr_nospc, -ENOSPC },
731 		{ nfserr_rofs, -EROFS },
732 		{ nfserr_mlink, -EMLINK },
733 		{ nfserr_nametoolong, -ENAMETOOLONG },
734 		{ nfserr_notempty, -ENOTEMPTY },
735 #ifdef EDQUOT
736 		{ nfserr_dquot, -EDQUOT },
737 #endif
738 		{ nfserr_stale, -ESTALE },
739 		{ nfserr_jukebox, -ETIMEDOUT },
740 		{ nfserr_jukebox, -ERESTARTSYS },
741 		{ nfserr_jukebox, -EAGAIN },
742 		{ nfserr_jukebox, -EWOULDBLOCK },
743 		{ nfserr_jukebox, -ENOMEM },
744 		{ nfserr_io, -ETXTBSY },
745 		{ nfserr_notsupp, -EOPNOTSUPP },
746 		{ nfserr_toosmall, -ETOOSMALL },
747 		{ nfserr_serverfault, -ESERVERFAULT },
748 		{ nfserr_serverfault, -ENFILE },
749 	};
750 	int	i;
751 
752 	for (i = 0; i < ARRAY_SIZE(nfs_errtbl); i++) {
753 		if (nfs_errtbl[i].syserr == errno)
754 			return nfs_errtbl[i].nfserr;
755 	}
756 	WARN(1, "nfsd: non-standard errno: %d\n", errno);
757 	return nfserr_io;
758 }
759 
760