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 <kmsmith@umich.edu> |
8 | * Andy Adamson <andros@umich.edu> |
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/fs_struct.h> |
36 | #include <linux/file.h> |
37 | #include <linux/falloc.h> |
38 | #include <linux/slab.h> |
39 | #include <linux/kthread.h> |
40 | #include <linux/namei.h> |
41 | |
42 | #include <linux/sunrpc/addr.h> |
43 | #include <linux/nfs_ssc.h> |
44 | |
45 | #include "idmap.h" |
46 | #include "cache.h" |
47 | #include "xdr4.h" |
48 | #include "vfs.h" |
49 | #include "current_stateid.h" |
50 | #include "netns.h" |
51 | #include "acl.h" |
52 | #include "pnfs.h" |
53 | #include "trace.h" |
54 | |
55 | static bool inter_copy_offload_enable; |
56 | module_param(inter_copy_offload_enable, bool, 0644); |
57 | MODULE_PARM_DESC(inter_copy_offload_enable, |
58 | "Enable inter server to server copy offload. Default: false" ); |
59 | |
60 | #ifdef CONFIG_NFSD_V4_2_INTER_SSC |
61 | static int nfsd4_ssc_umount_timeout = 900000; /* default to 15 mins */ |
62 | module_param(nfsd4_ssc_umount_timeout, int, 0644); |
63 | MODULE_PARM_DESC(nfsd4_ssc_umount_timeout, |
64 | "idle msecs before unmount export from source server" ); |
65 | #endif |
66 | |
67 | #define NFSDDBG_FACILITY NFSDDBG_PROC |
68 | |
69 | static u32 nfsd_attrmask[] = { |
70 | NFSD_WRITEABLE_ATTRS_WORD0, |
71 | NFSD_WRITEABLE_ATTRS_WORD1, |
72 | NFSD_WRITEABLE_ATTRS_WORD2 |
73 | }; |
74 | |
75 | static u32 nfsd41_ex_attrmask[] = { |
76 | NFSD_SUPPATTR_EXCLCREAT_WORD0, |
77 | NFSD_SUPPATTR_EXCLCREAT_WORD1, |
78 | NFSD_SUPPATTR_EXCLCREAT_WORD2 |
79 | }; |
80 | |
81 | static __be32 |
82 | check_attr_support(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
83 | u32 *bmval, u32 *writable) |
84 | { |
85 | struct dentry *dentry = cstate->current_fh.fh_dentry; |
86 | struct svc_export *exp = cstate->current_fh.fh_export; |
87 | |
88 | if (!nfsd_attrs_supported(minorversion: cstate->minorversion, bmval)) |
89 | return nfserr_attrnotsupp; |
90 | if ((bmval[0] & FATTR4_WORD0_ACL) && !IS_POSIXACL(d_inode(dentry))) |
91 | return nfserr_attrnotsupp; |
92 | if ((bmval[2] & FATTR4_WORD2_SECURITY_LABEL) && |
93 | !(exp->ex_flags & NFSEXP_SECURITY_LABEL)) |
94 | return nfserr_attrnotsupp; |
95 | if (writable && !bmval_is_subset(bm1: bmval, bm2: writable)) |
96 | return nfserr_inval; |
97 | if (writable && (bmval[2] & FATTR4_WORD2_MODE_UMASK) && |
98 | (bmval[1] & FATTR4_WORD1_MODE)) |
99 | return nfserr_inval; |
100 | return nfs_ok; |
101 | } |
102 | |
103 | static __be32 |
104 | nfsd4_check_open_attributes(struct svc_rqst *rqstp, |
105 | struct nfsd4_compound_state *cstate, struct nfsd4_open *open) |
106 | { |
107 | __be32 status = nfs_ok; |
108 | |
109 | if (open->op_create == NFS4_OPEN_CREATE) { |
110 | if (open->op_createmode == NFS4_CREATE_UNCHECKED |
111 | || open->op_createmode == NFS4_CREATE_GUARDED) |
112 | status = check_attr_support(rqstp, cstate, |
113 | bmval: open->op_bmval, writable: nfsd_attrmask); |
114 | else if (open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1) |
115 | status = check_attr_support(rqstp, cstate, |
116 | bmval: open->op_bmval, writable: nfsd41_ex_attrmask); |
117 | } |
118 | |
119 | return status; |
120 | } |
121 | |
122 | static int |
123 | is_create_with_attrs(struct nfsd4_open *open) |
124 | { |
125 | return open->op_create == NFS4_OPEN_CREATE |
126 | && (open->op_createmode == NFS4_CREATE_UNCHECKED |
127 | || open->op_createmode == NFS4_CREATE_GUARDED |
128 | || open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1); |
129 | } |
130 | |
131 | static inline void |
132 | fh_dup2(struct svc_fh *dst, struct svc_fh *src) |
133 | { |
134 | fh_put(dst); |
135 | dget(dentry: src->fh_dentry); |
136 | if (src->fh_export) |
137 | exp_get(exp: src->fh_export); |
138 | *dst = *src; |
139 | } |
140 | |
141 | static __be32 |
142 | do_open_permission(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open, int accmode) |
143 | { |
144 | |
145 | if (open->op_truncate && |
146 | !(open->op_share_access & NFS4_SHARE_ACCESS_WRITE)) |
147 | return nfserr_inval; |
148 | |
149 | accmode |= NFSD_MAY_READ_IF_EXEC; |
150 | |
151 | if (open->op_share_access & NFS4_SHARE_ACCESS_READ) |
152 | accmode |= NFSD_MAY_READ; |
153 | if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE) |
154 | accmode |= (NFSD_MAY_WRITE | NFSD_MAY_TRUNC); |
155 | if (open->op_share_deny & NFS4_SHARE_DENY_READ) |
156 | accmode |= NFSD_MAY_WRITE; |
157 | |
158 | return fh_verify(rqstp, current_fh, S_IFREG, accmode); |
159 | } |
160 | |
161 | static __be32 nfsd_check_obj_isreg(struct svc_fh *fh) |
162 | { |
163 | umode_t mode = d_inode(dentry: fh->fh_dentry)->i_mode; |
164 | |
165 | if (S_ISREG(mode)) |
166 | return nfs_ok; |
167 | if (S_ISDIR(mode)) |
168 | return nfserr_isdir; |
169 | /* |
170 | * Using err_symlink as our catch-all case may look odd; but |
171 | * there's no other obvious error for this case in 4.0, and we |
172 | * happen to know that it will cause the linux v4 client to do |
173 | * the right thing on attempts to open something other than a |
174 | * regular file. |
175 | */ |
176 | return nfserr_symlink; |
177 | } |
178 | |
179 | static void nfsd4_set_open_owner_reply_cache(struct nfsd4_compound_state *cstate, struct nfsd4_open *open, struct svc_fh *resfh) |
180 | { |
181 | if (nfsd4_has_session(cs: cstate)) |
182 | return; |
183 | fh_copy_shallow(dst: &open->op_openowner->oo_owner.so_replay.rp_openfh, |
184 | src: &resfh->fh_handle); |
185 | } |
186 | |
187 | static inline bool nfsd4_create_is_exclusive(int createmode) |
188 | { |
189 | return createmode == NFS4_CREATE_EXCLUSIVE || |
190 | createmode == NFS4_CREATE_EXCLUSIVE4_1; |
191 | } |
192 | |
193 | static __be32 |
194 | nfsd4_vfs_create(struct svc_fh *fhp, struct dentry *child, |
195 | struct nfsd4_open *open) |
196 | { |
197 | struct file *filp; |
198 | struct path path; |
199 | int oflags; |
200 | |
201 | oflags = O_CREAT | O_LARGEFILE; |
202 | switch (open->op_share_access & NFS4_SHARE_ACCESS_BOTH) { |
203 | case NFS4_SHARE_ACCESS_WRITE: |
204 | oflags |= O_WRONLY; |
205 | break; |
206 | case NFS4_SHARE_ACCESS_BOTH: |
207 | oflags |= O_RDWR; |
208 | break; |
209 | default: |
210 | oflags |= O_RDONLY; |
211 | } |
212 | |
213 | path.mnt = fhp->fh_export->ex_path.mnt; |
214 | path.dentry = child; |
215 | filp = dentry_create(path: &path, flags: oflags, mode: open->op_iattr.ia_mode, |
216 | current_cred()); |
217 | if (IS_ERR(ptr: filp)) |
218 | return nfserrno(errno: PTR_ERR(ptr: filp)); |
219 | |
220 | open->op_filp = filp; |
221 | return nfs_ok; |
222 | } |
223 | |
224 | /* |
225 | * Implement NFSv4's unchecked, guarded, and exclusive create |
226 | * semantics for regular files. Open state for this new file is |
227 | * subsequently fabricated in nfsd4_process_open2(). |
228 | * |
229 | * Upon return, caller must release @fhp and @resfhp. |
230 | */ |
231 | static __be32 |
232 | nfsd4_create_file(struct svc_rqst *rqstp, struct svc_fh *fhp, |
233 | struct svc_fh *resfhp, struct nfsd4_open *open) |
234 | { |
235 | struct iattr *iap = &open->op_iattr; |
236 | struct nfsd_attrs attrs = { |
237 | .na_iattr = iap, |
238 | .na_seclabel = &open->op_label, |
239 | }; |
240 | struct dentry *parent, *child; |
241 | __u32 v_mtime, v_atime; |
242 | struct inode *inode; |
243 | __be32 status; |
244 | int host_err; |
245 | |
246 | if (isdotent(open->op_fname, open->op_fnamelen)) |
247 | return nfserr_exist; |
248 | if (!(iap->ia_valid & ATTR_MODE)) |
249 | iap->ia_mode = 0; |
250 | |
251 | status = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_EXEC); |
252 | if (status != nfs_ok) |
253 | return status; |
254 | parent = fhp->fh_dentry; |
255 | inode = d_inode(dentry: parent); |
256 | |
257 | host_err = fh_want_write(fh: fhp); |
258 | if (host_err) |
259 | return nfserrno(errno: host_err); |
260 | |
261 | if (is_create_with_attrs(open)) |
262 | nfsd4_acl_to_attr(type: NF4REG, acl: open->op_acl, attr: &attrs); |
263 | |
264 | inode_lock_nested(inode, subclass: I_MUTEX_PARENT); |
265 | |
266 | child = lookup_one_len(open->op_fname, parent, open->op_fnamelen); |
267 | if (IS_ERR(ptr: child)) { |
268 | status = nfserrno(errno: PTR_ERR(ptr: child)); |
269 | goto out; |
270 | } |
271 | |
272 | if (d_really_is_negative(dentry: child)) { |
273 | status = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_CREATE); |
274 | if (status != nfs_ok) |
275 | goto out; |
276 | } |
277 | |
278 | status = fh_compose(resfhp, fhp->fh_export, child, fhp); |
279 | if (status != nfs_ok) |
280 | goto out; |
281 | |
282 | v_mtime = 0; |
283 | v_atime = 0; |
284 | if (nfsd4_create_is_exclusive(createmode: open->op_createmode)) { |
285 | u32 *verifier = (u32 *)open->op_verf.data; |
286 | |
287 | /* |
288 | * Solaris 7 gets confused (bugid 4218508) if these have |
289 | * the high bit set, as do xfs filesystems without the |
290 | * "bigtime" feature. So just clear the high bits. If this |
291 | * is ever changed to use different attrs for storing the |
292 | * verifier, then do_open_lookup() will also need to be |
293 | * fixed accordingly. |
294 | */ |
295 | v_mtime = verifier[0] & 0x7fffffff; |
296 | v_atime = verifier[1] & 0x7fffffff; |
297 | } |
298 | |
299 | if (d_really_is_positive(dentry: child)) { |
300 | /* NFSv4 protocol requires change attributes even though |
301 | * no change happened. |
302 | */ |
303 | status = fh_fill_both_attrs(fhp); |
304 | if (status != nfs_ok) |
305 | goto out; |
306 | |
307 | switch (open->op_createmode) { |
308 | case NFS4_CREATE_UNCHECKED: |
309 | if (!d_is_reg(dentry: child)) |
310 | break; |
311 | |
312 | /* |
313 | * In NFSv4, we don't want to truncate the file |
314 | * now. This would be wrong if the OPEN fails for |
315 | * some other reason. Furthermore, if the size is |
316 | * nonzero, we should ignore it according to spec! |
317 | */ |
318 | open->op_truncate = (iap->ia_valid & ATTR_SIZE) && |
319 | !iap->ia_size; |
320 | break; |
321 | case NFS4_CREATE_GUARDED: |
322 | status = nfserr_exist; |
323 | break; |
324 | case NFS4_CREATE_EXCLUSIVE: |
325 | if (inode_get_mtime_sec(inode: d_inode(dentry: child)) == v_mtime && |
326 | inode_get_atime_sec(inode: d_inode(dentry: child)) == v_atime && |
327 | d_inode(dentry: child)->i_size == 0) { |
328 | open->op_created = true; |
329 | break; /* subtle */ |
330 | } |
331 | status = nfserr_exist; |
332 | break; |
333 | case NFS4_CREATE_EXCLUSIVE4_1: |
334 | if (inode_get_mtime_sec(inode: d_inode(dentry: child)) == v_mtime && |
335 | inode_get_atime_sec(inode: d_inode(dentry: child)) == v_atime && |
336 | d_inode(dentry: child)->i_size == 0) { |
337 | open->op_created = true; |
338 | goto set_attr; /* subtle */ |
339 | } |
340 | status = nfserr_exist; |
341 | } |
342 | goto out; |
343 | } |
344 | |
345 | if (!IS_POSIXACL(inode)) |
346 | iap->ia_mode &= ~current_umask(); |
347 | |
348 | status = fh_fill_pre_attrs(fhp); |
349 | if (status != nfs_ok) |
350 | goto out; |
351 | status = nfsd4_vfs_create(fhp, child, open); |
352 | if (status != nfs_ok) |
353 | goto out; |
354 | open->op_created = true; |
355 | fh_fill_post_attrs(fhp); |
356 | |
357 | /* A newly created file already has a file size of zero. */ |
358 | if ((iap->ia_valid & ATTR_SIZE) && (iap->ia_size == 0)) |
359 | iap->ia_valid &= ~ATTR_SIZE; |
360 | if (nfsd4_create_is_exclusive(createmode: open->op_createmode)) { |
361 | iap->ia_valid = ATTR_MTIME | ATTR_ATIME | |
362 | ATTR_MTIME_SET|ATTR_ATIME_SET; |
363 | iap->ia_mtime.tv_sec = v_mtime; |
364 | iap->ia_atime.tv_sec = v_atime; |
365 | iap->ia_mtime.tv_nsec = 0; |
366 | iap->ia_atime.tv_nsec = 0; |
367 | } |
368 | |
369 | set_attr: |
370 | status = nfsd_create_setattr(rqstp, fhp, resfhp, iap: &attrs); |
371 | |
372 | if (attrs.na_labelerr) |
373 | open->op_bmval[2] &= ~FATTR4_WORD2_SECURITY_LABEL; |
374 | if (attrs.na_aclerr) |
375 | open->op_bmval[0] &= ~FATTR4_WORD0_ACL; |
376 | out: |
377 | inode_unlock(inode); |
378 | nfsd_attrs_free(attrs: &attrs); |
379 | if (child && !IS_ERR(ptr: child)) |
380 | dput(child); |
381 | fh_drop_write(fh: fhp); |
382 | return status; |
383 | } |
384 | |
385 | /** |
386 | * set_change_info - set up the change_info4 for a reply |
387 | * @cinfo: pointer to nfsd4_change_info to be populated |
388 | * @fhp: pointer to svc_fh to use as source |
389 | * |
390 | * Many operations in NFSv4 require change_info4 in the reply. This function |
391 | * populates that from the info that we (should!) have already collected. In |
392 | * the event that we didn't get any pre-attrs, just zero out both. |
393 | */ |
394 | static void |
395 | set_change_info(struct nfsd4_change_info *cinfo, struct svc_fh *fhp) |
396 | { |
397 | cinfo->atomic = (u32)(fhp->fh_pre_saved && fhp->fh_post_saved && !fhp->fh_no_atomic_attr); |
398 | cinfo->before_change = fhp->fh_pre_change; |
399 | cinfo->after_change = fhp->fh_post_change; |
400 | |
401 | /* |
402 | * If fetching the pre-change attributes failed, then we should |
403 | * have already failed the whole operation. We could have still |
404 | * failed to fetch post-change attributes however. |
405 | * |
406 | * If we didn't get post-op attrs, just zero-out the after |
407 | * field since we don't know what it should be. If the pre_saved |
408 | * field isn't set for some reason, throw warning and just copy |
409 | * whatever is in the after field. |
410 | */ |
411 | if (WARN_ON_ONCE(!fhp->fh_pre_saved)) |
412 | cinfo->before_change = 0; |
413 | if (!fhp->fh_post_saved) |
414 | cinfo->after_change = cinfo->before_change + 1; |
415 | } |
416 | |
417 | static __be32 |
418 | do_open_lookup(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_open *open, struct svc_fh **resfh) |
419 | { |
420 | struct svc_fh *current_fh = &cstate->current_fh; |
421 | int accmode; |
422 | __be32 status; |
423 | |
424 | *resfh = kmalloc(size: sizeof(struct svc_fh), GFP_KERNEL); |
425 | if (!*resfh) |
426 | return nfserr_jukebox; |
427 | fh_init(fhp: *resfh, NFS4_FHSIZE); |
428 | open->op_truncate = false; |
429 | |
430 | if (open->op_create) { |
431 | /* FIXME: check session persistence and pnfs flags. |
432 | * The nfsv4.1 spec requires the following semantics: |
433 | * |
434 | * Persistent | pNFS | Server REQUIRED | Client Allowed |
435 | * Reply Cache | server | | |
436 | * -------------+--------+-----------------+-------------------- |
437 | * no | no | EXCLUSIVE4_1 | EXCLUSIVE4_1 |
438 | * | | | (SHOULD) |
439 | * | | and EXCLUSIVE4 | or EXCLUSIVE4 |
440 | * | | | (SHOULD NOT) |
441 | * no | yes | EXCLUSIVE4_1 | EXCLUSIVE4_1 |
442 | * yes | no | GUARDED4 | GUARDED4 |
443 | * yes | yes | GUARDED4 | GUARDED4 |
444 | */ |
445 | |
446 | current->fs->umask = open->op_umask; |
447 | status = nfsd4_create_file(rqstp, fhp: current_fh, resfhp: *resfh, open); |
448 | current->fs->umask = 0; |
449 | |
450 | /* |
451 | * Following rfc 3530 14.2.16, and rfc 5661 18.16.4 |
452 | * use the returned bitmask to indicate which attributes |
453 | * we used to store the verifier: |
454 | */ |
455 | if (nfsd4_create_is_exclusive(createmode: open->op_createmode) && status == 0) |
456 | open->op_bmval[1] |= (FATTR4_WORD1_TIME_ACCESS | |
457 | FATTR4_WORD1_TIME_MODIFY); |
458 | } else { |
459 | status = nfsd_lookup(rqstp, current_fh, |
460 | open->op_fname, open->op_fnamelen, *resfh); |
461 | if (status == nfs_ok) |
462 | /* NFSv4 protocol requires change attributes even though |
463 | * no change happened. |
464 | */ |
465 | status = fh_fill_both_attrs(fhp: current_fh); |
466 | } |
467 | if (status) |
468 | goto out; |
469 | status = nfsd_check_obj_isreg(fh: *resfh); |
470 | if (status) |
471 | goto out; |
472 | |
473 | nfsd4_set_open_owner_reply_cache(cstate, open, resfh: *resfh); |
474 | accmode = NFSD_MAY_NOP; |
475 | if (open->op_created || |
476 | open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR) |
477 | accmode |= NFSD_MAY_OWNER_OVERRIDE; |
478 | status = do_open_permission(rqstp, current_fh: *resfh, open, accmode); |
479 | set_change_info(cinfo: &open->op_cinfo, fhp: current_fh); |
480 | out: |
481 | return status; |
482 | } |
483 | |
484 | static __be32 |
485 | do_open_fhandle(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_open *open) |
486 | { |
487 | struct svc_fh *current_fh = &cstate->current_fh; |
488 | int accmode = 0; |
489 | |
490 | /* We don't know the target directory, and therefore can not |
491 | * set the change info |
492 | */ |
493 | |
494 | memset(&open->op_cinfo, 0, sizeof(struct nfsd4_change_info)); |
495 | |
496 | nfsd4_set_open_owner_reply_cache(cstate, open, resfh: current_fh); |
497 | |
498 | open->op_truncate = (open->op_iattr.ia_valid & ATTR_SIZE) && |
499 | (open->op_iattr.ia_size == 0); |
500 | /* |
501 | * In the delegation case, the client is telling us about an |
502 | * open that it *already* performed locally, some time ago. We |
503 | * should let it succeed now if possible. |
504 | * |
505 | * In the case of a CLAIM_FH open, on the other hand, the client |
506 | * may be counting on us to enforce permissions (the Linux 4.1 |
507 | * client uses this for normal opens, for example). |
508 | */ |
509 | if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEG_CUR_FH) |
510 | accmode = NFSD_MAY_OWNER_OVERRIDE; |
511 | |
512 | return do_open_permission(rqstp, current_fh, open, accmode); |
513 | } |
514 | |
515 | static void |
516 | copy_clientid(clientid_t *clid, struct nfsd4_session *session) |
517 | { |
518 | struct nfsd4_sessionid *sid = |
519 | (struct nfsd4_sessionid *)session->se_sessionid.data; |
520 | |
521 | clid->cl_boot = sid->clientid.cl_boot; |
522 | clid->cl_id = sid->clientid.cl_id; |
523 | } |
524 | |
525 | static __be32 |
526 | nfsd4_open(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
527 | union nfsd4_op_u *u) |
528 | { |
529 | struct nfsd4_open *open = &u->open; |
530 | __be32 status; |
531 | struct svc_fh *resfh = NULL; |
532 | struct net *net = SVC_NET(rqstp); |
533 | struct nfsd_net *nn = net_generic(net, id: nfsd_net_id); |
534 | bool reclaim = false; |
535 | |
536 | dprintk("NFSD: nfsd4_open filename %.*s op_openowner %p\n" , |
537 | (int)open->op_fnamelen, open->op_fname, |
538 | open->op_openowner); |
539 | |
540 | open->op_filp = NULL; |
541 | open->op_rqstp = rqstp; |
542 | |
543 | /* This check required by spec. */ |
544 | if (open->op_create && open->op_claim_type != NFS4_OPEN_CLAIM_NULL) |
545 | return nfserr_inval; |
546 | |
547 | open->op_created = false; |
548 | /* |
549 | * RFC5661 18.51.3 |
550 | * Before RECLAIM_COMPLETE done, server should deny new lock |
551 | */ |
552 | if (nfsd4_has_session(cs: cstate) && |
553 | !test_bit(NFSD4_CLIENT_RECLAIM_COMPLETE, &cstate->clp->cl_flags) && |
554 | open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS) |
555 | return nfserr_grace; |
556 | |
557 | if (nfsd4_has_session(cs: cstate)) |
558 | copy_clientid(clid: &open->op_clientid, session: cstate->session); |
559 | |
560 | /* check seqid for replay. set nfs4_owner */ |
561 | status = nfsd4_process_open1(cstate, open, nn); |
562 | if (status == nfserr_replay_me) { |
563 | struct nfs4_replay *rp = &open->op_openowner->oo_owner.so_replay; |
564 | fh_put(&cstate->current_fh); |
565 | fh_copy_shallow(dst: &cstate->current_fh.fh_handle, |
566 | src: &rp->rp_openfh); |
567 | status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP); |
568 | if (status) |
569 | dprintk("nfsd4_open: replay failed" |
570 | " restoring previous filehandle\n" ); |
571 | else |
572 | status = nfserr_replay_me; |
573 | } |
574 | if (status) |
575 | goto out; |
576 | if (open->op_xdr_error) { |
577 | status = open->op_xdr_error; |
578 | goto out; |
579 | } |
580 | |
581 | status = nfsd4_check_open_attributes(rqstp, cstate, open); |
582 | if (status) |
583 | goto out; |
584 | |
585 | /* Openowner is now set, so sequence id will get bumped. Now we need |
586 | * these checks before we do any creates: */ |
587 | status = nfserr_grace; |
588 | if (opens_in_grace(net) && open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS) |
589 | goto out; |
590 | status = nfserr_no_grace; |
591 | if (!opens_in_grace(net) && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS) |
592 | goto out; |
593 | |
594 | switch (open->op_claim_type) { |
595 | case NFS4_OPEN_CLAIM_DELEGATE_CUR: |
596 | case NFS4_OPEN_CLAIM_NULL: |
597 | status = do_open_lookup(rqstp, cstate, open, resfh: &resfh); |
598 | if (status) |
599 | goto out; |
600 | break; |
601 | case NFS4_OPEN_CLAIM_PREVIOUS: |
602 | status = nfs4_check_open_reclaim(cstate->clp); |
603 | if (status) |
604 | goto out; |
605 | open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED; |
606 | reclaim = true; |
607 | fallthrough; |
608 | case NFS4_OPEN_CLAIM_FH: |
609 | case NFS4_OPEN_CLAIM_DELEG_CUR_FH: |
610 | status = do_open_fhandle(rqstp, cstate, open); |
611 | if (status) |
612 | goto out; |
613 | resfh = &cstate->current_fh; |
614 | break; |
615 | case NFS4_OPEN_CLAIM_DELEG_PREV_FH: |
616 | case NFS4_OPEN_CLAIM_DELEGATE_PREV: |
617 | status = nfserr_notsupp; |
618 | goto out; |
619 | default: |
620 | status = nfserr_inval; |
621 | goto out; |
622 | } |
623 | |
624 | status = nfsd4_process_open2(rqstp, current_fh: resfh, open); |
625 | if (status && open->op_created) |
626 | pr_warn("nfsd4_process_open2 failed to open newly-created file: status=%u\n" , |
627 | be32_to_cpu(status)); |
628 | if (reclaim && !status) |
629 | nn->somebody_reclaimed = true; |
630 | out: |
631 | if (open->op_filp) { |
632 | fput(open->op_filp); |
633 | open->op_filp = NULL; |
634 | } |
635 | if (resfh && resfh != &cstate->current_fh) { |
636 | fh_dup2(dst: &cstate->current_fh, src: resfh); |
637 | fh_put(resfh); |
638 | kfree(objp: resfh); |
639 | } |
640 | nfsd4_cleanup_open_state(cstate, open); |
641 | nfsd4_bump_seqid(cstate, nfserr: status); |
642 | return status; |
643 | } |
644 | |
645 | /* |
646 | * OPEN is the only seqid-mutating operation whose decoding can fail |
647 | * with a seqid-mutating error (specifically, decoding of user names in |
648 | * the attributes). Therefore we have to do some processing to look up |
649 | * the stateowner so that we can bump the seqid. |
650 | */ |
651 | static __be32 nfsd4_open_omfg(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_op *op) |
652 | { |
653 | struct nfsd4_open *open = &op->u.open; |
654 | |
655 | if (!seqid_mutating_err(ntohl(op->status))) |
656 | return op->status; |
657 | if (nfsd4_has_session(cs: cstate)) |
658 | return op->status; |
659 | open->op_xdr_error = op->status; |
660 | return nfsd4_open(rqstp, cstate, u: &op->u); |
661 | } |
662 | |
663 | /* |
664 | * filehandle-manipulating ops. |
665 | */ |
666 | static __be32 |
667 | nfsd4_getfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
668 | union nfsd4_op_u *u) |
669 | { |
670 | u->getfh = &cstate->current_fh; |
671 | return nfs_ok; |
672 | } |
673 | |
674 | static __be32 |
675 | nfsd4_putfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
676 | union nfsd4_op_u *u) |
677 | { |
678 | struct nfsd4_putfh *putfh = &u->putfh; |
679 | __be32 ret; |
680 | |
681 | fh_put(&cstate->current_fh); |
682 | cstate->current_fh.fh_handle.fh_size = putfh->pf_fhlen; |
683 | memcpy(&cstate->current_fh.fh_handle.fh_raw, putfh->pf_fhval, |
684 | putfh->pf_fhlen); |
685 | ret = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_BYPASS_GSS); |
686 | #ifdef CONFIG_NFSD_V4_2_INTER_SSC |
687 | if (ret == nfserr_stale && putfh->no_verify) { |
688 | SET_FH_FLAG(&cstate->current_fh, NFSD4_FH_FOREIGN); |
689 | ret = 0; |
690 | } |
691 | #endif |
692 | return ret; |
693 | } |
694 | |
695 | static __be32 |
696 | nfsd4_putrootfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
697 | union nfsd4_op_u *u) |
698 | { |
699 | fh_put(&cstate->current_fh); |
700 | |
701 | return exp_pseudoroot(rqstp, &cstate->current_fh); |
702 | } |
703 | |
704 | static __be32 |
705 | nfsd4_restorefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
706 | union nfsd4_op_u *u) |
707 | { |
708 | if (!cstate->save_fh.fh_dentry) |
709 | return nfserr_restorefh; |
710 | |
711 | fh_dup2(dst: &cstate->current_fh, src: &cstate->save_fh); |
712 | if (HAS_CSTATE_FLAG(cstate, SAVED_STATE_ID_FLAG)) { |
713 | memcpy(&cstate->current_stateid, &cstate->save_stateid, sizeof(stateid_t)); |
714 | SET_CSTATE_FLAG(cstate, CURRENT_STATE_ID_FLAG); |
715 | } |
716 | return nfs_ok; |
717 | } |
718 | |
719 | static __be32 |
720 | nfsd4_savefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
721 | union nfsd4_op_u *u) |
722 | { |
723 | fh_dup2(dst: &cstate->save_fh, src: &cstate->current_fh); |
724 | if (HAS_CSTATE_FLAG(cstate, CURRENT_STATE_ID_FLAG)) { |
725 | memcpy(&cstate->save_stateid, &cstate->current_stateid, sizeof(stateid_t)); |
726 | SET_CSTATE_FLAG(cstate, SAVED_STATE_ID_FLAG); |
727 | } |
728 | return nfs_ok; |
729 | } |
730 | |
731 | /* |
732 | * misc nfsv4 ops |
733 | */ |
734 | static __be32 |
735 | nfsd4_access(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
736 | union nfsd4_op_u *u) |
737 | { |
738 | struct nfsd4_access *access = &u->access; |
739 | u32 access_full; |
740 | |
741 | access_full = NFS3_ACCESS_FULL; |
742 | if (cstate->minorversion >= 2) |
743 | access_full |= NFS4_ACCESS_XALIST | NFS4_ACCESS_XAREAD | |
744 | NFS4_ACCESS_XAWRITE; |
745 | |
746 | if (access->ac_req_access & ~access_full) |
747 | return nfserr_inval; |
748 | |
749 | access->ac_resp_access = access->ac_req_access; |
750 | return nfsd_access(rqstp, &cstate->current_fh, &access->ac_resp_access, |
751 | &access->ac_supported); |
752 | } |
753 | |
754 | static void gen_boot_verifier(nfs4_verifier *verifier, struct net *net) |
755 | { |
756 | __be32 *verf = (__be32 *)verifier->data; |
757 | |
758 | BUILD_BUG_ON(2*sizeof(*verf) != sizeof(verifier->data)); |
759 | |
760 | nfsd_copy_write_verifier(verf, nn: net_generic(net, id: nfsd_net_id)); |
761 | } |
762 | |
763 | static __be32 |
764 | nfsd4_commit(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
765 | union nfsd4_op_u *u) |
766 | { |
767 | struct nfsd4_commit *commit = &u->commit; |
768 | struct nfsd_file *nf; |
769 | __be32 status; |
770 | |
771 | status = nfsd_file_acquire(rqstp, fhp: &cstate->current_fh, NFSD_MAY_WRITE | |
772 | NFSD_MAY_NOT_BREAK_LEASE, nfp: &nf); |
773 | if (status != nfs_ok) |
774 | return status; |
775 | |
776 | status = nfsd_commit(rqst: rqstp, fhp: &cstate->current_fh, nf, offset: commit->co_offset, |
777 | count: commit->co_count, |
778 | verf: (__be32 *)commit->co_verf.data); |
779 | nfsd_file_put(nf); |
780 | return status; |
781 | } |
782 | |
783 | static __be32 |
784 | nfsd4_create(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
785 | union nfsd4_op_u *u) |
786 | { |
787 | struct nfsd4_create *create = &u->create; |
788 | struct nfsd_attrs attrs = { |
789 | .na_iattr = &create->cr_iattr, |
790 | .na_seclabel = &create->cr_label, |
791 | }; |
792 | struct svc_fh resfh; |
793 | __be32 status; |
794 | dev_t rdev; |
795 | |
796 | fh_init(fhp: &resfh, NFS4_FHSIZE); |
797 | |
798 | status = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_NOP); |
799 | if (status) |
800 | return status; |
801 | |
802 | status = check_attr_support(rqstp, cstate, bmval: create->cr_bmval, |
803 | writable: nfsd_attrmask); |
804 | if (status) |
805 | return status; |
806 | |
807 | status = nfsd4_acl_to_attr(type: create->cr_type, acl: create->cr_acl, attr: &attrs); |
808 | current->fs->umask = create->cr_umask; |
809 | switch (create->cr_type) { |
810 | case NF4LNK: |
811 | status = nfsd_symlink(rqstp, &cstate->current_fh, |
812 | name: create->cr_name, len: create->cr_namelen, |
813 | path: create->cr_data, attrs: &attrs, res: &resfh); |
814 | break; |
815 | |
816 | case NF4BLK: |
817 | status = nfserr_inval; |
818 | rdev = MKDEV(create->cr_specdata1, create->cr_specdata2); |
819 | if (MAJOR(rdev) != create->cr_specdata1 || |
820 | MINOR(rdev) != create->cr_specdata2) |
821 | goto out_umask; |
822 | status = nfsd_create(rqstp, &cstate->current_fh, |
823 | name: create->cr_name, len: create->cr_namelen, |
824 | attrs: &attrs, S_IFBLK, rdev, res: &resfh); |
825 | break; |
826 | |
827 | case NF4CHR: |
828 | status = nfserr_inval; |
829 | rdev = MKDEV(create->cr_specdata1, create->cr_specdata2); |
830 | if (MAJOR(rdev) != create->cr_specdata1 || |
831 | MINOR(rdev) != create->cr_specdata2) |
832 | goto out_umask; |
833 | status = nfsd_create(rqstp, &cstate->current_fh, |
834 | name: create->cr_name, len: create->cr_namelen, |
835 | attrs: &attrs, S_IFCHR, rdev, res: &resfh); |
836 | break; |
837 | |
838 | case NF4SOCK: |
839 | status = nfsd_create(rqstp, &cstate->current_fh, |
840 | name: create->cr_name, len: create->cr_namelen, |
841 | attrs: &attrs, S_IFSOCK, rdev: 0, res: &resfh); |
842 | break; |
843 | |
844 | case NF4FIFO: |
845 | status = nfsd_create(rqstp, &cstate->current_fh, |
846 | name: create->cr_name, len: create->cr_namelen, |
847 | attrs: &attrs, S_IFIFO, rdev: 0, res: &resfh); |
848 | break; |
849 | |
850 | case NF4DIR: |
851 | create->cr_iattr.ia_valid &= ~ATTR_SIZE; |
852 | status = nfsd_create(rqstp, &cstate->current_fh, |
853 | name: create->cr_name, len: create->cr_namelen, |
854 | attrs: &attrs, S_IFDIR, rdev: 0, res: &resfh); |
855 | break; |
856 | |
857 | default: |
858 | status = nfserr_badtype; |
859 | } |
860 | |
861 | if (status) |
862 | goto out; |
863 | |
864 | if (attrs.na_labelerr) |
865 | create->cr_bmval[2] &= ~FATTR4_WORD2_SECURITY_LABEL; |
866 | if (attrs.na_aclerr) |
867 | create->cr_bmval[0] &= ~FATTR4_WORD0_ACL; |
868 | set_change_info(cinfo: &create->cr_cinfo, fhp: &cstate->current_fh); |
869 | fh_dup2(dst: &cstate->current_fh, src: &resfh); |
870 | out: |
871 | fh_put(&resfh); |
872 | out_umask: |
873 | current->fs->umask = 0; |
874 | nfsd_attrs_free(attrs: &attrs); |
875 | return status; |
876 | } |
877 | |
878 | static __be32 |
879 | nfsd4_getattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
880 | union nfsd4_op_u *u) |
881 | { |
882 | struct nfsd4_getattr *getattr = &u->getattr; |
883 | __be32 status; |
884 | |
885 | status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP); |
886 | if (status) |
887 | return status; |
888 | |
889 | if (getattr->ga_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1) |
890 | return nfserr_inval; |
891 | |
892 | getattr->ga_bmval[0] &= nfsd_suppattrs[cstate->minorversion][0]; |
893 | getattr->ga_bmval[1] &= nfsd_suppattrs[cstate->minorversion][1]; |
894 | getattr->ga_bmval[2] &= nfsd_suppattrs[cstate->minorversion][2]; |
895 | |
896 | getattr->ga_fhp = &cstate->current_fh; |
897 | return nfs_ok; |
898 | } |
899 | |
900 | static __be32 |
901 | nfsd4_link(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
902 | union nfsd4_op_u *u) |
903 | { |
904 | struct nfsd4_link *link = &u->link; |
905 | __be32 status; |
906 | |
907 | status = nfsd_link(rqstp, &cstate->current_fh, |
908 | link->li_name, link->li_namelen, &cstate->save_fh); |
909 | if (!status) |
910 | set_change_info(cinfo: &link->li_cinfo, fhp: &cstate->current_fh); |
911 | return status; |
912 | } |
913 | |
914 | static __be32 nfsd4_do_lookupp(struct svc_rqst *rqstp, struct svc_fh *fh) |
915 | { |
916 | struct svc_fh tmp_fh; |
917 | __be32 ret; |
918 | |
919 | fh_init(fhp: &tmp_fh, NFS4_FHSIZE); |
920 | ret = exp_pseudoroot(rqstp, &tmp_fh); |
921 | if (ret) |
922 | return ret; |
923 | if (tmp_fh.fh_dentry == fh->fh_dentry) { |
924 | fh_put(&tmp_fh); |
925 | return nfserr_noent; |
926 | } |
927 | fh_put(&tmp_fh); |
928 | return nfsd_lookup(rqstp, fh, ".." , 2, fh); |
929 | } |
930 | |
931 | static __be32 |
932 | nfsd4_lookupp(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
933 | union nfsd4_op_u *u) |
934 | { |
935 | return nfsd4_do_lookupp(rqstp, fh: &cstate->current_fh); |
936 | } |
937 | |
938 | static __be32 |
939 | nfsd4_lookup(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
940 | union nfsd4_op_u *u) |
941 | { |
942 | return nfsd_lookup(rqstp, &cstate->current_fh, |
943 | u->lookup.lo_name, u->lookup.lo_len, |
944 | &cstate->current_fh); |
945 | } |
946 | |
947 | static __be32 |
948 | nfsd4_read(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
949 | union nfsd4_op_u *u) |
950 | { |
951 | struct nfsd4_read *read = &u->read; |
952 | __be32 status; |
953 | |
954 | read->rd_nf = NULL; |
955 | |
956 | trace_nfsd_read_start(rqstp, fhp: &cstate->current_fh, |
957 | offset: read->rd_offset, len: read->rd_length); |
958 | |
959 | read->rd_length = min_t(u32, read->rd_length, svc_max_payload(rqstp)); |
960 | if (read->rd_offset > (u64)OFFSET_MAX) |
961 | read->rd_offset = (u64)OFFSET_MAX; |
962 | if (read->rd_offset + read->rd_length > (u64)OFFSET_MAX) |
963 | read->rd_length = (u64)OFFSET_MAX - read->rd_offset; |
964 | |
965 | /* |
966 | * If we do a zero copy read, then a client will see read data |
967 | * that reflects the state of the file *after* performing the |
968 | * following compound. |
969 | * |
970 | * To ensure proper ordering, we therefore turn off zero copy if |
971 | * the client wants us to do more in this compound: |
972 | */ |
973 | if (!nfsd4_last_compound_op(rqstp)) |
974 | clear_bit(nr: RQ_SPLICE_OK, addr: &rqstp->rq_flags); |
975 | |
976 | /* check stateid */ |
977 | status = nfs4_preprocess_stateid_op(rqstp, cstate, fhp: &cstate->current_fh, |
978 | stateid: &read->rd_stateid, RD_STATE, |
979 | filp: &read->rd_nf, NULL); |
980 | |
981 | read->rd_rqstp = rqstp; |
982 | read->rd_fhp = &cstate->current_fh; |
983 | return status; |
984 | } |
985 | |
986 | |
987 | static void |
988 | nfsd4_read_release(union nfsd4_op_u *u) |
989 | { |
990 | if (u->read.rd_nf) |
991 | nfsd_file_put(nf: u->read.rd_nf); |
992 | trace_nfsd_read_done(rqstp: u->read.rd_rqstp, fhp: u->read.rd_fhp, |
993 | offset: u->read.rd_offset, len: u->read.rd_length); |
994 | } |
995 | |
996 | static __be32 |
997 | nfsd4_readdir(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
998 | union nfsd4_op_u *u) |
999 | { |
1000 | struct nfsd4_readdir *readdir = &u->readdir; |
1001 | u64 cookie = readdir->rd_cookie; |
1002 | static const nfs4_verifier zeroverf; |
1003 | |
1004 | /* no need to check permission - this will be done in nfsd_readdir() */ |
1005 | |
1006 | if (readdir->rd_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1) |
1007 | return nfserr_inval; |
1008 | |
1009 | readdir->rd_bmval[0] &= nfsd_suppattrs[cstate->minorversion][0]; |
1010 | readdir->rd_bmval[1] &= nfsd_suppattrs[cstate->minorversion][1]; |
1011 | readdir->rd_bmval[2] &= nfsd_suppattrs[cstate->minorversion][2]; |
1012 | |
1013 | if ((cookie == 1) || (cookie == 2) || |
1014 | (cookie == 0 && memcmp(p: readdir->rd_verf.data, q: zeroverf.data, NFS4_VERIFIER_SIZE))) |
1015 | return nfserr_bad_cookie; |
1016 | |
1017 | readdir->rd_rqstp = rqstp; |
1018 | readdir->rd_fhp = &cstate->current_fh; |
1019 | return nfs_ok; |
1020 | } |
1021 | |
1022 | static __be32 |
1023 | nfsd4_readlink(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
1024 | union nfsd4_op_u *u) |
1025 | { |
1026 | u->readlink.rl_rqstp = rqstp; |
1027 | u->readlink.rl_fhp = &cstate->current_fh; |
1028 | return nfs_ok; |
1029 | } |
1030 | |
1031 | static __be32 |
1032 | nfsd4_remove(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
1033 | union nfsd4_op_u *u) |
1034 | { |
1035 | struct nfsd4_remove *remove = &u->remove; |
1036 | __be32 status; |
1037 | |
1038 | if (opens_in_grace(SVC_NET(rqstp))) |
1039 | return nfserr_grace; |
1040 | status = nfsd_unlink(rqstp, &cstate->current_fh, type: 0, |
1041 | name: remove->rm_name, len: remove->rm_namelen); |
1042 | if (!status) |
1043 | set_change_info(cinfo: &remove->rm_cinfo, fhp: &cstate->current_fh); |
1044 | return status; |
1045 | } |
1046 | |
1047 | static __be32 |
1048 | nfsd4_rename(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
1049 | union nfsd4_op_u *u) |
1050 | { |
1051 | struct nfsd4_rename *rename = &u->rename; |
1052 | __be32 status; |
1053 | |
1054 | if (opens_in_grace(SVC_NET(rqstp))) |
1055 | return nfserr_grace; |
1056 | status = nfsd_rename(rqstp, &cstate->save_fh, rename->rn_sname, |
1057 | rename->rn_snamelen, &cstate->current_fh, |
1058 | rename->rn_tname, rename->rn_tnamelen); |
1059 | if (status) |
1060 | return status; |
1061 | set_change_info(cinfo: &rename->rn_sinfo, fhp: &cstate->save_fh); |
1062 | set_change_info(cinfo: &rename->rn_tinfo, fhp: &cstate->current_fh); |
1063 | return nfs_ok; |
1064 | } |
1065 | |
1066 | static __be32 |
1067 | nfsd4_secinfo(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
1068 | union nfsd4_op_u *u) |
1069 | { |
1070 | struct nfsd4_secinfo *secinfo = &u->secinfo; |
1071 | struct svc_export *exp; |
1072 | struct dentry *dentry; |
1073 | __be32 err; |
1074 | |
1075 | err = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_EXEC); |
1076 | if (err) |
1077 | return err; |
1078 | err = nfsd_lookup_dentry(rqstp, &cstate->current_fh, |
1079 | secinfo->si_name, secinfo->si_namelen, |
1080 | &exp, &dentry); |
1081 | if (err) |
1082 | return err; |
1083 | if (d_really_is_negative(dentry)) { |
1084 | exp_put(exp); |
1085 | err = nfserr_noent; |
1086 | } else |
1087 | secinfo->si_exp = exp; |
1088 | dput(dentry); |
1089 | if (cstate->minorversion) |
1090 | /* See rfc 5661 section 2.6.3.1.1.8 */ |
1091 | fh_put(&cstate->current_fh); |
1092 | return err; |
1093 | } |
1094 | |
1095 | static __be32 |
1096 | nfsd4_secinfo_no_name(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
1097 | union nfsd4_op_u *u) |
1098 | { |
1099 | __be32 err; |
1100 | |
1101 | switch (u->secinfo_no_name.sin_style) { |
1102 | case NFS4_SECINFO_STYLE4_CURRENT_FH: |
1103 | break; |
1104 | case NFS4_SECINFO_STYLE4_PARENT: |
1105 | err = nfsd4_do_lookupp(rqstp, fh: &cstate->current_fh); |
1106 | if (err) |
1107 | return err; |
1108 | break; |
1109 | default: |
1110 | return nfserr_inval; |
1111 | } |
1112 | |
1113 | u->secinfo_no_name.sin_exp = exp_get(exp: cstate->current_fh.fh_export); |
1114 | fh_put(&cstate->current_fh); |
1115 | return nfs_ok; |
1116 | } |
1117 | |
1118 | static void |
1119 | nfsd4_secinfo_release(union nfsd4_op_u *u) |
1120 | { |
1121 | if (u->secinfo.si_exp) |
1122 | exp_put(exp: u->secinfo.si_exp); |
1123 | } |
1124 | |
1125 | static void |
1126 | nfsd4_secinfo_no_name_release(union nfsd4_op_u *u) |
1127 | { |
1128 | if (u->secinfo_no_name.sin_exp) |
1129 | exp_put(exp: u->secinfo_no_name.sin_exp); |
1130 | } |
1131 | |
1132 | static __be32 |
1133 | nfsd4_setattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
1134 | union nfsd4_op_u *u) |
1135 | { |
1136 | struct nfsd4_setattr *setattr = &u->setattr; |
1137 | struct nfsd_attrs attrs = { |
1138 | .na_iattr = &setattr->sa_iattr, |
1139 | .na_seclabel = &setattr->sa_label, |
1140 | }; |
1141 | struct inode *inode; |
1142 | __be32 status = nfs_ok; |
1143 | int err; |
1144 | |
1145 | if (setattr->sa_iattr.ia_valid & ATTR_SIZE) { |
1146 | status = nfs4_preprocess_stateid_op(rqstp, cstate, |
1147 | fhp: &cstate->current_fh, stateid: &setattr->sa_stateid, |
1148 | WR_STATE, NULL, NULL); |
1149 | if (status) |
1150 | return status; |
1151 | } |
1152 | err = fh_want_write(fh: &cstate->current_fh); |
1153 | if (err) |
1154 | return nfserrno(errno: err); |
1155 | status = nfs_ok; |
1156 | |
1157 | status = check_attr_support(rqstp, cstate, bmval: setattr->sa_bmval, |
1158 | writable: nfsd_attrmask); |
1159 | if (status) |
1160 | goto out; |
1161 | |
1162 | inode = cstate->current_fh.fh_dentry->d_inode; |
1163 | status = nfsd4_acl_to_attr(S_ISDIR(inode->i_mode) ? NF4DIR : NF4REG, |
1164 | acl: setattr->sa_acl, attr: &attrs); |
1165 | |
1166 | if (status) |
1167 | goto out; |
1168 | status = nfsd_setattr(rqstp, &cstate->current_fh, &attrs, |
1169 | 0, (time64_t)0); |
1170 | if (!status) |
1171 | status = nfserrno(errno: attrs.na_labelerr); |
1172 | if (!status) |
1173 | status = nfserrno(errno: attrs.na_aclerr); |
1174 | out: |
1175 | nfsd_attrs_free(attrs: &attrs); |
1176 | fh_drop_write(fh: &cstate->current_fh); |
1177 | return status; |
1178 | } |
1179 | |
1180 | static __be32 |
1181 | nfsd4_write(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
1182 | union nfsd4_op_u *u) |
1183 | { |
1184 | struct nfsd4_write *write = &u->write; |
1185 | stateid_t *stateid = &write->wr_stateid; |
1186 | struct nfsd_file *nf = NULL; |
1187 | __be32 status = nfs_ok; |
1188 | unsigned long cnt; |
1189 | int nvecs; |
1190 | |
1191 | if (write->wr_offset > (u64)OFFSET_MAX || |
1192 | write->wr_offset + write->wr_buflen > (u64)OFFSET_MAX) |
1193 | return nfserr_fbig; |
1194 | |
1195 | cnt = write->wr_buflen; |
1196 | trace_nfsd_write_start(rqstp, fhp: &cstate->current_fh, |
1197 | offset: write->wr_offset, len: cnt); |
1198 | status = nfs4_preprocess_stateid_op(rqstp, cstate, fhp: &cstate->current_fh, |
1199 | stateid, WR_STATE, filp: &nf, NULL); |
1200 | if (status) |
1201 | return status; |
1202 | |
1203 | write->wr_how_written = write->wr_stable_how; |
1204 | |
1205 | nvecs = svc_fill_write_vector(rqstp, payload: &write->wr_payload); |
1206 | WARN_ON_ONCE(nvecs > ARRAY_SIZE(rqstp->rq_vec)); |
1207 | |
1208 | status = nfsd_vfs_write(rqstp, fhp: &cstate->current_fh, nf, |
1209 | offset: write->wr_offset, vec: rqstp->rq_vec, vlen: nvecs, cnt: &cnt, |
1210 | stable: write->wr_how_written, |
1211 | verf: (__be32 *)write->wr_verifier.data); |
1212 | nfsd_file_put(nf); |
1213 | |
1214 | write->wr_bytes_written = cnt; |
1215 | trace_nfsd_write_done(rqstp, fhp: &cstate->current_fh, |
1216 | offset: write->wr_offset, len: cnt); |
1217 | return status; |
1218 | } |
1219 | |
1220 | static __be32 |
1221 | nfsd4_verify_copy(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
1222 | stateid_t *src_stateid, struct nfsd_file **src, |
1223 | stateid_t *dst_stateid, struct nfsd_file **dst) |
1224 | { |
1225 | __be32 status; |
1226 | |
1227 | if (!cstate->save_fh.fh_dentry) |
1228 | return nfserr_nofilehandle; |
1229 | |
1230 | status = nfs4_preprocess_stateid_op(rqstp, cstate, fhp: &cstate->save_fh, |
1231 | stateid: src_stateid, RD_STATE, filp: src, NULL); |
1232 | if (status) |
1233 | goto out; |
1234 | |
1235 | status = nfs4_preprocess_stateid_op(rqstp, cstate, fhp: &cstate->current_fh, |
1236 | stateid: dst_stateid, WR_STATE, filp: dst, NULL); |
1237 | if (status) |
1238 | goto out_put_src; |
1239 | |
1240 | /* fix up for NFS-specific error code */ |
1241 | if (!S_ISREG(file_inode((*src)->nf_file)->i_mode) || |
1242 | !S_ISREG(file_inode((*dst)->nf_file)->i_mode)) { |
1243 | status = nfserr_wrong_type; |
1244 | goto out_put_dst; |
1245 | } |
1246 | |
1247 | out: |
1248 | return status; |
1249 | out_put_dst: |
1250 | nfsd_file_put(nf: *dst); |
1251 | *dst = NULL; |
1252 | out_put_src: |
1253 | nfsd_file_put(nf: *src); |
1254 | *src = NULL; |
1255 | goto out; |
1256 | } |
1257 | |
1258 | static __be32 |
1259 | nfsd4_clone(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
1260 | union nfsd4_op_u *u) |
1261 | { |
1262 | struct nfsd4_clone *clone = &u->clone; |
1263 | struct nfsd_file *src, *dst; |
1264 | __be32 status; |
1265 | |
1266 | status = nfsd4_verify_copy(rqstp, cstate, src_stateid: &clone->cl_src_stateid, src: &src, |
1267 | dst_stateid: &clone->cl_dst_stateid, dst: &dst); |
1268 | if (status) |
1269 | goto out; |
1270 | |
1271 | status = nfsd4_clone_file_range(rqstp, nf_src: src, src_pos: clone->cl_src_pos, |
1272 | nf_dst: dst, dst_pos: clone->cl_dst_pos, count: clone->cl_count, |
1273 | EX_ISSYNC(cstate->current_fh.fh_export)); |
1274 | |
1275 | nfsd_file_put(nf: dst); |
1276 | nfsd_file_put(nf: src); |
1277 | out: |
1278 | return status; |
1279 | } |
1280 | |
1281 | static void nfs4_put_copy(struct nfsd4_copy *copy) |
1282 | { |
1283 | if (!refcount_dec_and_test(r: ©->refcount)) |
1284 | return; |
1285 | kfree(objp: copy->cp_src); |
1286 | kfree(objp: copy); |
1287 | } |
1288 | |
1289 | static void nfsd4_stop_copy(struct nfsd4_copy *copy) |
1290 | { |
1291 | if (!test_and_set_bit(NFSD4_COPY_F_STOPPED, addr: ©->cp_flags)) |
1292 | kthread_stop(k: copy->copy_task); |
1293 | nfs4_put_copy(copy); |
1294 | } |
1295 | |
1296 | static struct nfsd4_copy *nfsd4_get_copy(struct nfs4_client *clp) |
1297 | { |
1298 | struct nfsd4_copy *copy = NULL; |
1299 | |
1300 | spin_lock(lock: &clp->async_lock); |
1301 | if (!list_empty(head: &clp->async_copies)) { |
1302 | copy = list_first_entry(&clp->async_copies, struct nfsd4_copy, |
1303 | copies); |
1304 | refcount_inc(r: ©->refcount); |
1305 | } |
1306 | spin_unlock(lock: &clp->async_lock); |
1307 | return copy; |
1308 | } |
1309 | |
1310 | void nfsd4_shutdown_copy(struct nfs4_client *clp) |
1311 | { |
1312 | struct nfsd4_copy *copy; |
1313 | |
1314 | while ((copy = nfsd4_get_copy(clp)) != NULL) |
1315 | nfsd4_stop_copy(copy); |
1316 | } |
1317 | #ifdef CONFIG_NFSD_V4_2_INTER_SSC |
1318 | |
1319 | extern struct file *nfs42_ssc_open(struct vfsmount *ss_mnt, |
1320 | struct nfs_fh *src_fh, |
1321 | nfs4_stateid *stateid); |
1322 | extern void nfs42_ssc_close(struct file *filep); |
1323 | |
1324 | extern void nfs_sb_deactive(struct super_block *sb); |
1325 | |
1326 | #define "vers=4.2,addr=%s,sec=sys" |
1327 | |
1328 | /* |
1329 | * setup a work entry in the ssc delayed unmount list. |
1330 | */ |
1331 | static __be32 nfsd4_ssc_setup_dul(struct nfsd_net *nn, char *ipaddr, |
1332 | struct nfsd4_ssc_umount_item **nsui, |
1333 | struct svc_rqst *rqstp) |
1334 | { |
1335 | struct nfsd4_ssc_umount_item *ni = NULL; |
1336 | struct nfsd4_ssc_umount_item *work = NULL; |
1337 | struct nfsd4_ssc_umount_item *tmp; |
1338 | DEFINE_WAIT(wait); |
1339 | __be32 status = 0; |
1340 | |
1341 | *nsui = NULL; |
1342 | work = kzalloc(size: sizeof(*work), GFP_KERNEL); |
1343 | try_again: |
1344 | spin_lock(lock: &nn->nfsd_ssc_lock); |
1345 | list_for_each_entry_safe(ni, tmp, &nn->nfsd_ssc_mount_list, nsui_list) { |
1346 | if (strncmp(ni->nsui_ipaddr, ipaddr, sizeof(ni->nsui_ipaddr))) |
1347 | continue; |
1348 | /* found a match */ |
1349 | if (ni->nsui_busy) { |
1350 | /* wait - and try again */ |
1351 | prepare_to_wait(wq_head: &nn->nfsd_ssc_waitq, wq_entry: &wait, TASK_IDLE); |
1352 | spin_unlock(lock: &nn->nfsd_ssc_lock); |
1353 | |
1354 | /* allow 20secs for mount/unmount for now - revisit */ |
1355 | if (svc_thread_should_stop(rqstp) || |
1356 | (schedule_timeout(timeout: 20*HZ) == 0)) { |
1357 | finish_wait(wq_head: &nn->nfsd_ssc_waitq, wq_entry: &wait); |
1358 | kfree(objp: work); |
1359 | return nfserr_eagain; |
1360 | } |
1361 | finish_wait(wq_head: &nn->nfsd_ssc_waitq, wq_entry: &wait); |
1362 | goto try_again; |
1363 | } |
1364 | *nsui = ni; |
1365 | refcount_inc(r: &ni->nsui_refcnt); |
1366 | spin_unlock(lock: &nn->nfsd_ssc_lock); |
1367 | kfree(objp: work); |
1368 | |
1369 | /* return vfsmount in (*nsui)->nsui_vfsmount */ |
1370 | return 0; |
1371 | } |
1372 | if (work) { |
1373 | strscpy(p: work->nsui_ipaddr, q: ipaddr, size: sizeof(work->nsui_ipaddr) - 1); |
1374 | refcount_set(r: &work->nsui_refcnt, n: 2); |
1375 | work->nsui_busy = true; |
1376 | list_add_tail(new: &work->nsui_list, head: &nn->nfsd_ssc_mount_list); |
1377 | *nsui = work; |
1378 | } else |
1379 | status = nfserr_resource; |
1380 | spin_unlock(lock: &nn->nfsd_ssc_lock); |
1381 | return status; |
1382 | } |
1383 | |
1384 | static void nfsd4_ssc_update_dul(struct nfsd_net *nn, |
1385 | struct nfsd4_ssc_umount_item *nsui, |
1386 | struct vfsmount *ss_mnt) |
1387 | { |
1388 | spin_lock(lock: &nn->nfsd_ssc_lock); |
1389 | nsui->nsui_vfsmount = ss_mnt; |
1390 | nsui->nsui_busy = false; |
1391 | wake_up_all(&nn->nfsd_ssc_waitq); |
1392 | spin_unlock(lock: &nn->nfsd_ssc_lock); |
1393 | } |
1394 | |
1395 | static void nfsd4_ssc_cancel_dul(struct nfsd_net *nn, |
1396 | struct nfsd4_ssc_umount_item *nsui) |
1397 | { |
1398 | spin_lock(lock: &nn->nfsd_ssc_lock); |
1399 | list_del(entry: &nsui->nsui_list); |
1400 | wake_up_all(&nn->nfsd_ssc_waitq); |
1401 | spin_unlock(lock: &nn->nfsd_ssc_lock); |
1402 | kfree(objp: nsui); |
1403 | } |
1404 | |
1405 | /* |
1406 | * Support one copy source server for now. |
1407 | */ |
1408 | static __be32 |
1409 | (struct nl4_server *nss, struct svc_rqst *rqstp, |
1410 | struct nfsd4_ssc_umount_item **nsui) |
1411 | { |
1412 | struct file_system_type *type; |
1413 | struct vfsmount *ss_mnt; |
1414 | struct nfs42_netaddr *naddr; |
1415 | struct sockaddr_storage tmp_addr; |
1416 | size_t tmp_addrlen, match_netid_len = 3; |
1417 | char *startsep = "" , *endsep = "" , *match_netid = "tcp" ; |
1418 | char *ipaddr, *dev_name, *raw_data; |
1419 | int len, raw_len; |
1420 | __be32 status = nfserr_inval; |
1421 | struct nfsd_net *nn = net_generic(SVC_NET(rqstp), id: nfsd_net_id); |
1422 | |
1423 | naddr = &nss->u.nl4_addr; |
1424 | tmp_addrlen = rpc_uaddr2sockaddr(SVC_NET(rqstp), naddr->addr, |
1425 | naddr->addr_len, |
1426 | (struct sockaddr *)&tmp_addr, |
1427 | sizeof(tmp_addr)); |
1428 | *nsui = NULL; |
1429 | if (tmp_addrlen == 0) |
1430 | goto out_err; |
1431 | |
1432 | if (tmp_addr.ss_family == AF_INET6) { |
1433 | startsep = "[" ; |
1434 | endsep = "]" ; |
1435 | match_netid = "tcp6" ; |
1436 | match_netid_len = 4; |
1437 | } |
1438 | |
1439 | if (naddr->netid_len != match_netid_len || |
1440 | strncmp(naddr->netid, match_netid, naddr->netid_len)) |
1441 | goto out_err; |
1442 | |
1443 | /* Construct the raw data for the vfs_kern_mount call */ |
1444 | len = RPC_MAX_ADDRBUFLEN + 1; |
1445 | ipaddr = kzalloc(size: len, GFP_KERNEL); |
1446 | if (!ipaddr) |
1447 | goto out_err; |
1448 | |
1449 | rpc_ntop((struct sockaddr *)&tmp_addr, ipaddr, len); |
1450 | |
1451 | /* 2 for ipv6 endsep and startsep. 3 for ":/" and trailing '/0'*/ |
1452 | |
1453 | raw_len = strlen(NFSD42_INTERSSC_MOUNTOPS) + strlen(ipaddr); |
1454 | raw_data = kzalloc(size: raw_len, GFP_KERNEL); |
1455 | if (!raw_data) |
1456 | goto out_free_ipaddr; |
1457 | |
1458 | snprintf(buf: raw_data, size: raw_len, NFSD42_INTERSSC_MOUNTOPS, ipaddr); |
1459 | |
1460 | status = nfserr_nodev; |
1461 | type = get_fs_type(name: "nfs" ); |
1462 | if (!type) |
1463 | goto out_free_rawdata; |
1464 | |
1465 | /* Set the server:<export> for the vfs_kern_mount call */ |
1466 | dev_name = kzalloc(size: len + 5, GFP_KERNEL); |
1467 | if (!dev_name) |
1468 | goto out_free_rawdata; |
1469 | snprintf(buf: dev_name, size: len + 5, fmt: "%s%s%s:/" , startsep, ipaddr, endsep); |
1470 | |
1471 | status = nfsd4_ssc_setup_dul(nn, ipaddr, nsui, rqstp); |
1472 | if (status) |
1473 | goto out_free_devname; |
1474 | if ((*nsui)->nsui_vfsmount) |
1475 | goto out_done; |
1476 | |
1477 | /* Use an 'internal' mount: SB_KERNMOUNT -> MNT_INTERNAL */ |
1478 | ss_mnt = vfs_kern_mount(type, SB_KERNMOUNT, name: dev_name, data: raw_data); |
1479 | module_put(module: type->owner); |
1480 | if (IS_ERR(ptr: ss_mnt)) { |
1481 | status = nfserr_nodev; |
1482 | nfsd4_ssc_cancel_dul(nn, nsui: *nsui); |
1483 | goto out_free_devname; |
1484 | } |
1485 | nfsd4_ssc_update_dul(nn, nsui: *nsui, ss_mnt); |
1486 | out_done: |
1487 | status = 0; |
1488 | |
1489 | out_free_devname: |
1490 | kfree(objp: dev_name); |
1491 | out_free_rawdata: |
1492 | kfree(objp: raw_data); |
1493 | out_free_ipaddr: |
1494 | kfree(objp: ipaddr); |
1495 | out_err: |
1496 | return status; |
1497 | } |
1498 | |
1499 | /* |
1500 | * Verify COPY destination stateid. |
1501 | * |
1502 | * Connect to the source server with NFSv4.1. |
1503 | * Create the source struct file for nfsd_copy_range. |
1504 | * Called with COPY cstate: |
1505 | * SAVED_FH: source filehandle |
1506 | * CURRENT_FH: destination filehandle |
1507 | */ |
1508 | static __be32 |
1509 | nfsd4_setup_inter_ssc(struct svc_rqst *rqstp, |
1510 | struct nfsd4_compound_state *cstate, |
1511 | struct nfsd4_copy *copy) |
1512 | { |
1513 | struct svc_fh *s_fh = NULL; |
1514 | stateid_t *s_stid = ©->cp_src_stateid; |
1515 | __be32 status = nfserr_inval; |
1516 | |
1517 | /* Verify the destination stateid and set dst struct file*/ |
1518 | status = nfs4_preprocess_stateid_op(rqstp, cstate, fhp: &cstate->current_fh, |
1519 | stateid: ©->cp_dst_stateid, |
1520 | WR_STATE, filp: ©->nf_dst, NULL); |
1521 | if (status) |
1522 | goto out; |
1523 | |
1524 | status = nfsd4_interssc_connect(nss: copy->cp_src, rqstp, nsui: ©->ss_nsui); |
1525 | if (status) |
1526 | goto out; |
1527 | |
1528 | s_fh = &cstate->save_fh; |
1529 | |
1530 | copy->c_fh.size = s_fh->fh_handle.fh_size; |
1531 | memcpy(copy->c_fh.data, &s_fh->fh_handle.fh_raw, copy->c_fh.size); |
1532 | copy->stateid.seqid = cpu_to_be32(s_stid->si_generation); |
1533 | memcpy(copy->stateid.other, (void *)&s_stid->si_opaque, |
1534 | sizeof(stateid_opaque_t)); |
1535 | |
1536 | status = 0; |
1537 | out: |
1538 | return status; |
1539 | } |
1540 | |
1541 | static void |
1542 | nfsd4_cleanup_inter_ssc(struct nfsd4_ssc_umount_item *nsui, struct file *filp, |
1543 | struct nfsd_file *dst) |
1544 | { |
1545 | struct nfsd_net *nn = net_generic(net: dst->nf_net, id: nfsd_net_id); |
1546 | long timeout = msecs_to_jiffies(m: nfsd4_ssc_umount_timeout); |
1547 | |
1548 | nfs42_ssc_close(filep: filp); |
1549 | fput(filp); |
1550 | |
1551 | spin_lock(lock: &nn->nfsd_ssc_lock); |
1552 | list_del(entry: &nsui->nsui_list); |
1553 | /* |
1554 | * vfsmount can be shared by multiple exports, |
1555 | * decrement refcnt. If the count drops to 1 it |
1556 | * will be unmounted when nsui_expire expires. |
1557 | */ |
1558 | refcount_dec(r: &nsui->nsui_refcnt); |
1559 | nsui->nsui_expire = jiffies + timeout; |
1560 | list_add_tail(new: &nsui->nsui_list, head: &nn->nfsd_ssc_mount_list); |
1561 | spin_unlock(lock: &nn->nfsd_ssc_lock); |
1562 | } |
1563 | |
1564 | #else /* CONFIG_NFSD_V4_2_INTER_SSC */ |
1565 | |
1566 | static __be32 |
1567 | nfsd4_setup_inter_ssc(struct svc_rqst *rqstp, |
1568 | struct nfsd4_compound_state *cstate, |
1569 | struct nfsd4_copy *copy) |
1570 | { |
1571 | return nfserr_inval; |
1572 | } |
1573 | |
1574 | static void |
1575 | nfsd4_cleanup_inter_ssc(struct nfsd4_ssc_umount_item *nsui, struct file *filp, |
1576 | struct nfsd_file *dst) |
1577 | { |
1578 | } |
1579 | |
1580 | static struct file *nfs42_ssc_open(struct vfsmount *ss_mnt, |
1581 | struct nfs_fh *src_fh, |
1582 | nfs4_stateid *stateid) |
1583 | { |
1584 | return NULL; |
1585 | } |
1586 | #endif /* CONFIG_NFSD_V4_2_INTER_SSC */ |
1587 | |
1588 | static __be32 |
1589 | nfsd4_setup_intra_ssc(struct svc_rqst *rqstp, |
1590 | struct nfsd4_compound_state *cstate, |
1591 | struct nfsd4_copy *copy) |
1592 | { |
1593 | return nfsd4_verify_copy(rqstp, cstate, src_stateid: ©->cp_src_stateid, |
1594 | src: ©->nf_src, dst_stateid: ©->cp_dst_stateid, |
1595 | dst: ©->nf_dst); |
1596 | } |
1597 | |
1598 | static void nfsd4_cb_offload_release(struct nfsd4_callback *cb) |
1599 | { |
1600 | struct nfsd4_cb_offload *cbo = |
1601 | container_of(cb, struct nfsd4_cb_offload, co_cb); |
1602 | |
1603 | kfree(objp: cbo); |
1604 | } |
1605 | |
1606 | static int nfsd4_cb_offload_done(struct nfsd4_callback *cb, |
1607 | struct rpc_task *task) |
1608 | { |
1609 | struct nfsd4_cb_offload *cbo = |
1610 | container_of(cb, struct nfsd4_cb_offload, co_cb); |
1611 | |
1612 | trace_nfsd_cb_offload_done(stp: &cbo->co_res.cb_stateid, task); |
1613 | return 1; |
1614 | } |
1615 | |
1616 | static const struct nfsd4_callback_ops nfsd4_cb_offload_ops = { |
1617 | .release = nfsd4_cb_offload_release, |
1618 | .done = nfsd4_cb_offload_done |
1619 | }; |
1620 | |
1621 | static void nfsd4_init_copy_res(struct nfsd4_copy *copy, bool sync) |
1622 | { |
1623 | copy->cp_res.wr_stable_how = |
1624 | test_bit(NFSD4_COPY_F_COMMITTED, ©->cp_flags) ? |
1625 | NFS_FILE_SYNC : NFS_UNSTABLE; |
1626 | nfsd4_copy_set_sync(copy, sync); |
1627 | gen_boot_verifier(verifier: ©->cp_res.wr_verifier, net: copy->cp_clp->net); |
1628 | } |
1629 | |
1630 | static ssize_t _nfsd_copy_file_range(struct nfsd4_copy *copy, |
1631 | struct file *dst, |
1632 | struct file *src) |
1633 | { |
1634 | errseq_t since; |
1635 | ssize_t bytes_copied = 0; |
1636 | u64 bytes_total = copy->cp_count; |
1637 | u64 src_pos = copy->cp_src_pos; |
1638 | u64 dst_pos = copy->cp_dst_pos; |
1639 | int status; |
1640 | loff_t end; |
1641 | |
1642 | /* See RFC 7862 p.67: */ |
1643 | if (bytes_total == 0) |
1644 | bytes_total = ULLONG_MAX; |
1645 | do { |
1646 | /* Only async copies can be stopped here */ |
1647 | if (kthread_should_stop()) |
1648 | break; |
1649 | bytes_copied = nfsd_copy_file_range(src, src_pos, dst, dst_pos, |
1650 | bytes_total); |
1651 | if (bytes_copied <= 0) |
1652 | break; |
1653 | bytes_total -= bytes_copied; |
1654 | copy->cp_res.wr_bytes_written += bytes_copied; |
1655 | src_pos += bytes_copied; |
1656 | dst_pos += bytes_copied; |
1657 | } while (bytes_total > 0 && nfsd4_copy_is_async(copy)); |
1658 | /* for a non-zero asynchronous copy do a commit of data */ |
1659 | if (nfsd4_copy_is_async(copy) && copy->cp_res.wr_bytes_written > 0) { |
1660 | since = READ_ONCE(dst->f_wb_err); |
1661 | end = copy->cp_dst_pos + copy->cp_res.wr_bytes_written - 1; |
1662 | status = vfs_fsync_range(file: dst, start: copy->cp_dst_pos, end, datasync: 0); |
1663 | if (!status) |
1664 | status = filemap_check_wb_err(mapping: dst->f_mapping, since); |
1665 | if (!status) |
1666 | set_bit(NFSD4_COPY_F_COMMITTED, addr: ©->cp_flags); |
1667 | } |
1668 | return bytes_copied; |
1669 | } |
1670 | |
1671 | static __be32 nfsd4_do_copy(struct nfsd4_copy *copy, |
1672 | struct file *src, struct file *dst, |
1673 | bool sync) |
1674 | { |
1675 | __be32 status; |
1676 | ssize_t bytes; |
1677 | |
1678 | bytes = _nfsd_copy_file_range(copy, dst, src); |
1679 | |
1680 | /* for async copy, we ignore the error, client can always retry |
1681 | * to get the error |
1682 | */ |
1683 | if (bytes < 0 && !copy->cp_res.wr_bytes_written) |
1684 | status = nfserrno(errno: bytes); |
1685 | else { |
1686 | nfsd4_init_copy_res(copy, sync); |
1687 | status = nfs_ok; |
1688 | } |
1689 | return status; |
1690 | } |
1691 | |
1692 | static void dup_copy_fields(struct nfsd4_copy *src, struct nfsd4_copy *dst) |
1693 | { |
1694 | dst->cp_src_pos = src->cp_src_pos; |
1695 | dst->cp_dst_pos = src->cp_dst_pos; |
1696 | dst->cp_count = src->cp_count; |
1697 | dst->cp_flags = src->cp_flags; |
1698 | memcpy(&dst->cp_res, &src->cp_res, sizeof(src->cp_res)); |
1699 | memcpy(&dst->fh, &src->fh, sizeof(src->fh)); |
1700 | dst->cp_clp = src->cp_clp; |
1701 | dst->nf_dst = nfsd_file_get(nf: src->nf_dst); |
1702 | /* for inter, nf_src doesn't exist yet */ |
1703 | if (!nfsd4_ssc_is_inter(copy: src)) |
1704 | dst->nf_src = nfsd_file_get(nf: src->nf_src); |
1705 | |
1706 | memcpy(&dst->cp_stateid, &src->cp_stateid, sizeof(src->cp_stateid)); |
1707 | memcpy(dst->cp_src, src->cp_src, sizeof(struct nl4_server)); |
1708 | memcpy(&dst->stateid, &src->stateid, sizeof(src->stateid)); |
1709 | memcpy(&dst->c_fh, &src->c_fh, sizeof(src->c_fh)); |
1710 | dst->ss_nsui = src->ss_nsui; |
1711 | } |
1712 | |
1713 | static void release_copy_files(struct nfsd4_copy *copy) |
1714 | { |
1715 | if (copy->nf_src) |
1716 | nfsd_file_put(nf: copy->nf_src); |
1717 | if (copy->nf_dst) |
1718 | nfsd_file_put(nf: copy->nf_dst); |
1719 | } |
1720 | |
1721 | static void cleanup_async_copy(struct nfsd4_copy *copy) |
1722 | { |
1723 | nfs4_free_copy_state(copy); |
1724 | release_copy_files(copy); |
1725 | if (copy->cp_clp) { |
1726 | spin_lock(lock: ©->cp_clp->async_lock); |
1727 | if (!list_empty(head: ©->copies)) |
1728 | list_del_init(entry: ©->copies); |
1729 | spin_unlock(lock: ©->cp_clp->async_lock); |
1730 | } |
1731 | nfs4_put_copy(copy); |
1732 | } |
1733 | |
1734 | static void nfsd4_send_cb_offload(struct nfsd4_copy *copy, __be32 nfserr) |
1735 | { |
1736 | struct nfsd4_cb_offload *cbo; |
1737 | |
1738 | cbo = kzalloc(size: sizeof(*cbo), GFP_KERNEL); |
1739 | if (!cbo) |
1740 | return; |
1741 | |
1742 | memcpy(&cbo->co_res, ©->cp_res, sizeof(copy->cp_res)); |
1743 | memcpy(&cbo->co_fh, ©->fh, sizeof(copy->fh)); |
1744 | cbo->co_nfserr = nfserr; |
1745 | |
1746 | nfsd4_init_cb(cb: &cbo->co_cb, clp: copy->cp_clp, ops: &nfsd4_cb_offload_ops, |
1747 | op: NFSPROC4_CLNT_CB_OFFLOAD); |
1748 | trace_nfsd_cb_offload(clp: copy->cp_clp, stp: &cbo->co_res.cb_stateid, |
1749 | fh: &cbo->co_fh, count: copy->cp_count, status: nfserr); |
1750 | nfsd4_run_cb(cb: &cbo->co_cb); |
1751 | } |
1752 | |
1753 | /** |
1754 | * nfsd4_do_async_copy - kthread function for background server-side COPY |
1755 | * @data: arguments for COPY operation |
1756 | * |
1757 | * Return values: |
1758 | * %0: Copy operation is done. |
1759 | */ |
1760 | static int nfsd4_do_async_copy(void *data) |
1761 | { |
1762 | struct nfsd4_copy *copy = (struct nfsd4_copy *)data; |
1763 | __be32 nfserr; |
1764 | |
1765 | trace_nfsd_copy_do_async(copy); |
1766 | if (nfsd4_ssc_is_inter(copy)) { |
1767 | struct file *filp; |
1768 | |
1769 | filp = nfs42_ssc_open(ss_mnt: copy->ss_nsui->nsui_vfsmount, |
1770 | src_fh: ©->c_fh, stateid: ©->stateid); |
1771 | if (IS_ERR(ptr: filp)) { |
1772 | switch (PTR_ERR(ptr: filp)) { |
1773 | case -EBADF: |
1774 | nfserr = nfserr_wrong_type; |
1775 | break; |
1776 | default: |
1777 | nfserr = nfserr_offload_denied; |
1778 | } |
1779 | /* ss_mnt will be unmounted by the laundromat */ |
1780 | goto do_callback; |
1781 | } |
1782 | nfserr = nfsd4_do_copy(copy, src: filp, dst: copy->nf_dst->nf_file, |
1783 | sync: false); |
1784 | nfsd4_cleanup_inter_ssc(nsui: copy->ss_nsui, filp, dst: copy->nf_dst); |
1785 | } else { |
1786 | nfserr = nfsd4_do_copy(copy, src: copy->nf_src->nf_file, |
1787 | dst: copy->nf_dst->nf_file, sync: false); |
1788 | } |
1789 | |
1790 | do_callback: |
1791 | nfsd4_send_cb_offload(copy, nfserr); |
1792 | cleanup_async_copy(copy); |
1793 | return 0; |
1794 | } |
1795 | |
1796 | static __be32 |
1797 | nfsd4_copy(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
1798 | union nfsd4_op_u *u) |
1799 | { |
1800 | struct nfsd4_copy *copy = &u->copy; |
1801 | __be32 status; |
1802 | struct nfsd4_copy *async_copy = NULL; |
1803 | |
1804 | copy->cp_clp = cstate->clp; |
1805 | if (nfsd4_ssc_is_inter(copy)) { |
1806 | trace_nfsd_copy_inter(copy); |
1807 | if (!inter_copy_offload_enable || nfsd4_copy_is_sync(copy)) { |
1808 | status = nfserr_notsupp; |
1809 | goto out; |
1810 | } |
1811 | status = nfsd4_setup_inter_ssc(rqstp, cstate, copy); |
1812 | if (status) { |
1813 | trace_nfsd_copy_done(copy, status); |
1814 | return nfserr_offload_denied; |
1815 | } |
1816 | } else { |
1817 | trace_nfsd_copy_intra(copy); |
1818 | status = nfsd4_setup_intra_ssc(rqstp, cstate, copy); |
1819 | if (status) { |
1820 | trace_nfsd_copy_done(copy, status); |
1821 | return status; |
1822 | } |
1823 | } |
1824 | |
1825 | memcpy(©->fh, &cstate->current_fh.fh_handle, |
1826 | sizeof(struct knfsd_fh)); |
1827 | if (nfsd4_copy_is_async(copy)) { |
1828 | struct nfsd_net *nn = net_generic(SVC_NET(rqstp), id: nfsd_net_id); |
1829 | |
1830 | status = nfserrno(errno: -ENOMEM); |
1831 | async_copy = kzalloc(size: sizeof(struct nfsd4_copy), GFP_KERNEL); |
1832 | if (!async_copy) |
1833 | goto out_err; |
1834 | INIT_LIST_HEAD(list: &async_copy->copies); |
1835 | refcount_set(r: &async_copy->refcount, n: 1); |
1836 | async_copy->cp_src = kmalloc(size: sizeof(*async_copy->cp_src), GFP_KERNEL); |
1837 | if (!async_copy->cp_src) |
1838 | goto out_err; |
1839 | if (!nfs4_init_copy_state(nn, copy)) |
1840 | goto out_err; |
1841 | memcpy(©->cp_res.cb_stateid, ©->cp_stateid.cs_stid, |
1842 | sizeof(copy->cp_res.cb_stateid)); |
1843 | dup_copy_fields(src: copy, dst: async_copy); |
1844 | async_copy->copy_task = kthread_create(nfsd4_do_async_copy, |
1845 | async_copy, "%s" , "copy thread" ); |
1846 | if (IS_ERR(ptr: async_copy->copy_task)) |
1847 | goto out_err; |
1848 | spin_lock(lock: &async_copy->cp_clp->async_lock); |
1849 | list_add(new: &async_copy->copies, |
1850 | head: &async_copy->cp_clp->async_copies); |
1851 | spin_unlock(lock: &async_copy->cp_clp->async_lock); |
1852 | wake_up_process(tsk: async_copy->copy_task); |
1853 | status = nfs_ok; |
1854 | } else { |
1855 | status = nfsd4_do_copy(copy, src: copy->nf_src->nf_file, |
1856 | dst: copy->nf_dst->nf_file, sync: true); |
1857 | } |
1858 | out: |
1859 | trace_nfsd_copy_done(copy, status); |
1860 | release_copy_files(copy); |
1861 | return status; |
1862 | out_err: |
1863 | if (nfsd4_ssc_is_inter(copy)) { |
1864 | /* |
1865 | * Source's vfsmount of inter-copy will be unmounted |
1866 | * by the laundromat. Use copy instead of async_copy |
1867 | * since async_copy->ss_nsui might not be set yet. |
1868 | */ |
1869 | refcount_dec(r: ©->ss_nsui->nsui_refcnt); |
1870 | } |
1871 | if (async_copy) |
1872 | cleanup_async_copy(copy: async_copy); |
1873 | status = nfserrno(errno: -ENOMEM); |
1874 | goto out; |
1875 | } |
1876 | |
1877 | static struct nfsd4_copy * |
1878 | find_async_copy_locked(struct nfs4_client *clp, stateid_t *stateid) |
1879 | { |
1880 | struct nfsd4_copy *copy; |
1881 | |
1882 | lockdep_assert_held(&clp->async_lock); |
1883 | |
1884 | list_for_each_entry(copy, &clp->async_copies, copies) { |
1885 | if (memcmp(p: ©->cp_stateid.cs_stid, q: stateid, NFS4_STATEID_SIZE)) |
1886 | continue; |
1887 | return copy; |
1888 | } |
1889 | return NULL; |
1890 | } |
1891 | |
1892 | static struct nfsd4_copy * |
1893 | find_async_copy(struct nfs4_client *clp, stateid_t *stateid) |
1894 | { |
1895 | struct nfsd4_copy *copy; |
1896 | |
1897 | spin_lock(lock: &clp->async_lock); |
1898 | copy = find_async_copy_locked(clp, stateid); |
1899 | if (copy) |
1900 | refcount_inc(r: ©->refcount); |
1901 | spin_unlock(lock: &clp->async_lock); |
1902 | return copy; |
1903 | } |
1904 | |
1905 | static __be32 |
1906 | nfsd4_offload_cancel(struct svc_rqst *rqstp, |
1907 | struct nfsd4_compound_state *cstate, |
1908 | union nfsd4_op_u *u) |
1909 | { |
1910 | struct nfsd4_offload_status *os = &u->offload_status; |
1911 | struct nfsd4_copy *copy; |
1912 | struct nfs4_client *clp = cstate->clp; |
1913 | |
1914 | copy = find_async_copy(clp, stateid: &os->stateid); |
1915 | if (!copy) { |
1916 | struct nfsd_net *nn = net_generic(SVC_NET(rqstp), id: nfsd_net_id); |
1917 | |
1918 | return manage_cpntf_state(nn, st: &os->stateid, clp, NULL); |
1919 | } else |
1920 | nfsd4_stop_copy(copy); |
1921 | |
1922 | return nfs_ok; |
1923 | } |
1924 | |
1925 | static __be32 |
1926 | nfsd4_copy_notify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
1927 | union nfsd4_op_u *u) |
1928 | { |
1929 | struct nfsd4_copy_notify *cn = &u->copy_notify; |
1930 | __be32 status; |
1931 | struct nfsd_net *nn = net_generic(SVC_NET(rqstp), id: nfsd_net_id); |
1932 | struct nfs4_stid *stid; |
1933 | struct nfs4_cpntf_state *cps; |
1934 | struct nfs4_client *clp = cstate->clp; |
1935 | |
1936 | status = nfs4_preprocess_stateid_op(rqstp, cstate, fhp: &cstate->current_fh, |
1937 | stateid: &cn->cpn_src_stateid, RD_STATE, NULL, |
1938 | cstid: &stid); |
1939 | if (status) |
1940 | return status; |
1941 | |
1942 | cn->cpn_lease_time.tv_sec = nn->nfsd4_lease; |
1943 | cn->cpn_lease_time.tv_nsec = 0; |
1944 | |
1945 | status = nfserrno(errno: -ENOMEM); |
1946 | cps = nfs4_alloc_init_cpntf_state(nn, p_stid: stid); |
1947 | if (!cps) |
1948 | goto out; |
1949 | memcpy(&cn->cpn_cnr_stateid, &cps->cp_stateid.cs_stid, sizeof(stateid_t)); |
1950 | memcpy(&cps->cp_p_stateid, &stid->sc_stateid, sizeof(stateid_t)); |
1951 | memcpy(&cps->cp_p_clid, &clp->cl_clientid, sizeof(clientid_t)); |
1952 | |
1953 | /* For now, only return one server address in cpn_src, the |
1954 | * address used by the client to connect to this server. |
1955 | */ |
1956 | cn->cpn_src->nl4_type = NL4_NETADDR; |
1957 | status = nfsd4_set_netaddr(addr: (struct sockaddr *)&rqstp->rq_daddr, |
1958 | netaddr: &cn->cpn_src->u.nl4_addr); |
1959 | WARN_ON_ONCE(status); |
1960 | if (status) { |
1961 | nfs4_put_cpntf_state(nn, cps); |
1962 | goto out; |
1963 | } |
1964 | out: |
1965 | nfs4_put_stid(s: stid); |
1966 | return status; |
1967 | } |
1968 | |
1969 | static __be32 |
1970 | nfsd4_fallocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
1971 | struct nfsd4_fallocate *fallocate, int flags) |
1972 | { |
1973 | __be32 status; |
1974 | struct nfsd_file *nf; |
1975 | |
1976 | status = nfs4_preprocess_stateid_op(rqstp, cstate, fhp: &cstate->current_fh, |
1977 | stateid: &fallocate->falloc_stateid, |
1978 | WR_STATE, filp: &nf, NULL); |
1979 | if (status != nfs_ok) |
1980 | return status; |
1981 | |
1982 | status = nfsd4_vfs_fallocate(rqstp, &cstate->current_fh, nf->nf_file, |
1983 | fallocate->falloc_offset, |
1984 | fallocate->falloc_length, |
1985 | flags); |
1986 | nfsd_file_put(nf); |
1987 | return status; |
1988 | } |
1989 | |
1990 | static __be32 |
1991 | nfsd4_offload_status(struct svc_rqst *rqstp, |
1992 | struct nfsd4_compound_state *cstate, |
1993 | union nfsd4_op_u *u) |
1994 | { |
1995 | struct nfsd4_offload_status *os = &u->offload_status; |
1996 | __be32 status = nfs_ok; |
1997 | struct nfsd4_copy *copy; |
1998 | struct nfs4_client *clp = cstate->clp; |
1999 | |
2000 | spin_lock(lock: &clp->async_lock); |
2001 | copy = find_async_copy_locked(clp, stateid: &os->stateid); |
2002 | if (copy) |
2003 | os->count = copy->cp_res.wr_bytes_written; |
2004 | else |
2005 | status = nfserr_bad_stateid; |
2006 | spin_unlock(lock: &clp->async_lock); |
2007 | |
2008 | return status; |
2009 | } |
2010 | |
2011 | static __be32 |
2012 | nfsd4_allocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
2013 | union nfsd4_op_u *u) |
2014 | { |
2015 | return nfsd4_fallocate(rqstp, cstate, fallocate: &u->allocate, flags: 0); |
2016 | } |
2017 | |
2018 | static __be32 |
2019 | nfsd4_deallocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
2020 | union nfsd4_op_u *u) |
2021 | { |
2022 | return nfsd4_fallocate(rqstp, cstate, fallocate: &u->deallocate, |
2023 | FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE); |
2024 | } |
2025 | |
2026 | static __be32 |
2027 | nfsd4_seek(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
2028 | union nfsd4_op_u *u) |
2029 | { |
2030 | struct nfsd4_seek *seek = &u->seek; |
2031 | int whence; |
2032 | __be32 status; |
2033 | struct nfsd_file *nf; |
2034 | |
2035 | status = nfs4_preprocess_stateid_op(rqstp, cstate, fhp: &cstate->current_fh, |
2036 | stateid: &seek->seek_stateid, |
2037 | RD_STATE, filp: &nf, NULL); |
2038 | if (status) |
2039 | return status; |
2040 | |
2041 | switch (seek->seek_whence) { |
2042 | case NFS4_CONTENT_DATA: |
2043 | whence = SEEK_DATA; |
2044 | break; |
2045 | case NFS4_CONTENT_HOLE: |
2046 | whence = SEEK_HOLE; |
2047 | break; |
2048 | default: |
2049 | status = nfserr_union_notsupp; |
2050 | goto out; |
2051 | } |
2052 | |
2053 | /* |
2054 | * Note: This call does change file->f_pos, but nothing in NFSD |
2055 | * should ever file->f_pos. |
2056 | */ |
2057 | seek->seek_pos = vfs_llseek(file: nf->nf_file, offset: seek->seek_offset, whence); |
2058 | if (seek->seek_pos < 0) |
2059 | status = nfserrno(errno: seek->seek_pos); |
2060 | else if (seek->seek_pos >= i_size_read(inode: file_inode(f: nf->nf_file))) |
2061 | seek->seek_eof = true; |
2062 | |
2063 | out: |
2064 | nfsd_file_put(nf); |
2065 | return status; |
2066 | } |
2067 | |
2068 | /* This routine never returns NFS_OK! If there are no other errors, it |
2069 | * will return NFSERR_SAME or NFSERR_NOT_SAME depending on whether the |
2070 | * attributes matched. VERIFY is implemented by mapping NFSERR_SAME |
2071 | * to NFS_OK after the call; NVERIFY by mapping NFSERR_NOT_SAME to NFS_OK. |
2072 | */ |
2073 | static __be32 |
2074 | _nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
2075 | struct nfsd4_verify *verify) |
2076 | { |
2077 | __be32 *buf, *p; |
2078 | int count; |
2079 | __be32 status; |
2080 | |
2081 | status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP); |
2082 | if (status) |
2083 | return status; |
2084 | |
2085 | status = check_attr_support(rqstp, cstate, bmval: verify->ve_bmval, NULL); |
2086 | if (status) |
2087 | return status; |
2088 | |
2089 | if ((verify->ve_bmval[0] & FATTR4_WORD0_RDATTR_ERROR) |
2090 | || (verify->ve_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)) |
2091 | return nfserr_inval; |
2092 | if (verify->ve_attrlen & 3) |
2093 | return nfserr_inval; |
2094 | |
2095 | /* count in words: |
2096 | * bitmap_len(1) + bitmap(2) + attr_len(1) = 4 |
2097 | */ |
2098 | count = 4 + (verify->ve_attrlen >> 2); |
2099 | buf = kmalloc(size: count << 2, GFP_KERNEL); |
2100 | if (!buf) |
2101 | return nfserr_jukebox; |
2102 | |
2103 | p = buf; |
2104 | status = nfsd4_encode_fattr_to_buf(p: &p, words: count, fhp: &cstate->current_fh, |
2105 | exp: cstate->current_fh.fh_export, |
2106 | dentry: cstate->current_fh.fh_dentry, |
2107 | bmval: verify->ve_bmval, |
2108 | rqstp, ignore_crossmnt: 0); |
2109 | /* |
2110 | * If nfsd4_encode_fattr() ran out of space, assume that's because |
2111 | * the attributes are longer (hence different) than those given: |
2112 | */ |
2113 | if (status == nfserr_resource) |
2114 | status = nfserr_not_same; |
2115 | if (status) |
2116 | goto out_kfree; |
2117 | |
2118 | /* skip bitmap */ |
2119 | p = buf + 1 + ntohl(buf[0]); |
2120 | status = nfserr_not_same; |
2121 | if (ntohl(*p++) != verify->ve_attrlen) |
2122 | goto out_kfree; |
2123 | if (!memcmp(p, q: verify->ve_attrval, size: verify->ve_attrlen)) |
2124 | status = nfserr_same; |
2125 | |
2126 | out_kfree: |
2127 | kfree(objp: buf); |
2128 | return status; |
2129 | } |
2130 | |
2131 | static __be32 |
2132 | nfsd4_nverify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
2133 | union nfsd4_op_u *u) |
2134 | { |
2135 | __be32 status; |
2136 | |
2137 | status = _nfsd4_verify(rqstp, cstate, verify: &u->verify); |
2138 | return status == nfserr_not_same ? nfs_ok : status; |
2139 | } |
2140 | |
2141 | static __be32 |
2142 | nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
2143 | union nfsd4_op_u *u) |
2144 | { |
2145 | __be32 status; |
2146 | |
2147 | status = _nfsd4_verify(rqstp, cstate, verify: &u->nverify); |
2148 | return status == nfserr_same ? nfs_ok : status; |
2149 | } |
2150 | |
2151 | #ifdef CONFIG_NFSD_PNFS |
2152 | static const struct nfsd4_layout_ops * |
2153 | nfsd4_layout_verify(struct svc_export *exp, unsigned int layout_type) |
2154 | { |
2155 | if (!exp->ex_layout_types) { |
2156 | dprintk("%s: export does not support pNFS\n" , __func__); |
2157 | return NULL; |
2158 | } |
2159 | |
2160 | if (layout_type >= LAYOUT_TYPE_MAX || |
2161 | !(exp->ex_layout_types & (1 << layout_type))) { |
2162 | dprintk("%s: layout type %d not supported\n" , |
2163 | __func__, layout_type); |
2164 | return NULL; |
2165 | } |
2166 | |
2167 | return nfsd4_layout_ops[layout_type]; |
2168 | } |
2169 | |
2170 | static __be32 |
2171 | nfsd4_getdeviceinfo(struct svc_rqst *rqstp, |
2172 | struct nfsd4_compound_state *cstate, union nfsd4_op_u *u) |
2173 | { |
2174 | struct nfsd4_getdeviceinfo *gdp = &u->getdeviceinfo; |
2175 | const struct nfsd4_layout_ops *ops; |
2176 | struct nfsd4_deviceid_map *map; |
2177 | struct svc_export *exp; |
2178 | __be32 nfserr; |
2179 | |
2180 | dprintk("%s: layout_type %u dev_id [0x%llx:0x%x] maxcnt %u\n" , |
2181 | __func__, |
2182 | gdp->gd_layout_type, |
2183 | gdp->gd_devid.fsid_idx, gdp->gd_devid.generation, |
2184 | gdp->gd_maxcount); |
2185 | |
2186 | map = nfsd4_find_devid_map(idx: gdp->gd_devid.fsid_idx); |
2187 | if (!map) { |
2188 | dprintk("%s: couldn't find device ID to export mapping!\n" , |
2189 | __func__); |
2190 | return nfserr_noent; |
2191 | } |
2192 | |
2193 | exp = rqst_exp_find(rqstp, map->fsid_type, map->fsid); |
2194 | if (IS_ERR(ptr: exp)) { |
2195 | dprintk("%s: could not find device id\n" , __func__); |
2196 | return nfserr_noent; |
2197 | } |
2198 | |
2199 | nfserr = nfserr_layoutunavailable; |
2200 | ops = nfsd4_layout_verify(exp, layout_type: gdp->gd_layout_type); |
2201 | if (!ops) |
2202 | goto out; |
2203 | |
2204 | nfserr = nfs_ok; |
2205 | if (gdp->gd_maxcount != 0) { |
2206 | nfserr = ops->proc_getdeviceinfo(exp->ex_path.mnt->mnt_sb, |
2207 | rqstp, cstate->clp, gdp); |
2208 | } |
2209 | |
2210 | gdp->gd_notify_types &= ops->notify_types; |
2211 | out: |
2212 | exp_put(exp); |
2213 | return nfserr; |
2214 | } |
2215 | |
2216 | static void |
2217 | nfsd4_getdeviceinfo_release(union nfsd4_op_u *u) |
2218 | { |
2219 | kfree(objp: u->getdeviceinfo.gd_device); |
2220 | } |
2221 | |
2222 | static __be32 |
2223 | nfsd4_layoutget(struct svc_rqst *rqstp, |
2224 | struct nfsd4_compound_state *cstate, union nfsd4_op_u *u) |
2225 | { |
2226 | struct nfsd4_layoutget *lgp = &u->layoutget; |
2227 | struct svc_fh *current_fh = &cstate->current_fh; |
2228 | const struct nfsd4_layout_ops *ops; |
2229 | struct nfs4_layout_stateid *ls; |
2230 | __be32 nfserr; |
2231 | int accmode = NFSD_MAY_READ_IF_EXEC; |
2232 | |
2233 | switch (lgp->lg_seg.iomode) { |
2234 | case IOMODE_READ: |
2235 | accmode |= NFSD_MAY_READ; |
2236 | break; |
2237 | case IOMODE_RW: |
2238 | accmode |= NFSD_MAY_READ | NFSD_MAY_WRITE; |
2239 | break; |
2240 | default: |
2241 | dprintk("%s: invalid iomode %d\n" , |
2242 | __func__, lgp->lg_seg.iomode); |
2243 | nfserr = nfserr_badiomode; |
2244 | goto out; |
2245 | } |
2246 | |
2247 | nfserr = fh_verify(rqstp, current_fh, 0, accmode); |
2248 | if (nfserr) |
2249 | goto out; |
2250 | |
2251 | nfserr = nfserr_layoutunavailable; |
2252 | ops = nfsd4_layout_verify(exp: current_fh->fh_export, layout_type: lgp->lg_layout_type); |
2253 | if (!ops) |
2254 | goto out; |
2255 | |
2256 | /* |
2257 | * Verify minlength and range as per RFC5661: |
2258 | * o If loga_length is less than loga_minlength, |
2259 | * the metadata server MUST return NFS4ERR_INVAL. |
2260 | * o If the sum of loga_offset and loga_minlength exceeds |
2261 | * NFS4_UINT64_MAX, and loga_minlength is not |
2262 | * NFS4_UINT64_MAX, the error NFS4ERR_INVAL MUST result. |
2263 | * o If the sum of loga_offset and loga_length exceeds |
2264 | * NFS4_UINT64_MAX, and loga_length is not NFS4_UINT64_MAX, |
2265 | * the error NFS4ERR_INVAL MUST result. |
2266 | */ |
2267 | nfserr = nfserr_inval; |
2268 | if (lgp->lg_seg.length < lgp->lg_minlength || |
2269 | (lgp->lg_minlength != NFS4_MAX_UINT64 && |
2270 | lgp->lg_minlength > NFS4_MAX_UINT64 - lgp->lg_seg.offset) || |
2271 | (lgp->lg_seg.length != NFS4_MAX_UINT64 && |
2272 | lgp->lg_seg.length > NFS4_MAX_UINT64 - lgp->lg_seg.offset)) |
2273 | goto out; |
2274 | if (lgp->lg_seg.length == 0) |
2275 | goto out; |
2276 | |
2277 | nfserr = nfsd4_preprocess_layout_stateid(rqstp, cstate, stateid: &lgp->lg_sid, |
2278 | create: true, layout_type: lgp->lg_layout_type, lsp: &ls); |
2279 | if (nfserr) { |
2280 | trace_nfsd_layout_get_lookup_fail(stp: &lgp->lg_sid); |
2281 | goto out; |
2282 | } |
2283 | |
2284 | nfserr = nfserr_recallconflict; |
2285 | if (atomic_read(v: &ls->ls_stid.sc_file->fi_lo_recalls)) |
2286 | goto out_put_stid; |
2287 | |
2288 | nfserr = ops->proc_layoutget(d_inode(dentry: current_fh->fh_dentry), |
2289 | current_fh, lgp); |
2290 | if (nfserr) |
2291 | goto out_put_stid; |
2292 | |
2293 | nfserr = nfsd4_insert_layout(lgp, ls); |
2294 | |
2295 | out_put_stid: |
2296 | mutex_unlock(lock: &ls->ls_mutex); |
2297 | nfs4_put_stid(s: &ls->ls_stid); |
2298 | out: |
2299 | return nfserr; |
2300 | } |
2301 | |
2302 | static void |
2303 | nfsd4_layoutget_release(union nfsd4_op_u *u) |
2304 | { |
2305 | kfree(objp: u->layoutget.lg_content); |
2306 | } |
2307 | |
2308 | static __be32 |
2309 | nfsd4_layoutcommit(struct svc_rqst *rqstp, |
2310 | struct nfsd4_compound_state *cstate, union nfsd4_op_u *u) |
2311 | { |
2312 | struct nfsd4_layoutcommit *lcp = &u->layoutcommit; |
2313 | const struct nfsd4_layout_seg *seg = &lcp->lc_seg; |
2314 | struct svc_fh *current_fh = &cstate->current_fh; |
2315 | const struct nfsd4_layout_ops *ops; |
2316 | loff_t new_size = lcp->lc_last_wr + 1; |
2317 | struct inode *inode; |
2318 | struct nfs4_layout_stateid *ls; |
2319 | __be32 nfserr; |
2320 | |
2321 | nfserr = fh_verify(rqstp, current_fh, 0, NFSD_MAY_WRITE); |
2322 | if (nfserr) |
2323 | goto out; |
2324 | |
2325 | nfserr = nfserr_layoutunavailable; |
2326 | ops = nfsd4_layout_verify(exp: current_fh->fh_export, layout_type: lcp->lc_layout_type); |
2327 | if (!ops) |
2328 | goto out; |
2329 | inode = d_inode(dentry: current_fh->fh_dentry); |
2330 | |
2331 | nfserr = nfserr_inval; |
2332 | if (new_size <= seg->offset) { |
2333 | dprintk("pnfsd: last write before layout segment\n" ); |
2334 | goto out; |
2335 | } |
2336 | if (new_size > seg->offset + seg->length) { |
2337 | dprintk("pnfsd: last write beyond layout segment\n" ); |
2338 | goto out; |
2339 | } |
2340 | if (!lcp->lc_newoffset && new_size > i_size_read(inode)) { |
2341 | dprintk("pnfsd: layoutcommit beyond EOF\n" ); |
2342 | goto out; |
2343 | } |
2344 | |
2345 | nfserr = nfsd4_preprocess_layout_stateid(rqstp, cstate, stateid: &lcp->lc_sid, |
2346 | create: false, layout_type: lcp->lc_layout_type, |
2347 | lsp: &ls); |
2348 | if (nfserr) { |
2349 | trace_nfsd_layout_commit_lookup_fail(stp: &lcp->lc_sid); |
2350 | /* fixup error code as per RFC5661 */ |
2351 | if (nfserr == nfserr_bad_stateid) |
2352 | nfserr = nfserr_badlayout; |
2353 | goto out; |
2354 | } |
2355 | |
2356 | /* LAYOUTCOMMIT does not require any serialization */ |
2357 | mutex_unlock(lock: &ls->ls_mutex); |
2358 | |
2359 | if (new_size > i_size_read(inode)) { |
2360 | lcp->lc_size_chg = true; |
2361 | lcp->lc_newsize = new_size; |
2362 | } else { |
2363 | lcp->lc_size_chg = false; |
2364 | } |
2365 | |
2366 | nfserr = ops->proc_layoutcommit(inode, lcp); |
2367 | nfs4_put_stid(s: &ls->ls_stid); |
2368 | out: |
2369 | return nfserr; |
2370 | } |
2371 | |
2372 | static __be32 |
2373 | nfsd4_layoutreturn(struct svc_rqst *rqstp, |
2374 | struct nfsd4_compound_state *cstate, union nfsd4_op_u *u) |
2375 | { |
2376 | struct nfsd4_layoutreturn *lrp = &u->layoutreturn; |
2377 | struct svc_fh *current_fh = &cstate->current_fh; |
2378 | __be32 nfserr; |
2379 | |
2380 | nfserr = fh_verify(rqstp, current_fh, 0, NFSD_MAY_NOP); |
2381 | if (nfserr) |
2382 | goto out; |
2383 | |
2384 | nfserr = nfserr_layoutunavailable; |
2385 | if (!nfsd4_layout_verify(exp: current_fh->fh_export, layout_type: lrp->lr_layout_type)) |
2386 | goto out; |
2387 | |
2388 | switch (lrp->lr_seg.iomode) { |
2389 | case IOMODE_READ: |
2390 | case IOMODE_RW: |
2391 | case IOMODE_ANY: |
2392 | break; |
2393 | default: |
2394 | dprintk("%s: invalid iomode %d\n" , __func__, |
2395 | lrp->lr_seg.iomode); |
2396 | nfserr = nfserr_inval; |
2397 | goto out; |
2398 | } |
2399 | |
2400 | switch (lrp->lr_return_type) { |
2401 | case RETURN_FILE: |
2402 | nfserr = nfsd4_return_file_layouts(rqstp, cstate, lrp); |
2403 | break; |
2404 | case RETURN_FSID: |
2405 | case RETURN_ALL: |
2406 | nfserr = nfsd4_return_client_layouts(rqstp, cstate, lrp); |
2407 | break; |
2408 | default: |
2409 | dprintk("%s: invalid return_type %d\n" , __func__, |
2410 | lrp->lr_return_type); |
2411 | nfserr = nfserr_inval; |
2412 | break; |
2413 | } |
2414 | out: |
2415 | return nfserr; |
2416 | } |
2417 | #endif /* CONFIG_NFSD_PNFS */ |
2418 | |
2419 | static __be32 |
2420 | nfsd4_getxattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
2421 | union nfsd4_op_u *u) |
2422 | { |
2423 | struct nfsd4_getxattr *getxattr = &u->getxattr; |
2424 | |
2425 | return nfsd_getxattr(rqstp, fhp: &cstate->current_fh, |
2426 | name: getxattr->getxa_name, bufp: &getxattr->getxa_buf, |
2427 | lenp: &getxattr->getxa_len); |
2428 | } |
2429 | |
2430 | static __be32 |
2431 | nfsd4_setxattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
2432 | union nfsd4_op_u *u) |
2433 | { |
2434 | struct nfsd4_setxattr *setxattr = &u->setxattr; |
2435 | __be32 ret; |
2436 | |
2437 | if (opens_in_grace(SVC_NET(rqstp))) |
2438 | return nfserr_grace; |
2439 | |
2440 | ret = nfsd_setxattr(rqstp, fhp: &cstate->current_fh, name: setxattr->setxa_name, |
2441 | buf: setxattr->setxa_buf, len: setxattr->setxa_len, |
2442 | flags: setxattr->setxa_flags); |
2443 | |
2444 | if (!ret) |
2445 | set_change_info(cinfo: &setxattr->setxa_cinfo, fhp: &cstate->current_fh); |
2446 | |
2447 | return ret; |
2448 | } |
2449 | |
2450 | static __be32 |
2451 | nfsd4_listxattrs(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
2452 | union nfsd4_op_u *u) |
2453 | { |
2454 | /* |
2455 | * Get the entire list, then copy out only the user attributes |
2456 | * in the encode function. |
2457 | */ |
2458 | return nfsd_listxattr(rqstp, fhp: &cstate->current_fh, |
2459 | bufp: &u->listxattrs.lsxa_buf, lenp: &u->listxattrs.lsxa_len); |
2460 | } |
2461 | |
2462 | static __be32 |
2463 | nfsd4_removexattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, |
2464 | union nfsd4_op_u *u) |
2465 | { |
2466 | struct nfsd4_removexattr *removexattr = &u->removexattr; |
2467 | __be32 ret; |
2468 | |
2469 | if (opens_in_grace(SVC_NET(rqstp))) |
2470 | return nfserr_grace; |
2471 | |
2472 | ret = nfsd_removexattr(rqstp, fhp: &cstate->current_fh, |
2473 | name: removexattr->rmxa_name); |
2474 | |
2475 | if (!ret) |
2476 | set_change_info(cinfo: &removexattr->rmxa_cinfo, fhp: &cstate->current_fh); |
2477 | |
2478 | return ret; |
2479 | } |
2480 | |
2481 | /* |
2482 | * NULL call. |
2483 | */ |
2484 | static __be32 |
2485 | nfsd4_proc_null(struct svc_rqst *rqstp) |
2486 | { |
2487 | return rpc_success; |
2488 | } |
2489 | |
2490 | static inline void nfsd4_increment_op_stats(u32 opnum) |
2491 | { |
2492 | if (opnum >= FIRST_NFS4_OP && opnum <= LAST_NFS4_OP) |
2493 | percpu_counter_inc(fbc: &nfsdstats.counter[NFSD_STATS_NFS4_OP(opnum)]); |
2494 | } |
2495 | |
2496 | static const struct nfsd4_operation nfsd4_ops[]; |
2497 | |
2498 | static const char *nfsd4_op_name(unsigned opnum); |
2499 | |
2500 | /* |
2501 | * Enforce NFSv4.1 COMPOUND ordering rules: |
2502 | * |
2503 | * Also note, enforced elsewhere: |
2504 | * - SEQUENCE other than as first op results in |
2505 | * NFS4ERR_SEQUENCE_POS. (Enforced in nfsd4_sequence().) |
2506 | * - BIND_CONN_TO_SESSION must be the only op in its compound. |
2507 | * (Enforced in nfsd4_bind_conn_to_session().) |
2508 | * - DESTROY_SESSION must be the final operation in a compound, if |
2509 | * sessionid's in SEQUENCE and DESTROY_SESSION are the same. |
2510 | * (Enforced in nfsd4_destroy_session().) |
2511 | */ |
2512 | static __be32 nfs41_check_op_ordering(struct nfsd4_compoundargs *args) |
2513 | { |
2514 | struct nfsd4_op *first_op = &args->ops[0]; |
2515 | |
2516 | /* These ordering requirements don't apply to NFSv4.0: */ |
2517 | if (args->minorversion == 0) |
2518 | return nfs_ok; |
2519 | /* This is weird, but OK, not our problem: */ |
2520 | if (args->opcnt == 0) |
2521 | return nfs_ok; |
2522 | if (first_op->status == nfserr_op_illegal) |
2523 | return nfs_ok; |
2524 | if (!(nfsd4_ops[first_op->opnum].op_flags & ALLOWED_AS_FIRST_OP)) |
2525 | return nfserr_op_not_in_session; |
2526 | if (first_op->opnum == OP_SEQUENCE) |
2527 | return nfs_ok; |
2528 | /* |
2529 | * So first_op is something allowed outside a session, like |
2530 | * EXCHANGE_ID; but then it has to be the only op in the |
2531 | * compound: |
2532 | */ |
2533 | if (args->opcnt != 1) |
2534 | return nfserr_not_only_op; |
2535 | return nfs_ok; |
2536 | } |
2537 | |
2538 | const struct nfsd4_operation *OPDESC(struct nfsd4_op *op) |
2539 | { |
2540 | return &nfsd4_ops[op->opnum]; |
2541 | } |
2542 | |
2543 | bool nfsd4_cache_this_op(struct nfsd4_op *op) |
2544 | { |
2545 | if (op->opnum == OP_ILLEGAL) |
2546 | return false; |
2547 | return OPDESC(op)->op_flags & OP_CACHEME; |
2548 | } |
2549 | |
2550 | static bool need_wrongsec_check(struct svc_rqst *rqstp) |
2551 | { |
2552 | struct nfsd4_compoundres *resp = rqstp->rq_resp; |
2553 | struct nfsd4_compoundargs *argp = rqstp->rq_argp; |
2554 | struct nfsd4_op *this = &argp->ops[resp->opcnt - 1]; |
2555 | struct nfsd4_op *next = &argp->ops[resp->opcnt]; |
2556 | const struct nfsd4_operation *thisd = OPDESC(op: this); |
2557 | const struct nfsd4_operation *nextd; |
2558 | |
2559 | /* |
2560 | * Most ops check wronsec on our own; only the putfh-like ops |
2561 | * have special rules. |
2562 | */ |
2563 | if (!(thisd->op_flags & OP_IS_PUTFH_LIKE)) |
2564 | return false; |
2565 | /* |
2566 | * rfc 5661 2.6.3.1.1.6: don't bother erroring out a |
2567 | * put-filehandle operation if we're not going to use the |
2568 | * result: |
2569 | */ |
2570 | if (argp->opcnt == resp->opcnt) |
2571 | return false; |
2572 | if (next->opnum == OP_ILLEGAL) |
2573 | return false; |
2574 | nextd = OPDESC(op: next); |
2575 | /* |
2576 | * Rest of 2.6.3.1.1: certain operations will return WRONGSEC |
2577 | * errors themselves as necessary; others should check for them |
2578 | * now: |
2579 | */ |
2580 | return !(nextd->op_flags & OP_HANDLES_WRONGSEC); |
2581 | } |
2582 | |
2583 | #ifdef CONFIG_NFSD_V4_2_INTER_SSC |
2584 | static void |
2585 | check_if_stalefh_allowed(struct nfsd4_compoundargs *args) |
2586 | { |
2587 | struct nfsd4_op *op, *current_op = NULL, *saved_op = NULL; |
2588 | struct nfsd4_copy *copy; |
2589 | struct nfsd4_putfh *putfh; |
2590 | int i; |
2591 | |
2592 | /* traverse all operation and if it's a COPY compound, mark the |
2593 | * source filehandle to skip verification |
2594 | */ |
2595 | for (i = 0; i < args->opcnt; i++) { |
2596 | op = &args->ops[i]; |
2597 | if (op->opnum == OP_PUTFH) |
2598 | current_op = op; |
2599 | else if (op->opnum == OP_SAVEFH) |
2600 | saved_op = current_op; |
2601 | else if (op->opnum == OP_RESTOREFH) |
2602 | current_op = saved_op; |
2603 | else if (op->opnum == OP_COPY) { |
2604 | copy = (struct nfsd4_copy *)&op->u; |
2605 | if (!saved_op) { |
2606 | op->status = nfserr_nofilehandle; |
2607 | return; |
2608 | } |
2609 | putfh = (struct nfsd4_putfh *)&saved_op->u; |
2610 | if (nfsd4_ssc_is_inter(copy)) |
2611 | putfh->no_verify = true; |
2612 | } |
2613 | } |
2614 | } |
2615 | #else |
2616 | static void |
2617 | check_if_stalefh_allowed(struct nfsd4_compoundargs *args) |
2618 | { |
2619 | } |
2620 | #endif |
2621 | |
2622 | /* |
2623 | * COMPOUND call. |
2624 | */ |
2625 | static __be32 |
2626 | nfsd4_proc_compound(struct svc_rqst *rqstp) |
2627 | { |
2628 | struct nfsd4_compoundargs *args = rqstp->rq_argp; |
2629 | struct nfsd4_compoundres *resp = rqstp->rq_resp; |
2630 | struct nfsd4_op *op; |
2631 | struct nfsd4_compound_state *cstate = &resp->cstate; |
2632 | struct svc_fh *current_fh = &cstate->current_fh; |
2633 | struct svc_fh *save_fh = &cstate->save_fh; |
2634 | struct nfsd_net *nn = net_generic(SVC_NET(rqstp), id: nfsd_net_id); |
2635 | __be32 status; |
2636 | |
2637 | resp->xdr = &rqstp->rq_res_stream; |
2638 | resp->statusp = resp->xdr->p; |
2639 | |
2640 | /* reserve space for: NFS status code */ |
2641 | xdr_reserve_space(xdr: resp->xdr, XDR_UNIT); |
2642 | |
2643 | /* reserve space for: taglen, tag, and opcnt */ |
2644 | xdr_reserve_space(xdr: resp->xdr, XDR_UNIT * 2 + args->taglen); |
2645 | resp->taglen = args->taglen; |
2646 | resp->tag = args->tag; |
2647 | resp->rqstp = rqstp; |
2648 | cstate->minorversion = args->minorversion; |
2649 | fh_init(fhp: current_fh, NFS4_FHSIZE); |
2650 | fh_init(fhp: save_fh, NFS4_FHSIZE); |
2651 | /* |
2652 | * Don't use the deferral mechanism for NFSv4; compounds make it |
2653 | * too hard to avoid non-idempotency problems. |
2654 | */ |
2655 | clear_bit(nr: RQ_USEDEFERRAL, addr: &rqstp->rq_flags); |
2656 | |
2657 | /* |
2658 | * According to RFC3010, this takes precedence over all other errors. |
2659 | */ |
2660 | status = nfserr_minor_vers_mismatch; |
2661 | if (nfsd_minorversion(nn, minorversion: args->minorversion, change: NFSD_TEST) <= 0) |
2662 | goto out; |
2663 | |
2664 | status = nfs41_check_op_ordering(args); |
2665 | if (status) { |
2666 | op = &args->ops[0]; |
2667 | op->status = status; |
2668 | resp->opcnt = 1; |
2669 | goto encode_op; |
2670 | } |
2671 | check_if_stalefh_allowed(args); |
2672 | |
2673 | rqstp->rq_lease_breaker = (void **)&cstate->clp; |
2674 | |
2675 | trace_nfsd_compound(rqst: rqstp, tag: args->tag, taglen: args->taglen, opcnt: args->client_opcnt); |
2676 | while (!status && resp->opcnt < args->opcnt) { |
2677 | op = &args->ops[resp->opcnt++]; |
2678 | |
2679 | if (unlikely(resp->opcnt == NFSD_MAX_OPS_PER_COMPOUND)) { |
2680 | /* If there are still more operations to process, |
2681 | * stop here and report NFS4ERR_RESOURCE. */ |
2682 | if (cstate->minorversion == 0 && |
2683 | args->client_opcnt > resp->opcnt) { |
2684 | op->status = nfserr_resource; |
2685 | goto encode_op; |
2686 | } |
2687 | } |
2688 | |
2689 | /* |
2690 | * The XDR decode routines may have pre-set op->status; |
2691 | * for example, if there is a miscellaneous XDR error |
2692 | * it will be set to nfserr_bad_xdr. |
2693 | */ |
2694 | if (op->status) { |
2695 | if (op->opnum == OP_OPEN) |
2696 | op->status = nfsd4_open_omfg(rqstp, cstate, op); |
2697 | goto encode_op; |
2698 | } |
2699 | if (!current_fh->fh_dentry && |
2700 | !HAS_FH_FLAG(current_fh, NFSD4_FH_FOREIGN)) { |
2701 | if (!(op->opdesc->op_flags & ALLOWED_WITHOUT_FH)) { |
2702 | op->status = nfserr_nofilehandle; |
2703 | goto encode_op; |
2704 | } |
2705 | } else if (current_fh->fh_export && |
2706 | current_fh->fh_export->ex_fslocs.migrated && |
2707 | !(op->opdesc->op_flags & ALLOWED_ON_ABSENT_FS)) { |
2708 | op->status = nfserr_moved; |
2709 | goto encode_op; |
2710 | } |
2711 | |
2712 | fh_clear_pre_post_attrs(fhp: current_fh); |
2713 | |
2714 | /* If op is non-idempotent */ |
2715 | if (op->opdesc->op_flags & OP_MODIFIES_SOMETHING) { |
2716 | /* |
2717 | * Don't execute this op if we couldn't encode a |
2718 | * successful reply: |
2719 | */ |
2720 | u32 plen = op->opdesc->op_rsize_bop(rqstp, op); |
2721 | /* |
2722 | * Plus if there's another operation, make sure |
2723 | * we'll have space to at least encode an error: |
2724 | */ |
2725 | if (resp->opcnt < args->opcnt) |
2726 | plen += COMPOUND_ERR_SLACK_SPACE; |
2727 | op->status = nfsd4_check_resp_size(resp, plen); |
2728 | } |
2729 | |
2730 | if (op->status) |
2731 | goto encode_op; |
2732 | |
2733 | if (op->opdesc->op_get_currentstateid) |
2734 | op->opdesc->op_get_currentstateid(cstate, &op->u); |
2735 | op->status = op->opdesc->op_func(rqstp, cstate, &op->u); |
2736 | |
2737 | /* Only from SEQUENCE */ |
2738 | if (cstate->status == nfserr_replay_cache) { |
2739 | dprintk("%s NFS4.1 replay from cache\n" , __func__); |
2740 | status = op->status; |
2741 | goto out; |
2742 | } |
2743 | if (!op->status) { |
2744 | if (op->opdesc->op_set_currentstateid) |
2745 | op->opdesc->op_set_currentstateid(cstate, &op->u); |
2746 | |
2747 | if (op->opdesc->op_flags & OP_CLEAR_STATEID) |
2748 | clear_current_stateid(cstate); |
2749 | |
2750 | if (current_fh->fh_export && |
2751 | need_wrongsec_check(rqstp)) |
2752 | op->status = check_nfsd_access(exp: current_fh->fh_export, rqstp); |
2753 | } |
2754 | encode_op: |
2755 | if (op->status == nfserr_replay_me) { |
2756 | op->replay = &cstate->replay_owner->so_replay; |
2757 | nfsd4_encode_replay(xdr: resp->xdr, op); |
2758 | status = op->status = op->replay->rp_status; |
2759 | } else { |
2760 | nfsd4_encode_operation(resp, op); |
2761 | status = op->status; |
2762 | } |
2763 | |
2764 | trace_nfsd_compound_status(args_opcnt: args->client_opcnt, resp_opcnt: resp->opcnt, |
2765 | status, name: nfsd4_op_name(opnum: op->opnum)); |
2766 | |
2767 | nfsd4_cstate_clear_replay(cstate); |
2768 | nfsd4_increment_op_stats(opnum: op->opnum); |
2769 | } |
2770 | |
2771 | fh_put(current_fh); |
2772 | fh_put(save_fh); |
2773 | BUG_ON(cstate->replay_owner); |
2774 | out: |
2775 | cstate->status = status; |
2776 | /* Reset deferral mechanism for RPC deferrals */ |
2777 | set_bit(nr: RQ_USEDEFERRAL, addr: &rqstp->rq_flags); |
2778 | return rpc_success; |
2779 | } |
2780 | |
2781 | #define op_encode_hdr_size (2) |
2782 | #define op_encode_stateid_maxsz (XDR_QUADLEN(NFS4_STATEID_SIZE)) |
2783 | #define op_encode_verifier_maxsz (XDR_QUADLEN(NFS4_VERIFIER_SIZE)) |
2784 | #define op_encode_change_info_maxsz (5) |
2785 | #define nfs4_fattr_bitmap_maxsz (4) |
2786 | |
2787 | /* We'll fall back on returning no lockowner if run out of space: */ |
2788 | #define op_encode_lockowner_maxsz (0) |
2789 | #define op_encode_lock_denied_maxsz (8 + op_encode_lockowner_maxsz) |
2790 | |
2791 | #define nfs4_owner_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ)) |
2792 | |
2793 | #define op_encode_ace_maxsz (3 + nfs4_owner_maxsz) |
2794 | #define op_encode_delegation_maxsz (1 + op_encode_stateid_maxsz + 1 + \ |
2795 | op_encode_ace_maxsz) |
2796 | |
2797 | #define op_encode_channel_attrs_maxsz (6 + 1 + 1) |
2798 | |
2799 | /* |
2800 | * The _rsize() helpers are invoked by the NFSv4 COMPOUND decoder, which |
2801 | * is called before sunrpc sets rq_res.buflen. Thus we have to compute |
2802 | * the maximum payload size here, based on transport limits and the size |
2803 | * of the remaining space in the rq_pages array. |
2804 | */ |
2805 | static u32 nfsd4_max_payload(const struct svc_rqst *rqstp) |
2806 | { |
2807 | u32 buflen; |
2808 | |
2809 | buflen = (rqstp->rq_page_end - rqstp->rq_next_page) * PAGE_SIZE; |
2810 | buflen -= rqstp->rq_auth_slack; |
2811 | buflen -= rqstp->rq_res.head[0].iov_len; |
2812 | return min_t(u32, buflen, svc_max_payload(rqstp)); |
2813 | } |
2814 | |
2815 | static u32 nfsd4_only_status_rsize(const struct svc_rqst *rqstp, |
2816 | const struct nfsd4_op *op) |
2817 | { |
2818 | return (op_encode_hdr_size) * sizeof(__be32); |
2819 | } |
2820 | |
2821 | static u32 nfsd4_status_stateid_rsize(const struct svc_rqst *rqstp, |
2822 | const struct nfsd4_op *op) |
2823 | { |
2824 | return (op_encode_hdr_size + op_encode_stateid_maxsz)* sizeof(__be32); |
2825 | } |
2826 | |
2827 | static u32 nfsd4_access_rsize(const struct svc_rqst *rqstp, |
2828 | const struct nfsd4_op *op) |
2829 | { |
2830 | /* ac_supported, ac_resp_access */ |
2831 | return (op_encode_hdr_size + 2)* sizeof(__be32); |
2832 | } |
2833 | |
2834 | static u32 nfsd4_commit_rsize(const struct svc_rqst *rqstp, |
2835 | const struct nfsd4_op *op) |
2836 | { |
2837 | return (op_encode_hdr_size + op_encode_verifier_maxsz) * sizeof(__be32); |
2838 | } |
2839 | |
2840 | static u32 nfsd4_create_rsize(const struct svc_rqst *rqstp, |
2841 | const struct nfsd4_op *op) |
2842 | { |
2843 | return (op_encode_hdr_size + op_encode_change_info_maxsz |
2844 | + nfs4_fattr_bitmap_maxsz) * sizeof(__be32); |
2845 | } |
2846 | |
2847 | /* |
2848 | * Note since this is an idempotent operation we won't insist on failing |
2849 | * the op prematurely if the estimate is too large. We may turn off splice |
2850 | * reads unnecessarily. |
2851 | */ |
2852 | static u32 nfsd4_getattr_rsize(const struct svc_rqst *rqstp, |
2853 | const struct nfsd4_op *op) |
2854 | { |
2855 | const u32 *bmap = op->u.getattr.ga_bmval; |
2856 | u32 bmap0 = bmap[0], bmap1 = bmap[1], bmap2 = bmap[2]; |
2857 | u32 ret = 0; |
2858 | |
2859 | if (bmap0 & FATTR4_WORD0_ACL) |
2860 | return nfsd4_max_payload(rqstp); |
2861 | if (bmap0 & FATTR4_WORD0_FS_LOCATIONS) |
2862 | return nfsd4_max_payload(rqstp); |
2863 | |
2864 | if (bmap1 & FATTR4_WORD1_OWNER) { |
2865 | ret += IDMAP_NAMESZ + 4; |
2866 | bmap1 &= ~FATTR4_WORD1_OWNER; |
2867 | } |
2868 | if (bmap1 & FATTR4_WORD1_OWNER_GROUP) { |
2869 | ret += IDMAP_NAMESZ + 4; |
2870 | bmap1 &= ~FATTR4_WORD1_OWNER_GROUP; |
2871 | } |
2872 | if (bmap0 & FATTR4_WORD0_FILEHANDLE) { |
2873 | ret += NFS4_FHSIZE + 4; |
2874 | bmap0 &= ~FATTR4_WORD0_FILEHANDLE; |
2875 | } |
2876 | if (bmap2 & FATTR4_WORD2_SECURITY_LABEL) { |
2877 | ret += NFS4_MAXLABELLEN + 12; |
2878 | bmap2 &= ~FATTR4_WORD2_SECURITY_LABEL; |
2879 | } |
2880 | /* |
2881 | * Largest of remaining attributes are 16 bytes (e.g., |
2882 | * supported_attributes) |
2883 | */ |
2884 | ret += 16 * (hweight32(bmap0) + hweight32(bmap1) + hweight32(bmap2)); |
2885 | /* bitmask, length */ |
2886 | ret += 20; |
2887 | return ret; |
2888 | } |
2889 | |
2890 | static u32 nfsd4_getfh_rsize(const struct svc_rqst *rqstp, |
2891 | const struct nfsd4_op *op) |
2892 | { |
2893 | return (op_encode_hdr_size + 1) * sizeof(__be32) + NFS4_FHSIZE; |
2894 | } |
2895 | |
2896 | static u32 nfsd4_link_rsize(const struct svc_rqst *rqstp, |
2897 | const struct nfsd4_op *op) |
2898 | { |
2899 | return (op_encode_hdr_size + op_encode_change_info_maxsz) |
2900 | * sizeof(__be32); |
2901 | } |
2902 | |
2903 | static u32 nfsd4_lock_rsize(const struct svc_rqst *rqstp, |
2904 | const struct nfsd4_op *op) |
2905 | { |
2906 | return (op_encode_hdr_size + op_encode_lock_denied_maxsz) |
2907 | * sizeof(__be32); |
2908 | } |
2909 | |
2910 | static u32 nfsd4_open_rsize(const struct svc_rqst *rqstp, |
2911 | const struct nfsd4_op *op) |
2912 | { |
2913 | return (op_encode_hdr_size + op_encode_stateid_maxsz |
2914 | + op_encode_change_info_maxsz + 1 |
2915 | + nfs4_fattr_bitmap_maxsz |
2916 | + op_encode_delegation_maxsz) * sizeof(__be32); |
2917 | } |
2918 | |
2919 | static u32 nfsd4_read_rsize(const struct svc_rqst *rqstp, |
2920 | const struct nfsd4_op *op) |
2921 | { |
2922 | u32 rlen = min(op->u.read.rd_length, nfsd4_max_payload(rqstp)); |
2923 | |
2924 | return (op_encode_hdr_size + 2 + XDR_QUADLEN(rlen)) * sizeof(__be32); |
2925 | } |
2926 | |
2927 | static u32 nfsd4_read_plus_rsize(const struct svc_rqst *rqstp, |
2928 | const struct nfsd4_op *op) |
2929 | { |
2930 | u32 rlen = min(op->u.read.rd_length, nfsd4_max_payload(rqstp)); |
2931 | /* |
2932 | * If we detect that the file changed during hole encoding, then we |
2933 | * recover by encoding the remaining reply as data. This means we need |
2934 | * to set aside enough room to encode two data segments. |
2935 | */ |
2936 | u32 seg_len = 2 * (1 + 2 + 1); |
2937 | |
2938 | return (op_encode_hdr_size + 2 + seg_len + XDR_QUADLEN(rlen)) * sizeof(__be32); |
2939 | } |
2940 | |
2941 | static u32 nfsd4_readdir_rsize(const struct svc_rqst *rqstp, |
2942 | const struct nfsd4_op *op) |
2943 | { |
2944 | u32 rlen = min(op->u.readdir.rd_maxcount, nfsd4_max_payload(rqstp)); |
2945 | |
2946 | return (op_encode_hdr_size + op_encode_verifier_maxsz + |
2947 | XDR_QUADLEN(rlen)) * sizeof(__be32); |
2948 | } |
2949 | |
2950 | static u32 nfsd4_readlink_rsize(const struct svc_rqst *rqstp, |
2951 | const struct nfsd4_op *op) |
2952 | { |
2953 | return (op_encode_hdr_size + 1) * sizeof(__be32) + PAGE_SIZE; |
2954 | } |
2955 | |
2956 | static u32 nfsd4_remove_rsize(const struct svc_rqst *rqstp, |
2957 | const struct nfsd4_op *op) |
2958 | { |
2959 | return (op_encode_hdr_size + op_encode_change_info_maxsz) |
2960 | * sizeof(__be32); |
2961 | } |
2962 | |
2963 | static u32 nfsd4_rename_rsize(const struct svc_rqst *rqstp, |
2964 | const struct nfsd4_op *op) |
2965 | { |
2966 | return (op_encode_hdr_size + op_encode_change_info_maxsz |
2967 | + op_encode_change_info_maxsz) * sizeof(__be32); |
2968 | } |
2969 | |
2970 | static u32 nfsd4_sequence_rsize(const struct svc_rqst *rqstp, |
2971 | const struct nfsd4_op *op) |
2972 | { |
2973 | return (op_encode_hdr_size |
2974 | + XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + 5) * sizeof(__be32); |
2975 | } |
2976 | |
2977 | static u32 nfsd4_test_stateid_rsize(const struct svc_rqst *rqstp, |
2978 | const struct nfsd4_op *op) |
2979 | { |
2980 | return (op_encode_hdr_size + 1 + op->u.test_stateid.ts_num_ids) |
2981 | * sizeof(__be32); |
2982 | } |
2983 | |
2984 | static u32 nfsd4_setattr_rsize(const struct svc_rqst *rqstp, |
2985 | const struct nfsd4_op *op) |
2986 | { |
2987 | return (op_encode_hdr_size + nfs4_fattr_bitmap_maxsz) * sizeof(__be32); |
2988 | } |
2989 | |
2990 | static u32 nfsd4_secinfo_rsize(const struct svc_rqst *rqstp, |
2991 | const struct nfsd4_op *op) |
2992 | { |
2993 | return (op_encode_hdr_size + RPC_AUTH_MAXFLAVOR * |
2994 | (4 + XDR_QUADLEN(GSS_OID_MAX_LEN))) * sizeof(__be32); |
2995 | } |
2996 | |
2997 | static u32 nfsd4_setclientid_rsize(const struct svc_rqst *rqstp, |
2998 | const struct nfsd4_op *op) |
2999 | { |
3000 | return (op_encode_hdr_size + 2 + XDR_QUADLEN(NFS4_VERIFIER_SIZE)) * |
3001 | sizeof(__be32); |
3002 | } |
3003 | |
3004 | static u32 nfsd4_write_rsize(const struct svc_rqst *rqstp, |
3005 | const struct nfsd4_op *op) |
3006 | { |
3007 | return (op_encode_hdr_size + 2 + op_encode_verifier_maxsz) * sizeof(__be32); |
3008 | } |
3009 | |
3010 | static u32 nfsd4_exchange_id_rsize(const struct svc_rqst *rqstp, |
3011 | const struct nfsd4_op *op) |
3012 | { |
3013 | return (op_encode_hdr_size + 2 + 1 + /* eir_clientid, eir_sequenceid */\ |
3014 | 1 + 1 + /* eir_flags, spr_how */\ |
3015 | 4 + /* spo_must_enforce & _allow with bitmap */\ |
3016 | 2 + /*eir_server_owner.so_minor_id */\ |
3017 | /* eir_server_owner.so_major_id<> */\ |
3018 | XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 +\ |
3019 | /* eir_server_scope<> */\ |
3020 | XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 +\ |
3021 | 1 + /* eir_server_impl_id array length */\ |
3022 | 0 /* ignored eir_server_impl_id contents */) * sizeof(__be32); |
3023 | } |
3024 | |
3025 | static u32 nfsd4_bind_conn_to_session_rsize(const struct svc_rqst *rqstp, |
3026 | const struct nfsd4_op *op) |
3027 | { |
3028 | return (op_encode_hdr_size + \ |
3029 | XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + /* bctsr_sessid */\ |
3030 | 2 /* bctsr_dir, use_conn_in_rdma_mode */) * sizeof(__be32); |
3031 | } |
3032 | |
3033 | static u32 nfsd4_create_session_rsize(const struct svc_rqst *rqstp, |
3034 | const struct nfsd4_op *op) |
3035 | { |
3036 | return (op_encode_hdr_size + \ |
3037 | XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + /* sessionid */\ |
3038 | 2 + /* csr_sequence, csr_flags */\ |
3039 | op_encode_channel_attrs_maxsz + \ |
3040 | op_encode_channel_attrs_maxsz) * sizeof(__be32); |
3041 | } |
3042 | |
3043 | static u32 nfsd4_copy_rsize(const struct svc_rqst *rqstp, |
3044 | const struct nfsd4_op *op) |
3045 | { |
3046 | return (op_encode_hdr_size + |
3047 | 1 /* wr_callback */ + |
3048 | op_encode_stateid_maxsz /* wr_callback */ + |
3049 | 2 /* wr_count */ + |
3050 | 1 /* wr_committed */ + |
3051 | op_encode_verifier_maxsz + |
3052 | 1 /* cr_consecutive */ + |
3053 | 1 /* cr_synchronous */) * sizeof(__be32); |
3054 | } |
3055 | |
3056 | static u32 nfsd4_offload_status_rsize(const struct svc_rqst *rqstp, |
3057 | const struct nfsd4_op *op) |
3058 | { |
3059 | return (op_encode_hdr_size + |
3060 | 2 /* osr_count */ + |
3061 | 1 /* osr_complete<1> optional 0 for now */) * sizeof(__be32); |
3062 | } |
3063 | |
3064 | static u32 nfsd4_copy_notify_rsize(const struct svc_rqst *rqstp, |
3065 | const struct nfsd4_op *op) |
3066 | { |
3067 | return (op_encode_hdr_size + |
3068 | 3 /* cnr_lease_time */ + |
3069 | 1 /* We support one cnr_source_server */ + |
3070 | 1 /* cnr_stateid seq */ + |
3071 | op_encode_stateid_maxsz /* cnr_stateid */ + |
3072 | 1 /* num cnr_source_server*/ + |
3073 | 1 /* nl4_type */ + |
3074 | 1 /* nl4 size */ + |
3075 | XDR_QUADLEN(NFS4_OPAQUE_LIMIT) /*nl4_loc + nl4_loc_sz */) |
3076 | * sizeof(__be32); |
3077 | } |
3078 | |
3079 | #ifdef CONFIG_NFSD_PNFS |
3080 | static u32 nfsd4_getdeviceinfo_rsize(const struct svc_rqst *rqstp, |
3081 | const struct nfsd4_op *op) |
3082 | { |
3083 | u32 rlen = min(op->u.getdeviceinfo.gd_maxcount, nfsd4_max_payload(rqstp)); |
3084 | |
3085 | return (op_encode_hdr_size + |
3086 | 1 /* gd_layout_type*/ + |
3087 | XDR_QUADLEN(rlen) + |
3088 | 2 /* gd_notify_types */) * sizeof(__be32); |
3089 | } |
3090 | |
3091 | /* |
3092 | * At this stage we don't really know what layout driver will handle the request, |
3093 | * so we need to define an arbitrary upper bound here. |
3094 | */ |
3095 | #define MAX_LAYOUT_SIZE 128 |
3096 | static u32 nfsd4_layoutget_rsize(const struct svc_rqst *rqstp, |
3097 | const struct nfsd4_op *op) |
3098 | { |
3099 | return (op_encode_hdr_size + |
3100 | 1 /* logr_return_on_close */ + |
3101 | op_encode_stateid_maxsz + |
3102 | 1 /* nr of layouts */ + |
3103 | MAX_LAYOUT_SIZE) * sizeof(__be32); |
3104 | } |
3105 | |
3106 | static u32 nfsd4_layoutcommit_rsize(const struct svc_rqst *rqstp, |
3107 | const struct nfsd4_op *op) |
3108 | { |
3109 | return (op_encode_hdr_size + |
3110 | 1 /* locr_newsize */ + |
3111 | 2 /* ns_size */) * sizeof(__be32); |
3112 | } |
3113 | |
3114 | static u32 nfsd4_layoutreturn_rsize(const struct svc_rqst *rqstp, |
3115 | const struct nfsd4_op *op) |
3116 | { |
3117 | return (op_encode_hdr_size + |
3118 | 1 /* lrs_stateid */ + |
3119 | op_encode_stateid_maxsz) * sizeof(__be32); |
3120 | } |
3121 | #endif /* CONFIG_NFSD_PNFS */ |
3122 | |
3123 | |
3124 | static u32 nfsd4_seek_rsize(const struct svc_rqst *rqstp, |
3125 | const struct nfsd4_op *op) |
3126 | { |
3127 | return (op_encode_hdr_size + 3) * sizeof(__be32); |
3128 | } |
3129 | |
3130 | static u32 nfsd4_getxattr_rsize(const struct svc_rqst *rqstp, |
3131 | const struct nfsd4_op *op) |
3132 | { |
3133 | u32 rlen = min_t(u32, XATTR_SIZE_MAX, nfsd4_max_payload(rqstp)); |
3134 | |
3135 | return (op_encode_hdr_size + 1 + XDR_QUADLEN(rlen)) * sizeof(__be32); |
3136 | } |
3137 | |
3138 | static u32 nfsd4_setxattr_rsize(const struct svc_rqst *rqstp, |
3139 | const struct nfsd4_op *op) |
3140 | { |
3141 | return (op_encode_hdr_size + op_encode_change_info_maxsz) |
3142 | * sizeof(__be32); |
3143 | } |
3144 | static u32 nfsd4_listxattrs_rsize(const struct svc_rqst *rqstp, |
3145 | const struct nfsd4_op *op) |
3146 | { |
3147 | u32 rlen = min(op->u.listxattrs.lsxa_maxcount, nfsd4_max_payload(rqstp)); |
3148 | |
3149 | return (op_encode_hdr_size + 4 + XDR_QUADLEN(rlen)) * sizeof(__be32); |
3150 | } |
3151 | |
3152 | static u32 nfsd4_removexattr_rsize(const struct svc_rqst *rqstp, |
3153 | const struct nfsd4_op *op) |
3154 | { |
3155 | return (op_encode_hdr_size + op_encode_change_info_maxsz) |
3156 | * sizeof(__be32); |
3157 | } |
3158 | |
3159 | |
3160 | static const struct nfsd4_operation nfsd4_ops[] = { |
3161 | [OP_ACCESS] = { |
3162 | .op_func = nfsd4_access, |
3163 | .op_name = "OP_ACCESS" , |
3164 | .op_rsize_bop = nfsd4_access_rsize, |
3165 | }, |
3166 | [OP_CLOSE] = { |
3167 | .op_func = nfsd4_close, |
3168 | .op_flags = OP_MODIFIES_SOMETHING, |
3169 | .op_name = "OP_CLOSE" , |
3170 | .op_rsize_bop = nfsd4_status_stateid_rsize, |
3171 | .op_get_currentstateid = nfsd4_get_closestateid, |
3172 | .op_set_currentstateid = nfsd4_set_closestateid, |
3173 | }, |
3174 | [OP_COMMIT] = { |
3175 | .op_func = nfsd4_commit, |
3176 | .op_flags = OP_MODIFIES_SOMETHING, |
3177 | .op_name = "OP_COMMIT" , |
3178 | .op_rsize_bop = nfsd4_commit_rsize, |
3179 | }, |
3180 | [OP_CREATE] = { |
3181 | .op_func = nfsd4_create, |
3182 | .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME | OP_CLEAR_STATEID, |
3183 | .op_name = "OP_CREATE" , |
3184 | .op_rsize_bop = nfsd4_create_rsize, |
3185 | }, |
3186 | [OP_DELEGRETURN] = { |
3187 | .op_func = nfsd4_delegreturn, |
3188 | .op_flags = OP_MODIFIES_SOMETHING, |
3189 | .op_name = "OP_DELEGRETURN" , |
3190 | .op_rsize_bop = nfsd4_only_status_rsize, |
3191 | .op_get_currentstateid = nfsd4_get_delegreturnstateid, |
3192 | }, |
3193 | [OP_GETATTR] = { |
3194 | .op_func = nfsd4_getattr, |
3195 | .op_flags = ALLOWED_ON_ABSENT_FS, |
3196 | .op_rsize_bop = nfsd4_getattr_rsize, |
3197 | .op_name = "OP_GETATTR" , |
3198 | }, |
3199 | [OP_GETFH] = { |
3200 | .op_func = nfsd4_getfh, |
3201 | .op_name = "OP_GETFH" , |
3202 | .op_rsize_bop = nfsd4_getfh_rsize, |
3203 | }, |
3204 | [OP_LINK] = { |
3205 | .op_func = nfsd4_link, |
3206 | .op_flags = ALLOWED_ON_ABSENT_FS | OP_MODIFIES_SOMETHING |
3207 | | OP_CACHEME, |
3208 | .op_name = "OP_LINK" , |
3209 | .op_rsize_bop = nfsd4_link_rsize, |
3210 | }, |
3211 | [OP_LOCK] = { |
3212 | .op_func = nfsd4_lock, |
3213 | .op_release = nfsd4_lock_release, |
3214 | .op_flags = OP_MODIFIES_SOMETHING | |
3215 | OP_NONTRIVIAL_ERROR_ENCODE, |
3216 | .op_name = "OP_LOCK" , |
3217 | .op_rsize_bop = nfsd4_lock_rsize, |
3218 | .op_set_currentstateid = nfsd4_set_lockstateid, |
3219 | }, |
3220 | [OP_LOCKT] = { |
3221 | .op_func = nfsd4_lockt, |
3222 | .op_release = nfsd4_lockt_release, |
3223 | .op_flags = OP_NONTRIVIAL_ERROR_ENCODE, |
3224 | .op_name = "OP_LOCKT" , |
3225 | .op_rsize_bop = nfsd4_lock_rsize, |
3226 | }, |
3227 | [OP_LOCKU] = { |
3228 | .op_func = nfsd4_locku, |
3229 | .op_flags = OP_MODIFIES_SOMETHING, |
3230 | .op_name = "OP_LOCKU" , |
3231 | .op_rsize_bop = nfsd4_status_stateid_rsize, |
3232 | .op_get_currentstateid = nfsd4_get_lockustateid, |
3233 | }, |
3234 | [OP_LOOKUP] = { |
3235 | .op_func = nfsd4_lookup, |
3236 | .op_flags = OP_HANDLES_WRONGSEC | OP_CLEAR_STATEID, |
3237 | .op_name = "OP_LOOKUP" , |
3238 | .op_rsize_bop = nfsd4_only_status_rsize, |
3239 | }, |
3240 | [OP_LOOKUPP] = { |
3241 | .op_func = nfsd4_lookupp, |
3242 | .op_flags = OP_HANDLES_WRONGSEC | OP_CLEAR_STATEID, |
3243 | .op_name = "OP_LOOKUPP" , |
3244 | .op_rsize_bop = nfsd4_only_status_rsize, |
3245 | }, |
3246 | [OP_NVERIFY] = { |
3247 | .op_func = nfsd4_nverify, |
3248 | .op_name = "OP_NVERIFY" , |
3249 | .op_rsize_bop = nfsd4_only_status_rsize, |
3250 | }, |
3251 | [OP_OPEN] = { |
3252 | .op_func = nfsd4_open, |
3253 | .op_flags = OP_HANDLES_WRONGSEC | OP_MODIFIES_SOMETHING, |
3254 | .op_name = "OP_OPEN" , |
3255 | .op_rsize_bop = nfsd4_open_rsize, |
3256 | .op_set_currentstateid = nfsd4_set_openstateid, |
3257 | }, |
3258 | [OP_OPEN_CONFIRM] = { |
3259 | .op_func = nfsd4_open_confirm, |
3260 | .op_flags = OP_MODIFIES_SOMETHING, |
3261 | .op_name = "OP_OPEN_CONFIRM" , |
3262 | .op_rsize_bop = nfsd4_status_stateid_rsize, |
3263 | }, |
3264 | [OP_OPEN_DOWNGRADE] = { |
3265 | .op_func = nfsd4_open_downgrade, |
3266 | .op_flags = OP_MODIFIES_SOMETHING, |
3267 | .op_name = "OP_OPEN_DOWNGRADE" , |
3268 | .op_rsize_bop = nfsd4_status_stateid_rsize, |
3269 | .op_get_currentstateid = nfsd4_get_opendowngradestateid, |
3270 | .op_set_currentstateid = nfsd4_set_opendowngradestateid, |
3271 | }, |
3272 | [OP_PUTFH] = { |
3273 | .op_func = nfsd4_putfh, |
3274 | .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS |
3275 | | OP_IS_PUTFH_LIKE | OP_CLEAR_STATEID, |
3276 | .op_name = "OP_PUTFH" , |
3277 | .op_rsize_bop = nfsd4_only_status_rsize, |
3278 | }, |
3279 | [OP_PUTPUBFH] = { |
3280 | .op_func = nfsd4_putrootfh, |
3281 | .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS |
3282 | | OP_IS_PUTFH_LIKE | OP_CLEAR_STATEID, |
3283 | .op_name = "OP_PUTPUBFH" , |
3284 | .op_rsize_bop = nfsd4_only_status_rsize, |
3285 | }, |
3286 | [OP_PUTROOTFH] = { |
3287 | .op_func = nfsd4_putrootfh, |
3288 | .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS |
3289 | | OP_IS_PUTFH_LIKE | OP_CLEAR_STATEID, |
3290 | .op_name = "OP_PUTROOTFH" , |
3291 | .op_rsize_bop = nfsd4_only_status_rsize, |
3292 | }, |
3293 | [OP_READ] = { |
3294 | .op_func = nfsd4_read, |
3295 | .op_release = nfsd4_read_release, |
3296 | .op_name = "OP_READ" , |
3297 | .op_rsize_bop = nfsd4_read_rsize, |
3298 | .op_get_currentstateid = nfsd4_get_readstateid, |
3299 | }, |
3300 | [OP_READDIR] = { |
3301 | .op_func = nfsd4_readdir, |
3302 | .op_name = "OP_READDIR" , |
3303 | .op_rsize_bop = nfsd4_readdir_rsize, |
3304 | }, |
3305 | [OP_READLINK] = { |
3306 | .op_func = nfsd4_readlink, |
3307 | .op_name = "OP_READLINK" , |
3308 | .op_rsize_bop = nfsd4_readlink_rsize, |
3309 | }, |
3310 | [OP_REMOVE] = { |
3311 | .op_func = nfsd4_remove, |
3312 | .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME, |
3313 | .op_name = "OP_REMOVE" , |
3314 | .op_rsize_bop = nfsd4_remove_rsize, |
3315 | }, |
3316 | [OP_RENAME] = { |
3317 | .op_func = nfsd4_rename, |
3318 | .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME, |
3319 | .op_name = "OP_RENAME" , |
3320 | .op_rsize_bop = nfsd4_rename_rsize, |
3321 | }, |
3322 | [OP_RENEW] = { |
3323 | .op_func = nfsd4_renew, |
3324 | .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS |
3325 | | OP_MODIFIES_SOMETHING, |
3326 | .op_name = "OP_RENEW" , |
3327 | .op_rsize_bop = nfsd4_only_status_rsize, |
3328 | |
3329 | }, |
3330 | [OP_RESTOREFH] = { |
3331 | .op_func = nfsd4_restorefh, |
3332 | .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS |
3333 | | OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING, |
3334 | .op_name = "OP_RESTOREFH" , |
3335 | .op_rsize_bop = nfsd4_only_status_rsize, |
3336 | }, |
3337 | [OP_SAVEFH] = { |
3338 | .op_func = nfsd4_savefh, |
3339 | .op_flags = OP_HANDLES_WRONGSEC | OP_MODIFIES_SOMETHING, |
3340 | .op_name = "OP_SAVEFH" , |
3341 | .op_rsize_bop = nfsd4_only_status_rsize, |
3342 | }, |
3343 | [OP_SECINFO] = { |
3344 | .op_func = nfsd4_secinfo, |
3345 | .op_release = nfsd4_secinfo_release, |
3346 | .op_flags = OP_HANDLES_WRONGSEC, |
3347 | .op_name = "OP_SECINFO" , |
3348 | .op_rsize_bop = nfsd4_secinfo_rsize, |
3349 | }, |
3350 | [OP_SETATTR] = { |
3351 | .op_func = nfsd4_setattr, |
3352 | .op_name = "OP_SETATTR" , |
3353 | .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME |
3354 | | OP_NONTRIVIAL_ERROR_ENCODE, |
3355 | .op_rsize_bop = nfsd4_setattr_rsize, |
3356 | .op_get_currentstateid = nfsd4_get_setattrstateid, |
3357 | }, |
3358 | [OP_SETCLIENTID] = { |
3359 | .op_func = nfsd4_setclientid, |
3360 | .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS |
3361 | | OP_MODIFIES_SOMETHING | OP_CACHEME |
3362 | | OP_NONTRIVIAL_ERROR_ENCODE, |
3363 | .op_name = "OP_SETCLIENTID" , |
3364 | .op_rsize_bop = nfsd4_setclientid_rsize, |
3365 | }, |
3366 | [OP_SETCLIENTID_CONFIRM] = { |
3367 | .op_func = nfsd4_setclientid_confirm, |
3368 | .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS |
3369 | | OP_MODIFIES_SOMETHING | OP_CACHEME, |
3370 | .op_name = "OP_SETCLIENTID_CONFIRM" , |
3371 | .op_rsize_bop = nfsd4_only_status_rsize, |
3372 | }, |
3373 | [OP_VERIFY] = { |
3374 | .op_func = nfsd4_verify, |
3375 | .op_name = "OP_VERIFY" , |
3376 | .op_rsize_bop = nfsd4_only_status_rsize, |
3377 | }, |
3378 | [OP_WRITE] = { |
3379 | .op_func = nfsd4_write, |
3380 | .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME, |
3381 | .op_name = "OP_WRITE" , |
3382 | .op_rsize_bop = nfsd4_write_rsize, |
3383 | .op_get_currentstateid = nfsd4_get_writestateid, |
3384 | }, |
3385 | [OP_RELEASE_LOCKOWNER] = { |
3386 | .op_func = nfsd4_release_lockowner, |
3387 | .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS |
3388 | | OP_MODIFIES_SOMETHING, |
3389 | .op_name = "OP_RELEASE_LOCKOWNER" , |
3390 | .op_rsize_bop = nfsd4_only_status_rsize, |
3391 | }, |
3392 | |
3393 | /* NFSv4.1 operations */ |
3394 | [OP_EXCHANGE_ID] = { |
3395 | .op_func = nfsd4_exchange_id, |
3396 | .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP |
3397 | | OP_MODIFIES_SOMETHING, |
3398 | .op_name = "OP_EXCHANGE_ID" , |
3399 | .op_rsize_bop = nfsd4_exchange_id_rsize, |
3400 | }, |
3401 | [OP_BACKCHANNEL_CTL] = { |
3402 | .op_func = nfsd4_backchannel_ctl, |
3403 | .op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING, |
3404 | .op_name = "OP_BACKCHANNEL_CTL" , |
3405 | .op_rsize_bop = nfsd4_only_status_rsize, |
3406 | }, |
3407 | [OP_BIND_CONN_TO_SESSION] = { |
3408 | .op_func = nfsd4_bind_conn_to_session, |
3409 | .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP |
3410 | | OP_MODIFIES_SOMETHING, |
3411 | .op_name = "OP_BIND_CONN_TO_SESSION" , |
3412 | .op_rsize_bop = nfsd4_bind_conn_to_session_rsize, |
3413 | }, |
3414 | [OP_CREATE_SESSION] = { |
3415 | .op_func = nfsd4_create_session, |
3416 | .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP |
3417 | | OP_MODIFIES_SOMETHING, |
3418 | .op_name = "OP_CREATE_SESSION" , |
3419 | .op_rsize_bop = nfsd4_create_session_rsize, |
3420 | }, |
3421 | [OP_DESTROY_SESSION] = { |
3422 | .op_func = nfsd4_destroy_session, |
3423 | .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP |
3424 | | OP_MODIFIES_SOMETHING, |
3425 | .op_name = "OP_DESTROY_SESSION" , |
3426 | .op_rsize_bop = nfsd4_only_status_rsize, |
3427 | }, |
3428 | [OP_SEQUENCE] = { |
3429 | .op_func = nfsd4_sequence, |
3430 | .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP, |
3431 | .op_name = "OP_SEQUENCE" , |
3432 | .op_rsize_bop = nfsd4_sequence_rsize, |
3433 | }, |
3434 | [OP_DESTROY_CLIENTID] = { |
3435 | .op_func = nfsd4_destroy_clientid, |
3436 | .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP |
3437 | | OP_MODIFIES_SOMETHING, |
3438 | .op_name = "OP_DESTROY_CLIENTID" , |
3439 | .op_rsize_bop = nfsd4_only_status_rsize, |
3440 | }, |
3441 | [OP_RECLAIM_COMPLETE] = { |
3442 | .op_func = nfsd4_reclaim_complete, |
3443 | .op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING, |
3444 | .op_name = "OP_RECLAIM_COMPLETE" , |
3445 | .op_rsize_bop = nfsd4_only_status_rsize, |
3446 | }, |
3447 | [OP_SECINFO_NO_NAME] = { |
3448 | .op_func = nfsd4_secinfo_no_name, |
3449 | .op_release = nfsd4_secinfo_no_name_release, |
3450 | .op_flags = OP_HANDLES_WRONGSEC, |
3451 | .op_name = "OP_SECINFO_NO_NAME" , |
3452 | .op_rsize_bop = nfsd4_secinfo_rsize, |
3453 | }, |
3454 | [OP_TEST_STATEID] = { |
3455 | .op_func = nfsd4_test_stateid, |
3456 | .op_flags = ALLOWED_WITHOUT_FH, |
3457 | .op_name = "OP_TEST_STATEID" , |
3458 | .op_rsize_bop = nfsd4_test_stateid_rsize, |
3459 | }, |
3460 | [OP_FREE_STATEID] = { |
3461 | .op_func = nfsd4_free_stateid, |
3462 | .op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING, |
3463 | .op_name = "OP_FREE_STATEID" , |
3464 | .op_get_currentstateid = nfsd4_get_freestateid, |
3465 | .op_rsize_bop = nfsd4_only_status_rsize, |
3466 | }, |
3467 | #ifdef CONFIG_NFSD_PNFS |
3468 | [OP_GETDEVICEINFO] = { |
3469 | .op_func = nfsd4_getdeviceinfo, |
3470 | .op_release = nfsd4_getdeviceinfo_release, |
3471 | .op_flags = ALLOWED_WITHOUT_FH, |
3472 | .op_name = "OP_GETDEVICEINFO" , |
3473 | .op_rsize_bop = nfsd4_getdeviceinfo_rsize, |
3474 | }, |
3475 | [OP_LAYOUTGET] = { |
3476 | .op_func = nfsd4_layoutget, |
3477 | .op_release = nfsd4_layoutget_release, |
3478 | .op_flags = OP_MODIFIES_SOMETHING, |
3479 | .op_name = "OP_LAYOUTGET" , |
3480 | .op_rsize_bop = nfsd4_layoutget_rsize, |
3481 | }, |
3482 | [OP_LAYOUTCOMMIT] = { |
3483 | .op_func = nfsd4_layoutcommit, |
3484 | .op_flags = OP_MODIFIES_SOMETHING, |
3485 | .op_name = "OP_LAYOUTCOMMIT" , |
3486 | .op_rsize_bop = nfsd4_layoutcommit_rsize, |
3487 | }, |
3488 | [OP_LAYOUTRETURN] = { |
3489 | .op_func = nfsd4_layoutreturn, |
3490 | .op_flags = OP_MODIFIES_SOMETHING, |
3491 | .op_name = "OP_LAYOUTRETURN" , |
3492 | .op_rsize_bop = nfsd4_layoutreturn_rsize, |
3493 | }, |
3494 | #endif /* CONFIG_NFSD_PNFS */ |
3495 | |
3496 | /* NFSv4.2 operations */ |
3497 | [OP_ALLOCATE] = { |
3498 | .op_func = nfsd4_allocate, |
3499 | .op_flags = OP_MODIFIES_SOMETHING, |
3500 | .op_name = "OP_ALLOCATE" , |
3501 | .op_rsize_bop = nfsd4_only_status_rsize, |
3502 | }, |
3503 | [OP_DEALLOCATE] = { |
3504 | .op_func = nfsd4_deallocate, |
3505 | .op_flags = OP_MODIFIES_SOMETHING, |
3506 | .op_name = "OP_DEALLOCATE" , |
3507 | .op_rsize_bop = nfsd4_only_status_rsize, |
3508 | }, |
3509 | [OP_CLONE] = { |
3510 | .op_func = nfsd4_clone, |
3511 | .op_flags = OP_MODIFIES_SOMETHING, |
3512 | .op_name = "OP_CLONE" , |
3513 | .op_rsize_bop = nfsd4_only_status_rsize, |
3514 | }, |
3515 | [OP_COPY] = { |
3516 | .op_func = nfsd4_copy, |
3517 | .op_flags = OP_MODIFIES_SOMETHING, |
3518 | .op_name = "OP_COPY" , |
3519 | .op_rsize_bop = nfsd4_copy_rsize, |
3520 | }, |
3521 | [OP_READ_PLUS] = { |
3522 | .op_func = nfsd4_read, |
3523 | .op_release = nfsd4_read_release, |
3524 | .op_name = "OP_READ_PLUS" , |
3525 | .op_rsize_bop = nfsd4_read_plus_rsize, |
3526 | .op_get_currentstateid = nfsd4_get_readstateid, |
3527 | }, |
3528 | [OP_SEEK] = { |
3529 | .op_func = nfsd4_seek, |
3530 | .op_name = "OP_SEEK" , |
3531 | .op_rsize_bop = nfsd4_seek_rsize, |
3532 | }, |
3533 | [OP_OFFLOAD_STATUS] = { |
3534 | .op_func = nfsd4_offload_status, |
3535 | .op_name = "OP_OFFLOAD_STATUS" , |
3536 | .op_rsize_bop = nfsd4_offload_status_rsize, |
3537 | }, |
3538 | [OP_OFFLOAD_CANCEL] = { |
3539 | .op_func = nfsd4_offload_cancel, |
3540 | .op_flags = OP_MODIFIES_SOMETHING, |
3541 | .op_name = "OP_OFFLOAD_CANCEL" , |
3542 | .op_rsize_bop = nfsd4_only_status_rsize, |
3543 | }, |
3544 | [OP_COPY_NOTIFY] = { |
3545 | .op_func = nfsd4_copy_notify, |
3546 | .op_flags = OP_MODIFIES_SOMETHING, |
3547 | .op_name = "OP_COPY_NOTIFY" , |
3548 | .op_rsize_bop = nfsd4_copy_notify_rsize, |
3549 | }, |
3550 | [OP_GETXATTR] = { |
3551 | .op_func = nfsd4_getxattr, |
3552 | .op_name = "OP_GETXATTR" , |
3553 | .op_rsize_bop = nfsd4_getxattr_rsize, |
3554 | }, |
3555 | [OP_SETXATTR] = { |
3556 | .op_func = nfsd4_setxattr, |
3557 | .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME, |
3558 | .op_name = "OP_SETXATTR" , |
3559 | .op_rsize_bop = nfsd4_setxattr_rsize, |
3560 | }, |
3561 | [OP_LISTXATTRS] = { |
3562 | .op_func = nfsd4_listxattrs, |
3563 | .op_name = "OP_LISTXATTRS" , |
3564 | .op_rsize_bop = nfsd4_listxattrs_rsize, |
3565 | }, |
3566 | [OP_REMOVEXATTR] = { |
3567 | .op_func = nfsd4_removexattr, |
3568 | .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME, |
3569 | .op_name = "OP_REMOVEXATTR" , |
3570 | .op_rsize_bop = nfsd4_removexattr_rsize, |
3571 | }, |
3572 | }; |
3573 | |
3574 | /** |
3575 | * nfsd4_spo_must_allow - Determine if the compound op contains an |
3576 | * operation that is allowed to be sent with machine credentials |
3577 | * |
3578 | * @rqstp: a pointer to the struct svc_rqst |
3579 | * |
3580 | * Checks to see if the compound contains a spo_must_allow op |
3581 | * and confirms that it was sent with the proper machine creds. |
3582 | */ |
3583 | |
3584 | bool nfsd4_spo_must_allow(struct svc_rqst *rqstp) |
3585 | { |
3586 | struct nfsd4_compoundres *resp = rqstp->rq_resp; |
3587 | struct nfsd4_compoundargs *argp = rqstp->rq_argp; |
3588 | struct nfsd4_op *this; |
3589 | struct nfsd4_compound_state *cstate = &resp->cstate; |
3590 | struct nfs4_op_map *allow = &cstate->clp->cl_spo_must_allow; |
3591 | u32 opiter; |
3592 | |
3593 | if (!cstate->minorversion) |
3594 | return false; |
3595 | |
3596 | if (cstate->spo_must_allowed) |
3597 | return true; |
3598 | |
3599 | opiter = resp->opcnt; |
3600 | while (opiter < argp->opcnt) { |
3601 | this = &argp->ops[opiter++]; |
3602 | if (test_bit(this->opnum, allow->u.longs) && |
3603 | cstate->clp->cl_mach_cred && |
3604 | nfsd4_mach_creds_match(cl: cstate->clp, rqstp)) { |
3605 | cstate->spo_must_allowed = true; |
3606 | return true; |
3607 | } |
3608 | } |
3609 | cstate->spo_must_allowed = false; |
3610 | return false; |
3611 | } |
3612 | |
3613 | int nfsd4_max_reply(struct svc_rqst *rqstp, struct nfsd4_op *op) |
3614 | { |
3615 | if (op->opnum == OP_ILLEGAL || op->status == nfserr_notsupp) |
3616 | return op_encode_hdr_size * sizeof(__be32); |
3617 | |
3618 | BUG_ON(OPDESC(op)->op_rsize_bop == NULL); |
3619 | return OPDESC(op)->op_rsize_bop(rqstp, op); |
3620 | } |
3621 | |
3622 | void warn_on_nonidempotent_op(struct nfsd4_op *op) |
3623 | { |
3624 | if (OPDESC(op)->op_flags & OP_MODIFIES_SOMETHING) { |
3625 | pr_err("unable to encode reply to nonidempotent op %u (%s)\n" , |
3626 | op->opnum, nfsd4_op_name(op->opnum)); |
3627 | WARN_ON_ONCE(1); |
3628 | } |
3629 | } |
3630 | |
3631 | static const char *nfsd4_op_name(unsigned opnum) |
3632 | { |
3633 | if (opnum < ARRAY_SIZE(nfsd4_ops)) |
3634 | return nfsd4_ops[opnum].op_name; |
3635 | return "unknown_operation" ; |
3636 | } |
3637 | |
3638 | static const struct svc_procedure nfsd_procedures4[2] = { |
3639 | [NFSPROC4_NULL] = { |
3640 | .pc_func = nfsd4_proc_null, |
3641 | .pc_decode = nfssvc_decode_voidarg, |
3642 | .pc_encode = nfssvc_encode_voidres, |
3643 | .pc_argsize = sizeof(struct nfsd_voidargs), |
3644 | .pc_argzero = sizeof(struct nfsd_voidargs), |
3645 | .pc_ressize = sizeof(struct nfsd_voidres), |
3646 | .pc_cachetype = RC_NOCACHE, |
3647 | .pc_xdrressize = 1, |
3648 | .pc_name = "NULL" , |
3649 | }, |
3650 | [NFSPROC4_COMPOUND] = { |
3651 | .pc_func = nfsd4_proc_compound, |
3652 | .pc_decode = nfs4svc_decode_compoundargs, |
3653 | .pc_encode = nfs4svc_encode_compoundres, |
3654 | .pc_argsize = sizeof(struct nfsd4_compoundargs), |
3655 | .pc_argzero = offsetof(struct nfsd4_compoundargs, iops), |
3656 | .pc_ressize = sizeof(struct nfsd4_compoundres), |
3657 | .pc_release = nfsd4_release_compoundargs, |
3658 | .pc_cachetype = RC_NOCACHE, |
3659 | .pc_xdrressize = NFSD_BUFSIZE/4, |
3660 | .pc_name = "COMPOUND" , |
3661 | }, |
3662 | }; |
3663 | |
3664 | static DEFINE_PER_CPU_ALIGNED(unsigned long, |
3665 | nfsd_count4[ARRAY_SIZE(nfsd_procedures4)]); |
3666 | const struct svc_version nfsd_version4 = { |
3667 | .vs_vers = 4, |
3668 | .vs_nproc = ARRAY_SIZE(nfsd_procedures4), |
3669 | .vs_proc = nfsd_procedures4, |
3670 | .vs_count = nfsd_count4, |
3671 | .vs_dispatch = nfsd_dispatch, |
3672 | .vs_xdrsize = NFS4_SVC_XDRSIZE, |
3673 | .vs_rpcb_optnl = true, |
3674 | .vs_need_cong_ctrl = true, |
3675 | }; |
3676 | |