xref: /openbmc/linux/fs/nfsd/nfs4proc.c (revision d5cb9783536a41df9f9cba5b0a1d78047ed787f7)
1 /*
2  *  fs/nfsd/nfs4proc.c
3  *
4  *  Server-side procedures for NFSv4.
5  *
6  *  Copyright (c) 2002 The Regents of the University of Michigan.
7  *  All rights reserved.
8  *
9  *  Kendrick Smith <kmsmith@umich.edu>
10  *  Andy Adamson   <andros@umich.edu>
11  *
12  *  Redistribution and use in source and binary forms, with or without
13  *  modification, are permitted provided that the following conditions
14  *  are met:
15  *
16  *  1. Redistributions of source code must retain the above copyright
17  *     notice, this list of conditions and the following disclaimer.
18  *  2. Redistributions in binary form must reproduce the above copyright
19  *     notice, this list of conditions and the following disclaimer in the
20  *     documentation and/or other materials provided with the distribution.
21  *  3. Neither the name of the University nor the names of its
22  *     contributors may be used to endorse or promote products derived
23  *     from this software without specific prior written permission.
24  *
25  *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
26  *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
27  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
28  *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29  *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
30  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
31  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
32  *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33  *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34  *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35  *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36  *
37  * Note: some routines in this file are just trivial wrappers
38  * (e.g. nfsd4_lookup()) defined solely for the sake of consistent
39  * naming.  Since all such routines have been declared "inline",
40  * there shouldn't be any associated overhead.  At some point in
41  * the future, I might inline these "by hand" to clean up a
42  * little.
43  */
44 
45 #include <linux/param.h>
46 #include <linux/major.h>
47 #include <linux/slab.h>
48 #include <linux/file.h>
49 
50 #include <linux/sunrpc/svc.h>
51 #include <linux/nfsd/nfsd.h>
52 #include <linux/nfsd/cache.h>
53 #include <linux/nfs4.h>
54 #include <linux/nfsd/state.h>
55 #include <linux/nfsd/xdr4.h>
56 #include <linux/nfs4_acl.h>
57 
58 #define NFSDDBG_FACILITY		NFSDDBG_PROC
59 
60 static inline void
61 fh_dup2(struct svc_fh *dst, struct svc_fh *src)
62 {
63 	fh_put(dst);
64 	dget(src->fh_dentry);
65 	if (src->fh_export)
66 		cache_get(&src->fh_export->h);
67 	*dst = *src;
68 }
69 
70 static int
71 do_open_permission(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
72 {
73 	int accmode, status;
74 
75 	if (open->op_truncate &&
76 		!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
77 		return nfserr_inval;
78 
79 	accmode = MAY_NOP;
80 	if (open->op_share_access & NFS4_SHARE_ACCESS_READ)
81 		accmode = MAY_READ;
82 	if (open->op_share_deny & NFS4_SHARE_ACCESS_WRITE)
83 		accmode |= (MAY_WRITE | MAY_TRUNC);
84 	accmode |= MAY_OWNER_OVERRIDE;
85 
86 	status = fh_verify(rqstp, current_fh, S_IFREG, accmode);
87 
88 	return status;
89 }
90 
91 static int
92 do_open_lookup(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
93 {
94 	struct svc_fh resfh;
95 	int status;
96 
97 	fh_init(&resfh, NFS4_FHSIZE);
98 	open->op_truncate = 0;
99 
100 	if (open->op_create) {
101 		/*
102 		 * Note: create modes (UNCHECKED,GUARDED...) are the same
103 		 * in NFSv4 as in v3.
104 		 */
105 		status = nfsd_create_v3(rqstp, current_fh, open->op_fname.data,
106 					open->op_fname.len, &open->op_iattr,
107 					&resfh, open->op_createmode,
108 					(u32 *)open->op_verf.data, &open->op_truncate);
109 	}
110 	else {
111 		status = nfsd_lookup(rqstp, current_fh,
112 				     open->op_fname.data, open->op_fname.len, &resfh);
113 		fh_unlock(current_fh);
114 	}
115 
116 	if (!status) {
117 		set_change_info(&open->op_cinfo, current_fh);
118 
119 		/* set reply cache */
120 		fh_dup2(current_fh, &resfh);
121 		open->op_stateowner->so_replay.rp_openfh_len =
122 			resfh.fh_handle.fh_size;
123 		memcpy(open->op_stateowner->so_replay.rp_openfh,
124 				&resfh.fh_handle.fh_base,
125 				resfh.fh_handle.fh_size);
126 
127 		status = do_open_permission(rqstp, current_fh, open);
128 	}
129 
130 	fh_put(&resfh);
131 	return status;
132 }
133 
134 static int
135 do_open_fhandle(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
136 {
137 	int status;
138 
139 	/* Only reclaims from previously confirmed clients are valid */
140 	if ((status = nfs4_check_open_reclaim(&open->op_clientid)))
141 		return status;
142 
143 	/* We don't know the target directory, and therefore can not
144 	* set the change info
145 	*/
146 
147 	memset(&open->op_cinfo, 0, sizeof(struct nfsd4_change_info));
148 
149 	/* set replay cache */
150 	open->op_stateowner->so_replay.rp_openfh_len = current_fh->fh_handle.fh_size;
151 	memcpy(open->op_stateowner->so_replay.rp_openfh,
152 		&current_fh->fh_handle.fh_base,
153 		current_fh->fh_handle.fh_size);
154 
155 	open->op_truncate = (open->op_iattr.ia_valid & ATTR_SIZE) &&
156 		(open->op_iattr.ia_size == 0);
157 
158 	status = do_open_permission(rqstp, current_fh, open);
159 
160 	return status;
161 }
162 
163 
164 static inline int
165 nfsd4_open(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open, struct nfs4_stateowner **replay_owner)
166 {
167 	int status;
168 	dprintk("NFSD: nfsd4_open filename %.*s op_stateowner %p\n",
169 		(int)open->op_fname.len, open->op_fname.data,
170 		open->op_stateowner);
171 
172 	/* This check required by spec. */
173 	if (open->op_create && open->op_claim_type != NFS4_OPEN_CLAIM_NULL)
174 		return nfserr_inval;
175 
176 	nfs4_lock_state();
177 
178 	/* check seqid for replay. set nfs4_owner */
179 	status = nfsd4_process_open1(open);
180 	if (status == NFSERR_REPLAY_ME) {
181 		struct nfs4_replay *rp = &open->op_stateowner->so_replay;
182 		fh_put(current_fh);
183 		current_fh->fh_handle.fh_size = rp->rp_openfh_len;
184 		memcpy(&current_fh->fh_handle.fh_base, rp->rp_openfh,
185 				rp->rp_openfh_len);
186 		status = fh_verify(rqstp, current_fh, 0, MAY_NOP);
187 		if (status)
188 			dprintk("nfsd4_open: replay failed"
189 				" restoring previous filehandle\n");
190 		else
191 			status = NFSERR_REPLAY_ME;
192 	}
193 	if (status)
194 		goto out;
195 	switch (open->op_claim_type) {
196 		case NFS4_OPEN_CLAIM_DELEGATE_CUR:
197 			status = nfserr_inval;
198 			if (open->op_create)
199 				goto out;
200 			/* fall through */
201 		case NFS4_OPEN_CLAIM_NULL:
202 			/*
203 			 * (1) set CURRENT_FH to the file being opened,
204 			 * creating it if necessary, (2) set open->op_cinfo,
205 			 * (3) set open->op_truncate if the file is to be
206 			 * truncated after opening, (4) do permission checking.
207 			 */
208 			status = do_open_lookup(rqstp, current_fh, open);
209 			if (status)
210 				goto out;
211 			break;
212 		case NFS4_OPEN_CLAIM_PREVIOUS:
213 			/*
214 			 * The CURRENT_FH is already set to the file being
215 			 * opened.  (1) set open->op_cinfo, (2) set
216 			 * open->op_truncate if the file is to be truncated
217 			 * after opening, (3) do permission checking.
218 			*/
219 			status = do_open_fhandle(rqstp, current_fh, open);
220 			if (status)
221 				goto out;
222 			break;
223              	case NFS4_OPEN_CLAIM_DELEGATE_PREV:
224 			printk("NFSD: unsupported OPEN claim type %d\n",
225 				open->op_claim_type);
226 			status = nfserr_notsupp;
227 			goto out;
228 		default:
229 			printk("NFSD: Invalid OPEN claim type %d\n",
230 				open->op_claim_type);
231 			status = nfserr_inval;
232 			goto out;
233 	}
234 	/*
235 	 * nfsd4_process_open2() does the actual opening of the file.  If
236 	 * successful, it (1) truncates the file if open->op_truncate was
237 	 * set, (2) sets open->op_stateid, (3) sets open->op_delegation.
238 	 */
239 	status = nfsd4_process_open2(rqstp, current_fh, open);
240 out:
241 	if (open->op_stateowner) {
242 		nfs4_get_stateowner(open->op_stateowner);
243 		*replay_owner = open->op_stateowner;
244 	}
245 	nfs4_unlock_state();
246 	return status;
247 }
248 
249 /*
250  * filehandle-manipulating ops.
251  */
252 static inline int
253 nfsd4_getfh(struct svc_fh *current_fh, struct svc_fh **getfh)
254 {
255 	if (!current_fh->fh_dentry)
256 		return nfserr_nofilehandle;
257 
258 	*getfh = current_fh;
259 	return nfs_ok;
260 }
261 
262 static inline int
263 nfsd4_putfh(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_putfh *putfh)
264 {
265 	fh_put(current_fh);
266 	current_fh->fh_handle.fh_size = putfh->pf_fhlen;
267 	memcpy(&current_fh->fh_handle.fh_base, putfh->pf_fhval, putfh->pf_fhlen);
268 	return fh_verify(rqstp, current_fh, 0, MAY_NOP);
269 }
270 
271 static inline int
272 nfsd4_putrootfh(struct svc_rqst *rqstp, struct svc_fh *current_fh)
273 {
274 	int status;
275 
276 	fh_put(current_fh);
277 	status = exp_pseudoroot(rqstp->rq_client, current_fh,
278 			      &rqstp->rq_chandle);
279 	if (!status)
280 		status = nfserrno(nfsd_setuser(rqstp, current_fh->fh_export));
281 	return status;
282 }
283 
284 static inline int
285 nfsd4_restorefh(struct svc_fh *current_fh, struct svc_fh *save_fh)
286 {
287 	if (!save_fh->fh_dentry)
288 		return nfserr_restorefh;
289 
290 	fh_dup2(current_fh, save_fh);
291 	return nfs_ok;
292 }
293 
294 static inline int
295 nfsd4_savefh(struct svc_fh *current_fh, struct svc_fh *save_fh)
296 {
297 	if (!current_fh->fh_dentry)
298 		return nfserr_nofilehandle;
299 
300 	fh_dup2(save_fh, current_fh);
301 	return nfs_ok;
302 }
303 
304 /*
305  * misc nfsv4 ops
306  */
307 static inline int
308 nfsd4_access(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_access *access)
309 {
310 	if (access->ac_req_access & ~NFS3_ACCESS_FULL)
311 		return nfserr_inval;
312 
313 	access->ac_resp_access = access->ac_req_access;
314 	return nfsd_access(rqstp, current_fh, &access->ac_resp_access, &access->ac_supported);
315 }
316 
317 static inline int
318 nfsd4_commit(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_commit *commit)
319 {
320 	int status;
321 
322 	u32 *p = (u32 *)commit->co_verf.data;
323 	*p++ = nfssvc_boot.tv_sec;
324 	*p++ = nfssvc_boot.tv_usec;
325 
326 	status = nfsd_commit(rqstp, current_fh, commit->co_offset, commit->co_count);
327 	if (status == nfserr_symlink)
328 		status = nfserr_inval;
329 	return status;
330 }
331 
332 static int
333 nfsd4_create(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_create *create)
334 {
335 	struct svc_fh resfh;
336 	int status;
337 	dev_t rdev;
338 
339 	fh_init(&resfh, NFS4_FHSIZE);
340 
341 	status = fh_verify(rqstp, current_fh, S_IFDIR, MAY_CREATE);
342 	if (status == nfserr_symlink)
343 		status = nfserr_notdir;
344 	if (status)
345 		return status;
346 
347 	switch (create->cr_type) {
348 	case NF4LNK:
349 		/* ugh! we have to null-terminate the linktext, or
350 		 * vfs_symlink() will choke.  it is always safe to
351 		 * null-terminate by brute force, since at worst we
352 		 * will overwrite the first byte of the create namelen
353 		 * in the XDR buffer, which has already been extracted
354 		 * during XDR decode.
355 		 */
356 		create->cr_linkname[create->cr_linklen] = 0;
357 
358 		status = nfsd_symlink(rqstp, current_fh, create->cr_name,
359 				      create->cr_namelen, create->cr_linkname,
360 				      create->cr_linklen, &resfh, &create->cr_iattr);
361 		break;
362 
363 	case NF4BLK:
364 		rdev = MKDEV(create->cr_specdata1, create->cr_specdata2);
365 		if (MAJOR(rdev) != create->cr_specdata1 ||
366 		    MINOR(rdev) != create->cr_specdata2)
367 			return nfserr_inval;
368 		status = nfsd_create(rqstp, current_fh, create->cr_name,
369 				     create->cr_namelen, &create->cr_iattr,
370 				     S_IFBLK, rdev, &resfh);
371 		break;
372 
373 	case NF4CHR:
374 		rdev = MKDEV(create->cr_specdata1, create->cr_specdata2);
375 		if (MAJOR(rdev) != create->cr_specdata1 ||
376 		    MINOR(rdev) != create->cr_specdata2)
377 			return nfserr_inval;
378 		status = nfsd_create(rqstp, current_fh, create->cr_name,
379 				     create->cr_namelen, &create->cr_iattr,
380 				     S_IFCHR, rdev, &resfh);
381 		break;
382 
383 	case NF4SOCK:
384 		status = nfsd_create(rqstp, current_fh, create->cr_name,
385 				     create->cr_namelen, &create->cr_iattr,
386 				     S_IFSOCK, 0, &resfh);
387 		break;
388 
389 	case NF4FIFO:
390 		status = nfsd_create(rqstp, current_fh, create->cr_name,
391 				     create->cr_namelen, &create->cr_iattr,
392 				     S_IFIFO, 0, &resfh);
393 		break;
394 
395 	case NF4DIR:
396 		create->cr_iattr.ia_valid &= ~ATTR_SIZE;
397 		status = nfsd_create(rqstp, current_fh, create->cr_name,
398 				     create->cr_namelen, &create->cr_iattr,
399 				     S_IFDIR, 0, &resfh);
400 		break;
401 
402 	default:
403 		status = nfserr_badtype;
404 	}
405 
406 	if (!status) {
407 		fh_unlock(current_fh);
408 		set_change_info(&create->cr_cinfo, current_fh);
409 		fh_dup2(current_fh, &resfh);
410 	}
411 
412 	fh_put(&resfh);
413 	return status;
414 }
415 
416 static inline int
417 nfsd4_getattr(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_getattr *getattr)
418 {
419 	int status;
420 
421 	status = fh_verify(rqstp, current_fh, 0, MAY_NOP);
422 	if (status)
423 		return status;
424 
425 	if (getattr->ga_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)
426 		return nfserr_inval;
427 
428 	getattr->ga_bmval[0] &= NFSD_SUPPORTED_ATTRS_WORD0;
429 	getattr->ga_bmval[1] &= NFSD_SUPPORTED_ATTRS_WORD1;
430 
431 	getattr->ga_fhp = current_fh;
432 	return nfs_ok;
433 }
434 
435 static inline int
436 nfsd4_link(struct svc_rqst *rqstp, struct svc_fh *current_fh,
437 	   struct svc_fh *save_fh, struct nfsd4_link *link)
438 {
439 	int status = nfserr_nofilehandle;
440 
441 	if (!save_fh->fh_dentry)
442 		return status;
443 	status = nfsd_link(rqstp, current_fh, link->li_name, link->li_namelen, save_fh);
444 	if (!status)
445 		set_change_info(&link->li_cinfo, current_fh);
446 	return status;
447 }
448 
449 static int
450 nfsd4_lookupp(struct svc_rqst *rqstp, struct svc_fh *current_fh)
451 {
452 	struct svc_fh tmp_fh;
453 	int ret;
454 
455 	fh_init(&tmp_fh, NFS4_FHSIZE);
456 	if((ret = exp_pseudoroot(rqstp->rq_client, &tmp_fh,
457 			      &rqstp->rq_chandle)) != 0)
458 		return ret;
459 	if (tmp_fh.fh_dentry == current_fh->fh_dentry) {
460 		fh_put(&tmp_fh);
461 		return nfserr_noent;
462 	}
463 	fh_put(&tmp_fh);
464 	return nfsd_lookup(rqstp, current_fh, "..", 2, current_fh);
465 }
466 
467 static inline int
468 nfsd4_lookup(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_lookup *lookup)
469 {
470 	return nfsd_lookup(rqstp, current_fh, lookup->lo_name, lookup->lo_len, current_fh);
471 }
472 
473 static inline int
474 nfsd4_read(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_read *read)
475 {
476 	int status;
477 
478 	/* no need to check permission - this will be done in nfsd_read() */
479 
480 	read->rd_filp = NULL;
481 	if (read->rd_offset >= OFFSET_MAX)
482 		return nfserr_inval;
483 
484 	nfs4_lock_state();
485 	/* check stateid */
486 	if ((status = nfs4_preprocess_stateid_op(current_fh, &read->rd_stateid,
487 				CHECK_FH | RD_STATE, &read->rd_filp))) {
488 		dprintk("NFSD: nfsd4_read: couldn't process stateid!\n");
489 		goto out;
490 	}
491 	if (read->rd_filp)
492 		get_file(read->rd_filp);
493 	status = nfs_ok;
494 out:
495 	nfs4_unlock_state();
496 	read->rd_rqstp = rqstp;
497 	read->rd_fhp = current_fh;
498 	return status;
499 }
500 
501 static inline int
502 nfsd4_readdir(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_readdir *readdir)
503 {
504 	u64 cookie = readdir->rd_cookie;
505 	static const nfs4_verifier zeroverf;
506 
507 	/* no need to check permission - this will be done in nfsd_readdir() */
508 
509 	if (readdir->rd_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)
510 		return nfserr_inval;
511 
512 	readdir->rd_bmval[0] &= NFSD_SUPPORTED_ATTRS_WORD0;
513 	readdir->rd_bmval[1] &= NFSD_SUPPORTED_ATTRS_WORD1;
514 
515 	if ((cookie > ~(u32)0) || (cookie == 1) || (cookie == 2) ||
516 	    (cookie == 0 && memcmp(readdir->rd_verf.data, zeroverf.data, NFS4_VERIFIER_SIZE)))
517 		return nfserr_bad_cookie;
518 
519 	readdir->rd_rqstp = rqstp;
520 	readdir->rd_fhp = current_fh;
521 	return nfs_ok;
522 }
523 
524 static inline int
525 nfsd4_readlink(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_readlink *readlink)
526 {
527 	readlink->rl_rqstp = rqstp;
528 	readlink->rl_fhp = current_fh;
529 	return nfs_ok;
530 }
531 
532 static inline int
533 nfsd4_remove(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_remove *remove)
534 {
535 	int status;
536 
537 	if (nfs4_in_grace())
538 		return nfserr_grace;
539 	status = nfsd_unlink(rqstp, current_fh, 0, remove->rm_name, remove->rm_namelen);
540 	if (status == nfserr_symlink)
541 		return nfserr_notdir;
542 	if (!status) {
543 		fh_unlock(current_fh);
544 		set_change_info(&remove->rm_cinfo, current_fh);
545 	}
546 	return status;
547 }
548 
549 static inline int
550 nfsd4_rename(struct svc_rqst *rqstp, struct svc_fh *current_fh,
551 	     struct svc_fh *save_fh, struct nfsd4_rename *rename)
552 {
553 	int status = nfserr_nofilehandle;
554 
555 	if (!save_fh->fh_dentry)
556 		return status;
557 	if (nfs4_in_grace() && !(save_fh->fh_export->ex_flags
558 					& NFSEXP_NOSUBTREECHECK))
559 		return nfserr_grace;
560 	status = nfsd_rename(rqstp, save_fh, rename->rn_sname,
561 			     rename->rn_snamelen, current_fh,
562 			     rename->rn_tname, rename->rn_tnamelen);
563 
564 	/* the underlying filesystem returns different error's than required
565 	 * by NFSv4. both save_fh and current_fh have been verified.. */
566 	if (status == nfserr_isdir)
567 		status = nfserr_exist;
568 	else if ((status == nfserr_notdir) &&
569                   (S_ISDIR(save_fh->fh_dentry->d_inode->i_mode) &&
570                    S_ISDIR(current_fh->fh_dentry->d_inode->i_mode)))
571 		status = nfserr_exist;
572 	else if (status == nfserr_symlink)
573 		status = nfserr_notdir;
574 
575 	if (!status) {
576 		set_change_info(&rename->rn_sinfo, current_fh);
577 		set_change_info(&rename->rn_tinfo, save_fh);
578 	}
579 	return status;
580 }
581 
582 static inline int
583 nfsd4_setattr(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_setattr *setattr)
584 {
585 	int status = nfs_ok;
586 
587 	if (!current_fh->fh_dentry)
588 		return nfserr_nofilehandle;
589 
590 	status = nfs_ok;
591 	if (setattr->sa_iattr.ia_valid & ATTR_SIZE) {
592 		nfs4_lock_state();
593 		if ((status = nfs4_preprocess_stateid_op(current_fh,
594 						&setattr->sa_stateid,
595 						CHECK_FH | WR_STATE, NULL))) {
596 			dprintk("NFSD: nfsd4_setattr: couldn't process stateid!\n");
597 			goto out_unlock;
598 		}
599 		nfs4_unlock_state();
600 	}
601 	status = nfs_ok;
602 	if (setattr->sa_acl != NULL)
603 		status = nfsd4_set_nfs4_acl(rqstp, current_fh, setattr->sa_acl);
604 	if (status)
605 		goto out;
606 	status = nfsd_setattr(rqstp, current_fh, &setattr->sa_iattr,
607 				0, (time_t)0);
608 out:
609 	return status;
610 out_unlock:
611 	nfs4_unlock_state();
612 	return status;
613 }
614 
615 static inline int
616 nfsd4_write(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_write *write)
617 {
618 	stateid_t *stateid = &write->wr_stateid;
619 	struct file *filp = NULL;
620 	u32 *p;
621 	int status = nfs_ok;
622 
623 	/* no need to check permission - this will be done in nfsd_write() */
624 
625 	if (write->wr_offset >= OFFSET_MAX)
626 		return nfserr_inval;
627 
628 	nfs4_lock_state();
629 	if ((status = nfs4_preprocess_stateid_op(current_fh, stateid,
630 					CHECK_FH | WR_STATE, &filp))) {
631 		dprintk("NFSD: nfsd4_write: couldn't process stateid!\n");
632 		goto out;
633 	}
634 	if (filp)
635 		get_file(filp);
636 	nfs4_unlock_state();
637 
638 	write->wr_bytes_written = write->wr_buflen;
639 	write->wr_how_written = write->wr_stable_how;
640 	p = (u32 *)write->wr_verifier.data;
641 	*p++ = nfssvc_boot.tv_sec;
642 	*p++ = nfssvc_boot.tv_usec;
643 
644 	status =  nfsd_write(rqstp, current_fh, filp, write->wr_offset,
645 			write->wr_vec, write->wr_vlen, write->wr_buflen,
646 			&write->wr_how_written);
647 	if (filp)
648 		fput(filp);
649 
650 	if (status == nfserr_symlink)
651 		status = nfserr_inval;
652 	return status;
653 out:
654 	nfs4_unlock_state();
655 	return status;
656 }
657 
658 /* This routine never returns NFS_OK!  If there are no other errors, it
659  * will return NFSERR_SAME or NFSERR_NOT_SAME depending on whether the
660  * attributes matched.  VERIFY is implemented by mapping NFSERR_SAME
661  * to NFS_OK after the call; NVERIFY by mapping NFSERR_NOT_SAME to NFS_OK.
662  */
663 static int
664 nfsd4_verify(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_verify *verify)
665 {
666 	u32 *buf, *p;
667 	int count;
668 	int status;
669 
670 	status = fh_verify(rqstp, current_fh, 0, MAY_NOP);
671 	if (status)
672 		return status;
673 
674 	if ((verify->ve_bmval[0] & ~NFSD_SUPPORTED_ATTRS_WORD0)
675 	    || (verify->ve_bmval[1] & ~NFSD_SUPPORTED_ATTRS_WORD1))
676 		return nfserr_attrnotsupp;
677 	if ((verify->ve_bmval[0] & FATTR4_WORD0_RDATTR_ERROR)
678 	    || (verify->ve_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1))
679 		return nfserr_inval;
680 	if (verify->ve_attrlen & 3)
681 		return nfserr_inval;
682 
683 	/* count in words:
684 	 *   bitmap_len(1) + bitmap(2) + attr_len(1) = 4
685 	 */
686 	count = 4 + (verify->ve_attrlen >> 2);
687 	buf = kmalloc(count << 2, GFP_KERNEL);
688 	if (!buf)
689 		return nfserr_resource;
690 
691 	status = nfsd4_encode_fattr(current_fh, current_fh->fh_export,
692 				    current_fh->fh_dentry, buf,
693 				    &count, verify->ve_bmval,
694 				    rqstp);
695 
696 	/* this means that nfsd4_encode_fattr() ran out of space */
697 	if (status == nfserr_resource && count == 0)
698 		status = nfserr_not_same;
699 	if (status)
700 		goto out_kfree;
701 
702 	p = buf + 3;
703 	status = nfserr_not_same;
704 	if (ntohl(*p++) != verify->ve_attrlen)
705 		goto out_kfree;
706 	if (!memcmp(p, verify->ve_attrval, verify->ve_attrlen))
707 		status = nfserr_same;
708 
709 out_kfree:
710 	kfree(buf);
711 	return status;
712 }
713 
714 /*
715  * NULL call.
716  */
717 static int
718 nfsd4_proc_null(struct svc_rqst *rqstp, void *argp, void *resp)
719 {
720 	return nfs_ok;
721 }
722 
723 
724 /*
725  * COMPOUND call.
726  */
727 static int
728 nfsd4_proc_compound(struct svc_rqst *rqstp,
729 		    struct nfsd4_compoundargs *args,
730 		    struct nfsd4_compoundres *resp)
731 {
732 	struct nfsd4_op	*op;
733 	struct svc_fh	*current_fh = NULL;
734 	struct svc_fh	*save_fh = NULL;
735 	struct nfs4_stateowner *replay_owner = NULL;
736 	int		slack_space;    /* in words, not bytes! */
737 	int		status;
738 
739 	status = nfserr_resource;
740 	current_fh = kmalloc(sizeof(*current_fh), GFP_KERNEL);
741 	if (current_fh == NULL)
742 		goto out;
743 	fh_init(current_fh, NFS4_FHSIZE);
744 	save_fh = kmalloc(sizeof(*save_fh), GFP_KERNEL);
745 	if (save_fh == NULL)
746 		goto out;
747 	fh_init(save_fh, NFS4_FHSIZE);
748 
749 	resp->xbuf = &rqstp->rq_res;
750 	resp->p = rqstp->rq_res.head[0].iov_base + rqstp->rq_res.head[0].iov_len;
751 	resp->tagp = resp->p;
752 	/* reserve space for: taglen, tag, and opcnt */
753 	resp->p += 2 + XDR_QUADLEN(args->taglen);
754 	resp->end = rqstp->rq_res.head[0].iov_base + PAGE_SIZE;
755 	resp->taglen = args->taglen;
756 	resp->tag = args->tag;
757 	resp->opcnt = 0;
758 	resp->rqstp = rqstp;
759 
760 	/*
761 	 * According to RFC3010, this takes precedence over all other errors.
762 	 */
763 	status = nfserr_minor_vers_mismatch;
764 	if (args->minorversion > NFSD_SUPPORTED_MINOR_VERSION)
765 		goto out;
766 
767 	status = nfs_ok;
768 	while (!status && resp->opcnt < args->opcnt) {
769 		op = &args->ops[resp->opcnt++];
770 
771 		/*
772 		 * The XDR decode routines may have pre-set op->status;
773 		 * for example, if there is a miscellaneous XDR error
774 		 * it will be set to nfserr_bad_xdr.
775 		 */
776 		if (op->status)
777 			goto encode_op;
778 
779 		/* We must be able to encode a successful response to
780 		 * this operation, with enough room left over to encode a
781 		 * failed response to the next operation.  If we don't
782 		 * have enough room, fail with ERR_RESOURCE.
783 		 */
784 /* FIXME - is slack_space *really* words, or bytes??? - neilb */
785 		slack_space = (char *)resp->end - (char *)resp->p;
786 		if (slack_space < COMPOUND_SLACK_SPACE + COMPOUND_ERR_SLACK_SPACE) {
787 			BUG_ON(slack_space < COMPOUND_ERR_SLACK_SPACE);
788 			op->status = nfserr_resource;
789 			goto encode_op;
790 		}
791 
792 		/* All operations except RENEW, SETCLIENTID, RESTOREFH
793 		* SETCLIENTID_CONFIRM, PUTFH and PUTROOTFH
794 		* require a valid current filehandle
795 		*
796 		* SETATTR NOFILEHANDLE error handled in nfsd4_setattr
797 		* due to required returned bitmap argument
798 		*/
799 		if ((!current_fh->fh_dentry) &&
800 		   !((op->opnum == OP_PUTFH) || (op->opnum == OP_PUTROOTFH) ||
801 		   (op->opnum == OP_SETCLIENTID) ||
802 		   (op->opnum == OP_SETCLIENTID_CONFIRM) ||
803 		   (op->opnum == OP_RENEW) || (op->opnum == OP_RESTOREFH) ||
804 		   (op->opnum == OP_RELEASE_LOCKOWNER) ||
805 		   (op->opnum == OP_SETATTR))) {
806 			op->status = nfserr_nofilehandle;
807 			goto encode_op;
808 		}
809 		switch (op->opnum) {
810 		case OP_ACCESS:
811 			op->status = nfsd4_access(rqstp, current_fh, &op->u.access);
812 			break;
813 		case OP_CLOSE:
814 			op->status = nfsd4_close(rqstp, current_fh, &op->u.close, &replay_owner);
815 			break;
816 		case OP_COMMIT:
817 			op->status = nfsd4_commit(rqstp, current_fh, &op->u.commit);
818 			break;
819 		case OP_CREATE:
820 			op->status = nfsd4_create(rqstp, current_fh, &op->u.create);
821 			break;
822 		case OP_DELEGRETURN:
823 			op->status = nfsd4_delegreturn(rqstp, current_fh, &op->u.delegreturn);
824 			break;
825 		case OP_GETATTR:
826 			op->status = nfsd4_getattr(rqstp, current_fh, &op->u.getattr);
827 			break;
828 		case OP_GETFH:
829 			op->status = nfsd4_getfh(current_fh, &op->u.getfh);
830 			break;
831 		case OP_LINK:
832 			op->status = nfsd4_link(rqstp, current_fh, save_fh, &op->u.link);
833 			break;
834 		case OP_LOCK:
835 			op->status = nfsd4_lock(rqstp, current_fh, &op->u.lock, &replay_owner);
836 			break;
837 		case OP_LOCKT:
838 			op->status = nfsd4_lockt(rqstp, current_fh, &op->u.lockt);
839 			break;
840 		case OP_LOCKU:
841 			op->status = nfsd4_locku(rqstp, current_fh, &op->u.locku, &replay_owner);
842 			break;
843 		case OP_LOOKUP:
844 			op->status = nfsd4_lookup(rqstp, current_fh, &op->u.lookup);
845 			break;
846 		case OP_LOOKUPP:
847 			op->status = nfsd4_lookupp(rqstp, current_fh);
848 			break;
849 		case OP_NVERIFY:
850 			op->status = nfsd4_verify(rqstp, current_fh, &op->u.nverify);
851 			if (op->status == nfserr_not_same)
852 				op->status = nfs_ok;
853 			break;
854 		case OP_OPEN:
855 			op->status = nfsd4_open(rqstp, current_fh, &op->u.open, &replay_owner);
856 			break;
857 		case OP_OPEN_CONFIRM:
858 			op->status = nfsd4_open_confirm(rqstp, current_fh, &op->u.open_confirm, &replay_owner);
859 			break;
860 		case OP_OPEN_DOWNGRADE:
861 			op->status = nfsd4_open_downgrade(rqstp, current_fh, &op->u.open_downgrade, &replay_owner);
862 			break;
863 		case OP_PUTFH:
864 			op->status = nfsd4_putfh(rqstp, current_fh, &op->u.putfh);
865 			break;
866 		case OP_PUTROOTFH:
867 			op->status = nfsd4_putrootfh(rqstp, current_fh);
868 			break;
869 		case OP_READ:
870 			op->status = nfsd4_read(rqstp, current_fh, &op->u.read);
871 			break;
872 		case OP_READDIR:
873 			op->status = nfsd4_readdir(rqstp, current_fh, &op->u.readdir);
874 			break;
875 		case OP_READLINK:
876 			op->status = nfsd4_readlink(rqstp, current_fh, &op->u.readlink);
877 			break;
878 		case OP_REMOVE:
879 			op->status = nfsd4_remove(rqstp, current_fh, &op->u.remove);
880 			break;
881 		case OP_RENAME:
882 			op->status = nfsd4_rename(rqstp, current_fh, save_fh, &op->u.rename);
883 			break;
884 		case OP_RENEW:
885 			op->status = nfsd4_renew(&op->u.renew);
886 			break;
887 		case OP_RESTOREFH:
888 			op->status = nfsd4_restorefh(current_fh, save_fh);
889 			break;
890 		case OP_SAVEFH:
891 			op->status = nfsd4_savefh(current_fh, save_fh);
892 			break;
893 		case OP_SETATTR:
894 			op->status = nfsd4_setattr(rqstp, current_fh, &op->u.setattr);
895 			break;
896 		case OP_SETCLIENTID:
897 			op->status = nfsd4_setclientid(rqstp, &op->u.setclientid);
898 			break;
899 		case OP_SETCLIENTID_CONFIRM:
900 			op->status = nfsd4_setclientid_confirm(rqstp, &op->u.setclientid_confirm);
901 			break;
902 		case OP_VERIFY:
903 			op->status = nfsd4_verify(rqstp, current_fh, &op->u.verify);
904 			if (op->status == nfserr_same)
905 				op->status = nfs_ok;
906 			break;
907 		case OP_WRITE:
908 			op->status = nfsd4_write(rqstp, current_fh, &op->u.write);
909 			break;
910 		case OP_RELEASE_LOCKOWNER:
911 			op->status = nfsd4_release_lockowner(rqstp, &op->u.release_lockowner);
912 			break;
913 		default:
914 			BUG_ON(op->status == nfs_ok);
915 			break;
916 		}
917 
918 encode_op:
919 		if (op->status == NFSERR_REPLAY_ME) {
920 			op->replay = &replay_owner->so_replay;
921 			nfsd4_encode_replay(resp, op);
922 			status = op->status = op->replay->rp_status;
923 		} else {
924 			nfsd4_encode_operation(resp, op);
925 			status = op->status;
926 		}
927 		if (replay_owner && (replay_owner != (void *)(-1))) {
928 			nfs4_put_stateowner(replay_owner);
929 			replay_owner = NULL;
930 		}
931 		/* XXX Ugh, we need to get rid of this kind of special case: */
932 		if (op->opnum == OP_READ && op->u.read.rd_filp)
933 			fput(op->u.read.rd_filp);
934 	}
935 
936 out:
937 	nfsd4_release_compoundargs(args);
938 	if (current_fh)
939 		fh_put(current_fh);
940 	kfree(current_fh);
941 	if (save_fh)
942 		fh_put(save_fh);
943 	kfree(save_fh);
944 	return status;
945 }
946 
947 #define nfs4svc_decode_voidargs		NULL
948 #define nfs4svc_release_void		NULL
949 #define nfsd4_voidres			nfsd4_voidargs
950 #define nfs4svc_release_compound	NULL
951 struct nfsd4_voidargs { int dummy; };
952 
953 #define PROC(name, argt, rest, relt, cache, respsize)	\
954  { (svc_procfunc) nfsd4_proc_##name,		\
955    (kxdrproc_t) nfs4svc_decode_##argt##args,	\
956    (kxdrproc_t) nfs4svc_encode_##rest##res,	\
957    (kxdrproc_t) nfs4svc_release_##relt,		\
958    sizeof(struct nfsd4_##argt##args),		\
959    sizeof(struct nfsd4_##rest##res),		\
960    0,						\
961    cache,					\
962    respsize,					\
963  }
964 
965 /*
966  * TODO: At the present time, the NFSv4 server does not do XID caching
967  * of requests.  Implementing XID caching would not be a serious problem,
968  * although it would require a mild change in interfaces since one
969  * doesn't know whether an NFSv4 request is idempotent until after the
970  * XDR decode.  However, XID caching totally confuses pynfs (Peter
971  * Astrand's regression testsuite for NFSv4 servers), which reuses
972  * XID's liberally, so I've left it unimplemented until pynfs generates
973  * better XID's.
974  */
975 static struct svc_procedure		nfsd_procedures4[2] = {
976   PROC(null,	 void,		void,		void,	  RC_NOCACHE, 1),
977   PROC(compound, compound,	compound,	compound, RC_NOCACHE, NFSD_BUFSIZE)
978 };
979 
980 struct svc_version	nfsd_version4 = {
981 		.vs_vers	= 4,
982 		.vs_nproc	= 2,
983 		.vs_proc	= nfsd_procedures4,
984 		.vs_dispatch	= nfsd_dispatch,
985 		.vs_xdrsize	= NFS4_SVC_XDRSIZE,
986 };
987 
988 /*
989  * Local variables:
990  *  c-basic-offset: 8
991  * End:
992  */
993