xref: /openbmc/linux/fs/nfsd/nfsproc.c (revision d5cb9783536a41df9f9cba5b0a1d78047ed787f7)
1 /*
2  * nfsproc2.c	Process version 2 NFS requests.
3  * linux/fs/nfsd/nfs2proc.c
4  *
5  * Process version 2 NFS requests.
6  *
7  * Copyright (C) 1995-1997 Olaf Kirch <okir@monad.swb.de>
8  */
9 
10 #include <linux/linkage.h>
11 #include <linux/time.h>
12 #include <linux/errno.h>
13 #include <linux/fs.h>
14 #include <linux/stat.h>
15 #include <linux/fcntl.h>
16 #include <linux/net.h>
17 #include <linux/in.h>
18 #include <linux/namei.h>
19 #include <linux/unistd.h>
20 #include <linux/slab.h>
21 
22 #include <linux/sunrpc/svc.h>
23 #include <linux/nfsd/nfsd.h>
24 #include <linux/nfsd/cache.h>
25 #include <linux/nfsd/xdr.h>
26 
27 typedef struct svc_rqst	svc_rqst;
28 typedef struct svc_buf	svc_buf;
29 
30 #define NFSDDBG_FACILITY		NFSDDBG_PROC
31 
32 
33 static int
34 nfsd_proc_null(struct svc_rqst *rqstp, void *argp, void *resp)
35 {
36 	return nfs_ok;
37 }
38 
39 /*
40  * Get a file's attributes
41  * N.B. After this call resp->fh needs an fh_put
42  */
43 static int
44 nfsd_proc_getattr(struct svc_rqst *rqstp, struct nfsd_fhandle  *argp,
45 					  struct nfsd_attrstat *resp)
46 {
47 	dprintk("nfsd: GETATTR  %s\n", SVCFH_fmt(&argp->fh));
48 
49 	fh_copy(&resp->fh, &argp->fh);
50 	return fh_verify(rqstp, &resp->fh, 0, MAY_NOP);
51 }
52 
53 /*
54  * Set a file's attributes
55  * N.B. After this call resp->fh needs an fh_put
56  */
57 static int
58 nfsd_proc_setattr(struct svc_rqst *rqstp, struct nfsd_sattrargs *argp,
59 					  struct nfsd_attrstat  *resp)
60 {
61 	dprintk("nfsd: SETATTR  %s, valid=%x, size=%ld\n",
62 		SVCFH_fmt(&argp->fh),
63 		argp->attrs.ia_valid, (long) argp->attrs.ia_size);
64 
65 	fh_copy(&resp->fh, &argp->fh);
66 	return nfsd_setattr(rqstp, &resp->fh, &argp->attrs,0, (time_t)0);
67 }
68 
69 /*
70  * Look up a path name component
71  * Note: the dentry in the resp->fh may be negative if the file
72  * doesn't exist yet.
73  * N.B. After this call resp->fh needs an fh_put
74  */
75 static int
76 nfsd_proc_lookup(struct svc_rqst *rqstp, struct nfsd_diropargs *argp,
77 					 struct nfsd_diropres  *resp)
78 {
79 	int	nfserr;
80 
81 	dprintk("nfsd: LOOKUP   %s %.*s\n",
82 		SVCFH_fmt(&argp->fh), argp->len, argp->name);
83 
84 	fh_init(&resp->fh, NFS_FHSIZE);
85 	nfserr = nfsd_lookup(rqstp, &argp->fh, argp->name, argp->len,
86 				 &resp->fh);
87 
88 	fh_put(&argp->fh);
89 	return nfserr;
90 }
91 
92 /*
93  * Read a symlink.
94  */
95 static int
96 nfsd_proc_readlink(struct svc_rqst *rqstp, struct nfsd_readlinkargs *argp,
97 					   struct nfsd_readlinkres *resp)
98 {
99 	int	nfserr;
100 
101 	dprintk("nfsd: READLINK %s\n", SVCFH_fmt(&argp->fh));
102 
103 	/* Read the symlink. */
104 	resp->len = NFS_MAXPATHLEN;
105 	nfserr = nfsd_readlink(rqstp, &argp->fh, argp->buffer, &resp->len);
106 
107 	fh_put(&argp->fh);
108 	return nfserr;
109 }
110 
111 /*
112  * Read a portion of a file.
113  * N.B. After this call resp->fh needs an fh_put
114  */
115 static int
116 nfsd_proc_read(struct svc_rqst *rqstp, struct nfsd_readargs *argp,
117 				       struct nfsd_readres  *resp)
118 {
119 	int	nfserr;
120 
121 	dprintk("nfsd: READ    %s %d bytes at %d\n",
122 		SVCFH_fmt(&argp->fh),
123 		argp->count, argp->offset);
124 
125 	/* Obtain buffer pointer for payload. 19 is 1 word for
126 	 * status, 17 words for fattr, and 1 word for the byte count.
127 	 */
128 
129 	if (NFSSVC_MAXBLKSIZE < argp->count) {
130 		printk(KERN_NOTICE
131 			"oversized read request from %u.%u.%u.%u:%d (%d bytes)\n",
132 				NIPQUAD(rqstp->rq_addr.sin_addr.s_addr),
133 				ntohs(rqstp->rq_addr.sin_port),
134 				argp->count);
135 		argp->count = NFSSVC_MAXBLKSIZE;
136 	}
137 	svc_reserve(rqstp, (19<<2) + argp->count + 4);
138 
139 	resp->count = argp->count;
140 	nfserr = nfsd_read(rqstp, fh_copy(&resp->fh, &argp->fh), NULL,
141 				  argp->offset,
142 			   	  argp->vec, argp->vlen,
143 				  &resp->count);
144 
145 	return nfserr;
146 }
147 
148 /*
149  * Write data to a file
150  * N.B. After this call resp->fh needs an fh_put
151  */
152 static int
153 nfsd_proc_write(struct svc_rqst *rqstp, struct nfsd_writeargs *argp,
154 					struct nfsd_attrstat  *resp)
155 {
156 	int	nfserr;
157 	int	stable = 1;
158 
159 	dprintk("nfsd: WRITE    %s %d bytes at %d\n",
160 		SVCFH_fmt(&argp->fh),
161 		argp->len, argp->offset);
162 
163 	nfserr = nfsd_write(rqstp, fh_copy(&resp->fh, &argp->fh), NULL,
164 				   argp->offset,
165 				   argp->vec, argp->vlen,
166 				   argp->len,
167 				   &stable);
168 	return nfserr;
169 }
170 
171 /*
172  * CREATE processing is complicated. The keyword here is `overloaded.'
173  * The parent directory is kept locked between the check for existence
174  * and the actual create() call in compliance with VFS protocols.
175  * N.B. After this call _both_ argp->fh and resp->fh need an fh_put
176  */
177 static int
178 nfsd_proc_create(struct svc_rqst *rqstp, struct nfsd_createargs *argp,
179 					 struct nfsd_diropres   *resp)
180 {
181 	svc_fh		*dirfhp = &argp->fh;
182 	svc_fh		*newfhp = &resp->fh;
183 	struct iattr	*attr = &argp->attrs;
184 	struct inode	*inode;
185 	struct dentry	*dchild;
186 	int		nfserr, type, mode;
187 	dev_t		rdev = 0, wanted = new_decode_dev(attr->ia_size);
188 
189 	dprintk("nfsd: CREATE   %s %.*s\n",
190 		SVCFH_fmt(dirfhp), argp->len, argp->name);
191 
192 	/* First verify the parent file handle */
193 	nfserr = fh_verify(rqstp, dirfhp, S_IFDIR, MAY_EXEC);
194 	if (nfserr)
195 		goto done; /* must fh_put dirfhp even on error */
196 
197 	/* Check for MAY_WRITE in nfsd_create if necessary */
198 
199 	nfserr = nfserr_acces;
200 	if (!argp->len)
201 		goto done;
202 	nfserr = nfserr_exist;
203 	if (isdotent(argp->name, argp->len))
204 		goto done;
205 	fh_lock(dirfhp);
206 	dchild = lookup_one_len(argp->name, dirfhp->fh_dentry, argp->len);
207 	if (IS_ERR(dchild)) {
208 		nfserr = nfserrno(PTR_ERR(dchild));
209 		goto out_unlock;
210 	}
211 	fh_init(newfhp, NFS_FHSIZE);
212 	nfserr = fh_compose(newfhp, dirfhp->fh_export, dchild, dirfhp);
213 	if (!nfserr && !dchild->d_inode)
214 		nfserr = nfserr_noent;
215 	dput(dchild);
216 	if (nfserr) {
217 		if (nfserr != nfserr_noent)
218 			goto out_unlock;
219 		/*
220 		 * If the new file handle wasn't verified, we can't tell
221 		 * whether the file exists or not. Time to bail ...
222 		 */
223 		nfserr = nfserr_acces;
224 		if (!newfhp->fh_dentry) {
225 			printk(KERN_WARNING
226 				"nfsd_proc_create: file handle not verified\n");
227 			goto out_unlock;
228 		}
229 	}
230 
231 	inode = newfhp->fh_dentry->d_inode;
232 
233 	/* Unfudge the mode bits */
234 	if (attr->ia_valid & ATTR_MODE) {
235 		type = attr->ia_mode & S_IFMT;
236 		mode = attr->ia_mode & ~S_IFMT;
237 		if (!type) {
238 			/* no type, so if target exists, assume same as that,
239 			 * else assume a file */
240 			if (inode) {
241 				type = inode->i_mode & S_IFMT;
242 				switch(type) {
243 				case S_IFCHR:
244 				case S_IFBLK:
245 					/* reserve rdev for later checking */
246 					rdev = inode->i_rdev;
247 					attr->ia_valid |= ATTR_SIZE;
248 
249 					/* FALLTHROUGH */
250 				case S_IFIFO:
251 					/* this is probably a permission check..
252 					 * at least IRIX implements perm checking on
253 					 *   echo thing > device-special-file-or-pipe
254 					 * by doing a CREATE with type==0
255 					 */
256 					nfserr = nfsd_permission(newfhp->fh_export,
257 								 newfhp->fh_dentry,
258 								 MAY_WRITE|MAY_LOCAL_ACCESS);
259 					if (nfserr && nfserr != nfserr_rofs)
260 						goto out_unlock;
261 				}
262 			} else
263 				type = S_IFREG;
264 		}
265 	} else if (inode) {
266 		type = inode->i_mode & S_IFMT;
267 		mode = inode->i_mode & ~S_IFMT;
268 	} else {
269 		type = S_IFREG;
270 		mode = 0;	/* ??? */
271 	}
272 
273 	attr->ia_valid |= ATTR_MODE;
274 	attr->ia_mode = mode;
275 
276 	/* Special treatment for non-regular files according to the
277 	 * gospel of sun micro
278 	 */
279 	if (type != S_IFREG) {
280 		int	is_borc = 0;
281 		if (type != S_IFBLK && type != S_IFCHR) {
282 			rdev = 0;
283 		} else if (type == S_IFCHR && !(attr->ia_valid & ATTR_SIZE)) {
284 			/* If you think you've seen the worst, grok this. */
285 			type = S_IFIFO;
286 		} else {
287 			/* Okay, char or block special */
288 			is_borc = 1;
289 			if (!rdev)
290 				rdev = wanted;
291 		}
292 
293 		/* we've used the SIZE information, so discard it */
294 		attr->ia_valid &= ~ATTR_SIZE;
295 
296 		/* Make sure the type and device matches */
297 		nfserr = nfserr_exist;
298 		if (inode && type != (inode->i_mode & S_IFMT))
299 			goto out_unlock;
300 	}
301 
302 	nfserr = 0;
303 	if (!inode) {
304 		/* File doesn't exist. Create it and set attrs */
305 		nfserr = nfsd_create(rqstp, dirfhp, argp->name, argp->len,
306 					attr, type, rdev, newfhp);
307 	} else if (type == S_IFREG) {
308 		dprintk("nfsd:   existing %s, valid=%x, size=%ld\n",
309 			argp->name, attr->ia_valid, (long) attr->ia_size);
310 		/* File already exists. We ignore all attributes except
311 		 * size, so that creat() behaves exactly like
312 		 * open(..., O_CREAT|O_TRUNC|O_WRONLY).
313 		 */
314 		attr->ia_valid &= ATTR_SIZE;
315 		if (attr->ia_valid)
316 			nfserr = nfsd_setattr(rqstp, newfhp, attr, 0, (time_t)0);
317 	}
318 
319 out_unlock:
320 	/* We don't really need to unlock, as fh_put does it. */
321 	fh_unlock(dirfhp);
322 
323 done:
324 	fh_put(dirfhp);
325 	return nfserr;
326 }
327 
328 static int
329 nfsd_proc_remove(struct svc_rqst *rqstp, struct nfsd_diropargs *argp,
330 					 void		       *resp)
331 {
332 	int	nfserr;
333 
334 	dprintk("nfsd: REMOVE   %s %.*s\n", SVCFH_fmt(&argp->fh),
335 		argp->len, argp->name);
336 
337 	/* Unlink. -SIFDIR means file must not be a directory */
338 	nfserr = nfsd_unlink(rqstp, &argp->fh, -S_IFDIR, argp->name, argp->len);
339 	fh_put(&argp->fh);
340 	return nfserr;
341 }
342 
343 static int
344 nfsd_proc_rename(struct svc_rqst *rqstp, struct nfsd_renameargs *argp,
345 				  	 void		        *resp)
346 {
347 	int	nfserr;
348 
349 	dprintk("nfsd: RENAME   %s %.*s -> \n",
350 		SVCFH_fmt(&argp->ffh), argp->flen, argp->fname);
351 	dprintk("nfsd:        ->  %s %.*s\n",
352 		SVCFH_fmt(&argp->tfh), argp->tlen, argp->tname);
353 
354 	nfserr = nfsd_rename(rqstp, &argp->ffh, argp->fname, argp->flen,
355 				    &argp->tfh, argp->tname, argp->tlen);
356 	fh_put(&argp->ffh);
357 	fh_put(&argp->tfh);
358 	return nfserr;
359 }
360 
361 static int
362 nfsd_proc_link(struct svc_rqst *rqstp, struct nfsd_linkargs *argp,
363 				void			    *resp)
364 {
365 	int	nfserr;
366 
367 	dprintk("nfsd: LINK     %s ->\n",
368 		SVCFH_fmt(&argp->ffh));
369 	dprintk("nfsd:    %s %.*s\n",
370 		SVCFH_fmt(&argp->tfh),
371 		argp->tlen,
372 		argp->tname);
373 
374 	nfserr = nfsd_link(rqstp, &argp->tfh, argp->tname, argp->tlen,
375 				  &argp->ffh);
376 	fh_put(&argp->ffh);
377 	fh_put(&argp->tfh);
378 	return nfserr;
379 }
380 
381 static int
382 nfsd_proc_symlink(struct svc_rqst *rqstp, struct nfsd_symlinkargs *argp,
383 				          void			  *resp)
384 {
385 	struct svc_fh	newfh;
386 	int		nfserr;
387 
388 	dprintk("nfsd: SYMLINK  %s %.*s -> %.*s\n",
389 		SVCFH_fmt(&argp->ffh), argp->flen, argp->fname,
390 		argp->tlen, argp->tname);
391 
392 	fh_init(&newfh, NFS_FHSIZE);
393 	/*
394 	 * Create the link, look up new file and set attrs.
395 	 */
396 	nfserr = nfsd_symlink(rqstp, &argp->ffh, argp->fname, argp->flen,
397 						 argp->tname, argp->tlen,
398 				 		 &newfh, &argp->attrs);
399 
400 
401 	fh_put(&argp->ffh);
402 	fh_put(&newfh);
403 	return nfserr;
404 }
405 
406 /*
407  * Make directory. This operation is not idempotent.
408  * N.B. After this call resp->fh needs an fh_put
409  */
410 static int
411 nfsd_proc_mkdir(struct svc_rqst *rqstp, struct nfsd_createargs *argp,
412 					struct nfsd_diropres   *resp)
413 {
414 	int	nfserr;
415 
416 	dprintk("nfsd: MKDIR    %s %.*s\n", SVCFH_fmt(&argp->fh), argp->len, argp->name);
417 
418 	if (resp->fh.fh_dentry) {
419 		printk(KERN_WARNING
420 			"nfsd_proc_mkdir: response already verified??\n");
421 	}
422 
423 	argp->attrs.ia_valid &= ~ATTR_SIZE;
424 	fh_init(&resp->fh, NFS_FHSIZE);
425 	nfserr = nfsd_create(rqstp, &argp->fh, argp->name, argp->len,
426 				    &argp->attrs, S_IFDIR, 0, &resp->fh);
427 	fh_put(&argp->fh);
428 	return nfserr;
429 }
430 
431 /*
432  * Remove a directory
433  */
434 static int
435 nfsd_proc_rmdir(struct svc_rqst *rqstp, struct nfsd_diropargs *argp,
436 				 	void		      *resp)
437 {
438 	int	nfserr;
439 
440 	dprintk("nfsd: RMDIR    %s %.*s\n", SVCFH_fmt(&argp->fh), argp->len, argp->name);
441 
442 	nfserr = nfsd_unlink(rqstp, &argp->fh, S_IFDIR, argp->name, argp->len);
443 	fh_put(&argp->fh);
444 	return nfserr;
445 }
446 
447 /*
448  * Read a portion of a directory.
449  */
450 static int
451 nfsd_proc_readdir(struct svc_rqst *rqstp, struct nfsd_readdirargs *argp,
452 					  struct nfsd_readdirres  *resp)
453 {
454 	int		nfserr, count;
455 	loff_t		offset;
456 
457 	dprintk("nfsd: READDIR  %s %d bytes at %d\n",
458 		SVCFH_fmt(&argp->fh),
459 		argp->count, argp->cookie);
460 
461 	/* Shrink to the client read size */
462 	count = (argp->count >> 2) - 2;
463 
464 	/* Make sure we've room for the NULL ptr & eof flag */
465 	count -= 2;
466 	if (count < 0)
467 		count = 0;
468 
469 	resp->buffer = argp->buffer;
470 	resp->offset = NULL;
471 	resp->buflen = count;
472 	resp->common.err = nfs_ok;
473 	/* Read directory and encode entries on the fly */
474 	offset = argp->cookie;
475 	nfserr = nfsd_readdir(rqstp, &argp->fh, &offset,
476 			      &resp->common, nfssvc_encode_entry);
477 
478 	resp->count = resp->buffer - argp->buffer;
479 	if (resp->offset)
480 		*resp->offset = htonl(offset);
481 
482 	fh_put(&argp->fh);
483 	return nfserr;
484 }
485 
486 /*
487  * Get file system info
488  */
489 static int
490 nfsd_proc_statfs(struct svc_rqst * rqstp, struct nfsd_fhandle   *argp,
491 					  struct nfsd_statfsres *resp)
492 {
493 	int	nfserr;
494 
495 	dprintk("nfsd: STATFS   %s\n", SVCFH_fmt(&argp->fh));
496 
497 	nfserr = nfsd_statfs(rqstp, &argp->fh, &resp->stats);
498 	fh_put(&argp->fh);
499 	return nfserr;
500 }
501 
502 /*
503  * NFSv2 Server procedures.
504  * Only the results of non-idempotent operations are cached.
505  */
506 #define nfsd_proc_none		NULL
507 #define nfssvc_release_none	NULL
508 struct nfsd_void { int dummy; };
509 
510 #define PROC(name, argt, rest, relt, cache, respsize)	\
511  { (svc_procfunc) nfsd_proc_##name,		\
512    (kxdrproc_t) nfssvc_decode_##argt,		\
513    (kxdrproc_t) nfssvc_encode_##rest,		\
514    (kxdrproc_t) nfssvc_release_##relt,		\
515    sizeof(struct nfsd_##argt),			\
516    sizeof(struct nfsd_##rest),			\
517    0,						\
518    cache,					\
519    respsize,				       	\
520  }
521 
522 #define ST 1		/* status */
523 #define FH 8		/* filehandle */
524 #define	AT 18		/* attributes */
525 
526 static struct svc_procedure		nfsd_procedures2[18] = {
527   PROC(null,	 void,		void,		none,		RC_NOCACHE, ST),
528   PROC(getattr,	 fhandle,	attrstat,	fhandle,	RC_NOCACHE, ST+AT),
529   PROC(setattr,  sattrargs,	attrstat,	fhandle,	RC_REPLBUFF, ST+AT),
530   PROC(none,	 void,		void,		none,		RC_NOCACHE, ST),
531   PROC(lookup,	 diropargs,	diropres,	fhandle,	RC_NOCACHE, ST+FH+AT),
532   PROC(readlink, readlinkargs,	readlinkres,	none,		RC_NOCACHE, ST+1+NFS_MAXPATHLEN/4),
533   PROC(read,	 readargs,	readres,	fhandle,	RC_NOCACHE, ST+AT+1+NFSSVC_MAXBLKSIZE),
534   PROC(none,	 void,		void,		none,		RC_NOCACHE, ST),
535   PROC(write,	 writeargs,	attrstat,	fhandle,	RC_REPLBUFF, ST+AT),
536   PROC(create,	 createargs,	diropres,	fhandle,	RC_REPLBUFF, ST+FH+AT),
537   PROC(remove,	 diropargs,	void,		none,		RC_REPLSTAT, ST),
538   PROC(rename,	 renameargs,	void,		none,		RC_REPLSTAT, ST),
539   PROC(link,	 linkargs,	void,		none,		RC_REPLSTAT, ST),
540   PROC(symlink,	 symlinkargs,	void,		none,		RC_REPLSTAT, ST),
541   PROC(mkdir,	 createargs,	diropres,	fhandle,	RC_REPLBUFF, ST+FH+AT),
542   PROC(rmdir,	 diropargs,	void,		none,		RC_REPLSTAT, ST),
543   PROC(readdir,	 readdirargs,	readdirres,	none,		RC_NOCACHE, 0),
544   PROC(statfs,	 fhandle,	statfsres,	none,		RC_NOCACHE, ST+5),
545 };
546 
547 
548 struct svc_version	nfsd_version2 = {
549 		.vs_vers	= 2,
550 		.vs_nproc	= 18,
551 		.vs_proc	= nfsd_procedures2,
552 		.vs_dispatch	= nfsd_dispatch,
553 		.vs_xdrsize	= NFS2_SVC_XDRSIZE,
554 };
555 
556 /*
557  * Map errnos to NFS errnos.
558  */
559 int
560 nfserrno (int errno)
561 {
562 	static struct {
563 		int	nfserr;
564 		int	syserr;
565 	} nfs_errtbl[] = {
566 		{ nfs_ok, 0 },
567 		{ nfserr_perm, -EPERM },
568 		{ nfserr_noent, -ENOENT },
569 		{ nfserr_io, -EIO },
570 		{ nfserr_nxio, -ENXIO },
571 		{ nfserr_acces, -EACCES },
572 		{ nfserr_exist, -EEXIST },
573 		{ nfserr_xdev, -EXDEV },
574 		{ nfserr_mlink, -EMLINK },
575 		{ nfserr_nodev, -ENODEV },
576 		{ nfserr_notdir, -ENOTDIR },
577 		{ nfserr_isdir, -EISDIR },
578 		{ nfserr_inval, -EINVAL },
579 		{ nfserr_fbig, -EFBIG },
580 		{ nfserr_nospc, -ENOSPC },
581 		{ nfserr_rofs, -EROFS },
582 		{ nfserr_mlink, -EMLINK },
583 		{ nfserr_nametoolong, -ENAMETOOLONG },
584 		{ nfserr_notempty, -ENOTEMPTY },
585 #ifdef EDQUOT
586 		{ nfserr_dquot, -EDQUOT },
587 #endif
588 		{ nfserr_stale, -ESTALE },
589 		{ nfserr_jukebox, -ETIMEDOUT },
590 		{ nfserr_dropit, -EAGAIN },
591 		{ nfserr_dropit, -ENOMEM },
592 		{ nfserr_badname, -ESRCH },
593 		{ nfserr_io, -ETXTBSY },
594 		{ nfserr_notsupp, -EOPNOTSUPP },
595 		{ -1, -EIO }
596 	};
597 	int	i;
598 
599 	for (i = 0; nfs_errtbl[i].nfserr != -1; i++) {
600 		if (nfs_errtbl[i].syserr == errno)
601 			return nfs_errtbl[i].nfserr;
602 	}
603 	printk (KERN_INFO "nfsd: non-standard errno: %d\n", errno);
604 	return nfserr_io;
605 }
606 
607