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