Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
nfs4proc.c
Go to the documentation of this file.
1 /*
2  * Server-side procedures for NFSv4.
3  *
4  * Copyright (c) 2002 The Regents of the University of Michigan.
5  * All rights reserved.
6  *
7  * Kendrick Smith <[email protected]>
8  * Andy Adamson <[email protected]>
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  *
14  * 1. Redistributions of source code must retain the above copyright
15  * notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  * notice, this list of conditions and the following disclaimer in the
18  * documentation and/or other materials provided with the distribution.
19  * 3. Neither the name of the University nor the names of its
20  * contributors may be used to endorse or promote products derived
21  * from this software without specific prior written permission.
22  *
23  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
24  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
25  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26  * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
28  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
29  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
30  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
31  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
32  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
33  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34  */
35 #include <linux/file.h>
36 #include <linux/slab.h>
37 
38 #include "idmap.h"
39 #include "cache.h"
40 #include "xdr4.h"
41 #include "vfs.h"
42 #include "current_stateid.h"
43 
44 #define NFSDDBG_FACILITY NFSDDBG_PROC
45 
46 static u32 nfsd_attrmask[] = {
47  NFSD_WRITEABLE_ATTRS_WORD0,
48  NFSD_WRITEABLE_ATTRS_WORD1,
49  NFSD_WRITEABLE_ATTRS_WORD2
50 };
51 
52 static u32 nfsd41_ex_attrmask[] = {
53  NFSD_SUPPATTR_EXCLCREAT_WORD0,
54  NFSD_SUPPATTR_EXCLCREAT_WORD1,
55  NFSD_SUPPATTR_EXCLCREAT_WORD2
56 };
57 
58 static __be32
59 check_attr_support(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
60  u32 *bmval, u32 *writable)
61 {
62  struct dentry *dentry = cstate->current_fh.fh_dentry;
63 
64  /*
65  * Check about attributes are supported by the NFSv4 server or not.
66  * According to spec, unsupported attributes return ERR_ATTRNOTSUPP.
67  */
68  if ((bmval[0] & ~nfsd_suppattrs0(cstate->minorversion)) ||
69  (bmval[1] & ~nfsd_suppattrs1(cstate->minorversion)) ||
70  (bmval[2] & ~nfsd_suppattrs2(cstate->minorversion)))
71  return nfserr_attrnotsupp;
72 
73  /*
74  * Check FATTR4_WORD0_ACL can be supported
75  * in current environment or not.
76  */
77  if (bmval[0] & FATTR4_WORD0_ACL) {
78  if (!IS_POSIXACL(dentry->d_inode))
79  return nfserr_attrnotsupp;
80  }
81 
82  /*
83  * According to spec, read-only attributes return ERR_INVAL.
84  */
85  if (writable) {
86  if ((bmval[0] & ~writable[0]) || (bmval[1] & ~writable[1]) ||
87  (bmval[2] & ~writable[2]))
88  return nfserr_inval;
89  }
90 
91  return nfs_ok;
92 }
93 
94 static __be32
95 nfsd4_check_open_attributes(struct svc_rqst *rqstp,
96  struct nfsd4_compound_state *cstate, struct nfsd4_open *open)
97 {
99 
100  if (open->op_create == NFS4_OPEN_CREATE) {
103  status = check_attr_support(rqstp, cstate,
104  open->op_bmval, nfsd_attrmask);
105  else if (open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1)
106  status = check_attr_support(rqstp, cstate,
107  open->op_bmval, nfsd41_ex_attrmask);
108  }
109 
110  return status;
111 }
112 
113 static int
114 is_create_with_attrs(struct nfsd4_open *open)
115 {
116  return open->op_create == NFS4_OPEN_CREATE
120 }
121 
122 /*
123  * if error occurs when setting the acl, just clear the acl bit
124  * in the returned attr bitmap.
125  */
126 static void
127 do_set_nfs4_acl(struct svc_rqst *rqstp, struct svc_fh *fhp,
128  struct nfs4_acl *acl, u32 *bmval)
129 {
130  __be32 status;
131 
132  status = nfsd4_set_nfs4_acl(rqstp, fhp, acl);
133  if (status)
134  /*
135  * We should probably fail the whole open at this point,
136  * but we've already created the file, so it's too late;
137  * So this seems the least of evils:
138  */
139  bmval[0] &= ~FATTR4_WORD0_ACL;
140 }
141 
142 static inline void
143 fh_dup2(struct svc_fh *dst, struct svc_fh *src)
144 {
145  fh_put(dst);
146  dget(src->fh_dentry);
147  if (src->fh_export)
148  cache_get(&src->fh_export->h);
149  *dst = *src;
150 }
151 
152 static __be32
153 do_open_permission(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open, int accmode)
154 {
155  __be32 status;
156 
157  if (open->op_truncate &&
159  return nfserr_inval;
160 
161  accmode |= NFSD_MAY_READ_IF_EXEC;
162 
164  accmode |= NFSD_MAY_READ;
166  accmode |= (NFSD_MAY_WRITE | NFSD_MAY_TRUNC);
168  accmode |= NFSD_MAY_WRITE;
169 
170  status = fh_verify(rqstp, current_fh, S_IFREG, accmode);
171 
172  return status;
173 }
174 
175 static __be32 nfsd_check_obj_isreg(struct svc_fh *fh)
176 {
177  umode_t mode = fh->fh_dentry->d_inode->i_mode;
178 
179  if (S_ISREG(mode))
180  return nfs_ok;
181  if (S_ISDIR(mode))
182  return nfserr_isdir;
183  /*
184  * Using err_symlink as our catch-all case may look odd; but
185  * there's no other obvious error for this case in 4.0, and we
186  * happen to know that it will cause the linux v4 client to do
187  * the right thing on attempts to open something other than a
188  * regular file.
189  */
190  return nfserr_symlink;
191 }
192 
193 static __be32
194 do_open_lookup(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
195 {
196  struct svc_fh *resfh;
197  __be32 status;
198 
199  resfh = kmalloc(sizeof(struct svc_fh), GFP_KERNEL);
200  if (!resfh)
201  return nfserr_jukebox;
202  fh_init(resfh, NFS4_FHSIZE);
203  open->op_truncate = 0;
204 
205  if (open->op_create) {
206  /* FIXME: check session persistence and pnfs flags.
207  * The nfsv4.1 spec requires the following semantics:
208  *
209  * Persistent | pNFS | Server REQUIRED | Client Allowed
210  * Reply Cache | server | |
211  * -------------+--------+-----------------+--------------------
212  * no | no | EXCLUSIVE4_1 | EXCLUSIVE4_1
213  * | | | (SHOULD)
214  * | | and EXCLUSIVE4 | or EXCLUSIVE4
215  * | | | (SHOULD NOT)
216  * no | yes | EXCLUSIVE4_1 | EXCLUSIVE4_1
217  * yes | no | GUARDED4 | GUARDED4
218  * yes | yes | GUARDED4 | GUARDED4
219  */
220 
221  /*
222  * Note: create modes (UNCHECKED,GUARDED...) are the same
223  * in NFSv4 as in v3 except EXCLUSIVE4_1.
224  */
225  status = do_nfsd_create(rqstp, current_fh, open->op_fname.data,
226  open->op_fname.len, &open->op_iattr,
227  resfh, open->op_createmode,
228  (u32 *)open->op_verf.data,
229  &open->op_truncate, &open->op_created);
230 
231  /*
232  * Following rfc 3530 14.2.16, use the returned bitmask
233  * to indicate which attributes we used to store the
234  * verifier:
235  */
236  if (open->op_createmode == NFS4_CREATE_EXCLUSIVE && status == 0)
237  open->op_bmval[1] = (FATTR4_WORD1_TIME_ACCESS |
239  } else {
240  status = nfsd_lookup(rqstp, current_fh,
241  open->op_fname.data, open->op_fname.len, resfh);
242  fh_unlock(current_fh);
243  }
244  if (status)
245  goto out;
246  status = nfsd_check_obj_isreg(resfh);
247  if (status)
248  goto out;
249 
250  if (is_create_with_attrs(open) && open->op_acl != NULL)
251  do_set_nfs4_acl(rqstp, resfh, open->op_acl, open->op_bmval);
252 
253  /* set reply cache */
254  fh_copy_shallow(&open->op_openowner->oo_owner.so_replay.rp_openfh,
255  &resfh->fh_handle);
256  if (!open->op_created)
257  status = do_open_permission(rqstp, resfh, open,
258  NFSD_MAY_NOP);
259  set_change_info(&open->op_cinfo, current_fh);
260  fh_dup2(current_fh, resfh);
261 out:
262  fh_put(resfh);
263  kfree(resfh);
264  return status;
265 }
266 
267 static __be32
268 do_open_fhandle(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
269 {
270  __be32 status;
271 
272  /* We don't know the target directory, and therefore can not
273  * set the change info
274  */
275 
276  memset(&open->op_cinfo, 0, sizeof(struct nfsd4_change_info));
277 
278  /* set replay cache */
279  fh_copy_shallow(&open->op_openowner->oo_owner.so_replay.rp_openfh,
280  &current_fh->fh_handle);
281 
282  open->op_truncate = (open->op_iattr.ia_valid & ATTR_SIZE) &&
283  (open->op_iattr.ia_size == 0);
284 
285  status = do_open_permission(rqstp, current_fh, open,
287 
288  return status;
289 }
290 
291 static void
292 copy_clientid(clientid_t *clid, struct nfsd4_session *session)
293 {
294  struct nfsd4_sessionid *sid =
295  (struct nfsd4_sessionid *)session->se_sessionid.data;
296 
297  clid->cl_boot = sid->clientid.cl_boot;
298  clid->cl_id = sid->clientid.cl_id;
299 }
300 
301 static __be32
302 nfsd4_open(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
303  struct nfsd4_open *open)
304 {
305  __be32 status;
306  struct nfsd4_compoundres *resp;
307 
308  dprintk("NFSD: nfsd4_open filename %.*s op_openowner %p\n",
309  (int)open->op_fname.len, open->op_fname.data,
310  open->op_openowner);
311 
312  /* This check required by spec. */
313  if (open->op_create && open->op_claim_type != NFS4_OPEN_CLAIM_NULL)
314  return nfserr_inval;
315 
316  open->op_created = 0;
317  /*
318  * RFC5661 18.51.3
319  * Before RECLAIM_COMPLETE done, server should deny new lock
320  */
321  if (nfsd4_has_session(cstate) &&
323  &cstate->session->se_client->cl_flags) &&
325  return nfserr_grace;
326 
327  if (nfsd4_has_session(cstate))
328  copy_clientid(&open->op_clientid, cstate->session);
329 
330  nfs4_lock_state();
331 
332  /* check seqid for replay. set nfs4_owner */
333  resp = rqstp->rq_resp;
334  status = nfsd4_process_open1(&resp->cstate, open);
335  if (status == nfserr_replay_me) {
336  struct nfs4_replay *rp = &open->op_openowner->oo_owner.so_replay;
337  fh_put(&cstate->current_fh);
338  fh_copy_shallow(&cstate->current_fh.fh_handle,
339  &rp->rp_openfh);
340  status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
341  if (status)
342  dprintk("nfsd4_open: replay failed"
343  " restoring previous filehandle\n");
344  else
345  status = nfserr_replay_me;
346  }
347  if (status)
348  goto out;
349 
350  status = nfsd4_check_open_attributes(rqstp, cstate, open);
351  if (status)
352  goto out;
353 
354  /* Openowner is now set, so sequence id will get bumped. Now we need
355  * these checks before we do any creates: */
356  status = nfserr_grace;
358  goto out;
359  status = nfserr_no_grace;
361  goto out;
362 
363  switch (open->op_claim_type) {
366  status = do_open_lookup(rqstp, &cstate->current_fh,
367  open);
368  if (status)
369  goto out;
370  break;
372  open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
373  status = nfs4_check_open_reclaim(&open->op_clientid, cstate->minorversion);
374  if (status)
375  goto out;
376  case NFS4_OPEN_CLAIM_FH:
378  status = do_open_fhandle(rqstp, &cstate->current_fh,
379  open);
380  if (status)
381  goto out;
382  break;
385  open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
386  dprintk("NFSD: unsupported OPEN claim type %d\n",
387  open->op_claim_type);
388  status = nfserr_notsupp;
389  goto out;
390  default:
391  dprintk("NFSD: Invalid OPEN claim type %d\n",
392  open->op_claim_type);
393  status = nfserr_inval;
394  goto out;
395  }
396  /*
397  * nfsd4_process_open2() does the actual opening of the file. If
398  * successful, it (1) truncates the file if open->op_truncate was
399  * set, (2) sets open->op_stateid, (3) sets open->op_delegation.
400  */
401  status = nfsd4_process_open2(rqstp, &cstate->current_fh, open);
402  WARN_ON(status && open->op_created);
403 out:
404  nfsd4_cleanup_open_state(open, status);
405  if (open->op_openowner)
406  cstate->replay_owner = &open->op_openowner->oo_owner;
407  else
409  return status;
410 }
411 
412 /*
413  * filehandle-manipulating ops.
414  */
415 static __be32
416 nfsd4_getfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
417  struct svc_fh **getfh)
418 {
419  if (!cstate->current_fh.fh_dentry)
420  return nfserr_nofilehandle;
421 
422  *getfh = &cstate->current_fh;
423  return nfs_ok;
424 }
425 
426 static __be32
427 nfsd4_putfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
428  struct nfsd4_putfh *putfh)
429 {
430  fh_put(&cstate->current_fh);
431  cstate->current_fh.fh_handle.fh_size = putfh->pf_fhlen;
432  memcpy(&cstate->current_fh.fh_handle.fh_base, putfh->pf_fhval,
433  putfh->pf_fhlen);
434  return fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_BYPASS_GSS);
435 }
436 
437 static __be32
438 nfsd4_putrootfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
439  void *arg)
440 {
441  __be32 status;
442 
443  fh_put(&cstate->current_fh);
444  status = exp_pseudoroot(rqstp, &cstate->current_fh);
445  return status;
446 }
447 
448 static __be32
449 nfsd4_restorefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
450  void *arg)
451 {
452  if (!cstate->save_fh.fh_dentry)
453  return nfserr_restorefh;
454 
455  fh_dup2(&cstate->current_fh, &cstate->save_fh);
456  if (HAS_STATE_ID(cstate, SAVED_STATE_ID_FLAG)) {
457  memcpy(&cstate->current_stateid, &cstate->save_stateid, sizeof(stateid_t));
459  }
460  return nfs_ok;
461 }
462 
463 static __be32
464 nfsd4_savefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
465  void *arg)
466 {
467  if (!cstate->current_fh.fh_dentry)
468  return nfserr_nofilehandle;
469 
470  fh_dup2(&cstate->save_fh, &cstate->current_fh);
471  if (HAS_STATE_ID(cstate, CURRENT_STATE_ID_FLAG)) {
472  memcpy(&cstate->save_stateid, &cstate->current_stateid, sizeof(stateid_t));
474  }
475  return nfs_ok;
476 }
477 
478 /*
479  * misc nfsv4 ops
480  */
481 static __be32
482 nfsd4_access(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
483  struct nfsd4_access *access)
484 {
485  if (access->ac_req_access & ~NFS3_ACCESS_FULL)
486  return nfserr_inval;
487 
488  access->ac_resp_access = access->ac_req_access;
489  return nfsd_access(rqstp, &cstate->current_fh, &access->ac_resp_access,
490  &access->ac_supported);
491 }
492 
493 static void gen_boot_verifier(nfs4_verifier *verifier)
494 {
495  __be32 verf[2];
496 
497  verf[0] = (__be32)nfssvc_boot.tv_sec;
498  verf[1] = (__be32)nfssvc_boot.tv_usec;
499  memcpy(verifier->data, verf, sizeof(verifier->data));
500 }
501 
502 static __be32
503 nfsd4_commit(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
504  struct nfsd4_commit *commit)
505 {
506  gen_boot_verifier(&commit->co_verf);
507  return nfsd_commit(rqstp, &cstate->current_fh, commit->co_offset,
508  commit->co_count);
509 }
510 
511 static __be32
512 nfsd4_create(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
513  struct nfsd4_create *create)
514 {
515  struct svc_fh resfh;
516  __be32 status;
517  dev_t rdev;
518 
519  fh_init(&resfh, NFS4_FHSIZE);
520 
521  status = fh_verify(rqstp, &cstate->current_fh, S_IFDIR,
523  if (status)
524  return status;
525 
526  status = check_attr_support(rqstp, cstate, create->cr_bmval,
527  nfsd_attrmask);
528  if (status)
529  return status;
530 
531  switch (create->cr_type) {
532  case NF4LNK:
533  /* ugh! we have to null-terminate the linktext, or
534  * vfs_symlink() will choke. it is always safe to
535  * null-terminate by brute force, since at worst we
536  * will overwrite the first byte of the create namelen
537  * in the XDR buffer, which has already been extracted
538  * during XDR decode.
539  */
540  create->cr_linkname[create->cr_linklen] = 0;
541 
542  status = nfsd_symlink(rqstp, &cstate->current_fh,
543  create->cr_name, create->cr_namelen,
544  create->cr_linkname, create->cr_linklen,
545  &resfh, &create->cr_iattr);
546  break;
547 
548  case NF4BLK:
549  rdev = MKDEV(create->cr_specdata1, create->cr_specdata2);
550  if (MAJOR(rdev) != create->cr_specdata1 ||
551  MINOR(rdev) != create->cr_specdata2)
552  return nfserr_inval;
553  status = nfsd_create(rqstp, &cstate->current_fh,
554  create->cr_name, create->cr_namelen,
555  &create->cr_iattr, S_IFBLK, rdev, &resfh);
556  break;
557 
558  case NF4CHR:
559  rdev = MKDEV(create->cr_specdata1, create->cr_specdata2);
560  if (MAJOR(rdev) != create->cr_specdata1 ||
561  MINOR(rdev) != create->cr_specdata2)
562  return nfserr_inval;
563  status = nfsd_create(rqstp, &cstate->current_fh,
564  create->cr_name, create->cr_namelen,
565  &create->cr_iattr,S_IFCHR, rdev, &resfh);
566  break;
567 
568  case NF4SOCK:
569  status = nfsd_create(rqstp, &cstate->current_fh,
570  create->cr_name, create->cr_namelen,
571  &create->cr_iattr, S_IFSOCK, 0, &resfh);
572  break;
573 
574  case NF4FIFO:
575  status = nfsd_create(rqstp, &cstate->current_fh,
576  create->cr_name, create->cr_namelen,
577  &create->cr_iattr, S_IFIFO, 0, &resfh);
578  break;
579 
580  case NF4DIR:
581  create->cr_iattr.ia_valid &= ~ATTR_SIZE;
582  status = nfsd_create(rqstp, &cstate->current_fh,
583  create->cr_name, create->cr_namelen,
584  &create->cr_iattr, S_IFDIR, 0, &resfh);
585  break;
586 
587  default:
588  status = nfserr_badtype;
589  }
590 
591  if (status)
592  goto out;
593 
594  if (create->cr_acl != NULL)
595  do_set_nfs4_acl(rqstp, &resfh, create->cr_acl,
596  create->cr_bmval);
597 
598  fh_unlock(&cstate->current_fh);
599  set_change_info(&create->cr_cinfo, &cstate->current_fh);
600  fh_dup2(&cstate->current_fh, &resfh);
601 out:
602  fh_put(&resfh);
603  return status;
604 }
605 
606 static __be32
607 nfsd4_getattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
608  struct nfsd4_getattr *getattr)
609 {
610  __be32 status;
611 
612  status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
613  if (status)
614  return status;
615 
616  if (getattr->ga_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)
617  return nfserr_inval;
618 
619  getattr->ga_bmval[0] &= nfsd_suppattrs0(cstate->minorversion);
620  getattr->ga_bmval[1] &= nfsd_suppattrs1(cstate->minorversion);
621  getattr->ga_bmval[2] &= nfsd_suppattrs2(cstate->minorversion);
622 
623  getattr->ga_fhp = &cstate->current_fh;
624  return nfs_ok;
625 }
626 
627 static __be32
628 nfsd4_link(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
629  struct nfsd4_link *link)
630 {
631  __be32 status = nfserr_nofilehandle;
632 
633  if (!cstate->save_fh.fh_dentry)
634  return status;
635  status = nfsd_link(rqstp, &cstate->current_fh,
636  link->li_name, link->li_namelen, &cstate->save_fh);
637  if (!status)
638  set_change_info(&link->li_cinfo, &cstate->current_fh);
639  return status;
640 }
641 
642 static __be32 nfsd4_do_lookupp(struct svc_rqst *rqstp, struct svc_fh *fh)
643 {
644  struct svc_fh tmp_fh;
645  __be32 ret;
646 
647  fh_init(&tmp_fh, NFS4_FHSIZE);
648  ret = exp_pseudoroot(rqstp, &tmp_fh);
649  if (ret)
650  return ret;
651  if (tmp_fh.fh_dentry == fh->fh_dentry) {
652  fh_put(&tmp_fh);
653  return nfserr_noent;
654  }
655  fh_put(&tmp_fh);
656  return nfsd_lookup(rqstp, fh, "..", 2, fh);
657 }
658 
659 static __be32
660 nfsd4_lookupp(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
661  void *arg)
662 {
663  return nfsd4_do_lookupp(rqstp, &cstate->current_fh);
664 }
665 
666 static __be32
667 nfsd4_lookup(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
668  struct nfsd4_lookup *lookup)
669 {
670  return nfsd_lookup(rqstp, &cstate->current_fh,
671  lookup->lo_name, lookup->lo_len,
672  &cstate->current_fh);
673 }
674 
675 static __be32
676 nfsd4_read(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
677  struct nfsd4_read *read)
678 {
679  __be32 status;
680 
681  /* no need to check permission - this will be done in nfsd_read() */
682 
683  read->rd_filp = NULL;
684  if (read->rd_offset >= OFFSET_MAX)
685  return nfserr_inval;
686 
687  nfs4_lock_state();
688  /* check stateid */
689  if ((status = nfs4_preprocess_stateid_op(SVC_NET(rqstp),
690  cstate, &read->rd_stateid,
691  RD_STATE, &read->rd_filp))) {
692  dprintk("NFSD: nfsd4_read: couldn't process stateid!\n");
693  goto out;
694  }
695  if (read->rd_filp)
696  get_file(read->rd_filp);
697  status = nfs_ok;
698 out:
700  read->rd_rqstp = rqstp;
701  read->rd_fhp = &cstate->current_fh;
702  return status;
703 }
704 
705 static __be32
706 nfsd4_readdir(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
707  struct nfsd4_readdir *readdir)
708 {
709  u64 cookie = readdir->rd_cookie;
710  static const nfs4_verifier zeroverf;
711 
712  /* no need to check permission - this will be done in nfsd_readdir() */
713 
714  if (readdir->rd_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)
715  return nfserr_inval;
716 
717  readdir->rd_bmval[0] &= nfsd_suppattrs0(cstate->minorversion);
718  readdir->rd_bmval[1] &= nfsd_suppattrs1(cstate->minorversion);
719  readdir->rd_bmval[2] &= nfsd_suppattrs2(cstate->minorversion);
720 
721  if ((cookie == 1) || (cookie == 2) ||
722  (cookie == 0 && memcmp(readdir->rd_verf.data, zeroverf.data, NFS4_VERIFIER_SIZE)))
723  return nfserr_bad_cookie;
724 
725  readdir->rd_rqstp = rqstp;
726  readdir->rd_fhp = &cstate->current_fh;
727  return nfs_ok;
728 }
729 
730 static __be32
731 nfsd4_readlink(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
732  struct nfsd4_readlink *readlink)
733 {
734  readlink->rl_rqstp = rqstp;
735  readlink->rl_fhp = &cstate->current_fh;
736  return nfs_ok;
737 }
738 
739 static __be32
740 nfsd4_remove(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
741  struct nfsd4_remove *remove)
742 {
743  __be32 status;
744 
745  if (locks_in_grace(SVC_NET(rqstp)))
746  return nfserr_grace;
747  status = nfsd_unlink(rqstp, &cstate->current_fh, 0,
748  remove->rm_name, remove->rm_namelen);
749  if (!status) {
750  fh_unlock(&cstate->current_fh);
751  set_change_info(&remove->rm_cinfo, &cstate->current_fh);
752  }
753  return status;
754 }
755 
756 static __be32
757 nfsd4_rename(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
758  struct nfsd4_rename *rename)
759 {
760  __be32 status = nfserr_nofilehandle;
761 
762  if (!cstate->save_fh.fh_dentry)
763  return status;
764  if (locks_in_grace(SVC_NET(rqstp)) &&
765  !(cstate->save_fh.fh_export->ex_flags & NFSEXP_NOSUBTREECHECK))
766  return nfserr_grace;
767  status = nfsd_rename(rqstp, &cstate->save_fh, rename->rn_sname,
768  rename->rn_snamelen, &cstate->current_fh,
769  rename->rn_tname, rename->rn_tnamelen);
770 
771  /* the underlying filesystem returns different error's than required
772  * by NFSv4. both save_fh and current_fh have been verified.. */
773  if (status == nfserr_isdir)
774  status = nfserr_exist;
775  else if ((status == nfserr_notdir) &&
776  (S_ISDIR(cstate->save_fh.fh_dentry->d_inode->i_mode) &&
777  S_ISDIR(cstate->current_fh.fh_dentry->d_inode->i_mode)))
778  status = nfserr_exist;
779 
780  if (!status) {
781  set_change_info(&rename->rn_sinfo, &cstate->current_fh);
782  set_change_info(&rename->rn_tinfo, &cstate->save_fh);
783  }
784  return status;
785 }
786 
787 static __be32
788 nfsd4_secinfo(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
789  struct nfsd4_secinfo *secinfo)
790 {
791  struct svc_fh resfh;
792  struct svc_export *exp;
793  struct dentry *dentry;
794  __be32 err;
795 
796  fh_init(&resfh, NFS4_FHSIZE);
797  err = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_EXEC);
798  if (err)
799  return err;
800  err = nfsd_lookup_dentry(rqstp, &cstate->current_fh,
801  secinfo->si_name, secinfo->si_namelen,
802  &exp, &dentry);
803  if (err)
804  return err;
805  if (dentry->d_inode == NULL) {
806  exp_put(exp);
807  err = nfserr_noent;
808  } else
809  secinfo->si_exp = exp;
810  dput(dentry);
811  if (cstate->minorversion)
812  /* See rfc 5661 section 2.6.3.1.1.8 */
813  fh_put(&cstate->current_fh);
814  return err;
815 }
816 
817 static __be32
818 nfsd4_secinfo_no_name(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
819  struct nfsd4_secinfo_no_name *sin)
820 {
821  __be32 err;
822 
823  switch (sin->sin_style) {
825  break;
827  err = nfsd4_do_lookupp(rqstp, &cstate->current_fh);
828  if (err)
829  return err;
830  break;
831  default:
832  return nfserr_inval;
833  }
834  exp_get(cstate->current_fh.fh_export);
835  sin->sin_exp = cstate->current_fh.fh_export;
836  fh_put(&cstate->current_fh);
837  return nfs_ok;
838 }
839 
840 static __be32
841 nfsd4_setattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
842  struct nfsd4_setattr *setattr)
843 {
844  __be32 status = nfs_ok;
845  int err;
846 
847  if (setattr->sa_iattr.ia_valid & ATTR_SIZE) {
848  nfs4_lock_state();
849  status = nfs4_preprocess_stateid_op(SVC_NET(rqstp), cstate,
850  &setattr->sa_stateid, WR_STATE, NULL);
852  if (status) {
853  dprintk("NFSD: nfsd4_setattr: couldn't process stateid!\n");
854  return status;
855  }
856  }
857  err = fh_want_write(&cstate->current_fh);
858  if (err)
859  return nfserrno(err);
860  status = nfs_ok;
861 
862  status = check_attr_support(rqstp, cstate, setattr->sa_bmval,
863  nfsd_attrmask);
864  if (status)
865  goto out;
866 
867  if (setattr->sa_acl != NULL)
868  status = nfsd4_set_nfs4_acl(rqstp, &cstate->current_fh,
869  setattr->sa_acl);
870  if (status)
871  goto out;
872  status = nfsd_setattr(rqstp, &cstate->current_fh, &setattr->sa_iattr,
873  0, (time_t)0);
874 out:
875  fh_drop_write(&cstate->current_fh);
876  return status;
877 }
878 
879 static __be32
880 nfsd4_write(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
881  struct nfsd4_write *write)
882 {
883  stateid_t *stateid = &write->wr_stateid;
884  struct file *filp = NULL;
885  __be32 status = nfs_ok;
886  unsigned long cnt;
887 
888  /* no need to check permission - this will be done in nfsd_write() */
889 
890  if (write->wr_offset >= OFFSET_MAX)
891  return nfserr_inval;
892 
893  nfs4_lock_state();
894  status = nfs4_preprocess_stateid_op(SVC_NET(rqstp),
895  cstate, stateid, WR_STATE, &filp);
896  if (filp)
897  get_file(filp);
899 
900  if (status) {
901  dprintk("NFSD: nfsd4_write: couldn't process stateid!\n");
902  return status;
903  }
904 
905  cnt = write->wr_buflen;
906  write->wr_how_written = write->wr_stable_how;
907  gen_boot_verifier(&write->wr_verifier);
908 
909  status = nfsd_write(rqstp, &cstate->current_fh, filp,
910  write->wr_offset, rqstp->rq_vec, write->wr_vlen,
911  &cnt, &write->wr_how_written);
912  if (filp)
913  fput(filp);
914 
915  write->wr_bytes_written = cnt;
916 
917  return status;
918 }
919 
920 /* This routine never returns NFS_OK! If there are no other errors, it
921  * will return NFSERR_SAME or NFSERR_NOT_SAME depending on whether the
922  * attributes matched. VERIFY is implemented by mapping NFSERR_SAME
923  * to NFS_OK after the call; NVERIFY by mapping NFSERR_NOT_SAME to NFS_OK.
924  */
925 static __be32
926 _nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
927  struct nfsd4_verify *verify)
928 {
929  __be32 *buf, *p;
930  int count;
931  __be32 status;
932 
933  status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
934  if (status)
935  return status;
936 
937  status = check_attr_support(rqstp, cstate, verify->ve_bmval, NULL);
938  if (status)
939  return status;
940 
941  if ((verify->ve_bmval[0] & FATTR4_WORD0_RDATTR_ERROR)
942  || (verify->ve_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1))
943  return nfserr_inval;
944  if (verify->ve_attrlen & 3)
945  return nfserr_inval;
946 
947  /* count in words:
948  * bitmap_len(1) + bitmap(2) + attr_len(1) = 4
949  */
950  count = 4 + (verify->ve_attrlen >> 2);
951  buf = kmalloc(count << 2, GFP_KERNEL);
952  if (!buf)
953  return nfserr_jukebox;
954 
955  status = nfsd4_encode_fattr(&cstate->current_fh,
956  cstate->current_fh.fh_export,
957  cstate->current_fh.fh_dentry, buf,
958  &count, verify->ve_bmval,
959  rqstp, 0);
960 
961  /* this means that nfsd4_encode_fattr() ran out of space */
962  if (status == nfserr_resource && count == 0)
963  status = nfserr_not_same;
964  if (status)
965  goto out_kfree;
966 
967  /* skip bitmap */
968  p = buf + 1 + ntohl(buf[0]);
969  status = nfserr_not_same;
970  if (ntohl(*p++) != verify->ve_attrlen)
971  goto out_kfree;
972  if (!memcmp(p, verify->ve_attrval, verify->ve_attrlen))
973  status = nfserr_same;
974 
975 out_kfree:
976  kfree(buf);
977  return status;
978 }
979 
980 static __be32
981 nfsd4_nverify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
982  struct nfsd4_verify *verify)
983 {
984  __be32 status;
985 
986  status = _nfsd4_verify(rqstp, cstate, verify);
987  return status == nfserr_not_same ? nfs_ok : status;
988 }
989 
990 static __be32
991 nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
992  struct nfsd4_verify *verify)
993 {
994  __be32 status;
995 
996  status = _nfsd4_verify(rqstp, cstate, verify);
997  return status == nfserr_same ? nfs_ok : status;
998 }
999 
1000 /*
1001  * NULL call.
1002  */
1003 static __be32
1004 nfsd4_proc_null(struct svc_rqst *rqstp, void *argp, void *resp)
1005 {
1006  return nfs_ok;
1007 }
1008 
1009 static inline void nfsd4_increment_op_stats(u32 opnum)
1010 {
1011  if (opnum >= FIRST_NFS4_OP && opnum <= LAST_NFS4_OP)
1012  nfsdstats.nfs4_opcount[opnum]++;
1013 }
1014 
1015 typedef __be32(*nfsd4op_func)(struct svc_rqst *, struct nfsd4_compound_state *,
1016  void *);
1017 typedef u32(*nfsd4op_rsize)(struct svc_rqst *, struct nfsd4_op *op);
1018 typedef void(*stateid_setter)(struct nfsd4_compound_state *, void *);
1019 typedef void(*stateid_getter)(struct nfsd4_compound_state *, void *);
1020 
1022  ALLOWED_WITHOUT_FH = 1 << 0, /* No current filehandle required */
1023  ALLOWED_ON_ABSENT_FS = 1 << 1, /* ops processed on absent fs */
1024  ALLOWED_AS_FIRST_OP = 1 << 2, /* ops reqired first in compound */
1025  /* For rfc 5661 section 2.6.3.1.1: */
1028  /*
1029  * These are the ops whose result size we estimate before
1030  * encoding, to avoid performing an op then not being able to
1031  * respond or cache a response. This includes writes and setattrs
1032  * as well as the operations usually called "nonidempotent":
1033  */
1035  /*
1036  * Cache compounds containing these ops in the xid-based drc:
1037  * We use the DRC for compounds containing non-idempotent
1038  * operations, *except* those that are 4.1-specific (since
1039  * sessions provide their own EOS), and except for stateful
1040  * operations other than setclientid and setclientid_confirm
1041  * (since sequence numbers provide EOS for open, lock, etc in
1042  * the v4.0 case).
1043  */
1044  OP_CACHEME = 1 << 6,
1045  /*
1046  * These are ops which clear current state id.
1047  */
1049 };
1050 
1054  char *op_name;
1055  /* Try to get response size before operation */
1059 };
1060 
1061 static struct nfsd4_operation nfsd4_ops[];
1062 
1063 #ifdef NFSD_DEBUG
1064 static const char *nfsd4_op_name(unsigned opnum);
1065 #endif
1066 
1067 /*
1068  * Enforce NFSv4.1 COMPOUND ordering rules:
1069  *
1070  * Also note, enforced elsewhere:
1071  * - SEQUENCE other than as first op results in
1072  * NFS4ERR_SEQUENCE_POS. (Enforced in nfsd4_sequence().)
1073  * - BIND_CONN_TO_SESSION must be the only op in its compound.
1074  * (Enforced in nfsd4_bind_conn_to_session().)
1075  * - DESTROY_SESSION must be the final operation in a compound, if
1076  * sessionid's in SEQUENCE and DESTROY_SESSION are the same.
1077  * (Enforced in nfsd4_destroy_session().)
1078  */
1079 static __be32 nfs41_check_op_ordering(struct nfsd4_compoundargs *args)
1080 {
1081  struct nfsd4_op *op = &args->ops[0];
1082 
1083  /* These ordering requirements don't apply to NFSv4.0: */
1084  if (args->minorversion == 0)
1085  return nfs_ok;
1086  /* This is weird, but OK, not our problem: */
1087  if (args->opcnt == 0)
1088  return nfs_ok;
1089  if (op->status == nfserr_op_illegal)
1090  return nfs_ok;
1091  if (!(nfsd4_ops[op->opnum].op_flags & ALLOWED_AS_FIRST_OP))
1092  return nfserr_op_not_in_session;
1093  if (op->opnum == OP_SEQUENCE)
1094  return nfs_ok;
1095  if (args->opcnt != 1)
1096  return nfserr_not_only_op;
1097  return nfs_ok;
1098 }
1099 
1100 static inline struct nfsd4_operation *OPDESC(struct nfsd4_op *op)
1101 {
1102  return &nfsd4_ops[op->opnum];
1103 }
1104 
1106 {
1107  return OPDESC(op)->op_flags & OP_CACHEME;
1108 }
1109 
1110 static bool need_wrongsec_check(struct svc_rqst *rqstp)
1111 {
1112  struct nfsd4_compoundres *resp = rqstp->rq_resp;
1113  struct nfsd4_compoundargs *argp = rqstp->rq_argp;
1114  struct nfsd4_op *this = &argp->ops[resp->opcnt - 1];
1115  struct nfsd4_op *next = &argp->ops[resp->opcnt];
1116  struct nfsd4_operation *thisd;
1117  struct nfsd4_operation *nextd;
1118 
1119  thisd = OPDESC(this);
1120  /*
1121  * Most ops check wronsec on our own; only the putfh-like ops
1122  * have special rules.
1123  */
1124  if (!(thisd->op_flags & OP_IS_PUTFH_LIKE))
1125  return false;
1126  /*
1127  * rfc 5661 2.6.3.1.1.6: don't bother erroring out a
1128  * put-filehandle operation if we're not going to use the
1129  * result:
1130  */
1131  if (argp->opcnt == resp->opcnt)
1132  return false;
1133 
1134  nextd = OPDESC(next);
1135  /*
1136  * Rest of 2.6.3.1.1: certain operations will return WRONGSEC
1137  * errors themselves as necessary; others should check for them
1138  * now:
1139  */
1140  return !(nextd->op_flags & OP_HANDLES_WRONGSEC);
1141 }
1142 
1143 /*
1144  * COMPOUND call.
1145  */
1146 static __be32
1147 nfsd4_proc_compound(struct svc_rqst *rqstp,
1148  struct nfsd4_compoundargs *args,
1149  struct nfsd4_compoundres *resp)
1150 {
1151  struct nfsd4_op *op;
1152  struct nfsd4_operation *opdesc;
1153  struct nfsd4_compound_state *cstate = &resp->cstate;
1154  int slack_bytes;
1155  u32 plen = 0;
1156  __be32 status;
1157 
1158  resp->xbuf = &rqstp->rq_res;
1159  resp->p = rqstp->rq_res.head[0].iov_base +
1160  rqstp->rq_res.head[0].iov_len;
1161  resp->tagp = resp->p;
1162  /* reserve space for: taglen, tag, and opcnt */
1163  resp->p += 2 + XDR_QUADLEN(args->taglen);
1164  resp->end = rqstp->rq_res.head[0].iov_base + PAGE_SIZE;
1165  resp->taglen = args->taglen;
1166  resp->tag = args->tag;
1167  resp->opcnt = 0;
1168  resp->rqstp = rqstp;
1169  resp->cstate.minorversion = args->minorversion;
1170  resp->cstate.replay_owner = NULL;
1171  resp->cstate.session = NULL;
1172  fh_init(&resp->cstate.current_fh, NFS4_FHSIZE);
1173  fh_init(&resp->cstate.save_fh, NFS4_FHSIZE);
1174  /*
1175  * Don't use the deferral mechanism for NFSv4; compounds make it
1176  * too hard to avoid non-idempotency problems.
1177  */
1178  rqstp->rq_usedeferral = 0;
1179 
1180  /*
1181  * According to RFC3010, this takes precedence over all other errors.
1182  */
1183  status = nfserr_minor_vers_mismatch;
1185  goto out;
1186 
1187  status = nfs41_check_op_ordering(args);
1188  if (status) {
1189  op = &args->ops[0];
1190  op->status = status;
1191  goto encode_op;
1192  }
1193 
1194  while (!status && resp->opcnt < args->opcnt) {
1195  op = &args->ops[resp->opcnt++];
1196 
1197  dprintk("nfsv4 compound op #%d/%d: %d (%s)\n",
1198  resp->opcnt, args->opcnt, op->opnum,
1199  nfsd4_op_name(op->opnum));
1200  /*
1201  * The XDR decode routines may have pre-set op->status;
1202  * for example, if there is a miscellaneous XDR error
1203  * it will be set to nfserr_bad_xdr.
1204  */
1205  if (op->status)
1206  goto encode_op;
1207 
1208  /* We must be able to encode a successful response to
1209  * this operation, with enough room left over to encode a
1210  * failed response to the next operation. If we don't
1211  * have enough room, fail with ERR_RESOURCE.
1212  */
1213  slack_bytes = (char *)resp->end - (char *)resp->p;
1214  if (slack_bytes < COMPOUND_SLACK_SPACE
1215  + COMPOUND_ERR_SLACK_SPACE) {
1216  BUG_ON(slack_bytes < COMPOUND_ERR_SLACK_SPACE);
1217  op->status = nfserr_resource;
1218  goto encode_op;
1219  }
1220 
1221  opdesc = OPDESC(op);
1222 
1223  if (!cstate->current_fh.fh_dentry) {
1224  if (!(opdesc->op_flags & ALLOWED_WITHOUT_FH)) {
1226  goto encode_op;
1227  }
1228  } else if (cstate->current_fh.fh_export->ex_fslocs.migrated &&
1229  !(opdesc->op_flags & ALLOWED_ON_ABSENT_FS)) {
1230  op->status = nfserr_moved;
1231  goto encode_op;
1232  }
1233 
1234  /* If op is non-idempotent */
1235  if (opdesc->op_flags & OP_MODIFIES_SOMETHING) {
1236  plen = opdesc->op_rsize_bop(rqstp, op);
1237  op->status = nfsd4_check_resp_size(resp, plen);
1238  }
1239 
1240  if (op->status)
1241  goto encode_op;
1242 
1243  if (opdesc->op_func) {
1244  if (opdesc->op_get_currentstateid)
1245  opdesc->op_get_currentstateid(cstate, &op->u);
1246  op->status = opdesc->op_func(rqstp, cstate, &op->u);
1247  } else
1248  BUG_ON(op->status == nfs_ok);
1249 
1250  if (!op->status) {
1251  if (opdesc->op_set_currentstateid)
1252  opdesc->op_set_currentstateid(cstate, &op->u);
1253 
1254  if (opdesc->op_flags & OP_CLEAR_STATEID)
1255  clear_current_stateid(cstate);
1256 
1257  if (need_wrongsec_check(rqstp))
1258  op->status = check_nfsd_access(cstate->current_fh.fh_export, rqstp);
1259  }
1260 
1261 encode_op:
1262  /* Only from SEQUENCE */
1263  if (resp->cstate.status == nfserr_replay_cache) {
1264  dprintk("%s NFS4.1 replay from cache\n", __func__);
1265  status = op->status;
1266  goto out;
1267  }
1268  if (op->status == nfserr_replay_me) {
1269  op->replay = &cstate->replay_owner->so_replay;
1270  nfsd4_encode_replay(resp, op);
1271  status = op->status = op->replay->rp_status;
1272  } else {
1273  nfsd4_encode_operation(resp, op);
1274  status = op->status;
1275  }
1276 
1277  dprintk("nfsv4 compound op %p opcnt %d #%d: %d: status %d\n",
1278  args->ops, args->opcnt, resp->opcnt, op->opnum,
1279  be32_to_cpu(status));
1280 
1281  if (cstate->replay_owner) {
1283  cstate->replay_owner = NULL;
1284  }
1285  /* XXX Ugh, we need to get rid of this kind of special case: */
1286  if (op->opnum == OP_READ && op->u.read.rd_filp)
1287  fput(op->u.read.rd_filp);
1288 
1289  nfsd4_increment_op_stats(op->opnum);
1290  }
1291 
1292  resp->cstate.status = status;
1293  fh_put(&resp->cstate.current_fh);
1294  fh_put(&resp->cstate.save_fh);
1295  BUG_ON(resp->cstate.replay_owner);
1296 out:
1297  /* Reset deferral mechanism for RPC deferrals */
1298  rqstp->rq_usedeferral = 1;
1299  dprintk("nfsv4 compound returned %d\n", ntohl(status));
1300  return status;
1301 }
1302 
1303 #define op_encode_hdr_size (2)
1304 #define op_encode_stateid_maxsz (XDR_QUADLEN(NFS4_STATEID_SIZE))
1305 #define op_encode_verifier_maxsz (XDR_QUADLEN(NFS4_VERIFIER_SIZE))
1306 #define op_encode_change_info_maxsz (5)
1307 #define nfs4_fattr_bitmap_maxsz (4)
1308 
1309 #define op_encode_lockowner_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ))
1310 #define op_encode_lock_denied_maxsz (8 + op_encode_lockowner_maxsz)
1311 
1312 #define nfs4_owner_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ))
1313 
1314 #define op_encode_ace_maxsz (3 + nfs4_owner_maxsz)
1315 #define op_encode_delegation_maxsz (1 + op_encode_stateid_maxsz + 1 + \
1316  op_encode_ace_maxsz)
1317 
1318 #define op_encode_channel_attrs_maxsz (6 + 1 + 1)
1319 
1320 static inline u32 nfsd4_only_status_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1321 {
1322  return (op_encode_hdr_size) * sizeof(__be32);
1323 }
1324 
1325 static inline u32 nfsd4_status_stateid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1326 {
1328 }
1329 
1330 static inline u32 nfsd4_commit_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1331 {
1332  return (op_encode_hdr_size + op_encode_verifier_maxsz) * sizeof(__be32);
1333 }
1334 
1335 static inline u32 nfsd4_create_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1336 {
1338  + nfs4_fattr_bitmap_maxsz) * sizeof(__be32);
1339 }
1340 
1341 static inline u32 nfsd4_link_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1342 {
1344  * sizeof(__be32);
1345 }
1346 
1347 static inline u32 nfsd4_lock_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1348 {
1350  * sizeof(__be32);
1351 }
1352 
1353 static inline u32 nfsd4_open_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1354 {
1358  + op_encode_delegation_maxsz) * sizeof(__be32);
1359 }
1360 
1361 static inline u32 nfsd4_read_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1362 {
1363  u32 maxcount = 0, rlen = 0;
1364 
1365  maxcount = svc_max_payload(rqstp);
1366  rlen = op->u.read.rd_length;
1367 
1368  if (rlen > maxcount)
1369  rlen = maxcount;
1370 
1371  return (op_encode_hdr_size + 2) * sizeof(__be32) + rlen;
1372 }
1373 
1374 static inline u32 nfsd4_readdir_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1375 {
1376  u32 rlen = op->u.readdir.rd_maxcount;
1377 
1378  if (rlen > PAGE_SIZE)
1379  rlen = PAGE_SIZE;
1380 
1382  * sizeof(__be32) + rlen;
1383 }
1384 
1385 static inline u32 nfsd4_remove_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1386 {
1388  * sizeof(__be32);
1389 }
1390 
1391 static inline u32 nfsd4_rename_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1392 {
1394  + op_encode_change_info_maxsz) * sizeof(__be32);
1395 }
1396 
1397 static inline u32 nfsd4_setattr_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1398 {
1399  return (op_encode_hdr_size + nfs4_fattr_bitmap_maxsz) * sizeof(__be32);
1400 }
1401 
1402 static inline u32 nfsd4_setclientid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1403 {
1404  return (op_encode_hdr_size + 2 + 1024) * sizeof(__be32);
1405 }
1406 
1407 static inline u32 nfsd4_write_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1408 {
1409  return (op_encode_hdr_size + op_encode_verifier_maxsz) * sizeof(__be32);
1410 }
1411 
1412 static inline u32 nfsd4_exchange_id_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1413 {
1414  return (op_encode_hdr_size + 2 + 1 + /* eir_clientid, eir_sequenceid */\
1415  1 + 1 + 0 + /* eir_flags, spr_how, SP4_NONE (for now) */\
1416  2 + /*eir_server_owner.so_minor_id */\
1417  /* eir_server_owner.so_major_id<> */\
1418  XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 +\
1419  /* eir_server_scope<> */\
1420  XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 +\
1421  1 + /* eir_server_impl_id array length */\
1422  0 /* ignored eir_server_impl_id contents */) * sizeof(__be32);
1423 }
1424 
1425 static inline u32 nfsd4_bind_conn_to_session_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1426 {
1427  return (op_encode_hdr_size + \
1428  XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + /* bctsr_sessid */\
1429  2 /* bctsr_dir, use_conn_in_rdma_mode */) * sizeof(__be32);
1430 }
1431 
1432 static inline u32 nfsd4_create_session_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1433 {
1434  return (op_encode_hdr_size + \
1435  XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + /* sessionid */\
1436  2 + /* csr_sequence, csr_flags */\
1439 }
1440 
1441 static struct nfsd4_operation nfsd4_ops[] = {
1442  [OP_ACCESS] = {
1443  .op_func = (nfsd4op_func)nfsd4_access,
1444  .op_name = "OP_ACCESS",
1445  },
1446  [OP_CLOSE] = {
1447  .op_func = (nfsd4op_func)nfsd4_close,
1449  .op_name = "OP_CLOSE",
1450  .op_rsize_bop = (nfsd4op_rsize)nfsd4_status_stateid_rsize,
1451  .op_get_currentstateid = (stateid_getter)nfsd4_get_closestateid,
1453  },
1454  [OP_COMMIT] = {
1455  .op_func = (nfsd4op_func)nfsd4_commit,
1457  .op_name = "OP_COMMIT",
1458  .op_rsize_bop = (nfsd4op_rsize)nfsd4_commit_rsize,
1459  },
1460  [OP_CREATE] = {
1461  .op_func = (nfsd4op_func)nfsd4_create,
1463  .op_name = "OP_CREATE",
1464  .op_rsize_bop = (nfsd4op_rsize)nfsd4_create_rsize,
1465  },
1466  [OP_DELEGRETURN] = {
1467  .op_func = (nfsd4op_func)nfsd4_delegreturn,
1469  .op_name = "OP_DELEGRETURN",
1470  .op_rsize_bop = nfsd4_only_status_rsize,
1472  },
1473  [OP_GETATTR] = {
1474  .op_func = (nfsd4op_func)nfsd4_getattr,
1476  .op_name = "OP_GETATTR",
1477  },
1478  [OP_GETFH] = {
1479  .op_func = (nfsd4op_func)nfsd4_getfh,
1480  .op_name = "OP_GETFH",
1481  },
1482  [OP_LINK] = {
1483  .op_func = (nfsd4op_func)nfsd4_link,
1485  | OP_CACHEME,
1486  .op_name = "OP_LINK",
1487  .op_rsize_bop = (nfsd4op_rsize)nfsd4_link_rsize,
1488  },
1489  [OP_LOCK] = {
1490  .op_func = (nfsd4op_func)nfsd4_lock,
1492  .op_name = "OP_LOCK",
1493  .op_rsize_bop = (nfsd4op_rsize)nfsd4_lock_rsize,
1494  .op_set_currentstateid = (stateid_setter)nfsd4_set_lockstateid,
1495  },
1496  [OP_LOCKT] = {
1497  .op_func = (nfsd4op_func)nfsd4_lockt,
1498  .op_name = "OP_LOCKT",
1499  },
1500  [OP_LOCKU] = {
1501  .op_func = (nfsd4op_func)nfsd4_locku,
1503  .op_name = "OP_LOCKU",
1504  .op_rsize_bop = (nfsd4op_rsize)nfsd4_status_stateid_rsize,
1505  .op_get_currentstateid = (stateid_getter)nfsd4_get_lockustateid,
1506  },
1507  [OP_LOOKUP] = {
1508  .op_func = (nfsd4op_func)nfsd4_lookup,
1510  .op_name = "OP_LOOKUP",
1511  },
1512  [OP_LOOKUPP] = {
1513  .op_func = (nfsd4op_func)nfsd4_lookupp,
1515  .op_name = "OP_LOOKUPP",
1516  },
1517  [OP_NVERIFY] = {
1518  .op_func = (nfsd4op_func)nfsd4_nverify,
1519  .op_name = "OP_NVERIFY",
1520  },
1521  [OP_OPEN] = {
1522  .op_func = (nfsd4op_func)nfsd4_open,
1524  .op_name = "OP_OPEN",
1525  .op_rsize_bop = (nfsd4op_rsize)nfsd4_open_rsize,
1526  .op_set_currentstateid = (stateid_setter)nfsd4_set_openstateid,
1527  },
1528  [OP_OPEN_CONFIRM] = {
1529  .op_func = (nfsd4op_func)nfsd4_open_confirm,
1531  .op_name = "OP_OPEN_CONFIRM",
1532  .op_rsize_bop = (nfsd4op_rsize)nfsd4_status_stateid_rsize,
1533  },
1534  [OP_OPEN_DOWNGRADE] = {
1535  .op_func = (nfsd4op_func)nfsd4_open_downgrade,
1537  .op_name = "OP_OPEN_DOWNGRADE",
1538  .op_rsize_bop = (nfsd4op_rsize)nfsd4_status_stateid_rsize,
1539  .op_get_currentstateid = (stateid_getter)nfsd4_get_opendowngradestateid,
1541  },
1542  [OP_PUTFH] = {
1543  .op_func = (nfsd4op_func)nfsd4_putfh,
1546  | OP_CLEAR_STATEID,
1547  .op_name = "OP_PUTFH",
1548  .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
1549  },
1550  [OP_PUTPUBFH] = {
1551  .op_func = (nfsd4op_func)nfsd4_putrootfh,
1554  | OP_CLEAR_STATEID,
1555  .op_name = "OP_PUTPUBFH",
1556  .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
1557  },
1558  [OP_PUTROOTFH] = {
1559  .op_func = (nfsd4op_func)nfsd4_putrootfh,
1562  | OP_CLEAR_STATEID,
1563  .op_name = "OP_PUTROOTFH",
1564  .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
1565  },
1566  [OP_READ] = {
1567  .op_func = (nfsd4op_func)nfsd4_read,
1569  .op_name = "OP_READ",
1570  .op_rsize_bop = (nfsd4op_rsize)nfsd4_read_rsize,
1571  .op_get_currentstateid = (stateid_getter)nfsd4_get_readstateid,
1572  },
1573  [OP_READDIR] = {
1574  .op_func = (nfsd4op_func)nfsd4_readdir,
1576  .op_name = "OP_READDIR",
1577  .op_rsize_bop = (nfsd4op_rsize)nfsd4_readdir_rsize,
1578  },
1579  [OP_READLINK] = {
1580  .op_func = (nfsd4op_func)nfsd4_readlink,
1581  .op_name = "OP_READLINK",
1582  },
1583  [OP_REMOVE] = {
1584  .op_func = (nfsd4op_func)nfsd4_remove,
1586  .op_name = "OP_REMOVE",
1587  .op_rsize_bop = (nfsd4op_rsize)nfsd4_remove_rsize,
1588  },
1589  [OP_RENAME] = {
1590  .op_func = (nfsd4op_func)nfsd4_rename,
1592  .op_name = "OP_RENAME",
1593  .op_rsize_bop = (nfsd4op_rsize)nfsd4_rename_rsize,
1594  },
1595  [OP_RENEW] = {
1596  .op_func = (nfsd4op_func)nfsd4_renew,
1599  .op_name = "OP_RENEW",
1600  .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
1601 
1602  },
1603  [OP_RESTOREFH] = {
1604  .op_func = (nfsd4op_func)nfsd4_restorefh,
1607  .op_name = "OP_RESTOREFH",
1608  .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
1609  },
1610  [OP_SAVEFH] = {
1611  .op_func = (nfsd4op_func)nfsd4_savefh,
1613  .op_name = "OP_SAVEFH",
1614  .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
1615  },
1616  [OP_SECINFO] = {
1617  .op_func = (nfsd4op_func)nfsd4_secinfo,
1619  .op_name = "OP_SECINFO",
1620  },
1621  [OP_SETATTR] = {
1622  .op_func = (nfsd4op_func)nfsd4_setattr,
1623  .op_name = "OP_SETATTR",
1625  .op_rsize_bop = (nfsd4op_rsize)nfsd4_setattr_rsize,
1626  .op_get_currentstateid = (stateid_getter)nfsd4_get_setattrstateid,
1627  },
1628  [OP_SETCLIENTID] = {
1629  .op_func = (nfsd4op_func)nfsd4_setclientid,
1632  .op_name = "OP_SETCLIENTID",
1633  .op_rsize_bop = (nfsd4op_rsize)nfsd4_setclientid_rsize,
1634  },
1639  .op_name = "OP_SETCLIENTID_CONFIRM",
1640  .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
1641  },
1642  [OP_VERIFY] = {
1643  .op_func = (nfsd4op_func)nfsd4_verify,
1644  .op_name = "OP_VERIFY",
1645  },
1646  [OP_WRITE] = {
1647  .op_func = (nfsd4op_func)nfsd4_write,
1649  .op_name = "OP_WRITE",
1650  .op_rsize_bop = (nfsd4op_rsize)nfsd4_write_rsize,
1651  .op_get_currentstateid = (stateid_getter)nfsd4_get_writestateid,
1652  },
1653  [OP_RELEASE_LOCKOWNER] = {
1657  .op_name = "OP_RELEASE_LOCKOWNER",
1658  .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
1659  },
1660 
1661  /* NFSv4.1 operations */
1662  [OP_EXCHANGE_ID] = {
1663  .op_func = (nfsd4op_func)nfsd4_exchange_id,
1664  .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
1666  .op_name = "OP_EXCHANGE_ID",
1667  .op_rsize_bop = (nfsd4op_rsize)nfsd4_exchange_id_rsize,
1668  },
1671  .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
1673  .op_name = "OP_BIND_CONN_TO_SESSION",
1674  .op_rsize_bop = (nfsd4op_rsize)nfsd4_bind_conn_to_session_rsize,
1675  },
1676  [OP_CREATE_SESSION] = {
1677  .op_func = (nfsd4op_func)nfsd4_create_session,
1678  .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
1680  .op_name = "OP_CREATE_SESSION",
1681  .op_rsize_bop = (nfsd4op_rsize)nfsd4_create_session_rsize,
1682  },
1683  [OP_DESTROY_SESSION] = {
1684  .op_func = (nfsd4op_func)nfsd4_destroy_session,
1685  .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
1687  .op_name = "OP_DESTROY_SESSION",
1688  .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
1689  },
1690  [OP_SEQUENCE] = {
1691  .op_func = (nfsd4op_func)nfsd4_sequence,
1692  .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP,
1693  .op_name = "OP_SEQUENCE",
1694  },
1695  [OP_DESTROY_CLIENTID] = {
1697  .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
1699  .op_name = "OP_DESTROY_CLIENTID",
1700  .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
1701  },
1702  [OP_RECLAIM_COMPLETE] = {
1705  .op_name = "OP_RECLAIM_COMPLETE",
1706  .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
1707  },
1708  [OP_SECINFO_NO_NAME] = {
1709  .op_func = (nfsd4op_func)nfsd4_secinfo_no_name,
1711  .op_name = "OP_SECINFO_NO_NAME",
1712  },
1713  [OP_TEST_STATEID] = {
1714  .op_func = (nfsd4op_func)nfsd4_test_stateid,
1716  .op_name = "OP_TEST_STATEID",
1717  },
1718  [OP_FREE_STATEID] = {
1719  .op_func = (nfsd4op_func)nfsd4_free_stateid,
1721  .op_name = "OP_FREE_STATEID",
1722  .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
1723  },
1724 };
1725 
1726 #ifdef NFSD_DEBUG
1727 static const char *nfsd4_op_name(unsigned opnum)
1728 {
1729  if (opnum < ARRAY_SIZE(nfsd4_ops))
1730  return nfsd4_ops[opnum].op_name;
1731  return "unknown_operation";
1732 }
1733 #endif
1734 
1735 #define nfsd4_voidres nfsd4_voidargs
1736 struct nfsd4_voidargs { int dummy; };
1737 
1738 static struct svc_procedure nfsd_procedures4[2] = {
1739  [NFSPROC4_NULL] = {
1740  .pc_func = (svc_procfunc) nfsd4_proc_null,
1741  .pc_encode = (kxdrproc_t) nfs4svc_encode_voidres,
1742  .pc_argsize = sizeof(struct nfsd4_voidargs),
1743  .pc_ressize = sizeof(struct nfsd4_voidres),
1744  .pc_cachetype = RC_NOCACHE,
1745  .pc_xdrressize = 1,
1746  },
1747  [NFSPROC4_COMPOUND] = {
1748  .pc_func = (svc_procfunc) nfsd4_proc_compound,
1749  .pc_decode = (kxdrproc_t) nfs4svc_decode_compoundargs,
1750  .pc_encode = (kxdrproc_t) nfs4svc_encode_compoundres,
1751  .pc_argsize = sizeof(struct nfsd4_compoundargs),
1752  .pc_ressize = sizeof(struct nfsd4_compoundres),
1753  .pc_release = nfsd4_release_compoundargs,
1754  .pc_cachetype = RC_NOCACHE,
1755  .pc_xdrressize = NFSD_BUFSIZE/4,
1756  },
1757 };
1758 
1760  .vs_vers = 4,
1761  .vs_nproc = 2,
1762  .vs_proc = nfsd_procedures4,
1763  .vs_dispatch = nfsd_dispatch,
1764  .vs_xdrsize = NFS4_SVC_XDRSIZE,
1765 };
1766 
1767 /*
1768  * Local variables:
1769  * c-basic-offset: 8
1770  * End:
1771  */