blob: 8beda999e1346e8917bc3b624f33fed22e710d7b [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -070034 */
J. Bruce Fields880a3a52018-03-21 17:19:02 -040035#include <linux/fs_struct.h>
NeilBrown7e06b7f2005-06-23 22:03:13 -070036#include <linux/file.h>
Anna Schumakerb0cb9082014-11-07 14:44:27 -050037#include <linux/falloc.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090038#include <linux/slab.h>
Olga Kornievskaiae0639dc2018-07-20 18:19:20 -040039#include <linux/kthread.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040
Mi Jinlong58e7b332011-08-28 18:18:56 +080041#include "idmap.h"
Boaz Harrosh9a74af22009-12-03 20:30:56 +020042#include "cache.h"
43#include "xdr4.h"
J. Bruce Fields0a3adad2009-11-04 18:12:35 -050044#include "vfs.h"
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +010045#include "current_stateid.h"
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +030046#include "netns.h"
Christoph Hellwig4ac72492013-12-20 05:16:55 -080047#include "acl.h"
Christoph Hellwig9cf514c2014-05-05 13:11:59 +020048#include "pnfs.h"
Christoph Hellwig31ef83d2014-08-16 19:02:22 -050049#include "trace.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070050
David Quigley18032ca2013-05-02 13:19:10 -040051#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
52#include <linux/security.h>
53
54static inline void
55nfsd4_security_inode_setsecctx(struct svc_fh *resfh, struct xdr_netobj *label, u32 *bmval)
56{
David Howells2b0143b2015-03-17 22:25:59 +000057 struct inode *inode = d_inode(resfh->fh_dentry);
David Quigley18032ca2013-05-02 13:19:10 -040058 int status;
59
Al Viro59551022016-01-22 15:40:57 -050060 inode_lock(inode);
David Quigley18032ca2013-05-02 13:19:10 -040061 status = security_inode_setsecctx(resfh->fh_dentry,
62 label->data, label->len);
Al Viro59551022016-01-22 15:40:57 -050063 inode_unlock(inode);
David Quigley18032ca2013-05-02 13:19:10 -040064
65 if (status)
66 /*
67 * XXX: We should really fail the whole open, but we may
68 * already have created a new file, so it may be too
69 * late. For now this seems the least of evils:
70 */
71 bmval[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
72
73 return;
74}
75#else
76static inline void
77nfsd4_security_inode_setsecctx(struct svc_fh *resfh, struct xdr_netobj *label, u32 *bmval)
78{ }
79#endif
80
Linus Torvalds1da177e2005-04-16 15:20:36 -070081#define NFSDDBG_FACILITY NFSDDBG_PROC
82
Yu Zhiguo3c8e0312009-05-16 16:22:31 +080083static u32 nfsd_attrmask[] = {
84 NFSD_WRITEABLE_ATTRS_WORD0,
85 NFSD_WRITEABLE_ATTRS_WORD1,
86 NFSD_WRITEABLE_ATTRS_WORD2
87};
88
89static u32 nfsd41_ex_attrmask[] = {
90 NFSD_SUPPATTR_EXCLCREAT_WORD0,
91 NFSD_SUPPATTR_EXCLCREAT_WORD1,
92 NFSD_SUPPATTR_EXCLCREAT_WORD2
93};
94
95static __be32
96check_attr_support(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
97 u32 *bmval, u32 *writable)
98{
99 struct dentry *dentry = cstate->current_fh.fh_dentry;
J. Bruce Fields32ddd942017-01-03 12:30:11 -0500100 struct svc_export *exp = cstate->current_fh.fh_export;
Yu Zhiguo3c8e0312009-05-16 16:22:31 +0800101
J. Bruce Fields916d2d82016-10-18 14:18:40 -0400102 if (!nfsd_attrs_supported(cstate->minorversion, bmval))
Yu Zhiguo3c8e0312009-05-16 16:22:31 +0800103 return nfserr_attrnotsupp;
J. Bruce Fields916d2d82016-10-18 14:18:40 -0400104 if ((bmval[0] & FATTR4_WORD0_ACL) && !IS_POSIXACL(d_inode(dentry)))
105 return nfserr_attrnotsupp;
J. Bruce Fields32ddd942017-01-03 12:30:11 -0500106 if ((bmval[2] & FATTR4_WORD2_SECURITY_LABEL) &&
107 !(exp->ex_flags & NFSEXP_SECURITY_LABEL))
108 return nfserr_attrnotsupp;
J. Bruce Fields916d2d82016-10-18 14:18:40 -0400109 if (writable && !bmval_is_subset(bmval, writable))
110 return nfserr_inval;
Andreas Gruenbacher47057ab2016-01-12 20:24:14 +0100111 if (writable && (bmval[2] & FATTR4_WORD2_MODE_UMASK) &&
112 (bmval[1] & FATTR4_WORD1_MODE))
113 return nfserr_inval;
Yu Zhiguo3c8e0312009-05-16 16:22:31 +0800114 return nfs_ok;
115}
116
117static __be32
118nfsd4_check_open_attributes(struct svc_rqst *rqstp,
119 struct nfsd4_compound_state *cstate, struct nfsd4_open *open)
120{
121 __be32 status = nfs_ok;
122
123 if (open->op_create == NFS4_OPEN_CREATE) {
124 if (open->op_createmode == NFS4_CREATE_UNCHECKED
125 || open->op_createmode == NFS4_CREATE_GUARDED)
126 status = check_attr_support(rqstp, cstate,
127 open->op_bmval, nfsd_attrmask);
128 else if (open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1)
129 status = check_attr_support(rqstp, cstate,
130 open->op_bmval, nfsd41_ex_attrmask);
131 }
132
133 return status;
134}
135
Yu Zhiguo9208faf2009-07-06 17:24:16 +0800136static int
137is_create_with_attrs(struct nfsd4_open *open)
138{
139 return open->op_create == NFS4_OPEN_CREATE
140 && (open->op_createmode == NFS4_CREATE_UNCHECKED
141 || open->op_createmode == NFS4_CREATE_GUARDED
142 || open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1);
143}
144
145/*
146 * if error occurs when setting the acl, just clear the acl bit
147 * in the returned attr bitmap.
148 */
149static void
150do_set_nfs4_acl(struct svc_rqst *rqstp, struct svc_fh *fhp,
151 struct nfs4_acl *acl, u32 *bmval)
152{
153 __be32 status;
154
155 status = nfsd4_set_nfs4_acl(rqstp, fhp, acl);
156 if (status)
157 /*
158 * We should probably fail the whole open at this point,
159 * but we've already created the file, so it's too late;
160 * So this seems the least of evils:
161 */
162 bmval[0] &= ~FATTR4_WORD0_ACL;
163}
164
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165static inline void
166fh_dup2(struct svc_fh *dst, struct svc_fh *src)
167{
168 fh_put(dst);
169 dget(src->fh_dentry);
170 if (src->fh_export)
Kinglong Meebf18f162014-06-10 22:06:44 +0800171 exp_get(src->fh_export);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 *dst = *src;
173}
174
Al Virob37ad282006-10-19 23:28:59 -0700175static __be32
J. Bruce Fieldsdc730e12006-10-17 00:10:13 -0700176do_open_permission(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open, int accmode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177{
Al Virob37ad282006-10-19 23:28:59 -0700178 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179
180 if (open->op_truncate &&
181 !(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
182 return nfserr_inval;
183
J. Bruce Fieldsa0432262011-08-25 10:48:39 -0400184 accmode |= NFSD_MAY_READ_IF_EXEC;
185
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 if (open->op_share_access & NFS4_SHARE_ACCESS_READ)
Miklos Szeredi8837abc2008-06-16 13:20:29 +0200187 accmode |= NFSD_MAY_READ;
J. Bruce Fields9801d8a2006-10-17 00:10:14 -0700188 if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
Miklos Szeredi8837abc2008-06-16 13:20:29 +0200189 accmode |= (NFSD_MAY_WRITE | NFSD_MAY_TRUNC);
J. Bruce Fields57ecb342009-12-01 19:42:57 -0500190 if (open->op_share_deny & NFS4_SHARE_DENY_READ)
Miklos Szeredi8837abc2008-06-16 13:20:29 +0200191 accmode |= NFSD_MAY_WRITE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192
193 status = fh_verify(rqstp, current_fh, S_IFREG, accmode);
194
195 return status;
196}
197
J. Bruce Fieldsaadab6c2011-08-15 16:55:02 -0400198static __be32 nfsd_check_obj_isreg(struct svc_fh *fh)
199{
David Howells2b0143b2015-03-17 22:25:59 +0000200 umode_t mode = d_inode(fh->fh_dentry)->i_mode;
J. Bruce Fieldsaadab6c2011-08-15 16:55:02 -0400201
202 if (S_ISREG(mode))
203 return nfs_ok;
204 if (S_ISDIR(mode))
205 return nfserr_isdir;
206 /*
207 * Using err_symlink as our catch-all case may look odd; but
208 * there's no other obvious error for this case in 4.0, and we
209 * happen to know that it will cause the linux v4 client to do
210 * the right thing on attempts to open something other than a
211 * regular file.
212 */
213 return nfserr_symlink;
214}
215
J. Bruce Fieldsbbc9c36c2013-03-22 18:03:49 -0400216static void nfsd4_set_open_owner_reply_cache(struct nfsd4_compound_state *cstate, struct nfsd4_open *open, struct svc_fh *resfh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217{
J. Bruce Fieldsbbc9c36c2013-03-22 18:03:49 -0400218 if (nfsd4_has_session(cstate))
219 return;
220 fh_copy_shallow(&open->op_openowner->oo_owner.so_replay.rp_openfh,
221 &resfh->fh_handle);
222}
223
224static __be32
J. Bruce Fieldsc0e6bee2012-01-27 17:26:06 -0500225do_open_lookup(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_open *open, struct svc_fh **resfh)
J. Bruce Fieldsbbc9c36c2013-03-22 18:03:49 -0400226{
227 struct svc_fh *current_fh = &cstate->current_fh;
Neil Brown7007c902012-12-07 15:40:55 -0500228 int accmode;
Al Virob37ad282006-10-19 23:28:59 -0700229 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230
J. Bruce Fieldsc0e6bee2012-01-27 17:26:06 -0500231 *resfh = kmalloc(sizeof(struct svc_fh), GFP_KERNEL);
232 if (!*resfh)
J. Bruce Fields59deeb92012-01-27 16:49:55 -0500233 return nfserr_jukebox;
J. Bruce Fieldsc0e6bee2012-01-27 17:26:06 -0500234 fh_init(*resfh, NFS4_FHSIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 open->op_truncate = 0;
236
237 if (open->op_create) {
Benny Halevy79fb54a2009-04-03 08:29:17 +0300238 /* FIXME: check session persistence and pnfs flags.
239 * The nfsv4.1 spec requires the following semantics:
240 *
241 * Persistent | pNFS | Server REQUIRED | Client Allowed
242 * Reply Cache | server | |
243 * -------------+--------+-----------------+--------------------
244 * no | no | EXCLUSIVE4_1 | EXCLUSIVE4_1
245 * | | | (SHOULD)
246 * | | and EXCLUSIVE4 | or EXCLUSIVE4
247 * | | | (SHOULD NOT)
248 * no | yes | EXCLUSIVE4_1 | EXCLUSIVE4_1
249 * yes | no | GUARDED4 | GUARDED4
250 * yes | yes | GUARDED4 | GUARDED4
251 */
252
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 /*
254 * Note: create modes (UNCHECKED,GUARDED...) are the same
Mi Jinlongac6721a2011-04-20 17:06:25 +0800255 * in NFSv4 as in v3 except EXCLUSIVE4_1.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 */
J. Bruce Fields880a3a52018-03-21 17:19:02 -0400257 current->fs->umask = open->op_umask;
Mi Jinlongac6721a2011-04-20 17:06:25 +0800258 status = do_nfsd_create(rqstp, current_fh, open->op_fname.data,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 open->op_fname.len, &open->op_iattr,
J. Bruce Fieldsc0e6bee2012-01-27 17:26:06 -0500260 *resfh, open->op_createmode,
Jeff Layton749997e2007-07-31 00:37:51 -0700261 (u32 *)open->op_verf.data,
J. Bruce Fields856121b2011-10-13 11:37:11 -0400262 &open->op_truncate, &open->op_created);
J. Bruce Fields880a3a52018-03-21 17:19:02 -0400263 current->fs->umask = 0;
Jeff Layton749997e2007-07-31 00:37:51 -0700264
David Quigley18032ca2013-05-02 13:19:10 -0400265 if (!status && open->op_label.len)
J. Bruce Fieldsc0e6bee2012-01-27 17:26:06 -0500266 nfsd4_security_inode_setsecctx(*resfh, &open->op_label, open->op_bmval);
David Quigley18032ca2013-05-02 13:19:10 -0400267
J. Bruce Fields99f88722009-02-02 15:12:27 -0500268 /*
Kinglong Meeead8fb82015-07-30 21:55:02 +0800269 * Following rfc 3530 14.2.16, and rfc 5661 18.16.4
270 * use the returned bitmask to indicate which attributes
271 * we used to store the verifier:
Jeff Layton749997e2007-07-31 00:37:51 -0700272 */
Kinglong Meeead8fb82015-07-30 21:55:02 +0800273 if (nfsd_create_is_exclusive(open->op_createmode) && status == 0)
274 open->op_bmval[1] |= (FATTR4_WORD1_TIME_ACCESS |
275 FATTR4_WORD1_TIME_MODIFY);
J. Bruce Fields43357232014-01-24 18:04:40 -0500276 } else
277 /*
278 * Note this may exit with the parent still locked.
279 * We will hold the lock until nfsd4_open's final
280 * lookup, to prevent renames or unlinks until we've had
281 * a chance to an acquire a delegation if appropriate.
282 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 status = nfsd_lookup(rqstp, current_fh,
J. Bruce Fieldsc0e6bee2012-01-27 17:26:06 -0500284 open->op_fname.data, open->op_fname.len, *resfh);
J. Bruce Fieldsaf858522006-11-08 17:44:39 -0800285 if (status)
286 goto out;
J. Bruce Fieldsc0e6bee2012-01-27 17:26:06 -0500287 status = nfsd_check_obj_isreg(*resfh);
J. Bruce Fields9dc4e6c2012-04-09 18:06:49 -0400288 if (status)
289 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290
Yu Zhiguo9208faf2009-07-06 17:24:16 +0800291 if (is_create_with_attrs(open) && open->op_acl != NULL)
J. Bruce Fieldsc0e6bee2012-01-27 17:26:06 -0500292 do_set_nfs4_acl(rqstp, *resfh, open->op_acl, open->op_bmval);
Yu Zhiguo9208faf2009-07-06 17:24:16 +0800293
J. Bruce Fieldsc0e6bee2012-01-27 17:26:06 -0500294 nfsd4_set_open_owner_reply_cache(cstate, open, *resfh);
Neil Brown7007c902012-12-07 15:40:55 -0500295 accmode = NFSD_MAY_NOP;
J. Bruce Fields89f6c332013-06-19 15:47:37 -0400296 if (open->op_created ||
297 open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR)
Neil Brown7007c902012-12-07 15:40:55 -0500298 accmode |= NFSD_MAY_OWNER_OVERRIDE;
J. Bruce Fieldsc0e6bee2012-01-27 17:26:06 -0500299 status = do_open_permission(rqstp, *resfh, open, accmode);
J. Bruce Fields41fd1e42012-01-27 16:26:02 -0500300 set_change_info(&open->op_cinfo, current_fh);
J. Bruce Fieldsaf858522006-11-08 17:44:39 -0800301out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 return status;
303}
304
Al Virob37ad282006-10-19 23:28:59 -0700305static __be32
J. Bruce Fieldsbbc9c36c2013-03-22 18:03:49 -0400306do_open_fhandle(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_open *open)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307{
J. Bruce Fieldsbbc9c36c2013-03-22 18:03:49 -0400308 struct svc_fh *current_fh = &cstate->current_fh;
Al Virob37ad282006-10-19 23:28:59 -0700309 __be32 status;
J. Bruce Fields9f415eb2013-05-03 16:09:09 -0400310 int accmode = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 /* We don't know the target directory, and therefore can not
313 * set the change info
314 */
315
316 memset(&open->op_cinfo, 0, sizeof(struct nfsd4_change_info));
317
J. Bruce Fieldsbbc9c36c2013-03-22 18:03:49 -0400318 nfsd4_set_open_owner_reply_cache(cstate, open, current_fh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319
320 open->op_truncate = (open->op_iattr.ia_valid & ATTR_SIZE) &&
321 (open->op_iattr.ia_size == 0);
J. Bruce Fields9f415eb2013-05-03 16:09:09 -0400322 /*
323 * In the delegation case, the client is telling us about an
324 * open that it *already* performed locally, some time ago. We
325 * should let it succeed now if possible.
326 *
327 * In the case of a CLAIM_FH open, on the other hand, the client
328 * may be counting on us to enforce permissions (the Linux 4.1
329 * client uses this for normal opens, for example).
330 */
331 if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEG_CUR_FH)
332 accmode = NFSD_MAY_OWNER_OVERRIDE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333
J. Bruce Fields9f415eb2013-05-03 16:09:09 -0400334 status = do_open_permission(rqstp, current_fh, open, accmode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335
336 return status;
337}
338
Andy Adamson60adfc52009-04-03 08:28:50 +0300339static void
340copy_clientid(clientid_t *clid, struct nfsd4_session *session)
341{
342 struct nfsd4_sessionid *sid =
343 (struct nfsd4_sessionid *)session->se_sessionid.data;
344
345 clid->cl_boot = sid->clientid.cl_boot;
346 clid->cl_id = sid->clientid.cl_id;
347}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348
J.Bruce Fields71911552006-12-13 00:35:29 -0800349static __be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800350nfsd4_open(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
Christoph Hellwigeb698532017-05-08 20:58:35 +0200351 union nfsd4_op_u *u)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352{
Christoph Hellwigeb698532017-05-08 20:58:35 +0200353 struct nfsd4_open *open = &u->open;
Al Virob37ad282006-10-19 23:28:59 -0700354 __be32 status;
J. Bruce Fieldsc0e6bee2012-01-27 17:26:06 -0500355 struct svc_fh *resfh = NULL;
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +0300356 struct net *net = SVC_NET(rqstp);
357 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
J. Bruce Fields03f318c2018-06-08 12:28:47 -0400358 bool reclaim = false;
Andy Adamson66689582009-04-03 08:28:45 +0300359
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400360 dprintk("NFSD: nfsd4_open filename %.*s op_openowner %p\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 (int)open->op_fname.len, open->op_fname.data,
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400362 open->op_openowner);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 /* This check required by spec. */
365 if (open->op_create && open->op_claim_type != NFS4_OPEN_CLAIM_NULL)
366 return nfserr_inval;
367
J. Bruce Fields856121b2011-10-13 11:37:11 -0400368 open->op_created = 0;
Mi Jinlongab1350b2011-07-14 15:06:26 +0800369 /*
370 * RFC5661 18.51.3
371 * Before RECLAIM_COMPLETE done, server should deny new lock
372 */
373 if (nfsd4_has_session(cstate) &&
Jeff Laytona52d7262012-03-21 09:52:02 -0400374 !test_bit(NFSD4_CLIENT_RECLAIM_COMPLETE,
375 &cstate->session->se_client->cl_flags) &&
Mi Jinlongab1350b2011-07-14 15:06:26 +0800376 open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS)
377 return nfserr_grace;
378
Andy Adamson60adfc52009-04-03 08:28:50 +0300379 if (nfsd4_has_session(cstate))
380 copy_clientid(&open->op_clientid, cstate->session);
381
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 /* check seqid for replay. set nfs4_owner */
Kinglong Mee6cd22662015-07-13 17:32:05 +0800383 status = nfsd4_process_open1(cstate, open, nn);
Al Viroa90b0612006-10-19 23:29:03 -0700384 if (status == nfserr_replay_me) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400385 struct nfs4_replay *rp = &open->op_openowner->oo_owner.so_replay;
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800386 fh_put(&cstate->current_fh);
J. Bruce Fieldsa4773c02009-02-02 17:23:10 -0500387 fh_copy_shallow(&cstate->current_fh.fh_handle,
388 &rp->rp_openfh);
Miklos Szeredi8837abc2008-06-16 13:20:29 +0200389 status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 if (status)
391 dprintk("nfsd4_open: replay failed"
392 " restoring previous filehandle\n");
393 else
Al Viroa90b0612006-10-19 23:29:03 -0700394 status = nfserr_replay_me;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 }
396 if (status)
397 goto out;
J. Bruce Fields9d313b12013-02-28 12:51:49 -0800398 if (open->op_xdr_error) {
399 status = open->op_xdr_error;
400 goto out;
401 }
J. Bruce Fieldsfb553c02006-01-18 17:43:36 -0800402
Yu Zhiguo3c8e0312009-05-16 16:22:31 +0800403 status = nfsd4_check_open_attributes(rqstp, cstate, open);
404 if (status)
405 goto out;
406
J. Bruce Fieldsfb553c02006-01-18 17:43:36 -0800407 /* Openowner is now set, so sequence id will get bumped. Now we need
408 * these checks before we do any creates: */
J. Bruce Fieldscbd0d512006-02-07 12:58:32 -0800409 status = nfserr_grace;
J. Bruce Fieldsc87fb4a2015-08-06 12:47:02 -0400410 if (opens_in_grace(net) && open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS)
J. Bruce Fieldscbd0d512006-02-07 12:58:32 -0800411 goto out;
412 status = nfserr_no_grace;
J. Bruce Fieldsc87fb4a2015-08-06 12:47:02 -0400413 if (!opens_in_grace(net) && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
J. Bruce Fieldscbd0d512006-02-07 12:58:32 -0800414 goto out;
J. Bruce Fieldsfb553c02006-01-18 17:43:36 -0800415
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 switch (open->op_claim_type) {
NeilBrown0dd3c192005-06-23 22:02:56 -0700417 case NFS4_OPEN_CLAIM_DELEGATE_CUR:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 case NFS4_OPEN_CLAIM_NULL:
J. Bruce Fieldsc0e6bee2012-01-27 17:26:06 -0500419 status = do_open_lookup(rqstp, cstate, open, &resfh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 if (status)
421 goto out;
422 break;
423 case NFS4_OPEN_CLAIM_PREVIOUS:
Stanislav Kinsbursky3320fef192012-11-14 18:22:07 +0300424 status = nfs4_check_open_reclaim(&open->op_clientid,
Trond Myklebust0fe492d2014-06-30 11:48:47 -0400425 cstate, nn);
Mi Jinlong0cf99b92011-11-23 10:48:40 +0800426 if (status)
427 goto out;
Jeff Laytonba5378b2014-05-30 09:09:28 -0400428 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
J. Bruce Fields03f318c2018-06-08 12:28:47 -0400429 reclaim = true;
Gustavo A. R. Silva0a4c9262019-01-23 02:48:28 -0600430 /* fall through */
J. Bruce Fields8b289b22011-10-19 11:52:12 -0400431 case NFS4_OPEN_CLAIM_FH:
432 case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
J. Bruce Fieldsbbc9c36c2013-03-22 18:03:49 -0400433 status = do_open_fhandle(rqstp, cstate, open);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 if (status)
435 goto out;
J. Bruce Fieldsc0e6bee2012-01-27 17:26:06 -0500436 resfh = &cstate->current_fh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 break;
J. Bruce Fields8b289b22011-10-19 11:52:12 -0400438 case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 case NFS4_OPEN_CLAIM_DELEGATE_PREV:
J. Bruce Fields2fdada02007-07-27 16:10:37 -0400440 dprintk("NFSD: unsupported OPEN claim type %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 open->op_claim_type);
442 status = nfserr_notsupp;
443 goto out;
444 default:
J. Bruce Fields2fdada02007-07-27 16:10:37 -0400445 dprintk("NFSD: Invalid OPEN claim type %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 open->op_claim_type);
447 status = nfserr_inval;
448 goto out;
449 }
450 /*
451 * nfsd4_process_open2() does the actual opening of the file. If
452 * successful, it (1) truncates the file if open->op_truncate was
453 * set, (2) sets open->op_stateid, (3) sets open->op_delegation.
454 */
J. Bruce Fieldsc0e6bee2012-01-27 17:26:06 -0500455 status = nfsd4_process_open2(rqstp, resfh, open);
Jeff Laytonb3fbfe02014-07-29 21:37:44 -0400456 WARN(status && open->op_created,
457 "nfsd4_process_open2 failed to open newly-created file! status=%u\n",
458 be32_to_cpu(status));
J. Bruce Fields03f318c2018-06-08 12:28:47 -0400459 if (reclaim && !status)
460 nn->somebody_reclaimed = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461out:
J. Bruce Fieldsc0e6bee2012-01-27 17:26:06 -0500462 if (resfh && resfh != &cstate->current_fh) {
463 fh_dup2(&cstate->current_fh, resfh);
464 fh_put(resfh);
465 kfree(resfh);
466 }
Jeff Layton42297892015-03-23 10:53:44 -0400467 nfsd4_cleanup_open_state(cstate, open);
J. Bruce Fields9411b1d2013-04-01 16:37:12 -0400468 nfsd4_bump_seqid(cstate, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 return status;
470}
471
472/*
J. Bruce Fields9d313b12013-02-28 12:51:49 -0800473 * OPEN is the only seqid-mutating operation whose decoding can fail
474 * with a seqid-mutating error (specifically, decoding of user names in
475 * the attributes). Therefore we have to do some processing to look up
476 * the stateowner so that we can bump the seqid.
477 */
478static __be32 nfsd4_open_omfg(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_op *op)
479{
Christoph Hellwigeb698532017-05-08 20:58:35 +0200480 struct nfsd4_open *open = &op->u.open;
J. Bruce Fields9d313b12013-02-28 12:51:49 -0800481
482 if (!seqid_mutating_err(ntohl(op->status)))
483 return op->status;
484 if (nfsd4_has_session(cstate))
485 return op->status;
486 open->op_xdr_error = op->status;
Christoph Hellwigeb698532017-05-08 20:58:35 +0200487 return nfsd4_open(rqstp, cstate, &op->u);
J. Bruce Fields9d313b12013-02-28 12:51:49 -0800488}
489
490/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 * filehandle-manipulating ops.
492 */
J.Bruce Fields71911552006-12-13 00:35:29 -0800493static __be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -0800494nfsd4_getfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
Christoph Hellwigeb698532017-05-08 20:58:35 +0200495 union nfsd4_op_u *u)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496{
Christoph Hellwigeb698532017-05-08 20:58:35 +0200497 u->getfh = &cstate->current_fh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 return nfs_ok;
499}
500
J.Bruce Fields71911552006-12-13 00:35:29 -0800501static __be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800502nfsd4_putfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
Christoph Hellwigeb698532017-05-08 20:58:35 +0200503 union nfsd4_op_u *u)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504{
Christoph Hellwigeb698532017-05-08 20:58:35 +0200505 struct nfsd4_putfh *putfh = &u->putfh;
506
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800507 fh_put(&cstate->current_fh);
508 cstate->current_fh.fh_handle.fh_size = putfh->pf_fhlen;
509 memcpy(&cstate->current_fh.fh_handle.fh_base, putfh->pf_fhval,
510 putfh->pf_fhlen);
J. Bruce Fields68d93182011-04-08 17:00:50 -0400511 return fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_BYPASS_GSS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512}
513
J.Bruce Fields71911552006-12-13 00:35:29 -0800514static __be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -0800515nfsd4_putrootfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
Christoph Hellwigeb698532017-05-08 20:58:35 +0200516 union nfsd4_op_u *u)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517{
Al Virob37ad282006-10-19 23:28:59 -0700518 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800520 fh_put(&cstate->current_fh);
J. Bruce Fieldsdf547ef2007-07-17 04:04:43 -0700521 status = exp_pseudoroot(rqstp, &cstate->current_fh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 return status;
523}
524
J.Bruce Fields71911552006-12-13 00:35:29 -0800525static __be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -0800526nfsd4_restorefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
Christoph Hellwigeb698532017-05-08 20:58:35 +0200527 union nfsd4_op_u *u)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528{
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800529 if (!cstate->save_fh.fh_dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 return nfserr_restorefh;
531
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800532 fh_dup2(&cstate->current_fh, &cstate->save_fh);
Tigran Mkrtchyan37c593c2012-02-13 22:55:32 +0100533 if (HAS_STATE_ID(cstate, SAVED_STATE_ID_FLAG)) {
534 memcpy(&cstate->current_stateid, &cstate->save_stateid, sizeof(stateid_t));
535 SET_STATE_ID(cstate, CURRENT_STATE_ID_FLAG);
536 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 return nfs_ok;
538}
539
J.Bruce Fields71911552006-12-13 00:35:29 -0800540static __be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -0800541nfsd4_savefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
Christoph Hellwigeb698532017-05-08 20:58:35 +0200542 union nfsd4_op_u *u)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543{
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800544 fh_dup2(&cstate->save_fh, &cstate->current_fh);
Tigran Mkrtchyan37c593c2012-02-13 22:55:32 +0100545 if (HAS_STATE_ID(cstate, CURRENT_STATE_ID_FLAG)) {
546 memcpy(&cstate->save_stateid, &cstate->current_stateid, sizeof(stateid_t));
547 SET_STATE_ID(cstate, SAVED_STATE_ID_FLAG);
548 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 return nfs_ok;
550}
551
552/*
553 * misc nfsv4 ops
554 */
J.Bruce Fields71911552006-12-13 00:35:29 -0800555static __be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800556nfsd4_access(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
Christoph Hellwigeb698532017-05-08 20:58:35 +0200557 union nfsd4_op_u *u)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558{
Christoph Hellwigeb698532017-05-08 20:58:35 +0200559 struct nfsd4_access *access = &u->access;
560
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 if (access->ac_req_access & ~NFS3_ACCESS_FULL)
562 return nfserr_inval;
563
564 access->ac_resp_access = access->ac_req_access;
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800565 return nfsd_access(rqstp, &cstate->current_fh, &access->ac_resp_access,
566 &access->ac_supported);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567}
568
Stanislav Kinsburskyb9c0ef82012-12-06 14:23:19 +0300569static void gen_boot_verifier(nfs4_verifier *verifier, struct net *net)
Chuck Leverab4684d2012-03-02 17:13:50 -0500570{
571 __be32 verf[2];
Stanislav Kinsburskyb9c0ef82012-12-06 14:23:19 +0300572 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Chuck Leverab4684d2012-03-02 17:13:50 -0500573
Jeff Laytonf4199922014-06-17 07:44:11 -0400574 /*
575 * This is opaque to client, so no need to byte-swap. Use
Arnd Bergmann256a89f2017-10-19 12:04:11 +0200576 * __force to keep sparse happy. y2038 time_t overflow is
577 * irrelevant in this usage.
Jeff Laytonf4199922014-06-17 07:44:11 -0400578 */
579 verf[0] = (__force __be32)nn->nfssvc_boot.tv_sec;
Arnd Bergmann256a89f2017-10-19 12:04:11 +0200580 verf[1] = (__force __be32)nn->nfssvc_boot.tv_nsec;
Chuck Leverab4684d2012-03-02 17:13:50 -0500581 memcpy(verifier->data, verf, sizeof(verifier->data));
582}
583
J.Bruce Fields71911552006-12-13 00:35:29 -0800584static __be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800585nfsd4_commit(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
Christoph Hellwigeb698532017-05-08 20:58:35 +0200586 union nfsd4_op_u *u)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587{
Christoph Hellwigeb698532017-05-08 20:58:35 +0200588 struct nfsd4_commit *commit = &u->commit;
589
Stanislav Kinsburskyb9c0ef82012-12-06 14:23:19 +0300590 gen_boot_verifier(&commit->co_verf, SVC_NET(rqstp));
J. Bruce Fields75c096f2011-08-15 18:39:32 -0400591 return nfsd_commit(rqstp, &cstate->current_fh, commit->co_offset,
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800592 commit->co_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593}
594
Al Virob37ad282006-10-19 23:28:59 -0700595static __be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800596nfsd4_create(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
Christoph Hellwigeb698532017-05-08 20:58:35 +0200597 union nfsd4_op_u *u)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598{
Christoph Hellwigeb698532017-05-08 20:58:35 +0200599 struct nfsd4_create *create = &u->create;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 struct svc_fh resfh;
Al Virob37ad282006-10-19 23:28:59 -0700601 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 dev_t rdev;
603
604 fh_init(&resfh, NFS4_FHSIZE);
605
J. Bruce Fieldsfa081392016-07-21 16:00:12 -0400606 status = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_NOP);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 if (status)
608 return status;
609
Yu Zhiguo3c8e0312009-05-16 16:22:31 +0800610 status = check_attr_support(rqstp, cstate, create->cr_bmval,
611 nfsd_attrmask);
612 if (status)
613 return status;
614
J. Bruce Fields880a3a52018-03-21 17:19:02 -0400615 current->fs->umask = create->cr_umask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 switch (create->cr_type) {
617 case NF4LNK:
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800618 status = nfsd_symlink(rqstp, &cstate->current_fh,
619 create->cr_name, create->cr_namelen,
Kinglong Mee1e444f52014-07-01 17:48:02 +0800620 create->cr_data, &resfh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 break;
622
623 case NF4BLK:
J. Bruce Fields880a3a52018-03-21 17:19:02 -0400624 status = nfserr_inval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 rdev = MKDEV(create->cr_specdata1, create->cr_specdata2);
626 if (MAJOR(rdev) != create->cr_specdata1 ||
627 MINOR(rdev) != create->cr_specdata2)
J. Bruce Fields880a3a52018-03-21 17:19:02 -0400628 goto out_umask;
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800629 status = nfsd_create(rqstp, &cstate->current_fh,
630 create->cr_name, create->cr_namelen,
631 &create->cr_iattr, S_IFBLK, rdev, &resfh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 break;
633
634 case NF4CHR:
J. Bruce Fields880a3a52018-03-21 17:19:02 -0400635 status = nfserr_inval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 rdev = MKDEV(create->cr_specdata1, create->cr_specdata2);
637 if (MAJOR(rdev) != create->cr_specdata1 ||
638 MINOR(rdev) != create->cr_specdata2)
J. Bruce Fields880a3a52018-03-21 17:19:02 -0400639 goto out_umask;
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800640 status = nfsd_create(rqstp, &cstate->current_fh,
641 create->cr_name, create->cr_namelen,
642 &create->cr_iattr,S_IFCHR, rdev, &resfh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 break;
644
645 case NF4SOCK:
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800646 status = nfsd_create(rqstp, &cstate->current_fh,
647 create->cr_name, create->cr_namelen,
648 &create->cr_iattr, S_IFSOCK, 0, &resfh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 break;
650
651 case NF4FIFO:
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800652 status = nfsd_create(rqstp, &cstate->current_fh,
653 create->cr_name, create->cr_namelen,
654 &create->cr_iattr, S_IFIFO, 0, &resfh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 break;
656
657 case NF4DIR:
658 create->cr_iattr.ia_valid &= ~ATTR_SIZE;
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800659 status = nfsd_create(rqstp, &cstate->current_fh,
660 create->cr_name, create->cr_namelen,
661 &create->cr_iattr, S_IFDIR, 0, &resfh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 break;
663
664 default:
665 status = nfserr_badtype;
666 }
667
Yu Zhiguo9208faf2009-07-06 17:24:16 +0800668 if (status)
669 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670
David Quigley18032ca2013-05-02 13:19:10 -0400671 if (create->cr_label.len)
672 nfsd4_security_inode_setsecctx(&resfh, &create->cr_label, create->cr_bmval);
673
Yu Zhiguo9208faf2009-07-06 17:24:16 +0800674 if (create->cr_acl != NULL)
675 do_set_nfs4_acl(rqstp, &resfh, create->cr_acl,
676 create->cr_bmval);
677
678 fh_unlock(&cstate->current_fh);
679 set_change_info(&create->cr_cinfo, &cstate->current_fh);
680 fh_dup2(&cstate->current_fh, &resfh);
681out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 fh_put(&resfh);
J. Bruce Fields880a3a52018-03-21 17:19:02 -0400683out_umask:
684 current->fs->umask = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 return status;
686}
687
J.Bruce Fields71911552006-12-13 00:35:29 -0800688static __be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800689nfsd4_getattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
Christoph Hellwigeb698532017-05-08 20:58:35 +0200690 union nfsd4_op_u *u)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691{
Christoph Hellwigeb698532017-05-08 20:58:35 +0200692 struct nfsd4_getattr *getattr = &u->getattr;
Al Virob37ad282006-10-19 23:28:59 -0700693 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694
Miklos Szeredi8837abc2008-06-16 13:20:29 +0200695 status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 if (status)
697 return status;
698
699 if (getattr->ga_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)
700 return nfserr_inval;
701
J. Bruce Fields916d2d82016-10-18 14:18:40 -0400702 getattr->ga_bmval[0] &= nfsd_suppattrs[cstate->minorversion][0];
703 getattr->ga_bmval[1] &= nfsd_suppattrs[cstate->minorversion][1];
704 getattr->ga_bmval[2] &= nfsd_suppattrs[cstate->minorversion][2];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800706 getattr->ga_fhp = &cstate->current_fh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 return nfs_ok;
708}
709
J.Bruce Fields71911552006-12-13 00:35:29 -0800710static __be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800711nfsd4_link(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
Christoph Hellwigeb698532017-05-08 20:58:35 +0200712 union nfsd4_op_u *u)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713{
Christoph Hellwigeb698532017-05-08 20:58:35 +0200714 struct nfsd4_link *link = &u->link;
J. Bruce Fields95424462017-09-15 16:02:52 -0400715 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800717 status = nfsd_link(rqstp, &cstate->current_fh,
718 link->li_name, link->li_namelen, &cstate->save_fh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 if (!status)
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800720 set_change_info(&link->li_cinfo, &cstate->current_fh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 return status;
722}
723
J. Bruce Fields0ff7ab42010-12-16 10:06:27 -0500724static __be32 nfsd4_do_lookupp(struct svc_rqst *rqstp, struct svc_fh *fh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725{
726 struct svc_fh tmp_fh;
Al Virob37ad282006-10-19 23:28:59 -0700727 __be32 ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728
729 fh_init(&tmp_fh, NFS4_FHSIZE);
J. Bruce Fieldsdf547ef2007-07-17 04:04:43 -0700730 ret = exp_pseudoroot(rqstp, &tmp_fh);
731 if (ret)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 return ret;
J. Bruce Fields0ff7ab42010-12-16 10:06:27 -0500733 if (tmp_fh.fh_dentry == fh->fh_dentry) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 fh_put(&tmp_fh);
735 return nfserr_noent;
736 }
737 fh_put(&tmp_fh);
J. Bruce Fields0ff7ab42010-12-16 10:06:27 -0500738 return nfsd_lookup(rqstp, fh, "..", 2, fh);
739}
740
741static __be32
742nfsd4_lookupp(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
Christoph Hellwigeb698532017-05-08 20:58:35 +0200743 union nfsd4_op_u *u)
J. Bruce Fields0ff7ab42010-12-16 10:06:27 -0500744{
745 return nfsd4_do_lookupp(rqstp, &cstate->current_fh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746}
747
J.Bruce Fields71911552006-12-13 00:35:29 -0800748static __be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800749nfsd4_lookup(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
Christoph Hellwigeb698532017-05-08 20:58:35 +0200750 union nfsd4_op_u *u)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751{
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800752 return nfsd_lookup(rqstp, &cstate->current_fh,
Christoph Hellwigeb698532017-05-08 20:58:35 +0200753 u->lookup.lo_name, u->lookup.lo_len,
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800754 &cstate->current_fh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755}
756
J.Bruce Fields71911552006-12-13 00:35:29 -0800757static __be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800758nfsd4_read(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
Christoph Hellwigeb698532017-05-08 20:58:35 +0200759 union nfsd4_op_u *u)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760{
Christoph Hellwigeb698532017-05-08 20:58:35 +0200761 struct nfsd4_read *read = &u->read;
Al Virob37ad282006-10-19 23:28:59 -0700762 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763
NeilBrown7e06b7f2005-06-23 22:03:13 -0700764 read->rd_filp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 if (read->rd_offset >= OFFSET_MAX)
766 return nfserr_inval;
767
Chuck Lever87c59422018-03-28 13:29:11 -0400768 trace_nfsd_read_start(rqstp, &cstate->current_fh,
769 read->rd_offset, read->rd_length);
770
J. Bruce Fields9b3234b2012-12-04 18:03:46 -0500771 /*
772 * If we do a zero copy read, then a client will see read data
773 * that reflects the state of the file *after* performing the
774 * following compound.
775 *
776 * To ensure proper ordering, we therefore turn off zero copy if
777 * the client wants us to do more in this compound:
778 */
779 if (!nfsd4_last_compound_op(rqstp))
Jeff Layton779fb0f2014-11-19 07:51:18 -0500780 clear_bit(RQ_SPLICE_OK, &rqstp->rq_flags);
J. Bruce Fields9b3234b2012-12-04 18:03:46 -0500781
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 /* check stateid */
Anna Schumakeraa0d6ae2015-12-03 12:59:51 +0100783 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
784 &read->rd_stateid, RD_STATE,
785 &read->rd_filp, &read->rd_tmp_file);
Christoph Hellwigaf90f702015-06-18 16:45:00 +0200786 if (status) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787 dprintk("NFSD: nfsd4_read: couldn't process stateid!\n");
788 goto out;
789 }
790 status = nfs_ok;
791out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 read->rd_rqstp = rqstp;
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800793 read->rd_fhp = &cstate->current_fh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 return status;
795}
796
J. Bruce Fields34b1744c2017-05-05 17:09:37 -0400797
798static void
799nfsd4_read_release(union nfsd4_op_u *u)
800{
801 if (u->read.rd_filp)
802 fput(u->read.rd_filp);
Chuck Lever87c59422018-03-28 13:29:11 -0400803 trace_nfsd_read_done(u->read.rd_rqstp, u->read.rd_fhp,
804 u->read.rd_offset, u->read.rd_length);
J. Bruce Fields34b1744c2017-05-05 17:09:37 -0400805}
806
J.Bruce Fields71911552006-12-13 00:35:29 -0800807static __be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800808nfsd4_readdir(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
Christoph Hellwigeb698532017-05-08 20:58:35 +0200809 union nfsd4_op_u *u)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810{
Christoph Hellwigeb698532017-05-08 20:58:35 +0200811 struct nfsd4_readdir *readdir = &u->readdir;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 u64 cookie = readdir->rd_cookie;
813 static const nfs4_verifier zeroverf;
814
815 /* no need to check permission - this will be done in nfsd_readdir() */
816
817 if (readdir->rd_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)
818 return nfserr_inval;
819
J. Bruce Fields916d2d82016-10-18 14:18:40 -0400820 readdir->rd_bmval[0] &= nfsd_suppattrs[cstate->minorversion][0];
821 readdir->rd_bmval[1] &= nfsd_suppattrs[cstate->minorversion][1];
822 readdir->rd_bmval[2] &= nfsd_suppattrs[cstate->minorversion][2];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823
Bernd Schubert832023b2011-08-08 17:38:08 +0200824 if ((cookie == 1) || (cookie == 2) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 (cookie == 0 && memcmp(readdir->rd_verf.data, zeroverf.data, NFS4_VERIFIER_SIZE)))
826 return nfserr_bad_cookie;
827
828 readdir->rd_rqstp = rqstp;
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800829 readdir->rd_fhp = &cstate->current_fh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 return nfs_ok;
831}
832
J.Bruce Fields71911552006-12-13 00:35:29 -0800833static __be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800834nfsd4_readlink(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
Christoph Hellwigeb698532017-05-08 20:58:35 +0200835 union nfsd4_op_u *u)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836{
Christoph Hellwigeb698532017-05-08 20:58:35 +0200837 u->readlink.rl_rqstp = rqstp;
838 u->readlink.rl_fhp = &cstate->current_fh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 return nfs_ok;
840}
841
J.Bruce Fields71911552006-12-13 00:35:29 -0800842static __be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800843nfsd4_remove(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
Christoph Hellwigeb698532017-05-08 20:58:35 +0200844 union nfsd4_op_u *u)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845{
Christoph Hellwigeb698532017-05-08 20:58:35 +0200846 struct nfsd4_remove *remove = &u->remove;
Al Virob37ad282006-10-19 23:28:59 -0700847 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848
J. Bruce Fieldsc87fb4a2015-08-06 12:47:02 -0400849 if (opens_in_grace(SVC_NET(rqstp)))
NeilBrownc815afc2005-06-23 22:03:00 -0700850 return nfserr_grace;
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800851 status = nfsd_unlink(rqstp, &cstate->current_fh, 0,
852 remove->rm_name, remove->rm_namelen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 if (!status) {
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800854 fh_unlock(&cstate->current_fh);
855 set_change_info(&remove->rm_cinfo, &cstate->current_fh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 }
857 return status;
858}
859
J.Bruce Fields71911552006-12-13 00:35:29 -0800860static __be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800861nfsd4_rename(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
Christoph Hellwigeb698532017-05-08 20:58:35 +0200862 union nfsd4_op_u *u)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863{
Christoph Hellwigeb698532017-05-08 20:58:35 +0200864 struct nfsd4_rename *rename = &u->rename;
J. Bruce Fields95424462017-09-15 16:02:52 -0400865 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866
J. Bruce Fieldsf8f71d02018-11-06 11:47:20 -0500867 if (opens_in_grace(SVC_NET(rqstp)))
NeilBrownc815afc2005-06-23 22:03:00 -0700868 return nfserr_grace;
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800869 status = nfsd_rename(rqstp, &cstate->save_fh, rename->rn_sname,
870 rename->rn_snamelen, &cstate->current_fh,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 rename->rn_tname, rename->rn_tnamelen);
J. Bruce Fields2a6cf942013-04-30 15:28:51 -0400872 if (status)
873 return status;
874 set_change_info(&rename->rn_sinfo, &cstate->current_fh);
875 set_change_info(&rename->rn_tinfo, &cstate->save_fh);
876 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877}
878
J.Bruce Fields71911552006-12-13 00:35:29 -0800879static __be32
Andy Adamsondcb488a32007-07-17 04:04:51 -0700880nfsd4_secinfo(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
Christoph Hellwigeb698532017-05-08 20:58:35 +0200881 union nfsd4_op_u *u)
Andy Adamsondcb488a32007-07-17 04:04:51 -0700882{
Christoph Hellwigeb698532017-05-08 20:58:35 +0200883 struct nfsd4_secinfo *secinfo = &u->secinfo;
Andy Adamsondcb488a32007-07-17 04:04:51 -0700884 struct svc_export *exp;
885 struct dentry *dentry;
886 __be32 err;
887
J. Bruce Fields29a78a32011-04-09 11:28:53 -0400888 err = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_EXEC);
889 if (err)
890 return err;
Andy Adamsondcb488a32007-07-17 04:04:51 -0700891 err = nfsd_lookup_dentry(rqstp, &cstate->current_fh,
892 secinfo->si_name, secinfo->si_namelen,
893 &exp, &dentry);
894 if (err)
895 return err;
J. Bruce Fields2f6fc052016-03-02 16:36:21 -0800896 fh_unlock(&cstate->current_fh);
David Howells2b0143b2015-03-17 22:25:59 +0000897 if (d_really_is_negative(dentry)) {
Andy Adamsondcb488a32007-07-17 04:04:51 -0700898 exp_put(exp);
899 err = nfserr_noent;
900 } else
901 secinfo->si_exp = exp;
902 dput(dentry);
J. Bruce Fields56560b92010-12-16 09:57:15 -0500903 if (cstate->minorversion)
904 /* See rfc 5661 section 2.6.3.1.1.8 */
905 fh_put(&cstate->current_fh);
Andy Adamsondcb488a32007-07-17 04:04:51 -0700906 return err;
907}
908
909static __be32
J. Bruce Fields04f4ad12010-12-16 09:51:13 -0500910nfsd4_secinfo_no_name(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
Christoph Hellwigeb698532017-05-08 20:58:35 +0200911 union nfsd4_op_u *u)
J. Bruce Fields04f4ad12010-12-16 09:51:13 -0500912{
913 __be32 err;
914
Christoph Hellwigeb698532017-05-08 20:58:35 +0200915 switch (u->secinfo_no_name.sin_style) {
J. Bruce Fields04f4ad12010-12-16 09:51:13 -0500916 case NFS4_SECINFO_STYLE4_CURRENT_FH:
917 break;
918 case NFS4_SECINFO_STYLE4_PARENT:
919 err = nfsd4_do_lookupp(rqstp, &cstate->current_fh);
920 if (err)
921 return err;
922 break;
923 default:
924 return nfserr_inval;
925 }
Kinglong Meebf18f162014-06-10 22:06:44 +0800926
Christoph Hellwigeb698532017-05-08 20:58:35 +0200927 u->secinfo_no_name.sin_exp = exp_get(cstate->current_fh.fh_export);
J. Bruce Fields04f4ad12010-12-16 09:51:13 -0500928 fh_put(&cstate->current_fh);
929 return nfs_ok;
930}
931
J. Bruce Fields34b1744c2017-05-05 17:09:37 -0400932static void
933nfsd4_secinfo_release(union nfsd4_op_u *u)
934{
935 if (u->secinfo.si_exp)
936 exp_put(u->secinfo.si_exp);
937}
938
Eryu Guanec572b92017-09-29 15:01:10 +0800939static void
940nfsd4_secinfo_no_name_release(union nfsd4_op_u *u)
941{
942 if (u->secinfo_no_name.sin_exp)
943 exp_put(u->secinfo_no_name.sin_exp);
944}
945
J. Bruce Fields04f4ad12010-12-16 09:51:13 -0500946static __be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800947nfsd4_setattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
Christoph Hellwigeb698532017-05-08 20:58:35 +0200948 union nfsd4_op_u *u)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949{
Christoph Hellwigeb698532017-05-08 20:58:35 +0200950 struct nfsd4_setattr *setattr = &u->setattr;
Al Virob37ad282006-10-19 23:28:59 -0700951 __be32 status = nfs_ok;
Al Viro96f6f982012-04-12 23:47:00 -0400952 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954 if (setattr->sa_iattr.ia_valid & ATTR_SIZE) {
Christoph Hellwigaf90f702015-06-18 16:45:00 +0200955 status = nfs4_preprocess_stateid_op(rqstp, cstate,
Anna Schumakeraa0d6ae2015-12-03 12:59:51 +0100956 &cstate->current_fh, &setattr->sa_stateid,
957 WR_STATE, NULL, NULL);
J. Bruce Fields375c5542006-01-18 17:43:33 -0800958 if (status) {
Greg Banks3e3b4802006-10-02 02:17:41 -0700959 dprintk("NFSD: nfsd4_setattr: couldn't process stateid!\n");
J. Bruce Fields375c5542006-01-18 17:43:33 -0800960 return status;
961 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 }
Al Viro96f6f982012-04-12 23:47:00 -0400963 err = fh_want_write(&cstate->current_fh);
964 if (err)
965 return nfserrno(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 status = nfs_ok;
Yu Zhiguo3c8e0312009-05-16 16:22:31 +0800967
968 status = check_attr_support(rqstp, cstate, setattr->sa_bmval,
969 nfsd_attrmask);
970 if (status)
971 goto out;
972
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 if (setattr->sa_acl != NULL)
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800974 status = nfsd4_set_nfs4_acl(rqstp, &cstate->current_fh,
975 setattr->sa_acl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 if (status)
Dave Hansen18f335a2008-02-15 14:37:38 -0800977 goto out;
David Quigley18032ca2013-05-02 13:19:10 -0400978 if (setattr->sa_label.len)
979 status = nfsd4_set_nfs4_label(rqstp, &cstate->current_fh,
980 &setattr->sa_label);
981 if (status)
982 goto out;
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800983 status = nfsd_setattr(rqstp, &cstate->current_fh, &setattr->sa_iattr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 0, (time_t)0);
Dave Hansen18f335a2008-02-15 14:37:38 -0800985out:
Al Virobad0dcf2011-11-23 12:03:18 -0500986 fh_drop_write(&cstate->current_fh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987 return status;
988}
989
J.Bruce Fields71911552006-12-13 00:35:29 -0800990static __be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -0800991nfsd4_write(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
Christoph Hellwigeb698532017-05-08 20:58:35 +0200992 union nfsd4_op_u *u)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993{
Christoph Hellwigeb698532017-05-08 20:58:35 +0200994 struct nfsd4_write *write = &u->write;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 stateid_t *stateid = &write->wr_stateid;
996 struct file *filp = NULL;
Al Virob37ad282006-10-19 23:28:59 -0700997 __be32 status = nfs_ok;
David Shaw31dec252009-03-05 20:16:14 -0500998 unsigned long cnt;
J. Bruce Fieldsffe11372012-11-15 14:52:19 -0500999 int nvecs;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 if (write->wr_offset >= OFFSET_MAX)
1002 return nfserr_inval;
1003
Chuck Leverd890be12018-03-27 10:53:27 -04001004 cnt = write->wr_buflen;
1005 trace_nfsd_write_start(rqstp, &cstate->current_fh,
1006 write->wr_offset, cnt);
Anna Schumakeraa0d6ae2015-12-03 12:59:51 +01001007 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
1008 stateid, WR_STATE, &filp, NULL);
J. Bruce Fields375c5542006-01-18 17:43:33 -08001009 if (status) {
1010 dprintk("NFSD: nfsd4_write: couldn't process stateid!\n");
1011 return status;
1012 }
1013
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 write->wr_how_written = write->wr_stable_how;
Stanislav Kinsburskyb9c0ef82012-12-06 14:23:19 +03001015 gen_boot_verifier(&write->wr_verifier, SVC_NET(rqstp));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016
Chuck Lever3fd95572018-07-27 11:19:05 -04001017 nvecs = svc_fill_write_vector(rqstp, write->wr_pagelist,
1018 &write->wr_head, write->wr_buflen);
J. Bruce Fieldsffe11372012-11-15 14:52:19 -05001019 WARN_ON_ONCE(nvecs > ARRAY_SIZE(rqstp->rq_vec));
1020
Christoph Hellwigaf90f702015-06-18 16:45:00 +02001021 status = nfsd_vfs_write(rqstp, &cstate->current_fh, filp,
1022 write->wr_offset, rqstp->rq_vec, nvecs, &cnt,
Kinglong Mee54bbb7d2016-12-31 20:59:53 +08001023 write->wr_how_written);
Christoph Hellwigaf90f702015-06-18 16:45:00 +02001024 fput(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025
David Shaw31dec252009-03-05 20:16:14 -05001026 write->wr_bytes_written = cnt;
Chuck Leverd890be12018-03-27 10:53:27 -04001027 trace_nfsd_write_done(rqstp, &cstate->current_fh,
1028 write->wr_offset, cnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030}
1031
Anna Schumaker24bab492014-09-26 13:58:27 -04001032static __be32
Anna Schumaker29ae7f92016-09-07 15:57:30 -04001033nfsd4_verify_copy(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1034 stateid_t *src_stateid, struct file **src,
1035 stateid_t *dst_stateid, struct file **dst)
Christoph Hellwigffa01602015-12-03 12:59:52 +01001036{
Christoph Hellwigffa01602015-12-03 12:59:52 +01001037 __be32 status;
1038
Scott Mayhew01310bb2018-11-08 11:11:36 -05001039 if (!cstate->save_fh.fh_dentry)
1040 return nfserr_nofilehandle;
1041
Christoph Hellwigffa01602015-12-03 12:59:52 +01001042 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->save_fh,
Anna Schumaker29ae7f92016-09-07 15:57:30 -04001043 src_stateid, RD_STATE, src, NULL);
Christoph Hellwigffa01602015-12-03 12:59:52 +01001044 if (status) {
1045 dprintk("NFSD: %s: couldn't process src stateid!\n", __func__);
1046 goto out;
1047 }
1048
1049 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
Anna Schumaker29ae7f92016-09-07 15:57:30 -04001050 dst_stateid, WR_STATE, dst, NULL);
Christoph Hellwigffa01602015-12-03 12:59:52 +01001051 if (status) {
1052 dprintk("NFSD: %s: couldn't process dst stateid!\n", __func__);
1053 goto out_put_src;
1054 }
1055
1056 /* fix up for NFS-specific error code */
Anna Schumaker29ae7f92016-09-07 15:57:30 -04001057 if (!S_ISREG(file_inode(*src)->i_mode) ||
1058 !S_ISREG(file_inode(*dst)->i_mode)) {
Christoph Hellwigffa01602015-12-03 12:59:52 +01001059 status = nfserr_wrong_type;
1060 goto out_put_dst;
1061 }
1062
Anna Schumaker29ae7f92016-09-07 15:57:30 -04001063out:
1064 return status;
1065out_put_dst:
1066 fput(*dst);
1067out_put_src:
1068 fput(*src);
1069 goto out;
1070}
1071
1072static __be32
1073nfsd4_clone(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
Christoph Hellwigeb698532017-05-08 20:58:35 +02001074 union nfsd4_op_u *u)
Anna Schumaker29ae7f92016-09-07 15:57:30 -04001075{
Christoph Hellwigeb698532017-05-08 20:58:35 +02001076 struct nfsd4_clone *clone = &u->clone;
Anna Schumaker29ae7f92016-09-07 15:57:30 -04001077 struct file *src, *dst;
1078 __be32 status;
1079
1080 status = nfsd4_verify_copy(rqstp, cstate, &clone->cl_src_stateid, &src,
1081 &clone->cl_dst_stateid, &dst);
1082 if (status)
1083 goto out;
1084
Christoph Hellwigffa01602015-12-03 12:59:52 +01001085 status = nfsd4_clone_file_range(src, clone->cl_src_pos,
1086 dst, clone->cl_dst_pos, clone->cl_count);
1087
Christoph Hellwigffa01602015-12-03 12:59:52 +01001088 fput(dst);
Christoph Hellwigffa01602015-12-03 12:59:52 +01001089 fput(src);
1090out:
1091 return status;
1092}
1093
Olga Kornievskaiae0639dc2018-07-20 18:19:20 -04001094void nfs4_put_copy(struct nfsd4_copy *copy)
1095{
1096 if (!refcount_dec_and_test(&copy->refcount))
1097 return;
1098 kfree(copy);
1099}
1100
1101static bool
1102check_and_set_stop_copy(struct nfsd4_copy *copy)
1103{
1104 bool value;
1105
1106 spin_lock(&copy->cp_clp->async_lock);
1107 value = copy->stopped;
1108 if (!copy->stopped)
1109 copy->stopped = true;
1110 spin_unlock(&copy->cp_clp->async_lock);
1111 return value;
1112}
1113
1114static void nfsd4_stop_copy(struct nfsd4_copy *copy)
1115{
1116 /* only 1 thread should stop the copy */
1117 if (!check_and_set_stop_copy(copy))
1118 kthread_stop(copy->copy_task);
1119 nfs4_put_copy(copy);
1120}
1121
1122static struct nfsd4_copy *nfsd4_get_copy(struct nfs4_client *clp)
1123{
1124 struct nfsd4_copy *copy = NULL;
1125
1126 spin_lock(&clp->async_lock);
1127 if (!list_empty(&clp->async_copies)) {
1128 copy = list_first_entry(&clp->async_copies, struct nfsd4_copy,
1129 copies);
1130 refcount_inc(&copy->refcount);
1131 }
1132 spin_unlock(&clp->async_lock);
1133 return copy;
1134}
1135
1136void nfsd4_shutdown_copy(struct nfs4_client *clp)
1137{
1138 struct nfsd4_copy *copy;
1139
1140 while ((copy = nfsd4_get_copy(clp)) != NULL)
1141 nfsd4_stop_copy(copy);
1142}
1143
1144static void nfsd4_cb_offload_release(struct nfsd4_callback *cb)
1145{
1146 struct nfsd4_copy *copy = container_of(cb, struct nfsd4_copy, cp_cb);
1147
1148 nfs4_put_copy(copy);
1149}
1150
1151static int nfsd4_cb_offload_done(struct nfsd4_callback *cb,
1152 struct rpc_task *task)
1153{
1154 return 1;
1155}
1156
1157static const struct nfsd4_callback_ops nfsd4_cb_offload_ops = {
1158 .release = nfsd4_cb_offload_release,
1159 .done = nfsd4_cb_offload_done
1160};
1161
1162static void nfsd4_init_copy_res(struct nfsd4_copy *copy, bool sync)
1163{
1164 copy->cp_res.wr_stable_how = NFS_UNSTABLE;
1165 copy->cp_synchronous = sync;
1166 gen_boot_verifier(&copy->cp_res.wr_verifier, copy->cp_clp->net);
1167}
1168
1169static ssize_t _nfsd_copy_file_range(struct nfsd4_copy *copy)
1170{
1171 ssize_t bytes_copied = 0;
1172 size_t bytes_total = copy->cp_count;
1173 u64 src_pos = copy->cp_src_pos;
1174 u64 dst_pos = copy->cp_dst_pos;
1175
1176 do {
1177 if (kthread_should_stop())
1178 break;
1179 bytes_copied = nfsd_copy_file_range(copy->file_src, src_pos,
1180 copy->file_dst, dst_pos, bytes_total);
1181 if (bytes_copied <= 0)
1182 break;
1183 bytes_total -= bytes_copied;
1184 copy->cp_res.wr_bytes_written += bytes_copied;
1185 src_pos += bytes_copied;
1186 dst_pos += bytes_copied;
1187 } while (bytes_total > 0 && !copy->cp_synchronous);
1188 return bytes_copied;
1189}
1190
1191static __be32 nfsd4_do_copy(struct nfsd4_copy *copy, bool sync)
1192{
1193 __be32 status;
1194 ssize_t bytes;
1195
1196 bytes = _nfsd_copy_file_range(copy);
1197 /* for async copy, we ignore the error, client can always retry
1198 * to get the error
1199 */
1200 if (bytes < 0 && !copy->cp_res.wr_bytes_written)
1201 status = nfserrno(bytes);
1202 else {
1203 nfsd4_init_copy_res(copy, sync);
1204 status = nfs_ok;
1205 }
1206
1207 fput(copy->file_src);
1208 fput(copy->file_dst);
1209 return status;
1210}
1211
1212static void dup_copy_fields(struct nfsd4_copy *src, struct nfsd4_copy *dst)
1213{
1214 dst->cp_src_pos = src->cp_src_pos;
1215 dst->cp_dst_pos = src->cp_dst_pos;
1216 dst->cp_count = src->cp_count;
1217 dst->cp_synchronous = src->cp_synchronous;
1218 memcpy(&dst->cp_res, &src->cp_res, sizeof(src->cp_res));
1219 memcpy(&dst->fh, &src->fh, sizeof(src->fh));
1220 dst->cp_clp = src->cp_clp;
1221 dst->file_dst = get_file(src->file_dst);
1222 dst->file_src = get_file(src->file_src);
1223 memcpy(&dst->cp_stateid, &src->cp_stateid, sizeof(src->cp_stateid));
1224}
1225
1226static void cleanup_async_copy(struct nfsd4_copy *copy)
1227{
1228 nfs4_free_cp_state(copy);
1229 fput(copy->file_dst);
1230 fput(copy->file_src);
1231 spin_lock(&copy->cp_clp->async_lock);
1232 list_del(&copy->copies);
1233 spin_unlock(&copy->cp_clp->async_lock);
1234 nfs4_put_copy(copy);
1235}
1236
1237static int nfsd4_do_async_copy(void *data)
1238{
1239 struct nfsd4_copy *copy = (struct nfsd4_copy *)data;
1240 struct nfsd4_copy *cb_copy;
1241
1242 copy->nfserr = nfsd4_do_copy(copy, 0);
1243 cb_copy = kzalloc(sizeof(struct nfsd4_copy), GFP_KERNEL);
1244 if (!cb_copy)
1245 goto out;
1246 memcpy(&cb_copy->cp_res, &copy->cp_res, sizeof(copy->cp_res));
1247 cb_copy->cp_clp = copy->cp_clp;
1248 cb_copy->nfserr = copy->nfserr;
1249 memcpy(&cb_copy->fh, &copy->fh, sizeof(copy->fh));
1250 nfsd4_init_cb(&cb_copy->cp_cb, cb_copy->cp_clp,
1251 &nfsd4_cb_offload_ops, NFSPROC4_CLNT_CB_OFFLOAD);
1252 nfsd4_run_cb(&cb_copy->cp_cb);
1253out:
1254 cleanup_async_copy(copy);
1255 return 0;
1256}
1257
Christoph Hellwigffa01602015-12-03 12:59:52 +01001258static __be32
Anna Schumaker29ae7f92016-09-07 15:57:30 -04001259nfsd4_copy(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
Christoph Hellwigeb698532017-05-08 20:58:35 +02001260 union nfsd4_op_u *u)
Anna Schumaker29ae7f92016-09-07 15:57:30 -04001261{
Christoph Hellwigeb698532017-05-08 20:58:35 +02001262 struct nfsd4_copy *copy = &u->copy;
Anna Schumaker29ae7f92016-09-07 15:57:30 -04001263 __be32 status;
Olga Kornievskaiae0639dc2018-07-20 18:19:20 -04001264 struct nfsd4_copy *async_copy = NULL;
Anna Schumaker29ae7f92016-09-07 15:57:30 -04001265
Olga Kornievskaiae0639dc2018-07-20 18:19:20 -04001266 status = nfsd4_verify_copy(rqstp, cstate, &copy->cp_src_stateid,
1267 &copy->file_src, &copy->cp_dst_stateid,
1268 &copy->file_dst);
Anna Schumaker29ae7f92016-09-07 15:57:30 -04001269 if (status)
1270 goto out;
1271
Olga Kornievskaiae0639dc2018-07-20 18:19:20 -04001272 copy->cp_clp = cstate->clp;
1273 memcpy(&copy->fh, &cstate->current_fh.fh_handle,
1274 sizeof(struct knfsd_fh));
1275 if (!copy->cp_synchronous) {
1276 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Anna Schumaker29ae7f92016-09-07 15:57:30 -04001277
Olga Kornievskaiae0639dc2018-07-20 18:19:20 -04001278 status = nfserrno(-ENOMEM);
1279 async_copy = kzalloc(sizeof(struct nfsd4_copy), GFP_KERNEL);
1280 if (!async_copy)
1281 goto out;
1282 if (!nfs4_init_cp_state(nn, copy)) {
1283 kfree(async_copy);
1284 goto out;
1285 }
1286 refcount_set(&async_copy->refcount, 1);
1287 memcpy(&copy->cp_res.cb_stateid, &copy->cp_stateid,
1288 sizeof(copy->cp_stateid));
1289 dup_copy_fields(copy, async_copy);
1290 async_copy->copy_task = kthread_create(nfsd4_do_async_copy,
1291 async_copy, "%s", "copy thread");
1292 if (IS_ERR(async_copy->copy_task))
1293 goto out_err;
1294 spin_lock(&async_copy->cp_clp->async_lock);
1295 list_add(&async_copy->copies,
1296 &async_copy->cp_clp->async_copies);
1297 spin_unlock(&async_copy->cp_clp->async_lock);
1298 wake_up_process(async_copy->copy_task);
Anna Schumaker29ae7f92016-09-07 15:57:30 -04001299 status = nfs_ok;
Olga Kornievskaiae0639dc2018-07-20 18:19:20 -04001300 } else
1301 status = nfsd4_do_copy(copy, 1);
Anna Schumaker29ae7f92016-09-07 15:57:30 -04001302out:
1303 return status;
Olga Kornievskaiae0639dc2018-07-20 18:19:20 -04001304out_err:
1305 cleanup_async_copy(async_copy);
1306 goto out;
1307}
1308
1309struct nfsd4_copy *
1310find_async_copy(struct nfs4_client *clp, stateid_t *stateid)
1311{
1312 struct nfsd4_copy *copy;
1313
1314 spin_lock(&clp->async_lock);
1315 list_for_each_entry(copy, &clp->async_copies, copies) {
1316 if (memcmp(&copy->cp_stateid, stateid, NFS4_STATEID_SIZE))
1317 continue;
1318 refcount_inc(&copy->refcount);
1319 spin_unlock(&clp->async_lock);
1320 return copy;
1321 }
1322 spin_unlock(&clp->async_lock);
1323 return NULL;
Anna Schumaker29ae7f92016-09-07 15:57:30 -04001324}
1325
1326static __be32
Olga Kornievskaia885e2bf2018-07-20 18:19:19 -04001327nfsd4_offload_cancel(struct svc_rqst *rqstp,
1328 struct nfsd4_compound_state *cstate,
1329 union nfsd4_op_u *u)
1330{
Olga Kornievskaiae0639dc2018-07-20 18:19:20 -04001331 struct nfsd4_offload_status *os = &u->offload_status;
1332 __be32 status = 0;
1333 struct nfsd4_copy *copy;
1334 struct nfs4_client *clp = cstate->clp;
1335
1336 copy = find_async_copy(clp, &os->stateid);
1337 if (copy)
1338 nfsd4_stop_copy(copy);
1339 else
1340 status = nfserr_bad_stateid;
1341
1342 return status;
Olga Kornievskaia885e2bf2018-07-20 18:19:19 -04001343}
1344
1345static __be32
Anna Schumaker95d871f2014-11-07 14:44:26 -05001346nfsd4_fallocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1347 struct nfsd4_fallocate *fallocate, int flags)
1348{
J. Bruce Fields0d4d6722018-11-06 17:44:03 -05001349 __be32 status;
Anna Schumaker95d871f2014-11-07 14:44:26 -05001350 struct file *file;
1351
Anna Schumakeraa0d6ae2015-12-03 12:59:51 +01001352 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
Anna Schumaker95d871f2014-11-07 14:44:26 -05001353 &fallocate->falloc_stateid,
Christoph Hellwigaf90f702015-06-18 16:45:00 +02001354 WR_STATE, &file, NULL);
Anna Schumaker95d871f2014-11-07 14:44:26 -05001355 if (status != nfs_ok) {
1356 dprintk("NFSD: nfsd4_fallocate: couldn't process stateid!\n");
1357 return status;
1358 }
1359
1360 status = nfsd4_vfs_fallocate(rqstp, &cstate->current_fh, file,
1361 fallocate->falloc_offset,
1362 fallocate->falloc_length,
1363 flags);
1364 fput(file);
1365 return status;
1366}
Olga Kornievskaia6308bc92018-07-20 18:19:18 -04001367static __be32
1368nfsd4_offload_status(struct svc_rqst *rqstp,
1369 struct nfsd4_compound_state *cstate,
1370 union nfsd4_op_u *u)
1371{
Olga Kornievskaiae0639dc2018-07-20 18:19:20 -04001372 struct nfsd4_offload_status *os = &u->offload_status;
1373 __be32 status = 0;
1374 struct nfsd4_copy *copy;
1375 struct nfs4_client *clp = cstate->clp;
1376
1377 copy = find_async_copy(clp, &os->stateid);
1378 if (copy) {
1379 os->count = copy->cp_res.wr_bytes_written;
1380 nfs4_put_copy(copy);
1381 } else
1382 status = nfserr_bad_stateid;
1383
1384 return status;
Olga Kornievskaia6308bc92018-07-20 18:19:18 -04001385}
Anna Schumaker95d871f2014-11-07 14:44:26 -05001386
1387static __be32
1388nfsd4_allocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
Christoph Hellwigeb698532017-05-08 20:58:35 +02001389 union nfsd4_op_u *u)
Anna Schumaker95d871f2014-11-07 14:44:26 -05001390{
Christoph Hellwigeb698532017-05-08 20:58:35 +02001391 return nfsd4_fallocate(rqstp, cstate, &u->allocate, 0);
Anna Schumaker95d871f2014-11-07 14:44:26 -05001392}
1393
1394static __be32
Anna Schumakerb0cb9082014-11-07 14:44:27 -05001395nfsd4_deallocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
Christoph Hellwigeb698532017-05-08 20:58:35 +02001396 union nfsd4_op_u *u)
Anna Schumakerb0cb9082014-11-07 14:44:27 -05001397{
Christoph Hellwigeb698532017-05-08 20:58:35 +02001398 return nfsd4_fallocate(rqstp, cstate, &u->deallocate,
Anna Schumakerb0cb9082014-11-07 14:44:27 -05001399 FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE);
1400}
1401
1402static __be32
Anna Schumaker24bab492014-09-26 13:58:27 -04001403nfsd4_seek(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
Christoph Hellwigeb698532017-05-08 20:58:35 +02001404 union nfsd4_op_u *u)
Anna Schumaker24bab492014-09-26 13:58:27 -04001405{
Christoph Hellwigeb698532017-05-08 20:58:35 +02001406 struct nfsd4_seek *seek = &u->seek;
Anna Schumaker24bab492014-09-26 13:58:27 -04001407 int whence;
1408 __be32 status;
1409 struct file *file;
1410
Anna Schumakeraa0d6ae2015-12-03 12:59:51 +01001411 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
Anna Schumaker24bab492014-09-26 13:58:27 -04001412 &seek->seek_stateid,
Christoph Hellwigaf90f702015-06-18 16:45:00 +02001413 RD_STATE, &file, NULL);
Anna Schumaker24bab492014-09-26 13:58:27 -04001414 if (status) {
1415 dprintk("NFSD: nfsd4_seek: couldn't process stateid!\n");
1416 return status;
1417 }
1418
1419 switch (seek->seek_whence) {
1420 case NFS4_CONTENT_DATA:
1421 whence = SEEK_DATA;
1422 break;
1423 case NFS4_CONTENT_HOLE:
1424 whence = SEEK_HOLE;
1425 break;
1426 default:
1427 status = nfserr_union_notsupp;
1428 goto out;
1429 }
1430
1431 /*
1432 * Note: This call does change file->f_pos, but nothing in NFSD
1433 * should ever file->f_pos.
1434 */
1435 seek->seek_pos = vfs_llseek(file, seek->seek_offset, whence);
1436 if (seek->seek_pos < 0)
1437 status = nfserrno(seek->seek_pos);
1438 else if (seek->seek_pos >= i_size_read(file_inode(file)))
1439 seek->seek_eof = true;
1440
1441out:
1442 fput(file);
1443 return status;
1444}
1445
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446/* This routine never returns NFS_OK! If there are no other errors, it
1447 * will return NFSERR_SAME or NFSERR_NOT_SAME depending on whether the
1448 * attributes matched. VERIFY is implemented by mapping NFSERR_SAME
1449 * to NFS_OK after the call; NVERIFY by mapping NFSERR_NOT_SAME to NFS_OK.
1450 */
Al Virob37ad282006-10-19 23:28:59 -07001451static __be32
J.Bruce Fieldsc954e2a2006-12-13 00:35:31 -08001452_nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsca364312006-12-13 00:35:27 -08001453 struct nfsd4_verify *verify)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454{
Al Viro2ebbc012006-10-19 23:28:58 -07001455 __be32 *buf, *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456 int count;
Al Virob37ad282006-10-19 23:28:59 -07001457 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458
Miklos Szeredi8837abc2008-06-16 13:20:29 +02001459 status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 if (status)
1461 return status;
1462
Yu Zhiguo3c8e0312009-05-16 16:22:31 +08001463 status = check_attr_support(rqstp, cstate, verify->ve_bmval, NULL);
1464 if (status)
1465 return status;
1466
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467 if ((verify->ve_bmval[0] & FATTR4_WORD0_RDATTR_ERROR)
1468 || (verify->ve_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1))
1469 return nfserr_inval;
1470 if (verify->ve_attrlen & 3)
1471 return nfserr_inval;
1472
1473 /* count in words:
1474 * bitmap_len(1) + bitmap(2) + attr_len(1) = 4
1475 */
1476 count = 4 + (verify->ve_attrlen >> 2);
1477 buf = kmalloc(count << 2, GFP_KERNEL);
1478 if (!buf)
J. Bruce Fields3e772462011-08-10 19:07:33 -04001479 return nfserr_jukebox;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480
J. Bruce Fields84822d02012-12-14 17:57:50 -05001481 p = buf;
J. Bruce Fieldsd5184652013-08-26 16:04:46 -04001482 status = nfsd4_encode_fattr_to_buf(&p, count, &cstate->current_fh,
J.Bruce Fieldsca364312006-12-13 00:35:27 -08001483 cstate->current_fh.fh_export,
J. Bruce Fieldsd5184652013-08-26 16:04:46 -04001484 cstate->current_fh.fh_dentry,
1485 verify->ve_bmval,
Frank Filz406a7ea2007-11-27 11:34:05 -08001486 rqstp, 0);
J. Bruce Fields41ae6e712013-08-21 15:32:50 -04001487 /*
1488 * If nfsd4_encode_fattr() ran out of space, assume that's because
1489 * the attributes are longer (hence different) than those given:
1490 */
J. Bruce Fields84822d02012-12-14 17:57:50 -05001491 if (status == nfserr_resource)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492 status = nfserr_not_same;
1493 if (status)
1494 goto out_kfree;
1495
Benny Halevy95ec28c2009-04-03 08:29:08 +03001496 /* skip bitmap */
1497 p = buf + 1 + ntohl(buf[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498 status = nfserr_not_same;
1499 if (ntohl(*p++) != verify->ve_attrlen)
1500 goto out_kfree;
1501 if (!memcmp(p, verify->ve_attrval, verify->ve_attrlen))
1502 status = nfserr_same;
1503
1504out_kfree:
1505 kfree(buf);
1506 return status;
1507}
1508
J.Bruce Fieldsc954e2a2006-12-13 00:35:31 -08001509static __be32
1510nfsd4_nverify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
Christoph Hellwigeb698532017-05-08 20:58:35 +02001511 union nfsd4_op_u *u)
J.Bruce Fieldsc954e2a2006-12-13 00:35:31 -08001512{
1513 __be32 status;
1514
Christoph Hellwigeb698532017-05-08 20:58:35 +02001515 status = _nfsd4_verify(rqstp, cstate, &u->verify);
J.Bruce Fieldsc954e2a2006-12-13 00:35:31 -08001516 return status == nfserr_not_same ? nfs_ok : status;
1517}
1518
1519static __be32
1520nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
Christoph Hellwigeb698532017-05-08 20:58:35 +02001521 union nfsd4_op_u *u)
J.Bruce Fieldsc954e2a2006-12-13 00:35:31 -08001522{
1523 __be32 status;
1524
Christoph Hellwigeb698532017-05-08 20:58:35 +02001525 status = _nfsd4_verify(rqstp, cstate, &u->nverify);
J.Bruce Fieldsc954e2a2006-12-13 00:35:31 -08001526 return status == nfserr_same ? nfs_ok : status;
1527}
1528
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02001529#ifdef CONFIG_NFSD_PNFS
1530static const struct nfsd4_layout_ops *
1531nfsd4_layout_verify(struct svc_export *exp, unsigned int layout_type)
1532{
Jeff Layton8a4c3922016-07-10 15:55:58 -04001533 if (!exp->ex_layout_types) {
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02001534 dprintk("%s: export does not support pNFS\n", __func__);
1535 return NULL;
1536 }
1537
Ari Kauppib550a322017-05-05 16:07:55 -04001538 if (layout_type >= LAYOUT_TYPE_MAX ||
1539 !(exp->ex_layout_types & (1 << layout_type))) {
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02001540 dprintk("%s: layout type %d not supported\n",
1541 __func__, layout_type);
1542 return NULL;
1543 }
1544
1545 return nfsd4_layout_ops[layout_type];
1546}
1547
1548static __be32
1549nfsd4_getdeviceinfo(struct svc_rqst *rqstp,
Christoph Hellwigeb698532017-05-08 20:58:35 +02001550 struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02001551{
Christoph Hellwigeb698532017-05-08 20:58:35 +02001552 struct nfsd4_getdeviceinfo *gdp = &u->getdeviceinfo;
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02001553 const struct nfsd4_layout_ops *ops;
1554 struct nfsd4_deviceid_map *map;
1555 struct svc_export *exp;
1556 __be32 nfserr;
1557
1558 dprintk("%s: layout_type %u dev_id [0x%llx:0x%x] maxcnt %u\n",
1559 __func__,
1560 gdp->gd_layout_type,
1561 gdp->gd_devid.fsid_idx, gdp->gd_devid.generation,
1562 gdp->gd_maxcount);
1563
1564 map = nfsd4_find_devid_map(gdp->gd_devid.fsid_idx);
1565 if (!map) {
1566 dprintk("%s: couldn't find device ID to export mapping!\n",
1567 __func__);
1568 return nfserr_noent;
1569 }
1570
1571 exp = rqst_exp_find(rqstp, map->fsid_type, map->fsid);
1572 if (IS_ERR(exp)) {
1573 dprintk("%s: could not find device id\n", __func__);
1574 return nfserr_noent;
1575 }
1576
1577 nfserr = nfserr_layoutunavailable;
1578 ops = nfsd4_layout_verify(exp, gdp->gd_layout_type);
1579 if (!ops)
1580 goto out;
1581
1582 nfserr = nfs_ok;
Christoph Hellwigf99d4fb2016-03-04 20:46:17 +01001583 if (gdp->gd_maxcount != 0) {
1584 nfserr = ops->proc_getdeviceinfo(exp->ex_path.mnt->mnt_sb,
Tom Haynesd7c920d2016-06-14 13:41:27 -07001585 rqstp, cstate->session->se_client, gdp);
Christoph Hellwigf99d4fb2016-03-04 20:46:17 +01001586 }
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02001587
1588 gdp->gd_notify_types &= ops->notify_types;
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02001589out:
Kinglong Meea1420382015-03-15 23:12:15 +08001590 exp_put(exp);
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02001591 return nfserr;
1592}
1593
J. Bruce Fields34b1744c2017-05-05 17:09:37 -04001594static void
1595nfsd4_getdeviceinfo_release(union nfsd4_op_u *u)
1596{
1597 kfree(u->getdeviceinfo.gd_device);
1598}
1599
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02001600static __be32
1601nfsd4_layoutget(struct svc_rqst *rqstp,
Christoph Hellwigeb698532017-05-08 20:58:35 +02001602 struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02001603{
Christoph Hellwigeb698532017-05-08 20:58:35 +02001604 struct nfsd4_layoutget *lgp = &u->layoutget;
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02001605 struct svc_fh *current_fh = &cstate->current_fh;
1606 const struct nfsd4_layout_ops *ops;
1607 struct nfs4_layout_stateid *ls;
1608 __be32 nfserr;
Benjamin Coddington66282ec2017-12-19 09:35:25 -05001609 int accmode = NFSD_MAY_READ_IF_EXEC;
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02001610
1611 switch (lgp->lg_seg.iomode) {
1612 case IOMODE_READ:
Benjamin Coddington66282ec2017-12-19 09:35:25 -05001613 accmode |= NFSD_MAY_READ;
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02001614 break;
1615 case IOMODE_RW:
Benjamin Coddington66282ec2017-12-19 09:35:25 -05001616 accmode |= NFSD_MAY_READ | NFSD_MAY_WRITE;
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02001617 break;
1618 default:
1619 dprintk("%s: invalid iomode %d\n",
1620 __func__, lgp->lg_seg.iomode);
1621 nfserr = nfserr_badiomode;
1622 goto out;
1623 }
1624
1625 nfserr = fh_verify(rqstp, current_fh, 0, accmode);
1626 if (nfserr)
1627 goto out;
1628
1629 nfserr = nfserr_layoutunavailable;
1630 ops = nfsd4_layout_verify(current_fh->fh_export, lgp->lg_layout_type);
1631 if (!ops)
1632 goto out;
1633
1634 /*
1635 * Verify minlength and range as per RFC5661:
1636 * o If loga_length is less than loga_minlength,
1637 * the metadata server MUST return NFS4ERR_INVAL.
1638 * o If the sum of loga_offset and loga_minlength exceeds
1639 * NFS4_UINT64_MAX, and loga_minlength is not
1640 * NFS4_UINT64_MAX, the error NFS4ERR_INVAL MUST result.
1641 * o If the sum of loga_offset and loga_length exceeds
1642 * NFS4_UINT64_MAX, and loga_length is not NFS4_UINT64_MAX,
1643 * the error NFS4ERR_INVAL MUST result.
1644 */
1645 nfserr = nfserr_inval;
1646 if (lgp->lg_seg.length < lgp->lg_minlength ||
1647 (lgp->lg_minlength != NFS4_MAX_UINT64 &&
1648 lgp->lg_minlength > NFS4_MAX_UINT64 - lgp->lg_seg.offset) ||
1649 (lgp->lg_seg.length != NFS4_MAX_UINT64 &&
1650 lgp->lg_seg.length > NFS4_MAX_UINT64 - lgp->lg_seg.offset))
1651 goto out;
1652 if (lgp->lg_seg.length == 0)
1653 goto out;
1654
1655 nfserr = nfsd4_preprocess_layout_stateid(rqstp, cstate, &lgp->lg_sid,
1656 true, lgp->lg_layout_type, &ls);
Christoph Hellwig31ef83d2014-08-16 19:02:22 -05001657 if (nfserr) {
Chuck Leverf394b622018-03-27 10:53:11 -04001658 trace_nfsd_layout_get_lookup_fail(&lgp->lg_sid);
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02001659 goto out;
Christoph Hellwig31ef83d2014-08-16 19:02:22 -05001660 }
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02001661
Christoph Hellwigc5c707f2014-09-23 12:38:48 +02001662 nfserr = nfserr_recallconflict;
1663 if (atomic_read(&ls->ls_stid.sc_file->fi_lo_recalls))
1664 goto out_put_stid;
1665
David Howells2b0143b2015-03-17 22:25:59 +00001666 nfserr = ops->proc_layoutget(d_inode(current_fh->fh_dentry),
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02001667 current_fh, lgp);
1668 if (nfserr)
1669 goto out_put_stid;
1670
1671 nfserr = nfsd4_insert_layout(lgp, ls);
1672
1673out_put_stid:
Jeff Laytoncc8a5532015-09-17 07:58:24 -04001674 mutex_unlock(&ls->ls_mutex);
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02001675 nfs4_put_stid(&ls->ls_stid);
1676out:
1677 return nfserr;
1678}
1679
J. Bruce Fields34b1744c2017-05-05 17:09:37 -04001680static void
1681nfsd4_layoutget_release(union nfsd4_op_u *u)
1682{
1683 kfree(u->layoutget.lg_content);
1684}
1685
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02001686static __be32
1687nfsd4_layoutcommit(struct svc_rqst *rqstp,
Christoph Hellwigeb698532017-05-08 20:58:35 +02001688 struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02001689{
Christoph Hellwigeb698532017-05-08 20:58:35 +02001690 struct nfsd4_layoutcommit *lcp = &u->layoutcommit;
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02001691 const struct nfsd4_layout_seg *seg = &lcp->lc_seg;
1692 struct svc_fh *current_fh = &cstate->current_fh;
1693 const struct nfsd4_layout_ops *ops;
1694 loff_t new_size = lcp->lc_last_wr + 1;
1695 struct inode *inode;
1696 struct nfs4_layout_stateid *ls;
1697 __be32 nfserr;
1698
1699 nfserr = fh_verify(rqstp, current_fh, 0, NFSD_MAY_WRITE);
1700 if (nfserr)
1701 goto out;
1702
1703 nfserr = nfserr_layoutunavailable;
1704 ops = nfsd4_layout_verify(current_fh->fh_export, lcp->lc_layout_type);
1705 if (!ops)
1706 goto out;
David Howells2b0143b2015-03-17 22:25:59 +00001707 inode = d_inode(current_fh->fh_dentry);
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02001708
1709 nfserr = nfserr_inval;
1710 if (new_size <= seg->offset) {
1711 dprintk("pnfsd: last write before layout segment\n");
1712 goto out;
1713 }
1714 if (new_size > seg->offset + seg->length) {
1715 dprintk("pnfsd: last write beyond layout segment\n");
1716 goto out;
1717 }
1718 if (!lcp->lc_newoffset && new_size > i_size_read(inode)) {
1719 dprintk("pnfsd: layoutcommit beyond EOF\n");
1720 goto out;
1721 }
1722
1723 nfserr = nfsd4_preprocess_layout_stateid(rqstp, cstate, &lcp->lc_sid,
1724 false, lcp->lc_layout_type,
1725 &ls);
1726 if (nfserr) {
Chuck Leverf394b622018-03-27 10:53:11 -04001727 trace_nfsd_layout_commit_lookup_fail(&lcp->lc_sid);
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02001728 /* fixup error code as per RFC5661 */
1729 if (nfserr == nfserr_bad_stateid)
1730 nfserr = nfserr_badlayout;
1731 goto out;
1732 }
1733
Jeff Laytoncc8a5532015-09-17 07:58:24 -04001734 /* LAYOUTCOMMIT does not require any serialization */
1735 mutex_unlock(&ls->ls_mutex);
1736
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02001737 if (new_size > i_size_read(inode)) {
1738 lcp->lc_size_chg = 1;
1739 lcp->lc_newsize = new_size;
1740 } else {
1741 lcp->lc_size_chg = 0;
1742 }
1743
Kinglong Meed8398fc2015-07-07 10:12:03 +08001744 nfserr = ops->proc_layoutcommit(inode, lcp);
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02001745 nfs4_put_stid(&ls->ls_stid);
1746out:
1747 return nfserr;
1748}
1749
1750static __be32
1751nfsd4_layoutreturn(struct svc_rqst *rqstp,
Christoph Hellwigeb698532017-05-08 20:58:35 +02001752 struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02001753{
Christoph Hellwigeb698532017-05-08 20:58:35 +02001754 struct nfsd4_layoutreturn *lrp = &u->layoutreturn;
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02001755 struct svc_fh *current_fh = &cstate->current_fh;
1756 __be32 nfserr;
1757
1758 nfserr = fh_verify(rqstp, current_fh, 0, NFSD_MAY_NOP);
1759 if (nfserr)
1760 goto out;
1761
1762 nfserr = nfserr_layoutunavailable;
1763 if (!nfsd4_layout_verify(current_fh->fh_export, lrp->lr_layout_type))
1764 goto out;
1765
1766 switch (lrp->lr_seg.iomode) {
1767 case IOMODE_READ:
1768 case IOMODE_RW:
1769 case IOMODE_ANY:
1770 break;
1771 default:
1772 dprintk("%s: invalid iomode %d\n", __func__,
1773 lrp->lr_seg.iomode);
1774 nfserr = nfserr_inval;
1775 goto out;
1776 }
1777
1778 switch (lrp->lr_return_type) {
1779 case RETURN_FILE:
1780 nfserr = nfsd4_return_file_layouts(rqstp, cstate, lrp);
1781 break;
1782 case RETURN_FSID:
1783 case RETURN_ALL:
1784 nfserr = nfsd4_return_client_layouts(rqstp, cstate, lrp);
1785 break;
1786 default:
1787 dprintk("%s: invalid return_type %d\n", __func__,
1788 lrp->lr_return_type);
1789 nfserr = nfserr_inval;
1790 break;
1791 }
1792out:
1793 return nfserr;
1794}
1795#endif /* CONFIG_NFSD_PNFS */
1796
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797/*
1798 * NULL call.
1799 */
Al Viro7111c662006-10-19 23:28:45 -07001800static __be32
Christoph Hellwiga6beb732017-05-08 17:35:49 +02001801nfsd4_proc_null(struct svc_rqst *rqstp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802{
1803 return nfs_ok;
1804}
1805
Shankar Anande2b20952006-07-10 04:45:44 -07001806static inline void nfsd4_increment_op_stats(u32 opnum)
1807{
1808 if (opnum >= FIRST_NFS4_OP && opnum <= LAST_NFS4_OP)
1809 nfsdstats.nfs4_opcount[opnum]++;
1810}
1811
Christoph Hellwigbb2a8b02017-05-08 23:46:47 +02001812static const struct nfsd4_operation nfsd4_ops[];
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08001813
Adrian Bunkf1c7f792008-08-08 19:26:42 +03001814static const char *nfsd4_op_name(unsigned opnum);
Benny Halevyb001a1b2008-07-02 11:15:03 +03001815
Linus Torvalds1da177e2005-04-16 15:20:36 -07001816/*
J. Bruce Fields57716352010-04-21 12:27:19 -04001817 * Enforce NFSv4.1 COMPOUND ordering rules:
Andy Adamsonf9bb94c42009-04-03 08:28:12 +03001818 *
J. Bruce Fields57716352010-04-21 12:27:19 -04001819 * Also note, enforced elsewhere:
1820 * - SEQUENCE other than as first op results in
1821 * NFS4ERR_SEQUENCE_POS. (Enforced in nfsd4_sequence().)
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04001822 * - BIND_CONN_TO_SESSION must be the only op in its compound.
1823 * (Enforced in nfsd4_bind_conn_to_session().)
J. Bruce Fields57716352010-04-21 12:27:19 -04001824 * - DESTROY_SESSION must be the final operation in a compound, if
1825 * sessionid's in SEQUENCE and DESTROY_SESSION are the same.
1826 * (Enforced in nfsd4_destroy_session().)
Andy Adamsonf9bb94c42009-04-03 08:28:12 +03001827 */
J. Bruce Fields57716352010-04-21 12:27:19 -04001828static __be32 nfs41_check_op_ordering(struct nfsd4_compoundargs *args)
Andy Adamsonf9bb94c42009-04-03 08:28:12 +03001829{
J. Bruce Fields7a04cfd2018-06-13 15:04:59 -04001830 struct nfsd4_op *first_op = &args->ops[0];
J. Bruce Fields57716352010-04-21 12:27:19 -04001831
1832 /* These ordering requirements don't apply to NFSv4.0: */
1833 if (args->minorversion == 0)
1834 return nfs_ok;
1835 /* This is weird, but OK, not our problem: */
1836 if (args->opcnt == 0)
1837 return nfs_ok;
J. Bruce Fields7a04cfd2018-06-13 15:04:59 -04001838 if (first_op->status == nfserr_op_illegal)
J. Bruce Fields57716352010-04-21 12:27:19 -04001839 return nfs_ok;
J. Bruce Fields7a04cfd2018-06-13 15:04:59 -04001840 if (!(nfsd4_ops[first_op->opnum].op_flags & ALLOWED_AS_FIRST_OP))
J. Bruce Fields57716352010-04-21 12:27:19 -04001841 return nfserr_op_not_in_session;
J. Bruce Fields7a04cfd2018-06-13 15:04:59 -04001842 if (first_op->opnum == OP_SEQUENCE)
J. Bruce Fields57716352010-04-21 12:27:19 -04001843 return nfs_ok;
J. Bruce Fields7a04cfd2018-06-13 15:04:59 -04001844 /*
1845 * So first_op is something allowed outside a session, like
1846 * EXCHANGE_ID; but then it has to be the only op in the
1847 * compound:
1848 */
J. Bruce Fields57716352010-04-21 12:27:19 -04001849 if (args->opcnt != 1)
1850 return nfserr_not_only_op;
1851 return nfs_ok;
Andy Adamsonf9bb94c42009-04-03 08:28:12 +03001852}
1853
J. Bruce Fieldsf4f9ef42017-07-06 17:51:29 -04001854const struct nfsd4_operation *OPDESC(struct nfsd4_op *op)
J. Bruce Fields22b03212011-04-09 11:23:24 -04001855{
1856 return &nfsd4_ops[op->opnum];
1857}
1858
J. Bruce Fields10910062011-01-24 12:11:02 -05001859bool nfsd4_cache_this_op(struct nfsd4_op *op)
1860{
J. Bruce Fieldse372ba62014-05-19 12:27:11 -04001861 if (op->opnum == OP_ILLEGAL)
1862 return false;
J. Bruce Fieldsc8566942011-09-20 08:49:51 -04001863 return OPDESC(op)->op_flags & OP_CACHEME;
J. Bruce Fields10910062011-01-24 12:11:02 -05001864}
1865
J. Bruce Fields68d93182011-04-08 17:00:50 -04001866static bool need_wrongsec_check(struct svc_rqst *rqstp)
1867{
1868 struct nfsd4_compoundres *resp = rqstp->rq_resp;
1869 struct nfsd4_compoundargs *argp = rqstp->rq_argp;
1870 struct nfsd4_op *this = &argp->ops[resp->opcnt - 1];
1871 struct nfsd4_op *next = &argp->ops[resp->opcnt];
Christoph Hellwigbb2a8b02017-05-08 23:46:47 +02001872 const struct nfsd4_operation *thisd = OPDESC(this);
1873 const struct nfsd4_operation *nextd;
J. Bruce Fields68d93182011-04-08 17:00:50 -04001874
J. Bruce Fields68d93182011-04-08 17:00:50 -04001875 /*
1876 * Most ops check wronsec on our own; only the putfh-like ops
1877 * have special rules.
1878 */
1879 if (!(thisd->op_flags & OP_IS_PUTFH_LIKE))
1880 return false;
1881 /*
1882 * rfc 5661 2.6.3.1.1.6: don't bother erroring out a
1883 * put-filehandle operation if we're not going to use the
1884 * result:
1885 */
1886 if (argp->opcnt == resp->opcnt)
1887 return false;
J. Bruce Fields51904b02014-10-22 14:46:29 -04001888 if (next->opnum == OP_ILLEGAL)
1889 return false;
J. Bruce Fields68d93182011-04-08 17:00:50 -04001890 nextd = OPDESC(next);
1891 /*
1892 * Rest of 2.6.3.1.1: certain operations will return WRONGSEC
1893 * errors themselves as necessary; others should check for them
1894 * now:
1895 */
1896 return !(nextd->op_flags & OP_HANDLES_WRONGSEC);
1897}
1898
J. Bruce Fields2d124dfaa2014-01-15 16:26:42 -05001899static void svcxdr_init_encode(struct svc_rqst *rqstp,
1900 struct nfsd4_compoundres *resp)
1901{
1902 struct xdr_stream *xdr = &resp->xdr;
1903 struct xdr_buf *buf = &rqstp->rq_res;
1904 struct kvec *head = buf->head;
1905
1906 xdr->buf = buf;
J. Bruce Fieldsddd1ea52013-08-27 21:32:25 -04001907 xdr->iov = head;
J. Bruce Fields2d124dfaa2014-01-15 16:26:42 -05001908 xdr->p = head->iov_base + head->iov_len;
J. Bruce Fieldsa5cddc82014-05-12 18:10:58 -04001909 xdr->end = head->iov_base + PAGE_SIZE - rqstp->rq_auth_slack;
J. Bruce Fields6ac90392014-02-26 17:39:35 -05001910 /* Tail and page_len should be zero at this point: */
1911 buf->len = buf->head[0].iov_len;
J. Bruce Fields2825a7f2013-08-26 16:04:46 -04001912 xdr->scratch.iov_len = 0;
J. Bruce Fields05638dc2014-06-02 12:05:47 -04001913 xdr->page_ptr = buf->pages - 1;
J. Bruce Fields2825a7f2013-08-26 16:04:46 -04001914 buf->buflen = PAGE_SIZE * (1 + rqstp->rq_page_end - buf->pages)
J. Bruce Fieldsa5cddc82014-05-12 18:10:58 -04001915 - rqstp->rq_auth_slack;
J. Bruce Fields2d124dfaa2014-01-15 16:26:42 -05001916}
1917
Andy Adamsonf9bb94c42009-04-03 08:28:12 +03001918/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001919 * COMPOUND call.
1920 */
Al Viro7111c662006-10-19 23:28:45 -07001921static __be32
Christoph Hellwiga6beb732017-05-08 17:35:49 +02001922nfsd4_proc_compound(struct svc_rqst *rqstp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923{
Christoph Hellwiga6beb732017-05-08 17:35:49 +02001924 struct nfsd4_compoundargs *args = rqstp->rq_argp;
1925 struct nfsd4_compoundres *resp = rqstp->rq_resp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926 struct nfsd4_op *op;
Andy Adamsone354d572009-03-28 11:30:52 +03001927 struct nfsd4_compound_state *cstate = &resp->cstate;
Kinglong Mee4daeed22014-03-26 17:10:37 +08001928 struct svc_fh *current_fh = &cstate->current_fh;
1929 struct svc_fh *save_fh = &cstate->save_fh;
Trond Myklebuste333f3b2019-04-09 11:46:19 -04001930 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
Al Virob37ad282006-10-19 23:28:59 -07001931 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001932
J. Bruce Fields2d124dfaa2014-01-15 16:26:42 -05001933 svcxdr_init_encode(rqstp, resp);
J. Bruce Fields4aea24b2014-01-15 15:17:58 -05001934 resp->tagp = resp->xdr.p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935 /* reserve space for: taglen, tag, and opcnt */
J. Bruce Fieldsd3f627c2014-02-26 17:00:38 -05001936 xdr_reserve_space(&resp->xdr, 8 + args->taglen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937 resp->taglen = args->taglen;
1938 resp->tag = args->tag;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939 resp->rqstp = rqstp;
Kinglong Mee4daeed22014-03-26 17:10:37 +08001940 cstate->minorversion = args->minorversion;
Kinglong Mee4daeed22014-03-26 17:10:37 +08001941 fh_init(current_fh, NFS4_FHSIZE);
1942 fh_init(save_fh, NFS4_FHSIZE);
NeilBrown8ff30fa2010-08-12 17:04:07 +10001943 /*
1944 * Don't use the deferral mechanism for NFSv4; compounds make it
1945 * too hard to avoid non-idempotency problems.
1946 */
Jeff Layton30660e04b2014-11-19 07:51:16 -05001947 clear_bit(RQ_USEDEFERRAL, &rqstp->rq_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948
1949 /*
1950 * According to RFC3010, this takes precedence over all other errors.
1951 */
1952 status = nfserr_minor_vers_mismatch;
Trond Myklebuste333f3b2019-04-09 11:46:19 -04001953 if (nfsd_minorversion(nn, args->minorversion, NFSD_TEST) <= 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954 goto out;
J. Bruce Fields00781172017-11-15 12:30:27 -05001955 status = nfserr_resource;
1956 if (args->opcnt > NFSD_MAX_OPS_PER_COMPOUND)
1957 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958
J. Bruce Fields57716352010-04-21 12:27:19 -04001959 status = nfs41_check_op_ordering(args);
1960 if (status) {
Andy Adamsonf9bb94c42009-04-03 08:28:12 +03001961 op = &args->ops[0];
J. Bruce Fields57716352010-04-21 12:27:19 -04001962 op->status = status;
J. Bruce Fields5b7b15ae2018-06-13 15:21:35 -04001963 resp->opcnt = 1;
Andy Adamsonf9bb94c42009-04-03 08:28:12 +03001964 goto encode_op;
1965 }
1966
Chuck Leverfff40802018-03-27 10:53:54 -04001967 trace_nfsd_compound(rqstp, args->opcnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968 while (!status && resp->opcnt < args->opcnt) {
1969 op = &args->ops[resp->opcnt++];
1970
1971 /*
1972 * The XDR decode routines may have pre-set op->status;
1973 * for example, if there is a miscellaneous XDR error
1974 * it will be set to nfserr_bad_xdr.
1975 */
J. Bruce Fields9d313b12013-02-28 12:51:49 -08001976 if (op->status) {
1977 if (op->opnum == OP_OPEN)
1978 op->status = nfsd4_open_omfg(rqstp, cstate, op);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979 goto encode_op;
J. Bruce Fields9d313b12013-02-28 12:51:49 -08001980 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981
Kinglong Mee4daeed22014-03-26 17:10:37 +08001982 if (!current_fh->fh_dentry) {
J. Bruce Fieldsf4f9ef42017-07-06 17:51:29 -04001983 if (!(op->opdesc->op_flags & ALLOWED_WITHOUT_FH)) {
J.Bruce Fields42ca0992006-10-04 02:16:20 -07001984 op->status = nfserr_nofilehandle;
1985 goto encode_op;
1986 }
Kinglong Mee4daeed22014-03-26 17:10:37 +08001987 } else if (current_fh->fh_export->ex_fslocs.migrated &&
J. Bruce Fieldsf4f9ef42017-07-06 17:51:29 -04001988 !(op->opdesc->op_flags & ALLOWED_ON_ABSENT_FS)) {
J.Bruce Fields42ca0992006-10-04 02:16:20 -07001989 op->status = nfserr_moved;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001990 goto encode_op;
1991 }
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08001992
Kinglong Mee23367452014-03-29 10:23:47 +08001993 fh_clear_wcc(current_fh);
1994
Mi Jinlong58e7b332011-08-28 18:18:56 +08001995 /* If op is non-idempotent */
J. Bruce Fieldsf4f9ef42017-07-06 17:51:29 -04001996 if (op->opdesc->op_flags & OP_MODIFIES_SOMETHING) {
J. Bruce Fields4c69d582014-01-28 16:01:04 -05001997 /*
J. Bruce Fieldsa8095f72014-03-11 17:54:34 -04001998 * Don't execute this op if we couldn't encode a
1999 * succesful reply:
2000 */
J. Bruce Fieldsf4f9ef42017-07-06 17:51:29 -04002001 u32 plen = op->opdesc->op_rsize_bop(rqstp, op);
J. Bruce Fieldsa8095f72014-03-11 17:54:34 -04002002 /*
2003 * Plus if there's another operation, make sure
J. Bruce Fields4c69d582014-01-28 16:01:04 -05002004 * we'll have space to at least encode an error:
2005 */
2006 if (resp->opcnt < args->opcnt)
2007 plen += COMPOUND_ERR_SLACK_SPACE;
Mi Jinlong58e7b332011-08-28 18:18:56 +08002008 op->status = nfsd4_check_resp_size(resp, plen);
2009 }
2010
2011 if (op->status)
2012 goto encode_op;
2013
J. Bruce Fieldsf4f9ef42017-07-06 17:51:29 -04002014 if (op->opdesc->op_get_currentstateid)
2015 op->opdesc->op_get_currentstateid(cstate, &op->u);
2016 op->status = op->opdesc->op_func(rqstp, cstate, &op->u);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017
J. Bruce Fields9a307402017-05-23 12:24:40 -04002018 /* Only from SEQUENCE */
2019 if (cstate->status == nfserr_replay_cache) {
2020 dprintk("%s NFS4.1 replay from cache\n", __func__);
2021 status = op->status;
2022 goto out;
2023 }
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01002024 if (!op->status) {
J. Bruce Fieldsf4f9ef42017-07-06 17:51:29 -04002025 if (op->opdesc->op_set_currentstateid)
2026 op->opdesc->op_set_currentstateid(cstate, &op->u);
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01002027
J. Bruce Fieldsf4f9ef42017-07-06 17:51:29 -04002028 if (op->opdesc->op_flags & OP_CLEAR_STATEID)
Tigran Mkrtchyan37c593c2012-02-13 22:55:32 +01002029 clear_current_stateid(cstate);
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01002030
2031 if (need_wrongsec_check(rqstp))
Kinglong Mee4daeed22014-03-26 17:10:37 +08002032 op->status = check_nfsd_access(current_fh->fh_export, rqstp);
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01002033 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002034encode_op:
Al Viroa90b0612006-10-19 23:29:03 -07002035 if (op->status == nfserr_replay_me) {
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08002036 op->replay = &cstate->replay_owner->so_replay;
J. Bruce Fieldsd0a381d2014-01-30 17:18:38 -05002037 nfsd4_encode_replay(&resp->xdr, op);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002038 status = op->status = op->replay->rp_status;
2039 } else {
2040 nfsd4_encode_operation(resp, op);
2041 status = op->status;
2042 }
Benny Halevy04077172008-12-15 19:40:49 +02002043
Chuck Leverfff40802018-03-27 10:53:54 -04002044 trace_nfsd_compound_status(args->opcnt, resp->opcnt, status,
2045 nfsd4_op_name(op->opnum));
Benny Halevy04077172008-12-15 19:40:49 +02002046
Jeff Layton58fb12e2014-07-29 21:34:27 -04002047 nfsd4_cstate_clear_replay(cstate);
Shankar Anande2b20952006-07-10 04:45:44 -07002048 nfsd4_increment_op_stats(op->opnum);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002049 }
2050
Kinglong Mee4daeed22014-03-26 17:10:37 +08002051 cstate->status = status;
2052 fh_put(current_fh);
2053 fh_put(save_fh);
2054 BUG_ON(cstate->replay_owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002055out:
Andy Adamson2f425872009-04-03 08:27:32 +03002056 /* Reset deferral mechanism for RPC deferrals */
Jeff Layton30660e04b2014-11-19 07:51:16 -05002057 set_bit(RQ_USEDEFERRAL, &rqstp->rq_flags);
J. Bruce Fields3b12cd92008-05-05 17:17:44 -04002058 dprintk("nfsv4 compound returned %d\n", ntohl(status));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002059 return status;
2060}
2061
Mi Jinlong58e7b332011-08-28 18:18:56 +08002062#define op_encode_hdr_size (2)
2063#define op_encode_stateid_maxsz (XDR_QUADLEN(NFS4_STATEID_SIZE))
2064#define op_encode_verifier_maxsz (XDR_QUADLEN(NFS4_VERIFIER_SIZE))
2065#define op_encode_change_info_maxsz (5)
2066#define nfs4_fattr_bitmap_maxsz (4)
2067
J. Bruce Fields8c7424c2014-03-10 12:19:10 -04002068/* We'll fall back on returning no lockowner if run out of space: */
2069#define op_encode_lockowner_maxsz (0)
Mi Jinlong58e7b332011-08-28 18:18:56 +08002070#define op_encode_lock_denied_maxsz (8 + op_encode_lockowner_maxsz)
2071
2072#define nfs4_owner_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ))
2073
2074#define op_encode_ace_maxsz (3 + nfs4_owner_maxsz)
2075#define op_encode_delegation_maxsz (1 + op_encode_stateid_maxsz + 1 + \
2076 op_encode_ace_maxsz)
2077
2078#define op_encode_channel_attrs_maxsz (6 + 1 + 1)
2079
2080static inline u32 nfsd4_only_status_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2081{
2082 return (op_encode_hdr_size) * sizeof(__be32);
2083}
2084
2085static inline u32 nfsd4_status_stateid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2086{
2087 return (op_encode_hdr_size + op_encode_stateid_maxsz)* sizeof(__be32);
2088}
2089
Kinglong Mee2282cd22017-02-03 22:36:00 +08002090static inline u32 nfsd4_access_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2091{
2092 /* ac_supported, ac_resp_access */
2093 return (op_encode_hdr_size + 2)* sizeof(__be32);
2094}
2095
Mi Jinlong58e7b332011-08-28 18:18:56 +08002096static inline u32 nfsd4_commit_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2097{
2098 return (op_encode_hdr_size + op_encode_verifier_maxsz) * sizeof(__be32);
2099}
2100
2101static inline u32 nfsd4_create_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2102{
2103 return (op_encode_hdr_size + op_encode_change_info_maxsz
2104 + nfs4_fattr_bitmap_maxsz) * sizeof(__be32);
2105}
2106
J. Bruce Fieldsb86cef62014-03-23 12:01:48 -04002107/*
2108 * Note since this is an idempotent operation we won't insist on failing
2109 * the op prematurely if the estimate is too large. We may turn off splice
2110 * reads unnecessarily.
2111 */
2112static inline u32 nfsd4_getattr_rsize(struct svc_rqst *rqstp,
2113 struct nfsd4_op *op)
2114{
2115 u32 *bmap = op->u.getattr.ga_bmval;
2116 u32 bmap0 = bmap[0], bmap1 = bmap[1], bmap2 = bmap[2];
2117 u32 ret = 0;
2118
2119 if (bmap0 & FATTR4_WORD0_ACL)
2120 return svc_max_payload(rqstp);
2121 if (bmap0 & FATTR4_WORD0_FS_LOCATIONS)
2122 return svc_max_payload(rqstp);
2123
2124 if (bmap1 & FATTR4_WORD1_OWNER) {
2125 ret += IDMAP_NAMESZ + 4;
2126 bmap1 &= ~FATTR4_WORD1_OWNER;
2127 }
2128 if (bmap1 & FATTR4_WORD1_OWNER_GROUP) {
2129 ret += IDMAP_NAMESZ + 4;
2130 bmap1 &= ~FATTR4_WORD1_OWNER_GROUP;
2131 }
2132 if (bmap0 & FATTR4_WORD0_FILEHANDLE) {
2133 ret += NFS4_FHSIZE + 4;
2134 bmap0 &= ~FATTR4_WORD0_FILEHANDLE;
2135 }
2136 if (bmap2 & FATTR4_WORD2_SECURITY_LABEL) {
Kinglong Mee1ec8c0c2015-03-28 23:46:09 +08002137 ret += NFS4_MAXLABELLEN + 12;
J. Bruce Fieldsb86cef62014-03-23 12:01:48 -04002138 bmap2 &= ~FATTR4_WORD2_SECURITY_LABEL;
2139 }
2140 /*
2141 * Largest of remaining attributes are 16 bytes (e.g.,
2142 * supported_attributes)
2143 */
2144 ret += 16 * (hweight32(bmap0) + hweight32(bmap1) + hweight32(bmap2));
2145 /* bitmask, length */
2146 ret += 20;
2147 return ret;
2148}
2149
Kinglong Mee2282cd22017-02-03 22:36:00 +08002150static inline u32 nfsd4_getfh_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2151{
2152 return (op_encode_hdr_size + 1) * sizeof(__be32) + NFS4_FHSIZE;
2153}
2154
Mi Jinlong58e7b332011-08-28 18:18:56 +08002155static inline u32 nfsd4_link_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2156{
2157 return (op_encode_hdr_size + op_encode_change_info_maxsz)
2158 * sizeof(__be32);
2159}
2160
2161static inline u32 nfsd4_lock_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2162{
2163 return (op_encode_hdr_size + op_encode_lock_denied_maxsz)
2164 * sizeof(__be32);
2165}
2166
2167static inline u32 nfsd4_open_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2168{
2169 return (op_encode_hdr_size + op_encode_stateid_maxsz
2170 + op_encode_change_info_maxsz + 1
2171 + nfs4_fattr_bitmap_maxsz
2172 + op_encode_delegation_maxsz) * sizeof(__be32);
2173}
2174
2175static inline u32 nfsd4_read_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2176{
2177 u32 maxcount = 0, rlen = 0;
2178
2179 maxcount = svc_max_payload(rqstp);
Kinglong Mee3c7aa152014-06-10 18:08:19 +08002180 rlen = min(op->u.read.rd_length, maxcount);
Mi Jinlong58e7b332011-08-28 18:18:56 +08002181
J. Bruce Fields622f5602014-05-16 14:38:20 -04002182 return (op_encode_hdr_size + 2 + XDR_QUADLEN(rlen)) * sizeof(__be32);
Mi Jinlong58e7b332011-08-28 18:18:56 +08002183}
2184
2185static inline u32 nfsd4_readdir_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2186{
Kinglong Mee3c7aa152014-06-10 18:08:19 +08002187 u32 maxcount = 0, rlen = 0;
Mi Jinlong58e7b332011-08-28 18:18:56 +08002188
Kinglong Mee3c7aa152014-06-10 18:08:19 +08002189 maxcount = svc_max_payload(rqstp);
2190 rlen = min(op->u.readdir.rd_maxcount, maxcount);
Mi Jinlong58e7b332011-08-28 18:18:56 +08002191
J. Bruce Fields561f0ed2014-01-20 16:37:11 -05002192 return (op_encode_hdr_size + op_encode_verifier_maxsz +
2193 XDR_QUADLEN(rlen)) * sizeof(__be32);
Mi Jinlong58e7b332011-08-28 18:18:56 +08002194}
2195
Kinglong Mee2282cd22017-02-03 22:36:00 +08002196static inline u32 nfsd4_readlink_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2197{
2198 return (op_encode_hdr_size + 1) * sizeof(__be32) + PAGE_SIZE;
2199}
2200
Mi Jinlong58e7b332011-08-28 18:18:56 +08002201static inline u32 nfsd4_remove_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2202{
2203 return (op_encode_hdr_size + op_encode_change_info_maxsz)
2204 * sizeof(__be32);
2205}
2206
2207static inline u32 nfsd4_rename_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2208{
2209 return (op_encode_hdr_size + op_encode_change_info_maxsz
2210 + op_encode_change_info_maxsz) * sizeof(__be32);
2211}
2212
J. Bruce Fieldsccae70a2014-03-23 09:34:22 -07002213static inline u32 nfsd4_sequence_rsize(struct svc_rqst *rqstp,
2214 struct nfsd4_op *op)
2215{
J. Bruce Fieldsd1d84c92014-08-21 15:04:31 -04002216 return (op_encode_hdr_size
2217 + XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + 5) * sizeof(__be32);
J. Bruce Fieldsccae70a2014-03-23 09:34:22 -07002218}
2219
Kinglong Mee2282cd22017-02-03 22:36:00 +08002220static inline u32 nfsd4_test_stateid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2221{
2222 return (op_encode_hdr_size + 1 + op->u.test_stateid.ts_num_ids)
2223 * sizeof(__be32);
2224}
2225
Mi Jinlong58e7b332011-08-28 18:18:56 +08002226static inline u32 nfsd4_setattr_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2227{
2228 return (op_encode_hdr_size + nfs4_fattr_bitmap_maxsz) * sizeof(__be32);
2229}
2230
Kinglong Mee2282cd22017-02-03 22:36:00 +08002231static inline u32 nfsd4_secinfo_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2232{
2233 return (op_encode_hdr_size + RPC_AUTH_MAXFLAVOR *
2234 (4 + XDR_QUADLEN(GSS_OID_MAX_LEN))) * sizeof(__be32);
2235}
2236
Mi Jinlong58e7b332011-08-28 18:18:56 +08002237static inline u32 nfsd4_setclientid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2238{
J. Bruce Fields480efae2014-03-10 14:17:55 -04002239 return (op_encode_hdr_size + 2 + XDR_QUADLEN(NFS4_VERIFIER_SIZE)) *
2240 sizeof(__be32);
Mi Jinlong58e7b332011-08-28 18:18:56 +08002241}
2242
2243static inline u32 nfsd4_write_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2244{
J. Bruce Fieldsf34e4322014-05-16 21:24:56 -04002245 return (op_encode_hdr_size + 2 + op_encode_verifier_maxsz) * sizeof(__be32);
Mi Jinlong58e7b332011-08-28 18:18:56 +08002246}
2247
2248static inline u32 nfsd4_exchange_id_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2249{
2250 return (op_encode_hdr_size + 2 + 1 + /* eir_clientid, eir_sequenceid */\
Kinglong Meea8bb84b2013-12-10 15:24:36 +08002251 1 + 1 + /* eir_flags, spr_how */\
2252 4 + /* spo_must_enforce & _allow with bitmap */\
Mi Jinlong58e7b332011-08-28 18:18:56 +08002253 2 + /*eir_server_owner.so_minor_id */\
2254 /* eir_server_owner.so_major_id<> */\
2255 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 +\
2256 /* eir_server_scope<> */\
2257 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 +\
2258 1 + /* eir_server_impl_id array length */\
2259 0 /* ignored eir_server_impl_id contents */) * sizeof(__be32);
2260}
2261
2262static inline u32 nfsd4_bind_conn_to_session_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2263{
2264 return (op_encode_hdr_size + \
2265 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + /* bctsr_sessid */\
2266 2 /* bctsr_dir, use_conn_in_rdma_mode */) * sizeof(__be32);
2267}
2268
2269static inline u32 nfsd4_create_session_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2270{
2271 return (op_encode_hdr_size + \
2272 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + /* sessionid */\
2273 2 + /* csr_sequence, csr_flags */\
2274 op_encode_channel_attrs_maxsz + \
2275 op_encode_channel_attrs_maxsz) * sizeof(__be32);
2276}
2277
Anna Schumaker29ae7f92016-09-07 15:57:30 -04002278static inline u32 nfsd4_copy_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2279{
2280 return (op_encode_hdr_size +
2281 1 /* wr_callback */ +
2282 op_encode_stateid_maxsz /* wr_callback */ +
2283 2 /* wr_count */ +
2284 1 /* wr_committed */ +
2285 op_encode_verifier_maxsz +
2286 1 /* cr_consecutive */ +
2287 1 /* cr_synchronous */) * sizeof(__be32);
2288}
2289
Olga Kornievskaia6308bc92018-07-20 18:19:18 -04002290static inline u32 nfsd4_offload_status_rsize(struct svc_rqst *rqstp,
2291 struct nfsd4_op *op)
2292{
2293 return (op_encode_hdr_size +
2294 2 /* osr_count */ +
2295 1 /* osr_complete<1> optional 0 for now */) * sizeof(__be32);
2296}
2297
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02002298#ifdef CONFIG_NFSD_PNFS
Kinglong Mee2282cd22017-02-03 22:36:00 +08002299static inline u32 nfsd4_getdeviceinfo_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2300{
2301 u32 maxcount = 0, rlen = 0;
2302
2303 maxcount = svc_max_payload(rqstp);
2304 rlen = min(op->u.getdeviceinfo.gd_maxcount, maxcount);
2305
2306 return (op_encode_hdr_size +
2307 1 /* gd_layout_type*/ +
2308 XDR_QUADLEN(rlen) +
2309 2 /* gd_notify_types */) * sizeof(__be32);
2310}
2311
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02002312/*
2313 * At this stage we don't really know what layout driver will handle the request,
2314 * so we need to define an arbitrary upper bound here.
2315 */
2316#define MAX_LAYOUT_SIZE 128
2317static inline u32 nfsd4_layoutget_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2318{
2319 return (op_encode_hdr_size +
2320 1 /* logr_return_on_close */ +
2321 op_encode_stateid_maxsz +
2322 1 /* nr of layouts */ +
2323 MAX_LAYOUT_SIZE) * sizeof(__be32);
2324}
2325
2326static inline u32 nfsd4_layoutcommit_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2327{
2328 return (op_encode_hdr_size +
2329 1 /* locr_newsize */ +
2330 2 /* ns_size */) * sizeof(__be32);
2331}
2332
2333static inline u32 nfsd4_layoutreturn_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2334{
2335 return (op_encode_hdr_size +
2336 1 /* lrs_stateid */ +
2337 op_encode_stateid_maxsz) * sizeof(__be32);
2338}
2339#endif /* CONFIG_NFSD_PNFS */
2340
Kinglong Mee2282cd22017-02-03 22:36:00 +08002341
2342static inline u32 nfsd4_seek_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2343{
2344 return (op_encode_hdr_size + 3) * sizeof(__be32);
2345}
2346
Christoph Hellwigbb2a8b02017-05-08 23:46:47 +02002347static const struct nfsd4_operation nfsd4_ops[] = {
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002348 [OP_ACCESS] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002349 .op_func = nfsd4_access,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002350 .op_name = "OP_ACCESS",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002351 .op_rsize_bop = nfsd4_access_rsize,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002352 },
2353 [OP_CLOSE] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002354 .op_func = nfsd4_close,
Mi Jinlong58e7b332011-08-28 18:18:56 +08002355 .op_flags = OP_MODIFIES_SOMETHING,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002356 .op_name = "OP_CLOSE",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002357 .op_rsize_bop = nfsd4_status_stateid_rsize,
Christoph Hellwig57832e72017-05-08 20:37:33 +02002358 .op_get_currentstateid = nfsd4_get_closestateid,
Christoph Hellwigb60e9852017-05-08 20:03:15 +02002359 .op_set_currentstateid = nfsd4_set_closestateid,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002360 },
2361 [OP_COMMIT] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002362 .op_func = nfsd4_commit,
Mi Jinlong58e7b332011-08-28 18:18:56 +08002363 .op_flags = OP_MODIFIES_SOMETHING,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002364 .op_name = "OP_COMMIT",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002365 .op_rsize_bop = nfsd4_commit_rsize,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002366 },
2367 [OP_CREATE] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002368 .op_func = nfsd4_create,
Tigran Mkrtchyand1471052012-02-13 22:55:29 +01002369 .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME | OP_CLEAR_STATEID,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002370 .op_name = "OP_CREATE",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002371 .op_rsize_bop = nfsd4_create_rsize,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002372 },
2373 [OP_DELEGRETURN] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002374 .op_func = nfsd4_delegreturn,
Mi Jinlong58e7b332011-08-28 18:18:56 +08002375 .op_flags = OP_MODIFIES_SOMETHING,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002376 .op_name = "OP_DELEGRETURN",
Mi Jinlong58e7b332011-08-28 18:18:56 +08002377 .op_rsize_bop = nfsd4_only_status_rsize,
Christoph Hellwig57832e72017-05-08 20:37:33 +02002378 .op_get_currentstateid = nfsd4_get_delegreturnstateid,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002379 },
2380 [OP_GETATTR] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002381 .op_func = nfsd4_getattr,
J.Bruce Fieldseeac2942006-12-13 00:35:39 -08002382 .op_flags = ALLOWED_ON_ABSENT_FS,
J. Bruce Fieldsb86cef62014-03-23 12:01:48 -04002383 .op_rsize_bop = nfsd4_getattr_rsize,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002384 .op_name = "OP_GETATTR",
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002385 },
2386 [OP_GETFH] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002387 .op_func = nfsd4_getfh,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002388 .op_name = "OP_GETFH",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002389 .op_rsize_bop = nfsd4_getfh_rsize,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002390 },
2391 [OP_LINK] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002392 .op_func = nfsd4_link,
J. Bruce Fieldsc8566942011-09-20 08:49:51 -04002393 .op_flags = ALLOWED_ON_ABSENT_FS | OP_MODIFIES_SOMETHING
2394 | OP_CACHEME,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002395 .op_name = "OP_LINK",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002396 .op_rsize_bop = nfsd4_link_rsize,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002397 },
2398 [OP_LOCK] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002399 .op_func = nfsd4_lock,
J. Bruce Fieldsb7571e42017-05-06 10:49:21 -04002400 .op_flags = OP_MODIFIES_SOMETHING |
2401 OP_NONTRIVIAL_ERROR_ENCODE,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002402 .op_name = "OP_LOCK",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002403 .op_rsize_bop = nfsd4_lock_rsize,
Christoph Hellwigb60e9852017-05-08 20:03:15 +02002404 .op_set_currentstateid = nfsd4_set_lockstateid,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002405 },
2406 [OP_LOCKT] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002407 .op_func = nfsd4_lockt,
J. Bruce Fieldsb7571e42017-05-06 10:49:21 -04002408 .op_flags = OP_NONTRIVIAL_ERROR_ENCODE,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002409 .op_name = "OP_LOCKT",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002410 .op_rsize_bop = nfsd4_lock_rsize,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002411 },
2412 [OP_LOCKU] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002413 .op_func = nfsd4_locku,
Mi Jinlong58e7b332011-08-28 18:18:56 +08002414 .op_flags = OP_MODIFIES_SOMETHING,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002415 .op_name = "OP_LOCKU",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002416 .op_rsize_bop = nfsd4_status_stateid_rsize,
Christoph Hellwig57832e72017-05-08 20:37:33 +02002417 .op_get_currentstateid = nfsd4_get_lockustateid,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002418 },
2419 [OP_LOOKUP] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002420 .op_func = nfsd4_lookup,
Tigran Mkrtchyand1471052012-02-13 22:55:29 +01002421 .op_flags = OP_HANDLES_WRONGSEC | OP_CLEAR_STATEID,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002422 .op_name = "OP_LOOKUP",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002423 .op_rsize_bop = nfsd4_only_status_rsize,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002424 },
2425 [OP_LOOKUPP] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002426 .op_func = nfsd4_lookupp,
Tigran Mkrtchyand1471052012-02-13 22:55:29 +01002427 .op_flags = OP_HANDLES_WRONGSEC | OP_CLEAR_STATEID,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002428 .op_name = "OP_LOOKUPP",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002429 .op_rsize_bop = nfsd4_only_status_rsize,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002430 },
2431 [OP_NVERIFY] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002432 .op_func = nfsd4_nverify,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002433 .op_name = "OP_NVERIFY",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002434 .op_rsize_bop = nfsd4_only_status_rsize,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002435 },
2436 [OP_OPEN] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002437 .op_func = nfsd4_open,
Mi Jinlong58e7b332011-08-28 18:18:56 +08002438 .op_flags = OP_HANDLES_WRONGSEC | OP_MODIFIES_SOMETHING,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002439 .op_name = "OP_OPEN",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002440 .op_rsize_bop = nfsd4_open_rsize,
Christoph Hellwigb60e9852017-05-08 20:03:15 +02002441 .op_set_currentstateid = nfsd4_set_openstateid,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002442 },
2443 [OP_OPEN_CONFIRM] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002444 .op_func = nfsd4_open_confirm,
Mi Jinlong58e7b332011-08-28 18:18:56 +08002445 .op_flags = OP_MODIFIES_SOMETHING,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002446 .op_name = "OP_OPEN_CONFIRM",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002447 .op_rsize_bop = nfsd4_status_stateid_rsize,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002448 },
2449 [OP_OPEN_DOWNGRADE] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002450 .op_func = nfsd4_open_downgrade,
Mi Jinlong58e7b332011-08-28 18:18:56 +08002451 .op_flags = OP_MODIFIES_SOMETHING,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002452 .op_name = "OP_OPEN_DOWNGRADE",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002453 .op_rsize_bop = nfsd4_status_stateid_rsize,
Christoph Hellwig57832e72017-05-08 20:37:33 +02002454 .op_get_currentstateid = nfsd4_get_opendowngradestateid,
Christoph Hellwigb60e9852017-05-08 20:03:15 +02002455 .op_set_currentstateid = nfsd4_set_opendowngradestateid,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002456 },
2457 [OP_PUTFH] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002458 .op_func = nfsd4_putfh,
J. Bruce Fields68d93182011-04-08 17:00:50 -04002459 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
J. Bruce Fields5b648692014-03-07 11:43:58 -05002460 | OP_IS_PUTFH_LIKE | OP_CLEAR_STATEID,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002461 .op_name = "OP_PUTFH",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002462 .op_rsize_bop = nfsd4_only_status_rsize,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002463 },
J.Bruce Fieldseeac2942006-12-13 00:35:39 -08002464 [OP_PUTPUBFH] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002465 .op_func = nfsd4_putrootfh,
J. Bruce Fields68d93182011-04-08 17:00:50 -04002466 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
J. Bruce Fields5b648692014-03-07 11:43:58 -05002467 | OP_IS_PUTFH_LIKE | OP_CLEAR_STATEID,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002468 .op_name = "OP_PUTPUBFH",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002469 .op_rsize_bop = nfsd4_only_status_rsize,
J.Bruce Fieldseeac2942006-12-13 00:35:39 -08002470 },
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002471 [OP_PUTROOTFH] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002472 .op_func = nfsd4_putrootfh,
J. Bruce Fields68d93182011-04-08 17:00:50 -04002473 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
J. Bruce Fields5b648692014-03-07 11:43:58 -05002474 | OP_IS_PUTFH_LIKE | OP_CLEAR_STATEID,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002475 .op_name = "OP_PUTROOTFH",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002476 .op_rsize_bop = nfsd4_only_status_rsize,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002477 },
2478 [OP_READ] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002479 .op_func = nfsd4_read,
J. Bruce Fields34b1744c2017-05-05 17:09:37 -04002480 .op_release = nfsd4_read_release,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002481 .op_name = "OP_READ",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002482 .op_rsize_bop = nfsd4_read_rsize,
Christoph Hellwig57832e72017-05-08 20:37:33 +02002483 .op_get_currentstateid = nfsd4_get_readstateid,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002484 },
2485 [OP_READDIR] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002486 .op_func = nfsd4_readdir,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002487 .op_name = "OP_READDIR",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002488 .op_rsize_bop = nfsd4_readdir_rsize,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002489 },
2490 [OP_READLINK] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002491 .op_func = nfsd4_readlink,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002492 .op_name = "OP_READLINK",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002493 .op_rsize_bop = nfsd4_readlink_rsize,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002494 },
2495 [OP_REMOVE] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002496 .op_func = nfsd4_remove,
J. Bruce Fieldsc8566942011-09-20 08:49:51 -04002497 .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002498 .op_name = "OP_REMOVE",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002499 .op_rsize_bop = nfsd4_remove_rsize,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002500 },
2501 [OP_RENAME] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002502 .op_func = nfsd4_rename,
J. Bruce Fieldsc8566942011-09-20 08:49:51 -04002503 .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
Mi Jinlong58e7b332011-08-28 18:18:56 +08002504 .op_name = "OP_RENAME",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002505 .op_rsize_bop = nfsd4_rename_rsize,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002506 },
2507 [OP_RENEW] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002508 .op_func = nfsd4_renew,
Mi Jinlong58e7b332011-08-28 18:18:56 +08002509 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2510 | OP_MODIFIES_SOMETHING,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002511 .op_name = "OP_RENEW",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002512 .op_rsize_bop = nfsd4_only_status_rsize,
Mi Jinlong58e7b332011-08-28 18:18:56 +08002513
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002514 },
2515 [OP_RESTOREFH] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002516 .op_func = nfsd4_restorefh,
J. Bruce Fields68d93182011-04-08 17:00:50 -04002517 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
Mi Jinlong58e7b332011-08-28 18:18:56 +08002518 | OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002519 .op_name = "OP_RESTOREFH",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002520 .op_rsize_bop = nfsd4_only_status_rsize,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002521 },
2522 [OP_SAVEFH] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002523 .op_func = nfsd4_savefh,
Mi Jinlong58e7b332011-08-28 18:18:56 +08002524 .op_flags = OP_HANDLES_WRONGSEC | OP_MODIFIES_SOMETHING,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002525 .op_name = "OP_SAVEFH",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002526 .op_rsize_bop = nfsd4_only_status_rsize,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002527 },
Andy Adamsondcb488a32007-07-17 04:04:51 -07002528 [OP_SECINFO] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002529 .op_func = nfsd4_secinfo,
J. Bruce Fields34b1744c2017-05-05 17:09:37 -04002530 .op_release = nfsd4_secinfo_release,
J. Bruce Fields68d93182011-04-08 17:00:50 -04002531 .op_flags = OP_HANDLES_WRONGSEC,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002532 .op_name = "OP_SECINFO",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002533 .op_rsize_bop = nfsd4_secinfo_rsize,
Andy Adamsondcb488a32007-07-17 04:04:51 -07002534 },
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002535 [OP_SETATTR] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002536 .op_func = nfsd4_setattr,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002537 .op_name = "OP_SETATTR",
J. Bruce Fieldsb7571e42017-05-06 10:49:21 -04002538 .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME
2539 | OP_NONTRIVIAL_ERROR_ENCODE,
Christoph Hellwig1c122632017-05-08 20:42:10 +02002540 .op_rsize_bop = nfsd4_setattr_rsize,
Christoph Hellwig57832e72017-05-08 20:37:33 +02002541 .op_get_currentstateid = nfsd4_get_setattrstateid,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002542 },
2543 [OP_SETCLIENTID] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002544 .op_func = nfsd4_setclientid,
Mi Jinlong58e7b332011-08-28 18:18:56 +08002545 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
J. Bruce Fieldsb7571e42017-05-06 10:49:21 -04002546 | OP_MODIFIES_SOMETHING | OP_CACHEME
2547 | OP_NONTRIVIAL_ERROR_ENCODE,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002548 .op_name = "OP_SETCLIENTID",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002549 .op_rsize_bop = nfsd4_setclientid_rsize,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002550 },
2551 [OP_SETCLIENTID_CONFIRM] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002552 .op_func = nfsd4_setclientid_confirm,
Mi Jinlong58e7b332011-08-28 18:18:56 +08002553 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
J. Bruce Fieldsc8566942011-09-20 08:49:51 -04002554 | OP_MODIFIES_SOMETHING | OP_CACHEME,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002555 .op_name = "OP_SETCLIENTID_CONFIRM",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002556 .op_rsize_bop = nfsd4_only_status_rsize,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002557 },
2558 [OP_VERIFY] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002559 .op_func = nfsd4_verify,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002560 .op_name = "OP_VERIFY",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002561 .op_rsize_bop = nfsd4_only_status_rsize,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002562 },
2563 [OP_WRITE] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002564 .op_func = nfsd4_write,
J. Bruce Fieldsc8566942011-09-20 08:49:51 -04002565 .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002566 .op_name = "OP_WRITE",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002567 .op_rsize_bop = nfsd4_write_rsize,
Christoph Hellwig57832e72017-05-08 20:37:33 +02002568 .op_get_currentstateid = nfsd4_get_writestateid,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002569 },
2570 [OP_RELEASE_LOCKOWNER] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002571 .op_func = nfsd4_release_lockowner,
Mi Jinlong58e7b332011-08-28 18:18:56 +08002572 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2573 | OP_MODIFIES_SOMETHING,
Benny Halevyb001a1b2008-07-02 11:15:03 +03002574 .op_name = "OP_RELEASE_LOCKOWNER",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002575 .op_rsize_bop = nfsd4_only_status_rsize,
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002576 },
Andy Adamson069b6ad2009-04-03 08:27:58 +03002577
2578 /* NFSv4.1 operations */
2579 [OP_EXCHANGE_ID] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002580 .op_func = nfsd4_exchange_id,
Mi Jinlong58e7b332011-08-28 18:18:56 +08002581 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
2582 | OP_MODIFIES_SOMETHING,
Andy Adamson069b6ad2009-04-03 08:27:58 +03002583 .op_name = "OP_EXCHANGE_ID",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002584 .op_rsize_bop = nfsd4_exchange_id_rsize,
Andy Adamson069b6ad2009-04-03 08:27:58 +03002585 },
J. Bruce Fieldscb73a9f2012-11-01 18:09:48 -04002586 [OP_BACKCHANNEL_CTL] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002587 .op_func = nfsd4_backchannel_ctl,
J. Bruce Fieldscb73a9f2012-11-01 18:09:48 -04002588 .op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING,
2589 .op_name = "OP_BACKCHANNEL_CTL",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002590 .op_rsize_bop = nfsd4_only_status_rsize,
J. Bruce Fieldscb73a9f2012-11-01 18:09:48 -04002591 },
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04002592 [OP_BIND_CONN_TO_SESSION] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002593 .op_func = nfsd4_bind_conn_to_session,
Mi Jinlong58e7b332011-08-28 18:18:56 +08002594 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
2595 | OP_MODIFIES_SOMETHING,
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04002596 .op_name = "OP_BIND_CONN_TO_SESSION",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002597 .op_rsize_bop = nfsd4_bind_conn_to_session_rsize,
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04002598 },
Andy Adamson069b6ad2009-04-03 08:27:58 +03002599 [OP_CREATE_SESSION] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002600 .op_func = nfsd4_create_session,
Mi Jinlong58e7b332011-08-28 18:18:56 +08002601 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
2602 | OP_MODIFIES_SOMETHING,
Andy Adamson069b6ad2009-04-03 08:27:58 +03002603 .op_name = "OP_CREATE_SESSION",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002604 .op_rsize_bop = nfsd4_create_session_rsize,
Andy Adamson069b6ad2009-04-03 08:27:58 +03002605 },
2606 [OP_DESTROY_SESSION] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002607 .op_func = nfsd4_destroy_session,
Mi Jinlong58e7b332011-08-28 18:18:56 +08002608 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
2609 | OP_MODIFIES_SOMETHING,
Andy Adamson069b6ad2009-04-03 08:27:58 +03002610 .op_name = "OP_DESTROY_SESSION",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002611 .op_rsize_bop = nfsd4_only_status_rsize,
Andy Adamson069b6ad2009-04-03 08:27:58 +03002612 },
2613 [OP_SEQUENCE] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002614 .op_func = nfsd4_sequence,
Andy Adamsonf9bb94c42009-04-03 08:28:12 +03002615 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP,
Andy Adamson069b6ad2009-04-03 08:27:58 +03002616 .op_name = "OP_SEQUENCE",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002617 .op_rsize_bop = nfsd4_sequence_rsize,
Andy Adamson069b6ad2009-04-03 08:27:58 +03002618 },
Benny Halevy094b5d72011-06-16 11:39:10 -04002619 [OP_DESTROY_CLIENTID] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002620 .op_func = nfsd4_destroy_clientid,
Mi Jinlong58e7b332011-08-28 18:18:56 +08002621 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
2622 | OP_MODIFIES_SOMETHING,
Benny Halevy094b5d72011-06-16 11:39:10 -04002623 .op_name = "OP_DESTROY_CLIENTID",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002624 .op_rsize_bop = nfsd4_only_status_rsize,
Benny Halevy094b5d72011-06-16 11:39:10 -04002625 },
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002626 [OP_RECLAIM_COMPLETE] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002627 .op_func = nfsd4_reclaim_complete,
Mi Jinlong58e7b332011-08-28 18:18:56 +08002628 .op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING,
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002629 .op_name = "OP_RECLAIM_COMPLETE",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002630 .op_rsize_bop = nfsd4_only_status_rsize,
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002631 },
J. Bruce Fields04f4ad12010-12-16 09:51:13 -05002632 [OP_SECINFO_NO_NAME] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002633 .op_func = nfsd4_secinfo_no_name,
Eryu Guanec572b92017-09-29 15:01:10 +08002634 .op_release = nfsd4_secinfo_no_name_release,
J. Bruce Fields68d93182011-04-08 17:00:50 -04002635 .op_flags = OP_HANDLES_WRONGSEC,
J. Bruce Fields04f4ad12010-12-16 09:51:13 -05002636 .op_name = "OP_SECINFO_NO_NAME",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002637 .op_rsize_bop = nfsd4_secinfo_rsize,
J. Bruce Fields04f4ad12010-12-16 09:51:13 -05002638 },
Bryan Schumaker17456802011-07-13 10:50:48 -04002639 [OP_TEST_STATEID] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002640 .op_func = nfsd4_test_stateid,
Bryan Schumaker17456802011-07-13 10:50:48 -04002641 .op_flags = ALLOWED_WITHOUT_FH,
2642 .op_name = "OP_TEST_STATEID",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002643 .op_rsize_bop = nfsd4_test_stateid_rsize,
Bryan Schumaker17456802011-07-13 10:50:48 -04002644 },
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04002645 [OP_FREE_STATEID] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002646 .op_func = nfsd4_free_stateid,
Mi Jinlong58e7b332011-08-28 18:18:56 +08002647 .op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING,
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04002648 .op_name = "OP_FREE_STATEID",
Christoph Hellwig57832e72017-05-08 20:37:33 +02002649 .op_get_currentstateid = nfsd4_get_freestateid,
Christoph Hellwig1c122632017-05-08 20:42:10 +02002650 .op_rsize_bop = nfsd4_only_status_rsize,
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04002651 },
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02002652#ifdef CONFIG_NFSD_PNFS
2653 [OP_GETDEVICEINFO] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002654 .op_func = nfsd4_getdeviceinfo,
J. Bruce Fields34b1744c2017-05-05 17:09:37 -04002655 .op_release = nfsd4_getdeviceinfo_release,
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02002656 .op_flags = ALLOWED_WITHOUT_FH,
2657 .op_name = "OP_GETDEVICEINFO",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002658 .op_rsize_bop = nfsd4_getdeviceinfo_rsize,
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02002659 },
2660 [OP_LAYOUTGET] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002661 .op_func = nfsd4_layoutget,
J. Bruce Fields34b1744c2017-05-05 17:09:37 -04002662 .op_release = nfsd4_layoutget_release,
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02002663 .op_flags = OP_MODIFIES_SOMETHING,
2664 .op_name = "OP_LAYOUTGET",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002665 .op_rsize_bop = nfsd4_layoutget_rsize,
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02002666 },
2667 [OP_LAYOUTCOMMIT] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002668 .op_func = nfsd4_layoutcommit,
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02002669 .op_flags = OP_MODIFIES_SOMETHING,
2670 .op_name = "OP_LAYOUTCOMMIT",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002671 .op_rsize_bop = nfsd4_layoutcommit_rsize,
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02002672 },
2673 [OP_LAYOUTRETURN] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002674 .op_func = nfsd4_layoutreturn,
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02002675 .op_flags = OP_MODIFIES_SOMETHING,
2676 .op_name = "OP_LAYOUTRETURN",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002677 .op_rsize_bop = nfsd4_layoutreturn_rsize,
Christoph Hellwig9cf514c2014-05-05 13:11:59 +02002678 },
2679#endif /* CONFIG_NFSD_PNFS */
Anna Schumaker24bab492014-09-26 13:58:27 -04002680
2681 /* NFSv4.2 operations */
Anna Schumaker95d871f2014-11-07 14:44:26 -05002682 [OP_ALLOCATE] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002683 .op_func = nfsd4_allocate,
Olga Kornievskaia03b31f42018-12-04 14:09:21 -05002684 .op_flags = OP_MODIFIES_SOMETHING,
Anna Schumaker95d871f2014-11-07 14:44:26 -05002685 .op_name = "OP_ALLOCATE",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002686 .op_rsize_bop = nfsd4_only_status_rsize,
Anna Schumaker95d871f2014-11-07 14:44:26 -05002687 },
Anna Schumakerb0cb9082014-11-07 14:44:27 -05002688 [OP_DEALLOCATE] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002689 .op_func = nfsd4_deallocate,
Olga Kornievskaia03b31f42018-12-04 14:09:21 -05002690 .op_flags = OP_MODIFIES_SOMETHING,
Anna Schumakerb0cb9082014-11-07 14:44:27 -05002691 .op_name = "OP_DEALLOCATE",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002692 .op_rsize_bop = nfsd4_only_status_rsize,
Anna Schumakerb0cb9082014-11-07 14:44:27 -05002693 },
Christoph Hellwigffa01602015-12-03 12:59:52 +01002694 [OP_CLONE] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002695 .op_func = nfsd4_clone,
Olga Kornievskaia03b31f42018-12-04 14:09:21 -05002696 .op_flags = OP_MODIFIES_SOMETHING,
Christoph Hellwigffa01602015-12-03 12:59:52 +01002697 .op_name = "OP_CLONE",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002698 .op_rsize_bop = nfsd4_only_status_rsize,
Christoph Hellwigffa01602015-12-03 12:59:52 +01002699 },
Anna Schumaker29ae7f92016-09-07 15:57:30 -04002700 [OP_COPY] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002701 .op_func = nfsd4_copy,
Olga Kornievskaia03b31f42018-12-04 14:09:21 -05002702 .op_flags = OP_MODIFIES_SOMETHING,
Anna Schumaker29ae7f92016-09-07 15:57:30 -04002703 .op_name = "OP_COPY",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002704 .op_rsize_bop = nfsd4_copy_rsize,
Anna Schumaker29ae7f92016-09-07 15:57:30 -04002705 },
Anna Schumaker24bab492014-09-26 13:58:27 -04002706 [OP_SEEK] = {
Christoph Hellwigeb698532017-05-08 20:58:35 +02002707 .op_func = nfsd4_seek,
Anna Schumaker24bab492014-09-26 13:58:27 -04002708 .op_name = "OP_SEEK",
Christoph Hellwig1c122632017-05-08 20:42:10 +02002709 .op_rsize_bop = nfsd4_seek_rsize,
Anna Schumaker24bab492014-09-26 13:58:27 -04002710 },
Olga Kornievskaia6308bc92018-07-20 18:19:18 -04002711 [OP_OFFLOAD_STATUS] = {
2712 .op_func = nfsd4_offload_status,
2713 .op_name = "OP_OFFLOAD_STATUS",
2714 .op_rsize_bop = nfsd4_offload_status_rsize,
2715 },
Olga Kornievskaia885e2bf2018-07-20 18:19:19 -04002716 [OP_OFFLOAD_CANCEL] = {
2717 .op_func = nfsd4_offload_cancel,
2718 .op_flags = OP_MODIFIES_SOMETHING,
2719 .op_name = "OP_OFFLOAD_CANCEL",
2720 .op_rsize_bop = nfsd4_only_status_rsize,
2721 },
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002722};
2723
Andrew Elbleed941642016-06-15 12:52:09 -04002724/**
2725 * nfsd4_spo_must_allow - Determine if the compound op contains an
2726 * operation that is allowed to be sent with machine credentials
2727 *
2728 * @rqstp: a pointer to the struct svc_rqst
2729 *
2730 * Checks to see if the compound contains a spo_must_allow op
2731 * and confirms that it was sent with the proper machine creds.
2732 */
2733
2734bool nfsd4_spo_must_allow(struct svc_rqst *rqstp)
2735{
2736 struct nfsd4_compoundres *resp = rqstp->rq_resp;
2737 struct nfsd4_compoundargs *argp = rqstp->rq_argp;
2738 struct nfsd4_op *this = &argp->ops[resp->opcnt - 1];
2739 struct nfsd4_compound_state *cstate = &resp->cstate;
2740 struct nfs4_op_map *allow = &cstate->clp->cl_spo_must_allow;
2741 u32 opiter;
2742
2743 if (!cstate->minorversion)
2744 return false;
2745
2746 if (cstate->spo_must_allowed == true)
2747 return true;
2748
2749 opiter = resp->opcnt;
2750 while (opiter < argp->opcnt) {
2751 this = &argp->ops[opiter++];
2752 if (test_bit(this->opnum, allow->u.longs) &&
2753 cstate->clp->cl_mach_cred &&
2754 nfsd4_mach_creds_match(cstate->clp, rqstp)) {
2755 cstate->spo_must_allowed = true;
2756 return true;
2757 }
2758 }
2759 cstate->spo_must_allowed = false;
2760 return false;
2761}
2762
J. Bruce Fields4f0cefb2014-03-11 15:39:13 -04002763int nfsd4_max_reply(struct svc_rqst *rqstp, struct nfsd4_op *op)
2764{
Olga Kornievskaia05b72782017-03-23 14:36:20 -04002765 if (op->opnum == OP_ILLEGAL || op->status == nfserr_notsupp)
J. Bruce Fields4f0cefb2014-03-11 15:39:13 -04002766 return op_encode_hdr_size * sizeof(__be32);
Kinglong Mee2282cd22017-02-03 22:36:00 +08002767
2768 BUG_ON(OPDESC(op)->op_rsize_bop == NULL);
2769 return OPDESC(op)->op_rsize_bop(rqstp, op);
J. Bruce Fields4f0cefb2014-03-11 15:39:13 -04002770}
2771
J. Bruce Fields07d1f802014-03-06 20:39:29 -05002772void warn_on_nonidempotent_op(struct nfsd4_op *op)
2773{
2774 if (OPDESC(op)->op_flags & OP_MODIFIES_SOMETHING) {
2775 pr_err("unable to encode reply to nonidempotent op %d (%s)\n",
2776 op->opnum, nfsd4_op_name(op->opnum));
2777 WARN_ON_ONCE(1);
2778 }
2779}
2780
Adrian Bunkf1c7f792008-08-08 19:26:42 +03002781static const char *nfsd4_op_name(unsigned opnum)
Benny Halevyb001a1b2008-07-02 11:15:03 +03002782{
2783 if (opnum < ARRAY_SIZE(nfsd4_ops))
2784 return nfsd4_ops[opnum].op_name;
2785 return "unknown_operation";
2786}
2787
Linus Torvalds1da177e2005-04-16 15:20:36 -07002788#define nfsd4_voidres nfsd4_voidargs
Linus Torvalds1da177e2005-04-16 15:20:36 -07002789struct nfsd4_voidargs { int dummy; };
2790
Christoph Hellwig860bda22017-05-12 16:11:49 +02002791static const struct svc_procedure nfsd_procedures4[2] = {
Yu Zhiguo0a93a472009-05-19 14:09:54 +08002792 [NFSPROC4_NULL] = {
Christoph Hellwigf7235b62017-05-08 17:59:13 +02002793 .pc_func = nfsd4_proc_null,
Christoph Hellwig63f8de32017-05-08 19:42:02 +02002794 .pc_encode = nfs4svc_encode_voidres,
Yu Zhiguo0a93a472009-05-19 14:09:54 +08002795 .pc_argsize = sizeof(struct nfsd4_voidargs),
2796 .pc_ressize = sizeof(struct nfsd4_voidres),
2797 .pc_cachetype = RC_NOCACHE,
2798 .pc_xdrressize = 1,
2799 },
2800 [NFSPROC4_COMPOUND] = {
Christoph Hellwigf7235b62017-05-08 17:59:13 +02002801 .pc_func = nfsd4_proc_compound,
Christoph Hellwig026fec72017-05-08 19:01:48 +02002802 .pc_decode = nfs4svc_decode_compoundargs,
Christoph Hellwig63f8de32017-05-08 19:42:02 +02002803 .pc_encode = nfs4svc_encode_compoundres,
Yu Zhiguo0a93a472009-05-19 14:09:54 +08002804 .pc_argsize = sizeof(struct nfsd4_compoundargs),
2805 .pc_ressize = sizeof(struct nfsd4_compoundres),
J. Bruce Fields3e98abf2011-07-16 17:15:10 -04002806 .pc_release = nfsd4_release_compoundargs,
Yu Zhiguo0a93a472009-05-19 14:09:54 +08002807 .pc_cachetype = RC_NOCACHE,
2808 .pc_xdrressize = NFSD_BUFSIZE/4,
2809 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002810};
2811
Christoph Hellwig7fd38af2017-05-08 23:40:27 +02002812static unsigned int nfsd_count3[ARRAY_SIZE(nfsd_procedures4)];
Christoph Hellwige9679182017-05-12 16:21:37 +02002813const struct svc_version nfsd_version4 = {
Jeff Layton5283b032017-02-24 13:25:24 -05002814 .vs_vers = 4,
2815 .vs_nproc = 2,
2816 .vs_proc = nfsd_procedures4,
Christoph Hellwig7fd38af2017-05-08 23:40:27 +02002817 .vs_count = nfsd_count3,
Jeff Layton5283b032017-02-24 13:25:24 -05002818 .vs_dispatch = nfsd_dispatch,
2819 .vs_xdrsize = NFS4_SVC_XDRSIZE,
2820 .vs_rpcb_optnl = true,
2821 .vs_need_cong_ctrl = true,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002822};
2823
2824/*
2825 * Local variables:
2826 * c-basic-offset: 8
2827 * End:
2828 */