]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blame - fs/nfs/nfs4proc.c
projects / mirror_ubuntu-hirsute-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
NFS: Create a single nfs4_setup_sequence() function
[mirror_ubuntu-hirsute-kernel.git] / fs / nfs / nfs4proc.c
CommitLineData
1da177e4
LT		 1/*
2 * fs/nfs/nfs4proc.c
3 *
4 * Client-side procedure declarations for NFSv4.
5 *
6 * Copyright (c) 2002 The Regents of the University of Michigan.
7 * All rights reserved.
8 *
9 * Kendrick Smith <kmsmith@umich.edu>
10 * Andy Adamson <andros@umich.edu>
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 *
16 * 1. Redistributions of source code must retain the above copyright
17 * notice, this list of conditions and the following disclaimer.
18 * 2. Redistributions in binary form must reproduce the above copyright
19 * notice, this list of conditions and the following disclaimer in the
20 * documentation and/or other materials provided with the distribution.
21 * 3. Neither the name of the University nor the names of its
22 * contributors may be used to endorse or promote products derived
23 * from this software without specific prior written permission.
24 *
25 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
26 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
27 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
28 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
30 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
31 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
32 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 */
37
38#include <linux/mm.h>
1da177e4
LT		 39#include <linux/delay.h>
40#include <linux/errno.h>
41#include <linux/string.h>
652f89f6
TM		 42#include <linux/ratelimit.h>
43#include <linux/printk.h>
5a0e3ad6 44#include <linux/slab.h>
1da177e4
LT		 45#include <linux/sunrpc/clnt.h>
46#include <linux/nfs.h>
47#include <linux/nfs4.h>
48#include <linux/nfs_fs.h>
49#include <linux/nfs_page.h>
9b7160c5 50#include <linux/nfs_mount.h>
1da177e4 51#include <linux/namei.h>
02a913a7 52#include <linux/mount.h>
99fe60d0 53#include <linux/module.h>
64c2ce8b 54#include <linux/xattr.h>
c7a360b0 55#include <linux/utsname.h>
d310310c 56#include <linux/freezer.h>
1da177e4 57
4ce79717 58#include "nfs4_fs.h"
1da177e4 59#include "delegation.h"
101070ca 60#include "internal.h"
006ea73e 61#include "iostat.h"
fc931582 62#include "callback.h"
b1f69b75 63#include "pnfs.h"
f092075d 64#include "netns.h"
40c64c26 65#include "nfs4idmap.h"
73e39aaa 66#include "nfs4session.h"
de242c0b 67#include "fscache.h"
1da177e4 68
c6d01c6f
TM		 69#include "nfs4trace.h"
70
1da177e4
LT		 71#define NFSDBG_FACILITY NFSDBG_PROC
72
2066fe89 73#define NFS4_POLL_RETRY_MIN (HZ/10)
1da177e4
LT		 74#define NFS4_POLL_RETRY_MAX (15*HZ)
75
a1d1c4f1
TM		 76/* file attributes which can be mapped to nfs attributes */
77#define NFS4_VALID_ATTRS (ATTR_MODE \
78 | ATTR_UID \
79 | ATTR_GID \
80 | ATTR_SIZE \
81 | ATTR_ATIME \
82 | ATTR_MTIME \
83 | ATTR_CTIME \
84 | ATTR_ATIME_SET \
85 | ATTR_MTIME_SET)
86
cdd4e68b 87struct nfs4_opendata;
864472e9 88static int _nfs4_proc_open(struct nfs4_opendata *data);
b257957e 89static int _nfs4_recover_proc_open(struct nfs4_opendata *data);
1da177e4 90static int nfs4_do_fsinfo(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *);
81934ddb 91static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr);
1775fd3e
DQ		 92static int nfs4_proc_getattr(struct nfs_server *, struct nfs_fh *, struct nfs_fattr *, struct nfs4_label *label);
93static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr, struct nfs4_label *label);
0ab64e0e
TM		 94static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
95 struct nfs_fattr *fattr, struct iattr *sattr,
29b59f94 96 struct nfs_open_context *ctx, struct nfs4_label *ilabel,
1775fd3e 97 struct nfs4_label *olabel);
f062eb6c 98#ifdef CONFIG_NFS_V4_1
ab7cb0df
TM		 99static int nfs41_test_stateid(struct nfs_server *, nfs4_stateid *,
100 struct rpc_cred *);
f0b0bf88
TM		 101static int nfs41_free_stateid(struct nfs_server *, const nfs4_stateid *,
102 struct rpc_cred *, bool);
f062eb6c 103#endif
aa9c2669
DQ		 104
105#ifdef CONFIG_NFS_V4_SECURITY_LABEL
106static inline struct nfs4_label *
107nfs4_label_init_security(struct inode *dir, struct dentry *dentry,
108 struct iattr *sattr, struct nfs4_label *label)
109{
110 int err;
111
112 if (label == NULL)
113 return NULL;
114
115 if (nfs_server_capable(dir, NFS_CAP_SECURITY_LABEL) == 0)
116 return NULL;
117
aa9c2669
DQ		 118 err = security_dentry_init_security(dentry, sattr->ia_mode,
119 &dentry->d_name, (void **)&label->label, &label->len);
120 if (err == 0)
121 return label;
122
123 return NULL;
124}
125static inline void
126nfs4_label_release_security(struct nfs4_label *label)
127{
128 if (label)
129 security_release_secctx(label->label, label->len);
130}
131static inline u32 *nfs4_bitmask(struct nfs_server *server, struct nfs4_label *label)
132{
133 if (label)
134 return server->attr_bitmask;
135
136 return server->attr_bitmask_nl;
137}
138#else
139static inline struct nfs4_label *
140nfs4_label_init_security(struct inode *dir, struct dentry *dentry,
141 struct iattr *sattr, struct nfs4_label *l)
142{ return NULL; }
143static inline void
144nfs4_label_release_security(struct nfs4_label *label)
145{ return; }
146static inline u32 *
147nfs4_bitmask(struct nfs_server *server, struct nfs4_label *label)
148{ return server->attr_bitmask; }
149#endif
150
1da177e4 151/* Prevent leaks of NFSv4 errors into userland */
46f72f57 152static int nfs4_map_errors(int err)
1da177e4 153{
52567b03
TM		 154 if (err >= -1000)
155 return err;
156 switch (err) {
157 case -NFS4ERR_RESOURCE:
30005121
WAA		 158 case -NFS4ERR_LAYOUTTRYLATER:
159 case -NFS4ERR_RECALLCONFLICT:
52567b03 160 return -EREMOTEIO;
7ebb9315 161 case -NFS4ERR_WRONGSEC:
8897538e 162 case -NFS4ERR_WRONG_CRED:
7ebb9315 163 return -EPERM;
3ddeb7c5
TM		 164 case -NFS4ERR_BADOWNER:
165 case -NFS4ERR_BADNAME:
166 return -EINVAL;
fb13bfa7
TM		 167 case -NFS4ERR_SHARE_DENIED:
168 return -EACCES;
f25efd85
SD		 169 case -NFS4ERR_MINOR_VERS_MISMATCH:
170 return -EPROTONOSUPPORT;
6e3cf241
TM		 171 case -NFS4ERR_FILE_OPEN:
172 return -EBUSY;
52567b03 173 default:
1da177e4 174 dprintk("%s could not handle NFSv4 error %d\n",
3110ff80 175 __func__, -err);
52567b03 176 break;
1da177e4 177 }
52567b03 178 return -EIO;
1da177e4
LT		 179}
180
181/*
182 * This is our standard bitmap for GETATTR requests.
183 */
1549210f 184const u32 nfs4_fattr_bitmap[3] = {
1da177e4
LT		 185 FATTR4_WORD0_TYPE
186 | FATTR4_WORD0_CHANGE
187 | FATTR4_WORD0_SIZE
188 | FATTR4_WORD0_FSID
189 | FATTR4_WORD0_FILEID,
190 FATTR4_WORD1_MODE
191 | FATTR4_WORD1_NUMLINKS
192 | FATTR4_WORD1_OWNER
193 | FATTR4_WORD1_OWNER_GROUP
194 | FATTR4_WORD1_RAWDEV
195 | FATTR4_WORD1_SPACE_USED
196 | FATTR4_WORD1_TIME_ACCESS
197 | FATTR4_WORD1_TIME_METADATA
ea96d1ec
AS		 198 | FATTR4_WORD1_TIME_MODIFY
199 | FATTR4_WORD1_MOUNTED_ON_FILEID,
aa9c2669
DQ		 200#ifdef CONFIG_NFS_V4_SECURITY_LABEL
201 FATTR4_WORD2_SECURITY_LABEL
202#endif
1da177e4
LT		 203};
204
1549210f
TM		 205static const u32 nfs4_pnfs_open_bitmap[3] = {
206 FATTR4_WORD0_TYPE
207 | FATTR4_WORD0_CHANGE
208 | FATTR4_WORD0_SIZE
209 | FATTR4_WORD0_FSID
210 | FATTR4_WORD0_FILEID,
211 FATTR4_WORD1_MODE
212 | FATTR4_WORD1_NUMLINKS
213 | FATTR4_WORD1_OWNER
214 | FATTR4_WORD1_OWNER_GROUP
215 | FATTR4_WORD1_RAWDEV
216 | FATTR4_WORD1_SPACE_USED
217 | FATTR4_WORD1_TIME_ACCESS
218 | FATTR4_WORD1_TIME_METADATA
219 | FATTR4_WORD1_TIME_MODIFY,
220 FATTR4_WORD2_MDSTHRESHOLD
95864c91
TM		 221#ifdef CONFIG_NFS_V4_SECURITY_LABEL
222 | FATTR4_WORD2_SECURITY_LABEL
223#endif
1549210f
TM		 224};
225
e23008ec
AA		 226static const u32 nfs4_open_noattr_bitmap[3] = {
227 FATTR4_WORD0_TYPE
e23008ec
AA		 228 | FATTR4_WORD0_FILEID,
229};
230
a09df2ca 231const u32 nfs4_statfs_bitmap[3] = {
1da177e4
LT		 232 FATTR4_WORD0_FILES_AVAIL
233 | FATTR4_WORD0_FILES_FREE
234 | FATTR4_WORD0_FILES_TOTAL,
235 FATTR4_WORD1_SPACE_AVAIL
236 | FATTR4_WORD1_SPACE_FREE
237 | FATTR4_WORD1_SPACE_TOTAL
238};
239
a09df2ca 240const u32 nfs4_pathconf_bitmap[3] = {
1da177e4
LT		 241 FATTR4_WORD0_MAXLINK
242 | FATTR4_WORD0_MAXNAME,
243 0
244};
245
dae100c2 246const u32 nfs4_fsinfo_bitmap[3] = { FATTR4_WORD0_MAXFILESIZE
1da177e4
LT		 247 | FATTR4_WORD0_MAXREAD
248 | FATTR4_WORD0_MAXWRITE
249 | FATTR4_WORD0_LEASE_TIME,
55b6e774 250 FATTR4_WORD1_TIME_DELTA
dae100c2
FI		 251 | FATTR4_WORD1_FS_LAYOUT_TYPES,
252 FATTR4_WORD2_LAYOUT_BLKSIZE
2a92ee92 253 | FATTR4_WORD2_CLONE_BLKSIZE
1da177e4
LT		 254};
255
a09df2ca 256const u32 nfs4_fs_locations_bitmap[3] = {
830b8e33
MN		 257 FATTR4_WORD0_TYPE
258 | FATTR4_WORD0_CHANGE
259 | FATTR4_WORD0_SIZE
260 | FATTR4_WORD0_FSID
261 | FATTR4_WORD0_FILEID
262 | FATTR4_WORD0_FS_LOCATIONS,
263 FATTR4_WORD1_MODE
264 | FATTR4_WORD1_NUMLINKS
265 | FATTR4_WORD1_OWNER
266 | FATTR4_WORD1_OWNER_GROUP
267 | FATTR4_WORD1_RAWDEV
268 | FATTR4_WORD1_SPACE_USED
269 | FATTR4_WORD1_TIME_ACCESS
270 | FATTR4_WORD1_TIME_METADATA
271 | FATTR4_WORD1_TIME_MODIFY
a09df2ca 272 | FATTR4_WORD1_MOUNTED_ON_FILEID,
830b8e33
MN		 273};
274
bc4785cd 275static void nfs4_setup_readdir(u64 cookie, __be32 *verifier, struct dentry *dentry,
1da177e4
LT		 276 struct nfs4_readdir_arg *readdir)
277{
0dbb4c67 278 __be32 *start, *p;
1da177e4 279
1da177e4 280 if (cookie > 2) {
b7ef1956 281 readdir->cookie = cookie;
1da177e4
LT		 282 memcpy(&readdir->verifier, verifier, sizeof(readdir->verifier));
283 return;
284 }
285
286 readdir->cookie = 0;
287 memset(&readdir->verifier, 0, sizeof(readdir->verifier));
288 if (cookie == 2)
289 return;
290
291 /*
292 * NFSv4 servers do not return entries for '.' and '..'
293 * Therefore, we fake these entries here. We let '.'
294 * have cookie 0 and '..' have cookie 1. Note that
295 * when talking to the server, we always send cookie 0
296 * instead of 1 or 2.
297 */
2b86ce2d 298 start = p = kmap_atomic(*readdir->pages);
1da177e4
LT		 299
300 if (cookie == 0) {
301 *p++ = xdr_one; /* next */
302 *p++ = xdr_zero; /* cookie, first word */
303 *p++ = xdr_one; /* cookie, second word */
304 *p++ = xdr_one; /* entry len */
305 memcpy(p, ".\0\0\0", 4); /* entry */
306 p++;
307 *p++ = xdr_one; /* bitmap length */
308 *p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */
309 *p++ = htonl(8); /* attribute buffer length */
2b0143b5 310 p = xdr_encode_hyper(p, NFS_FILEID(d_inode(dentry)));
1da177e4
LT		 311 }
312
313 *p++ = xdr_one; /* next */
314 *p++ = xdr_zero; /* cookie, first word */
315 *p++ = xdr_two; /* cookie, second word */
316 *p++ = xdr_two; /* entry len */
317 memcpy(p, "..\0\0", 4); /* entry */
318 p++;
319 *p++ = xdr_one; /* bitmap length */
320 *p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */
321 *p++ = htonl(8); /* attribute buffer length */
2b0143b5 322 p = xdr_encode_hyper(p, NFS_FILEID(d_inode(dentry->d_parent)));
1da177e4
LT		 323
324 readdir->pgbase = (char *)p - (char *)start;
325 readdir->count -= readdir->pgbase;
2b86ce2d 326 kunmap_atomic(start);
1da177e4
LT		 327}
328
26d36301
TM		 329static void nfs4_test_and_free_stateid(struct nfs_server *server,
330 nfs4_stateid *stateid,
331 struct rpc_cred *cred)
332{
333 const struct nfs4_minor_version_ops *ops = server->nfs_client->cl_mvops;
334
335 ops->test_and_free_expired(server, stateid, cred);
336}
337
338static void __nfs4_free_revoked_stateid(struct nfs_server *server,
339 nfs4_stateid *stateid,
340 struct rpc_cred *cred)
341{
342 stateid->type = NFS4_REVOKED_STATEID_TYPE;
343 nfs4_test_and_free_stateid(server, stateid, cred);
344}
345
346static void nfs4_free_revoked_stateid(struct nfs_server *server,
347 const nfs4_stateid *stateid,
348 struct rpc_cred *cred)
349{
350 nfs4_stateid tmp;
351
352 nfs4_stateid_copy(&tmp, stateid);
353 __nfs4_free_revoked_stateid(server, &tmp, cred);
354}
355
8478eaa1
N		 356static long nfs4_update_delay(long *timeout)
357{
358 long ret;
359 if (!timeout)
360 return NFS4_POLL_RETRY_MAX;
361 if (*timeout <= 0)
362 *timeout = NFS4_POLL_RETRY_MIN;
363 if (*timeout > NFS4_POLL_RETRY_MAX)
364 *timeout = NFS4_POLL_RETRY_MAX;
365 ret = *timeout;
366 *timeout <<= 1;
367 return ret;
368}
369
65de872e
TM		 370static int nfs4_delay(struct rpc_clnt *clnt, long *timeout)
371{
372 int res = 0;
373
374 might_sleep();
375
8478eaa1
N		 376 freezable_schedule_timeout_killable_unsafe(
377 nfs4_update_delay(timeout));
65de872e
TM		 378 if (fatal_signal_pending(current))
379 res = -ERESTARTSYS;
65de872e
TM		 380 return res;
381}
382
383/* This is the error handling routine for processes that are allowed
384 * to sleep.
385 */
b3c2aa07
TM		 386static int nfs4_do_handle_exception(struct nfs_server *server,
387 int errorcode, struct nfs4_exception *exception)
65de872e
TM		 388{
389 struct nfs_client *clp = server->nfs_client;
9e33bed5 390 struct nfs4_state *state = exception->state;
8487c479 391 const nfs4_stateid *stateid = exception->stateid;
3114ea7a 392 struct inode *inode = exception->inode;
65de872e
TM		 393 int ret = errorcode;
394
b3c2aa07
TM		 395 exception->delay = 0;
396 exception->recovering = 0;
65de872e 397 exception->retry = 0;
272289a3
TM		 398
399 if (stateid == NULL && state != NULL)
400 stateid = &state->stateid;
401
65de872e
TM		 402 switch(errorcode) {
403 case 0:
404 return 0;
5ba12443
TM		 405 case -NFS4ERR_DELEG_REVOKED:
406 case -NFS4ERR_ADMIN_REVOKED:
272289a3 407 case -NFS4ERR_EXPIRED:
5ba12443 408 case -NFS4ERR_BAD_STATEID:
272289a3
TM		 409 if (inode != NULL && stateid != NULL) {
410 nfs_inode_find_state_and_recover(inode,
411 stateid);
412 goto wait_on_recovery;
413 }
414 case -NFS4ERR_OPENMODE:
8487c479
TM		 415 if (inode) {
416 int err;
417
418 err = nfs_async_inode_return_delegation(inode,
419 stateid);
420 if (err == 0)
421 goto wait_on_recovery;
422 if (stateid != NULL && stateid->type == NFS4_DELEGATION_STATEID_TYPE) {
423 exception->retry = 1;
424 break;
425 }
426 }
3114ea7a
TM		 427 if (state == NULL)
428 break;
5d422301
TM		 429 ret = nfs4_schedule_stateid_recovery(server, state);
430 if (ret < 0)
431 break;
3114ea7a 432 goto wait_on_recovery;
65de872e 433 case -NFS4ERR_STALE_STATEID:
a2c0b9e2 434 case -NFS4ERR_STALE_CLIENTID:
0400a6b0
TM		 435 nfs4_schedule_lease_recovery(clp);
436 goto wait_on_recovery;
519ae255
CL		 437 case -NFS4ERR_MOVED:
438 ret = nfs4_schedule_migration_recovery(server);
439 if (ret < 0)
440 break;
441 goto wait_on_recovery;
8ef2f8d4
CL		 442 case -NFS4ERR_LEASE_MOVED:
443 nfs4_schedule_lease_moved_recovery(clp);
444 goto wait_on_recovery;
03391693 445#if defined(CONFIG_NFS_V4_1)
4745e315
AA		 446 case -NFS4ERR_BADSESSION:
447 case -NFS4ERR_BADSLOT:
448 case -NFS4ERR_BAD_HIGH_SLOT:
449 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
450 case -NFS4ERR_DEADSESSION:
451 case -NFS4ERR_SEQ_FALSE_RETRY:
452 case -NFS4ERR_SEQ_MISORDERED:
453 dprintk("%s ERROR: %d Reset session\n", __func__,
454 errorcode);
9f594791 455 nfs4_schedule_session_recovery(clp->cl_session, errorcode);
399f11c3 456 goto wait_on_recovery;
03391693 457#endif /* defined(CONFIG_NFS_V4_1) */
65de872e 458 case -NFS4ERR_FILE_OPEN:
44ed3556
N		 459 if (exception->timeout > HZ) {
460 /* We have retried a decent amount, time to
461 * fail
462 */
463 ret = -EBUSY;
464 break;
465 }
65de872e 466 case -NFS4ERR_DELAY:
2598ed34
TM		 467 nfs_inc_server_stats(server, NFSIOS_DELAY);
468 case -NFS4ERR_GRACE:
e85d7ee4 469 case -NFS4ERR_LAYOUTTRYLATER:
183d9e7b 470 case -NFS4ERR_RECALLCONFLICT:
b3c2aa07
TM		 471 exception->delay = 1;
472 return 0;
473
a8a4ae3a 474 case -NFS4ERR_RETRY_UNCACHED_REP:
65de872e
TM		 475 case -NFS4ERR_OLD_STATEID:
476 exception->retry = 1;
b064eca2
TM		 477 break;
478 case -NFS4ERR_BADOWNER:
479 /* The following works around a Linux server bug! */
480 case -NFS4ERR_BADNAME:
481 if (server->caps & NFS_CAP_UIDGID_NOMAP) {
482 server->caps &= ~NFS_CAP_UIDGID_NOMAP;
483 exception->retry = 1;
484 printk(KERN_WARNING "NFS: v4 server %s "
485 "does not accept raw "
486 "uid/gids. "
487 "Reenabling the idmapper.\n",
488 server->nfs_client->cl_hostname);
489 }
65de872e
TM		 490 }
491 /* We failed to handle the error */
492 return nfs4_map_errors(ret);
0400a6b0 493wait_on_recovery:
b3c2aa07
TM		 494 exception->recovering = 1;
495 return 0;
496}
497
498/* This is the error handling routine for processes that are allowed
499 * to sleep.
500 */
501int nfs4_handle_exception(struct nfs_server *server, int errorcode, struct nfs4_exception *exception)
502{
503 struct nfs_client *clp = server->nfs_client;
504 int ret;
505
506 ret = nfs4_do_handle_exception(server, errorcode, exception);
507 if (exception->delay) {
508 ret = nfs4_delay(server->client, &exception->timeout);
509 goto out_retry;
510 }
511 if (exception->recovering) {
512 ret = nfs4_wait_clnt_recover(clp);
513 if (test_bit(NFS_MIG_FAILED, &server->mig_status))
514 return -EIO;
515 goto out_retry;
516 }
517 return ret;
518out_retry:
a2c0b9e2
TM		 519 if (ret == 0)
520 exception->retry = 1;
521 return ret;
65de872e
TM		 522}
523
037fc980
TM		 524static int
525nfs4_async_handle_exception(struct rpc_task *task, struct nfs_server *server,
526 int errorcode, struct nfs4_exception *exception)
527{
528 struct nfs_client *clp = server->nfs_client;
529 int ret;
530
531 ret = nfs4_do_handle_exception(server, errorcode, exception);
532 if (exception->delay) {
533 rpc_delay(task, nfs4_update_delay(&exception->timeout));
534 goto out_retry;
535 }
536 if (exception->recovering) {
537 rpc_sleep_on(&clp->cl_rpcwaitq, task, NULL);
538 if (test_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) == 0)
539 rpc_wake_up_queued_task(&clp->cl_rpcwaitq, task);
540 goto out_retry;
541 }
519ae255 542 if (test_bit(NFS_MIG_FAILED, &server->mig_status))
037fc980
TM		 543 ret = -EIO;
544 return ret;
545out_retry:
a2c0b9e2
TM		 546 if (ret == 0)
547 exception->retry = 1;
548 return ret;
65de872e
TM		 549}
550
037fc980
TM		 551static int
552nfs4_async_handle_error(struct rpc_task *task, struct nfs_server *server,
553 struct nfs4_state *state, long *timeout)
554{
555 struct nfs4_exception exception = {
556 .state = state,
557 };
558
559 if (task->tk_status >= 0)
560 return 0;
561 if (timeout)
562 exception.timeout = *timeout;
563 task->tk_status = nfs4_async_handle_exception(task, server,
564 task->tk_status,
565 &exception);
566 if (exception.delay && timeout)
567 *timeout = exception.timeout;
568 if (exception.retry)
569 return -EAGAIN;
570 return 0;
571}
572
a5250def
WAA		 573/*
574 * Return 'true' if 'clp' is using an rpc_client that is integrity protected
575 * or 'false' otherwise.
576 */
577static bool _nfs4_is_integrity_protected(struct nfs_client *clp)
578{
579 rpc_authflavor_t flavor = clp->cl_rpcclient->cl_auth->au_flavor;
580
581 if (flavor == RPC_AUTH_GSS_KRB5I ||
582 flavor == RPC_AUTH_GSS_KRB5P)
583 return true;
584
585 return false;
586}
65de872e 587
452e9352 588static void do_renew_lease(struct nfs_client *clp, unsigned long timestamp)
1da177e4 589{
1da177e4
LT		 590 spin_lock(&clp->cl_lock);
591 if (time_before(clp->cl_last_renewal,timestamp))
592 clp->cl_last_renewal = timestamp;
593 spin_unlock(&clp->cl_lock);
594}
595
452e9352
TM		 596static void renew_lease(const struct nfs_server *server, unsigned long timestamp)
597{
be824167
TM		 598 struct nfs_client *clp = server->nfs_client;
599
600 if (!nfs4_has_session(clp))
601 do_renew_lease(clp, timestamp);
452e9352
TM		 602}
603
2a3eb2b9
CL		 604struct nfs4_call_sync_data {
605 const struct nfs_server *seq_server;
606 struct nfs4_sequence_args *seq_args;
607 struct nfs4_sequence_res *seq_res;
608};
609
be3a5d23
TM		 610void nfs4_init_sequence(struct nfs4_sequence_args *args,
611 struct nfs4_sequence_res *res, int cache_reply)
a9c92d6b
CL		 612{
613 args->sa_slot = NULL;
614 args->sa_cache_this = cache_reply;
615 args->sa_privileged = 0;
616
617 res->sr_slot = NULL;
618}
619
620static void nfs4_set_sequence_privileged(struct nfs4_sequence_args *args)
621{
622 args->sa_privileged = 1;
623}
624
6de7e12f
AS		 625static int nfs40_setup_sequence(struct nfs4_slot_table *tbl,
626 struct nfs4_sequence_args *args,
627 struct nfs4_sequence_res *res,
628 struct rpc_task *task)
3bd2384a 629{
3bd2384a
CL		 630 struct nfs4_slot *slot;
631
632 /* slot already allocated? */
633 if (res->sr_slot != NULL)
634 goto out_start;
635
636 spin_lock(&tbl->slot_tbl_lock);
637 if (nfs4_slot_tbl_draining(tbl) && !args->sa_privileged)
638 goto out_sleep;
639
640 slot = nfs4_alloc_slot(tbl);
641 if (IS_ERR(slot)) {
642 if (slot == ERR_PTR(-ENOMEM))
643 task->tk_timeout = HZ >> 2;
644 goto out_sleep;
645 }
646 spin_unlock(&tbl->slot_tbl_lock);
647
0a014a44 648 slot->privileged = args->sa_privileged ? 1 : 0;
3bd2384a
CL		 649 args->sa_slot = slot;
650 res->sr_slot = slot;
651
652out_start:
653 rpc_call_start(task);
654 return 0;
655
656out_sleep:
657 if (args->sa_privileged)
658 rpc_sleep_on_priority(&tbl->slot_tbl_waitq, task,
659 NULL, RPC_PRIORITY_PRIVILEGED);
660 else
661 rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL);
662 spin_unlock(&tbl->slot_tbl_lock);
663 return -EAGAIN;
664}
665
2e80dbe7 666static void nfs40_sequence_free_slot(struct nfs4_sequence_res *res)
3bd2384a
CL		 667{
668 struct nfs4_slot *slot = res->sr_slot;
669 struct nfs4_slot_table *tbl;
670
3bd2384a
CL		 671 tbl = slot->table;
672 spin_lock(&tbl->slot_tbl_lock);
673 if (!nfs41_wake_and_assign_slot(tbl, slot))
674 nfs4_free_slot(tbl, slot);
675 spin_unlock(&tbl->slot_tbl_lock);
676
677 res->sr_slot = NULL;
2e80dbe7
TM		 678}
679
680static int nfs40_sequence_done(struct rpc_task *task,
681 struct nfs4_sequence_res *res)
682{
683 if (res->sr_slot != NULL)
684 nfs40_sequence_free_slot(res);
3bd2384a
CL		 685 return 1;
686}
687
cccef3b9
AA		 688#if defined(CONFIG_NFS_V4_1)
689
d185a334 690static void nfs41_sequence_free_slot(struct nfs4_sequence_res *res)
13615871 691{
e3725ec0 692 struct nfs4_session *session;
13615871 693 struct nfs4_slot_table *tbl;
a13ce7c6 694 struct nfs4_slot *slot = res->sr_slot;
c10e4498 695 bool send_new_highest_used_slotid = false;
13615871 696
a13ce7c6 697 tbl = slot->table;
e3725ec0 698 session = tbl->session;
ea028ac9 699
07e8dcbd
TM		 700 /* Bump the slot sequence number */
701 if (slot->seq_done)
702 slot->seq_nr++;
703 slot->seq_done = 0;
704
35dc1d74 705 spin_lock(&tbl->slot_tbl_lock);
c10e4498
TM		 706 /* Be nice to the server: try to ensure that the last transmitted
707 * value for highest_user_slotid <= target_highest_slotid
708 */
709 if (tbl->highest_used_slotid > tbl->target_highest_slotid)
710 send_new_highest_used_slotid = true;
711
a13ce7c6 712 if (nfs41_wake_and_assign_slot(tbl, slot)) {
b75ad4cd
TM		 713 send_new_highest_used_slotid = false;
714 goto out_unlock;
715 }
a13ce7c6 716 nfs4_free_slot(tbl, slot);
c10e4498
TM		 717
718 if (tbl->highest_used_slotid != NFS4_NO_SLOT)
719 send_new_highest_used_slotid = false;
b75ad4cd 720out_unlock:
35dc1d74 721 spin_unlock(&tbl->slot_tbl_lock);
dfb4f309 722 res->sr_slot = NULL;
c10e4498 723 if (send_new_highest_used_slotid)
3f10a6af 724 nfs41_notify_server(session->clp);
045d2a6d
TM		 725 if (waitqueue_active(&tbl->slot_waitq))
726 wake_up_all(&tbl->slot_waitq);
13615871
AA		 727}
728
2e80dbe7
TM		 729static int nfs41_sequence_process(struct rpc_task *task,
730 struct nfs4_sequence_res *res)
b0df806c 731{
e3725ec0 732 struct nfs4_session *session;
a13ce7c6 733 struct nfs4_slot *slot = res->sr_slot;
14516c3a 734 struct nfs_client *clp;
ac20d163 735 bool interrupted = false;
85563073 736 int ret = 1;
b0df806c 737
a13ce7c6
TM		 738 if (slot == NULL)
739 goto out_noaction;
468f8613
BS		 740 /* don't increment the sequence number if the task wasn't sent */
741 if (!RPC_WAS_SENT(task))
b0df806c
AA		 742 goto out;
743
e3725ec0 744 session = slot->table->session;
933602e3 745
ac20d163
TM		 746 if (slot->interrupted) {
747 slot->interrupted = 0;
748 interrupted = true;
749 }
750
2f92ae34 751 trace_nfs4_sequence_done(session, res);
691daf3b 752 /* Check the SEQUENCE operation status */
14516c3a
TM		 753 switch (res->sr_status) {
754 case 0:
a865880e
OK		 755 /* If previous op on slot was interrupted and we reused
756 * the seq# and got a reply from the cache, then retry
757 */
758 if (task->tk_status == -EREMOTEIO && interrupted) {
759 ++slot->seq_nr;
760 goto retry_nowait;
761 }
b0df806c 762 /* Update the slot's sequence and clientid lease timer */
07e8dcbd 763 slot->seq_done = 1;
e3725ec0 764 clp = session->clp;
8e63b6a8 765 do_renew_lease(clp, res->sr_timestamp);
0629e370 766 /* Check sequence flags */
0a014a44
TM		 767 nfs41_handle_sequence_flag_errors(clp, res->sr_status_flags,
768 !!slot->privileged);
464ee9f9 769 nfs41_update_target_slotid(slot->table, slot, res);
14516c3a 770 break;
ac20d163
TM		 771 case 1:
772 /*
773 * sr_status remains 1 if an RPC level error occurred.
774 * The server may or may not have processed the sequence
775 * operation..
776 * Mark the slot as having hosted an interrupted RPC call.
777 */
778 slot->interrupted = 1;
779 goto out;
14516c3a
TM		 780 case -NFS4ERR_DELAY:
781 /* The server detected a resend of the RPC call and
782 * returned NFS4ERR_DELAY as per Section 2.10.6.2
783 * of RFC5661.
784 */
df2fabff 785 dprintk("%s: slot=%u seq=%u: Operation in progress\n",
dfb4f309 786 __func__,
df2fabff 787 slot->slot_nr,
933602e3 788 slot->seq_nr);
14516c3a 789 goto out_retry;
85563073
TM		 790 case -NFS4ERR_BADSLOT:
791 /*
792 * The slot id we used was probably retired. Try again
793 * using a different slot id.
794 */
e8794440
TM		 795 goto retry_nowait;
796 case -NFS4ERR_SEQ_MISORDERED:
ac20d163
TM		 797 /*
798 * Was the last operation on this sequence interrupted?
799 * If so, retry after bumping the sequence number.
800 */
801 if (interrupted) {
802 ++slot->seq_nr;
803 goto retry_nowait;
804 }
e8794440
TM		 805 /*
806 * Could this slot have been previously retired?
807 * If so, then the server may be expecting seq_nr = 1!
808 */
8e63b6a8
TM		 809 if (slot->seq_nr != 1) {
810 slot->seq_nr = 1;
811 goto retry_nowait;
812 }
813 break;
e8794440
TM		 814 case -NFS4ERR_SEQ_FALSE_RETRY:
815 ++slot->seq_nr;
816 goto retry_nowait;
2cf10cdd
TM		 817 case -NFS4ERR_DEADSESSION:
818 case -NFS4ERR_BADSESSION:
819 nfs4_schedule_session_recovery(session, res->sr_status);
820 goto retry_nowait;
14516c3a
TM		 821 default:
822 /* Just update the slot sequence no. */
07e8dcbd 823 slot->seq_done = 1;
b0df806c
AA		 824 }
825out:
826 /* The session may be reset by one of the error handlers. */
827 dprintk("%s: Error %d free the slot \n", __func__, res->sr_status);
a13ce7c6 828out_noaction:
85563073 829 return ret;
e8794440
TM		 830retry_nowait:
831 if (rpc_restart_call_prepare(task)) {
2e80dbe7 832 nfs41_sequence_free_slot(res);
e8794440
TM		 833 task->tk_status = 0;
834 ret = 0;
835 }
836 goto out;
14516c3a 837out_retry:
d05dd4e9 838 if (!rpc_restart_call(task))
14516c3a
TM		 839 goto out;
840 rpc_delay(task, NFS4_POLL_RETRY_MAX);
841 return 0;
b0df806c 842}
2e80dbe7
TM		 843
844int nfs41_sequence_done(struct rpc_task *task, struct nfs4_sequence_res *res)
845{
846 if (!nfs41_sequence_process(task, res))
847 return 0;
848 if (res->sr_slot != NULL)
849 nfs41_sequence_free_slot(res);
850 return 1;
851
852}
f9c96fcc 853EXPORT_SYMBOL_GPL(nfs41_sequence_done);
b0df806c 854
2e80dbe7
TM		 855static int nfs4_sequence_process(struct rpc_task *task, struct nfs4_sequence_res *res)
856{
857 if (res->sr_slot == NULL)
858 return 1;
859 if (res->sr_slot->table->session != NULL)
860 return nfs41_sequence_process(task, res);
861 return nfs40_sequence_done(task, res);
862}
863
864static void nfs4_sequence_free_slot(struct nfs4_sequence_res *res)
865{
866 if (res->sr_slot != NULL) {
867 if (res->sr_slot->table->session != NULL)
868 nfs41_sequence_free_slot(res);
869 else
870 nfs40_sequence_free_slot(res);
871 }
872}
873
2c4b131d 874int nfs4_sequence_done(struct rpc_task *task, struct nfs4_sequence_res *res)
df896455 875{
e3725ec0 876 if (res->sr_slot == NULL)
14516c3a 877 return 1;
3bd2384a
CL		 878 if (!res->sr_slot->table->session)
879 return nfs40_sequence_done(task, res);
14516c3a 880 return nfs41_sequence_done(task, res);
df896455 881}
2c4b131d 882EXPORT_SYMBOL_GPL(nfs4_sequence_done);
df896455 883
6de7e12f 884static int nfs41_setup_sequence(struct nfs4_session *session,
ce5039c1
AA		 885 struct nfs4_sequence_args *args,
886 struct nfs4_sequence_res *res,
ce5039c1
AA		 887 struct rpc_task *task)
888{
fbcd4abc
AA		 889 struct nfs4_slot *slot;
890 struct nfs4_slot_table *tbl;
fbcd4abc
AA		 891
892 dprintk("--> %s\n", __func__);
ce5039c1 893 /* slot already allocated? */
dfb4f309 894 if (res->sr_slot != NULL)
d9afbd1b 895 goto out_success;
ce5039c1 896
fbcd4abc
AA		 897 tbl = &session->fc_slot_table;
898
69d206b5
TM		 899 task->tk_timeout = 0;
900
fbcd4abc 901 spin_lock(&tbl->slot_tbl_lock);
774d5f14 902 if (test_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state) &&
8fe72bac 903 !args->sa_privileged) {
0b1c8fc4 904 /* The state manager will wait until the slot table is empty */
0b1c8fc4 905 dprintk("%s session is draining\n", __func__);
7b939a3f 906 goto out_sleep;
689cf5c1
AB		 907 }
908
2dc03b7f 909 slot = nfs4_alloc_slot(tbl);
69d206b5
TM		 910 if (IS_ERR(slot)) {
911 /* If out of memory, try again in 1/4 second */
912 if (slot == ERR_PTR(-ENOMEM))
913 task->tk_timeout = HZ >> 2;
fbcd4abc 914 dprintk("<-- %s: no free slots\n", __func__);
7b939a3f 915 goto out_sleep;
fbcd4abc
AA		 916 }
917 spin_unlock(&tbl->slot_tbl_lock);
918
0a014a44 919 slot->privileged = args->sa_privileged ? 1 : 0;
2b2fa717 920 args->sa_slot = slot;
fbcd4abc 921
e8d92382 922 dprintk("<-- %s slotid=%u seqid=%u\n", __func__,
2dc03b7f 923 slot->slot_nr, slot->seq_nr);
fbcd4abc 924
dfb4f309 925 res->sr_slot = slot;
8e63b6a8 926 res->sr_timestamp = jiffies;
2a6e26cd 927 res->sr_status_flags = 0;
fbcd4abc
AA		 928 /*
929 * sr_status is only set in decode_sequence, and so will remain
930 * set to 1 if an rpc level failure occurs.
931 */
932 res->sr_status = 1;
2f92ae34 933 trace_nfs4_setup_sequence(session, args);
d9afbd1b
TM		 934out_success:
935 rpc_call_start(task);
ce5039c1 936 return 0;
7b939a3f 937out_sleep:
8fe72bac
TM		 938 /* Privileged tasks are queued with top priority */
939 if (args->sa_privileged)
1e1093c7
TM		 940 rpc_sleep_on_priority(&tbl->slot_tbl_waitq, task,
941 NULL, RPC_PRIORITY_PRIVILEGED);
942 else
943 rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL);
7b939a3f
TM		 944 spin_unlock(&tbl->slot_tbl_lock);
945 return -EAGAIN;
ce5039c1
AA		 946}
947
ce5039c1
AA		 948static void nfs41_call_sync_prepare(struct rpc_task *task, void *calldata)
949{
2a3eb2b9 950 struct nfs4_call_sync_data *data = calldata;
ce5039c1 951
035168ab
TM		 952 dprintk("--> %s data->seq_server %p\n", __func__, data->seq_server);
953
7981c8a6
AS		 954 nfs4_setup_sequence(data->seq_server->nfs_client,
955 data->seq_args, data->seq_res, task);
ce5039c1
AA		 956}
957
69ab40c4
AA		 958static void nfs41_call_sync_done(struct rpc_task *task, void *calldata)
959{
2a3eb2b9 960 struct nfs4_call_sync_data *data = calldata;
69ab40c4 961
14516c3a 962 nfs41_sequence_done(task, data->seq_res);
69ab40c4
AA		 963}
964
17280175 965static const struct rpc_call_ops nfs41_call_sync_ops = {
ce5039c1 966 .rpc_call_prepare = nfs41_call_sync_prepare,
69ab40c4 967 .rpc_call_done = nfs41_call_sync_done,
ce5039c1
AA		 968};
969
3bd2384a
CL		 970#else /* !CONFIG_NFS_V4_1 */
971
2e80dbe7
TM		 972static int nfs4_sequence_process(struct rpc_task *task, struct nfs4_sequence_res *res)
973{
974 return nfs40_sequence_done(task, res);
975}
976
977static void nfs4_sequence_free_slot(struct nfs4_sequence_res *res)
978{
979 if (res->sr_slot != NULL)
980 nfs40_sequence_free_slot(res);
981}
982
2c4b131d
PT		 983int nfs4_sequence_done(struct rpc_task *task,
984 struct nfs4_sequence_res *res)
9915ea7e 985{
3bd2384a 986 return nfs40_sequence_done(task, res);
9915ea7e 987}
2c4b131d 988EXPORT_SYMBOL_GPL(nfs4_sequence_done);
3bd2384a
CL		 989
990#endif /* !CONFIG_NFS_V4_1 */
9915ea7e 991
7981c8a6
AS		 992int nfs4_setup_sequence(const struct nfs_client *client,
993 struct nfs4_sequence_args *args,
994 struct nfs4_sequence_res *res,
995 struct rpc_task *task)
996{
997#if defined(CONFIG_NFS_V4_1)
998 struct nfs4_session *session = nfs4_get_session(client);
999
1000 if (session)
1001 return nfs41_setup_sequence(session, args, res, task);
1002#endif /* CONFIG_NFS_V4_1 */
1003 return nfs40_setup_sequence(client->cl_slot_tbl, args, res, task);
1004
1005}
1006EXPORT_SYMBOL_GPL(nfs4_setup_sequence);
1007
9915ea7e
CL		 1008static void nfs40_call_sync_prepare(struct rpc_task *task, void *calldata)
1009{
1010 struct nfs4_call_sync_data *data = calldata;
42e1cca7 1011 nfs4_setup_sequence(data->seq_server->nfs_client,
9915ea7e
CL		 1012 data->seq_args, data->seq_res, task);
1013}
1014
1015static void nfs40_call_sync_done(struct rpc_task *task, void *calldata)
1016{
1017 struct nfs4_call_sync_data *data = calldata;
1018 nfs4_sequence_done(task, data->seq_res);
1019}
1020
1021static const struct rpc_call_ops nfs40_call_sync_ops = {
1022 .rpc_call_prepare = nfs40_call_sync_prepare,
1023 .rpc_call_done = nfs40_call_sync_done,
1024};
1025
7c513058
BS		 1026static int nfs4_call_sync_sequence(struct rpc_clnt *clnt,
1027 struct nfs_server *server,
ce5039c1
AA		 1028 struct rpc_message *msg,
1029 struct nfs4_sequence_args *args,
8fe72bac 1030 struct nfs4_sequence_res *res)
ce5039c1
AA		 1031{
1032 int ret;
1033 struct rpc_task *task;
9915ea7e 1034 struct nfs_client *clp = server->nfs_client;
2a3eb2b9 1035 struct nfs4_call_sync_data data = {
035168ab 1036 .seq_server = server,
ce5039c1
AA		 1037 .seq_args = args,
1038 .seq_res = res,
ce5039c1
AA		 1039 };
1040 struct rpc_task_setup task_setup = {
7c513058 1041 .rpc_client = clnt,
ce5039c1 1042 .rpc_message = msg,
9915ea7e 1043 .callback_ops = clp->cl_mvops->call_sync_ops,
ce5039c1
AA		 1044 .callback_data = &data
1045 };
1046
ce5039c1
AA		 1047 task = rpc_run_task(&task_setup);
1048 if (IS_ERR(task))
1049 ret = PTR_ERR(task);
1050 else {
1051 ret = task->tk_status;
1052 rpc_put_task(task);
1053 }
1054 return ret;
1055}
1056
7c513058
BS		 1057int nfs4_call_sync(struct rpc_clnt *clnt,
1058 struct nfs_server *server,
e73b83f2
BS		 1059 struct rpc_message *msg,
1060 struct nfs4_sequence_args *args,
1061 struct nfs4_sequence_res *res,
1062 int cache_reply)
1063{
a9c92d6b 1064 nfs4_init_sequence(args, res, cache_reply);
9915ea7e 1065 return nfs4_call_sync_sequence(clnt, server, msg, args, res);
e73b83f2 1066}
cccef3b9 1067
d3129ef6
TM		 1068static void update_changeattr(struct inode *dir, struct nfs4_change_info *cinfo,
1069 unsigned long timestamp)
1da177e4 1070{
38478b24 1071 struct nfs_inode *nfsi = NFS_I(dir);
1da177e4 1072
38478b24 1073 spin_lock(&dir->i_lock);
359d7d1c 1074 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
e603a4c1
TM		 1075 if (cinfo->atomic && cinfo->before == dir->i_version) {
1076 nfsi->cache_validity &= ~NFS_INO_REVAL_PAGECACHE;
1077 nfsi->attrtimeo_timestamp = jiffies;
1078 } else {
bfc69a45 1079 nfs_force_lookup_revalidate(dir);
e603a4c1
TM		 1080 if (cinfo->before != dir->i_version)
1081 nfsi->cache_validity |= NFS_INO_INVALID_ACCESS |
1082 NFS_INO_INVALID_ACL;
1083 }
a9a4a87a 1084 dir->i_version = cinfo->after;
d3129ef6 1085 nfsi->read_cache_jiffies = timestamp;
3235b403 1086 nfsi->attr_gencount = nfs_inc_attr_generation_counter();
de242c0b 1087 nfs_fscache_invalidate(dir);
38478b24 1088 spin_unlock(&dir->i_lock);
1da177e4
LT		 1089}
1090
e56e0b78 1091struct nfs4_opendata {
c6d00e63 1092 struct kref kref;
e56e0b78
TM		 1093 struct nfs_openargs o_arg;
1094 struct nfs_openres o_res;
cdd4e68b
TM		 1095 struct nfs_open_confirmargs c_arg;
1096 struct nfs_open_confirmres c_res;
6926afd1
TM		 1097 struct nfs4_string owner_name;
1098 struct nfs4_string group_name;
a49c2691 1099 struct nfs4_label *a_label;
e56e0b78 1100 struct nfs_fattr f_attr;
1775fd3e 1101 struct nfs4_label *f_label;
e56e0b78 1102 struct dentry *dir;
82a2c1b7 1103 struct dentry *dentry;
e56e0b78 1104 struct nfs4_state_owner *owner;
aac00a8d 1105 struct nfs4_state *state;
e56e0b78 1106 struct iattr attrs;
26e976a8 1107 unsigned long timestamp;
3e309914 1108 unsigned int rpc_done : 1;
5bc2afc2 1109 unsigned int file_created : 1;
bdeca1b7 1110 unsigned int is_recover : 1;
24ac23ab
TM		 1111 int rpc_status;
1112 int cancelled;
e56e0b78
TM		 1113};
1114
49f9a0fa
TM		 1115static bool nfs4_clear_cap_atomic_open_v1(struct nfs_server *server,
1116 int err, struct nfs4_exception *exception)
1117{
1118 if (err != -EINVAL)
1119 return false;
1120 if (!(server->caps & NFS_CAP_ATOMIC_OPEN_V1))
1121 return false;
1122 server->caps &= ~NFS_CAP_ATOMIC_OPEN_V1;
1123 exception->retry = 1;
1124 return true;
1125}
1126
6ae37339
TM		 1127static u32
1128nfs4_map_atomic_open_share(struct nfs_server *server,
1129 fmode_t fmode, int openflags)
1130{
1131 u32 res = 0;
1132
1133 switch (fmode & (FMODE_READ | FMODE_WRITE)) {
1134 case FMODE_READ:
1135 res = NFS4_SHARE_ACCESS_READ;
1136 break;
1137 case FMODE_WRITE:
1138 res = NFS4_SHARE_ACCESS_WRITE;
1139 break;
1140 case FMODE_READ|FMODE_WRITE:
1141 res = NFS4_SHARE_ACCESS_BOTH;
1142 }
1143 if (!(server->caps & NFS_CAP_ATOMIC_OPEN_V1))
1144 goto out;
1145 /* Want no delegation if we're using O_DIRECT */
1146 if (openflags & O_DIRECT)
1147 res |= NFS4_SHARE_WANT_NO_DELEG;
1148out:
1149 return res;
1150}
1151
49f9a0fa
TM		 1152static enum open_claim_type4
1153nfs4_map_atomic_open_claim(struct nfs_server *server,
1154 enum open_claim_type4 claim)
1155{
1156 if (server->caps & NFS_CAP_ATOMIC_OPEN_V1)
1157 return claim;
1158 switch (claim) {
1159 default:
1160 return claim;
1161 case NFS4_OPEN_CLAIM_FH:
1162 return NFS4_OPEN_CLAIM_NULL;
1163 case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
1164 return NFS4_OPEN_CLAIM_DELEGATE_CUR;
1165 case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
1166 return NFS4_OPEN_CLAIM_DELEGATE_PREV;
1167 }
1168}
2ced46c2
TM		 1169
1170static void nfs4_init_opendata_res(struct nfs4_opendata *p)
1171{
1172 p->o_res.f_attr = &p->f_attr;
1775fd3e 1173 p->o_res.f_label = p->f_label;
c1d51931
TM		 1174 p->o_res.seqid = p->o_arg.seqid;
1175 p->c_res.seqid = p->c_arg.seqid;
2ced46c2 1176 p->o_res.server = p->o_arg.server;
5f657530 1177 p->o_res.access_request = p->o_arg.access;
2ced46c2 1178 nfs_fattr_init(&p->f_attr);
6926afd1 1179 nfs_fattr_init_names(&p->f_attr, &p->owner_name, &p->group_name);
2ced46c2
TM		 1180}
1181
82a2c1b7 1182static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
dc0b027d 1183 struct nfs4_state_owner *sp, fmode_t fmode, int flags,
8535b2be 1184 const struct iattr *attrs,
1775fd3e 1185 struct nfs4_label *label,
4a1c0893 1186 enum open_claim_type4 claim,
8535b2be 1187 gfp_t gfp_mask)
e56e0b78 1188{
82a2c1b7 1189 struct dentry *parent = dget_parent(dentry);
2b0143b5 1190 struct inode *dir = d_inode(parent);
e56e0b78 1191 struct nfs_server *server = NFS_SERVER(dir);
63f5f796 1192 struct nfs_seqid *(*alloc_seqid)(struct nfs_seqid_counter *, gfp_t);
e56e0b78
TM		 1193 struct nfs4_opendata *p;
1194
8535b2be 1195 p = kzalloc(sizeof(*p), gfp_mask);
e56e0b78
TM		 1196 if (p == NULL)
1197 goto err;
14c43f76
DQ		 1198
1199 p->f_label = nfs4_label_alloc(server, gfp_mask);
1200 if (IS_ERR(p->f_label))
1201 goto err_free_p;
1202
a49c2691
KM		 1203 p->a_label = nfs4_label_alloc(server, gfp_mask);
1204 if (IS_ERR(p->a_label))
1205 goto err_free_f;
1206
63f5f796
TM		 1207 alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid;
1208 p->o_arg.seqid = alloc_seqid(&sp->so_seqid, gfp_mask);
badc76dd 1209 if (IS_ERR(p->o_arg.seqid))
14c43f76 1210 goto err_free_label;
82a2c1b7
AV		 1211 nfs_sb_active(dentry->d_sb);
1212 p->dentry = dget(dentry);
e56e0b78
TM		 1213 p->dir = parent;
1214 p->owner = sp;
1215 atomic_inc(&sp->so_count);
dc0b027d
TM		 1216 p->o_arg.open_flags = flags;
1217 p->o_arg.fmode = fmode & (FMODE_READ|FMODE_WRITE);
dff25ddb 1218 p->o_arg.umask = current_umask();
536585cc 1219 p->o_arg.claim = nfs4_map_atomic_open_claim(server, claim);
6ae37339
TM		 1220 p->o_arg.share_access = nfs4_map_atomic_open_share(server,
1221 fmode, flags);
ae2bb032
WAA		 1222 /* don't put an ACCESS op in OPEN compound if O_EXCL, because ACCESS
1223 * will return permission denied for all bits until close */
1224 if (!(flags & O_EXCL)) {
1225 /* ask server to check for all possible rights as results
1226 * are cached */
536585cc
TM		 1227 switch (p->o_arg.claim) {
1228 default:
1229 break;
1230 case NFS4_OPEN_CLAIM_NULL:
1231 case NFS4_OPEN_CLAIM_FH:
1232 p->o_arg.access = NFS4_ACCESS_READ |
1233 NFS4_ACCESS_MODIFY |
1234 NFS4_ACCESS_EXTEND |
1235 NFS4_ACCESS_EXECUTE;
1236 }
ae2bb032 1237 }
7539bbab 1238 p->o_arg.clientid = server->nfs_client->cl_clientid;
95b72eb0
TM		 1239 p->o_arg.id.create_time = ktime_to_ns(sp->so_seqid.create_time);
1240 p->o_arg.id.uniquifier = sp->so_seqid.owner_id;
82a2c1b7 1241 p->o_arg.name = &dentry->d_name;
e56e0b78 1242 p->o_arg.server = server;
aa9c2669 1243 p->o_arg.bitmask = nfs4_bitmask(server, label);
1549210f 1244 p->o_arg.open_bitmap = &nfs4_fattr_bitmap[0];
a49c2691 1245 p->o_arg.label = nfs4_label_copy(p->a_label, label);
49f9a0fa 1246 switch (p->o_arg.claim) {
4a1c0893
TM		 1247 case NFS4_OPEN_CLAIM_NULL:
1248 case NFS4_OPEN_CLAIM_DELEGATE_CUR:
1249 case NFS4_OPEN_CLAIM_DELEGATE_PREV:
1250 p->o_arg.fh = NFS_FH(dir);
1251 break;
1252 case NFS4_OPEN_CLAIM_PREVIOUS:
1253 case NFS4_OPEN_CLAIM_FH:
1254 case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
1255 case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
2b0143b5 1256 p->o_arg.fh = NFS_FH(d_inode(dentry));
4a1c0893 1257 }
536e43d1 1258 if (attrs != NULL && attrs->ia_valid != 0) {
c281fa9c 1259 __u32 verf[2];
d77d76ff 1260
e56e0b78
TM		 1261 p->o_arg.u.attrs = &p->attrs;
1262 memcpy(&p->attrs, attrs, sizeof(p->attrs));
cd93710e
CL		 1263
1264 verf[0] = jiffies;
1265 verf[1] = current->pid;
1266 memcpy(p->o_arg.u.verifier.data, verf,
1267 sizeof(p->o_arg.u.verifier.data));
e56e0b78 1268 }
cdd4e68b
TM		 1269 p->c_arg.fh = &p->o_res.fh;
1270 p->c_arg.stateid = &p->o_res.stateid;
1271 p->c_arg.seqid = p->o_arg.seqid;
2ced46c2 1272 nfs4_init_opendata_res(p);
c6d00e63 1273 kref_init(&p->kref);
e56e0b78 1274 return p;
14c43f76
DQ		 1275
1276err_free_label:
a49c2691
KM		 1277 nfs4_label_free(p->a_label);
1278err_free_f:
14c43f76
DQ		 1279 nfs4_label_free(p->f_label);
1280err_free_p:
e56e0b78
TM		 1281 kfree(p);
1282err:
1283 dput(parent);
1284 return NULL;
1285}
1286
c6d00e63 1287static void nfs4_opendata_free(struct kref *kref)
e56e0b78 1288{
c6d00e63
TM		 1289 struct nfs4_opendata *p = container_of(kref,
1290 struct nfs4_opendata, kref);
82a2c1b7 1291 struct super_block *sb = p->dentry->d_sb;
c6d00e63
TM		 1292
1293 nfs_free_seqid(p->o_arg.seqid);
2e80dbe7 1294 nfs4_sequence_free_slot(&p->o_res.seq_res);
aac00a8d
TM		 1295 if (p->state != NULL)
1296 nfs4_put_open_state(p->state);
c6d00e63 1297 nfs4_put_state_owner(p->owner);
14c43f76 1298
a49c2691 1299 nfs4_label_free(p->a_label);
14c43f76
DQ		 1300 nfs4_label_free(p->f_label);
1301
c6d00e63 1302 dput(p->dir);
82a2c1b7
AV		 1303 dput(p->dentry);
1304 nfs_sb_deactive(sb);
6926afd1 1305 nfs_fattr_free_names(&p->f_attr);
e911b815 1306 kfree(p->f_attr.mdsthreshold);
c6d00e63
TM		 1307 kfree(p);
1308}
1309
1310static void nfs4_opendata_put(struct nfs4_opendata *p)
1311{
1312 if (p != NULL)
1313 kref_put(&p->kref, nfs4_opendata_free);
e56e0b78
TM		 1314}
1315
06f814a3
TM		 1316static int nfs4_wait_for_completion_rpc_task(struct rpc_task *task)
1317{
06f814a3
TM		 1318 int ret;
1319
06f814a3 1320 ret = rpc_wait_for_completion_task(task);
06f814a3
TM		 1321 return ret;
1322}
1323
24311f88
TM		 1324static bool nfs4_mode_match_open_stateid(struct nfs4_state *state,
1325 fmode_t fmode)
1326{
1327 switch(fmode & (FMODE_READ|FMODE_WRITE)) {
1328 case FMODE_READ|FMODE_WRITE:
1329 return state->n_rdwr != 0;
1330 case FMODE_WRITE:
1331 return state->n_wronly != 0;
1332 case FMODE_READ:
1333 return state->n_rdonly != 0;
1334 }
1335 WARN_ON_ONCE(1);
1336 return false;
1337}
1338
dc0b027d 1339static int can_open_cached(struct nfs4_state *state, fmode_t mode, int open_mode)
6ee41268
TM		 1340{
1341 int ret = 0;
dc0b027d 1342
536e43d1 1343 if (open_mode & (O_EXCL|O_TRUNC))
dc0b027d
TM		 1344 goto out;
1345 switch (mode & (FMODE_READ|FMODE_WRITE)) {
6ee41268 1346 case FMODE_READ:
88069f77
TM		 1347 ret |= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0
1348 && state->n_rdonly != 0;
6ee41268
TM		 1349 break;
1350 case FMODE_WRITE:
88069f77
TM		 1351 ret |= test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0
1352 && state->n_wronly != 0;
6ee41268
TM		 1353 break;
1354 case FMODE_READ|FMODE_WRITE:
88069f77
TM		 1355 ret |= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0
1356 && state->n_rdwr != 0;
6ee41268 1357 }
dc0b027d 1358out:
6ee41268
TM		 1359 return ret;
1360}
1361
2a606188
TM		 1362static int can_open_delegated(struct nfs_delegation *delegation, fmode_t fmode,
1363 enum open_claim_type4 claim)
aac00a8d 1364{
652f89f6
TM		 1365 if (delegation == NULL)
1366 return 0;
dc0b027d 1367 if ((delegation->type & fmode) != fmode)
aac00a8d 1368 return 0;
d25be546
TM		 1369 if (test_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
1370 return 0;
2a606188
TM		 1371 switch (claim) {
1372 case NFS4_OPEN_CLAIM_NULL:
1373 case NFS4_OPEN_CLAIM_FH:
1374 break;
1375 case NFS4_OPEN_CLAIM_PREVIOUS:
1376 if (!test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags))
1377 break;
1378 default:
1379 return 0;
1380 }
b7391f44 1381 nfs_mark_delegation_referenced(delegation);
aac00a8d
TM		 1382 return 1;
1383}
1384
dc0b027d 1385static void update_open_stateflags(struct nfs4_state *state, fmode_t fmode)
e7616923 1386{
dc0b027d 1387 switch (fmode) {
e7616923
TM		 1388 case FMODE_WRITE:
1389 state->n_wronly++;
1390 break;
1391 case FMODE_READ:
1392 state->n_rdonly++;
1393 break;
1394 case FMODE_READ|FMODE_WRITE:
1395 state->n_rdwr++;
1396 }
dc0b027d 1397 nfs4_state_set_mode_locked(state, state->state | fmode);
003707c7
TM		 1398}
1399
8a64c4ef
TM		 1400#ifdef CONFIG_NFS_V4_1
1401static bool nfs_open_stateid_recover_openmode(struct nfs4_state *state)
1402{
1403 if (state->n_rdonly && !test_bit(NFS_O_RDONLY_STATE, &state->flags))
1404 return true;
1405 if (state->n_wronly && !test_bit(NFS_O_WRONLY_STATE, &state->flags))
1406 return true;
1407 if (state->n_rdwr && !test_bit(NFS_O_RDWR_STATE, &state->flags))
1408 return true;
1409 return false;
1410}
1411#endif /* CONFIG_NFS_V4_1 */
1412
4f14c194
TM		 1413static void nfs_test_and_clear_all_open_stateid(struct nfs4_state *state)
1414{
1415 struct nfs_client *clp = state->owner->so_server->nfs_client;
1416 bool need_recover = false;
1417
1418 if (test_and_clear_bit(NFS_O_RDONLY_STATE, &state->flags) && state->n_rdonly)
1419 need_recover = true;
1420 if (test_and_clear_bit(NFS_O_WRONLY_STATE, &state->flags) && state->n_wronly)
1421 need_recover = true;
1422 if (test_and_clear_bit(NFS_O_RDWR_STATE, &state->flags) && state->n_rdwr)
1423 need_recover = true;
1424 if (need_recover)
1425 nfs4_state_mark_reclaim_nograce(clp, state);
1426}
1427
e999e80e 1428static bool nfs_need_update_open_stateid(struct nfs4_state *state,
1393d961 1429 const nfs4_stateid *stateid, nfs4_stateid *freeme)
e999e80e
TM		 1430{
1431 if (test_and_set_bit(NFS_OPEN_STATE, &state->flags) == 0)
1432 return true;
4f14c194 1433 if (!nfs4_stateid_match_other(stateid, &state->open_stateid)) {
1393d961 1434 nfs4_stateid_copy(freeme, &state->open_stateid);
4f14c194 1435 nfs_test_and_clear_all_open_stateid(state);
e999e80e 1436 return true;
4f14c194 1437 }
e999e80e
TM		 1438 if (nfs4_stateid_is_newer(stateid, &state->open_stateid))
1439 return true;
1440 return false;
1441}
1442
f95549cf
TM		 1443static void nfs_resync_open_stateid_locked(struct nfs4_state *state)
1444{
3c38cbe2
TM		 1445 if (!(state->n_wronly || state->n_rdonly || state->n_rdwr))
1446 return;
f95549cf
TM		 1447 if (state->n_wronly)
1448 set_bit(NFS_O_WRONLY_STATE, &state->flags);
1449 if (state->n_rdonly)
1450 set_bit(NFS_O_RDONLY_STATE, &state->flags);
1451 if (state->n_rdwr)
1452 set_bit(NFS_O_RDWR_STATE, &state->flags);
3c38cbe2 1453 set_bit(NFS_OPEN_STATE, &state->flags);
f95549cf
TM		 1454}
1455
226056c5
TM		 1456static void nfs_clear_open_stateid_locked(struct nfs4_state *state,
1457 nfs4_stateid *stateid, fmode_t fmode)
003707c7 1458{
226056c5
TM		 1459 clear_bit(NFS_O_RDWR_STATE, &state->flags);
1460 switch (fmode & (FMODE_READ|FMODE_WRITE)) {
1461 case FMODE_WRITE:
1462 clear_bit(NFS_O_RDONLY_STATE, &state->flags);
1463 break;
1464 case FMODE_READ:
1465 clear_bit(NFS_O_WRONLY_STATE, &state->flags);
1466 break;
1467 case 0:
1468 clear_bit(NFS_O_RDONLY_STATE, &state->flags);
1469 clear_bit(NFS_O_WRONLY_STATE, &state->flags);
1470 clear_bit(NFS_OPEN_STATE, &state->flags);
1471 }
1472 if (stateid == NULL)
1473 return;
3e7dfb16
TM		 1474 /* Handle OPEN+OPEN_DOWNGRADE races */
1475 if (nfs4_stateid_match_other(stateid, &state->open_stateid) &&
1476 !nfs4_stateid_is_newer(stateid, &state->open_stateid)) {
f95549cf 1477 nfs_resync_open_stateid_locked(state);
226056c5 1478 return;
f95549cf 1479 }
003707c7 1480 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
f597c537
TM		 1481 nfs4_stateid_copy(&state->stateid, stateid);
1482 nfs4_stateid_copy(&state->open_stateid, stateid);
226056c5
TM		 1483}
1484
4a1e2feb
TM		 1485static void nfs_clear_open_stateid(struct nfs4_state *state,
1486 nfs4_stateid *arg_stateid,
1487 nfs4_stateid *stateid, fmode_t fmode)
226056c5
TM		 1488{
1489 write_seqlock(&state->seqlock);
3e7dfb16
TM		 1490 /* Ignore, if the CLOSE argment doesn't match the current stateid */
1491 if (nfs4_state_match_open_stateid_other(state, arg_stateid))
1492 nfs_clear_open_stateid_locked(state, stateid, fmode);
226056c5 1493 write_sequnlock(&state->seqlock);
4f14c194
TM		 1494 if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags))
1495 nfs4_schedule_state_manager(state->owner->so_server->nfs_client);
226056c5
TM		 1496}
1497
1393d961
TM		 1498static void nfs_set_open_stateid_locked(struct nfs4_state *state,
1499 const nfs4_stateid *stateid, fmode_t fmode,
1500 nfs4_stateid *freeme)
003707c7 1501{
dc0b027d 1502 switch (fmode) {
003707c7
TM		 1503 case FMODE_READ:
1504 set_bit(NFS_O_RDONLY_STATE, &state->flags);
1505 break;
1506 case FMODE_WRITE:
1507 set_bit(NFS_O_WRONLY_STATE, &state->flags);
1508 break;
1509 case FMODE_READ|FMODE_WRITE:
1510 set_bit(NFS_O_RDWR_STATE, &state->flags);
1511 }
1393d961 1512 if (!nfs_need_update_open_stateid(state, stateid, freeme))
e999e80e
TM		 1513 return;
1514 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
1515 nfs4_stateid_copy(&state->stateid, stateid);
1516 nfs4_stateid_copy(&state->open_stateid, stateid);
003707c7
TM		 1517}
1518
1393d961
TM		 1519static void __update_open_stateid(struct nfs4_state *state,
1520 const nfs4_stateid *open_stateid,
1521 const nfs4_stateid *deleg_stateid,
1522 fmode_t fmode,
1523 nfs4_stateid *freeme)
1da177e4 1524{
8bda4e4c
TM		 1525 /*
1526 * Protect the call to nfs4_state_set_mode_locked and
1527 * serialise the stateid update
1528 */
361cad3c 1529 spin_lock(&state->owner->so_lock);
8bda4e4c 1530 write_seqlock(&state->seqlock);
003707c7 1531 if (deleg_stateid != NULL) {
f597c537 1532 nfs4_stateid_copy(&state->stateid, deleg_stateid);
003707c7
TM		 1533 set_bit(NFS_DELEGATED_STATE, &state->flags);
1534 }
1535 if (open_stateid != NULL)
1393d961 1536 nfs_set_open_stateid_locked(state, open_stateid, fmode, freeme);
8bda4e4c 1537 write_sequnlock(&state->seqlock);
dc0b027d 1538 update_open_stateflags(state, fmode);
ec073428 1539 spin_unlock(&state->owner->so_lock);
1da177e4
LT		 1540}
1541
1393d961
TM		 1542static int update_open_stateid(struct nfs4_state *state,
1543 const nfs4_stateid *open_stateid,
1544 const nfs4_stateid *delegation,
1545 fmode_t fmode)
34310430 1546{
1393d961
TM		 1547 struct nfs_server *server = NFS_SERVER(state->inode);
1548 struct nfs_client *clp = server->nfs_client;
34310430
TM		 1549 struct nfs_inode *nfsi = NFS_I(state->inode);
1550 struct nfs_delegation *deleg_cur;
83aa3e0f 1551 nfs4_stateid freeme = { };
34310430
TM		 1552 int ret = 0;
1553
dc0b027d 1554 fmode &= (FMODE_READ|FMODE_WRITE);
34310430
TM		 1555
1556 rcu_read_lock();
1557 deleg_cur = rcu_dereference(nfsi->delegation);
1558 if (deleg_cur == NULL)
1559 goto no_delegation;
1560
1561 spin_lock(&deleg_cur->lock);
17f26b12 1562 if (rcu_dereference(nfsi->delegation) != deleg_cur ||
d25be546 1563 test_bit(NFS_DELEGATION_RETURNING, &deleg_cur->flags) ||
dc0b027d 1564 (deleg_cur->type & fmode) != fmode)
34310430
TM		 1565 goto no_delegation_unlock;
1566
1567 if (delegation == NULL)
1568 delegation = &deleg_cur->stateid;
f597c537 1569 else if (!nfs4_stateid_match(&deleg_cur->stateid, delegation))
34310430
TM		 1570 goto no_delegation_unlock;
1571
b7391f44 1572 nfs_mark_delegation_referenced(deleg_cur);
1393d961
TM		 1573 __update_open_stateid(state, open_stateid, &deleg_cur->stateid,
1574 fmode, &freeme);
34310430
TM		 1575 ret = 1;
1576no_delegation_unlock:
1577 spin_unlock(&deleg_cur->lock);
1578no_delegation:
1579 rcu_read_unlock();
1580
1581 if (!ret && open_stateid != NULL) {
1393d961 1582 __update_open_stateid(state, open_stateid, NULL, fmode, &freeme);
34310430
TM		 1583 ret = 1;
1584 }
4f14c194 1585 if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags))
1393d961
TM		 1586 nfs4_schedule_state_manager(clp);
1587 if (freeme.type != 0)
1588 nfs4_test_and_free_stateid(server, &freeme,
1589 state->owner->so_cred);
34310430
TM		 1590
1591 return ret;
1592}
1593
39071e6f
TM		 1594static bool nfs4_update_lock_stateid(struct nfs4_lock_state *lsp,
1595 const nfs4_stateid *stateid)
1596{
1597 struct nfs4_state *state = lsp->ls_state;
1598 bool ret = false;
1599
1600 spin_lock(&state->state_lock);
1601 if (!nfs4_stateid_match_other(stateid, &lsp->ls_stateid))
1602 goto out_noupdate;
1603 if (!nfs4_stateid_is_newer(stateid, &lsp->ls_stateid))
1604 goto out_noupdate;
1605 nfs4_stateid_copy(&lsp->ls_stateid, stateid);
1606 ret = true;
1607out_noupdate:
1608 spin_unlock(&state->state_lock);
1609 return ret;
1610}
34310430 1611
dc0b027d 1612static void nfs4_return_incompatible_delegation(struct inode *inode, fmode_t fmode)
aac00a8d
TM		 1613{
1614 struct nfs_delegation *delegation;
1615
1616 rcu_read_lock();
1617 delegation = rcu_dereference(NFS_I(inode)->delegation);
dc0b027d 1618 if (delegation == NULL || (delegation->type & fmode) == fmode) {
aac00a8d
TM		 1619 rcu_read_unlock();
1620 return;
1621 }
1622 rcu_read_unlock();
57ec14c5 1623 nfs4_inode_return_delegation(inode);
aac00a8d
TM		 1624}
1625
6ee41268 1626static struct nfs4_state *nfs4_try_open_cached(struct nfs4_opendata *opendata)
aac00a8d
TM		 1627{
1628 struct nfs4_state *state = opendata->state;
1629 struct nfs_inode *nfsi = NFS_I(state->inode);
1630 struct nfs_delegation *delegation;
f448badd 1631 int open_mode = opendata->o_arg.open_flags;
dc0b027d 1632 fmode_t fmode = opendata->o_arg.fmode;
2a606188 1633 enum open_claim_type4 claim = opendata->o_arg.claim;
aac00a8d
TM		 1634 nfs4_stateid stateid;
1635 int ret = -EAGAIN;
1636
aac00a8d 1637 for (;;) {
61beef75 1638 spin_lock(&state->owner->so_lock);
dc0b027d 1639 if (can_open_cached(state, fmode, open_mode)) {
61beef75 1640 update_open_stateflags(state, fmode);
6ee41268 1641 spin_unlock(&state->owner->so_lock);
61beef75 1642 goto out_return_state;
6ee41268 1643 }
61beef75 1644 spin_unlock(&state->owner->so_lock);
34310430
TM		 1645 rcu_read_lock();
1646 delegation = rcu_dereference(nfsi->delegation);
2a606188 1647 if (!can_open_delegated(delegation, fmode, claim)) {
34310430 1648 rcu_read_unlock();
aac00a8d 1649 break;
34310430 1650 }
aac00a8d 1651 /* Save the delegation */
f597c537 1652 nfs4_stateid_copy(&stateid, &delegation->stateid);
aac00a8d 1653 rcu_read_unlock();
fa332941 1654 nfs_release_seqid(opendata->o_arg.seqid);
bdeca1b7
TM		 1655 if (!opendata->is_recover) {
1656 ret = nfs_may_open(state->inode, state->owner->so_cred, open_mode);
1657 if (ret != 0)
1658 goto out;
1659 }
aac00a8d 1660 ret = -EAGAIN;
34310430
TM		 1661
1662 /* Try to update the stateid using the delegation */
dc0b027d 1663 if (update_open_stateid(state, NULL, &stateid, fmode))
34310430 1664 goto out_return_state;
aac00a8d 1665 }
aac00a8d
TM		 1666out:
1667 return ERR_PTR(ret);
1668out_return_state:
1669 atomic_inc(&state->count);
1670 return state;
1671}
1672
e23008ec
AA		 1673static void
1674nfs4_opendata_check_deleg(struct nfs4_opendata *data, struct nfs4_state *state)
1675{
1676 struct nfs_client *clp = NFS_SERVER(state->inode)->nfs_client;
1677 struct nfs_delegation *delegation;
1678 int delegation_flags = 0;
1679
1680 rcu_read_lock();
1681 delegation = rcu_dereference(NFS_I(state->inode)->delegation);
1682 if (delegation)
1683 delegation_flags = delegation->flags;
1684 rcu_read_unlock();
72d79ff8
TM		 1685 switch (data->o_arg.claim) {
1686 default:
1687 break;
1688 case NFS4_OPEN_CLAIM_DELEGATE_CUR:
1689 case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
e23008ec
AA		 1690 pr_err_ratelimited("NFS: Broken NFSv4 server %s is "
1691 "returning a delegation for "
1692 "OPEN(CLAIM_DELEGATE_CUR)\n",
1693 clp->cl_hostname);
72d79ff8
TM		 1694 return;
1695 }
1696 if ((delegation_flags & 1UL<<NFS_DELEGATION_NEED_RECLAIM) == 0)
e23008ec
AA		 1697 nfs_inode_set_delegation(state->inode,
1698 data->owner->so_cred,
1699 &data->o_res);
1700 else
1701 nfs_inode_reclaim_delegation(state->inode,
1702 data->owner->so_cred,
1703 &data->o_res);
1704}
1705
1706/*
1707 * Check the inode attributes against the CLAIM_PREVIOUS returned attributes
1708 * and update the nfs4_state.
1709 */
1710static struct nfs4_state *
1711_nfs4_opendata_reclaim_to_nfs4_state(struct nfs4_opendata *data)
1712{
1713 struct inode *inode = data->state->inode;
1714 struct nfs4_state *state = data->state;
1715 int ret;
1716
d2bfda2e
WAA		 1717 if (!data->rpc_done) {
1718 if (data->rpc_status) {
1719 ret = data->rpc_status;
1720 goto err;
1721 }
1722 /* cached opens have already been processed */
1723 goto update;
e23008ec
AA		 1724 }
1725
e23008ec
AA		 1726 ret = nfs_refresh_inode(inode, &data->f_attr);
1727 if (ret)
1728 goto err;
1729
1730 if (data->o_res.delegation_type != 0)
1731 nfs4_opendata_check_deleg(data, state);
d2bfda2e 1732update:
e23008ec
AA		 1733 update_open_stateid(state, &data->o_res.stateid, NULL,
1734 data->o_arg.fmode);
d49f042a 1735 atomic_inc(&state->count);
e23008ec
AA		 1736
1737 return state;
1738err:
1739 return ERR_PTR(ret);
1740
1741}
1742
1743static struct nfs4_state *
1744_nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
24ac23ab
TM		 1745{
1746 struct inode *inode;
1747 struct nfs4_state *state = NULL;
1b370bc2 1748 int ret;
24ac23ab 1749
aac00a8d 1750 if (!data->rpc_done) {
6ee41268 1751 state = nfs4_try_open_cached(data);
9759b0fb 1752 trace_nfs4_cached_open(data->state);
aac00a8d
TM		 1753 goto out;
1754 }
1755
1b370bc2 1756 ret = -EAGAIN;
24ac23ab 1757 if (!(data->f_attr.valid & NFS_ATTR_FATTR))
1b370bc2 1758 goto err;
1775fd3e 1759 inode = nfs_fhget(data->dir->d_sb, &data->o_res.fh, &data->f_attr, data->f_label);
1b370bc2 1760 ret = PTR_ERR(inode);
03f28e3a 1761 if (IS_ERR(inode))
1b370bc2
TM		 1762 goto err;
1763 ret = -ENOMEM;
24ac23ab
TM		 1764 state = nfs4_get_open_state(inode, data->owner);
1765 if (state == NULL)
1b370bc2 1766 goto err_put_inode;
e23008ec
AA		 1767 if (data->o_res.delegation_type != 0)
1768 nfs4_opendata_check_deleg(data, state);
34310430 1769 update_open_stateid(state, &data->o_res.stateid, NULL,
dc0b027d 1770 data->o_arg.fmode);
24ac23ab 1771 iput(inode);
aac00a8d 1772out:
7aa262b5 1773 nfs_release_seqid(data->o_arg.seqid);
24ac23ab 1774 return state;
1b370bc2
TM		 1775err_put_inode:
1776 iput(inode);
1777err:
1778 return ERR_PTR(ret);
24ac23ab
TM		 1779}
1780
e23008ec
AA		 1781static struct nfs4_state *
1782nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
1783{
2e80dbe7
TM		 1784 struct nfs4_state *ret;
1785
e23008ec 1786 if (data->o_arg.claim == NFS4_OPEN_CLAIM_PREVIOUS)
2e80dbe7
TM		 1787 ret =_nfs4_opendata_reclaim_to_nfs4_state(data);
1788 else
1789 ret = _nfs4_opendata_to_nfs4_state(data);
1790 nfs4_sequence_free_slot(&data->o_res.seq_res);
1791 return ret;
e23008ec
AA		 1792}
1793
864472e9
TM		 1794static struct nfs_open_context *nfs4_state_find_open_context(struct nfs4_state *state)
1795{
1796 struct nfs_inode *nfsi = NFS_I(state->inode);
1797 struct nfs_open_context *ctx;
1798
1799 spin_lock(&state->inode->i_lock);
1800 list_for_each_entry(ctx, &nfsi->open_files, list) {
1801 if (ctx->state != state)
1802 continue;
1803 get_nfs_open_context(ctx);
1804 spin_unlock(&state->inode->i_lock);
1805 return ctx;
1806 }
1807 spin_unlock(&state->inode->i_lock);
1808 return ERR_PTR(-ENOENT);
1809}
1810
4a1c0893
TM		 1811static struct nfs4_opendata *nfs4_open_recoverdata_alloc(struct nfs_open_context *ctx,
1812 struct nfs4_state *state, enum open_claim_type4 claim)
6f220ed5
TM		 1813{
1814 struct nfs4_opendata *opendata;
1815
4a1c0893 1816 opendata = nfs4_opendata_alloc(ctx->dentry, state->owner, 0, 0,
1775fd3e 1817 NULL, NULL, claim, GFP_NOFS);
6f220ed5
TM		 1818 if (opendata == NULL)
1819 return ERR_PTR(-ENOMEM);
1820 opendata->state = state;
1821 atomic_inc(&state->count);
1822 return opendata;
1823}
1824
24311f88
TM		 1825static int nfs4_open_recover_helper(struct nfs4_opendata *opendata,
1826 fmode_t fmode)
864472e9 1827{
2ced46c2 1828 struct nfs4_state *newstate;
864472e9
TM		 1829 int ret;
1830
24311f88 1831 if (!nfs4_mode_match_open_stateid(opendata->state, fmode))
39f897fd 1832 return 0;
dc0b027d
TM		 1833 opendata->o_arg.open_flags = 0;
1834 opendata->o_arg.fmode = fmode;
be36e185
TM		 1835 opendata->o_arg.share_access = nfs4_map_atomic_open_share(
1836 NFS_SB(opendata->dentry->d_sb),
1837 fmode, 0);
2ced46c2
TM		 1838 memset(&opendata->o_res, 0, sizeof(opendata->o_res));
1839 memset(&opendata->c_res, 0, sizeof(opendata->c_res));
1840 nfs4_init_opendata_res(opendata);
b257957e 1841 ret = _nfs4_recover_proc_open(opendata);
864472e9
TM		 1842 if (ret != 0)
1843 return ret;
2ced46c2 1844 newstate = nfs4_opendata_to_nfs4_state(opendata);
1b370bc2
TM		 1845 if (IS_ERR(newstate))
1846 return PTR_ERR(newstate);
24311f88
TM		 1847 if (newstate != opendata->state)
1848 ret = -ESTALE;
643168c2 1849 nfs4_close_state(newstate, fmode);
24311f88 1850 return ret;
864472e9
TM		 1851}
1852
1853static int nfs4_open_recover(struct nfs4_opendata *opendata, struct nfs4_state *state)
1854{
864472e9
TM		 1855 int ret;
1856
4f14c194
TM		 1857 /* Don't trigger recovery in nfs_test_and_clear_all_open_stateid */
1858 clear_bit(NFS_O_RDWR_STATE, &state->flags);
1859 clear_bit(NFS_O_WRONLY_STATE, &state->flags);
1860 clear_bit(NFS_O_RDONLY_STATE, &state->flags);
864472e9 1861 /* memory barrier prior to reading state->n_* */
2ced46c2 1862 clear_bit(NFS_DELEGATED_STATE, &state->flags);
fd068b20 1863 clear_bit(NFS_OPEN_STATE, &state->flags);
864472e9 1864 smp_rmb();
24311f88
TM		 1865 ret = nfs4_open_recover_helper(opendata, FMODE_READ|FMODE_WRITE);
1866 if (ret != 0)
1867 return ret;
1868 ret = nfs4_open_recover_helper(opendata, FMODE_WRITE);
1869 if (ret != 0)
1870 return ret;
1871 ret = nfs4_open_recover_helper(opendata, FMODE_READ);
1872 if (ret != 0)
1873 return ret;
1ac7e2fd
TM		 1874 /*
1875 * We may have performed cached opens for all three recoveries.
1876 * Check if we need to update the current stateid.
1877 */
1878 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0 &&
f597c537 1879 !nfs4_stateid_match(&state->stateid, &state->open_stateid)) {
8bda4e4c 1880 write_seqlock(&state->seqlock);
1ac7e2fd 1881 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
f597c537 1882 nfs4_stateid_copy(&state->stateid, &state->open_stateid);
8bda4e4c 1883 write_sequnlock(&state->seqlock);
1ac7e2fd 1884 }
864472e9
TM		 1885 return 0;
1886}
1887
1da177e4
LT		 1888/*
1889 * OPEN_RECLAIM:
1890 * reclaim state on the server after a reboot.
1da177e4 1891 */
539cd03a 1892static int _nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state)
1da177e4 1893{
1ac7e2fd 1894 struct nfs_delegation *delegation;
864472e9 1895 struct nfs4_opendata *opendata;
dc0b027d 1896 fmode_t delegation_type = 0;
1da177e4
LT		 1897 int status;
1898
4a1c0893
TM		 1899 opendata = nfs4_open_recoverdata_alloc(ctx, state,
1900 NFS4_OPEN_CLAIM_PREVIOUS);
6f220ed5
TM		 1901 if (IS_ERR(opendata))
1902 return PTR_ERR(opendata);
1ac7e2fd
TM		 1903 rcu_read_lock();
1904 delegation = rcu_dereference(NFS_I(state->inode)->delegation);
15c831bf 1905 if (delegation != NULL && test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags) != 0)
65bbf6bd 1906 delegation_type = delegation->type;
1ac7e2fd 1907 rcu_read_unlock();
864472e9
TM		 1908 opendata->o_arg.u.delegation_type = delegation_type;
1909 status = nfs4_open_recover(opendata, state);
c6d00e63 1910 nfs4_opendata_put(opendata);
1da177e4
LT		 1911 return status;
1912}
1913
539cd03a 1914static int nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state)
1da177e4
LT		 1915{
1916 struct nfs_server *server = NFS_SERVER(state->inode);
1917 struct nfs4_exception exception = { };
1918 int err;
1919 do {
539cd03a 1920 err = _nfs4_do_open_reclaim(ctx, state);
42113a75 1921 trace_nfs4_open_reclaim(ctx, 0, err);
49f9a0fa
TM		 1922 if (nfs4_clear_cap_atomic_open_v1(server, err, &exception))
1923 continue;
168667c4 1924 if (err != -NFS4ERR_DELAY)
202b50dc
TM		 1925 break;
1926 nfs4_handle_exception(server, err, &exception);
1da177e4
LT		 1927 } while (exception.retry);
1928 return err;
1929}
1930
864472e9
TM		 1931static int nfs4_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *state)
1932{
1933 struct nfs_open_context *ctx;
1934 int ret;
1935
1936 ctx = nfs4_state_find_open_context(state);
1937 if (IS_ERR(ctx))
91876b13 1938 return -EAGAIN;
539cd03a 1939 ret = nfs4_do_open_reclaim(ctx, state);
864472e9
TM		 1940 put_nfs_open_context(ctx);
1941 return ret;
1942}
1943
db4f2e63 1944static int nfs4_handle_delegation_recall_error(struct nfs_server *server, struct nfs4_state *state, const nfs4_stateid *stateid, int err)
1da177e4 1945{
be76b5b6
TM		 1946 switch (err) {
1947 default:
1948 printk(KERN_ERR "NFS: %s: unhandled error "
1949 "%d.\n", __func__, err);
1950 case 0:
1951 case -ENOENT:
8eee52af 1952 case -EAGAIN:
be76b5b6
TM		 1953 case -ESTALE:
1954 break;
1955 case -NFS4ERR_BADSESSION:
1956 case -NFS4ERR_BADSLOT:
1957 case -NFS4ERR_BAD_HIGH_SLOT:
1958 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1959 case -NFS4ERR_DEADSESSION:
1960 set_bit(NFS_DELEGATED_STATE, &state->flags);
1961 nfs4_schedule_session_recovery(server->nfs_client->cl_session, err);
1962 return -EAGAIN;
1963 case -NFS4ERR_STALE_CLIENTID:
1964 case -NFS4ERR_STALE_STATEID:
1965 set_bit(NFS_DELEGATED_STATE, &state->flags);
be76b5b6
TM		 1966 /* Don't recall a delegation if it was lost */
1967 nfs4_schedule_lease_recovery(server->nfs_client);
1968 return -EAGAIN;
352297b9
CL		 1969 case -NFS4ERR_MOVED:
1970 nfs4_schedule_migration_recovery(server);
1971 return -EAGAIN;
8ef2f8d4
CL		 1972 case -NFS4ERR_LEASE_MOVED:
1973 nfs4_schedule_lease_moved_recovery(server->nfs_client);
1974 return -EAGAIN;
be76b5b6
TM		 1975 case -NFS4ERR_DELEG_REVOKED:
1976 case -NFS4ERR_ADMIN_REVOKED:
404ea356 1977 case -NFS4ERR_EXPIRED:
be76b5b6 1978 case -NFS4ERR_BAD_STATEID:
db4f2e63 1979 case -NFS4ERR_OPENMODE:
be76b5b6
TM		 1980 nfs_inode_find_state_and_recover(state->inode,
1981 stateid);
1982 nfs4_schedule_stateid_recovery(server, state);
869f9dfa 1983 return -EAGAIN;
be76b5b6
TM		 1984 case -NFS4ERR_DELAY:
1985 case -NFS4ERR_GRACE:
1986 set_bit(NFS_DELEGATED_STATE, &state->flags);
1987 ssleep(1);
1988 return -EAGAIN;
db4f2e63
TM		 1989 case -ENOMEM:
1990 case -NFS4ERR_DENIED:
1991 /* kill_proc(fl->fl_pid, SIGLOST, 1); */
1992 return 0;
be76b5b6 1993 }
1da177e4
LT		 1994 return err;
1995}
1996
24311f88
TM		 1997int nfs4_open_delegation_recall(struct nfs_open_context *ctx,
1998 struct nfs4_state *state, const nfs4_stateid *stateid,
1999 fmode_t type)
db4f2e63
TM		 2000{
2001 struct nfs_server *server = NFS_SERVER(state->inode);
2002 struct nfs4_opendata *opendata;
24311f88 2003 int err = 0;
db4f2e63
TM		 2004
2005 opendata = nfs4_open_recoverdata_alloc(ctx, state,
2006 NFS4_OPEN_CLAIM_DELEG_CUR_FH);
2007 if (IS_ERR(opendata))
2008 return PTR_ERR(opendata);
2009 nfs4_stateid_copy(&opendata->o_arg.u.delegation, stateid);
5e99b532
JL		 2010 write_seqlock(&state->seqlock);
2011 nfs4_stateid_copy(&state->stateid, &state->open_stateid);
2012 write_sequnlock(&state->seqlock);
24311f88
TM		 2013 clear_bit(NFS_DELEGATED_STATE, &state->flags);
2014 switch (type & (FMODE_READ|FMODE_WRITE)) {
2015 case FMODE_READ|FMODE_WRITE:
2016 case FMODE_WRITE:
2017 err = nfs4_open_recover_helper(opendata, FMODE_READ|FMODE_WRITE);
2018 if (err)
2019 break;
2020 err = nfs4_open_recover_helper(opendata, FMODE_WRITE);
2021 if (err)
2022 break;
2023 case FMODE_READ:
2024 err = nfs4_open_recover_helper(opendata, FMODE_READ);
2025 }
db4f2e63
TM		 2026 nfs4_opendata_put(opendata);
2027 return nfs4_handle_delegation_recall_error(server, state, stateid, err);
2028}
2029
be05c860
CL		 2030static void nfs4_open_confirm_prepare(struct rpc_task *task, void *calldata)
2031{
2032 struct nfs4_opendata *data = calldata;
2033
7981c8a6
AS		 2034 nfs4_setup_sequence(data->o_arg.server->nfs_client,
2035 &data->c_arg.seq_args, &data->c_res.seq_res, task);
be05c860
CL		 2036}
2037
cdd4e68b
TM		 2038static void nfs4_open_confirm_done(struct rpc_task *task, void *calldata)
2039{
2040 struct nfs4_opendata *data = calldata;
2041
17ead6c8 2042 nfs40_sequence_done(task, &data->c_res.seq_res);
be05c860 2043
cdd4e68b 2044 data->rpc_status = task->tk_status;
26e976a8 2045 if (data->rpc_status == 0) {
f597c537 2046 nfs4_stateid_copy(&data->o_res.stateid, &data->c_res.stateid);
bb22629e 2047 nfs_confirm_seqid(&data->owner->so_seqid, 0);
26e976a8 2048 renew_lease(data->o_res.server, data->timestamp);
3e309914 2049 data->rpc_done = 1;
26e976a8 2050 }
cdd4e68b
TM		 2051}
2052
2053static void nfs4_open_confirm_release(void *calldata)
2054{
2055 struct nfs4_opendata *data = calldata;
2056 struct nfs4_state *state = NULL;
2057
2058 /* If this request hasn't been cancelled, do nothing */
2059 if (data->cancelled == 0)
2060 goto out_free;
2061 /* In case of error, no cleanup! */
3e309914 2062 if (!data->rpc_done)
cdd4e68b 2063 goto out_free;
cdd4e68b 2064 state = nfs4_opendata_to_nfs4_state(data);
1b370bc2 2065 if (!IS_ERR(state))
643168c2 2066 nfs4_close_state(state, data->o_arg.fmode);
cdd4e68b 2067out_free:
c6d00e63 2068 nfs4_opendata_put(data);
cdd4e68b
TM		 2069}
2070
2071static const struct rpc_call_ops nfs4_open_confirm_ops = {
be05c860 2072 .rpc_call_prepare = nfs4_open_confirm_prepare,
cdd4e68b
TM		 2073 .rpc_call_done = nfs4_open_confirm_done,
2074 .rpc_release = nfs4_open_confirm_release,
2075};
2076
2077/*
2078 * Note: On error, nfs4_proc_open_confirm will free the struct nfs4_opendata
2079 */
2080static int _nfs4_proc_open_confirm(struct nfs4_opendata *data)
2081{
2b0143b5 2082 struct nfs_server *server = NFS_SERVER(d_inode(data->dir));
cdd4e68b 2083 struct rpc_task *task;
5138fde0
TM		 2084 struct rpc_message msg = {
2085 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_CONFIRM],
2086 .rpc_argp = &data->c_arg,
2087 .rpc_resp = &data->c_res,
2088 .rpc_cred = data->owner->so_cred,
2089 };
c970aa85
TM		 2090 struct rpc_task_setup task_setup_data = {
2091 .rpc_client = server->client,
5138fde0 2092 .rpc_message = &msg,
c970aa85
TM		 2093 .callback_ops = &nfs4_open_confirm_ops,
2094 .callback_data = data,
101070ca 2095 .workqueue = nfsiod_workqueue,
c970aa85
TM		 2096 .flags = RPC_TASK_ASYNC,
2097 };
1da177e4
LT		 2098 int status;
2099
17ead6c8 2100 nfs4_init_sequence(&data->c_arg.seq_args, &data->c_res.seq_res, 1);
c6d00e63 2101 kref_get(&data->kref);
3e309914
TM		 2102 data->rpc_done = 0;
2103 data->rpc_status = 0;
5138fde0 2104 data->timestamp = jiffies;
e92c1e0d
BC		 2105 if (data->is_recover)
2106 nfs4_set_sequence_privileged(&data->c_arg.seq_args);
c970aa85 2107 task = rpc_run_task(&task_setup_data);
7a1218a2 2108 if (IS_ERR(task))
cdd4e68b 2109 return PTR_ERR(task);
cdd4e68b
TM		 2110 status = nfs4_wait_for_completion_rpc_task(task);
2111 if (status != 0) {
2112 data->cancelled = 1;
2113 smp_wmb();
2114 } else
2115 status = data->rpc_status;
e6b3c4db 2116 rpc_put_task(task);
1da177e4
LT		 2117 return status;
2118}
2119
24ac23ab 2120static void nfs4_open_prepare(struct rpc_task *task, void *calldata)
1da177e4 2121{
24ac23ab
TM		 2122 struct nfs4_opendata *data = calldata;
2123 struct nfs4_state_owner *sp = data->owner;
549b19cc 2124 struct nfs_client *clp = sp->so_server->nfs_client;
2a606188 2125 enum open_claim_type4 claim = data->o_arg.claim;
5138fde0 2126
24ac23ab 2127 if (nfs_wait_on_sequence(data->o_arg.seqid, task) != 0)
c8da19b9 2128 goto out_wait;
aac00a8d
TM		 2129 /*
2130 * Check if we still need to send an OPEN call, or if we can use
2131 * a delegation instead.
2132 */
2133 if (data->state != NULL) {
2134 struct nfs_delegation *delegation;
2135
dc0b027d 2136 if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags))
6ee41268 2137 goto out_no_action;
aac00a8d
TM		 2138 rcu_read_lock();
2139 delegation = rcu_dereference(NFS_I(data->state->inode)->delegation);
2a606188 2140 if (can_open_delegated(delegation, data->o_arg.fmode, claim))
652f89f6 2141 goto unlock_no_action;
aac00a8d
TM		 2142 rcu_read_unlock();
2143 }
95b72eb0 2144 /* Update client id. */
549b19cc 2145 data->o_arg.clientid = clp->cl_clientid;
2a606188
TM		 2146 switch (claim) {
2147 default:
2148 break;
8188df17
TM		 2149 case NFS4_OPEN_CLAIM_PREVIOUS:
2150 case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
2151 case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
e23008ec 2152 data->o_arg.open_bitmap = &nfs4_open_noattr_bitmap[0];
8188df17
TM		 2153 case NFS4_OPEN_CLAIM_FH:
2154 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_NOATTR];
6f220ed5
TM		 2155 nfs_copy_fh(&data->o_res.fh, data->o_arg.fh);
2156 }
26e976a8 2157 data->timestamp = jiffies;
42e1cca7 2158 if (nfs4_setup_sequence(data->o_arg.server->nfs_client,
d898528c 2159 &data->o_arg.seq_args,
2240a9e2
TM		 2160 &data->o_res.seq_res,
2161 task) != 0)
2162 nfs_release_seqid(data->o_arg.seqid);
549b19cc
TM		 2163
2164 /* Set the create mode (note dependency on the session type) */
2165 data->o_arg.createmode = NFS4_CREATE_UNCHECKED;
2166 if (data->o_arg.open_flags & O_EXCL) {
2167 data->o_arg.createmode = NFS4_CREATE_EXCLUSIVE;
2168 if (nfs4_has_persistent_session(clp))
2169 data->o_arg.createmode = NFS4_CREATE_GUARDED;
2170 else if (clp->cl_mvops->minor_version > 0)
2171 data->o_arg.createmode = NFS4_CREATE_EXCLUSIVE4_1;
2172 }
6ee41268 2173 return;
652f89f6 2174unlock_no_action:
9759b0fb 2175 trace_nfs4_cached_open(data->state);
652f89f6 2176 rcu_read_unlock();
6ee41268
TM		 2177out_no_action:
2178 task->tk_action = NULL;
c8da19b9 2179out_wait:
b75ad4cd 2180 nfs4_sequence_done(task, &data->o_res.seq_res);
b257957e
AB		 2181}
2182
24ac23ab
TM		 2183static void nfs4_open_done(struct rpc_task *task, void *calldata)
2184{
2185 struct nfs4_opendata *data = calldata;
1da177e4 2186
24ac23ab 2187 data->rpc_status = task->tk_status;
d898528c 2188
2e80dbe7 2189 if (!nfs4_sequence_process(task, &data->o_res.seq_res))
14516c3a 2190 return;
d898528c 2191
24ac23ab 2192 if (task->tk_status == 0) {
807d66d8
TM		 2193 if (data->o_res.f_attr->valid & NFS_ATTR_FATTR_TYPE) {
2194 switch (data->o_res.f_attr->mode & S_IFMT) {
6f926b5b
TM		 2195 case S_IFREG:
2196 break;
2197 case S_IFLNK:
24ac23ab 2198 data->rpc_status = -ELOOP;
6f926b5b
TM		 2199 break;
2200 case S_IFDIR:
24ac23ab 2201 data->rpc_status = -EISDIR;
6f926b5b
TM		 2202 break;
2203 default:
24ac23ab 2204 data->rpc_status = -ENOTDIR;
807d66d8 2205 }
6f926b5b 2206 }
26e976a8 2207 renew_lease(data->o_res.server, data->timestamp);
0f9f95e0
TM		 2208 if (!(data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM))
2209 nfs_confirm_seqid(&data->owner->so_seqid, 0);
6f926b5b 2210 }
3e309914 2211 data->rpc_done = 1;
24ac23ab 2212}
6f926b5b 2213
24ac23ab
TM		 2214static void nfs4_open_release(void *calldata)
2215{
2216 struct nfs4_opendata *data = calldata;
2217 struct nfs4_state *state = NULL;
2218
2219 /* If this request hasn't been cancelled, do nothing */
2220 if (data->cancelled == 0)
2221 goto out_free;
2222 /* In case of error, no cleanup! */
3e309914 2223 if (data->rpc_status != 0 || !data->rpc_done)
24ac23ab
TM		 2224 goto out_free;
2225 /* In case we need an open_confirm, no cleanup! */
2226 if (data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM)
2227 goto out_free;
24ac23ab 2228 state = nfs4_opendata_to_nfs4_state(data);
1b370bc2 2229 if (!IS_ERR(state))
643168c2 2230 nfs4_close_state(state, data->o_arg.fmode);
24ac23ab 2231out_free:
c6d00e63 2232 nfs4_opendata_put(data);
24ac23ab
TM		 2233}
2234
2235static const struct rpc_call_ops nfs4_open_ops = {
2236 .rpc_call_prepare = nfs4_open_prepare,
2237 .rpc_call_done = nfs4_open_done,
2238 .rpc_release = nfs4_open_release,
2239};
2240
b257957e 2241static int nfs4_run_open_task(struct nfs4_opendata *data, int isrecover)
24ac23ab 2242{
2b0143b5 2243 struct inode *dir = d_inode(data->dir);
24ac23ab
TM		 2244 struct nfs_server *server = NFS_SERVER(dir);
2245 struct nfs_openargs *o_arg = &data->o_arg;
2246 struct nfs_openres *o_res = &data->o_res;
2247 struct rpc_task *task;
5138fde0
TM		 2248 struct rpc_message msg = {
2249 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN],
2250 .rpc_argp = o_arg,
2251 .rpc_resp = o_res,
2252 .rpc_cred = data->owner->so_cred,
2253 };
c970aa85
TM		 2254 struct rpc_task_setup task_setup_data = {
2255 .rpc_client = server->client,
5138fde0 2256 .rpc_message = &msg,
c970aa85
TM		 2257 .callback_ops = &nfs4_open_ops,
2258 .callback_data = data,
101070ca 2259 .workqueue = nfsiod_workqueue,
c970aa85
TM		 2260 .flags = RPC_TASK_ASYNC,
2261 };
24ac23ab
TM		 2262 int status;
2263
a9c92d6b 2264 nfs4_init_sequence(&o_arg->seq_args, &o_res->seq_res, 1);
c6d00e63 2265 kref_get(&data->kref);
3e309914
TM		 2266 data->rpc_done = 0;
2267 data->rpc_status = 0;
2ced46c2 2268 data->cancelled = 0;
bdeca1b7
TM		 2269 data->is_recover = 0;
2270 if (isrecover) {
8fe72bac 2271 nfs4_set_sequence_privileged(&o_arg->seq_args);
bdeca1b7
TM		 2272 data->is_recover = 1;
2273 }
c970aa85 2274 task = rpc_run_task(&task_setup_data);
b257957e
AB		 2275 if (IS_ERR(task))
2276 return PTR_ERR(task);
2277 status = nfs4_wait_for_completion_rpc_task(task);
2278 if (status != 0) {
2279 data->cancelled = 1;
2280 smp_wmb();
2281 } else
2282 status = data->rpc_status;
2283 rpc_put_task(task);
2284
2285 return status;
2286}
2287
2288static int _nfs4_recover_proc_open(struct nfs4_opendata *data)
2289{
2b0143b5 2290 struct inode *dir = d_inode(data->dir);
b257957e
AB		 2291 struct nfs_openres *o_res = &data->o_res;
2292 int status;
2293
2294 status = nfs4_run_open_task(data, 1);
2295 if (status != 0 || !data->rpc_done)
2296 return status;
2297
6926afd1
TM		 2298 nfs_fattr_map_and_free_names(NFS_SERVER(dir), &data->f_attr);
2299
b257957e
AB		 2300 if (o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) {
2301 status = _nfs4_proc_open_confirm(data);
2302 if (status != 0)
2303 return status;
2304 }
2305
2306 return status;
2307}
2308
f3792d63
TM		 2309/*
2310 * Additional permission checks in order to distinguish between an
2311 * open for read, and an open for execute. This works around the
2312 * fact that NFSv4 OPEN treats read and execute permissions as being
2313 * the same.
2314 * Note that in the non-execute case, we want to turn off permission
2315 * checking if we just created a new file (POSIX open() semantics).
2316 */
6168f62c
WAA		 2317static int nfs4_opendata_access(struct rpc_cred *cred,
2318 struct nfs4_opendata *opendata,
f8d9a897
WAA		 2319 struct nfs4_state *state, fmode_t fmode,
2320 int openflags)
6168f62c
WAA		 2321{
2322 struct nfs_access_entry cache;
2323 u32 mask;
2324
2325 /* access call failed or for some reason the server doesn't
2326 * support any access modes -- defer access call until later */
2327 if (opendata->o_res.access_supported == 0)
2328 return 0;
2329
2330 mask = 0;
f3792d63
TM		 2331 /*
2332 * Use openflags to check for exec, because fmode won't
2333 * always have FMODE_EXEC set when file open for exec.
2334 */
f8d9a897
WAA		 2335 if (openflags & __FMODE_EXEC) {
2336 /* ONLY check for exec rights */
2337 mask = MAY_EXEC;
f3792d63 2338 } else if ((fmode & FMODE_READ) && !opendata->file_created)
f8d9a897 2339 mask = MAY_READ;
6168f62c
WAA		 2340
2341 cache.cred = cred;
2342 cache.jiffies = jiffies;
2343 nfs_access_set_mask(&cache, opendata->o_res.access_result);
2344 nfs_access_add_cache(state->inode, &cache);
2345
bbd3a8ee 2346 if ((mask & ~cache.mask & (MAY_READ | MAY_EXEC)) == 0)
6168f62c
WAA		 2347 return 0;
2348
2349 /* even though OPEN succeeded, access is denied. Close the file */
2350 nfs4_close_state(state, fmode);
998f40b5 2351 return -EACCES;
6168f62c
WAA		 2352}
2353
b257957e
AB		 2354/*
2355 * Note: On error, nfs4_proc_open will free the struct nfs4_opendata
2356 */
2357static int _nfs4_proc_open(struct nfs4_opendata *data)
2358{
2b0143b5 2359 struct inode *dir = d_inode(data->dir);
b257957e
AB		 2360 struct nfs_server *server = NFS_SERVER(dir);
2361 struct nfs_openargs *o_arg = &data->o_arg;
2362 struct nfs_openres *o_res = &data->o_res;
2363 int status;
2364
2365 status = nfs4_run_open_task(data, 0);
08ef7bd3
TM		 2366 if (!data->rpc_done)
2367 return status;
2368 if (status != 0) {
2369 if (status == -NFS4ERR_BADNAME &&
2370 !(o_arg->open_flags & O_CREAT))
2371 return -ENOENT;
24ac23ab 2372 return status;
08ef7bd3 2373 }
24ac23ab 2374
6926afd1
TM		 2375 nfs_fattr_map_and_free_names(server, &data->f_attr);
2376
5bc2afc2 2377 if (o_arg->open_flags & O_CREAT) {
5bc2afc2
TM		 2378 if (o_arg->open_flags & O_EXCL)
2379 data->file_created = 1;
2380 else if (o_res->cinfo.before != o_res->cinfo.after)
2381 data->file_created = 1;
2dfc6173 2382 if (data->file_created || dir->i_version != o_res->cinfo.after)
d3129ef6
TM		 2383 update_changeattr(dir, &o_res->cinfo,
2384 o_res->f_attr->time_start);
5bc2afc2 2385 }
0df5dd4a
TM		 2386 if ((o_res->rflags & NFS4_OPEN_RESULT_LOCKTYPE_POSIX) == 0)
2387 server->caps &= ~NFS_CAP_POSIX_LOCK;
1da177e4 2388 if(o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) {
cdd4e68b 2389 status = _nfs4_proc_open_confirm(data);
1da177e4 2390 if (status != 0)
24ac23ab 2391 return status;
1da177e4
LT		 2392 }
2393 if (!(o_res->f_attr->valid & NFS_ATTR_FATTR))
8935ef66 2394 nfs4_proc_getattr(server, &o_res->fh, o_res->f_attr, o_res->f_label);
24ac23ab 2395 return 0;
1da177e4
LT		 2396}
2397
d83217c1
AA		 2398static int nfs4_recover_expired_lease(struct nfs_server *server)
2399{
2400 return nfs4_client_recover_expired_lease(server->nfs_client);
2401}
2402
1da177e4
LT		 2403/*
2404 * OPEN_EXPIRED:
2405 * reclaim state on the server after a network partition.
2406 * Assumes caller holds the appropriate lock
2407 */
539cd03a 2408static int _nfs4_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state)
1da177e4 2409{
e56e0b78 2410 struct nfs4_opendata *opendata;
864472e9 2411 int ret;
1da177e4 2412
4a1c0893 2413 opendata = nfs4_open_recoverdata_alloc(ctx, state,
49f9a0fa 2414 NFS4_OPEN_CLAIM_FH);
6f220ed5
TM		 2415 if (IS_ERR(opendata))
2416 return PTR_ERR(opendata);
864472e9 2417 ret = nfs4_open_recover(opendata, state);
35d05778 2418 if (ret == -ESTALE)
3d4ff43d 2419 d_drop(ctx->dentry);
c6d00e63 2420 nfs4_opendata_put(opendata);
864472e9 2421 return ret;
1da177e4
LT		 2422}
2423
a9ed2e25 2424static int nfs4_do_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state)
202b50dc 2425{
539cd03a 2426 struct nfs_server *server = NFS_SERVER(state->inode);
202b50dc
TM		 2427 struct nfs4_exception exception = { };
2428 int err;
2429
2430 do {
539cd03a 2431 err = _nfs4_open_expired(ctx, state);
42113a75 2432 trace_nfs4_open_expired(ctx, 0, err);
49f9a0fa
TM		 2433 if (nfs4_clear_cap_atomic_open_v1(server, err, &exception))
2434 continue;
a9ed2e25
TM		 2435 switch (err) {
2436 default:
2437 goto out;
2438 case -NFS4ERR_GRACE:
2439 case -NFS4ERR_DELAY:
2440 nfs4_handle_exception(server, err, &exception);
2441 err = 0;
2442 }
202b50dc 2443 } while (exception.retry);
a9ed2e25 2444out:
202b50dc
TM		 2445 return err;
2446}
2447
1da177e4
LT		 2448static int nfs4_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)
2449{
1da177e4 2450 struct nfs_open_context *ctx;
864472e9 2451 int ret;
1da177e4 2452
864472e9
TM		 2453 ctx = nfs4_state_find_open_context(state);
2454 if (IS_ERR(ctx))
91876b13 2455 return -EAGAIN;
539cd03a 2456 ret = nfs4_do_open_expired(ctx, state);
864472e9
TM		 2457 put_nfs_open_context(ctx);
2458 return ret;
1da177e4
LT		 2459}
2460
41020b67
TM		 2461static void nfs_finish_clear_delegation_stateid(struct nfs4_state *state,
2462 const nfs4_stateid *stateid)
4dfd4f7a 2463{
41020b67 2464 nfs_remove_bad_delegation(state->inode, stateid);
4dfd4f7a
TM		 2465 write_seqlock(&state->seqlock);
2466 nfs4_stateid_copy(&state->stateid, &state->open_stateid);
2467 write_sequnlock(&state->seqlock);
2468 clear_bit(NFS_DELEGATED_STATE, &state->flags);
2469}
2470
2471static void nfs40_clear_delegation_stateid(struct nfs4_state *state)
2472{
2473 if (rcu_access_pointer(NFS_I(state->inode)->delegation) != NULL)
41020b67 2474 nfs_finish_clear_delegation_stateid(state, NULL);
4dfd4f7a
TM		 2475}
2476
2477static int nfs40_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)
2478{
2479 /* NFSv4.0 doesn't allow for delegation recovery on open expire */
2480 nfs40_clear_delegation_stateid(state);
2481 return nfs4_open_expired(sp, state);
2482}
2483
45870d69
TM		 2484static int nfs40_test_and_free_expired_stateid(struct nfs_server *server,
2485 nfs4_stateid *stateid,
2486 struct rpc_cred *cred)
2487{
2488 return -NFS4ERR_BAD_STATEID;
2489}
2490
f062eb6c 2491#if defined(CONFIG_NFS_V4_1)
4586f6e2
TM		 2492static int nfs41_test_and_free_expired_stateid(struct nfs_server *server,
2493 nfs4_stateid *stateid,
2494 struct rpc_cred *cred)
2495{
2496 int status;
2497
f7a62ada
TM		 2498 switch (stateid->type) {
2499 default:
2500 break;
2501 case NFS4_INVALID_STATEID_TYPE:
2502 case NFS4_SPECIAL_STATEID_TYPE:
2503 return -NFS4ERR_BAD_STATEID;
2504 case NFS4_REVOKED_STATEID_TYPE:
2505 goto out_free;
2506 }
4586f6e2 2507
f7a62ada 2508 status = nfs41_test_stateid(server, stateid, cred);
4586f6e2
TM		 2509 switch (status) {
2510 case -NFS4ERR_EXPIRED:
2511 case -NFS4ERR_ADMIN_REVOKED:
2512 case -NFS4ERR_DELEG_REVOKED:
f7a62ada
TM		 2513 break;
2514 default:
4586f6e2
TM		 2515 return status;
2516 }
f7a62ada
TM		 2517out_free:
2518 /* Ack the revoked state to the server */
f0b0bf88 2519 nfs41_free_stateid(server, stateid, cred, true);
f7a62ada 2520 return -NFS4ERR_EXPIRED;
4586f6e2
TM		 2521}
2522
0c116cad 2523static void nfs41_check_delegation_stateid(struct nfs4_state *state)
f062eb6c 2524{
f062eb6c 2525 struct nfs_server *server = NFS_SERVER(state->inode);
0c116cad 2526 nfs4_stateid stateid;
ab7cb0df 2527 struct nfs_delegation *delegation;
0c116cad
TM		 2528 struct rpc_cred *cred;
2529 int status;
3e60ffdd 2530
ab7cb0df
TM		 2531 /* Get the delegation credential for use by test/free_stateid */
2532 rcu_read_lock();
2533 delegation = rcu_dereference(NFS_I(state->inode)->delegation);
0c116cad 2534 if (delegation == NULL) {
ab7cb0df 2535 rcu_read_unlock();
0c116cad
TM		 2536 return;
2537 }
2538
2539 nfs4_stateid_copy(&stateid, &delegation->stateid);
4c8e5447
TM		 2540 if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) {
2541 rcu_read_unlock();
41020b67 2542 nfs_finish_clear_delegation_stateid(state, &stateid);
4c8e5447
TM		 2543 return;
2544 }
0c116cad 2545
63d63cbf
TM		 2546 if (!test_and_clear_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags)) {
2547 rcu_read_unlock();
2548 return;
2549 }
2550
0c116cad
TM		 2551 cred = get_rpccred(delegation->cred);
2552 rcu_read_unlock();
4586f6e2 2553 status = nfs41_test_and_free_expired_stateid(server, &stateid, cred);
0c116cad 2554 trace_nfs4_test_delegation_stateid(state, NULL, status);
f7a62ada 2555 if (status == -NFS4ERR_EXPIRED || status == -NFS4ERR_BAD_STATEID)
41020b67 2556 nfs_finish_clear_delegation_stateid(state, &stateid);
ab7cb0df 2557
0c116cad 2558 put_rpccred(cred);
3e60ffdd
CL		 2559}
2560
c5896fc8
TM		 2561/**
2562 * nfs41_check_expired_locks - possibly free a lock stateid
2563 *
2564 * @state: NFSv4 state for an inode
2565 *
2566 * Returns NFS_OK if recovery for this stateid is now finished.
2567 * Otherwise a negative NFS4ERR value is returned.
2568 */
2569static int nfs41_check_expired_locks(struct nfs4_state *state)
2570{
2571 int status, ret = NFS_OK;
d75a6a0e 2572 struct nfs4_lock_state *lsp, *prev = NULL;
c5896fc8
TM		 2573 struct nfs_server *server = NFS_SERVER(state->inode);
2574
2575 if (!test_bit(LK_STATE_IN_USE, &state->flags))
2576 goto out;
d75a6a0e
BC		 2577
2578 spin_lock(&state->state_lock);
c5896fc8
TM		 2579 list_for_each_entry(lsp, &state->lock_states, ls_locks) {
2580 if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags)) {
2581 struct rpc_cred *cred = lsp->ls_state->owner->so_cred;
2582
d75a6a0e
BC		 2583 atomic_inc(&lsp->ls_count);
2584 spin_unlock(&state->state_lock);
2585
2586 nfs4_put_lock_state(prev);
2587 prev = lsp;
2588
c5896fc8
TM		 2589 status = nfs41_test_and_free_expired_stateid(server,
2590 &lsp->ls_stateid,
2591 cred);
2592 trace_nfs4_test_lock_stateid(state, lsp, status);
2593 if (status == -NFS4ERR_EXPIRED ||
2594 status == -NFS4ERR_BAD_STATEID) {
2595 clear_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags);
67dd4830 2596 lsp->ls_stateid.type = NFS4_INVALID_STATEID_TYPE;
c5896fc8
TM		 2597 if (!recover_lost_locks)
2598 set_bit(NFS_LOCK_LOST, &lsp->ls_flags);
2599 } else if (status != NFS_OK) {
2600 ret = status;
d75a6a0e
BC		 2601 nfs4_put_lock_state(prev);
2602 goto out;
c5896fc8 2603 }
d75a6a0e 2604 spin_lock(&state->state_lock);
c5896fc8 2605 }
d75a6a0e
BC		 2606 }
2607 spin_unlock(&state->state_lock);
2608 nfs4_put_lock_state(prev);
c5896fc8
TM		 2609out:
2610 return ret;
2611}
2612
3e60ffdd
CL		 2613/**
2614 * nfs41_check_open_stateid - possibly free an open stateid
2615 *
2616 * @state: NFSv4 state for an inode
2617 *
2618 * Returns NFS_OK if recovery for this stateid is now finished.
2619 * Otherwise a negative NFS4ERR value is returned.
2620 */
2621static int nfs41_check_open_stateid(struct nfs4_state *state)
2622{
2623 struct nfs_server *server = NFS_SERVER(state->inode);
fcb6d9c6 2624 nfs4_stateid *stateid = &state->open_stateid;
ab7cb0df 2625 struct rpc_cred *cred = state->owner->so_cred;
3e60ffdd
CL		 2626 int status;
2627
b134fc4a 2628 if (test_bit(NFS_OPEN_STATE, &state->flags) == 0) {
8a64c4ef
TM		 2629 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) {
2630 if (nfs4_have_delegation(state->inode, state->state))
2631 return NFS_OK;
2632 return -NFS4ERR_OPENMODE;
2633 }
3e60ffdd 2634 return -NFS4ERR_BAD_STATEID;
b134fc4a 2635 }
4586f6e2 2636 status = nfs41_test_and_free_expired_stateid(server, stateid, cred);
08cb47fa 2637 trace_nfs4_test_open_stateid(state, NULL, status);
f7a62ada 2638 if (status == -NFS4ERR_EXPIRED || status == -NFS4ERR_BAD_STATEID) {
3e60ffdd
CL		 2639 clear_bit(NFS_O_RDONLY_STATE, &state->flags);
2640 clear_bit(NFS_O_WRONLY_STATE, &state->flags);
2641 clear_bit(NFS_O_RDWR_STATE, &state->flags);
fd068b20 2642 clear_bit(NFS_OPEN_STATE, &state->flags);
67dd4830 2643 stateid->type = NFS4_INVALID_STATEID_TYPE;
b01dd1d8 2644 }
8a64c4ef
TM		 2645 if (status != NFS_OK)
2646 return status;
2647 if (nfs_open_stateid_recover_openmode(state))
2648 return -NFS4ERR_OPENMODE;
2649 return NFS_OK;
b01dd1d8
BS		 2650}
2651
2652static int nfs41_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)
2653{
eb64cf96 2654 int status;
b01dd1d8 2655
0c116cad 2656 nfs41_check_delegation_stateid(state);
c5896fc8
TM		 2657 status = nfs41_check_expired_locks(state);
2658 if (status != NFS_OK)
2659 return status;
3e60ffdd 2660 status = nfs41_check_open_stateid(state);
eb64cf96
CL		 2661 if (status != NFS_OK)
2662 status = nfs4_open_expired(sp, state);
2663 return status;
f062eb6c
BS		 2664}
2665#endif
2666
aa53ed54
JL		 2667/*
2668 * on an EXCLUSIVE create, the server should send back a bitmask with FATTR4-*
2669 * fields corresponding to attributes that were used to store the verifier.
2670 * Make sure we clobber those fields in the later setattr call
2671 */
5334c5bd
KM		 2672static inline void nfs4_exclusive_attrset(struct nfs4_opendata *opendata,
2673 struct iattr *sattr, struct nfs4_label **label)
aa53ed54 2674{
5334c5bd
KM		 2675 const u32 *attrset = opendata->o_res.attrset;
2676
2677 if ((attrset[1] & FATTR4_WORD1_TIME_ACCESS) &&
aa53ed54
JL		 2678 !(sattr->ia_valid & ATTR_ATIME_SET))
2679 sattr->ia_valid |= ATTR_ATIME;
2680
5334c5bd 2681 if ((attrset[1] & FATTR4_WORD1_TIME_MODIFY) &&
aa53ed54
JL		 2682 !(sattr->ia_valid & ATTR_MTIME_SET))
2683 sattr->ia_valid |= ATTR_MTIME;
5334c5bd
KM		 2684
2685 /* Except MODE, it seems harmless of setting twice. */
a430607b
BC		 2686 if (opendata->o_arg.createmode != NFS4_CREATE_EXCLUSIVE &&
2687 attrset[1] & FATTR4_WORD1_MODE)
5334c5bd
KM		 2688 sattr->ia_valid &= ~ATTR_MODE;
2689
2690 if (attrset[2] & FATTR4_WORD2_SECURITY_LABEL)
2691 *label = NULL;
aa53ed54
JL		 2692}
2693
c21443c2
TM		 2694static int _nfs4_open_and_get_state(struct nfs4_opendata *opendata,
2695 fmode_t fmode,
2696 int flags,
3efb9722 2697 struct nfs_open_context *ctx)
c21443c2
TM		 2698{
2699 struct nfs4_state_owner *sp = opendata->owner;
2700 struct nfs_server *server = sp->so_server;
275bb307 2701 struct dentry *dentry;
c21443c2
TM		 2702 struct nfs4_state *state;
2703 unsigned int seq;
2704 int ret;
2705
2706 seq = raw_seqcount_begin(&sp->so_reclaim_seqcount);
2707
2708 ret = _nfs4_proc_open(opendata);
dca78001 2709 if (ret != 0)
c21443c2
TM		 2710 goto out;
2711
2712 state = nfs4_opendata_to_nfs4_state(opendata);
2713 ret = PTR_ERR(state);
2714 if (IS_ERR(state))
2715 goto out;
2716 if (server->caps & NFS_CAP_POSIX_LOCK)
2717 set_bit(NFS_STATE_POSIX_LOCKS, &state->flags);
a8ce377a
JL		 2718 if (opendata->o_res.rflags & NFS4_OPEN_RESULT_MAY_NOTIFY_LOCK)
2719 set_bit(NFS_STATE_MAY_NOTIFY_LOCK, &state->flags);
c21443c2 2720
275bb307 2721 dentry = opendata->dentry;
2b0143b5 2722 if (d_really_is_negative(dentry)) {
668d0cd5 2723 struct dentry *alias;
275bb307 2724 d_drop(dentry);
668d0cd5
AV		 2725 alias = d_exact_alias(dentry, state->inode);
2726 if (!alias)
2727 alias = d_splice_alias(igrab(state->inode), dentry);
2728 /* d_splice_alias() can't fail here - it's a non-directory */
2729 if (alias) {
275bb307 2730 dput(ctx->dentry);
668d0cd5 2731 ctx->dentry = dentry = alias;
275bb307
TM		 2732 }
2733 nfs_set_verifier(dentry,
2b0143b5 2734 nfs_save_change_attribute(d_inode(opendata->dir)));
275bb307
TM		 2735 }
2736
c21443c2
TM		 2737 ret = nfs4_opendata_access(sp->so_cred, opendata, state, fmode, flags);
2738 if (ret != 0)
2739 goto out;
2740
3efb9722 2741 ctx->state = state;
2b0143b5 2742 if (d_inode(dentry) == state->inode) {
c45ffdd2
TM		 2743 nfs_inode_attach_open_context(ctx);
2744 if (read_seqcount_retry(&sp->so_reclaim_seqcount, seq))
2745 nfs4_schedule_stateid_recovery(server, state);
2746 }
c21443c2
TM		 2747out:
2748 return ret;
2749}
2750
1da177e4 2751/*
24ac23ab 2752 * Returns a referenced nfs4_state
1da177e4 2753 */
82be417a 2754static int _nfs4_do_open(struct inode *dir,
4197a055 2755 struct nfs_open_context *ctx,
82be417a
AA		 2756 int flags,
2757 struct iattr *sattr,
5bc2afc2
TM		 2758 struct nfs4_label *label,
2759 int *opened)
1da177e4
LT		 2760{
2761 struct nfs4_state_owner *sp;
2762 struct nfs4_state *state = NULL;
2763 struct nfs_server *server = NFS_SERVER(dir);
e56e0b78 2764 struct nfs4_opendata *opendata;
4197a055
TM		 2765 struct dentry *dentry = ctx->dentry;
2766 struct rpc_cred *cred = ctx->cred;
2767 struct nfs4_threshold **ctx_th = &ctx->mdsthreshold;
2768 fmode_t fmode = ctx->mode & (FMODE_READ|FMODE_WRITE|FMODE_EXEC);
49f9a0fa 2769 enum open_claim_type4 claim = NFS4_OPEN_CLAIM_NULL;
1775fd3e 2770 struct nfs4_label *olabel = NULL;
aac00a8d 2771 int status;
1da177e4
LT		 2772
2773 /* Protect against reboot recovery conflicts */
1da177e4 2774 status = -ENOMEM;
d1e284d5
TM		 2775 sp = nfs4_get_state_owner(server, cred, GFP_KERNEL);
2776 if (sp == NULL) {
1da177e4
LT		 2777 dprintk("nfs4_do_open: nfs4_get_state_owner failed!\n");
2778 goto out_err;
2779 }
58d9714a
TM		 2780 status = nfs4_recover_expired_lease(server);
2781 if (status != 0)
b4454fe1 2782 goto err_put_state_owner;
2b0143b5
DH		 2783 if (d_really_is_positive(dentry))
2784 nfs4_return_incompatible_delegation(d_inode(dentry), fmode);
58d9714a 2785 status = -ENOMEM;
2b0143b5 2786 if (d_really_is_positive(dentry))
49f9a0fa 2787 claim = NFS4_OPEN_CLAIM_FH;
4a1c0893 2788 opendata = nfs4_opendata_alloc(dentry, sp, fmode, flags, sattr,
1775fd3e 2789 label, claim, GFP_KERNEL);
e56e0b78 2790 if (opendata == NULL)
95d35cb4 2791 goto err_put_state_owner;
1da177e4 2792
14c43f76
DQ		 2793 if (label) {
2794 olabel = nfs4_label_alloc(server, GFP_KERNEL);
2795 if (IS_ERR(olabel)) {
2796 status = PTR_ERR(olabel);
2797 goto err_opendata_put;
2798 }
2799 }
2800
e911b815
TM		 2801 if (server->attr_bitmask[2] & FATTR4_WORD2_MDSTHRESHOLD) {
2802 if (!opendata->f_attr.mdsthreshold) {
2803 opendata->f_attr.mdsthreshold = pnfs_mdsthreshold_alloc();
2804 if (!opendata->f_attr.mdsthreshold)
2805 goto err_free_label;
2806 }
1549210f 2807 opendata->o_arg.open_bitmap = &nfs4_pnfs_open_bitmap[0];
82be417a 2808 }
2b0143b5
DH		 2809 if (d_really_is_positive(dentry))
2810 opendata->state = nfs4_get_open_state(d_inode(dentry), sp);
aac00a8d 2811
3efb9722 2812 status = _nfs4_open_and_get_state(opendata, fmode, flags, ctx);
6168f62c 2813 if (status != 0)
14c43f76 2814 goto err_free_label;
3efb9722 2815 state = ctx->state;
6168f62c 2816
efcbc04e 2817 if ((opendata->o_arg.open_flags & (O_CREAT|O_EXCL)) == (O_CREAT|O_EXCL) &&
549b19cc 2818 (opendata->o_arg.createmode != NFS4_CREATE_GUARDED)) {
5334c5bd 2819 nfs4_exclusive_attrset(opendata, sattr, &label);
a1d1c4f1
TM		 2820 /*
2821 * send create attributes which was not set by open
2822 * with an extra setattr.
2823 */
2824 if (sattr->ia_valid & NFS4_VALID_ATTRS) {
2825 nfs_fattr_init(opendata->o_res.f_attr);
2826 status = nfs4_do_setattr(state->inode, cred,
2827 opendata->o_res.f_attr, sattr,
29b59f94 2828 ctx, label, olabel);
a1d1c4f1
TM		 2829 if (status == 0) {
2830 nfs_setattr_update_inode(state->inode, sattr,
2831 opendata->o_res.f_attr);
2832 nfs_setsecurity(state->inode, opendata->o_res.f_attr, olabel);
2833 }
1775fd3e 2834 }
0ab64e0e 2835 }
c5c3fb5f 2836 if (opened && opendata->file_created)
5bc2afc2 2837 *opened |= FILE_CREATED;
82be417a 2838
e911b815 2839 if (pnfs_use_threshold(ctx_th, opendata->f_attr.mdsthreshold, server)) {
82be417a 2840 *ctx_th = opendata->f_attr.mdsthreshold;
e911b815
TM		 2841 opendata->f_attr.mdsthreshold = NULL;
2842 }
82be417a 2843
14c43f76
DQ		 2844 nfs4_label_free(olabel);
2845
c6d00e63 2846 nfs4_opendata_put(opendata);
1da177e4 2847 nfs4_put_state_owner(sp);
1da177e4 2848 return 0;
14c43f76
DQ		 2849err_free_label:
2850 nfs4_label_free(olabel);
c6d00e63
TM		 2851err_opendata_put:
2852 nfs4_opendata_put(opendata);
e56e0b78
TM		 2853err_put_state_owner:
2854 nfs4_put_state_owner(sp);
1da177e4 2855out_err:
1da177e4
LT		 2856 return status;
2857}
2858
2859
82be417a 2860static struct nfs4_state *nfs4_do_open(struct inode *dir,
4197a055 2861 struct nfs_open_context *ctx,
82be417a
AA		 2862 int flags,
2863 struct iattr *sattr,
5bc2afc2
TM		 2864 struct nfs4_label *label,
2865 int *opened)
1da177e4 2866{
49f9a0fa 2867 struct nfs_server *server = NFS_SERVER(dir);
1da177e4
LT		 2868 struct nfs4_exception exception = { };
2869 struct nfs4_state *res;
2870 int status;
2871
2872 do {
5bc2afc2 2873 status = _nfs4_do_open(dir, ctx, flags, sattr, label, opened);
3efb9722 2874 res = ctx->state;
42113a75 2875 trace_nfs4_open_file(ctx, flags, status);
1da177e4
LT		 2876 if (status == 0)
2877 break;
2878 /* NOTE: BAD_SEQID means the server and client disagree about the
2879 * book-keeping w.r.t. state-changing operations
2880 * (OPEN/CLOSE/LOCK/LOCKU...)
2881 * It is actually a sign of a bug on the client or on the server.
2882 *
2883 * If we receive a BAD_SEQID error in the particular case of
cee54fc9 2884 * doing an OPEN, we assume that nfs_increment_open_seqid() will
1da177e4
LT		 2885 * have unhashed the old state_owner for us, and that we can
2886 * therefore safely retry using a new one. We should still warn
2887 * the user though...
2888 */
2889 if (status == -NFS4ERR_BAD_SEQID) {
9a3ba432 2890 pr_warn_ratelimited("NFS: v4 server %s "
6f43ddcc
TM		 2891 " returned a bad sequence-id error!\n",
2892 NFS_SERVER(dir)->nfs_client->cl_hostname);
1da177e4
LT		 2893 exception.retry = 1;
2894 continue;
2895 }
550f5747
TM		 2896 /*
2897 * BAD_STATEID on OPEN means that the server cancelled our
2898 * state before it received the OPEN_CONFIRM.
2899 * Recover by retrying the request as per the discussion
2900 * on Page 181 of RFC3530.
2901 */
2902 if (status == -NFS4ERR_BAD_STATEID) {
2903 exception.retry = 1;
2904 continue;
2905 }
aac00a8d
TM		 2906 if (status == -EAGAIN) {
2907 /* We must have found a delegation */
2908 exception.retry = 1;
2909 continue;
2910 }
49f9a0fa
TM		 2911 if (nfs4_clear_cap_atomic_open_v1(server, status, &exception))
2912 continue;
2913 res = ERR_PTR(nfs4_handle_exception(server,
1da177e4
LT		 2914 status, &exception));
2915 } while (exception.retry);
2916 return res;
2917}
2918
8487c479
TM		 2919static int _nfs4_do_setattr(struct inode *inode,
2920 struct nfs_setattrargs *arg,
2921 struct nfs_setattrres *res,
2922 struct rpc_cred *cred,
29b59f94 2923 struct nfs_open_context *ctx)
1da177e4 2924{
3e4f6290 2925 struct nfs_server *server = NFS_SERVER(inode);
1da177e4 2926 struct rpc_message msg = {
659bfcd6 2927 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETATTR],
8487c479
TM		 2928 .rpc_argp = arg,
2929 .rpc_resp = res,
659bfcd6 2930 .rpc_cred = cred,
1da177e4 2931 };
abf4e13c 2932 struct rpc_cred *delegation_cred = NULL;
26e976a8 2933 unsigned long timestamp = jiffies;
ee3ae84e
TM		 2934 fmode_t fmode;
2935 bool truncate;
65e4308d 2936 int status;
1da177e4 2937
8487c479 2938 nfs_fattr_init(res->fattr);
1da177e4 2939
ee3ae84e 2940 /* Servers should only apply open mode checks for file size changes */
8487c479 2941 truncate = (arg->iap->ia_valid & ATTR_SIZE) ? true : false;
ee3ae84e
TM		 2942 fmode = truncate ? FMODE_WRITE : FMODE_READ;
2943
8487c479 2944 if (nfs4_copy_delegation_stateid(inode, fmode, &arg->stateid, &delegation_cred)) {
ee3ae84e 2945 /* Use that stateid */
29b59f94 2946 } else if (truncate && ctx != NULL) {
17393475 2947 struct nfs_lock_context *l_ctx;
29b59f94 2948 if (!nfs4_valid_open_stateid(ctx->state))
0418dae1 2949 return -EBADF;
17393475
N		 2950 l_ctx = nfs_get_lock_context(ctx);
2951 if (IS_ERR(l_ctx))
2952 return PTR_ERR(l_ctx);
7a0566b3
N		 2953 status = nfs4_select_rw_stateid(ctx->state, FMODE_WRITE, l_ctx,
2954 &arg->stateid, &delegation_cred);
2955 nfs_put_lock_context(l_ctx);
2956 if (status == -EIO)
0418dae1 2957 return -EBADF;
08e9eac4 2958 } else
8487c479 2959 nfs4_stateid_copy(&arg->stateid, &zero_stateid);
abf4e13c
TM		 2960 if (delegation_cred)
2961 msg.rpc_cred = delegation_cred;
1da177e4 2962
8487c479 2963 status = nfs4_call_sync(server->client, server, &msg, &arg->seq_args, &res->seq_res, 1);
abf4e13c
TM		 2964
2965 put_rpccred(delegation_cred);
29b59f94 2966 if (status == 0 && ctx != NULL)
26e976a8 2967 renew_lease(server, timestamp);
8487c479 2968 trace_nfs4_setattr(inode, &arg->stateid, status);
65e4308d 2969 return status;
1da177e4
LT		 2970}
2971
659bfcd6
TM		 2972static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
2973 struct nfs_fattr *fattr, struct iattr *sattr,
29b59f94 2974 struct nfs_open_context *ctx, struct nfs4_label *ilabel,
1775fd3e 2975 struct nfs4_label *olabel)
1da177e4 2976{
3e4f6290 2977 struct nfs_server *server = NFS_SERVER(inode);
29b59f94 2978 struct nfs4_state *state = ctx ? ctx->state : NULL;
8487c479
TM		 2979 struct nfs_setattrargs arg = {
2980 .fh = NFS_FH(inode),
2981 .iap = sattr,
2982 .server = server,
2983 .bitmask = server->attr_bitmask,
2984 .label = ilabel,
2985 };
2986 struct nfs_setattrres res = {
2987 .fattr = fattr,
2988 .label = olabel,
2989 .server = server,
2990 };
a1d0b5ee
TM		 2991 struct nfs4_exception exception = {
2992 .state = state,
3114ea7a 2993 .inode = inode,
8487c479 2994 .stateid = &arg.stateid,
a1d0b5ee 2995 };
1da177e4 2996 int err;
8487c479
TM		 2997
2998 arg.bitmask = nfs4_bitmask(server, ilabel);
2999 if (ilabel)
3000 arg.bitmask = nfs4_bitmask(server, olabel);
3001
1da177e4 3002 do {
29b59f94 3003 err = _nfs4_do_setattr(inode, &arg, &res, cred, ctx);
451146be
TM		 3004 switch (err) {
3005 case -NFS4ERR_OPENMODE:
721ccfb7
TM		 3006 if (!(sattr->ia_valid & ATTR_SIZE)) {
3007 pr_warn_once("NFSv4: server %s is incorrectly "
3008 "applying open mode checks to "
3009 "a SETATTR that is not "
3010 "changing file size.\n",
3011 server->nfs_client->cl_hostname);
3012 }
451146be
TM		 3013 if (state && !(state->state & FMODE_WRITE)) {
3014 err = -EBADF;
3015 if (sattr->ia_valid & ATTR_OPEN)
3016 err = -EACCES;
3017 goto out;
3018 }
3019 }
3020 err = nfs4_handle_exception(server, err, &exception);
1da177e4 3021 } while (exception.retry);
451146be 3022out:
1da177e4
LT		 3023 return err;
3024}
3025
500d701f
PT		 3026static bool
3027nfs4_wait_on_layoutreturn(struct inode *inode, struct rpc_task *task)
3028{
3029 if (inode == NULL || !nfs_have_layout(inode))
3030 return false;
3031
3032 return pnfs_wait_on_layoutreturn(inode, task);
3033}
3034
1da177e4
LT		 3035struct nfs4_closedata {
3036 struct inode *inode;
3037 struct nfs4_state *state;
3038 struct nfs_closeargs arg;
3039 struct nfs_closeres res;
cf805165
TM		 3040 struct {
3041 struct nfs4_layoutreturn_args arg;
3042 struct nfs4_layoutreturn_res res;
4d796d75 3043 struct nfs4_xdr_opaque_data ld_private;
cf805165
TM		 3044 u32 roc_barrier;
3045 bool roc;
3046 } lr;
516a6af6 3047 struct nfs_fattr fattr;
26e976a8 3048 unsigned long timestamp;
1da177e4
LT		 3049};
3050
963d8fe5 3051static void nfs4_free_closedata(void *data)
9512135d 3052{
963d8fe5
TM		 3053 struct nfs4_closedata *calldata = data;
3054 struct nfs4_state_owner *sp = calldata->state->owner;
643168c2 3055 struct super_block *sb = calldata->state->inode->i_sb;
9512135d 3056
cf805165 3057 if (calldata->lr.roc)
1c5bd76d
TM		 3058 pnfs_roc_release(&calldata->lr.arg, &calldata->lr.res,
3059 calldata->res.lr_ret);
9512135d
TM		 3060 nfs4_put_open_state(calldata->state);
3061 nfs_free_seqid(calldata->arg.seqid);
9512135d 3062 nfs4_put_state_owner(sp);
322b2b90 3063 nfs_sb_deactive(sb);
9512135d
TM		 3064 kfree(calldata);
3065}
3066
963d8fe5 3067static void nfs4_close_done(struct rpc_task *task, void *data)
1da177e4 3068{
963d8fe5 3069 struct nfs4_closedata *calldata = data;
1da177e4 3070 struct nfs4_state *state = calldata->state;
1da177e4 3071 struct nfs_server *server = NFS_SERVER(calldata->inode);
412f6c4c 3072 nfs4_stateid *res_stateid = NULL;
1da177e4 3073
a3ca5651 3074 dprintk("%s: begin!\n", __func__);
14516c3a
TM		 3075 if (!nfs4_sequence_done(task, &calldata->res.seq_res))
3076 return;
42113a75 3077 trace_nfs4_close(state, &calldata->arg, &calldata->res, task->tk_status);
cf805165
TM		 3078
3079 /* Handle Layoutreturn errors */
3080 if (calldata->arg.lr_args && task->tk_status != 0) {
3081 switch (calldata->res.lr_ret) {
3082 default:
3083 calldata->res.lr_ret = -NFS4ERR_NOMATCHING_LAYOUT;
3084 break;
3085 case 0:
3086 calldata->arg.lr_args = NULL;
3087 calldata->res.lr_res = NULL;
3088 break;
3089 case -NFS4ERR_ADMIN_REVOKED:
3090 case -NFS4ERR_DELEG_REVOKED:
3091 case -NFS4ERR_EXPIRED:
3092 case -NFS4ERR_BAD_STATEID:
3093 case -NFS4ERR_OLD_STATEID:
3094 case -NFS4ERR_UNKNOWN_LAYOUTTYPE:
3095 case -NFS4ERR_WRONG_CRED:
3096 calldata->arg.lr_args = NULL;
3097 calldata->res.lr_res = NULL;
3098 calldata->res.lr_ret = 0;
3099 rpc_restart_call_prepare(task);
3100 return;
3101 }
3102 }
3103
1da177e4
LT		 3104 /* hmm. we are done with the inode, and in the process of freeing
3105 * the state_owner. we keep this around to process errors
3106 */
1da177e4
LT		 3107 switch (task->tk_status) {
3108 case 0:
412f6c4c 3109 res_stateid = &calldata->res.stateid;
26e976a8 3110 renew_lease(server, calldata->timestamp);
412f6c4c 3111 break;
f07d4a31
TM		 3112 case -NFS4ERR_ACCESS:
3113 if (calldata->arg.bitmask != NULL) {
3114 calldata->arg.bitmask = NULL;
3115 calldata->res.fattr = NULL;
3116 task->tk_status = 0;
3117 rpc_restart_call_prepare(task);
3118 goto out_release;
3119
3120 }
3121 break;
69794ad7 3122 case -NFS4ERR_ADMIN_REVOKED:
1da177e4 3123 case -NFS4ERR_STALE_STATEID:
26d36301
TM		 3124 case -NFS4ERR_EXPIRED:
3125 nfs4_free_revoked_stateid(server,
3126 &calldata->arg.stateid,
3127 task->tk_msg.rpc_cred);
9e33bed5
TM		 3128 case -NFS4ERR_OLD_STATEID:
3129 case -NFS4ERR_BAD_STATEID:
566fcec6 3130 if (!nfs4_stateid_match(&calldata->arg.stateid,
369d6b7f 3131 &state->open_stateid)) {
566fcec6
TM		 3132 rpc_restart_call_prepare(task);
3133 goto out_release;
3134 }
dc0b027d 3135 if (calldata->arg.fmode == 0)
9e33bed5 3136 break;
1da177e4 3137 default:
8478eaa1 3138 if (nfs4_async_handle_error(task, server, state, NULL) == -EAGAIN) {
72211dbe 3139 rpc_restart_call_prepare(task);
69794ad7
TM		 3140 goto out_release;
3141 }
1da177e4 3142 }
4a1e2feb
TM		 3143 nfs_clear_open_stateid(state, &calldata->arg.stateid,
3144 res_stateid, calldata->arg.fmode);
69794ad7 3145out_release:
72211dbe 3146 nfs_release_seqid(calldata->arg.seqid);
d8d84983 3147 nfs_refresh_inode(calldata->inode, &calldata->fattr);
a3ca5651 3148 dprintk("%s: done, ret = %d!\n", __func__, task->tk_status);
1da177e4
LT		 3149}
3150
4ce70ada 3151static void nfs4_close_prepare(struct rpc_task *task, void *data)
1da177e4 3152{
4ce70ada 3153 struct nfs4_closedata *calldata = data;
9512135d 3154 struct nfs4_state *state = calldata->state;
7fdab069 3155 struct inode *inode = calldata->inode;
aee7af35 3156 bool is_rdonly, is_wronly, is_rdwr;
88069f77 3157 int call_close = 0;
9512135d 3158
a3ca5651 3159 dprintk("%s: begin!\n", __func__);
963d8fe5 3160 if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
c8da19b9 3161 goto out_wait;
003707c7 3162
88069f77 3163 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE];
4cecb76f 3164 spin_lock(&state->owner->so_lock);
aee7af35
TM		 3165 is_rdwr = test_bit(NFS_O_RDWR_STATE, &state->flags);
3166 is_rdonly = test_bit(NFS_O_RDONLY_STATE, &state->flags);
3167 is_wronly = test_bit(NFS_O_WRONLY_STATE, &state->flags);
369d6b7f 3168 nfs4_stateid_copy(&calldata->arg.stateid, &state->open_stateid);
003707c7 3169 /* Calculate the change in open mode */
cd9288ff 3170 calldata->arg.fmode = 0;
e7616923 3171 if (state->n_rdwr == 0) {
cd9288ff
TM		 3172 if (state->n_rdonly == 0)
3173 call_close |= is_rdonly;
3174 else if (is_rdonly)
3175 calldata->arg.fmode |= FMODE_READ;
3176 if (state->n_wronly == 0)
3177 call_close |= is_wronly;
3178 else if (is_wronly)
3179 calldata->arg.fmode |= FMODE_WRITE;
e547f262
TM		 3180 if (calldata->arg.fmode != (FMODE_READ|FMODE_WRITE))
3181 call_close |= is_rdwr;
cd9288ff
TM		 3182 } else if (is_rdwr)
3183 calldata->arg.fmode |= FMODE_READ|FMODE_WRITE;
3184
5cc7861e
TM		 3185 if (!nfs4_valid_open_stateid(state) ||
3186 test_bit(NFS_OPEN_STATE, &state->flags) == 0)
5d422301 3187 call_close = 0;
4cecb76f 3188 spin_unlock(&state->owner->so_lock);
88069f77
TM		 3189
3190 if (!call_close) {
963d8fe5 3191 /* Note: exit _without_ calling nfs4_close_done */
c8da19b9 3192 goto out_no_action;
9512135d 3193 }
88069f77 3194
1c5bd76d 3195 if (!calldata->lr.roc && nfs4_wait_on_layoutreturn(inode, task)) {
500d701f
PT		 3196 nfs_release_seqid(calldata->arg.seqid);
3197 goto out_wait;
3198 }
3199
9413a1a1 3200 if (calldata->arg.fmode == 0)
88069f77 3201 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE];
3ecefc92 3202
9413a1a1 3203 if (calldata->arg.fmode == 0 || calldata->arg.fmode == FMODE_READ) {
3ecefc92
TM		 3204 /* Close-to-open cache consistency revalidation */
3205 if (!nfs4_have_delegation(inode, FMODE_READ))
3206 calldata->arg.bitmask = NFS_SERVER(inode)->cache_consistency_bitmask;
3207 else
3208 calldata->arg.bitmask = NULL;
3209 }
3c13cb5b 3210
6ae37339
TM		 3211 calldata->arg.share_access =
3212 nfs4_map_atomic_open_share(NFS_SERVER(inode),
3213 calldata->arg.fmode, 0);
88069f77 3214
d8d84983
TM		 3215 if (calldata->res.fattr == NULL)
3216 calldata->arg.bitmask = NULL;
3217 else if (calldata->arg.bitmask == NULL)
3218 calldata->res.fattr = NULL;
26e976a8 3219 calldata->timestamp = jiffies;
42e1cca7 3220 if (nfs4_setup_sequence(NFS_SERVER(inode)->nfs_client,
9d12b216
TM		 3221 &calldata->arg.seq_args,
3222 &calldata->res.seq_res,
2240a9e2
TM		 3223 task) != 0)
3224 nfs_release_seqid(calldata->arg.seqid);
a3ca5651 3225 dprintk("%s: done!\n", __func__);
c8da19b9
TM		 3226 return;
3227out_no_action:
3228 task->tk_action = NULL;
3229out_wait:
3230 nfs4_sequence_done(task, &calldata->res.seq_res);
1da177e4
LT		 3231}
3232
963d8fe5 3233static const struct rpc_call_ops nfs4_close_ops = {
4ce70ada 3234 .rpc_call_prepare = nfs4_close_prepare,
963d8fe5
TM		 3235 .rpc_call_done = nfs4_close_done,
3236 .rpc_release = nfs4_free_closedata,
3237};
3238
1da177e4
LT		 3239/*
3240 * It is possible for data to be read/written from a mem-mapped file
3241 * after the sys_close call (which hits the vfs layer as a flush).
3242 * This means that we can't safely call nfsv4 close on a file until
3243 * the inode is cleared. This in turn means that we are not good
3244 * NFSv4 citizens - we do not indicate to the server to update the file's
3245 * share state even when we are done with one of the three share
3246 * stateid's in the inode.
3247 *
3248 * NOTE: Caller must be holding the sp->so_owner semaphore!
3249 */
1f7977c1 3250int nfs4_do_close(struct nfs4_state *state, gfp_t gfp_mask, int wait)
1da177e4 3251{
4a35bd41 3252 struct nfs_server *server = NFS_SERVER(state->inode);
63f5f796 3253 struct nfs_seqid *(*alloc_seqid)(struct nfs_seqid_counter *, gfp_t);
1da177e4 3254 struct nfs4_closedata *calldata;
b39e625b
TM		 3255 struct nfs4_state_owner *sp = state->owner;
3256 struct rpc_task *task;
5138fde0
TM		 3257 struct rpc_message msg = {
3258 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE],
3259 .rpc_cred = state->owner->so_cred,
3260 };
c970aa85
TM		 3261 struct rpc_task_setup task_setup_data = {
3262 .rpc_client = server->client,
5138fde0 3263 .rpc_message = &msg,
c970aa85 3264 .callback_ops = &nfs4_close_ops,
101070ca 3265 .workqueue = nfsiod_workqueue,
c970aa85
TM		 3266 .flags = RPC_TASK_ASYNC,
3267 };
9512135d 3268 int status = -ENOMEM;
1da177e4 3269
fa940720
WAA		 3270 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_CLEANUP,
3271 &task_setup_data.rpc_client, &msg);
3272
8535b2be 3273 calldata = kzalloc(sizeof(*calldata), gfp_mask);
1da177e4 3274 if (calldata == NULL)
9512135d 3275 goto out;
a9c92d6b 3276 nfs4_init_sequence(&calldata->arg.seq_args, &calldata->res.seq_res, 1);
4a35bd41 3277 calldata->inode = state->inode;
1da177e4 3278 calldata->state = state;
4a35bd41 3279 calldata->arg.fh = NFS_FH(state->inode);
1da177e4 3280 /* Serialization for the sequence id */
63f5f796
TM		 3281 alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid;
3282 calldata->arg.seqid = alloc_seqid(&state->owner->so_seqid, gfp_mask);
badc76dd 3283 if (IS_ERR(calldata->arg.seqid))
9512135d 3284 goto out_free_calldata;
d8d84983 3285 nfs_fattr_init(&calldata->fattr);
dc0b027d 3286 calldata->arg.fmode = 0;
4d796d75 3287 calldata->lr.arg.ld_private = &calldata->lr.ld_private;
516a6af6 3288 calldata->res.fattr = &calldata->fattr;
c1d51931 3289 calldata->res.seqid = calldata->arg.seqid;
516a6af6 3290 calldata->res.server = server;
cf805165 3291 calldata->res.lr_ret = -NFS4ERR_NOMATCHING_LAYOUT;
1c5bd76d
TM		 3292 calldata->lr.roc = pnfs_roc(state->inode,
3293 &calldata->lr.arg, &calldata->lr.res, msg.rpc_cred);
3294 if (calldata->lr.roc) {
3295 calldata->arg.lr_args = &calldata->lr.arg;
3296 calldata->res.lr_res = &calldata->lr.res;
3297 }
643168c2 3298 nfs_sb_active(calldata->inode->i_sb);
9512135d 3299
1174dd1f
TM		 3300 msg.rpc_argp = &calldata->arg;
3301 msg.rpc_resp = &calldata->res;
c970aa85
TM		 3302 task_setup_data.callback_data = calldata;
3303 task = rpc_run_task(&task_setup_data);
b39e625b
TM		 3304 if (IS_ERR(task))
3305 return PTR_ERR(task);
a49c3c77
TM		 3306 status = 0;
3307 if (wait)
3308 status = rpc_wait_for_completion_task(task);
b39e625b 3309 rpc_put_task(task);
a49c3c77 3310 return status;
9512135d
TM		 3311out_free_calldata:
3312 kfree(calldata);
3313out:
b39e625b
TM		 3314 nfs4_put_open_state(state);
3315 nfs4_put_state_owner(sp);
9512135d 3316 return status;
1da177e4
LT		 3317}
3318
2b484297 3319static struct inode *
5bc2afc2
TM		 3320nfs4_atomic_open(struct inode *dir, struct nfs_open_context *ctx,
3321 int open_flags, struct iattr *attr, int *opened)
1da177e4 3322{
1da177e4 3323 struct nfs4_state *state;
aa9c2669
DQ		 3324 struct nfs4_label l = {0, 0, 0, NULL}, *label = NULL;
3325
3326 label = nfs4_label_init_security(dir, ctx->dentry, attr, &l);
1da177e4 3327
565277f6 3328 /* Protect against concurrent sillydeletes */
5bc2afc2 3329 state = nfs4_do_open(dir, ctx, open_flags, attr, label, opened);
aa9c2669
DQ		 3330
3331 nfs4_label_release_security(label);
3332
f46e0bd3
TM		 3333 if (IS_ERR(state))
3334 return ERR_CAST(state);
275bb307 3335 return state->inode;
1da177e4
LT		 3336}
3337
1185a552 3338static void nfs4_close_context(struct nfs_open_context *ctx, int is_sync)
7fe5c398
TM		 3339{
3340 if (ctx->state == NULL)
3341 return;
3342 if (is_sync)
643168c2 3343 nfs4_close_sync(ctx->state, ctx->mode);
7fe5c398 3344 else
643168c2 3345 nfs4_close_state(ctx->state, ctx->mode);
7fe5c398 3346}
1da177e4 3347
b944dba3
TM		 3348#define FATTR4_WORD1_NFS40_MASK (2*FATTR4_WORD1_MOUNTED_ON_FILEID - 1UL)
3349#define FATTR4_WORD2_NFS41_MASK (2*FATTR4_WORD2_SUPPATTR_EXCLCREAT - 1UL)
dff25ddb 3350#define FATTR4_WORD2_NFS42_MASK (2*FATTR4_WORD2_MODE_UMASK - 1UL)
b944dba3 3351
1da177e4
LT		 3352static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
3353{
8c61282f 3354 u32 bitmask[3] = {}, minorversion = server->nfs_client->cl_minorversion;
43652ad5
BH		 3355 struct nfs4_server_caps_arg args = {
3356 .fhandle = fhandle,
8c61282f 3357 .bitmask = bitmask,
43652ad5 3358 };
1da177e4
LT		 3359 struct nfs4_server_caps_res res = {};
3360 struct rpc_message msg = {
3361 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SERVER_CAPS],
43652ad5 3362 .rpc_argp = &args,
1da177e4
LT		 3363 .rpc_resp = &res,
3364 };
3365 int status;
3366
8c61282f
KM		 3367 bitmask[0] = FATTR4_WORD0_SUPPORTED_ATTRS |
3368 FATTR4_WORD0_FH_EXPIRE_TYPE |
3369 FATTR4_WORD0_LINK_SUPPORT |
3370 FATTR4_WORD0_SYMLINK_SUPPORT |
3371 FATTR4_WORD0_ACLSUPPORT;
3372 if (minorversion)
3373 bitmask[2] = FATTR4_WORD2_SUPPATTR_EXCLCREAT;
3374
7c513058 3375 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
1da177e4 3376 if (status == 0) {
b944dba3 3377 /* Sanity check the server answers */
8c61282f 3378 switch (minorversion) {
b944dba3
TM		 3379 case 0:
3380 res.attr_bitmask[1] &= FATTR4_WORD1_NFS40_MASK;
3381 res.attr_bitmask[2] = 0;
3382 break;
3383 case 1:
3384 res.attr_bitmask[2] &= FATTR4_WORD2_NFS41_MASK;
3385 break;
3386 case 2:
3387 res.attr_bitmask[2] &= FATTR4_WORD2_NFS42_MASK;
3388 }
1da177e4 3389 memcpy(server->attr_bitmask, res.attr_bitmask, sizeof(server->attr_bitmask));
62ab460c
TM		 3390 server->caps &= ~(NFS_CAP_ACLS|NFS_CAP_HARDLINKS|
3391 NFS_CAP_SYMLINKS|NFS_CAP_FILEID|
3392 NFS_CAP_MODE|NFS_CAP_NLINK|NFS_CAP_OWNER|
3393 NFS_CAP_OWNER_GROUP|NFS_CAP_ATIME|
b944dba3
TM		 3394 NFS_CAP_CTIME|NFS_CAP_MTIME|
3395 NFS_CAP_SECURITY_LABEL);
7dd7d959
MN		 3396 if (res.attr_bitmask[0] & FATTR4_WORD0_ACL &&
3397 res.acl_bitmask & ACL4_SUPPORT_ALLOW_ACL)
1da177e4
LT		 3398 server->caps |= NFS_CAP_ACLS;
3399 if (res.has_links != 0)
3400 server->caps |= NFS_CAP_HARDLINKS;
3401 if (res.has_symlinks != 0)
3402 server->caps |= NFS_CAP_SYMLINKS;
62ab460c
TM		 3403 if (res.attr_bitmask[0] & FATTR4_WORD0_FILEID)
3404 server->caps |= NFS_CAP_FILEID;
3405 if (res.attr_bitmask[1] & FATTR4_WORD1_MODE)
3406 server->caps |= NFS_CAP_MODE;
3407 if (res.attr_bitmask[1] & FATTR4_WORD1_NUMLINKS)
3408 server->caps |= NFS_CAP_NLINK;
3409 if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER)
3410 server->caps |= NFS_CAP_OWNER;
3411 if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER_GROUP)
3412 server->caps |= NFS_CAP_OWNER_GROUP;
3413 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_ACCESS)
3414 server->caps |= NFS_CAP_ATIME;
3415 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_METADATA)
3416 server->caps |= NFS_CAP_CTIME;
3417 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_MODIFY)
3418 server->caps |= NFS_CAP_MTIME;
aa9c2669
DQ		 3419#ifdef CONFIG_NFS_V4_SECURITY_LABEL
3420 if (res.attr_bitmask[2] & FATTR4_WORD2_SECURITY_LABEL)
3421 server->caps |= NFS_CAP_SECURITY_LABEL;
3422#endif
3423 memcpy(server->attr_bitmask_nl, res.attr_bitmask,
3424 sizeof(server->attr_bitmask));
b944dba3 3425 server->attr_bitmask_nl[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
62ab460c 3426
a65318bf
TM		 3427 memcpy(server->cache_consistency_bitmask, res.attr_bitmask, sizeof(server->cache_consistency_bitmask));
3428 server->cache_consistency_bitmask[0] &= FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE;
3429 server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY;
b944dba3 3430 server->cache_consistency_bitmask[2] = 0;
8c61282f
KM		 3431 memcpy(server->exclcreat_bitmask, res.exclcreat_bitmask,
3432 sizeof(server->exclcreat_bitmask));
1da177e4 3433 server->acl_bitmask = res.acl_bitmask;
264e6351 3434 server->fh_expire_type = res.fh_expire_type;
1da177e4 3435 }
cccef3b9 3436
1da177e4
LT		 3437 return status;
3438}
3439
55a97593 3440int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
1da177e4
LT		 3441{
3442 struct nfs4_exception exception = { };
3443 int err;
3444 do {
3445 err = nfs4_handle_exception(server,
3446 _nfs4_server_capabilities(server, fhandle),
3447 &exception);
3448 } while (exception.retry);
3449 return err;
3450}
3451
3452static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
3453 struct nfs_fsinfo *info)
3454{
aa9c2669 3455 u32 bitmask[3];
1da177e4 3456 struct nfs4_lookup_root_arg args = {
aa9c2669 3457 .bitmask = bitmask,
1da177e4
LT		 3458 };
3459 struct nfs4_lookup_res res = {
3460 .server = server,
0e574af1 3461 .fattr = info->fattr,
1da177e4
LT		 3462 .fh = fhandle,
3463 };
3464 struct rpc_message msg = {
3465 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP_ROOT],
3466 .rpc_argp = &args,
3467 .rpc_resp = &res,
3468 };
008f55d0 3469
aa9c2669
DQ		 3470 bitmask[0] = nfs4_fattr_bitmap[0];
3471 bitmask[1] = nfs4_fattr_bitmap[1];
3472 /*
3473 * Process the label in the upcoming getfattr
3474 */
3475 bitmask[2] = nfs4_fattr_bitmap[2] & ~FATTR4_WORD2_SECURITY_LABEL;
3476
0e574af1 3477 nfs_fattr_init(info->fattr);
7c513058 3478 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
1da177e4
LT		 3479}
3480
3481static int nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
3482 struct nfs_fsinfo *info)
3483{
3484 struct nfs4_exception exception = { };
3485 int err;
3486 do {
fb8a5ba8 3487 err = _nfs4_lookup_root(server, fhandle, info);
b5f875a9 3488 trace_nfs4_lookup_root(server, fhandle, info->fattr, err);
fb8a5ba8
BS		 3489 switch (err) {
3490 case 0:
3491 case -NFS4ERR_WRONGSEC:
05e9cfb4 3492 goto out;
fb8a5ba8
BS		 3493 default:
3494 err = nfs4_handle_exception(server, err, &exception);
3495 }
1da177e4 3496 } while (exception.retry);
05e9cfb4 3497out:
1da177e4
LT		 3498 return err;
3499}
3500
8f70e95f
BS		 3501static int nfs4_lookup_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
3502 struct nfs_fsinfo *info, rpc_authflavor_t flavor)
3503{
c2190661
TM		 3504 struct rpc_auth_create_args auth_args = {
3505 .pseudoflavor = flavor,
3506 };
8f70e95f
BS		 3507 struct rpc_auth *auth;
3508 int ret;
3509
c2190661 3510 auth = rpcauth_create(&auth_args, server->client);
e8d920c5 3511 if (IS_ERR(auth)) {
75bc8821 3512 ret = -EACCES;
8f70e95f
BS		 3513 goto out;
3514 }
3515 ret = nfs4_lookup_root(server, fhandle, info);
8f70e95f
BS		 3516out:
3517 return ret;
3518}
3519
9a744ba3
CL		 3520/*
3521 * Retry pseudoroot lookup with various security flavors. We do this when:
3522 *
3523 * NFSv4.0: the PUTROOTFH operation returns NFS4ERR_WRONGSEC
3524 * NFSv4.1: the server does not support the SECINFO_NO_NAME operation
3525 *
3526 * Returns zero on success, or a negative NFS4ERR value, or a
3527 * negative errno value.
3528 */
801a16dc 3529static int nfs4_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
54ceac45 3530 struct nfs_fsinfo *info)
1da177e4 3531{
9a744ba3
CL		 3532 /* Per 3530bis 15.33.5 */
3533 static const rpc_authflavor_t flav_array[] = {
3534 RPC_AUTH_GSS_KRB5P,
3535 RPC_AUTH_GSS_KRB5I,
3536 RPC_AUTH_GSS_KRB5,
c4eafe11 3537 RPC_AUTH_UNIX, /* courtesy */
9a744ba3
CL		 3538 RPC_AUTH_NULL,
3539 };
3540 int status = -EPERM;
3541 size_t i;
6a1a1e34 3542
4d4b69dd
WAA		 3543 if (server->auth_info.flavor_len > 0) {
3544 /* try each flavor specified by user */
3545 for (i = 0; i < server->auth_info.flavor_len; i++) {
3546 status = nfs4_lookup_root_sec(server, fhandle, info,
3547 server->auth_info.flavors[i]);
3548 if (status == -NFS4ERR_WRONGSEC || status == -EACCES)
3549 continue;
3550 break;
3551 }
3552 } else {
3553 /* no flavors specified by user, try default list */
3554 for (i = 0; i < ARRAY_SIZE(flav_array); i++) {
3555 status = nfs4_lookup_root_sec(server, fhandle, info,
3556 flav_array[i]);
3557 if (status == -NFS4ERR_WRONGSEC || status == -EACCES)
3558 continue;
3559 break;
3560 }
8f70e95f 3561 }
9a744ba3 3562
fb8a5ba8
BS		 3563 /*
3564 * -EACCESS could mean that the user doesn't have correct permissions
3565 * to access the mount. It could also mean that we tried to mount
3566 * with a gss auth flavor, but rpc.gssd isn't running. Either way,
3567 * existing mount programs don't handle -EACCES very well so it should
3568 * be mapped to -EPERM instead.
3569 */
3570 if (status == -EACCES)
3571 status = -EPERM;
801a16dc
BS		 3572 return status;
3573}
3574
2ed4b95b
CL		 3575/**
3576 * nfs4_proc_get_rootfh - get file handle for server's pseudoroot
3577 * @server: initialized nfs_server handle
3578 * @fhandle: we fill in the pseudo-fs root file handle
3579 * @info: we fill in an FSINFO struct
5e6b1990 3580 * @auth_probe: probe the auth flavours
2ed4b95b
CL		 3581 *
3582 * Returns zero on success, or a negative errno.
801a16dc 3583 */
3028eb2b 3584int nfs4_proc_get_rootfh(struct nfs_server *server, struct nfs_fh *fhandle,
5e6b1990
TM		 3585 struct nfs_fsinfo *info,
3586 bool auth_probe)
801a16dc 3587{
c7757074 3588 int status = 0;
2ed4b95b 3589
c7757074 3590 if (!auth_probe)
5e6b1990 3591 status = nfs4_lookup_root(server, fhandle, info);
c7757074
AP		 3592
3593 if (auth_probe || status == NFS4ERR_WRONGSEC)
698c937b
TM		 3594 status = server->nfs_client->cl_mvops->find_root_sec(server,
3595 fhandle, info);
2ed4b95b 3596
1da177e4
LT		 3597 if (status == 0)
3598 status = nfs4_server_capabilities(server, fhandle);
3599 if (status == 0)
3600 status = nfs4_do_fsinfo(server, fhandle, info);
2ed4b95b 3601
c12e87f4 3602 return nfs4_map_errors(status);
1da177e4
LT		 3603}
3604
bae36241
BS		 3605static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *mntfh,
3606 struct nfs_fsinfo *info)
3607{
3608 int error;
3609 struct nfs_fattr *fattr = info->fattr;
1775fd3e 3610 struct nfs4_label *label = NULL;
bae36241
BS		 3611
3612 error = nfs4_server_capabilities(server, mntfh);
3613 if (error < 0) {
3614 dprintk("nfs4_get_root: getcaps error = %d\n", -error);
3615 return error;
3616 }
3617
14c43f76
DQ		 3618 label = nfs4_label_alloc(server, GFP_KERNEL);
3619 if (IS_ERR(label))
3620 return PTR_ERR(label);
3621
1775fd3e 3622 error = nfs4_proc_getattr(server, mntfh, fattr, label);
bae36241
BS		 3623 if (error < 0) {
3624 dprintk("nfs4_get_root: getattr error = %d\n", -error);
14c43f76 3625 goto err_free_label;
bae36241
BS		 3626 }
3627
3628 if (fattr->valid & NFS_ATTR_FATTR_FSID &&
3629 !nfs_fsid_equal(&server->fsid, &fattr->fsid))
3630 memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid));
3631
14c43f76
DQ		 3632err_free_label:
3633 nfs4_label_free(label);
3634
bae36241
BS		 3635 return error;
3636}
3637
6b97fd3d
MN		 3638/*
3639 * Get locations and (maybe) other attributes of a referral.
3640 * Note that we'll actually follow the referral later when
3641 * we detect fsid mismatch in inode revalidation
3642 */
f05d147f
BS		 3643static int nfs4_get_referral(struct rpc_clnt *client, struct inode *dir,
3644 const struct qstr *name, struct nfs_fattr *fattr,
3645 struct nfs_fh *fhandle)
6b97fd3d
MN		 3646{
3647 int status = -ENOMEM;
3648 struct page *page = NULL;
3649 struct nfs4_fs_locations *locations = NULL;
6b97fd3d
MN		 3650
3651 page = alloc_page(GFP_KERNEL);
3652 if (page == NULL)
3653 goto out;
3654 locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
3655 if (locations == NULL)
3656 goto out;
3657
f05d147f 3658 status = nfs4_proc_fs_locations(client, dir, name, locations, page);
6b97fd3d
MN		 3659 if (status != 0)
3660 goto out;
519ae255
CL		 3661
3662 /*
3663 * If the fsid didn't change, this is a migration event, not a
3664 * referral. Cause us to drop into the exception handler, which
3665 * will kick off migration recovery.
3666 */
6b97fd3d 3667 if (nfs_fsid_equal(&NFS_SERVER(dir)->fsid, &locations->fattr.fsid)) {
533eb461
AA		 3668 dprintk("%s: server did not return a different fsid for"
3669 " a referral at %s\n", __func__, name->name);
519ae255 3670 status = -NFS4ERR_MOVED;
6b97fd3d
MN		 3671 goto out;
3672 }
533eb461
AA		 3673 /* Fixup attributes for the nfs_lookup() call to nfs_fhget() */
3674 nfs_fixup_referral_attributes(&locations->fattr);
6b97fd3d 3675
533eb461 3676 /* replace the lookup nfs_fattr with the locations nfs_fattr */
6b97fd3d 3677 memcpy(fattr, &locations->fattr, sizeof(struct nfs_fattr));
6b97fd3d
MN		 3678 memset(fhandle, 0, sizeof(struct nfs_fh));
3679out:
3680 if (page)
3681 __free_page(page);
5d7ca35a 3682 kfree(locations);
6b97fd3d
MN		 3683 return status;
3684}
3685
1775fd3e
DQ		 3686static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
3687 struct nfs_fattr *fattr, struct nfs4_label *label)
1da177e4
LT		 3688{
3689 struct nfs4_getattr_arg args = {
3690 .fh = fhandle,
3691 .bitmask = server->attr_bitmask,
3692 };
3693 struct nfs4_getattr_res res = {
3694 .fattr = fattr,
1775fd3e 3695 .label = label,
1da177e4
LT		 3696 .server = server,
3697 };
3698 struct rpc_message msg = {
3699 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETATTR],
3700 .rpc_argp = &args,
3701 .rpc_resp = &res,
3702 };
aa9c2669
DQ		 3703
3704 args.bitmask = nfs4_bitmask(server, label);
3705
0e574af1 3706 nfs_fattr_init(fattr);
7c513058 3707 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
1da177e4
LT		 3708}
3709
1775fd3e
DQ		 3710static int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
3711 struct nfs_fattr *fattr, struct nfs4_label *label)
1da177e4
LT		 3712{
3713 struct nfs4_exception exception = { };
3714 int err;
3715 do {
b5f875a9
TM		 3716 err = _nfs4_proc_getattr(server, fhandle, fattr, label);
3717 trace_nfs4_getattr(server, fhandle, fattr, err);
3718 err = nfs4_handle_exception(server, err,
1da177e4
LT		 3719 &exception);
3720 } while (exception.retry);
3721 return err;
3722}
3723
3724/*
3725 * The file is not closed if it is opened due to the a request to change
3726 * the size of the file. The open call will not be needed once the
3727 * VFS layer lookup-intents are implemented.
3728 *
3729 * Close is called when the inode is destroyed.
3730 * If we haven't opened the file for O_WRONLY, we
3731 * need to in the size_change case to obtain a stateid.
3732 *
3733 * Got race?
3734 * Because OPEN is always done by name in nfsv4, it is
3735 * possible that we opened a different file by the same
3736 * name. We can recognize this race condition, but we
3737 * can't do anything about it besides returning an error.
3738 *
3739 * This will be fixed with VFS changes (lookup-intent).
3740 */
3741static int
3742nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
3743 struct iattr *sattr)
3744{
2b0143b5 3745 struct inode *inode = d_inode(dentry);
659bfcd6 3746 struct rpc_cred *cred = NULL;
29b59f94 3747 struct nfs_open_context *ctx = NULL;
14c43f76 3748 struct nfs4_label *label = NULL;
1da177e4
LT		 3749 int status;
3750
88ac815c
PT		 3751 if (pnfs_ld_layoutret_on_setattr(inode) &&
3752 sattr->ia_valid & ATTR_SIZE &&
3753 sattr->ia_size < i_size_read(inode))
24028672 3754 pnfs_commit_and_return_layout(inode);
8a1636c4 3755
0e574af1 3756 nfs_fattr_init(fattr);
1da177e4 3757
2669940d
AA		 3758 /* Deal with open(O_TRUNC) */
3759 if (sattr->ia_valid & ATTR_OPEN)
cc7936f9 3760 sattr->ia_valid &= ~(ATTR_MTIME|ATTR_CTIME);
2669940d
AA		 3761
3762 /* Optimization: if the end result is no change, don't RPC */
cc7936f9 3763 if ((sattr->ia_valid & ~(ATTR_FILE|ATTR_OPEN)) == 0)
2669940d
AA		 3764 return 0;
3765
d530838b 3766 /* Search for an existing open(O_WRITE) file */
659bfcd6 3767 if (sattr->ia_valid & ATTR_FILE) {
659bfcd6
TM		 3768
3769 ctx = nfs_file_open_context(sattr->ia_file);
29b59f94 3770 if (ctx)
504e5189 3771 cred = ctx->cred;
659bfcd6 3772 }
08e9eac4 3773
14c43f76
DQ		 3774 label = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL);
3775 if (IS_ERR(label))
3776 return PTR_ERR(label);
3777
29b59f94 3778 status = nfs4_do_setattr(inode, cred, fattr, sattr, ctx, NULL, label);
aa9c2669 3779 if (status == 0) {
f044636d 3780 nfs_setattr_update_inode(inode, sattr, fattr);
aa9c2669
DQ		 3781 nfs_setsecurity(inode, fattr, label);
3782 }
14c43f76 3783 nfs4_label_free(label);
1da177e4
LT		 3784 return status;
3785}
3786
0c2e53f1
TM		 3787static int _nfs4_proc_lookup(struct rpc_clnt *clnt, struct inode *dir,
3788 const struct qstr *name, struct nfs_fh *fhandle,
1775fd3e 3789 struct nfs_fattr *fattr, struct nfs4_label *label)
2b3de441 3790{
0c2e53f1 3791 struct nfs_server *server = NFS_SERVER(dir);
2b3de441
DH		 3792 int status;
3793 struct nfs4_lookup_arg args = {
3794 .bitmask = server->attr_bitmask,
0c2e53f1 3795 .dir_fh = NFS_FH(dir),
2b3de441
DH		 3796 .name = name,
3797 };
3798 struct nfs4_lookup_res res = {
3799 .server = server,
3800 .fattr = fattr,
aa9c2669 3801 .label = label,
2b3de441
DH		 3802 .fh = fhandle,
3803 };
3804 struct rpc_message msg = {
3805 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP],
3806 .rpc_argp = &args,
3807 .rpc_resp = &res,
3808 };
3809
aa9c2669
DQ		 3810 args.bitmask = nfs4_bitmask(server, label);
3811
2b3de441
DH		 3812 nfs_fattr_init(fattr);
3813
1da177e4 3814 dprintk("NFS call lookup %s\n", name->name);
0c2e53f1 3815 status = nfs4_call_sync(clnt, server, &msg, &args.seq_args, &res.seq_res, 0);
1da177e4
LT		 3816 dprintk("NFS reply lookup: %d\n", status);
3817 return status;
3818}
3819
72de53ec 3820static void nfs_fixup_secinfo_attributes(struct nfs_fattr *fattr)
7ebb9315 3821{
7ebb9315 3822 fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE |
72de53ec 3823 NFS_ATTR_FATTR_NLINK | NFS_ATTR_FATTR_MOUNTPOINT;
7ebb9315
BS		 3824 fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO;
3825 fattr->nlink = 2;
3826}
3827
72de53ec 3828static int nfs4_proc_lookup_common(struct rpc_clnt **clnt, struct inode *dir,
beffb8fe 3829 const struct qstr *name, struct nfs_fh *fhandle,
1775fd3e 3830 struct nfs_fattr *fattr, struct nfs4_label *label)
1da177e4
LT		 3831{
3832 struct nfs4_exception exception = { };
72de53ec 3833 struct rpc_clnt *client = *clnt;
1da177e4
LT		 3834 int err;
3835 do {
1775fd3e 3836 err = _nfs4_proc_lookup(client, dir, name, fhandle, fattr, label);
078ea3df 3837 trace_nfs4_lookup(dir, name, err);
72de53ec 3838 switch (err) {
08ef7bd3 3839 case -NFS4ERR_BADNAME:
72de53ec
BS		 3840 err = -ENOENT;
3841 goto out;
0c2e53f1 3842 case -NFS4ERR_MOVED:
f05d147f 3843 err = nfs4_get_referral(client, dir, name, fattr, fhandle);
c86c90c6
DM		 3844 if (err == -NFS4ERR_MOVED)
3845 err = nfs4_handle_exception(NFS_SERVER(dir), err, &exception);
72de53ec 3846 goto out;
0c2e53f1 3847 case -NFS4ERR_WRONGSEC:
72de53ec
BS		 3848 err = -EPERM;
3849 if (client != *clnt)
3850 goto out;
66b06860 3851 client = nfs4_negotiate_security(client, dir, name);
72de53ec
BS		 3852 if (IS_ERR(client))
3853 return PTR_ERR(client);
3854
3855 exception.retry = 1;
3856 break;
3857 default:
3858 err = nfs4_handle_exception(NFS_SERVER(dir), err, &exception);
0c2e53f1 3859 }
1da177e4 3860 } while (exception.retry);
72de53ec
BS		 3861
3862out:
3863 if (err == 0)
3864 *clnt = client;
3865 else if (client != *clnt)
3866 rpc_shutdown_client(client);
3867
1da177e4
LT		 3868 return err;
3869}
3870
beffb8fe 3871static int nfs4_proc_lookup(struct inode *dir, const struct qstr *name,
1775fd3e
DQ		 3872 struct nfs_fh *fhandle, struct nfs_fattr *fattr,
3873 struct nfs4_label *label)
72de53ec
BS		 3874{
3875 int status;
3876 struct rpc_clnt *client = NFS_CLIENT(dir);
3877
1775fd3e 3878 status = nfs4_proc_lookup_common(&client, dir, name, fhandle, fattr, label);
72de53ec
BS		 3879 if (client != NFS_CLIENT(dir)) {
3880 rpc_shutdown_client(client);
3881 nfs_fixup_secinfo_attributes(fattr);
3882 }
3883 return status;
3884}
3885
f05d147f 3886struct rpc_clnt *
beffb8fe 3887nfs4_proc_lookup_mountpoint(struct inode *dir, const struct qstr *name,
f05d147f
BS		 3888 struct nfs_fh *fhandle, struct nfs_fattr *fattr)
3889{
b72888cb 3890 struct rpc_clnt *client = NFS_CLIENT(dir);
f05d147f 3891 int status;
f05d147f 3892
1775fd3e 3893 status = nfs4_proc_lookup_common(&client, dir, name, fhandle, fattr, NULL);
b72888cb 3894 if (status < 0)
f05d147f 3895 return ERR_PTR(status);
b72888cb 3896 return (client == NFS_CLIENT(dir)) ? rpc_clone_client(client) : client;
f05d147f
BS		 3897}
3898
1da177e4
LT		 3899static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)
3900{
76b32999 3901 struct nfs_server *server = NFS_SERVER(inode);
1da177e4
LT		 3902 struct nfs4_accessargs args = {
3903 .fh = NFS_FH(inode),
a4980e78 3904 .bitmask = server->cache_consistency_bitmask,
76b32999
TM		 3905 };
3906 struct nfs4_accessres res = {
3907 .server = server,
1da177e4 3908 };
1da177e4
LT		 3909 struct rpc_message msg = {
3910 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ACCESS],
3911 .rpc_argp = &args,
3912 .rpc_resp = &res,
3913 .rpc_cred = entry->cred,
3914 };
3915 int mode = entry->mask;
aa9c2669 3916 int status = 0;
1da177e4
LT		 3917
3918 /*
3919 * Determine which access bits we want to ask for...
3920 */
3921 if (mode & MAY_READ)
3922 args.access |= NFS4_ACCESS_READ;
3923 if (S_ISDIR(inode->i_mode)) {
3924 if (mode & MAY_WRITE)
3925 args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE;
3926 if (mode & MAY_EXEC)
3927 args.access |= NFS4_ACCESS_LOOKUP;
3928 } else {
3929 if (mode & MAY_WRITE)
3930 args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND;
3931 if (mode & MAY_EXEC)
3932 args.access |= NFS4_ACCESS_EXECUTE;
3933 }
c407d41a
TM		 3934
3935 res.fattr = nfs_alloc_fattr();
3936 if (res.fattr == NULL)
3937 return -ENOMEM;
3938
7c513058 3939 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
1da177e4 3940 if (!status) {
6168f62c 3941 nfs_access_set_mask(entry, res.access);
c407d41a 3942 nfs_refresh_inode(inode, res.fattr);
1da177e4 3943 }
c407d41a 3944 nfs_free_fattr(res.fattr);
1da177e4
LT		 3945 return status;
3946}
3947
3948static int nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)
3949{
3950 struct nfs4_exception exception = { };
3951 int err;
3952 do {
c1578b76
TM		 3953 err = _nfs4_proc_access(inode, entry);
3954 trace_nfs4_access(inode, err);
3955 err = nfs4_handle_exception(NFS_SERVER(inode), err,
1da177e4
LT		 3956 &exception);
3957 } while (exception.retry);
3958 return err;
3959}
3960
3961/*
3962 * TODO: For the time being, we don't try to get any attributes
3963 * along with any of the zero-copy operations READ, READDIR,
3964 * READLINK, WRITE.
3965 *
3966 * In the case of the first three, we want to put the GETATTR
3967 * after the read-type operation -- this is because it is hard
3968 * to predict the length of a GETATTR response in v4, and thus
3969 * align the READ data correctly. This means that the GETATTR
3970 * may end up partially falling into the page cache, and we should
3971 * shift it into the 'tail' of the xdr_buf before processing.
3972 * To do this efficiently, we need to know the total length
3973 * of data received, which doesn't seem to be available outside
3974 * of the RPC layer.
3975 *
3976 * In the case of WRITE, we also want to put the GETATTR after
3977 * the operation -- in this case because we want to make sure
140150db 3978 * we get the post-operation mtime and size.
1da177e4
LT		 3979 *
3980 * Both of these changes to the XDR layer would in fact be quite
3981 * minor, but I decided to leave them for a subsequent patch.
3982 */
3983static int _nfs4_proc_readlink(struct inode *inode, struct page *page,
3984 unsigned int pgbase, unsigned int pglen)
3985{
3986 struct nfs4_readlink args = {
3987 .fh = NFS_FH(inode),
3988 .pgbase = pgbase,
3989 .pglen = pglen,
3990 .pages = &page,
3991 };
f50c7000 3992 struct nfs4_readlink_res res;
1da177e4
LT		 3993 struct rpc_message msg = {
3994 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READLINK],
3995 .rpc_argp = &args,
f50c7000 3996 .rpc_resp = &res,
1da177e4
LT		 3997 };
3998
7c513058 3999 return nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode), &msg, &args.seq_args, &res.seq_res, 0);
1da177e4
LT		 4000}
4001
4002static int nfs4_proc_readlink(struct inode *inode, struct page *page,
4003 unsigned int pgbase, unsigned int pglen)
4004{
4005 struct nfs4_exception exception = { };
4006 int err;
4007 do {
c1578b76
TM		 4008 err = _nfs4_proc_readlink(inode, page, pgbase, pglen);
4009 trace_nfs4_readlink(inode, err);
4010 err = nfs4_handle_exception(NFS_SERVER(inode), err,
1da177e4
LT		 4011 &exception);
4012 } while (exception.retry);
4013 return err;
4014}
4015
1da177e4 4016/*
8867fe58 4017 * This is just for mknod. open(O_CREAT) will always do ->open_context().
1da177e4 4018 */
1da177e4
LT		 4019static int
4020nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
8867fe58 4021 int flags)
1da177e4 4022{
dff25ddb 4023 struct nfs_server *server = NFS_SERVER(dir);
aa9c2669 4024 struct nfs4_label l, *ilabel = NULL;
8867fe58 4025 struct nfs_open_context *ctx;
1da177e4 4026 struct nfs4_state *state;
1da177e4
LT		 4027 int status = 0;
4028
532d4def 4029 ctx = alloc_nfs_open_context(dentry, FMODE_READ, NULL);
8867fe58
MS		 4030 if (IS_ERR(ctx))
4031 return PTR_ERR(ctx);
4032
aa9c2669
DQ		 4033 ilabel = nfs4_label_init_security(dir, dentry, sattr, &l);
4034
dff25ddb
AG		 4035 if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK))
4036 sattr->ia_mode &= ~current_umask();
c5c3fb5f 4037 state = nfs4_do_open(dir, ctx, flags, sattr, ilabel, NULL);
1da177e4
LT		 4038 if (IS_ERR(state)) {
4039 status = PTR_ERR(state);
c0204fd2 4040 goto out;
1da177e4 4041 }
1da177e4 4042out:
aa9c2669 4043 nfs4_label_release_security(ilabel);
8867fe58 4044 put_nfs_open_context(ctx);
1da177e4
LT		 4045 return status;
4046}
4047
beffb8fe 4048static int _nfs4_proc_remove(struct inode *dir, const struct qstr *name)
1da177e4 4049{
16e42959 4050 struct nfs_server *server = NFS_SERVER(dir);
4fdc17b2 4051 struct nfs_removeargs args = {
1da177e4 4052 .fh = NFS_FH(dir),
26fe5750 4053 .name = *name,
16e42959 4054 };
4fdc17b2 4055 struct nfs_removeres res = {
16e42959 4056 .server = server,
1da177e4 4057 };
1da177e4 4058 struct rpc_message msg = {
4fdc17b2
TM		 4059 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE],
4060 .rpc_argp = &args,
4061 .rpc_resp = &res,
1da177e4 4062 };
d3129ef6 4063 unsigned long timestamp = jiffies;
778d2817 4064 int status;
1da177e4 4065
7c513058 4066 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 1);
778d2817 4067 if (status == 0)
d3129ef6 4068 update_changeattr(dir, &res.cinfo, timestamp);
1da177e4
LT		 4069 return status;
4070}
4071
beffb8fe 4072static int nfs4_proc_remove(struct inode *dir, const struct qstr *name)
1da177e4
LT		 4073{
4074 struct nfs4_exception exception = { };
4075 int err;
4076 do {
078ea3df
TM		 4077 err = _nfs4_proc_remove(dir, name);
4078 trace_nfs4_remove(dir, name, err);
4079 err = nfs4_handle_exception(NFS_SERVER(dir), err,
1da177e4
LT		 4080 &exception);
4081 } while (exception.retry);
4082 return err;
4083}
4084
e4eff1a6 4085static void nfs4_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
1da177e4 4086{
e4eff1a6
TM		 4087 struct nfs_server *server = NFS_SERVER(dir);
4088 struct nfs_removeargs *args = msg->rpc_argp;
4089 struct nfs_removeres *res = msg->rpc_resp;
1da177e4 4090
e4eff1a6 4091 res->server = server;
1da177e4 4092 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE];
a9c92d6b 4093 nfs4_init_sequence(&args->seq_args, &res->seq_res, 1);
aa9c2669
DQ		 4094
4095 nfs_fattr_init(res->dir_attr);
1da177e4
LT		 4096}
4097
34e137cc
BS		 4098static void nfs4_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
4099{
42e1cca7 4100 nfs4_setup_sequence(NFS_SB(data->dentry->d_sb)->nfs_client,
d9afbd1b
TM		 4101 &data->args.seq_args,
4102 &data->res.seq_res,
4103 task);
1da177e4
LT		 4104}
4105
e4eff1a6 4106static int nfs4_proc_unlink_done(struct rpc_task *task, struct inode *dir)
1da177e4 4107{
078ea3df
TM		 4108 struct nfs_unlinkdata *data = task->tk_calldata;
4109 struct nfs_removeres *res = &data->res;
e4eff1a6 4110
14516c3a
TM		 4111 if (!nfs4_sequence_done(task, &res->seq_res))
4112 return 0;
8478eaa1
N		 4113 if (nfs4_async_handle_error(task, res->server, NULL,
4114 &data->timeout) == -EAGAIN)
e4eff1a6 4115 return 0;
c40d52fe 4116 if (task->tk_status == 0)
d3129ef6 4117 update_changeattr(dir, &res->cinfo, res->dir_attr->time_start);
e4eff1a6 4118 return 1;
1da177e4
LT		 4119}
4120
d3d4152a
JL		 4121static void nfs4_proc_rename_setup(struct rpc_message *msg, struct inode *dir)
4122{
4123 struct nfs_server *server = NFS_SERVER(dir);
4124 struct nfs_renameargs *arg = msg->rpc_argp;
4125 struct nfs_renameres *res = msg->rpc_resp;
4126
4127 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME];
d3d4152a 4128 res->server = server;
a9c92d6b 4129 nfs4_init_sequence(&arg->seq_args, &res->seq_res, 1);
d3d4152a
JL		 4130}
4131
c6bfa1a1
BS		 4132static void nfs4_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
4133{
42e1cca7 4134 nfs4_setup_sequence(NFS_SERVER(data->old_dir)->nfs_client,
d9afbd1b
TM		 4135 &data->args.seq_args,
4136 &data->res.seq_res,
4137 task);
d3d4152a
JL		 4138}
4139
4140static int nfs4_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
4141 struct inode *new_dir)
4142{
fbc6f7c2
TM		 4143 struct nfs_renamedata *data = task->tk_calldata;
4144 struct nfs_renameres *res = &data->res;
d3d4152a
JL		 4145
4146 if (!nfs4_sequence_done(task, &res->seq_res))
4147 return 0;
8478eaa1 4148 if (nfs4_async_handle_error(task, res->server, NULL, &data->timeout) == -EAGAIN)
d3d4152a
JL		 4149 return 0;
4150
c733c49c 4151 if (task->tk_status == 0) {
d3129ef6 4152 update_changeattr(old_dir, &res->old_cinfo, res->old_fattr->time_start);
c733c49c 4153 if (new_dir != old_dir)
d3129ef6 4154 update_changeattr(new_dir, &res->new_cinfo, res->new_fattr->time_start);
c733c49c 4155 }
d3d4152a
JL		 4156 return 1;
4157}
4158
beffb8fe 4159static int _nfs4_proc_link(struct inode *inode, struct inode *dir, const struct qstr *name)
1da177e4 4160{
91ba2eee 4161 struct nfs_server *server = NFS_SERVER(inode);
1da177e4
LT		 4162 struct nfs4_link_arg arg = {
4163 .fh = NFS_FH(inode),
4164 .dir_fh = NFS_FH(dir),
4165 .name = name,
91ba2eee
TM		 4166 .bitmask = server->attr_bitmask,
4167 };
91ba2eee
TM		 4168 struct nfs4_link_res res = {
4169 .server = server,
1775fd3e 4170 .label = NULL,
1da177e4 4171 };
1da177e4
LT		 4172 struct rpc_message msg = {
4173 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LINK],
4174 .rpc_argp = &arg,
91ba2eee 4175 .rpc_resp = &res,
1da177e4 4176 };
136f2627
TM		 4177 int status = -ENOMEM;
4178
4179 res.fattr = nfs_alloc_fattr();
778d2817 4180 if (res.fattr == NULL)
136f2627 4181 goto out;
1da177e4 4182
14c43f76
DQ		 4183 res.label = nfs4_label_alloc(server, GFP_KERNEL);
4184 if (IS_ERR(res.label)) {
4185 status = PTR_ERR(res.label);
4186 goto out;
4187 }
aa9c2669 4188 arg.bitmask = nfs4_bitmask(server, res.label);
14c43f76 4189
7c513058 4190 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
91ba2eee 4191 if (!status) {
d3129ef6 4192 update_changeattr(dir, &res.cinfo, res.fattr->time_start);
aa9c2669
DQ		 4193 status = nfs_post_op_update_inode(inode, res.fattr);
4194 if (!status)
4195 nfs_setsecurity(inode, res.fattr, res.label);
91ba2eee 4196 }
14c43f76
DQ		 4197
4198
4199 nfs4_label_free(res.label);
4200
136f2627 4201out:
136f2627 4202 nfs_free_fattr(res.fattr);
1da177e4
LT		 4203 return status;
4204}
4205
beffb8fe 4206static int nfs4_proc_link(struct inode *inode, struct inode *dir, const struct qstr *name)
1da177e4
LT		 4207{
4208 struct nfs4_exception exception = { };
4209 int err;
4210 do {
4211 err = nfs4_handle_exception(NFS_SERVER(inode),
4212 _nfs4_proc_link(inode, dir, name),
4213 &exception);
4214 } while (exception.retry);
4215 return err;
4216}
4217
57dc9a57
TM		 4218struct nfs4_createdata {
4219 struct rpc_message msg;
4220 struct nfs4_create_arg arg;
4221 struct nfs4_create_res res;
4222 struct nfs_fh fh;
4223 struct nfs_fattr fattr;
1775fd3e 4224 struct nfs4_label *label;
57dc9a57
TM		 4225};
4226
4227static struct nfs4_createdata *nfs4_alloc_createdata(struct inode *dir,
beffb8fe 4228 const struct qstr *name, struct iattr *sattr, u32 ftype)
57dc9a57
TM		 4229{
4230 struct nfs4_createdata *data;
4231
4232 data = kzalloc(sizeof(*data), GFP_KERNEL);
4233 if (data != NULL) {
4234 struct nfs_server *server = NFS_SERVER(dir);
4235
14c43f76
DQ		 4236 data->label = nfs4_label_alloc(server, GFP_KERNEL);
4237 if (IS_ERR(data->label))
4238 goto out_free;
4239
57dc9a57
TM		 4240 data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE];
4241 data->msg.rpc_argp = &data->arg;
4242 data->msg.rpc_resp = &data->res;
4243 data->arg.dir_fh = NFS_FH(dir);
4244 data->arg.server = server;
4245 data->arg.name = name;
4246 data->arg.attrs = sattr;
4247 data->arg.ftype = ftype;
aa9c2669 4248 data->arg.bitmask = nfs4_bitmask(server, data->label);
dff25ddb 4249 data->arg.umask = current_umask();
57dc9a57
TM		 4250 data->res.server = server;
4251 data->res.fh = &data->fh;
4252 data->res.fattr = &data->fattr;
1775fd3e 4253 data->res.label = data->label;
57dc9a57 4254 nfs_fattr_init(data->res.fattr);
57dc9a57
TM		 4255 }
4256 return data;
14c43f76
DQ		 4257out_free:
4258 kfree(data);
4259 return NULL;
57dc9a57
TM		 4260}
4261
4262static int nfs4_do_create(struct inode *dir, struct dentry *dentry, struct nfs4_createdata *data)
4263{
7c513058 4264 int status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &data->msg,
e73b83f2 4265 &data->arg.seq_args, &data->res.seq_res, 1);
57dc9a57 4266 if (status == 0) {
d3129ef6
TM		 4267 update_changeattr(dir, &data->res.dir_cinfo,
4268 data->res.fattr->time_start);
1775fd3e 4269 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, data->res.label);
57dc9a57
TM		 4270 }
4271 return status;
4272}
4273
4274static void nfs4_free_createdata(struct nfs4_createdata *data)
4275{
14c43f76 4276 nfs4_label_free(data->label);
57dc9a57
TM		 4277 kfree(data);
4278}
4279
4f390c15 4280static int _nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
1775fd3e
DQ		 4281 struct page *page, unsigned int len, struct iattr *sattr,
4282 struct nfs4_label *label)
1da177e4 4283{
57dc9a57
TM		 4284 struct nfs4_createdata *data;
4285 int status = -ENAMETOOLONG;
1da177e4 4286
94a6d753 4287 if (len > NFS4_MAXPATHLEN)
57dc9a57 4288 goto out;
4f390c15 4289
57dc9a57
TM		 4290 status = -ENOMEM;
4291 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4LNK);
4292 if (data == NULL)
4293 goto out;
4294
4295 data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SYMLINK];
4296 data->arg.u.symlink.pages = &page;
4297 data->arg.u.symlink.len = len;
1775fd3e 4298 data->arg.label = label;
1da177e4 4299
57dc9a57
TM		 4300 status = nfs4_do_create(dir, dentry, data);
4301
4302 nfs4_free_createdata(data);
4303out:
1da177e4
LT		 4304 return status;
4305}
4306
4f390c15 4307static int nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
94a6d753 4308 struct page *page, unsigned int len, struct iattr *sattr)
1da177e4
LT		 4309{
4310 struct nfs4_exception exception = { };
aa9c2669 4311 struct nfs4_label l, *label = NULL;
1da177e4 4312 int err;
aa9c2669
DQ		 4313
4314 label = nfs4_label_init_security(dir, dentry, sattr, &l);
4315
1da177e4 4316 do {
078ea3df
TM		 4317 err = _nfs4_proc_symlink(dir, dentry, page, len, sattr, label);
4318 trace_nfs4_symlink(dir, &dentry->d_name, err);
4319 err = nfs4_handle_exception(NFS_SERVER(dir), err,
1da177e4
LT		 4320 &exception);
4321 } while (exception.retry);
aa9c2669
DQ		 4322
4323 nfs4_label_release_security(label);
1da177e4
LT		 4324 return err;
4325}
4326
4327static int _nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
1775fd3e 4328 struct iattr *sattr, struct nfs4_label *label)
1da177e4 4329{
57dc9a57
TM		 4330 struct nfs4_createdata *data;
4331 int status = -ENOMEM;
1da177e4 4332
57dc9a57
TM		 4333 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4DIR);
4334 if (data == NULL)
4335 goto out;
4336
1775fd3e 4337 data->arg.label = label;
57dc9a57
TM		 4338 status = nfs4_do_create(dir, dentry, data);
4339
4340 nfs4_free_createdata(data);
4341out:
1da177e4
LT		 4342 return status;
4343}
4344
4345static int nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
4346 struct iattr *sattr)
4347{
dff25ddb 4348 struct nfs_server *server = NFS_SERVER(dir);
1da177e4 4349 struct nfs4_exception exception = { };
aa9c2669 4350 struct nfs4_label l, *label = NULL;
1da177e4 4351 int err;
a8a5da99 4352
aa9c2669
DQ		 4353 label = nfs4_label_init_security(dir, dentry, sattr, &l);
4354
dff25ddb
AG		 4355 if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK))
4356 sattr->ia_mode &= ~current_umask();
1da177e4 4357 do {
078ea3df
TM		 4358 err = _nfs4_proc_mkdir(dir, dentry, sattr, label);
4359 trace_nfs4_mkdir(dir, &dentry->d_name, err);
4360 err = nfs4_handle_exception(NFS_SERVER(dir), err,
1da177e4
LT		 4361 &exception);
4362 } while (exception.retry);
aa9c2669
DQ		 4363 nfs4_label_release_security(label);
4364
1da177e4
LT		 4365 return err;
4366}
4367
4368static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
56e4ebf8 4369 u64 cookie, struct page **pages, unsigned int count, int plus)
1da177e4 4370{
2b0143b5 4371 struct inode *dir = d_inode(dentry);
1da177e4
LT		 4372 struct nfs4_readdir_arg args = {
4373 .fh = NFS_FH(dir),
56e4ebf8 4374 .pages = pages,
1da177e4
LT		 4375 .pgbase = 0,
4376 .count = count,
2b0143b5 4377 .bitmask = NFS_SERVER(d_inode(dentry))->attr_bitmask,
82f2e547 4378 .plus = plus,
1da177e4
LT		 4379 };
4380 struct nfs4_readdir_res res;
4381 struct rpc_message msg = {
4382 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READDIR],
4383 .rpc_argp = &args,
4384 .rpc_resp = &res,
4385 .rpc_cred = cred,
4386 };
4387 int status;
4388
6de1472f
AV		 4389 dprintk("%s: dentry = %pd2, cookie = %Lu\n", __func__,
4390 dentry,
eadf4598 4391 (unsigned long long)cookie);
c3f52af3 4392 nfs4_setup_readdir(cookie, NFS_I(dir)->cookieverf, dentry, &args);
1da177e4 4393 res.pgbase = args.pgbase;
7c513058 4394 status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &msg, &args.seq_args, &res.seq_res, 0);
ac396128 4395 if (status >= 0) {
c3f52af3 4396 memcpy(NFS_I(dir)->cookieverf, res.verifier.data, NFS4_VERIFIER_SIZE);
ac396128
TM		 4397 status += args.pgbase;
4398 }
c4812998
TM		 4399
4400 nfs_invalidate_atime(dir);
4401
3110ff80 4402 dprintk("%s: returns %d\n", __func__, status);
1da177e4
LT		 4403 return status;
4404}
4405
4406static int nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
56e4ebf8 4407 u64 cookie, struct page **pages, unsigned int count, int plus)
1da177e4
LT		 4408{
4409 struct nfs4_exception exception = { };
4410 int err;
4411 do {
c1578b76
TM		 4412 err = _nfs4_proc_readdir(dentry, cred, cookie,
4413 pages, count, plus);
2b0143b5
DH		 4414 trace_nfs4_readdir(d_inode(dentry), err);
4415 err = nfs4_handle_exception(NFS_SERVER(d_inode(dentry)), err,
1da177e4
LT		 4416 &exception);
4417 } while (exception.retry);
4418 return err;
4419}
4420
4421static int _nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
aa9c2669 4422 struct iattr *sattr, struct nfs4_label *label, dev_t rdev)
1da177e4 4423{
57dc9a57
TM		 4424 struct nfs4_createdata *data;
4425 int mode = sattr->ia_mode;
4426 int status = -ENOMEM;
1da177e4 4427
57dc9a57
TM		 4428 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4SOCK);
4429 if (data == NULL)
4430 goto out;
4431
1da177e4 4432 if (S_ISFIFO(mode))
57dc9a57 4433 data->arg.ftype = NF4FIFO;
1da177e4 4434 else if (S_ISBLK(mode)) {
57dc9a57
TM		 4435 data->arg.ftype = NF4BLK;
4436 data->arg.u.device.specdata1 = MAJOR(rdev);
4437 data->arg.u.device.specdata2 = MINOR(rdev);
1da177e4
LT		 4438 }
4439 else if (S_ISCHR(mode)) {
57dc9a57
TM		 4440 data->arg.ftype = NF4CHR;
4441 data->arg.u.device.specdata1 = MAJOR(rdev);
4442 data->arg.u.device.specdata2 = MINOR(rdev);
4ea8fed5
TM		 4443 } else if (!S_ISSOCK(mode)) {
4444 status = -EINVAL;
4445 goto out_free;
1da177e4 4446 }
1775fd3e 4447
aa9c2669 4448 data->arg.label = label;
57dc9a57 4449 status = nfs4_do_create(dir, dentry, data);
4ea8fed5 4450out_free:
57dc9a57
TM		 4451 nfs4_free_createdata(data);
4452out:
1da177e4
LT		 4453 return status;
4454}
4455
4456static int nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
4457 struct iattr *sattr, dev_t rdev)
4458{
dff25ddb 4459 struct nfs_server *server = NFS_SERVER(dir);
1da177e4 4460 struct nfs4_exception exception = { };
aa9c2669 4461 struct nfs4_label l, *label = NULL;
1da177e4 4462 int err;
a8a5da99 4463
aa9c2669
DQ		 4464 label = nfs4_label_init_security(dir, dentry, sattr, &l);
4465
dff25ddb
AG		 4466 if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK))
4467 sattr->ia_mode &= ~current_umask();
1da177e4 4468 do {
078ea3df
TM		 4469 err = _nfs4_proc_mknod(dir, dentry, sattr, label, rdev);
4470 trace_nfs4_mknod(dir, &dentry->d_name, err);
4471 err = nfs4_handle_exception(NFS_SERVER(dir), err,
1da177e4
LT		 4472 &exception);
4473 } while (exception.retry);
aa9c2669
DQ		 4474
4475 nfs4_label_release_security(label);
4476
1da177e4
LT		 4477 return err;
4478}
4479
4480static int _nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
4481 struct nfs_fsstat *fsstat)
4482{
4483 struct nfs4_statfs_arg args = {
4484 .fh = fhandle,
4485 .bitmask = server->attr_bitmask,
4486 };
24ad148a
BH		 4487 struct nfs4_statfs_res res = {
4488 .fsstat = fsstat,
4489 };
1da177e4
LT		 4490 struct rpc_message msg = {
4491 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_STATFS],
4492 .rpc_argp = &args,
24ad148a 4493 .rpc_resp = &res,
1da177e4
LT		 4494 };
4495
0e574af1 4496 nfs_fattr_init(fsstat->fattr);
7c513058 4497 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
1da177e4
LT		 4498}
4499
4500static int nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsstat *fsstat)
4501{
4502 struct nfs4_exception exception = { };
4503 int err;
4504 do {
4505 err = nfs4_handle_exception(server,
4506 _nfs4_proc_statfs(server, fhandle, fsstat),
4507 &exception);
4508 } while (exception.retry);
4509 return err;
4510}
4511
4512static int _nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
4513 struct nfs_fsinfo *fsinfo)
4514{
4515 struct nfs4_fsinfo_arg args = {
4516 .fh = fhandle,
4517 .bitmask = server->attr_bitmask,
4518 };
3dda5e43
BH		 4519 struct nfs4_fsinfo_res res = {
4520 .fsinfo = fsinfo,
4521 };
1da177e4
LT		 4522 struct rpc_message msg = {
4523 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSINFO],
4524 .rpc_argp = &args,
3dda5e43 4525 .rpc_resp = &res,
1da177e4
LT		 4526 };
4527
7c513058 4528 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
1da177e4
LT		 4529}
4530
4531static int nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
4532{
4533 struct nfs4_exception exception = { };
83ca7f5a 4534 unsigned long now = jiffies;
1da177e4
LT		 4535 int err;
4536
4537 do {
83ca7f5a 4538 err = _nfs4_do_fsinfo(server, fhandle, fsinfo);
b5f875a9 4539 trace_nfs4_fsinfo(server, fhandle, fsinfo->fattr, err);
83ca7f5a 4540 if (err == 0) {
fb10fb67
TM		 4541 nfs4_set_lease_period(server->nfs_client,
4542 fsinfo->lease_time * HZ,
4543 now);
83ca7f5a
CL		 4544 break;
4545 }
4546 err = nfs4_handle_exception(server, err, &exception);
1da177e4
LT		 4547 } while (exception.retry);
4548 return err;
4549}
4550
4551static int nfs4_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
4552{
e38eb650
BS		 4553 int error;
4554
0e574af1 4555 nfs_fattr_init(fsinfo->fattr);
e38eb650 4556 error = nfs4_do_fsinfo(server, fhandle, fsinfo);
dc182549
PT		 4557 if (error == 0) {
4558 /* block layout checks this! */
4559 server->pnfs_blksize = fsinfo->blksize;
ca440c38 4560 set_pnfs_layoutdriver(server, fhandle, fsinfo);
dc182549 4561 }
e38eb650
BS		 4562
4563 return error;
1da177e4
LT		 4564}
4565
4566static int _nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
4567 struct nfs_pathconf *pathconf)
4568{
4569 struct nfs4_pathconf_arg args = {
4570 .fh = fhandle,
4571 .bitmask = server->attr_bitmask,
4572 };
d45b2989
BH		 4573 struct nfs4_pathconf_res res = {
4574 .pathconf = pathconf,
4575 };
1da177e4
LT		 4576 struct rpc_message msg = {
4577 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_PATHCONF],
4578 .rpc_argp = &args,
d45b2989 4579 .rpc_resp = &res,
1da177e4
LT		 4580 };
4581
4582 /* None of the pathconf attributes are mandatory to implement */
4583 if ((args.bitmask[0] & nfs4_pathconf_bitmap[0]) == 0) {
4584 memset(pathconf, 0, sizeof(*pathconf));
4585 return 0;
4586 }
4587
0e574af1 4588 nfs_fattr_init(pathconf->fattr);
7c513058 4589 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
1da177e4
LT		 4590}
4591
4592static int nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
4593 struct nfs_pathconf *pathconf)
4594{
4595 struct nfs4_exception exception = { };
4596 int err;
4597
4598 do {
4599 err = nfs4_handle_exception(server,
4600 _nfs4_proc_pathconf(server, fhandle, pathconf),
4601 &exception);
4602 } while (exception.retry);
4603 return err;
4604}
4605
5521abfd 4606int nfs4_set_rw_stateid(nfs4_stateid *stateid,
9b206149
TM		 4607 const struct nfs_open_context *ctx,
4608 const struct nfs_lock_context *l_ctx,
4609 fmode_t fmode)
4610{
17393475 4611 return nfs4_select_rw_stateid(ctx->state, fmode, l_ctx, stateid, NULL);
9b206149
TM		 4612}
4613EXPORT_SYMBOL_GPL(nfs4_set_rw_stateid);
4614
5521abfd
TM		 4615static bool nfs4_stateid_is_current(nfs4_stateid *stateid,
4616 const struct nfs_open_context *ctx,
4617 const struct nfs_lock_context *l_ctx,
4618 fmode_t fmode)
4619{
4620 nfs4_stateid current_stateid;
4621
e1253be0
TM		 4622 /* If the current stateid represents a lost lock, then exit */
4623 if (nfs4_set_rw_stateid(&current_stateid, ctx, l_ctx, fmode) == -EIO)
4624 return true;
5521abfd
TM		 4625 return nfs4_stateid_match(stateid, &current_stateid);
4626}
4627
4628static bool nfs4_error_stateid_expired(int err)
4629{
4630 switch (err) {
4631 case -NFS4ERR_DELEG_REVOKED:
4632 case -NFS4ERR_ADMIN_REVOKED:
4633 case -NFS4ERR_BAD_STATEID:
4634 case -NFS4ERR_STALE_STATEID:
4635 case -NFS4ERR_OLD_STATEID:
4636 case -NFS4ERR_OPENMODE:
4637 case -NFS4ERR_EXPIRED:
4638 return true;
4639 }
4640 return false;
4641}
4642
d45f60c6 4643static int nfs4_read_done_cb(struct rpc_task *task, struct nfs_pgio_header *hdr)
1da177e4 4644{
d45f60c6 4645 struct nfs_server *server = NFS_SERVER(hdr->inode);
1da177e4 4646
d45f60c6 4647 trace_nfs4_read(hdr, task->tk_status);
9c27869d
TM		 4648 if (task->tk_status < 0) {
4649 struct nfs4_exception exception = {
4650 .inode = hdr->inode,
4651 .state = hdr->args.context->state,
4652 .stateid = &hdr->args.stateid,
4653 };
4654 task->tk_status = nfs4_async_handle_exception(task,
4655 server, task->tk_status, &exception);
4656 if (exception.retry) {
4657 rpc_restart_call_prepare(task);
4658 return -EAGAIN;
4659 }
1da177e4 4660 }
8850df99 4661
1da177e4 4662 if (task->tk_status > 0)
d45f60c6 4663 renew_lease(server, hdr->timestamp);
ec06c096 4664 return 0;
1da177e4
LT		 4665}
4666
5521abfd 4667static bool nfs4_read_stateid_changed(struct rpc_task *task,
3c6b899c 4668 struct nfs_pgio_args *args)
5521abfd
TM		 4669{
4670
4671 if (!nfs4_error_stateid_expired(task->tk_status) ||
4672 nfs4_stateid_is_current(&args->stateid,
4673 args->context,
4674 args->lock_context,
4675 FMODE_READ))
4676 return false;
4677 rpc_restart_call_prepare(task);
4678 return true;
4679}
4680
d45f60c6 4681static int nfs4_read_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
cbdabc7f
AA		 4682{
4683
4684 dprintk("--> %s\n", __func__);
4685
d45f60c6 4686 if (!nfs4_sequence_done(task, &hdr->res.seq_res))
cbdabc7f 4687 return -EAGAIN;
d45f60c6 4688 if (nfs4_read_stateid_changed(task, &hdr->args))
5521abfd 4689 return -EAGAIN;
bfc505de
TM		 4690 if (task->tk_status > 0)
4691 nfs_invalidate_atime(hdr->inode);
d45f60c6
WAA		 4692 return hdr->pgio_done_cb ? hdr->pgio_done_cb(task, hdr) :
4693 nfs4_read_done_cb(task, hdr);
cbdabc7f
AA		 4694}
4695
d45f60c6
WAA		 4696static void nfs4_proc_read_setup(struct nfs_pgio_header *hdr,
4697 struct rpc_message *msg)
1da177e4 4698{
d45f60c6 4699 hdr->timestamp = jiffies;
ca857cc1
TM		 4700 if (!hdr->pgio_done_cb)
4701 hdr->pgio_done_cb = nfs4_read_done_cb;
bdc7f021 4702 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READ];
d45f60c6 4703 nfs4_init_sequence(&hdr->args.seq_args, &hdr->res.seq_res, 0);
1da177e4
LT		 4704}
4705
d45f60c6
WAA		 4706static int nfs4_proc_pgio_rpc_prepare(struct rpc_task *task,
4707 struct nfs_pgio_header *hdr)
ea7c3303 4708{
42e1cca7 4709 if (nfs4_setup_sequence(NFS_SERVER(hdr->inode)->nfs_client,
d45f60c6
WAA		 4710 &hdr->args.seq_args,
4711 &hdr->res.seq_res,
9b206149 4712 task))
ef1820f9 4713 return 0;
d45f60c6
WAA		 4714 if (nfs4_set_rw_stateid(&hdr->args.stateid, hdr->args.context,
4715 hdr->args.lock_context,
4716 hdr->rw_ops->rw_mode) == -EIO)
ef1820f9 4717 return -EIO;
d45f60c6 4718 if (unlikely(test_bit(NFS_CONTEXT_BAD, &hdr->args.context->flags)))
ef1820f9
N		 4719 return -EIO;
4720 return 0;
1da177e4
LT		 4721}
4722
d45f60c6
WAA		 4723static int nfs4_write_done_cb(struct rpc_task *task,
4724 struct nfs_pgio_header *hdr)
1da177e4 4725{
d45f60c6 4726 struct inode *inode = hdr->inode;
8478eaa1 4727
d45f60c6 4728 trace_nfs4_write(hdr, task->tk_status);
9c27869d
TM		 4729 if (task->tk_status < 0) {
4730 struct nfs4_exception exception = {
4731 .inode = hdr->inode,
4732 .state = hdr->args.context->state,
4733 .stateid = &hdr->args.stateid,
4734 };
4735 task->tk_status = nfs4_async_handle_exception(task,
4736 NFS_SERVER(inode), task->tk_status,
4737 &exception);
4738 if (exception.retry) {
4739 rpc_restart_call_prepare(task);
4740 return -EAGAIN;
4741 }
1da177e4 4742 }
4f9838c7 4743 if (task->tk_status >= 0) {
d45f60c6 4744 renew_lease(NFS_SERVER(inode), hdr->timestamp);
a08a8cd3 4745 nfs_writeback_update_inode(hdr);
4f9838c7 4746 }
788e7a89 4747 return 0;
1da177e4
LT		 4748}
4749
5521abfd 4750static bool nfs4_write_stateid_changed(struct rpc_task *task,
3c6b899c 4751 struct nfs_pgio_args *args)
5521abfd
TM		 4752{
4753
4754 if (!nfs4_error_stateid_expired(task->tk_status) ||
4755 nfs4_stateid_is_current(&args->stateid,
4756 args->context,
4757 args->lock_context,
4758 FMODE_WRITE))
4759 return false;
4760 rpc_restart_call_prepare(task);
4761 return true;
4762}
4763
d45f60c6 4764static int nfs4_write_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
b029bc9b 4765{
d45f60c6 4766 if (!nfs4_sequence_done(task, &hdr->res.seq_res))
b029bc9b 4767 return -EAGAIN;
d45f60c6 4768 if (nfs4_write_stateid_changed(task, &hdr->args))
5521abfd 4769 return -EAGAIN;
d45f60c6
WAA		 4770 return hdr->pgio_done_cb ? hdr->pgio_done_cb(task, hdr) :
4771 nfs4_write_done_cb(task, hdr);
b029bc9b
FI		 4772}
4773
5a37f851 4774static
d45f60c6 4775bool nfs4_write_need_cache_consistency_data(struct nfs_pgio_header *hdr)
a69aef14 4776{
5a37f851 4777 /* Don't request attributes for pNFS or O_DIRECT writes */
d45f60c6 4778 if (hdr->ds_clp != NULL || hdr->dreq != NULL)
5a37f851
TM		 4779 return false;
4780 /* Otherwise, request attributes if and only if we don't hold
4781 * a delegation
4782 */
011e2a7f 4783 return nfs4_have_delegation(hdr->inode, FMODE_READ) == 0;
a69aef14 4784}
a69aef14 4785
d45f60c6
WAA		 4786static void nfs4_proc_write_setup(struct nfs_pgio_header *hdr,
4787 struct rpc_message *msg)
1da177e4 4788{
d45f60c6 4789 struct nfs_server *server = NFS_SERVER(hdr->inode);
bdc7f021 4790
d45f60c6
WAA		 4791 if (!nfs4_write_need_cache_consistency_data(hdr)) {
4792 hdr->args.bitmask = NULL;
4793 hdr->res.fattr = NULL;
7ffd1064 4794 } else
d45f60c6 4795 hdr->args.bitmask = server->cache_consistency_bitmask;
5a37f851 4796
d45f60c6
WAA		 4797 if (!hdr->pgio_done_cb)
4798 hdr->pgio_done_cb = nfs4_write_done_cb;
4799 hdr->res.server = server;
4800 hdr->timestamp = jiffies;
1da177e4 4801
bdc7f021 4802 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_WRITE];
d45f60c6 4803 nfs4_init_sequence(&hdr->args.seq_args, &hdr->res.seq_res, 1);
1da177e4
LT		 4804}
4805
0b7c0153 4806static void nfs4_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data)
c6cb80d0 4807{
42e1cca7 4808 nfs4_setup_sequence(NFS_SERVER(data->inode)->nfs_client,
d9afbd1b
TM		 4809 &data->args.seq_args,
4810 &data->res.seq_res,
4811 task);
1da177e4
LT		 4812}
4813
0b7c0153 4814static int nfs4_commit_done_cb(struct rpc_task *task, struct nfs_commit_data *data)
1da177e4 4815{
1da177e4 4816 struct inode *inode = data->inode;
14516c3a 4817
cc668ab3 4818 trace_nfs4_commit(data, task->tk_status);
8478eaa1
N		 4819 if (nfs4_async_handle_error(task, NFS_SERVER(inode),
4820 NULL, NULL) == -EAGAIN) {
d00c5d43 4821 rpc_restart_call_prepare(task);
788e7a89 4822 return -EAGAIN;
1da177e4 4823 }
788e7a89 4824 return 0;
1da177e4
LT		 4825}
4826
0b7c0153 4827static int nfs4_commit_done(struct rpc_task *task, struct nfs_commit_data *data)
5f452431
FI		 4828{
4829 if (!nfs4_sequence_done(task, &data->res.seq_res))
4830 return -EAGAIN;
0b7c0153 4831 return data->commit_done_cb(task, data);
5f452431
FI		 4832}
4833
0b7c0153 4834static void nfs4_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg)
1da177e4 4835{
788e7a89 4836 struct nfs_server *server = NFS_SERVER(data->inode);
988b6dce 4837
0b7c0153
FI		 4838 if (data->commit_done_cb == NULL)
4839 data->commit_done_cb = nfs4_commit_done_cb;
4f9838c7 4840 data->res.server = server;
bdc7f021 4841 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COMMIT];
a9c92d6b 4842 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
1da177e4
LT		 4843}
4844
9bc4e3ca
CL		 4845struct nfs4_renewdata {
4846 struct nfs_client *client;
4847 unsigned long timestamp;
4848};
4849
1da177e4
LT		 4850/*
4851 * nfs4_proc_async_renew(): This is not one of the nfs_rpc_ops; it is a special
4852 * standalone procedure for queueing an asynchronous RENEW.
4853 */
9bc4e3ca 4854static void nfs4_renew_release(void *calldata)
dc96aef9 4855{
9bc4e3ca
CL		 4856 struct nfs4_renewdata *data = calldata;
4857 struct nfs_client *clp = data->client;
dc96aef9 4858
0851de06
AB		 4859 if (atomic_read(&clp->cl_count) > 1)
4860 nfs4_schedule_state_renewal(clp);
4861 nfs_put_client(clp);
9bc4e3ca 4862 kfree(data);
dc96aef9
AB		 4863}
4864
9bc4e3ca 4865static void nfs4_renew_done(struct rpc_task *task, void *calldata)
1da177e4 4866{
9bc4e3ca
CL		 4867 struct nfs4_renewdata *data = calldata;
4868 struct nfs_client *clp = data->client;
4869 unsigned long timestamp = data->timestamp;
1da177e4 4870
c6d01c6f 4871 trace_nfs4_renew_async(clp, task->tk_status);
f8aba1e8
CL		 4872 switch (task->tk_status) {
4873 case 0:
4874 break;
4875 case -NFS4ERR_LEASE_MOVED:
4876 nfs4_schedule_lease_moved_recovery(clp);
4877 break;
4878 default:
95baa25c 4879 /* Unless we're shutting down, schedule state recovery! */
042b60be
TM		 4880 if (test_bit(NFS_CS_RENEWD, &clp->cl_res_state) == 0)
4881 return;
4882 if (task->tk_status != NFS4ERR_CB_PATH_DOWN) {
0400a6b0 4883 nfs4_schedule_lease_recovery(clp);
042b60be
TM		 4884 return;
4885 }
4886 nfs4_schedule_path_down_recovery(clp);
1da177e4 4887 }
452e9352 4888 do_renew_lease(clp, timestamp);
1da177e4
LT		 4889}
4890
963d8fe5
TM		 4891static const struct rpc_call_ops nfs4_renew_ops = {
4892 .rpc_call_done = nfs4_renew_done,
dc96aef9 4893 .rpc_release = nfs4_renew_release,
963d8fe5
TM		 4894};
4895
2f60ea6b 4896static int nfs4_proc_async_renew(struct nfs_client *clp, struct rpc_cred *cred, unsigned renew_flags)
1da177e4
LT		 4897{
4898 struct rpc_message msg = {
4899 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW],
4900 .rpc_argp = clp,
b4454fe1 4901 .rpc_cred = cred,
1da177e4 4902 };
9bc4e3ca 4903 struct nfs4_renewdata *data;
1da177e4 4904
2f60ea6b
TM		 4905 if (renew_flags == 0)
4906 return 0;
0851de06
AB		 4907 if (!atomic_inc_not_zero(&clp->cl_count))
4908 return -EIO;
b569ad34 4909 data = kmalloc(sizeof(*data), GFP_NOFS);
9bc4e3ca
CL		 4910 if (data == NULL)
4911 return -ENOMEM;
4912 data->client = clp;
4913 data->timestamp = jiffies;
bc7a05ca 4914 return rpc_call_async(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT,
9bc4e3ca 4915 &nfs4_renew_ops, data);
1da177e4
LT		 4916}
4917
8534d4ec 4918static int nfs4_proc_renew(struct nfs_client *clp, struct rpc_cred *cred)
1da177e4
LT		 4919{
4920 struct rpc_message msg = {
4921 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW],
4922 .rpc_argp = clp,
b4454fe1 4923 .rpc_cred = cred,
1da177e4
LT		 4924 };
4925 unsigned long now = jiffies;
4926 int status;
4927
bc7a05ca 4928 status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
1da177e4
LT		 4929 if (status < 0)
4930 return status;
452e9352 4931 do_renew_lease(clp, now);
1da177e4
LT		 4932 return 0;
4933}
4934
aa1870af
BF		 4935static inline int nfs4_server_supports_acls(struct nfs_server *server)
4936{
7dd7d959 4937 return server->caps & NFS_CAP_ACLS;
aa1870af
BF		 4938}
4939
21f498c2
TM		 4940/* Assuming that XATTR_SIZE_MAX is a multiple of PAGE_SIZE, and that
4941 * it's OK to put sizeof(void) * (XATTR_SIZE_MAX/PAGE_SIZE) bytes on
aa1870af
BF		 4942 * the stack.
4943 */
21f498c2 4944#define NFS4ACL_MAXPAGES DIV_ROUND_UP(XATTR_SIZE_MAX, PAGE_SIZE)
aa1870af 4945
e9e3d724 4946static int buf_to_pages_noslab(const void *buf, size_t buflen,
8fbcf237 4947 struct page **pages)
e9e3d724
NH		 4948{
4949 struct page *newpage, **spages;
4950 int rc = 0;
4951 size_t len;
4952 spages = pages;
4953
4954 do {
21f498c2 4955 len = min_t(size_t, PAGE_SIZE, buflen);
e9e3d724
NH		 4956 newpage = alloc_page(GFP_KERNEL);
4957
4958 if (newpage == NULL)
4959 goto unwind;
4960 memcpy(page_address(newpage), buf, len);
4961 buf += len;
4962 buflen -= len;
4963 *pages++ = newpage;
4964 rc++;
4965 } while (buflen != 0);
4966
4967 return rc;
4968
4969unwind:
4970 for(; rc > 0; rc--)
4971 __free_page(spages[rc-1]);
4972 return -ENOMEM;
4973}
4974
e50a1c2e
BF		 4975struct nfs4_cached_acl {
4976 int cached;
4977 size_t len;
3e9d4154 4978 char data[0];
e50a1c2e
BF		 4979};
4980
4981static void nfs4_set_cached_acl(struct inode *inode, struct nfs4_cached_acl *acl)
4982{
4983 struct nfs_inode *nfsi = NFS_I(inode);
4984
4985 spin_lock(&inode->i_lock);
4986 kfree(nfsi->nfs4_acl);
4987 nfsi->nfs4_acl = acl;
4988 spin_unlock(&inode->i_lock);
4989}
4990
4991static void nfs4_zap_acl_attr(struct inode *inode)
4992{
4993 nfs4_set_cached_acl(inode, NULL);
4994}
4995
4996static inline ssize_t nfs4_read_cached_acl(struct inode *inode, char *buf, size_t buflen)
4997{
4998 struct nfs_inode *nfsi = NFS_I(inode);
4999 struct nfs4_cached_acl *acl;
5000 int ret = -ENOENT;
5001
5002 spin_lock(&inode->i_lock);
5003 acl = nfsi->nfs4_acl;
5004 if (acl == NULL)
5005 goto out;
5006 if (buf == NULL) /* user is just asking for length */
5007 goto out_len;
5008 if (acl->cached == 0)
5009 goto out;
5010 ret = -ERANGE; /* see getxattr(2) man page */
5011 if (acl->len > buflen)
5012 goto out;
5013 memcpy(buf, acl->data, acl->len);
5014out_len:
5015 ret = acl->len;
5016out:
5017 spin_unlock(&inode->i_lock);
5018 return ret;
5019}
5020
5794d21e 5021static void nfs4_write_cached_acl(struct inode *inode, struct page **pages, size_t pgbase, size_t acl_len)
e50a1c2e
BF		 5022{
5023 struct nfs4_cached_acl *acl;
b291f1b1 5024 size_t buflen = sizeof(*acl) + acl_len;
e50a1c2e 5025
1f1ea6c2 5026 if (buflen <= PAGE_SIZE) {
b291f1b1 5027 acl = kmalloc(buflen, GFP_KERNEL);
e50a1c2e
BF		 5028 if (acl == NULL)
5029 goto out;
5030 acl->cached = 1;
5794d21e 5031 _copy_from_pages(acl->data, pages, pgbase, acl_len);
e50a1c2e
BF		 5032 } else {
5033 acl = kmalloc(sizeof(*acl), GFP_KERNEL);
5034 if (acl == NULL)
5035 goto out;
5036 acl->cached = 0;
5037 }
5038 acl->len = acl_len;
5039out:
5040 nfs4_set_cached_acl(inode, acl);
5041}
5042
bf118a34
AA		 5043/*
5044 * The getxattr API returns the required buffer length when called with a
5045 * NULL buf. The NFSv4 acl tool then calls getxattr again after allocating
5046 * the required buf. On a NULL buf, we send a page of data to the server
5047 * guessing that the ACL request can be serviced by a page. If so, we cache
5048 * up to the page of ACL data, and the 2nd call to getxattr is serviced by
5049 * the cache. If not so, we throw away the page, and cache the required
5050 * length. The next getxattr call will then produce another round trip to
5051 * the server, this time with the input buf of the required size.
5052 */
16b4289c 5053static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)
aa1870af 5054{
bf118a34 5055 struct page *pages[NFS4ACL_MAXPAGES] = {NULL, };
aa1870af
BF		 5056 struct nfs_getaclargs args = {
5057 .fh = NFS_FH(inode),
5058 .acl_pages = pages,
5059 .acl_len = buflen,
5060 };
663c79b3
BH		 5061 struct nfs_getaclres res = {
5062 .acl_len = buflen,
5063 };
aa1870af
BF		 5064 struct rpc_message msg = {
5065 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETACL],
5066 .rpc_argp = &args,
663c79b3 5067 .rpc_resp = &res,
aa1870af 5068 };
21f498c2
TM		 5069 unsigned int npages = DIV_ROUND_UP(buflen, PAGE_SIZE);
5070 int ret = -ENOMEM, i;
aa1870af 5071
bf118a34
AA		 5072 /* As long as we're doing a round trip to the server anyway,
5073 * let's be prepared for a page of acl data. */
5074 if (npages == 0)
5075 npages = 1;
21f498c2
TM		 5076 if (npages > ARRAY_SIZE(pages))
5077 return -ERANGE;
5a006899 5078
bf118a34
AA		 5079 for (i = 0; i < npages; i++) {
5080 pages[i] = alloc_page(GFP_KERNEL);
5081 if (!pages[i])
5082 goto out_free;
e50a1c2e 5083 }
5a006899
SP		 5084
5085 /* for decoding across pages */
5086 res.acl_scratch = alloc_page(GFP_KERNEL);
5087 if (!res.acl_scratch)
5088 goto out_free;
5089
bf118a34 5090 args.acl_len = npages * PAGE_SIZE;
5a006899 5091
de040bec 5092 dprintk("%s buf %p buflen %zu npages %d args.acl_len %zu\n",
bf118a34
AA		 5093 __func__, buf, buflen, npages, args.acl_len);
5094 ret = nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode),
5095 &msg, &args.seq_args, &res.seq_res, 0);
e50a1c2e
BF		 5096 if (ret)
5097 goto out_free;
bf118a34 5098
1f1ea6c2
TM		 5099 /* Handle the case where the passed-in buffer is too short */
5100 if (res.acl_flags & NFS4_ACL_TRUNC) {
5101 /* Did the user only issue a request for the acl length? */
5102 if (buf == NULL)
5103 goto out_ok;
e50a1c2e 5104 ret = -ERANGE;
1f1ea6c2 5105 goto out_free;
e50a1c2e 5106 }
1f1ea6c2 5107 nfs4_write_cached_acl(inode, pages, res.acl_data_offset, res.acl_len);
7d3e91a8
SW		 5108 if (buf) {
5109 if (res.acl_len > buflen) {
5110 ret = -ERANGE;
5111 goto out_free;
5112 }
1f1ea6c2 5113 _copy_from_pages(buf, pages, res.acl_data_offset, res.acl_len);
7d3e91a8 5114 }
1f1ea6c2
TM		 5115out_ok:
5116 ret = res.acl_len;
e50a1c2e 5117out_free:
bf118a34
AA		 5118 for (i = 0; i < npages; i++)
5119 if (pages[i])
5120 __free_page(pages[i]);
331818f1
TM		 5121 if (res.acl_scratch)
5122 __free_page(res.acl_scratch);
aa1870af
BF		 5123 return ret;
5124}
5125
16b4289c
TM		 5126static ssize_t nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)
5127{
5128 struct nfs4_exception exception = { };
5129 ssize_t ret;
5130 do {
5131 ret = __nfs4_get_acl_uncached(inode, buf, buflen);
c1578b76 5132 trace_nfs4_get_acl(inode, ret);
16b4289c
TM		 5133 if (ret >= 0)
5134 break;
5135 ret = nfs4_handle_exception(NFS_SERVER(inode), ret, &exception);
5136 } while (exception.retry);
5137 return ret;
5138}
5139
e50a1c2e
BF		 5140static ssize_t nfs4_proc_get_acl(struct inode *inode, void *buf, size_t buflen)
5141{
5142 struct nfs_server *server = NFS_SERVER(inode);
5143 int ret;
5144
5145 if (!nfs4_server_supports_acls(server))
5146 return -EOPNOTSUPP;
5147 ret = nfs_revalidate_inode(server, inode);
5148 if (ret < 0)
5149 return ret;
08a22b39
AK		 5150 if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_ACL)
5151 nfs_zap_acl_cache(inode);
e50a1c2e
BF		 5152 ret = nfs4_read_cached_acl(inode, buf, buflen);
5153 if (ret != -ENOENT)
bf118a34
AA		 5154 /* -ENOENT is returned if there is no ACL or if there is an ACL
5155 * but no cached acl data, just the acl length */
e50a1c2e
BF		 5156 return ret;
5157 return nfs4_get_acl_uncached(inode, buf, buflen);
5158}
5159
16b4289c 5160static int __nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen)
4b580ee3
BF		 5161{
5162 struct nfs_server *server = NFS_SERVER(inode);
5163 struct page *pages[NFS4ACL_MAXPAGES];
5164 struct nfs_setaclargs arg = {
5165 .fh = NFS_FH(inode),
5166 .acl_pages = pages,
5167 .acl_len = buflen,
5168 };
73c403a9 5169 struct nfs_setaclres res;
4b580ee3
BF		 5170 struct rpc_message msg = {
5171 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETACL],
5172 .rpc_argp = &arg,
73c403a9 5173 .rpc_resp = &res,
4b580ee3 5174 };
21f498c2 5175 unsigned int npages = DIV_ROUND_UP(buflen, PAGE_SIZE);
e9e3d724 5176 int ret, i;
4b580ee3
BF		 5177
5178 if (!nfs4_server_supports_acls(server))
5179 return -EOPNOTSUPP;
21f498c2
TM		 5180 if (npages > ARRAY_SIZE(pages))
5181 return -ERANGE;
8fbcf237 5182 i = buf_to_pages_noslab(buf, buflen, arg.acl_pages);
e9e3d724
NH		 5183 if (i < 0)
5184 return i;
57ec14c5 5185 nfs4_inode_return_delegation(inode);
7c513058 5186 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
e9e3d724
NH		 5187
5188 /*
5189 * Free each page after tx, so the only ref left is
5190 * held by the network stack
5191 */
5192 for (; i > 0; i--)
5193 put_page(pages[i-1]);
5194
08a22b39
AK		 5195 /*
5196 * Acl update can result in inode attribute update.
5197 * so mark the attribute cache invalid.
5198 */
5199 spin_lock(&inode->i_lock);
5200 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATTR;
5201 spin_unlock(&inode->i_lock);
f41f7418
TM		 5202 nfs_access_zap_cache(inode);
5203 nfs_zap_acl_cache(inode);
4b580ee3
BF		 5204 return ret;
5205}
5206
16b4289c
TM		 5207static int nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen)
5208{
5209 struct nfs4_exception exception = { };
5210 int err;
5211 do {
c1578b76
TM		 5212 err = __nfs4_proc_set_acl(inode, buf, buflen);
5213 trace_nfs4_set_acl(inode, err);
5214 err = nfs4_handle_exception(NFS_SERVER(inode), err,
16b4289c
TM		 5215 &exception);
5216 } while (exception.retry);
5217 return err;
5218}
5219
aa9c2669
DQ		 5220#ifdef CONFIG_NFS_V4_SECURITY_LABEL
5221static int _nfs4_get_security_label(struct inode *inode, void *buf,
5222 size_t buflen)
5223{
5224 struct nfs_server *server = NFS_SERVER(inode);
5225 struct nfs_fattr fattr;
5226 struct nfs4_label label = {0, 0, buflen, buf};
5227
5228 u32 bitmask[3] = { 0, 0, FATTR4_WORD2_SECURITY_LABEL };
fcb63a9b 5229 struct nfs4_getattr_arg arg = {
aa9c2669
DQ		 5230 .fh = NFS_FH(inode),
5231 .bitmask = bitmask,
5232 };
5233 struct nfs4_getattr_res res = {
5234 .fattr = &fattr,
5235 .label = &label,
5236 .server = server,
5237 };
5238 struct rpc_message msg = {
5239 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETATTR],
fcb63a9b 5240 .rpc_argp = &arg,
aa9c2669
DQ		 5241 .rpc_resp = &res,
5242 };
5243 int ret;
5244
5245 nfs_fattr_init(&fattr);
5246
fcb63a9b 5247 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 0);
aa9c2669
DQ		 5248 if (ret)
5249 return ret;
5250 if (!(fattr.valid & NFS_ATTR_FATTR_V4_SECURITY_LABEL))
5251 return -ENOENT;
5252 if (buflen < label.len)
5253 return -ERANGE;
5254 return 0;
5255}
5256
5257static int nfs4_get_security_label(struct inode *inode, void *buf,
5258 size_t buflen)
5259{
5260 struct nfs4_exception exception = { };
5261 int err;
5262
5263 if (!nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL))
5264 return -EOPNOTSUPP;
5265
5266 do {
c1578b76
TM		 5267 err = _nfs4_get_security_label(inode, buf, buflen);
5268 trace_nfs4_get_security_label(inode, err);
5269 err = nfs4_handle_exception(NFS_SERVER(inode), err,
aa9c2669
DQ		 5270 &exception);
5271 } while (exception.retry);
5272 return err;
5273}
5274
5275static int _nfs4_do_set_security_label(struct inode *inode,
5276 struct nfs4_label *ilabel,
5277 struct nfs_fattr *fattr,
5278 struct nfs4_label *olabel)
5279{
5280
5281 struct iattr sattr = {0};
5282 struct nfs_server *server = NFS_SERVER(inode);
5283 const u32 bitmask[3] = { 0, 0, FATTR4_WORD2_SECURITY_LABEL };
12207f69 5284 struct nfs_setattrargs arg = {
aa9c2669
DQ		 5285 .fh = NFS_FH(inode),
5286 .iap = &sattr,
5287 .server = server,
5288 .bitmask = bitmask,
5289 .label = ilabel,
5290 };
5291 struct nfs_setattrres res = {
5292 .fattr = fattr,
5293 .label = olabel,
5294 .server = server,
5295 };
5296 struct rpc_message msg = {
5297 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETATTR],
12207f69 5298 .rpc_argp = &arg,
aa9c2669
DQ		 5299 .rpc_resp = &res,
5300 };
5301 int status;
5302
12207f69 5303 nfs4_stateid_copy(&arg.stateid, &zero_stateid);
aa9c2669 5304
12207f69 5305 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
aa9c2669
DQ		 5306 if (status)
5307 dprintk("%s failed: %d\n", __func__, status);
5308
5309 return status;
5310}
5311
5312static int nfs4_do_set_security_label(struct inode *inode,
5313 struct nfs4_label *ilabel,
5314 struct nfs_fattr *fattr,
5315 struct nfs4_label *olabel)
5316{
5317 struct nfs4_exception exception = { };
5318 int err;
5319
5320 do {
c1578b76
TM		 5321 err = _nfs4_do_set_security_label(inode, ilabel,
5322 fattr, olabel);
5323 trace_nfs4_set_security_label(inode, err);
5324 err = nfs4_handle_exception(NFS_SERVER(inode), err,
aa9c2669
DQ		 5325 &exception);
5326 } while (exception.retry);
5327 return err;
5328}
5329
5330static int
59301226 5331nfs4_set_security_label(struct inode *inode, const void *buf, size_t buflen)
aa9c2669
DQ		 5332{
5333 struct nfs4_label ilabel, *olabel = NULL;
5334 struct nfs_fattr fattr;
5335 struct rpc_cred *cred;
aa9c2669
DQ		 5336 int status;
5337
5338 if (!nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL))
5339 return -EOPNOTSUPP;
5340
5341 nfs_fattr_init(&fattr);
5342
5343 ilabel.pi = 0;
5344 ilabel.lfs = 0;
5345 ilabel.label = (char *)buf;
5346 ilabel.len = buflen;
5347
5348 cred = rpc_lookup_cred();
5349 if (IS_ERR(cred))
5350 return PTR_ERR(cred);
5351
5352 olabel = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL);
5353 if (IS_ERR(olabel)) {
5354 status = -PTR_ERR(olabel);
5355 goto out;
5356 }
5357
5358 status = nfs4_do_set_security_label(inode, &ilabel, &fattr, olabel);
5359 if (status == 0)
5360 nfs_setsecurity(inode, &fattr, olabel);
5361
5362 nfs4_label_free(olabel);
5363out:
5364 put_rpccred(cred);
5365 return status;
5366}
5367#endif /* CONFIG_NFS_V4_SECURITY_LABEL */
5368
5369
f092075d
CL		 5370static void nfs4_init_boot_verifier(const struct nfs_client *clp,
5371 nfs4_verifier *bootverf)
cd93710e
CL		 5372{
5373 __be32 verf[2];
5374
2c820d9a
CL		 5375 if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) {
5376 /* An impossible timestamp guarantees this value
5377 * will never match a generated boot time. */
2f86e091
DD		 5378 verf[0] = cpu_to_be32(U32_MAX);
5379 verf[1] = cpu_to_be32(U32_MAX);
2c820d9a 5380 } else {
f092075d 5381 struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
2f86e091
DD		 5382 u64 ns = ktime_to_ns(nn->boot_time);
5383
5384 verf[0] = cpu_to_be32(ns >> 32);
5385 verf[1] = cpu_to_be32(ns);
2c820d9a 5386 }
cd93710e
CL		 5387 memcpy(bootverf->data, verf, sizeof(bootverf->data));
5388}
5389
a3192688
JL		 5390static int
5391nfs4_init_nonuniform_client_string(struct nfs_client *clp)
e984a55a 5392{
a3192688
JL		 5393 size_t len;
5394 char *str;
e984a55a 5395
ceb3a16c 5396 if (clp->cl_owner_id != NULL)
a3192688 5397 return 0;
4a3e5779 5398
a3192688 5399 rcu_read_lock();
4a70316c 5400 len = 14 + strlen(clp->cl_ipaddr) + 1 +
a3192688
JL		 5401 strlen(rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR)) +
5402 1 +
5403 strlen(rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_PROTO)) +
5404 1;
5405 rcu_read_unlock();
5406
5407 if (len > NFS4_OPAQUE_LIMIT + 1)
5408 return -EINVAL;
5409
5410 /*
5411 * Since this string is allocated at mount time, and held until the
5412 * nfs_client is destroyed, we can use GFP_KERNEL here w/o worrying
5413 * about a memory-reclaim deadlock.
5414 */
5415 str = kmalloc(len, GFP_KERNEL);
5416 if (!str)
5417 return -ENOMEM;
ceb3a16c 5418
e984a55a 5419 rcu_read_lock();
f2dd436e 5420 scnprintf(str, len, "Linux NFSv4.0 %s/%s %s",
a3192688
JL		 5421 clp->cl_ipaddr,
5422 rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR),
5423 rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_PROTO));
e984a55a 5424 rcu_read_unlock();
a3192688 5425
a3192688
JL		 5426 clp->cl_owner_id = str;
5427 return 0;
e984a55a
CL		 5428}
5429
873e3851
JL		 5430static int
5431nfs4_init_uniquifier_client_string(struct nfs_client *clp)
5432{
873e3851
JL		 5433 size_t len;
5434 char *str;
5435
5436 len = 10 + 10 + 1 + 10 + 1 +
5437 strlen(nfs4_client_id_uniquifier) + 1 +
5438 strlen(clp->cl_rpcclient->cl_nodename) + 1;
5439
5440 if (len > NFS4_OPAQUE_LIMIT + 1)
5441 return -EINVAL;
5442
5443 /*
5444 * Since this string is allocated at mount time, and held until the
5445 * nfs_client is destroyed, we can use GFP_KERNEL here w/o worrying
5446 * about a memory-reclaim deadlock.
5447 */
5448 str = kmalloc(len, GFP_KERNEL);
5449 if (!str)
5450 return -ENOMEM;
5451
f2dd436e 5452 scnprintf(str, len, "Linux NFSv%u.%u %s/%s",
873e3851
JL		 5453 clp->rpc_ops->version, clp->cl_minorversion,
5454 nfs4_client_id_uniquifier,
5455 clp->cl_rpcclient->cl_nodename);
873e3851
JL		 5456 clp->cl_owner_id = str;
5457 return 0;
5458}
5459
5460static int
5461nfs4_init_uniform_client_string(struct nfs_client *clp)
e984a55a 5462{
873e3851
JL		 5463 size_t len;
5464 char *str;
ceb3a16c
TM		 5465
5466 if (clp->cl_owner_id != NULL)
873e3851 5467 return 0;
6f2ea7f2
CL		 5468
5469 if (nfs4_client_id_uniquifier[0] != '\0')
873e3851
JL		 5470 return nfs4_init_uniquifier_client_string(clp);
5471
5472 len = 10 + 10 + 1 + 10 + 1 +
5473 strlen(clp->cl_rpcclient->cl_nodename) + 1;
5474
5475 if (len > NFS4_OPAQUE_LIMIT + 1)
5476 return -EINVAL;
5477
5478 /*
5479 * Since this string is allocated at mount time, and held until the
5480 * nfs_client is destroyed, we can use GFP_KERNEL here w/o worrying
5481 * about a memory-reclaim deadlock.
5482 */
5483 str = kmalloc(len, GFP_KERNEL);
5484 if (!str)
5485 return -ENOMEM;
5486
f2dd436e 5487 scnprintf(str, len, "Linux NFSv%u.%u %s",
873e3851
JL		 5488 clp->rpc_ops->version, clp->cl_minorversion,
5489 clp->cl_rpcclient->cl_nodename);
873e3851
JL		 5490 clp->cl_owner_id = str;
5491 return 0;
e984a55a
CL		 5492}
5493
706cb8db
CL		 5494/*
5495 * nfs4_callback_up_net() starts only "tcp" and "tcp6" callback
5496 * services. Advertise one based on the address family of the
5497 * clientaddr.
5498 */
5499static unsigned int
5500nfs4_init_callback_netid(const struct nfs_client *clp, char *buf, size_t len)
5501{
5502 if (strchr(clp->cl_ipaddr, ':') != NULL)
5503 return scnprintf(buf, len, "tcp6");
5504 else
5505 return scnprintf(buf, len, "tcp");
5506}
5507
f11b2a1c
JL		 5508static void nfs4_setclientid_done(struct rpc_task *task, void *calldata)
5509{
5510 struct nfs4_setclientid *sc = calldata;
5511
5512 if (task->tk_status == 0)
5513 sc->sc_cred = get_rpccred(task->tk_rqstp->rq_cred);
5514}
5515
5516static const struct rpc_call_ops nfs4_setclientid_ops = {
5517 .rpc_call_done = nfs4_setclientid_done,
5518};
5519
6bbb4ae8
CL		 5520/**
5521 * nfs4_proc_setclientid - Negotiate client ID
5522 * @clp: state data structure
5523 * @program: RPC program for NFSv4 callback service
5524 * @port: IP port number for NFS4 callback service
5525 * @cred: RPC credential to use for this call
5526 * @res: where to place the result
5527 *
5528 * Returns zero, a negative errno, or a negative NFS4ERR status code.
5529 */
bb8b27e5
TM		 5530int nfs4_proc_setclientid(struct nfs_client *clp, u32 program,
5531 unsigned short port, struct rpc_cred *cred,
5532 struct nfs4_setclientid_res *res)
1da177e4
LT		 5533{
5534 nfs4_verifier sc_verifier;
5535 struct nfs4_setclientid setclientid = {
5536 .sc_verifier = &sc_verifier,
5537 .sc_prog = program,
3a6bb738 5538 .sc_clnt = clp,
1da177e4
LT		 5539 };
5540 struct rpc_message msg = {
5541 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID],
5542 .rpc_argp = &setclientid,
bb8b27e5 5543 .rpc_resp = res,
286d7d6a 5544 .rpc_cred = cred,
1da177e4 5545 };
f11b2a1c
JL		 5546 struct rpc_task *task;
5547 struct rpc_task_setup task_setup_data = {
5548 .rpc_client = clp->cl_rpcclient,
5549 .rpc_message = &msg,
5550 .callback_ops = &nfs4_setclientid_ops,
5551 .callback_data = &setclientid,
5552 .flags = RPC_TASK_TIMEOUT,
5553 };
6bbb4ae8 5554 int status;
1da177e4 5555
de734831 5556 /* nfs_client_id4 */
f092075d 5557 nfs4_init_boot_verifier(clp, &sc_verifier);
873e3851
JL		 5558
5559 if (test_bit(NFS_CS_MIGRATION, &clp->cl_flags))
5560 status = nfs4_init_uniform_client_string(clp);
5561 else
a3192688 5562 status = nfs4_init_nonuniform_client_string(clp);
873e3851
JL		 5563
5564 if (status)
5565 goto out;
3a6bb738 5566
de734831 5567 /* cb_client4 */
706cb8db
CL		 5568 setclientid.sc_netid_len =
5569 nfs4_init_callback_netid(clp,
5570 setclientid.sc_netid,
5571 sizeof(setclientid.sc_netid));
de734831 5572 setclientid.sc_uaddr_len = scnprintf(setclientid.sc_uaddr,
d4d3c507 5573 sizeof(setclientid.sc_uaddr), "%s.%u.%u",
1da177e4
LT		 5574 clp->cl_ipaddr, port >> 8, port & 255);
5575
3a6bb738 5576 dprintk("NFS call setclientid auth=%s, '%s'\n",
6bbb4ae8 5577 clp->cl_rpcclient->cl_auth->au_ops->au_name,
3a6bb738 5578 clp->cl_owner_id);
f11b2a1c
JL		 5579 task = rpc_run_task(&task_setup_data);
5580 if (IS_ERR(task)) {
5581 status = PTR_ERR(task);
5582 goto out;
5583 }
5584 status = task->tk_status;
5585 if (setclientid.sc_cred) {
5586 clp->cl_acceptor = rpcauth_stringify_acceptor(setclientid.sc_cred);
5587 put_rpccred(setclientid.sc_cred);
5588 }
5589 rpc_put_task(task);
5590out:
c6d01c6f 5591 trace_nfs4_setclientid(clp, status);
6bbb4ae8
CL		 5592 dprintk("NFS reply setclientid: %d\n", status);
5593 return status;
1da177e4
LT		 5594}
5595
6bbb4ae8
CL		 5596/**
5597 * nfs4_proc_setclientid_confirm - Confirm client ID
5598 * @clp: state data structure
5599 * @res: result of a previous SETCLIENTID
5600 * @cred: RPC credential to use for this call
5601 *
5602 * Returns zero, a negative errno, or a negative NFS4ERR status code.
5603 */
fd954ae1 5604int nfs4_proc_setclientid_confirm(struct nfs_client *clp,
bb8b27e5
TM		 5605 struct nfs4_setclientid_res *arg,
5606 struct rpc_cred *cred)
1da177e4 5607{
1da177e4
LT		 5608 struct rpc_message msg = {
5609 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID_CONFIRM],
bb8b27e5 5610 .rpc_argp = arg,
286d7d6a 5611 .rpc_cred = cred,
1da177e4 5612 };
1da177e4
LT		 5613 int status;
5614
6bbb4ae8
CL		 5615 dprintk("NFS call setclientid_confirm auth=%s, (client ID %llx)\n",
5616 clp->cl_rpcclient->cl_auth->au_ops->au_name,
5617 clp->cl_clientid);
1bd714f2 5618 status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
c6d01c6f 5619 trace_nfs4_setclientid_confirm(clp, status);
6bbb4ae8 5620 dprintk("NFS reply setclientid_confirm: %d\n", status);
1da177e4
LT		 5621 return status;
5622}
5623
fe650407
TM		 5624struct nfs4_delegreturndata {
5625 struct nfs4_delegreturnargs args;
fa178f29 5626 struct nfs4_delegreturnres res;
fe650407
TM		 5627 struct nfs_fh fh;
5628 nfs4_stateid stateid;
26e976a8 5629 unsigned long timestamp;
586f1c39
TM		 5630 struct {
5631 struct nfs4_layoutreturn_args arg;
5632 struct nfs4_layoutreturn_res res;
4d796d75 5633 struct nfs4_xdr_opaque_data ld_private;
586f1c39
TM		 5634 u32 roc_barrier;
5635 bool roc;
5636 } lr;
fa178f29 5637 struct nfs_fattr fattr;
fe650407 5638 int rpc_status;
039b756a 5639 struct inode *inode;
fe650407
TM		 5640};
5641
fe650407
TM		 5642static void nfs4_delegreturn_done(struct rpc_task *task, void *calldata)
5643{
5644 struct nfs4_delegreturndata *data = calldata;
938e1010 5645
14516c3a
TM		 5646 if (!nfs4_sequence_done(task, &data->res.seq_res))
5647 return;
938e1010 5648
ca8acf8d 5649 trace_nfs4_delegreturn_exit(&data->args, &data->res, task->tk_status);
586f1c39
TM		 5650
5651 /* Handle Layoutreturn errors */
5652 if (data->args.lr_args && task->tk_status != 0) {
5653 switch(data->res.lr_ret) {
5654 default:
5655 data->res.lr_ret = -NFS4ERR_NOMATCHING_LAYOUT;
5656 break;
5657 case 0:
5658 data->args.lr_args = NULL;
5659 data->res.lr_res = NULL;
5660 break;
5661 case -NFS4ERR_ADMIN_REVOKED:
5662 case -NFS4ERR_DELEG_REVOKED:
5663 case -NFS4ERR_EXPIRED:
5664 case -NFS4ERR_BAD_STATEID:
5665 case -NFS4ERR_OLD_STATEID:
5666 case -NFS4ERR_UNKNOWN_LAYOUTTYPE:
5667 case -NFS4ERR_WRONG_CRED:
5668 data->args.lr_args = NULL;
5669 data->res.lr_res = NULL;
5670 data->res.lr_ret = 0;
5671 rpc_restart_call_prepare(task);
5672 return;
5673 }
5674 }
5675
79708861 5676 switch (task->tk_status) {
79708861 5677 case 0:
fa178f29 5678 renew_lease(data->res.server, data->timestamp);
23ea44c2 5679 break;
c97cf606
TM		 5680 case -NFS4ERR_ADMIN_REVOKED:
5681 case -NFS4ERR_DELEG_REVOKED:
26d36301
TM		 5682 case -NFS4ERR_EXPIRED:
5683 nfs4_free_revoked_stateid(data->res.server,
5684 data->args.stateid,
5685 task->tk_msg.rpc_cred);
c97cf606
TM		 5686 case -NFS4ERR_BAD_STATEID:
5687 case -NFS4ERR_OLD_STATEID:
5688 case -NFS4ERR_STALE_STATEID:
c97cf606
TM		 5689 task->tk_status = 0;
5690 break;
8ac2b422
TM		 5691 case -NFS4ERR_ACCESS:
5692 if (data->args.bitmask) {
5693 data->args.bitmask = NULL;
5694 data->res.fattr = NULL;
5695 task->tk_status = 0;
5696 rpc_restart_call_prepare(task);
5697 return;
5698 }
79708861 5699 default:
8478eaa1
N		 5700 if (nfs4_async_handle_error(task, data->res.server,
5701 NULL, NULL) == -EAGAIN) {
d00c5d43 5702 rpc_restart_call_prepare(task);
79708861
RL		 5703 return;
5704 }
5705 }
5706 data->rpc_status = task->tk_status;
fe650407
TM		 5707}
5708
5709static void nfs4_delegreturn_release(void *calldata)
5710{
039b756a 5711 struct nfs4_delegreturndata *data = calldata;
ea7c38fe 5712 struct inode *inode = data->inode;
039b756a 5713
ea7c38fe 5714 if (inode) {
586f1c39 5715 if (data->lr.roc)
1c5bd76d
TM		 5716 pnfs_roc_release(&data->lr.arg, &data->lr.res,
5717 data->res.lr_ret);
0bc2c9b4 5718 nfs_post_op_update_inode_force_wcc(inode, &data->fattr);
ea7c38fe
TM		 5719 nfs_iput_and_deactive(inode);
5720 }
fe650407
TM		 5721 kfree(calldata);
5722}
5723
938e1010
AA		 5724static void nfs4_delegreturn_prepare(struct rpc_task *task, void *data)
5725{
5726 struct nfs4_delegreturndata *d_data;
5727
5728 d_data = (struct nfs4_delegreturndata *)data;
5729
1c5bd76d 5730 if (!d_data->lr.roc && nfs4_wait_on_layoutreturn(d_data->inode, task))
500d701f
PT		 5731 return;
5732
42e1cca7 5733 nfs4_setup_sequence(d_data->res.server->nfs_client,
d9afbd1b
TM		 5734 &d_data->args.seq_args,
5735 &d_data->res.seq_res,
5736 task);
938e1010 5737}
938e1010 5738
c8d149f3 5739static const struct rpc_call_ops nfs4_delegreturn_ops = {
938e1010 5740 .rpc_call_prepare = nfs4_delegreturn_prepare,
fe650407
TM		 5741 .rpc_call_done = nfs4_delegreturn_done,
5742 .rpc_release = nfs4_delegreturn_release,
5743};
5744
e6f81075 5745static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync)
fe650407
TM		 5746{
5747 struct nfs4_delegreturndata *data;
fa178f29 5748 struct nfs_server *server = NFS_SERVER(inode);
fe650407 5749 struct rpc_task *task;
5138fde0
TM		 5750 struct rpc_message msg = {
5751 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DELEGRETURN],
5752 .rpc_cred = cred,
5753 };
c970aa85
TM		 5754 struct rpc_task_setup task_setup_data = {
5755 .rpc_client = server->client,
5138fde0 5756 .rpc_message = &msg,
c970aa85
TM		 5757 .callback_ops = &nfs4_delegreturn_ops,
5758 .flags = RPC_TASK_ASYNC,
5759 };
e6f81075 5760 int status = 0;
fe650407 5761
8535b2be 5762 data = kzalloc(sizeof(*data), GFP_NOFS);
fe650407
TM		 5763 if (data == NULL)
5764 return -ENOMEM;
a9c92d6b 5765 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
99ade3c7
AE		 5766
5767 nfs4_state_protect(server->nfs_client,
5768 NFS_SP4_MACH_CRED_CLEANUP,
5769 &task_setup_data.rpc_client, &msg);
5770
fe650407
TM		 5771 data->args.fhandle = &data->fh;
5772 data->args.stateid = &data->stateid;
9e907fec 5773 data->args.bitmask = server->cache_consistency_bitmask;
fe650407 5774 nfs_copy_fh(&data->fh, NFS_FH(inode));
f597c537 5775 nfs4_stateid_copy(&data->stateid, stateid);
fa178f29
TM		 5776 data->res.fattr = &data->fattr;
5777 data->res.server = server;
586f1c39 5778 data->res.lr_ret = -NFS4ERR_NOMATCHING_LAYOUT;
4d796d75 5779 data->lr.arg.ld_private = &data->lr.ld_private;
5138fde0 5780 nfs_fattr_init(data->res.fattr);
26e976a8 5781 data->timestamp = jiffies;
fe650407 5782 data->rpc_status = 0;
53e6fc86 5783 data->lr.roc = pnfs_roc(inode, &data->lr.arg, &data->lr.res, cred);
ea7c38fe 5784 data->inode = nfs_igrab_and_active(inode);
1c5bd76d 5785 if (data->inode) {
1c5bd76d
TM		 5786 if (data->lr.roc) {
5787 data->args.lr_args = &data->lr.arg;
5788 data->res.lr_res = &data->lr.res;
5789 }
53e6fc86
TM		 5790 } else if (data->lr.roc) {
5791 pnfs_roc_release(&data->lr.arg, &data->lr.res, 0);
5792 data->lr.roc = false;
1c5bd76d 5793 }
fe650407 5794
c970aa85 5795 task_setup_data.callback_data = data;
1174dd1f
TM		 5796 msg.rpc_argp = &data->args;
5797 msg.rpc_resp = &data->res;
c970aa85 5798 task = rpc_run_task(&task_setup_data);
7a1218a2 5799 if (IS_ERR(task))
fe650407 5800 return PTR_ERR(task);
e6f81075
TM		 5801 if (!issync)
5802 goto out;
fe650407 5803 status = nfs4_wait_for_completion_rpc_task(task);
e6f81075
TM		 5804 if (status != 0)
5805 goto out;
5806 status = data->rpc_status;
e6f81075 5807out:
e6b3c4db 5808 rpc_put_task(task);
fe650407 5809 return status;
1da177e4
LT		 5810}
5811
e6f81075 5812int nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync)
1da177e4
LT		 5813{
5814 struct nfs_server *server = NFS_SERVER(inode);
5815 struct nfs4_exception exception = { };
5816 int err;
5817 do {
e6f81075 5818 err = _nfs4_proc_delegreturn(inode, cred, stateid, issync);
48c9579a 5819 trace_nfs4_delegreturn(inode, stateid, err);
1da177e4
LT		 5820 switch (err) {
5821 case -NFS4ERR_STALE_STATEID:
5822 case -NFS4ERR_EXPIRED:
1da177e4
LT		 5823 case 0:
5824 return 0;
5825 }
5826 err = nfs4_handle_exception(server, err, &exception);
5827 } while (exception.retry);
5828 return err;
5829}
5830
1da177e4
LT		 5831static int _nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)
5832{
5833 struct inode *inode = state->inode;
5834 struct nfs_server *server = NFS_SERVER(inode);
7539bbab 5835 struct nfs_client *clp = server->nfs_client;
911d1aaf 5836 struct nfs_lockt_args arg = {
1da177e4 5837 .fh = NFS_FH(inode),
911d1aaf 5838 .fl = request,
1da177e4 5839 };
911d1aaf
TM		 5840 struct nfs_lockt_res res = {
5841 .denied = request,
1da177e4
LT		 5842 };
5843 struct rpc_message msg = {
5844 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKT],
5845 .rpc_argp = &arg,
5846 .rpc_resp = &res,
5847 .rpc_cred = state->owner->so_cred,
5848 };
1da177e4
LT		 5849 struct nfs4_lock_state *lsp;
5850 int status;
5851
911d1aaf 5852 arg.lock_owner.clientid = clp->cl_clientid;
8d0a8a9d
TM		 5853 status = nfs4_set_lock_state(state, request);
5854 if (status != 0)
5855 goto out;
5856 lsp = request->fl_u.nfs4_fl.owner;
48c22eb2 5857 arg.lock_owner.id = lsp->ls_seqid.owner_id;
d035c36c 5858 arg.lock_owner.s_dev = server->s_dev;
7c513058 5859 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
911d1aaf
TM		 5860 switch (status) {
5861 case 0:
5862 request->fl_type = F_UNLCK;
5863 break;
5864 case -NFS4ERR_DENIED:
5865 status = 0;
1da177e4 5866 }
70cc6487 5867 request->fl_ops->fl_release_private(request);
a6f951dd 5868 request->fl_ops = NULL;
8d0a8a9d 5869out:
1da177e4
LT		 5870 return status;
5871}
5872
5873static int nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)
5874{
5875 struct nfs4_exception exception = { };
5876 int err;
5877
5878 do {
d1b748a5
TM		 5879 err = _nfs4_proc_getlk(state, cmd, request);
5880 trace_nfs4_get_lock(request, state, cmd, err);
5881 err = nfs4_handle_exception(NFS_SERVER(state->inode), err,
1da177e4
LT		 5882 &exception);
5883 } while (exception.retry);
5884 return err;
5885}
5886
faf5f49c 5887struct nfs4_unlockdata {
911d1aaf
TM		 5888 struct nfs_locku_args arg;
5889 struct nfs_locku_res res;
faf5f49c
TM		 5890 struct nfs4_lock_state *lsp;
5891 struct nfs_open_context *ctx;
911d1aaf 5892 struct file_lock fl;
516285eb 5893 struct nfs_server *server;
26e976a8 5894 unsigned long timestamp;
faf5f49c
TM		 5895};
5896
911d1aaf
TM		 5897static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl,
5898 struct nfs_open_context *ctx,
5899 struct nfs4_lock_state *lsp,
5900 struct nfs_seqid *seqid)
5901{
5902 struct nfs4_unlockdata *p;
5903 struct inode *inode = lsp->ls_state->inode;
5904
8535b2be 5905 p = kzalloc(sizeof(*p), GFP_NOFS);
911d1aaf
TM		 5906 if (p == NULL)
5907 return NULL;
5908 p->arg.fh = NFS_FH(inode);
5909 p->arg.fl = &p->fl;
5910 p->arg.seqid = seqid;
c1d51931 5911 p->res.seqid = seqid;
911d1aaf
TM		 5912 p->lsp = lsp;
5913 atomic_inc(&lsp->ls_count);
5914 /* Ensure we don't close file until we're done freeing locks! */
5915 p->ctx = get_nfs_open_context(ctx);
5916 memcpy(&p->fl, fl, sizeof(p->fl));
5917 p->server = NFS_SERVER(inode);
5918 return p;
5919}
5920
06f814a3 5921static void nfs4_locku_release_calldata(void *data)
faf5f49c 5922{
963d8fe5 5923 struct nfs4_unlockdata *calldata = data;
911d1aaf 5924 nfs_free_seqid(calldata->arg.seqid);
06f814a3
TM		 5925 nfs4_put_lock_state(calldata->lsp);
5926 put_nfs_open_context(calldata->ctx);
5927 kfree(calldata);
faf5f49c
TM		 5928}
5929
963d8fe5 5930static void nfs4_locku_done(struct rpc_task *task, void *data)
faf5f49c 5931{
963d8fe5 5932 struct nfs4_unlockdata *calldata = data;
faf5f49c 5933
14516c3a
TM		 5934 if (!nfs4_sequence_done(task, &calldata->res.seq_res))
5935 return;
faf5f49c
TM		 5936 switch (task->tk_status) {
5937 case 0:
26e976a8 5938 renew_lease(calldata->server, calldata->timestamp);
75575ddf 5939 locks_lock_inode_wait(calldata->lsp->ls_state->inode, &calldata->fl);
c69899a1
TM		 5940 if (nfs4_update_lock_stateid(calldata->lsp,
5941 &calldata->res.stateid))
5942 break;
26d36301
TM		 5943 case -NFS4ERR_ADMIN_REVOKED:
5944 case -NFS4ERR_EXPIRED:
5945 nfs4_free_revoked_stateid(calldata->server,
5946 &calldata->arg.stateid,
5947 task->tk_msg.rpc_cred);
9e33bed5
TM		 5948 case -NFS4ERR_BAD_STATEID:
5949 case -NFS4ERR_OLD_STATEID:
faf5f49c 5950 case -NFS4ERR_STALE_STATEID:
425c1d4e
TM		 5951 if (!nfs4_stateid_match(&calldata->arg.stateid,
5952 &calldata->lsp->ls_stateid))
5953 rpc_restart_call_prepare(task);
faf5f49c
TM		 5954 break;
5955 default:
8478eaa1
N		 5956 if (nfs4_async_handle_error(task, calldata->server,
5957 NULL, NULL) == -EAGAIN)
d00c5d43 5958 rpc_restart_call_prepare(task);
faf5f49c 5959 }
2b1bc308 5960 nfs_release_seqid(calldata->arg.seqid);
faf5f49c
TM		 5961}
5962
4ce70ada 5963static void nfs4_locku_prepare(struct rpc_task *task, void *data)
faf5f49c 5964{
4ce70ada 5965 struct nfs4_unlockdata *calldata = data;
faf5f49c 5966
911d1aaf 5967 if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
c8da19b9 5968 goto out_wait;
425c1d4e 5969 nfs4_stateid_copy(&calldata->arg.stateid, &calldata->lsp->ls_stateid);
795a88c9 5970 if (test_bit(NFS_LOCK_INITIALIZED, &calldata->lsp->ls_flags) == 0) {
963d8fe5 5971 /* Note: exit _without_ running nfs4_locku_done */
c8da19b9 5972 goto out_no_action;
faf5f49c 5973 }
26e976a8 5974 calldata->timestamp = jiffies;
42e1cca7 5975 if (nfs4_setup_sequence(calldata->server->nfs_client,
a893693c 5976 &calldata->arg.seq_args,
2240a9e2
TM		 5977 &calldata->res.seq_res,
5978 task) != 0)
5979 nfs_release_seqid(calldata->arg.seqid);
c8da19b9
TM		 5980 return;
5981out_no_action:
5982 task->tk_action = NULL;
5983out_wait:
5984 nfs4_sequence_done(task, &calldata->res.seq_res);
faf5f49c
TM		 5985}
5986
963d8fe5 5987static const struct rpc_call_ops nfs4_locku_ops = {
4ce70ada 5988 .rpc_call_prepare = nfs4_locku_prepare,
963d8fe5 5989 .rpc_call_done = nfs4_locku_done,
06f814a3 5990 .rpc_release = nfs4_locku_release_calldata,
963d8fe5
TM		 5991};
5992
a5d16a4d
TM		 5993static struct rpc_task *nfs4_do_unlck(struct file_lock *fl,
5994 struct nfs_open_context *ctx,
5995 struct nfs4_lock_state *lsp,
5996 struct nfs_seqid *seqid)
5997{
5998 struct nfs4_unlockdata *data;
5138fde0
TM		 5999 struct rpc_message msg = {
6000 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKU],
6001 .rpc_cred = ctx->cred,
6002 };
c970aa85
TM		 6003 struct rpc_task_setup task_setup_data = {
6004 .rpc_client = NFS_CLIENT(lsp->ls_state->inode),
5138fde0 6005 .rpc_message = &msg,
c970aa85 6006 .callback_ops = &nfs4_locku_ops,
101070ca 6007 .workqueue = nfsiod_workqueue,
c970aa85
TM		 6008 .flags = RPC_TASK_ASYNC,
6009 };
a5d16a4d 6010
fa940720
WAA		 6011 nfs4_state_protect(NFS_SERVER(lsp->ls_state->inode)->nfs_client,
6012 NFS_SP4_MACH_CRED_CLEANUP, &task_setup_data.rpc_client, &msg);
6013
137d6aca
FF		 6014 /* Ensure this is an unlock - when canceling a lock, the
6015 * canceled lock is passed in, and it won't be an unlock.
6016 */
6017 fl->fl_type = F_UNLCK;
6018
a5d16a4d
TM		 6019 data = nfs4_alloc_unlockdata(fl, ctx, lsp, seqid);
6020 if (data == NULL) {
6021 nfs_free_seqid(seqid);
6022 return ERR_PTR(-ENOMEM);
6023 }
6024
a9c92d6b 6025 nfs4_init_sequence(&data->arg.seq_args, &data->res.seq_res, 1);
1174dd1f
TM		 6026 msg.rpc_argp = &data->arg;
6027 msg.rpc_resp = &data->res;
c970aa85
TM		 6028 task_setup_data.callback_data = data;
6029 return rpc_run_task(&task_setup_data);
a5d16a4d
TM		 6030}
6031
faf5f49c
TM		 6032static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock *request)
6033{
65b62a29
TM		 6034 struct inode *inode = state->inode;
6035 struct nfs4_state_owner *sp = state->owner;
6036 struct nfs_inode *nfsi = NFS_I(inode);
911d1aaf 6037 struct nfs_seqid *seqid;
1da177e4 6038 struct nfs4_lock_state *lsp;
06f814a3 6039 struct rpc_task *task;
b4019c0e 6040 struct nfs_seqid *(*alloc_seqid)(struct nfs_seqid_counter *, gfp_t);
06f814a3 6041 int status = 0;
536ff0f8 6042 unsigned char fl_flags = request->fl_flags;
faf5f49c 6043
8d0a8a9d 6044 status = nfs4_set_lock_state(state, request);
9b073574
TM		 6045 /* Unlock _before_ we do the RPC call */
6046 request->fl_flags |= FL_EXISTS;
65b62a29
TM		 6047 /* Exclude nfs_delegation_claim_locks() */
6048 mutex_lock(&sp->so_delegreturn_mutex);
6049 /* Exclude nfs4_reclaim_open_stateid() - note nesting! */
19e03c57 6050 down_read(&nfsi->rwsem);
75575ddf 6051 if (locks_lock_inode_wait(inode, request) == -ENOENT) {
19e03c57 6052 up_read(&nfsi->rwsem);
65b62a29 6053 mutex_unlock(&sp->so_delegreturn_mutex);
9b073574 6054 goto out;
19e03c57
TM		 6055 }
6056 up_read(&nfsi->rwsem);
65b62a29 6057 mutex_unlock(&sp->so_delegreturn_mutex);
8d0a8a9d 6058 if (status != 0)
9b073574
TM		 6059 goto out;
6060 /* Is this a delegated lock? */
8d0a8a9d 6061 lsp = request->fl_u.nfs4_fl.owner;
c5a2a15f
TM		 6062 if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) == 0)
6063 goto out;
b4019c0e
TM		 6064 alloc_seqid = NFS_SERVER(inode)->nfs_client->cl_mvops->alloc_seqid;
6065 seqid = alloc_seqid(&lsp->ls_seqid, GFP_KERNEL);
9b073574 6066 status = -ENOMEM;
badc76dd 6067 if (IS_ERR(seqid))
9b073574 6068 goto out;
cd3758e3 6069 task = nfs4_do_unlck(request, nfs_file_open_context(request->fl_file), lsp, seqid);
a5d16a4d
TM		 6070 status = PTR_ERR(task);
6071 if (IS_ERR(task))
9b073574 6072 goto out;
a5d16a4d 6073 status = nfs4_wait_for_completion_rpc_task(task);
e6b3c4db 6074 rpc_put_task(task);
9b073574 6075out:
536ff0f8 6076 request->fl_flags = fl_flags;
d1b748a5 6077 trace_nfs4_unlock(request, state, F_SETLK, status);
1da177e4
LT		 6078 return status;
6079}
6080
a5d16a4d
TM		 6081struct nfs4_lockdata {
6082 struct nfs_lock_args arg;
6083 struct nfs_lock_res res;
6084 struct nfs4_lock_state *lsp;
6085 struct nfs_open_context *ctx;
6086 struct file_lock fl;
26e976a8 6087 unsigned long timestamp;
a5d16a4d
TM		 6088 int rpc_status;
6089 int cancelled;
66179efe 6090 struct nfs_server *server;
a5d16a4d
TM		 6091};
6092
6093static struct nfs4_lockdata *nfs4_alloc_lockdata(struct file_lock *fl,
8535b2be
TM		 6094 struct nfs_open_context *ctx, struct nfs4_lock_state *lsp,
6095 gfp_t gfp_mask)
1da177e4 6096{
a5d16a4d
TM		 6097 struct nfs4_lockdata *p;
6098 struct inode *inode = lsp->ls_state->inode;
1da177e4 6099 struct nfs_server *server = NFS_SERVER(inode);
b4019c0e 6100 struct nfs_seqid *(*alloc_seqid)(struct nfs_seqid_counter *, gfp_t);
a5d16a4d 6101
8535b2be 6102 p = kzalloc(sizeof(*p), gfp_mask);
a5d16a4d
TM		 6103 if (p == NULL)
6104 return NULL;
6105
6106 p->arg.fh = NFS_FH(inode);
6107 p->arg.fl = &p->fl;
8535b2be 6108 p->arg.open_seqid = nfs_alloc_seqid(&lsp->ls_state->owner->so_seqid, gfp_mask);
badc76dd 6109 if (IS_ERR(p->arg.open_seqid))
2f74c0a0 6110 goto out_free;
b4019c0e
TM		 6111 alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid;
6112 p->arg.lock_seqid = alloc_seqid(&lsp->ls_seqid, gfp_mask);
badc76dd 6113 if (IS_ERR(p->arg.lock_seqid))
2f74c0a0 6114 goto out_free_seqid;
7539bbab 6115 p->arg.lock_owner.clientid = server->nfs_client->cl_clientid;
48c22eb2 6116 p->arg.lock_owner.id = lsp->ls_seqid.owner_id;
d035c36c 6117 p->arg.lock_owner.s_dev = server->s_dev;
c1d51931 6118 p->res.lock_seqid = p->arg.lock_seqid;
a5d16a4d 6119 p->lsp = lsp;
66179efe 6120 p->server = server;
a5d16a4d
TM		 6121 atomic_inc(&lsp->ls_count);
6122 p->ctx = get_nfs_open_context(ctx);
6123 memcpy(&p->fl, fl, sizeof(p->fl));
6124 return p;
2f74c0a0
TM		 6125out_free_seqid:
6126 nfs_free_seqid(p->arg.open_seqid);
a5d16a4d
TM		 6127out_free:
6128 kfree(p);
6129 return NULL;
6130}
6131
6132static void nfs4_lock_prepare(struct rpc_task *task, void *calldata)
6133{
6134 struct nfs4_lockdata *data = calldata;
6135 struct nfs4_state *state = data->lsp->ls_state;
06735b34 6136
3110ff80 6137 dprintk("%s: begin!\n", __func__);
2f74c0a0 6138 if (nfs_wait_on_sequence(data->arg.lock_seqid, task) != 0)
c8da19b9 6139 goto out_wait;
a5d16a4d 6140 /* Do we need to do an open_to_lock_owner? */
6b447539 6141 if (!test_bit(NFS_LOCK_INITIALIZED, &data->lsp->ls_flags)) {
8fe72bac 6142 if (nfs_wait_on_sequence(data->arg.open_seqid, task) != 0) {
2240a9e2 6143 goto out_release_lock_seqid;
8fe72bac 6144 }
425c1d4e
TM		 6145 nfs4_stateid_copy(&data->arg.open_stateid,
6146 &state->open_stateid);
a5d16a4d 6147 data->arg.new_lock_owner = 1;
c1d51931 6148 data->res.open_seqid = data->arg.open_seqid;
425c1d4e 6149 } else {
2f74c0a0 6150 data->arg.new_lock_owner = 0;
425c1d4e
TM		 6151 nfs4_stateid_copy(&data->arg.lock_stateid,
6152 &data->lsp->ls_stateid);
6153 }
5d422301
TM		 6154 if (!nfs4_valid_open_stateid(state)) {
6155 data->rpc_status = -EBADF;
6156 task->tk_action = NULL;
6157 goto out_release_open_seqid;
6158 }
26e976a8 6159 data->timestamp = jiffies;
42e1cca7 6160 if (nfs4_setup_sequence(data->server->nfs_client,
035168ab 6161 &data->arg.seq_args,
2240a9e2 6162 &data->res.seq_res,
d9afbd1b 6163 task) == 0)
66179efe 6164 return;
5d422301 6165out_release_open_seqid:
2240a9e2
TM		 6166 nfs_release_seqid(data->arg.open_seqid);
6167out_release_lock_seqid:
6168 nfs_release_seqid(data->arg.lock_seqid);
c8da19b9
TM		 6169out_wait:
6170 nfs4_sequence_done(task, &data->res.seq_res);
8fe72bac 6171 dprintk("%s: done!, ret = %d\n", __func__, data->rpc_status);
b257957e
AB		 6172}
6173
a5d16a4d
TM		 6174static void nfs4_lock_done(struct rpc_task *task, void *calldata)
6175{
6176 struct nfs4_lockdata *data = calldata;
39071e6f 6177 struct nfs4_lock_state *lsp = data->lsp;
a5d16a4d 6178
3110ff80 6179 dprintk("%s: begin!\n", __func__);
a5d16a4d 6180
14516c3a
TM		 6181 if (!nfs4_sequence_done(task, &data->res.seq_res))
6182 return;
66179efe 6183
a5d16a4d 6184 data->rpc_status = task->tk_status;
425c1d4e
TM		 6185 switch (task->tk_status) {
6186 case 0:
2b0143b5 6187 renew_lease(NFS_SERVER(d_inode(data->ctx->dentry)),
39071e6f 6188 data->timestamp);
c69899a1
TM		 6189 if (data->arg.new_lock) {
6190 data->fl.fl_flags &= ~(FL_SLEEP | FL_ACCESS);
75575ddf 6191 if (locks_lock_inode_wait(lsp->ls_state->inode, &data->fl) < 0) {
c69899a1
TM		 6192 rpc_restart_call_prepare(task);
6193 break;
6194 }
6195 }
39071e6f
TM		 6196 if (data->arg.new_lock_owner != 0) {
6197 nfs_confirm_seqid(&lsp->ls_seqid, 0);
6198 nfs4_stateid_copy(&lsp->ls_stateid, &data->res.stateid);
6199 set_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags);
6200 } else if (!nfs4_update_lock_stateid(lsp, &data->res.stateid))
6201 rpc_restart_call_prepare(task);
425c1d4e
TM		 6202 break;
6203 case -NFS4ERR_BAD_STATEID:
6204 case -NFS4ERR_OLD_STATEID:
6205 case -NFS4ERR_STALE_STATEID:
6206 case -NFS4ERR_EXPIRED:
6207 if (data->arg.new_lock_owner != 0) {
6208 if (!nfs4_stateid_match(&data->arg.open_stateid,
6209 &lsp->ls_state->open_stateid))
6210 rpc_restart_call_prepare(task);
6211 } else if (!nfs4_stateid_match(&data->arg.lock_stateid,
6212 &lsp->ls_stateid))
6213 rpc_restart_call_prepare(task);
a5d16a4d 6214 }
3110ff80 6215 dprintk("%s: done, ret = %d!\n", __func__, data->rpc_status);
a5d16a4d
TM		 6216}
6217
6218static void nfs4_lock_release(void *calldata)
6219{
6220 struct nfs4_lockdata *data = calldata;
6221
3110ff80 6222 dprintk("%s: begin!\n", __func__);
2f74c0a0 6223 nfs_free_seqid(data->arg.open_seqid);
a5d16a4d
TM		 6224 if (data->cancelled != 0) {
6225 struct rpc_task *task;
6226 task = nfs4_do_unlck(&data->fl, data->ctx, data->lsp,
6227 data->arg.lock_seqid);
6228 if (!IS_ERR(task))
bf294b41 6229 rpc_put_task_async(task);
3110ff80 6230 dprintk("%s: cancelling lock!\n", __func__);
a5d16a4d
TM		 6231 } else
6232 nfs_free_seqid(data->arg.lock_seqid);
6233 nfs4_put_lock_state(data->lsp);
6234 put_nfs_open_context(data->ctx);
6235 kfree(data);
3110ff80 6236 dprintk("%s: done!\n", __func__);
a5d16a4d
TM		 6237}
6238
6239static const struct rpc_call_ops nfs4_lock_ops = {
6240 .rpc_call_prepare = nfs4_lock_prepare,
6241 .rpc_call_done = nfs4_lock_done,
6242 .rpc_release = nfs4_lock_release,
6243};
6244
2bee72a6
TM		 6245static void nfs4_handle_setlk_error(struct nfs_server *server, struct nfs4_lock_state *lsp, int new_lock_owner, int error)
6246{
2bee72a6
TM		 6247 switch (error) {
6248 case -NFS4ERR_ADMIN_REVOKED:
d7f3e4bf 6249 case -NFS4ERR_EXPIRED:
2bee72a6 6250 case -NFS4ERR_BAD_STATEID:
ecac799a 6251 lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED;
2bee72a6 6252 if (new_lock_owner != 0 ||
795a88c9 6253 test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) != 0)
ecac799a 6254 nfs4_schedule_stateid_recovery(server, lsp->ls_state);
a2c0b9e2
TM		 6255 break;
6256 case -NFS4ERR_STALE_STATEID:
a2c0b9e2 6257 lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED;
ecac799a 6258 nfs4_schedule_lease_recovery(server->nfs_client);
2bee72a6
TM		 6259 };
6260}
6261
afe6c27c 6262static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *fl, int recovery_type)
a5d16a4d
TM		 6263{
6264 struct nfs4_lockdata *data;
6265 struct rpc_task *task;
5138fde0
TM		 6266 struct rpc_message msg = {
6267 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCK],
6268 .rpc_cred = state->owner->so_cred,
6269 };
c970aa85
TM		 6270 struct rpc_task_setup task_setup_data = {
6271 .rpc_client = NFS_CLIENT(state->inode),
5138fde0 6272 .rpc_message = &msg,
c970aa85 6273 .callback_ops = &nfs4_lock_ops,
101070ca 6274 .workqueue = nfsiod_workqueue,
c970aa85
TM		 6275 .flags = RPC_TASK_ASYNC,
6276 };
a5d16a4d
TM		 6277 int ret;
6278
3110ff80 6279 dprintk("%s: begin!\n", __func__);
cd3758e3 6280 data = nfs4_alloc_lockdata(fl, nfs_file_open_context(fl->fl_file),
8535b2be
TM		 6281 fl->fl_u.nfs4_fl.owner,
6282 recovery_type == NFS_LOCK_NEW ? GFP_KERNEL : GFP_NOFS);
a5d16a4d
TM		 6283 if (data == NULL)
6284 return -ENOMEM;
6285 if (IS_SETLKW(cmd))
6286 data->arg.block = 1;
a9c92d6b 6287 nfs4_init_sequence(&data->arg.seq_args, &data->res.seq_res, 1);
1174dd1f
TM		 6288 msg.rpc_argp = &data->arg;
6289 msg.rpc_resp = &data->res;
c970aa85 6290 task_setup_data.callback_data = data;
8fe72bac
TM		 6291 if (recovery_type > NFS_LOCK_NEW) {
6292 if (recovery_type == NFS_LOCK_RECLAIM)
6293 data->arg.reclaim = NFS_LOCK_RECLAIM;
6294 nfs4_set_sequence_privileged(&data->arg.seq_args);
c69899a1
TM		 6295 } else
6296 data->arg.new_lock = 1;
c970aa85 6297 task = rpc_run_task(&task_setup_data);
7a1218a2 6298 if (IS_ERR(task))
a5d16a4d 6299 return PTR_ERR(task);
a5d16a4d
TM		 6300 ret = nfs4_wait_for_completion_rpc_task(task);
6301 if (ret == 0) {
6302 ret = data->rpc_status;
2bee72a6
TM		 6303 if (ret)
6304 nfs4_handle_setlk_error(data->server, data->lsp,
6305 data->arg.new_lock_owner, ret);
a5d16a4d
TM		 6306 } else
6307 data->cancelled = 1;
e6b3c4db 6308 rpc_put_task(task);
3110ff80 6309 dprintk("%s: done, ret = %d!\n", __func__, ret);
48c9579a 6310 trace_nfs4_set_lock(fl, state, &data->res.stateid, cmd, ret);
a5d16a4d 6311 return ret;
1da177e4
LT		 6312}
6313
6314static int nfs4_lock_reclaim(struct nfs4_state *state, struct file_lock *request)
6315{
202b50dc 6316 struct nfs_server *server = NFS_SERVER(state->inode);
05ffe24f
TM		 6317 struct nfs4_exception exception = {
6318 .inode = state->inode,
6319 };
202b50dc
TM		 6320 int err;
6321
6322 do {
42a2d13e
TM		 6323 /* Cache the lock if possible... */
6324 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)
6325 return 0;
afe6c27c 6326 err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_RECLAIM);
168667c4 6327 if (err != -NFS4ERR_DELAY)
202b50dc
TM		 6328 break;
6329 nfs4_handle_exception(server, err, &exception);
6330 } while (exception.retry);
6331 return err;
1da177e4
LT		 6332}
6333
6334static int nfs4_lock_expired(struct nfs4_state *state, struct file_lock *request)
6335{
202b50dc 6336 struct nfs_server *server = NFS_SERVER(state->inode);
05ffe24f
TM		 6337 struct nfs4_exception exception = {
6338 .inode = state->inode,
6339 };
202b50dc
TM		 6340 int err;
6341
6bfc93ef
TM		 6342 err = nfs4_set_lock_state(state, request);
6343 if (err != 0)
6344 return err;
f6de7a39 6345 if (!recover_lost_locks) {
ef1820f9
N		 6346 set_bit(NFS_LOCK_LOST, &request->fl_u.nfs4_fl.owner->ls_flags);
6347 return 0;
6348 }
202b50dc 6349 do {
42a2d13e
TM		 6350 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)
6351 return 0;
afe6c27c 6352 err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_EXPIRED);
a9ed2e25
TM		 6353 switch (err) {
6354 default:
6355 goto out;
6356 case -NFS4ERR_GRACE:
6357 case -NFS4ERR_DELAY:
6358 nfs4_handle_exception(server, err, &exception);
6359 err = 0;
6360 }
202b50dc 6361 } while (exception.retry);
a9ed2e25 6362out:
202b50dc 6363 return err;
1da177e4
LT		 6364}
6365
f062eb6c 6366#if defined(CONFIG_NFS_V4_1)
b01dd1d8
BS		 6367static int nfs41_lock_expired(struct nfs4_state *state, struct file_lock *request)
6368{
c5896fc8
TM		 6369 struct nfs4_lock_state *lsp;
6370 int status;
b01dd1d8 6371
c5896fc8
TM		 6372 status = nfs4_set_lock_state(state, request);
6373 if (status != 0)
6374 return status;
6375 lsp = request->fl_u.nfs4_fl.owner;
6376 if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) ||
6377 test_bit(NFS_LOCK_LOST, &lsp->ls_flags))
6378 return 0;
6379 status = nfs4_lock_expired(state, request);
eb64cf96 6380 return status;
f062eb6c
BS		 6381}
6382#endif
6383
1da177e4
LT		 6384static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
6385{
19e03c57 6386 struct nfs_inode *nfsi = NFS_I(state->inode);
11476e9d 6387 struct nfs4_state_owner *sp = state->owner;
01c3b861 6388 unsigned char fl_flags = request->fl_flags;
1ea67dbd 6389 int status;
1da177e4 6390
01c3b861 6391 request->fl_flags |= FL_ACCESS;
75575ddf 6392 status = locks_lock_inode_wait(state->inode, request);
01c3b861
TM		 6393 if (status < 0)
6394 goto out;
11476e9d 6395 mutex_lock(&sp->so_delegreturn_mutex);
19e03c57 6396 down_read(&nfsi->rwsem);
01c3b861 6397 if (test_bit(NFS_DELEGATED_STATE, &state->flags)) {
01c3b861 6398 /* Yes: cache locks! */
01c3b861 6399 /* ...but avoid races with delegation recall... */
19e03c57 6400 request->fl_flags = fl_flags & ~FL_SLEEP;
75575ddf 6401 status = locks_lock_inode_wait(state->inode, request);
c69899a1 6402 up_read(&nfsi->rwsem);
11476e9d 6403 mutex_unlock(&sp->so_delegreturn_mutex);
9a99af49 6404 goto out;
9a99af49 6405 }
19e03c57 6406 up_read(&nfsi->rwsem);
11476e9d 6407 mutex_unlock(&sp->so_delegreturn_mutex);
c69899a1 6408 status = _nfs4_do_setlk(state, cmd, request, NFS_LOCK_NEW);
01c3b861
TM		 6409out:
6410 request->fl_flags = fl_flags;
1da177e4
LT		 6411 return status;
6412}
6413
6414static int nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
6415{
a1d0b5ee
TM		 6416 struct nfs4_exception exception = {
6417 .state = state,
05ffe24f 6418 .inode = state->inode,
a1d0b5ee 6419 };
1da177e4
LT		 6420 int err;
6421
6422 do {
965b5d67
TM		 6423 err = _nfs4_proc_setlk(state, cmd, request);
6424 if (err == -NFS4ERR_DENIED)
6425 err = -EAGAIN;
1da177e4 6426 err = nfs4_handle_exception(NFS_SERVER(state->inode),
965b5d67 6427 err, &exception);
1da177e4
LT		 6428 } while (exception.retry);
6429 return err;
6430}
6431
d2f3a7f9
JL		 6432#define NFS4_LOCK_MINTIMEOUT (1 * HZ)
6433#define NFS4_LOCK_MAXTIMEOUT (30 * HZ)
6434
6435static int
a1d617d8
JL		 6436nfs4_retry_setlk_simple(struct nfs4_state *state, int cmd,
6437 struct file_lock *request)
d2f3a7f9
JL		 6438{
6439 int status = -ERESTARTSYS;
6440 unsigned long timeout = NFS4_LOCK_MINTIMEOUT;
6441
6442 while(!signalled()) {
6443 status = nfs4_proc_setlk(state, cmd, request);
6444 if ((status != -EAGAIN) || IS_SETLK(cmd))
6445 break;
6446 freezable_schedule_timeout_interruptible(timeout);
6447 timeout *= 2;
6448 timeout = min_t(unsigned long, NFS4_LOCK_MAXTIMEOUT, timeout);
6449 status = -ERESTARTSYS;
6450 }
6451 return status;
6452}
6453
a1d617d8
JL		 6454#ifdef CONFIG_NFS_V4_1
6455struct nfs4_lock_waiter {
6456 struct task_struct *task;
6457 struct inode *inode;
6458 struct nfs_lowner *owner;
6459 bool notified;
6460};
6461
6462static int
6463nfs4_wake_lock_waiter(wait_queue_t *wait, unsigned int mode, int flags, void *key)
6464{
6465 int ret;
6466 struct cb_notify_lock_args *cbnl = key;
6467 struct nfs4_lock_waiter *waiter = wait->private;
6468 struct nfs_lowner *lowner = &cbnl->cbnl_owner,
6469 *wowner = waiter->owner;
6470
6471 /* Only wake if the callback was for the same owner */
6472 if (lowner->clientid != wowner->clientid ||
6473 lowner->id != wowner->id ||
6474 lowner->s_dev != wowner->s_dev)
6475 return 0;
6476
6477 /* Make sure it's for the right inode */
6478 if (nfs_compare_fh(NFS_FH(waiter->inode), &cbnl->cbnl_fh))
6479 return 0;
6480
6481 waiter->notified = true;
6482
6483 /* override "private" so we can use default_wake_function */
6484 wait->private = waiter->task;
6485 ret = autoremove_wake_function(wait, mode, flags, key);
6486 wait->private = waiter;
6487 return ret;
6488}
6489
6490static int
6491nfs4_retry_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
6492{
6493 int status = -ERESTARTSYS;
6494 unsigned long flags;
6495 struct nfs4_lock_state *lsp = request->fl_u.nfs4_fl.owner;
6496 struct nfs_server *server = NFS_SERVER(state->inode);
6497 struct nfs_client *clp = server->nfs_client;
6498 wait_queue_head_t *q = &clp->cl_lock_waitq;
6499 struct nfs_lowner owner = { .clientid = clp->cl_clientid,
6500 .id = lsp->ls_seqid.owner_id,
6501 .s_dev = server->s_dev };
6502 struct nfs4_lock_waiter waiter = { .task = current,
6503 .inode = state->inode,
6504 .owner = &owner,
6505 .notified = false };
6506 wait_queue_t wait;
6507
6508 /* Don't bother with waitqueue if we don't expect a callback */
6509 if (!test_bit(NFS_STATE_MAY_NOTIFY_LOCK, &state->flags))
6510 return nfs4_retry_setlk_simple(state, cmd, request);
6511
6512 init_wait(&wait);
6513 wait.private = &waiter;
6514 wait.func = nfs4_wake_lock_waiter;
6515 add_wait_queue(q, &wait);
6516
6517 while(!signalled()) {
6518 status = nfs4_proc_setlk(state, cmd, request);
6519 if ((status != -EAGAIN) || IS_SETLK(cmd))
6520 break;
6521
6522 status = -ERESTARTSYS;
6523 spin_lock_irqsave(&q->lock, flags);
6524 if (waiter.notified) {
6525 spin_unlock_irqrestore(&q->lock, flags);
6526 continue;
6527 }
6528 set_current_state(TASK_INTERRUPTIBLE);
6529 spin_unlock_irqrestore(&q->lock, flags);
6530
6531 freezable_schedule_timeout_interruptible(NFS4_LOCK_MAXTIMEOUT);
6532 }
6533
6534 finish_wait(q, &wait);
6535 return status;
6536}
6537#else /* !CONFIG_NFS_V4_1 */
6538static inline int
6539nfs4_retry_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
6540{
6541 return nfs4_retry_setlk_simple(state, cmd, request);
6542}
6543#endif
6544
1da177e4
LT		 6545static int
6546nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request)
6547{
6548 struct nfs_open_context *ctx;
6549 struct nfs4_state *state;
1da177e4
LT		 6550 int status;
6551
6552 /* verify open state */
cd3758e3 6553 ctx = nfs_file_open_context(filp);
1da177e4
LT		 6554 state = ctx->state;
6555
6556 if (request->fl_start < 0 || request->fl_end < 0)
6557 return -EINVAL;
6558
d953126a
TM		 6559 if (IS_GETLK(cmd)) {
6560 if (state != NULL)
6561 return nfs4_proc_getlk(state, F_GETLK, request);
6562 return 0;
6563 }
1da177e4
LT		 6564
6565 if (!(IS_SETLK(cmd) || IS_SETLKW(cmd)))
6566 return -EINVAL;
6567
d953126a
TM		 6568 if (request->fl_type == F_UNLCK) {
6569 if (state != NULL)
6570 return nfs4_proc_unlck(state, cmd, request);
6571 return 0;
6572 }
1da177e4 6573
d953126a
TM		 6574 if (state == NULL)
6575 return -ENOLCK;
1ea67dbd
JL		 6576
6577 if ((request->fl_flags & FL_POSIX) &&
6578 !test_bit(NFS_STATE_POSIX_LOCKS, &state->flags))
6579 return -ENOLCK;
6580
55725513
TM		 6581 /*
6582 * Don't rely on the VFS having checked the file open mode,
6583 * since it won't do this for flock() locks.
6584 */
f44106e2 6585 switch (request->fl_type) {
55725513
TM		 6586 case F_RDLCK:
6587 if (!(filp->f_mode & FMODE_READ))
6588 return -EBADF;
6589 break;
6590 case F_WRLCK:
6591 if (!(filp->f_mode & FMODE_WRITE))
6592 return -EBADF;
6593 }
6594
1ea67dbd
JL		 6595 status = nfs4_set_lock_state(state, request);
6596 if (status != 0)
6597 return status;
6598
d2f3a7f9 6599 return nfs4_retry_setlk(state, cmd, request);
1da177e4
LT		 6600}
6601
db4f2e63 6602int nfs4_lock_delegation_recall(struct file_lock *fl, struct nfs4_state *state, const nfs4_stateid *stateid)
888e694c
TM		 6603{
6604 struct nfs_server *server = NFS_SERVER(state->inode);
888e694c
TM		 6605 int err;
6606
6607 err = nfs4_set_lock_state(state, fl);
6608 if (err != 0)
db4f2e63 6609 return err;
4a706fa0 6610 err = _nfs4_do_setlk(state, F_SETLK, fl, NFS_LOCK_NEW);
db4f2e63 6611 return nfs4_handle_delegation_recall_error(server, state, stateid, err);
888e694c 6612}
6b3b5496 6613
cf470c3e
TM		 6614struct nfs_release_lockowner_data {
6615 struct nfs4_lock_state *lsp;
5ae67c4f 6616 struct nfs_server *server;
cf470c3e 6617 struct nfs_release_lockowner_args args;
b7e63a10 6618 struct nfs_release_lockowner_res res;
60ea6812 6619 unsigned long timestamp;
cf470c3e
TM		 6620};
6621
fbd4bfd1
CL		 6622static void nfs4_release_lockowner_prepare(struct rpc_task *task, void *calldata)
6623{
6624 struct nfs_release_lockowner_data *data = calldata;
5b53dc88 6625 struct nfs_server *server = data->server;
7981c8a6
AS		 6626 nfs4_setup_sequence(server->nfs_client, &data->args.seq_args,
6627 &data->res.seq_res, task);
5b53dc88 6628 data->args.lock_owner.clientid = server->nfs_client->cl_clientid;
60ea6812 6629 data->timestamp = jiffies;
fbd4bfd1
CL		 6630}
6631
6632static void nfs4_release_lockowner_done(struct rpc_task *task, void *calldata)
6633{
6634 struct nfs_release_lockowner_data *data = calldata;
60ea6812
CL		 6635 struct nfs_server *server = data->server;
6636
b7e63a10 6637 nfs40_sequence_done(task, &data->res.seq_res);
60ea6812
CL		 6638
6639 switch (task->tk_status) {
6640 case 0:
6641 renew_lease(server, data->timestamp);
6642 break;
6643 case -NFS4ERR_STALE_CLIENTID:
6644 case -NFS4ERR_EXPIRED:
5b53dc88
KM		 6645 nfs4_schedule_lease_recovery(server->nfs_client);
6646 break;
60ea6812
CL		 6647 case -NFS4ERR_LEASE_MOVED:
6648 case -NFS4ERR_DELAY:
8478eaa1
N		 6649 if (nfs4_async_handle_error(task, server,
6650 NULL, NULL) == -EAGAIN)
60ea6812
CL		 6651 rpc_restart_call_prepare(task);
6652 }
fbd4bfd1
CL		 6653}
6654
d3c7b7cc
TM		 6655static void nfs4_release_lockowner_release(void *calldata)
6656{
cf470c3e 6657 struct nfs_release_lockowner_data *data = calldata;
5ae67c4f 6658 nfs4_free_lock_state(data->server, data->lsp);
d3c7b7cc
TM		 6659 kfree(calldata);
6660}
6661
17280175 6662static const struct rpc_call_ops nfs4_release_lockowner_ops = {
fbd4bfd1
CL		 6663 .rpc_call_prepare = nfs4_release_lockowner_prepare,
6664 .rpc_call_done = nfs4_release_lockowner_done,
d3c7b7cc
TM		 6665 .rpc_release = nfs4_release_lockowner_release,
6666};
6667
f1cdae87
JL		 6668static void
6669nfs4_release_lockowner(struct nfs_server *server, struct nfs4_lock_state *lsp)
d3c7b7cc 6670{
cf470c3e 6671 struct nfs_release_lockowner_data *data;
d3c7b7cc
TM		 6672 struct rpc_message msg = {
6673 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RELEASE_LOCKOWNER],
6674 };
6675
6676 if (server->nfs_client->cl_mvops->minor_version != 0)
f1cdae87 6677 return;
fbd4bfd1 6678
cf470c3e
TM		 6679 data = kmalloc(sizeof(*data), GFP_NOFS);
6680 if (!data)
f1cdae87 6681 return;
cf470c3e 6682 data->lsp = lsp;
5ae67c4f 6683 data->server = server;
cf470c3e
TM		 6684 data->args.lock_owner.clientid = server->nfs_client->cl_clientid;
6685 data->args.lock_owner.id = lsp->ls_seqid.owner_id;
6686 data->args.lock_owner.s_dev = server->s_dev;
fbd4bfd1 6687
cf470c3e 6688 msg.rpc_argp = &data->args;
b7e63a10
TM		 6689 msg.rpc_resp = &data->res;
6690 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 0);
cf470c3e 6691 rpc_call_async(server->client, &msg, 0, &nfs4_release_lockowner_ops, data);
d3c7b7cc
TM		 6692}
6693
aa1870af
BF		 6694#define XATTR_NAME_NFSV4_ACL "system.nfs4_acl"
6695
d9a82a04 6696static int nfs4_xattr_set_nfs4_acl(const struct xattr_handler *handler,
59301226
AV		 6697 struct dentry *unused, struct inode *inode,
6698 const char *key, const void *buf,
6699 size_t buflen, int flags)
6b3b5496 6700{
59301226 6701 return nfs4_proc_set_acl(inode, buf, buflen);
6b3b5496
BF		 6702}
6703
d9a82a04 6704static int nfs4_xattr_get_nfs4_acl(const struct xattr_handler *handler,
b296821a
AV		 6705 struct dentry *unused, struct inode *inode,
6706 const char *key, void *buf, size_t buflen)
6b3b5496 6707{
b296821a 6708 return nfs4_proc_get_acl(inode, buf, buflen);
6b3b5496
BF		 6709}
6710
764a5c6b 6711static bool nfs4_xattr_list_nfs4_acl(struct dentry *dentry)
6b3b5496 6712{
764a5c6b 6713 return nfs4_server_supports_acls(NFS_SERVER(d_inode(dentry)));
6b3b5496
BF		 6714}
6715
c9bccef6 6716#ifdef CONFIG_NFS_V4_SECURITY_LABEL
c9bccef6 6717
d9a82a04 6718static int nfs4_xattr_set_nfs4_label(const struct xattr_handler *handler,
59301226
AV		 6719 struct dentry *unused, struct inode *inode,
6720 const char *key, const void *buf,
6721 size_t buflen, int flags)
c9bccef6
DQ		 6722{
6723 if (security_ismaclabel(key))
59301226 6724 return nfs4_set_security_label(inode, buf, buflen);
c9bccef6
DQ		 6725
6726 return -EOPNOTSUPP;
6727}
6728
d9a82a04 6729static int nfs4_xattr_get_nfs4_label(const struct xattr_handler *handler,
b296821a
AV		 6730 struct dentry *unused, struct inode *inode,
6731 const char *key, void *buf, size_t buflen)
c9bccef6
DQ		 6732{
6733 if (security_ismaclabel(key))
b296821a 6734 return nfs4_get_security_label(inode, buf, buflen);
c9bccef6
DQ		 6735 return -EOPNOTSUPP;
6736}
6737
c4803c49
AG		 6738static ssize_t
6739nfs4_listxattr_nfs4_label(struct inode *inode, char *list, size_t list_len)
c9bccef6 6740{
c4803c49 6741 int len = 0;
c9bccef6 6742
c4803c49
AG		 6743 if (nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL)) {
6744 len = security_inode_listsecurity(inode, list, list_len);
6745 if (list_len && len > list_len)
6746 return -ERANGE;
c9bccef6
DQ		 6747 }
6748 return len;
6749}
6750
6751static const struct xattr_handler nfs4_xattr_nfs4_label_handler = {
6752 .prefix = XATTR_SECURITY_PREFIX,
c9bccef6
DQ		 6753 .get = nfs4_xattr_get_nfs4_label,
6754 .set = nfs4_xattr_set_nfs4_label,
6755};
c9bccef6 6756
c4803c49
AG		 6757#else
6758
6759static ssize_t
6760nfs4_listxattr_nfs4_label(struct inode *inode, char *list, size_t list_len)
6761{
6762 return 0;
6763}
6764
6765#endif
c9bccef6 6766
533eb461
AA		 6767/*
6768 * nfs_fhget will use either the mounted_on_fileid or the fileid
6769 */
69aaaae1
TM		 6770static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr)
6771{
533eb461
AA		 6772 if (!(((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) ||
6773 (fattr->valid & NFS_ATTR_FATTR_FILEID)) &&
6774 (fattr->valid & NFS_ATTR_FATTR_FSID) &&
81934ddb 6775 (fattr->valid & NFS_ATTR_FATTR_V4_LOCATIONS)))
69aaaae1
TM		 6776 return;
6777
6778 fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE |
81934ddb 6779 NFS_ATTR_FATTR_NLINK | NFS_ATTR_FATTR_V4_REFERRAL;
69aaaae1
TM		 6780 fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO;
6781 fattr->nlink = 2;
6782}
6783
f05d147f
BS		 6784static int _nfs4_proc_fs_locations(struct rpc_clnt *client, struct inode *dir,
6785 const struct qstr *name,
6786 struct nfs4_fs_locations *fs_locations,
6787 struct page *page)
683b57b4
TM		 6788{
6789 struct nfs_server *server = NFS_SERVER(dir);
a09df2ca 6790 u32 bitmask[3] = {
361e624f 6791 [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS,
683b57b4
TM		 6792 };
6793 struct nfs4_fs_locations_arg args = {
6794 .dir_fh = NFS_FH(dir),
c228fd3a 6795 .name = name,
683b57b4
TM		 6796 .page = page,
6797 .bitmask = bitmask,
6798 };
22958463
BH		 6799 struct nfs4_fs_locations_res res = {
6800 .fs_locations = fs_locations,
6801 };
683b57b4
TM		 6802 struct rpc_message msg = {
6803 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS],
6804 .rpc_argp = &args,
22958463 6805 .rpc_resp = &res,
683b57b4
TM		 6806 };
6807 int status;
6808
3110ff80 6809 dprintk("%s: start\n", __func__);
533eb461
AA		 6810
6811 /* Ask for the fileid of the absent filesystem if mounted_on_fileid
6812 * is not supported */
6813 if (NFS_SERVER(dir)->attr_bitmask[1] & FATTR4_WORD1_MOUNTED_ON_FILEID)
6814 bitmask[1] |= FATTR4_WORD1_MOUNTED_ON_FILEID;
6815 else
6816 bitmask[0] |= FATTR4_WORD0_FILEID;
6817
c228fd3a 6818 nfs_fattr_init(&fs_locations->fattr);
683b57b4 6819 fs_locations->server = server;
830b8e33 6820 fs_locations->nlocations = 0;
f05d147f 6821 status = nfs4_call_sync(client, server, &msg, &args.seq_args, &res.seq_res, 0);
3110ff80 6822 dprintk("%s: returned status = %d\n", __func__, status);
683b57b4
TM		 6823 return status;
6824}
6825
f05d147f
BS		 6826int nfs4_proc_fs_locations(struct rpc_clnt *client, struct inode *dir,
6827 const struct qstr *name,
6828 struct nfs4_fs_locations *fs_locations,
6829 struct page *page)
db0a9593
BS		 6830{
6831 struct nfs4_exception exception = { };
6832 int err;
6833 do {
078ea3df
TM		 6834 err = _nfs4_proc_fs_locations(client, dir, name,
6835 fs_locations, page);
6836 trace_nfs4_get_fs_locations(dir, name, err);
6837 err = nfs4_handle_exception(NFS_SERVER(dir), err,
db0a9593
BS		 6838 &exception);
6839 } while (exception.retry);
6840 return err;
6841}
6842
b03d735b
CL		 6843/*
6844 * This operation also signals the server that this client is
6845 * performing migration recovery. The server can stop returning
6846 * NFS4ERR_LEASE_MOVED to this client. A RENEW operation is
6847 * appended to this compound to identify the client ID which is
6848 * performing recovery.
6849 */
6850static int _nfs40_proc_get_locations(struct inode *inode,
6851 struct nfs4_fs_locations *locations,
6852 struct page *page, struct rpc_cred *cred)
6853{
6854 struct nfs_server *server = NFS_SERVER(inode);
6855 struct rpc_clnt *clnt = server->client;
6856 u32 bitmask[2] = {
6857 [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS,
6858 };
6859 struct nfs4_fs_locations_arg args = {
6860 .clientid = server->nfs_client->cl_clientid,
6861 .fh = NFS_FH(inode),
6862 .page = page,
6863 .bitmask = bitmask,
6864 .migration = 1, /* skip LOOKUP */
6865 .renew = 1, /* append RENEW */
6866 };
6867 struct nfs4_fs_locations_res res = {
6868 .fs_locations = locations,
6869 .migration = 1,
6870 .renew = 1,
6871 };
6872 struct rpc_message msg = {
6873 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS],
6874 .rpc_argp = &args,
6875 .rpc_resp = &res,
6876 .rpc_cred = cred,
6877 };
6878 unsigned long now = jiffies;
6879 int status;
6880
6881 nfs_fattr_init(&locations->fattr);
6882 locations->server = server;
6883 locations->nlocations = 0;
6884
6885 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
6886 nfs4_set_sequence_privileged(&args.seq_args);
6887 status = nfs4_call_sync_sequence(clnt, server, &msg,
6888 &args.seq_args, &res.seq_res);
6889 if (status)
6890 return status;
6891
6892 renew_lease(server, now);
6893 return 0;
6894}
6895
6896#ifdef CONFIG_NFS_V4_1
6897
6898/*
6899 * This operation also signals the server that this client is
6900 * performing migration recovery. The server can stop asserting
6901 * SEQ4_STATUS_LEASE_MOVED for this client. The client ID
6902 * performing this operation is identified in the SEQUENCE
6903 * operation in this compound.
6904 *
6905 * When the client supports GETATTR(fs_locations_info), it can
6906 * be plumbed in here.
6907 */
6908static int _nfs41_proc_get_locations(struct inode *inode,
6909 struct nfs4_fs_locations *locations,
6910 struct page *page, struct rpc_cred *cred)
6911{
6912 struct nfs_server *server = NFS_SERVER(inode);
6913 struct rpc_clnt *clnt = server->client;
6914 u32 bitmask[2] = {
6915 [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS,
6916 };
6917 struct nfs4_fs_locations_arg args = {
6918 .fh = NFS_FH(inode),
6919 .page = page,
6920 .bitmask = bitmask,
6921 .migration = 1, /* skip LOOKUP */
6922 };
6923 struct nfs4_fs_locations_res res = {
6924 .fs_locations = locations,
6925 .migration = 1,
6926 };
6927 struct rpc_message msg = {
6928 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS],
6929 .rpc_argp = &args,
6930 .rpc_resp = &res,
6931 .rpc_cred = cred,
6932 };
6933 int status;
6934
6935 nfs_fattr_init(&locations->fattr);
6936 locations->server = server;
6937 locations->nlocations = 0;
6938
6939 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
6940 nfs4_set_sequence_privileged(&args.seq_args);
6941 status = nfs4_call_sync_sequence(clnt, server, &msg,
6942 &args.seq_args, &res.seq_res);
6943 if (status == NFS4_OK &&
6944 res.seq_res.sr_status_flags & SEQ4_STATUS_LEASE_MOVED)
6945 status = -NFS4ERR_LEASE_MOVED;
6946 return status;
6947}
6948
6949#endif /* CONFIG_NFS_V4_1 */
6950
6951/**
6952 * nfs4_proc_get_locations - discover locations for a migrated FSID
6953 * @inode: inode on FSID that is migrating
6954 * @locations: result of query
6955 * @page: buffer
6956 * @cred: credential to use for this operation
6957 *
6958 * Returns NFS4_OK on success, a negative NFS4ERR status code if the
6959 * operation failed, or a negative errno if a local error occurred.
6960 *
6961 * On success, "locations" is filled in, but if the server has
6962 * no locations information, NFS_ATTR_FATTR_V4_LOCATIONS is not
6963 * asserted.
6964 *
6965 * -NFS4ERR_LEASE_MOVED is returned if the server still has leases
6966 * from this client that require migration recovery.
6967 */
6968int nfs4_proc_get_locations(struct inode *inode,
6969 struct nfs4_fs_locations *locations,
6970 struct page *page, struct rpc_cred *cred)
6971{
6972 struct nfs_server *server = NFS_SERVER(inode);
6973 struct nfs_client *clp = server->nfs_client;
6974 const struct nfs4_mig_recovery_ops *ops =
6975 clp->cl_mvops->mig_recovery_ops;
6976 struct nfs4_exception exception = { };
6977 int status;
6978
6979 dprintk("%s: FSID %llx:%llx on \"%s\"\n", __func__,
6980 (unsigned long long)server->fsid.major,
6981 (unsigned long long)server->fsid.minor,
6982 clp->cl_hostname);
6983 nfs_display_fhandle(NFS_FH(inode), __func__);
6984
6985 do {
6986 status = ops->get_locations(inode, locations, page, cred);
6987 if (status != -NFS4ERR_DELAY)
6988 break;
6989 nfs4_handle_exception(server, status, &exception);
6990 } while (exception.retry);
6991 return status;
6992}
6993
44c99933
CL		 6994/*
6995 * This operation also signals the server that this client is
6996 * performing "lease moved" recovery. The server can stop
6997 * returning NFS4ERR_LEASE_MOVED to this client. A RENEW operation
6998 * is appended to this compound to identify the client ID which is
6999 * performing recovery.
7000 */
7001static int _nfs40_proc_fsid_present(struct inode *inode, struct rpc_cred *cred)
7002{
7003 struct nfs_server *server = NFS_SERVER(inode);
7004 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
7005 struct rpc_clnt *clnt = server->client;
7006 struct nfs4_fsid_present_arg args = {
7007 .fh = NFS_FH(inode),
7008 .clientid = clp->cl_clientid,
7009 .renew = 1, /* append RENEW */
7010 };
7011 struct nfs4_fsid_present_res res = {
7012 .renew = 1,
7013 };
7014 struct rpc_message msg = {
7015 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSID_PRESENT],
7016 .rpc_argp = &args,
7017 .rpc_resp = &res,
7018 .rpc_cred = cred,
7019 };
7020 unsigned long now = jiffies;
7021 int status;
7022
7023 res.fh = nfs_alloc_fhandle();
7024 if (res.fh == NULL)
7025 return -ENOMEM;
7026
7027 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
7028 nfs4_set_sequence_privileged(&args.seq_args);
7029 status = nfs4_call_sync_sequence(clnt, server, &msg,
7030 &args.seq_args, &res.seq_res);
7031 nfs_free_fhandle(res.fh);
7032 if (status)
7033 return status;
7034
7035 do_renew_lease(clp, now);
7036 return 0;
7037}
7038
7039#ifdef CONFIG_NFS_V4_1
7040
7041/*
7042 * This operation also signals the server that this client is
7043 * performing "lease moved" recovery. The server can stop asserting
7044 * SEQ4_STATUS_LEASE_MOVED for this client. The client ID performing
7045 * this operation is identified in the SEQUENCE operation in this
7046 * compound.
7047 */
7048static int _nfs41_proc_fsid_present(struct inode *inode, struct rpc_cred *cred)
7049{
7050 struct nfs_server *server = NFS_SERVER(inode);
7051 struct rpc_clnt *clnt = server->client;
7052 struct nfs4_fsid_present_arg args = {
7053 .fh = NFS_FH(inode),
7054 };
7055 struct nfs4_fsid_present_res res = {
7056 };
7057 struct rpc_message msg = {
7058 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSID_PRESENT],
7059 .rpc_argp = &args,
7060 .rpc_resp = &res,
7061 .rpc_cred = cred,
7062 };
7063 int status;
7064
7065 res.fh = nfs_alloc_fhandle();
7066 if (res.fh == NULL)
7067 return -ENOMEM;
7068
7069 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
7070 nfs4_set_sequence_privileged(&args.seq_args);
7071 status = nfs4_call_sync_sequence(clnt, server, &msg,
7072 &args.seq_args, &res.seq_res);
7073 nfs_free_fhandle(res.fh);
7074 if (status == NFS4_OK &&
7075 res.seq_res.sr_status_flags & SEQ4_STATUS_LEASE_MOVED)
7076 status = -NFS4ERR_LEASE_MOVED;
7077 return status;
7078}
7079
7080#endif /* CONFIG_NFS_V4_1 */
7081
7082/**
7083 * nfs4_proc_fsid_present - Is this FSID present or absent on server?
7084 * @inode: inode on FSID to check
7085 * @cred: credential to use for this operation
7086 *
7087 * Server indicates whether the FSID is present, moved, or not
7088 * recognized. This operation is necessary to clear a LEASE_MOVED
7089 * condition for this client ID.
7090 *
7091 * Returns NFS4_OK if the FSID is present on this server,
7092 * -NFS4ERR_MOVED if the FSID is no longer present, a negative
7093 * NFS4ERR code if some error occurred on the server, or a
7094 * negative errno if a local failure occurred.
7095 */
7096int nfs4_proc_fsid_present(struct inode *inode, struct rpc_cred *cred)
7097{
7098 struct nfs_server *server = NFS_SERVER(inode);
7099 struct nfs_client *clp = server->nfs_client;
7100 const struct nfs4_mig_recovery_ops *ops =
7101 clp->cl_mvops->mig_recovery_ops;
7102 struct nfs4_exception exception = { };
7103 int status;
7104
7105 dprintk("%s: FSID %llx:%llx on \"%s\"\n", __func__,
7106 (unsigned long long)server->fsid.major,
7107 (unsigned long long)server->fsid.minor,
7108 clp->cl_hostname);
7109 nfs_display_fhandle(NFS_FH(inode), __func__);
7110
7111 do {
7112 status = ops->fsid_present(inode, cred);
7113 if (status != -NFS4ERR_DELAY)
7114 break;
7115 nfs4_handle_exception(server, status, &exception);
7116 } while (exception.retry);
7117 return status;
7118}
7119
5ec16a85 7120/**
a5250def
WAA		 7121 * If 'use_integrity' is true and the state managment nfs_client
7122 * cl_rpcclient is using krb5i/p, use the integrity protected cl_rpcclient
7123 * and the machine credential as per RFC3530bis and RFC5661 Security
7124 * Considerations sections. Otherwise, just use the user cred with the
7125 * filesystem's rpc_client.
5ec16a85 7126 */
a5250def 7127static int _nfs4_proc_secinfo(struct inode *dir, const struct qstr *name, struct nfs4_secinfo_flavors *flavors, bool use_integrity)
5a5ea0d4
BS		 7128{
7129 int status;
7130 struct nfs4_secinfo_arg args = {
7131 .dir_fh = NFS_FH(dir),
7132 .name = name,
7133 };
7134 struct nfs4_secinfo_res res = {
7135 .flavors = flavors,
7136 };
7137 struct rpc_message msg = {
7138 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SECINFO],
7139 .rpc_argp = &args,
7140 .rpc_resp = &res,
7141 };
a5250def 7142 struct rpc_clnt *clnt = NFS_SERVER(dir)->client;
7cb852df 7143 struct rpc_cred *cred = NULL;
a5250def
WAA		 7144
7145 if (use_integrity) {
7146 clnt = NFS_SERVER(dir)->nfs_client->cl_rpcclient;
7cb852df
WAA		 7147 cred = nfs4_get_clid_cred(NFS_SERVER(dir)->nfs_client);
7148 msg.rpc_cred = cred;
a5250def 7149 }
5a5ea0d4
BS		 7150
7151 dprintk("NFS call secinfo %s\n", name->name);
8b5bee2e
WAA		 7152
7153 nfs4_state_protect(NFS_SERVER(dir)->nfs_client,
7154 NFS_SP4_MACH_CRED_SECINFO, &clnt, &msg);
7155
a5250def
WAA		 7156 status = nfs4_call_sync(clnt, NFS_SERVER(dir), &msg, &args.seq_args,
7157 &res.seq_res, 0);
5a5ea0d4 7158 dprintk("NFS reply secinfo: %d\n", status);
a5250def 7159
7cb852df
WAA		 7160 if (cred)
7161 put_rpccred(cred);
a5250def 7162
5a5ea0d4
BS		 7163 return status;
7164}
7165
72de53ec
BS		 7166int nfs4_proc_secinfo(struct inode *dir, const struct qstr *name,
7167 struct nfs4_secinfo_flavors *flavors)
5a5ea0d4
BS		 7168{
7169 struct nfs4_exception exception = { };
7170 int err;
7171 do {
a5250def
WAA		 7172 err = -NFS4ERR_WRONGSEC;
7173
7174 /* try to use integrity protection with machine cred */
7175 if (_nfs4_is_integrity_protected(NFS_SERVER(dir)->nfs_client))
7176 err = _nfs4_proc_secinfo(dir, name, flavors, true);
7177
7178 /*
7179 * if unable to use integrity protection, or SECINFO with
7180 * integrity protection returns NFS4ERR_WRONGSEC (which is
7181 * disallowed by spec, but exists in deployed servers) use
7182 * the current filesystem's rpc_client and the user cred.
7183 */
7184 if (err == -NFS4ERR_WRONGSEC)
7185 err = _nfs4_proc_secinfo(dir, name, flavors, false);
7186
078ea3df
TM		 7187 trace_nfs4_secinfo(dir, name, err);
7188 err = nfs4_handle_exception(NFS_SERVER(dir), err,
5a5ea0d4
BS		 7189 &exception);
7190 } while (exception.retry);
7191 return err;
7192}
7193
557134a3 7194#ifdef CONFIG_NFS_V4_1
357f54d6
AA		 7195/*
7196 * Check the exchange flags returned by the server for invalid flags, having
7197 * both PNFS and NON_PNFS flags set, and not having one of NON_PNFS, PNFS, or
7198 * DS flags set.
7199 */
7200static int nfs4_check_cl_exchange_flags(u32 flags)
7201{
7202 if (flags & ~EXCHGID4_FLAG_MASK_R)
7203 goto out_inval;
7204 if ((flags & EXCHGID4_FLAG_USE_PNFS_MDS) &&
7205 (flags & EXCHGID4_FLAG_USE_NON_PNFS))
7206 goto out_inval;
7207 if (!(flags & (EXCHGID4_FLAG_MASK_PNFS)))
7208 goto out_inval;
7209 return NFS_OK;
7210out_inval:
7211 return -NFS4ERR_INVAL;
7212}
7213
78fe0f41 7214static bool
79d4e1f0
CL		 7215nfs41_same_server_scope(struct nfs41_server_scope *a,
7216 struct nfs41_server_scope *b)
78fe0f41
WAA		 7217{
7218 if (a->server_scope_sz == b->server_scope_sz &&
7219 memcmp(a->server_scope, b->server_scope, a->server_scope_sz) == 0)
7220 return true;
7221
7222 return false;
7223}
7224
02a95dee
AA		 7225static void
7226nfs4_bind_one_conn_to_session_done(struct rpc_task *task, void *calldata)
7227{
7228}
7229
7230static const struct rpc_call_ops nfs4_bind_one_conn_to_session_ops = {
7231 .rpc_call_done = &nfs4_bind_one_conn_to_session_done,
7232};
7233
7c44f1ae 7234/*
d9ddbf5d 7235 * nfs4_proc_bind_one_conn_to_session()
7c44f1ae
WAA		 7236 *
7237 * The 4.1 client currently uses the same TCP connection for the
7238 * fore and backchannel.
7239 */
d9ddbf5d
TM		 7240static
7241int nfs4_proc_bind_one_conn_to_session(struct rpc_clnt *clnt,
7242 struct rpc_xprt *xprt,
7243 struct nfs_client *clp,
7244 struct rpc_cred *cred)
7c44f1ae
WAA		 7245{
7246 int status;
71a097c6
TM		 7247 struct nfs41_bind_conn_to_session_args args = {
7248 .client = clp,
7249 .dir = NFS4_CDFC4_FORE_OR_BOTH,
7250 };
7c44f1ae
WAA		 7251 struct nfs41_bind_conn_to_session_res res;
7252 struct rpc_message msg = {
7253 .rpc_proc =
7254 &nfs4_procedures[NFSPROC4_CLNT_BIND_CONN_TO_SESSION],
71a097c6 7255 .rpc_argp = &args,
7c44f1ae 7256 .rpc_resp = &res,
2cf047c9 7257 .rpc_cred = cred,
7c44f1ae 7258 };
d9ddbf5d
TM		 7259 struct rpc_task_setup task_setup_data = {
7260 .rpc_client = clnt,
7261 .rpc_xprt = xprt,
02a95dee 7262 .callback_ops = &nfs4_bind_one_conn_to_session_ops,
d9ddbf5d
TM		 7263 .rpc_message = &msg,
7264 .flags = RPC_TASK_TIMEOUT,
7265 };
7266 struct rpc_task *task;
7c44f1ae
WAA		 7267
7268 dprintk("--> %s\n", __func__);
7c44f1ae 7269
71a097c6
TM		 7270 nfs4_copy_sessionid(&args.sessionid, &clp->cl_session->sess_id);
7271 if (!(clp->cl_session->flags & SESSION4_BACK_CHAN))
7272 args.dir = NFS4_CDFC4_FORE;
7c44f1ae 7273
d9ddbf5d
TM		 7274 /* Do not set the backchannel flag unless this is clnt->cl_xprt */
7275 if (xprt != rcu_access_pointer(clnt->cl_xprt))
7276 args.dir = NFS4_CDFC4_FORE;
7277
7278 task = rpc_run_task(&task_setup_data);
7279 if (!IS_ERR(task)) {
7280 status = task->tk_status;
7281 rpc_put_task(task);
7282 } else
7283 status = PTR_ERR(task);
c6d01c6f 7284 trace_nfs4_bind_conn_to_session(clp, status);
7c44f1ae 7285 if (status == 0) {
71a097c6 7286 if (memcmp(res.sessionid.data,
7c44f1ae
WAA		 7287 clp->cl_session->sess_id.data, NFS4_MAX_SESSIONID_LEN)) {
7288 dprintk("NFS: %s: Session ID mismatch\n", __func__);
7289 status = -EIO;
71a097c6 7290 goto out;
7c44f1ae 7291 }
71a097c6 7292 if ((res.dir & args.dir) != res.dir || res.dir == 0) {
7c44f1ae
WAA		 7293 dprintk("NFS: %s: Unexpected direction from server\n",
7294 __func__);
7295 status = -EIO;
71a097c6 7296 goto out;
7c44f1ae 7297 }
71a097c6 7298 if (res.use_conn_in_rdma_mode != args.use_conn_in_rdma_mode) {
7c44f1ae
WAA		 7299 dprintk("NFS: %s: Server returned RDMA mode = true\n",
7300 __func__);
7301 status = -EIO;
71a097c6 7302 goto out;
7c44f1ae
WAA		 7303 }
7304 }
7c44f1ae
WAA		 7305out:
7306 dprintk("<-- %s status= %d\n", __func__, status);
7307 return status;
7308}
7309
d9ddbf5d
TM		 7310struct rpc_bind_conn_calldata {
7311 struct nfs_client *clp;
7312 struct rpc_cred *cred;
7313};
7314
7315static int
7316nfs4_proc_bind_conn_to_session_callback(struct rpc_clnt *clnt,
7317 struct rpc_xprt *xprt,
7318 void *calldata)
7319{
7320 struct rpc_bind_conn_calldata *p = calldata;
7321
7322 return nfs4_proc_bind_one_conn_to_session(clnt, xprt, p->clp, p->cred);
7323}
7324
7325int nfs4_proc_bind_conn_to_session(struct nfs_client *clp, struct rpc_cred *cred)
7326{
7327 struct rpc_bind_conn_calldata data = {
7328 .clp = clp,
7329 .cred = cred,
7330 };
7331 return rpc_clnt_iterate_for_each_xprt(clp->cl_rpcclient,
7332 nfs4_proc_bind_conn_to_session_callback, &data);
7333}
7334
99fe60d0 7335/*
fa940720
WAA		 7336 * Minimum set of SP4_MACH_CRED operations from RFC 5661 in the enforce map
7337 * and operations we'd like to see to enable certain features in the allow map
2031cd1a
WAA		 7338 */
7339static const struct nfs41_state_protection nfs4_sp4_mach_cred_request = {
7340 .how = SP4_MACH_CRED,
7341 .enforce.u.words = {
7342 [1] = 1 << (OP_BIND_CONN_TO_SESSION - 32) |
7343 1 << (OP_EXCHANGE_ID - 32) |
7344 1 << (OP_CREATE_SESSION - 32) |
7345 1 << (OP_DESTROY_SESSION - 32) |
7346 1 << (OP_DESTROY_CLIENTID - 32)
fa940720
WAA		 7347 },
7348 .allow.u.words = {
7349 [0] = 1 << (OP_CLOSE) |
99ade3c7 7350 1 << (OP_OPEN_DOWNGRADE) |
a0279625 7351 1 << (OP_LOCKU) |
99ade3c7 7352 1 << (OP_DELEGRETURN) |
a0279625 7353 1 << (OP_COMMIT),
8b5bee2e 7354 [1] = 1 << (OP_SECINFO - 32) |
3787d506 7355 1 << (OP_SECINFO_NO_NAME - 32) |
99ade3c7 7356 1 << (OP_LAYOUTRETURN - 32) |
3787d506 7357 1 << (OP_TEST_STATEID - 32) |
a0279625
WAA		 7358 1 << (OP_FREE_STATEID - 32) |
7359 1 << (OP_WRITE - 32)
2031cd1a
WAA		 7360 }
7361};
7362
7363/*
7364 * Select the state protection mode for client `clp' given the server results
7365 * from exchange_id in `sp'.
99fe60d0 7366 *
2031cd1a
WAA		 7367 * Returns 0 on success, negative errno otherwise.
7368 */
7369static int nfs4_sp4_select_mode(struct nfs_client *clp,
7370 struct nfs41_state_protection *sp)
7371{
7372 static const u32 supported_enforce[NFS4_OP_MAP_NUM_WORDS] = {
7373 [1] = 1 << (OP_BIND_CONN_TO_SESSION - 32) |
7374 1 << (OP_EXCHANGE_ID - 32) |
7375 1 << (OP_CREATE_SESSION - 32) |
7376 1 << (OP_DESTROY_SESSION - 32) |
7377 1 << (OP_DESTROY_CLIENTID - 32)
7378 };
7379 unsigned int i;
7380
7381 if (sp->how == SP4_MACH_CRED) {
7382 /* Print state protect result */
7383 dfprintk(MOUNT, "Server SP4_MACH_CRED support:\n");
7384 for (i = 0; i <= LAST_NFS4_OP; i++) {
7385 if (test_bit(i, sp->enforce.u.longs))
7386 dfprintk(MOUNT, " enforce op %d\n", i);
7387 if (test_bit(i, sp->allow.u.longs))
7388 dfprintk(MOUNT, " allow op %d\n", i);
7389 }
7390
7391 /* make sure nothing is on enforce list that isn't supported */
7392 for (i = 0; i < NFS4_OP_MAP_NUM_WORDS; i++) {
7393 if (sp->enforce.u.words[i] & ~supported_enforce[i]) {
7394 dfprintk(MOUNT, "sp4_mach_cred: disabled\n");
7395 return -EINVAL;
7396 }
7397 }
7398
7399 /*
7400 * Minimal mode - state operations are allowed to use machine
7401 * credential. Note this already happens by default, so the
7402 * client doesn't have to do anything more than the negotiation.
7403 *
7404 * NOTE: we don't care if EXCHANGE_ID is in the list -
7405 * we're already using the machine cred for exchange_id
7406 * and will never use a different cred.
7407 */
7408 if (test_bit(OP_BIND_CONN_TO_SESSION, sp->enforce.u.longs) &&
7409 test_bit(OP_CREATE_SESSION, sp->enforce.u.longs) &&
7410 test_bit(OP_DESTROY_SESSION, sp->enforce.u.longs) &&
7411 test_bit(OP_DESTROY_CLIENTID, sp->enforce.u.longs)) {
7412 dfprintk(MOUNT, "sp4_mach_cred:\n");
7413 dfprintk(MOUNT, " minimal mode enabled\n");
7414 set_bit(NFS_SP4_MACH_CRED_MINIMAL, &clp->cl_sp4_flags);
7415 } else {
7416 dfprintk(MOUNT, "sp4_mach_cred: disabled\n");
7417 return -EINVAL;
7418 }
fa940720
WAA		 7419
7420 if (test_bit(OP_CLOSE, sp->allow.u.longs) &&
99ade3c7
AE		 7421 test_bit(OP_OPEN_DOWNGRADE, sp->allow.u.longs) &&
7422 test_bit(OP_DELEGRETURN, sp->allow.u.longs) &&
fa940720
WAA		 7423 test_bit(OP_LOCKU, sp->allow.u.longs)) {
7424 dfprintk(MOUNT, " cleanup mode enabled\n");
7425 set_bit(NFS_SP4_MACH_CRED_CLEANUP, &clp->cl_sp4_flags);
7426 }
8b5bee2e 7427
99ade3c7
AE		 7428 if (test_bit(OP_LAYOUTRETURN, sp->allow.u.longs)) {
7429 dfprintk(MOUNT, " pnfs cleanup mode enabled\n");
7430 set_bit(NFS_SP4_MACH_CRED_PNFS_CLEANUP,
7431 &clp->cl_sp4_flags);
7432 }
7433
8b5bee2e
WAA		 7434 if (test_bit(OP_SECINFO, sp->allow.u.longs) &&
7435 test_bit(OP_SECINFO_NO_NAME, sp->allow.u.longs)) {
7436 dfprintk(MOUNT, " secinfo mode enabled\n");
7437 set_bit(NFS_SP4_MACH_CRED_SECINFO, &clp->cl_sp4_flags);
7438 }
3787d506
WAA		 7439
7440 if (test_bit(OP_TEST_STATEID, sp->allow.u.longs) &&
7441 test_bit(OP_FREE_STATEID, sp->allow.u.longs)) {
7442 dfprintk(MOUNT, " stateid mode enabled\n");
7443 set_bit(NFS_SP4_MACH_CRED_STATEID, &clp->cl_sp4_flags);
7444 }
8c21c62c
WAA		 7445
7446 if (test_bit(OP_WRITE, sp->allow.u.longs)) {
7447 dfprintk(MOUNT, " write mode enabled\n");
7448 set_bit(NFS_SP4_MACH_CRED_WRITE, &clp->cl_sp4_flags);
7449 }
7450
7451 if (test_bit(OP_COMMIT, sp->allow.u.longs)) {
7452 dfprintk(MOUNT, " commit mode enabled\n");
7453 set_bit(NFS_SP4_MACH_CRED_COMMIT, &clp->cl_sp4_flags);
7454 }
2031cd1a
WAA		 7455 }
7456
7457 return 0;
7458}
7459
8d89bd70
AA		 7460struct nfs41_exchange_id_data {
7461 struct nfs41_exchange_id_res res;
7462 struct nfs41_exchange_id_args args;
ad0849a7 7463 struct rpc_xprt *xprt;
8d89bd70
AA		 7464 int rpc_status;
7465};
7466
7467static void nfs4_exchange_id_done(struct rpc_task *task, void *data)
7468{
7469 struct nfs41_exchange_id_data *cdata =
7470 (struct nfs41_exchange_id_data *)data;
7471 struct nfs_client *clp = cdata->args.client;
7472 int status = task->tk_status;
7473
7474 trace_nfs4_exchange_id(clp, status);
7475
7476 if (status == 0)
7477 status = nfs4_check_cl_exchange_flags(cdata->res.flags);
ad0849a7
AA		 7478
7479 if (cdata->xprt && status == 0) {
7480 status = nfs4_detect_session_trunking(clp, &cdata->res,
7481 cdata->xprt);
7482 goto out;
7483 }
7484
8d89bd70
AA		 7485 if (status == 0)
7486 status = nfs4_sp4_select_mode(clp, &cdata->res.state_protect);
7487
7488 if (status == 0) {
7489 clp->cl_clientid = cdata->res.clientid;
7490 clp->cl_exchange_flags = cdata->res.flags;
7491 /* Client ID is not confirmed */
7492 if (!(cdata->res.flags & EXCHGID4_FLAG_CONFIRMED_R)) {
7493 clear_bit(NFS4_SESSION_ESTABLISHED,
7494 &clp->cl_session->session_state);
7495 clp->cl_seqid = cdata->res.seqid;
7496 }
7497
7498 kfree(clp->cl_serverowner);
7499 clp->cl_serverowner = cdata->res.server_owner;
7500 cdata->res.server_owner = NULL;
7501
7502 /* use the most recent implementation id */
7503 kfree(clp->cl_implid);
7504 clp->cl_implid = cdata->res.impl_id;
7505 cdata->res.impl_id = NULL;
7506
7507 if (clp->cl_serverscope != NULL &&
7508 !nfs41_same_server_scope(clp->cl_serverscope,
7509 cdata->res.server_scope)) {
7510 dprintk("%s: server_scope mismatch detected\n",
7511 __func__);
7512 set_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state);
7513 kfree(clp->cl_serverscope);
7514 clp->cl_serverscope = NULL;
7515 }
7516
7517 if (clp->cl_serverscope == NULL) {
7518 clp->cl_serverscope = cdata->res.server_scope;
7519 cdata->res.server_scope = NULL;
7520 }
ad0849a7
AA		 7521 /* Save the EXCHANGE_ID verifier session trunk tests */
7522 memcpy(clp->cl_confirm.data, cdata->args.verifier->data,
7523 sizeof(clp->cl_confirm.data));
8d89bd70 7524 }
ad0849a7 7525out:
8d89bd70 7526 cdata->rpc_status = status;
ad0849a7 7527 return;
8d89bd70
AA		 7528}
7529
7530static void nfs4_exchange_id_release(void *data)
7531{
7532 struct nfs41_exchange_id_data *cdata =
7533 (struct nfs41_exchange_id_data *)data;
7534
7535 nfs_put_client(cdata->args.client);
ad0849a7
AA		 7536 if (cdata->xprt) {
7537 xprt_put(cdata->xprt);
7538 rpc_clnt_xprt_switch_put(cdata->args.client->cl_rpcclient);
7539 }
8d89bd70
AA		 7540 kfree(cdata->res.impl_id);
7541 kfree(cdata->res.server_scope);
7542 kfree(cdata->res.server_owner);
7543 kfree(cdata);
7544}
7545
7546static const struct rpc_call_ops nfs4_exchange_id_call_ops = {
7547 .rpc_call_done = nfs4_exchange_id_done,
7548 .rpc_release = nfs4_exchange_id_release,
7549};
7550
2031cd1a
WAA		 7551/*
7552 * _nfs4_proc_exchange_id()
6bbb4ae8 7553 *
2031cd1a 7554 * Wrapper for EXCHANGE_ID operation.
99fe60d0 7555 */
2031cd1a 7556static int _nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred,
ad0849a7 7557 u32 sp4_how, struct rpc_xprt *xprt)
99fe60d0
BH		 7558{
7559 nfs4_verifier verifier;
99fe60d0
BH		 7560 struct rpc_message msg = {
7561 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_EXCHANGE_ID],
99fe60d0
BH		 7562 .rpc_cred = cred,
7563 };
8d89bd70
AA		 7564 struct rpc_task_setup task_setup_data = {
7565 .rpc_client = clp->cl_rpcclient,
7566 .callback_ops = &nfs4_exchange_id_call_ops,
7567 .rpc_message = &msg,
7568 .flags = RPC_TASK_ASYNC | RPC_TASK_TIMEOUT,
7569 };
7570 struct nfs41_exchange_id_data *calldata;
7571 struct rpc_task *task;
7572 int status = -EIO;
7573
7574 if (!atomic_inc_not_zero(&clp->cl_count))
7575 goto out;
7576
7577 status = -ENOMEM;
7578 calldata = kzalloc(sizeof(*calldata), GFP_NOFS);
7579 if (!calldata)
7580 goto out;
99fe60d0 7581
ad0849a7
AA		 7582 if (!xprt)
7583 nfs4_init_boot_verifier(clp, &verifier);
873e3851
JL		 7584
7585 status = nfs4_init_uniform_client_string(clp);
7586 if (status)
8d89bd70 7587 goto out_calldata;
3a6bb738
JL		 7588
7589 dprintk("NFS call exchange_id auth=%s, '%s'\n",
6bbb4ae8 7590 clp->cl_rpcclient->cl_auth->au_ops->au_name,
3a6bb738 7591 clp->cl_owner_id);
99fe60d0 7592
8d89bd70
AA		 7593 calldata->res.server_owner = kzalloc(sizeof(struct nfs41_server_owner),
7594 GFP_NOFS);
7595 status = -ENOMEM;
7596 if (unlikely(calldata->res.server_owner == NULL))
7597 goto out_calldata;
78fe0f41 7598
8d89bd70 7599 calldata->res.server_scope = kzalloc(sizeof(struct nfs41_server_scope),
bbafffd2 7600 GFP_NOFS);
8d89bd70 7601 if (unlikely(calldata->res.server_scope == NULL))
acdeb69d 7602 goto out_server_owner;
78fe0f41 7603
8d89bd70
AA		 7604 calldata->res.impl_id = kzalloc(sizeof(struct nfs41_impl_id), GFP_NOFS);
7605 if (unlikely(calldata->res.impl_id == NULL))
7d2ed9ac 7606 goto out_server_scope;
7d2ed9ac 7607
2031cd1a
WAA		 7608 switch (sp4_how) {
7609 case SP4_NONE:
8d89bd70 7610 calldata->args.state_protect.how = SP4_NONE;
2031cd1a
WAA		 7611 break;
7612
7613 case SP4_MACH_CRED:
8d89bd70 7614 calldata->args.state_protect = nfs4_sp4_mach_cred_request;
2031cd1a
WAA		 7615 break;
7616
7617 default:
7618 /* unsupported! */
7619 WARN_ON_ONCE(1);
7620 status = -EINVAL;
6b55970b 7621 goto out_impl_id;
2031cd1a 7622 }
ad0849a7
AA		 7623 if (xprt) {
7624 calldata->xprt = xprt;
7625 task_setup_data.rpc_xprt = xprt;
7626 task_setup_data.flags =
7627 RPC_TASK_SOFT|RPC_TASK_SOFTCONN|RPC_TASK_ASYNC;
7628 calldata->args.verifier = &clp->cl_confirm;
7629 } else {
7630 calldata->args.verifier = &verifier;
7631 }
8d89bd70
AA		 7632 calldata->args.client = clp;
7633#ifdef CONFIG_NFS_V4_1_MIGRATION
7634 calldata->args.flags = EXCHGID4_FLAG_SUPP_MOVED_REFER |
7635 EXCHGID4_FLAG_BIND_PRINC_STATEID |
7636 EXCHGID4_FLAG_SUPP_MOVED_MIGR,
7637#else
7638 calldata->args.flags = EXCHGID4_FLAG_SUPP_MOVED_REFER |
7639 EXCHGID4_FLAG_BIND_PRINC_STATEID,
7640#endif
7641 msg.rpc_argp = &calldata->args;
7642 msg.rpc_resp = &calldata->res;
7643 task_setup_data.callback_data = calldata;
2031cd1a 7644
8d89bd70
AA		 7645 task = rpc_run_task(&task_setup_data);
7646 if (IS_ERR(task)) {
7647 status = PTR_ERR(task);
7648 goto out_impl_id;
6b55970b 7649 }
7d2ed9ac 7650
ad0849a7
AA		 7651 if (!xprt) {
7652 status = rpc_wait_for_completion_task(task);
7653 if (!status)
7654 status = calldata->rpc_status;
7655 } else /* session trunking test */
8d89bd70 7656 status = calldata->rpc_status;
ad0849a7 7657
8d89bd70 7658 rpc_put_task(task);
abe9a6d5 7659out:
177313f1 7660 if (clp->cl_implid != NULL)
6bbb4ae8 7661 dprintk("NFS reply exchange_id: Server Implementation ID: "
7d2ed9ac 7662 "domain: %s, name: %s, date: %llu,%u\n",
6bbb4ae8 7663 clp->cl_implid->domain, clp->cl_implid->name,
59155546
CL		 7664 clp->cl_implid->date.seconds,
7665 clp->cl_implid->date.nseconds);
6bbb4ae8 7666 dprintk("NFS reply exchange_id: %d\n", status);
99fe60d0 7667 return status;
8d89bd70
AA		 7668
7669out_impl_id:
7670 kfree(calldata->res.impl_id);
7671out_server_scope:
7672 kfree(calldata->res.server_scope);
7673out_server_owner:
7674 kfree(calldata->res.server_owner);
7675out_calldata:
7676 kfree(calldata);
7677 goto out;
99fe60d0
BH		 7678}
7679
2031cd1a
WAA		 7680/*
7681 * nfs4_proc_exchange_id()
7682 *
7683 * Returns zero, a negative errno, or a negative NFS4ERR status code.
7684 *
7685 * Since the clientid has expired, all compounds using sessions
7686 * associated with the stale clientid will be returning
7687 * NFS4ERR_BADSESSION in the sequence operation, and will therefore
7688 * be in some phase of session reset.
7689 *
7690 * Will attempt to negotiate SP4_MACH_CRED if krb5i / krb5p auth is used.
7691 */
7692int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred)
7693{
7694 rpc_authflavor_t authflavor = clp->cl_rpcclient->cl_auth->au_flavor;
7695 int status;
7696
7697 /* try SP4_MACH_CRED if krb5i/p */
7698 if (authflavor == RPC_AUTH_GSS_KRB5I ||
7699 authflavor == RPC_AUTH_GSS_KRB5P) {
ad0849a7 7700 status = _nfs4_proc_exchange_id(clp, cred, SP4_MACH_CRED, NULL);
2031cd1a
WAA		 7701 if (!status)
7702 return 0;
7703 }
7704
7705 /* try SP4_NONE */
ad0849a7 7706 return _nfs4_proc_exchange_id(clp, cred, SP4_NONE, NULL);
2031cd1a
WAA		 7707}
7708
04fa2c6b
AA		 7709/**
7710 * nfs4_test_session_trunk
7711 *
7712 * This is an add_xprt_test() test function called from
7713 * rpc_clnt_setup_test_and_add_xprt.
7714 *
7715 * The rpc_xprt_switch is referrenced by rpc_clnt_setup_test_and_add_xprt
7716 * and is dereferrenced in nfs4_exchange_id_release
7717 *
7718 * Upon success, add the new transport to the rpc_clnt
7719 *
7720 * @clnt: struct rpc_clnt to get new transport
7721 * @xprt: the rpc_xprt to test
7722 * @data: call data for _nfs4_proc_exchange_id.
7723 */
7724int nfs4_test_session_trunk(struct rpc_clnt *clnt, struct rpc_xprt *xprt,
7725 void *data)
7726{
7727 struct nfs4_add_xprt_data *adata = (struct nfs4_add_xprt_data *)data;
7728 u32 sp4_how;
7729
7730 dprintk("--> %s try %s\n", __func__,
7731 xprt->address_strings[RPC_DISPLAY_ADDR]);
7732
7733 sp4_how = (adata->clp->cl_sp4_flags == 0 ? SP4_NONE : SP4_MACH_CRED);
7734
7735 /* Test connection for session trunking. Async exchange_id call */
7736 return _nfs4_proc_exchange_id(adata->clp, adata->cred, sp4_how, xprt);
2031cd1a 7737}
04fa2c6b 7738EXPORT_SYMBOL_GPL(nfs4_test_session_trunk);
2031cd1a 7739
66245539
TM		 7740static int _nfs4_proc_destroy_clientid(struct nfs_client *clp,
7741 struct rpc_cred *cred)
7742{
7743 struct rpc_message msg = {
7744 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_CLIENTID],
7745 .rpc_argp = clp,
7746 .rpc_cred = cred,
7747 };
7748 int status;
7749
7750 status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
c6d01c6f 7751 trace_nfs4_destroy_clientid(clp, status);
66245539 7752 if (status)
02c67525 7753 dprintk("NFS: Got error %d from the server %s on "
66245539
TM		 7754 "DESTROY_CLIENTID.", status, clp->cl_hostname);
7755 return status;
7756}
7757
7758static int nfs4_proc_destroy_clientid(struct nfs_client *clp,
7759 struct rpc_cred *cred)
7760{
7761 unsigned int loop;
7762 int ret;
7763
7764 for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) {
7765 ret = _nfs4_proc_destroy_clientid(clp, cred);
7766 switch (ret) {
7767 case -NFS4ERR_DELAY:
7768 case -NFS4ERR_CLIENTID_BUSY:
7769 ssleep(1);
7770 break;
7771 default:
7772 return ret;
7773 }
7774 }
7775 return 0;
7776}
7777
7778int nfs4_destroy_clientid(struct nfs_client *clp)
7779{
7780 struct rpc_cred *cred;
7781 int ret = 0;
7782
7783 if (clp->cl_mvops->minor_version < 1)
7784 goto out;
7785 if (clp->cl_exchange_flags == 0)
7786 goto out;
05f4c350
CL		 7787 if (clp->cl_preserve_clid)
7788 goto out;
73d8bde5 7789 cred = nfs4_get_clid_cred(clp);
66245539
TM		 7790 ret = nfs4_proc_destroy_clientid(clp, cred);
7791 if (cred)
7792 put_rpccred(cred);
7793 switch (ret) {
7794 case 0:
7795 case -NFS4ERR_STALE_CLIENTID:
7796 clp->cl_exchange_flags = 0;
7797 }
7798out:
7799 return ret;
7800}
7801
2050f0cc
AA		 7802struct nfs4_get_lease_time_data {
7803 struct nfs4_get_lease_time_args *args;
7804 struct nfs4_get_lease_time_res *res;
7805 struct nfs_client *clp;
7806};
7807
7808static void nfs4_get_lease_time_prepare(struct rpc_task *task,
7809 void *calldata)
7810{
2050f0cc
AA		 7811 struct nfs4_get_lease_time_data *data =
7812 (struct nfs4_get_lease_time_data *)calldata;
7813
7814 dprintk("--> %s\n", __func__);
7815 /* just setup sequence, do not trigger session recovery
7816 since we're invoked within one */
7981c8a6 7817 nfs4_setup_sequence(data->clp,
d9afbd1b
TM		 7818 &data->args->la_seq_args,
7819 &data->res->lr_seq_res,
7820 task);
2050f0cc
AA		 7821 dprintk("<-- %s\n", __func__);
7822}
7823
7824/*
7825 * Called from nfs4_state_manager thread for session setup, so don't recover
7826 * from sequence operation or clientid errors.
7827 */
7828static void nfs4_get_lease_time_done(struct rpc_task *task, void *calldata)
7829{
7830 struct nfs4_get_lease_time_data *data =
7831 (struct nfs4_get_lease_time_data *)calldata;
7832
7833 dprintk("--> %s\n", __func__);
14516c3a
TM		 7834 if (!nfs41_sequence_done(task, &data->res->lr_seq_res))
7835 return;
2050f0cc
AA		 7836 switch (task->tk_status) {
7837 case -NFS4ERR_DELAY:
7838 case -NFS4ERR_GRACE:
7839 dprintk("%s Retry: tk_status %d\n", __func__, task->tk_status);
7840 rpc_delay(task, NFS4_POLL_RETRY_MIN);
7841 task->tk_status = 0;
a8a4ae3a
AA		 7842 /* fall through */
7843 case -NFS4ERR_RETRY_UNCACHED_REP:
d00c5d43 7844 rpc_restart_call_prepare(task);
2050f0cc
AA		 7845 return;
7846 }
2050f0cc
AA		 7847 dprintk("<-- %s\n", __func__);
7848}
7849
17280175 7850static const struct rpc_call_ops nfs4_get_lease_time_ops = {
2050f0cc
AA		 7851 .rpc_call_prepare = nfs4_get_lease_time_prepare,
7852 .rpc_call_done = nfs4_get_lease_time_done,
7853};
7854
7855int nfs4_proc_get_lease_time(struct nfs_client *clp, struct nfs_fsinfo *fsinfo)
7856{
7857 struct rpc_task *task;
7858 struct nfs4_get_lease_time_args args;
7859 struct nfs4_get_lease_time_res res = {
7860 .lr_fsinfo = fsinfo,
7861 };
7862 struct nfs4_get_lease_time_data data = {
7863 .args = &args,
7864 .res = &res,
7865 .clp = clp,
7866 };
7867 struct rpc_message msg = {
7868 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GET_LEASE_TIME],
7869 .rpc_argp = &args,
7870 .rpc_resp = &res,
7871 };
7872 struct rpc_task_setup task_setup = {
7873 .rpc_client = clp->cl_rpcclient,
7874 .rpc_message = &msg,
7875 .callback_ops = &nfs4_get_lease_time_ops,
1bd714f2
TM		 7876 .callback_data = &data,
7877 .flags = RPC_TASK_TIMEOUT,
2050f0cc
AA		 7878 };
7879 int status;
7880
a9c92d6b 7881 nfs4_init_sequence(&args.la_seq_args, &res.lr_seq_res, 0);
8fe72bac 7882 nfs4_set_sequence_privileged(&args.la_seq_args);
2050f0cc
AA		 7883 dprintk("--> %s\n", __func__);
7884 task = rpc_run_task(&task_setup);
7885
7886 if (IS_ERR(task))
7887 status = PTR_ERR(task);
7888 else {
7889 status = task->tk_status;
7890 rpc_put_task(task);
7891 }
7892 dprintk("<-- %s return %d\n", __func__, status);
7893
7894 return status;
7895}
7896
fc931582
AA		 7897/*
7898 * Initialize the values to be used by the client in CREATE_SESSION
7899 * If nfs4_init_session set the fore channel request and response sizes,
7900 * use them.
7901 *
7902 * Set the back channel max_resp_sz_cached to zero to force the client to
7903 * always set csa_cachethis to FALSE because the current implementation
7904 * of the back channel DRC only supports caching the CB_SEQUENCE operation.
7905 */
6b26cc8c
CL		 7906static void nfs4_init_channel_attrs(struct nfs41_create_session_args *args,
7907 struct rpc_clnt *clnt)
fc931582 7908{
18aad3d5 7909 unsigned int max_rqst_sz, max_resp_sz;
6b26cc8c 7910 unsigned int max_bc_payload = rpc_max_bc_payload(clnt);
18aad3d5
AA		 7911
7912 max_rqst_sz = NFS_MAX_FILE_IO_SIZE + nfs41_maxwrite_overhead;
7913 max_resp_sz = NFS_MAX_FILE_IO_SIZE + nfs41_maxread_overhead;
fc931582 7914
fc931582 7915 /* Fore channel attributes */
18aad3d5
AA		 7916 args->fc_attrs.max_rqst_sz = max_rqst_sz;
7917 args->fc_attrs.max_resp_sz = max_resp_sz;
fc931582 7918 args->fc_attrs.max_ops = NFS4_MAX_OPS;
ef159e91 7919 args->fc_attrs.max_reqs = max_session_slots;
fc931582
AA		 7920
7921 dprintk("%s: Fore Channel : max_rqst_sz=%u max_resp_sz=%u "
8e0d46e1 7922 "max_ops=%u max_reqs=%u\n",
fc931582
AA		 7923 __func__,
7924 args->fc_attrs.max_rqst_sz, args->fc_attrs.max_resp_sz,
8e0d46e1 7925 args->fc_attrs.max_ops, args->fc_attrs.max_reqs);
fc931582
AA		 7926
7927 /* Back channel attributes */
6b26cc8c
CL		 7928 args->bc_attrs.max_rqst_sz = max_bc_payload;
7929 args->bc_attrs.max_resp_sz = max_bc_payload;
fc931582
AA		 7930 args->bc_attrs.max_resp_sz_cached = 0;
7931 args->bc_attrs.max_ops = NFS4_MAX_BACK_CHANNEL_OPS;
5405fc44 7932 args->bc_attrs.max_reqs = min_t(unsigned short, max_session_cb_slots, 1);
fc931582
AA		 7933
7934 dprintk("%s: Back Channel : max_rqst_sz=%u max_resp_sz=%u "
7935 "max_resp_sz_cached=%u max_ops=%u max_reqs=%u\n",
7936 __func__,
7937 args->bc_attrs.max_rqst_sz, args->bc_attrs.max_resp_sz,
7938 args->bc_attrs.max_resp_sz_cached, args->bc_attrs.max_ops,
7939 args->bc_attrs.max_reqs);
7940}
7941
79969dd1
TM		 7942static int nfs4_verify_fore_channel_attrs(struct nfs41_create_session_args *args,
7943 struct nfs41_create_session_res *res)
8d35301d 7944{
43c2e885 7945 struct nfs4_channel_attrs *sent = &args->fc_attrs;
79969dd1 7946 struct nfs4_channel_attrs *rcvd = &res->fc_attrs;
43c2e885 7947
43c2e885
BF		 7948 if (rcvd->max_resp_sz > sent->max_resp_sz)
7949 return -EINVAL;
7950 /*
7951 * Our requested max_ops is the minimum we need; we're not
7952 * prepared to break up compounds into smaller pieces than that.
7953 * So, no point even trying to continue if the server won't
7954 * cooperate:
7955 */
7956 if (rcvd->max_ops < sent->max_ops)
7957 return -EINVAL;
7958 if (rcvd->max_reqs == 0)
7959 return -EINVAL;
b4b9a0c1
VG		 7960 if (rcvd->max_reqs > NFS4_MAX_SLOT_TABLE)
7961 rcvd->max_reqs = NFS4_MAX_SLOT_TABLE;
43c2e885 7962 return 0;
8d35301d
AA		 7963}
7964
79969dd1
TM		 7965static int nfs4_verify_back_channel_attrs(struct nfs41_create_session_args *args,
7966 struct nfs41_create_session_res *res)
43c2e885
BF		 7967{
7968 struct nfs4_channel_attrs *sent = &args->bc_attrs;
79969dd1 7969 struct nfs4_channel_attrs *rcvd = &res->bc_attrs;
8d35301d 7970
b1c0df5f
TM		 7971 if (!(res->flags & SESSION4_BACK_CHAN))
7972 goto out;
43c2e885
BF		 7973 if (rcvd->max_rqst_sz > sent->max_rqst_sz)
7974 return -EINVAL;
7975 if (rcvd->max_resp_sz < sent->max_resp_sz)
7976 return -EINVAL;
7977 if (rcvd->max_resp_sz_cached > sent->max_resp_sz_cached)
7978 return -EINVAL;
5405fc44 7979 if (rcvd->max_ops > sent->max_ops)
43c2e885 7980 return -EINVAL;
5405fc44 7981 if (rcvd->max_reqs > sent->max_reqs)
43c2e885 7982 return -EINVAL;
b1c0df5f 7983out:
43c2e885
BF		 7984 return 0;
7985}
8d35301d 7986
8d35301d 7987static int nfs4_verify_channel_attrs(struct nfs41_create_session_args *args,
79969dd1 7988 struct nfs41_create_session_res *res)
8d35301d 7989{
43c2e885 7990 int ret;
8d35301d 7991
79969dd1 7992 ret = nfs4_verify_fore_channel_attrs(args, res);
43c2e885
BF		 7993 if (ret)
7994 return ret;
79969dd1
TM		 7995 return nfs4_verify_back_channel_attrs(args, res);
7996}
7997
7998static void nfs4_update_session(struct nfs4_session *session,
7999 struct nfs41_create_session_res *res)
8000{
8001 nfs4_copy_sessionid(&session->sess_id, &res->sessionid);
e11259f9
TM		 8002 /* Mark client id and session as being confirmed */
8003 session->clp->cl_exchange_flags |= EXCHGID4_FLAG_CONFIRMED_R;
8004 set_bit(NFS4_SESSION_ESTABLISHED, &session->session_state);
79969dd1
TM		 8005 session->flags = res->flags;
8006 memcpy(&session->fc_attrs, &res->fc_attrs, sizeof(session->fc_attrs));
b1c0df5f
TM		 8007 if (res->flags & SESSION4_BACK_CHAN)
8008 memcpy(&session->bc_attrs, &res->bc_attrs,
8009 sizeof(session->bc_attrs));
8d35301d
AA		 8010}
8011
848f5bda
TM		 8012static int _nfs4_proc_create_session(struct nfs_client *clp,
8013 struct rpc_cred *cred)
fc931582
AA		 8014{
8015 struct nfs4_session *session = clp->cl_session;
8016 struct nfs41_create_session_args args = {
8017 .client = clp,
79969dd1
TM		 8018 .clientid = clp->cl_clientid,
8019 .seqid = clp->cl_seqid,
fc931582
AA		 8020 .cb_program = NFS4_CALLBACK,
8021 };
79969dd1
TM		 8022 struct nfs41_create_session_res res;
8023
fc931582
AA		 8024 struct rpc_message msg = {
8025 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE_SESSION],
8026 .rpc_argp = &args,
8027 .rpc_resp = &res,
848f5bda 8028 .rpc_cred = cred,
fc931582
AA		 8029 };
8030 int status;
8031
6b26cc8c 8032 nfs4_init_channel_attrs(&args, clp->cl_rpcclient);
0f91421e 8033 args.flags = (SESSION4_PERSIST | SESSION4_BACK_CHAN);
fc931582 8034
1bd714f2 8035 status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
c6d01c6f 8036 trace_nfs4_create_session(clp, status);
fc931582 8037
b519d408
TM		 8038 switch (status) {
8039 case -NFS4ERR_STALE_CLIENTID:
8040 case -NFS4ERR_DELAY:
8041 case -ETIMEDOUT:
8042 case -EACCES:
8043 case -EAGAIN:
8044 goto out;
8045 };
8046
8047 clp->cl_seqid++;
43095d39 8048 if (!status) {
8d35301d 8049 /* Verify the session's negotiated channel_attrs values */
79969dd1 8050 status = nfs4_verify_channel_attrs(&args, &res);
fc931582 8051 /* Increment the clientid slot sequence id */
79969dd1
TM		 8052 if (status)
8053 goto out;
8054 nfs4_update_session(session, &res);
fc931582 8055 }
79969dd1 8056out:
fc931582
AA		 8057 return status;
8058}
8059
8060/*
8061 * Issues a CREATE_SESSION operation to the server.
8062 * It is the responsibility of the caller to verify the session is
8063 * expired before calling this routine.
8064 */
848f5bda 8065int nfs4_proc_create_session(struct nfs_client *clp, struct rpc_cred *cred)
fc931582
AA		 8066{
8067 int status;
8068 unsigned *ptr;
fc931582
AA		 8069 struct nfs4_session *session = clp->cl_session;
8070
8071 dprintk("--> %s clp=%p session=%p\n", __func__, clp, session);
8072
848f5bda 8073 status = _nfs4_proc_create_session(clp, cred);
fc931582
AA		 8074 if (status)
8075 goto out;
8076
aacd5537
AA		 8077 /* Init or reset the session slot tables */
8078 status = nfs4_setup_session_slot_tables(session);
8079 dprintk("slot table setup returned %d\n", status);
fc931582
AA		 8080 if (status)
8081 goto out;
8082
8083 ptr = (unsigned *)&session->sess_id.data[0];
8084 dprintk("%s client>seqid %d sessionid %u:%u:%u:%u\n", __func__,
8085 clp->cl_seqid, ptr[0], ptr[1], ptr[2], ptr[3]);
fc931582
AA		 8086out:
8087 dprintk("<-- %s\n", __func__);
8088 return status;
8089}
8090
0f3e66c6
AA		 8091/*
8092 * Issue the over-the-wire RPC DESTROY_SESSION.
8093 * The caller must serialize access to this routine.
8094 */
848f5bda
TM		 8095int nfs4_proc_destroy_session(struct nfs4_session *session,
8096 struct rpc_cred *cred)
0f3e66c6 8097{
848f5bda
TM		 8098 struct rpc_message msg = {
8099 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_SESSION],
8100 .rpc_argp = session,
8101 .rpc_cred = cred,
8102 };
0f3e66c6 8103 int status = 0;
0f3e66c6
AA		 8104
8105 dprintk("--> nfs4_proc_destroy_session\n");
8106
8107 /* session is still being setup */
e11259f9
TM		 8108 if (!test_and_clear_bit(NFS4_SESSION_ESTABLISHED, &session->session_state))
8109 return 0;
0f3e66c6 8110
1bd714f2 8111 status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
c6d01c6f 8112 trace_nfs4_destroy_session(session->clp, status);
0f3e66c6
AA		 8113
8114 if (status)
08106ac7 8115 dprintk("NFS: Got error %d from the server on DESTROY_SESSION. "
0f3e66c6
AA		 8116 "Session has been destroyed regardless...\n", status);
8117
8118 dprintk("<-- nfs4_proc_destroy_session\n");
8119 return status;
8120}
8121
fc01cea9
AA		 8122/*
8123 * Renew the cl_session lease.
8124 */
d5f8d3fe
TM		 8125struct nfs4_sequence_data {
8126 struct nfs_client *clp;
8127 struct nfs4_sequence_args args;
8128 struct nfs4_sequence_res res;
8129};
8130
dc96aef9
AB		 8131static void nfs41_sequence_release(void *data)
8132{
d5f8d3fe
TM		 8133 struct nfs4_sequence_data *calldata = data;
8134 struct nfs_client *clp = calldata->clp;
dc96aef9 8135
7135840f
AB		 8136 if (atomic_read(&clp->cl_count) > 1)
8137 nfs4_schedule_state_renewal(clp);
8138 nfs_put_client(clp);
d5f8d3fe 8139 kfree(calldata);
dc96aef9
AB		 8140}
8141
aa5190d0
TM		 8142static int nfs41_sequence_handle_errors(struct rpc_task *task, struct nfs_client *clp)
8143{
8144 switch(task->tk_status) {
8145 case -NFS4ERR_DELAY:
aa5190d0
TM		 8146 rpc_delay(task, NFS4_POLL_RETRY_MAX);
8147 return -EAGAIN;
8148 default:
0400a6b0 8149 nfs4_schedule_lease_recovery(clp);
aa5190d0
TM		 8150 }
8151 return 0;
8152}
8153
dc96aef9 8154static void nfs41_sequence_call_done(struct rpc_task *task, void *data)
fc01cea9 8155{
d5f8d3fe
TM		 8156 struct nfs4_sequence_data *calldata = data;
8157 struct nfs_client *clp = calldata->clp;
fc01cea9 8158
14516c3a
TM		 8159 if (!nfs41_sequence_done(task, task->tk_msg.rpc_resp))
8160 return;
fc01cea9 8161
c6d01c6f 8162 trace_nfs4_sequence(clp, task->tk_status);
fc01cea9
AA		 8163 if (task->tk_status < 0) {
8164 dprintk("%s ERROR %d\n", __func__, task->tk_status);
7135840f
AB		 8165 if (atomic_read(&clp->cl_count) == 1)
8166 goto out;
fc01cea9 8167
aa5190d0
TM		 8168 if (nfs41_sequence_handle_errors(task, clp) == -EAGAIN) {
8169 rpc_restart_call_prepare(task);
fc01cea9
AA		 8170 return;
8171 }
8172 }
fc01cea9 8173 dprintk("%s rpc_cred %p\n", __func__, task->tk_msg.rpc_cred);
7135840f 8174out:
fc01cea9
AA		 8175 dprintk("<-- %s\n", __func__);
8176}
8177
8178static void nfs41_sequence_prepare(struct rpc_task *task, void *data)
8179{
d5f8d3fe
TM		 8180 struct nfs4_sequence_data *calldata = data;
8181 struct nfs_client *clp = calldata->clp;
fc01cea9
AA		 8182 struct nfs4_sequence_args *args;
8183 struct nfs4_sequence_res *res;
8184
fc01cea9
AA		 8185 args = task->tk_msg.rpc_argp;
8186 res = task->tk_msg.rpc_resp;
8187
7981c8a6 8188 nfs4_setup_sequence(clp, args, res, task);
fc01cea9
AA		 8189}
8190
8191static const struct rpc_call_ops nfs41_sequence_ops = {
8192 .rpc_call_done = nfs41_sequence_call_done,
8193 .rpc_call_prepare = nfs41_sequence_prepare,
dc96aef9 8194 .rpc_release = nfs41_sequence_release,
fc01cea9
AA		 8195};
8196
8fe72bac
TM		 8197static struct rpc_task *_nfs41_proc_sequence(struct nfs_client *clp,
8198 struct rpc_cred *cred,
8199 bool is_privileged)
fc01cea9 8200{
d5f8d3fe 8201 struct nfs4_sequence_data *calldata;
fc01cea9
AA		 8202 struct rpc_message msg = {
8203 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SEQUENCE],
8204 .rpc_cred = cred,
8205 };
71ac6da9
TM		 8206 struct rpc_task_setup task_setup_data = {
8207 .rpc_client = clp->cl_rpcclient,
8208 .rpc_message = &msg,
8fe72bac 8209 .callback_ops = &nfs41_sequence_ops,
bc7a05ca 8210 .flags = RPC_TASK_ASYNC | RPC_TASK_TIMEOUT,
71ac6da9 8211 };
fc01cea9 8212
7135840f 8213 if (!atomic_inc_not_zero(&clp->cl_count))
71ac6da9 8214 return ERR_PTR(-EIO);
dfb4f309 8215 calldata = kzalloc(sizeof(*calldata), GFP_NOFS);
d5f8d3fe 8216 if (calldata == NULL) {
7135840f 8217 nfs_put_client(clp);
71ac6da9 8218 return ERR_PTR(-ENOMEM);
fc01cea9 8219 }
a9c92d6b 8220 nfs4_init_sequence(&calldata->args, &calldata->res, 0);
8fe72bac
TM		 8221 if (is_privileged)
8222 nfs4_set_sequence_privileged(&calldata->args);
d5f8d3fe
TM		 8223 msg.rpc_argp = &calldata->args;
8224 msg.rpc_resp = &calldata->res;
8225 calldata->clp = clp;
71ac6da9 8226 task_setup_data.callback_data = calldata;
fc01cea9 8227
71ac6da9
TM		 8228 return rpc_run_task(&task_setup_data);
8229}
8230
2f60ea6b 8231static int nfs41_proc_async_sequence(struct nfs_client *clp, struct rpc_cred *cred, unsigned renew_flags)
71ac6da9
TM		 8232{
8233 struct rpc_task *task;
8234 int ret = 0;
8235
2f60ea6b 8236 if ((renew_flags & NFS4_RENEW_TIMEOUT) == 0)
d1f456b0 8237 return -EAGAIN;
8fe72bac 8238 task = _nfs41_proc_sequence(clp, cred, false);
71ac6da9
TM		 8239 if (IS_ERR(task))
8240 ret = PTR_ERR(task);
8241 else
bf294b41 8242 rpc_put_task_async(task);
71ac6da9
TM		 8243 dprintk("<-- %s status=%d\n", __func__, ret);
8244 return ret;
8245}
8246
8247static int nfs4_proc_sequence(struct nfs_client *clp, struct rpc_cred *cred)
8248{
8249 struct rpc_task *task;
8250 int ret;
8251
8fe72bac 8252 task = _nfs41_proc_sequence(clp, cred, true);
71ac6da9
TM		 8253 if (IS_ERR(task)) {
8254 ret = PTR_ERR(task);
8255 goto out;
8256 }
8257 ret = rpc_wait_for_completion_task(task);
be824167 8258 if (!ret)
71ac6da9
TM		 8259 ret = task->tk_status;
8260 rpc_put_task(task);
8261out:
8262 dprintk("<-- %s status=%d\n", __func__, ret);
8263 return ret;
fc01cea9
AA		 8264}
8265
fce5c838
RL		 8266struct nfs4_reclaim_complete_data {
8267 struct nfs_client *clp;
8268 struct nfs41_reclaim_complete_args arg;
8269 struct nfs41_reclaim_complete_res res;
8270};
8271
8272static void nfs4_reclaim_complete_prepare(struct rpc_task *task, void *data)
8273{
8274 struct nfs4_reclaim_complete_data *calldata = data;
8275
7981c8a6 8276 nfs4_setup_sequence(calldata->clp,
d9afbd1b
TM		 8277 &calldata->arg.seq_args,
8278 &calldata->res.seq_res,
8279 task);
fce5c838
RL		 8280}
8281
aa5190d0
TM		 8282static int nfs41_reclaim_complete_handle_errors(struct rpc_task *task, struct nfs_client *clp)
8283{
8284 switch(task->tk_status) {
8285 case 0:
8286 case -NFS4ERR_COMPLETE_ALREADY:
8287 case -NFS4ERR_WRONG_CRED: /* What to do here? */
8288 break;
8289 case -NFS4ERR_DELAY:
aa5190d0 8290 rpc_delay(task, NFS4_POLL_RETRY_MAX);
a8a4ae3a
AA		 8291 /* fall through */
8292 case -NFS4ERR_RETRY_UNCACHED_REP:
aa5190d0
TM		 8293 return -EAGAIN;
8294 default:
0400a6b0 8295 nfs4_schedule_lease_recovery(clp);
aa5190d0
TM		 8296 }
8297 return 0;
8298}
8299
fce5c838
RL		 8300static void nfs4_reclaim_complete_done(struct rpc_task *task, void *data)
8301{
8302 struct nfs4_reclaim_complete_data *calldata = data;
8303 struct nfs_client *clp = calldata->clp;
8304 struct nfs4_sequence_res *res = &calldata->res.seq_res;
8305
8306 dprintk("--> %s\n", __func__);
14516c3a
TM		 8307 if (!nfs41_sequence_done(task, res))
8308 return;
fce5c838 8309
c6d01c6f 8310 trace_nfs4_reclaim_complete(clp, task->tk_status);
aa5190d0
TM		 8311 if (nfs41_reclaim_complete_handle_errors(task, clp) == -EAGAIN) {
8312 rpc_restart_call_prepare(task);
8313 return;
8314 }
fce5c838
RL		 8315 dprintk("<-- %s\n", __func__);
8316}
8317
8318static void nfs4_free_reclaim_complete_data(void *data)
8319{
8320 struct nfs4_reclaim_complete_data *calldata = data;
8321
8322 kfree(calldata);
8323}
8324
8325static const struct rpc_call_ops nfs4_reclaim_complete_call_ops = {
8326 .rpc_call_prepare = nfs4_reclaim_complete_prepare,
8327 .rpc_call_done = nfs4_reclaim_complete_done,
8328 .rpc_release = nfs4_free_reclaim_complete_data,
8329};
8330
8331/*
8332 * Issue a global reclaim complete.
8333 */
965e9c23
TM		 8334static int nfs41_proc_reclaim_complete(struct nfs_client *clp,
8335 struct rpc_cred *cred)
fce5c838
RL		 8336{
8337 struct nfs4_reclaim_complete_data *calldata;
8338 struct rpc_task *task;
8339 struct rpc_message msg = {
8340 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RECLAIM_COMPLETE],
965e9c23 8341 .rpc_cred = cred,
fce5c838
RL		 8342 };
8343 struct rpc_task_setup task_setup_data = {
8344 .rpc_client = clp->cl_rpcclient,
8345 .rpc_message = &msg,
8346 .callback_ops = &nfs4_reclaim_complete_call_ops,
8347 .flags = RPC_TASK_ASYNC,
8348 };
8349 int status = -ENOMEM;
8350
8351 dprintk("--> %s\n", __func__);
8535b2be 8352 calldata = kzalloc(sizeof(*calldata), GFP_NOFS);
fce5c838
RL		 8353 if (calldata == NULL)
8354 goto out;
8355 calldata->clp = clp;
8356 calldata->arg.one_fs = 0;
fce5c838 8357
a9c92d6b 8358 nfs4_init_sequence(&calldata->arg.seq_args, &calldata->res.seq_res, 0);
8fe72bac 8359 nfs4_set_sequence_privileged(&calldata->arg.seq_args);
fce5c838
RL		 8360 msg.rpc_argp = &calldata->arg;
8361 msg.rpc_resp = &calldata->res;
8362 task_setup_data.callback_data = calldata;
8363 task = rpc_run_task(&task_setup_data);
acf82b85 8364 if (IS_ERR(task)) {
fce5c838 8365 status = PTR_ERR(task);
acf82b85
DC		 8366 goto out;
8367 }
c34c32ea
AA		 8368 status = nfs4_wait_for_completion_rpc_task(task);
8369 if (status == 0)
8370 status = task->tk_status;
fce5c838 8371 rpc_put_task(task);
acf82b85 8372 return 0;
fce5c838
RL		 8373out:
8374 dprintk("<-- %s status=%d\n", __func__, status);
8375 return status;
8376}
b1f69b75
AA		 8377
8378static void
8379nfs4_layoutget_prepare(struct rpc_task *task, void *calldata)
8380{
8381 struct nfs4_layoutget *lgp = calldata;
c31663d4 8382 struct nfs_server *server = NFS_SERVER(lgp->args.inode);
b1f69b75
AA		 8383
8384 dprintk("--> %s\n", __func__);
7981c8a6 8385 nfs4_setup_sequence(server->nfs_client, &lgp->args.seq_args,
183d9e7b
JL		 8386 &lgp->res.seq_res, task);
8387 dprintk("<-- %s\n", __func__);
b1f69b75
AA		 8388}
8389
8390static void nfs4_layoutget_done(struct rpc_task *task, void *calldata)
8391{
8392 struct nfs4_layoutget *lgp = calldata;
183d9e7b
JL		 8393
8394 dprintk("--> %s\n", __func__);
2e80dbe7 8395 nfs41_sequence_process(task, &lgp->res.seq_res);
183d9e7b
JL		 8396 dprintk("<-- %s\n", __func__);
8397}
8398
8399static int
8400nfs4_layoutget_handle_exception(struct rpc_task *task,
8401 struct nfs4_layoutget *lgp, struct nfs4_exception *exception)
8402{
ee314c2a
TM		 8403 struct inode *inode = lgp->args.inode;
8404 struct nfs_server *server = NFS_SERVER(inode);
8405 struct pnfs_layout_hdr *lo;
e85d7ee4
TM		 8406 int nfs4err = task->tk_status;
8407 int err, status = 0;
f7db0b28 8408 LIST_HEAD(head);
b1f69b75 8409
ed7e5423 8410 dprintk("--> %s tk_status => %d\n", __func__, -task->tk_status);
b1f69b75 8411
e85d7ee4 8412 switch (nfs4err) {
b1f69b75 8413 case 0:
ee314c2a 8414 goto out;
7c1e6e58
PT		 8415
8416 /*
8417 * NFS4ERR_LAYOUTUNAVAILABLE means we are not supposed to use pnfs
8418 * on the file. set tk_status to -ENODATA to tell upper layer to
8419 * retry go inband.
8420 */
8421 case -NFS4ERR_LAYOUTUNAVAILABLE:
183d9e7b 8422 status = -ENODATA;
7c1e6e58 8423 goto out;
21b874c8
TM		 8424 /*
8425 * NFS4ERR_BADLAYOUT means the MDS cannot return a layout of
8426 * length lgp->args.minlength != 0 (see RFC5661 section 18.43.3).
8427 */
8428 case -NFS4ERR_BADLAYOUT:
183d9e7b
JL		 8429 status = -EOVERFLOW;
8430 goto out;
ed7e5423
BH		 8431 /*
8432 * NFS4ERR_LAYOUTTRYLATER is a conflict with another client
21b874c8
TM		 8433 * (or clients) writing to the same RAID stripe except when
8434 * the minlength argument is 0 (see RFC5661 section 18.43.3).
183d9e7b
JL		 8435 *
8436 * Treat it like we would RECALLCONFLICT -- we retry for a little
8437 * while, and then eventually give up.
ed7e5423 8438 */
b1f69b75 8439 case -NFS4ERR_LAYOUTTRYLATER:
183d9e7b
JL		 8440 if (lgp->args.minlength == 0) {
8441 status = -EOVERFLOW;
8442 goto out;
ed7e5423 8443 }
e85d7ee4
TM		 8444 status = -EBUSY;
8445 break;
183d9e7b 8446 case -NFS4ERR_RECALLCONFLICT:
183d9e7b 8447 status = -ERECALLCONFLICT;
e85d7ee4 8448 break;
26f47443
TM		 8449 case -NFS4ERR_DELEG_REVOKED:
8450 case -NFS4ERR_ADMIN_REVOKED:
ee314c2a
TM		 8451 case -NFS4ERR_EXPIRED:
8452 case -NFS4ERR_BAD_STATEID:
183d9e7b 8453 exception->timeout = 0;
ee314c2a 8454 spin_lock(&inode->i_lock);
f7db0b28
TM		 8455 lo = NFS_I(inode)->layout;
8456 /* If the open stateid was bad, then recover it. */
8457 if (!lo || test_bit(NFS_LAYOUT_INVALID_STID, &lo->plh_flags) ||
8458 nfs4_stateid_match_other(&lgp->args.stateid,
2259f960 8459 &lgp->args.ctx->state->stateid)) {
ee314c2a 8460 spin_unlock(&inode->i_lock);
183d9e7b 8461 exception->state = lgp->args.ctx->state;
26f47443 8462 exception->stateid = &lgp->args.stateid;
2259f960
TM		 8463 break;
8464 }
f7db0b28
TM		 8465
8466 /*
8467 * Mark the bad layout state as invalid, then retry
8468 */
668f455d 8469 pnfs_mark_layout_stateid_invalid(lo, &head);
f7db0b28
TM		 8470 spin_unlock(&inode->i_lock);
8471 pnfs_free_lseg_list(&head);
8472 status = -EAGAIN;
8473 goto out;
b1f69b75 8474 }
183d9e7b 8475
8ac09251 8476 nfs4_sequence_free_slot(&lgp->res.seq_res);
e85d7ee4
TM		 8477 err = nfs4_handle_exception(server, nfs4err, exception);
8478 if (!status) {
8479 if (exception->retry)
8480 status = -EAGAIN;
8481 else
8482 status = err;
8483 }
ee314c2a 8484out:
b1f69b75 8485 dprintk("<-- %s\n", __func__);
183d9e7b 8486 return status;
b1f69b75
AA		 8487}
8488
8554116e
IK		 8489static size_t max_response_pages(struct nfs_server *server)
8490{
8491 u32 max_resp_sz = server->nfs_client->cl_session->fc_attrs.max_resp_sz;
8492 return nfs_page_array_len(0, max_resp_sz);
8493}
8494
8495static void nfs4_free_pages(struct page **pages, size_t size)
8496{
8497 int i;
8498
8499 if (!pages)
8500 return;
8501
8502 for (i = 0; i < size; i++) {
8503 if (!pages[i])
8504 break;
8505 __free_page(pages[i]);
8506 }
8507 kfree(pages);
8508}
8509
8510static struct page **nfs4_alloc_pages(size_t size, gfp_t gfp_flags)
8511{
8512 struct page **pages;
8513 int i;
8514
8515 pages = kcalloc(size, sizeof(struct page *), gfp_flags);
8516 if (!pages) {
8517 dprintk("%s: can't alloc array of %zu pages\n", __func__, size);
8518 return NULL;
8519 }
8520
8521 for (i = 0; i < size; i++) {
8522 pages[i] = alloc_page(gfp_flags);
8523 if (!pages[i]) {
8524 dprintk("%s: failed to allocate page\n", __func__);
8525 nfs4_free_pages(pages, size);
8526 return NULL;
8527 }
8528 }
8529
8530 return pages;
8531}
8532
b1f69b75
AA		 8533static void nfs4_layoutget_release(void *calldata)
8534{
8535 struct nfs4_layoutget *lgp = calldata;
a47970ff
WAA		 8536 struct inode *inode = lgp->args.inode;
8537 struct nfs_server *server = NFS_SERVER(inode);
8554116e 8538 size_t max_pages = max_response_pages(server);
b1f69b75
AA		 8539
8540 dprintk("--> %s\n", __func__);
8554116e 8541 nfs4_free_pages(lgp->args.layout.pages, max_pages);
a47970ff 8542 pnfs_put_layout_hdr(NFS_I(inode)->layout);
b1f69b75
AA		 8543 put_nfs_open_context(lgp->args.ctx);
8544 kfree(calldata);
8545 dprintk("<-- %s\n", __func__);
8546}
8547
8548static const struct rpc_call_ops nfs4_layoutget_call_ops = {
8549 .rpc_call_prepare = nfs4_layoutget_prepare,
8550 .rpc_call_done = nfs4_layoutget_done,
8551 .rpc_release = nfs4_layoutget_release,
8552};
8553
a0b0a6e3 8554struct pnfs_layout_segment *
183d9e7b 8555nfs4_proc_layoutget(struct nfs4_layoutget *lgp, long *timeout, gfp_t gfp_flags)
b1f69b75 8556{
a47970ff
WAA		 8557 struct inode *inode = lgp->args.inode;
8558 struct nfs_server *server = NFS_SERVER(inode);
8554116e 8559 size_t max_pages = max_response_pages(server);
b1f69b75
AA		 8560 struct rpc_task *task;
8561 struct rpc_message msg = {
8562 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTGET],
8563 .rpc_argp = &lgp->args,
8564 .rpc_resp = &lgp->res,
6ab59344 8565 .rpc_cred = lgp->cred,
b1f69b75
AA		 8566 };
8567 struct rpc_task_setup task_setup_data = {
8568 .rpc_client = server->client,
8569 .rpc_message = &msg,
8570 .callback_ops = &nfs4_layoutget_call_ops,
8571 .callback_data = lgp,
8572 .flags = RPC_TASK_ASYNC,
8573 };
a0b0a6e3 8574 struct pnfs_layout_segment *lseg = NULL;
bc23676c
TM		 8575 struct nfs4_exception exception = {
8576 .inode = inode,
8577 .timeout = *timeout,
8578 };
b1f69b75
AA		 8579 int status = 0;
8580
8581 dprintk("--> %s\n", __func__);
8582
4bd5a980
PT		 8583 /* nfs4_layoutget_release calls pnfs_put_layout_hdr */
8584 pnfs_get_layout_hdr(NFS_I(inode)->layout);
8585
8554116e
IK		 8586 lgp->args.layout.pages = nfs4_alloc_pages(max_pages, gfp_flags);
8587 if (!lgp->args.layout.pages) {
8588 nfs4_layoutget_release(lgp);
a0b0a6e3 8589 return ERR_PTR(-ENOMEM);
8554116e
IK		 8590 }
8591 lgp->args.layout.pglen = max_pages * PAGE_SIZE;
8592
35124a09 8593 lgp->res.layoutp = &lgp->args.layout;
b1f69b75 8594 lgp->res.seq_res.sr_slot = NULL;
a9c92d6b 8595 nfs4_init_sequence(&lgp->args.seq_args, &lgp->res.seq_res, 0);
a47970ff 8596
b1f69b75
AA		 8597 task = rpc_run_task(&task_setup_data);
8598 if (IS_ERR(task))
a0b0a6e3 8599 return ERR_CAST(task);
b1f69b75 8600 status = nfs4_wait_for_completion_rpc_task(task);
183d9e7b
JL		 8601 if (status == 0) {
8602 status = nfs4_layoutget_handle_exception(task, lgp, &exception);
8603 *timeout = exception.timeout;
8604 }
8605
1037e6ea
TM		 8606 trace_nfs4_layoutget(lgp->args.ctx,
8607 &lgp->args.range,
8608 &lgp->res.range,
48c9579a 8609 &lgp->res.stateid,
1037e6ea 8610 status);
183d9e7b 8611
085b7a45
WAA		 8612 /* if layoutp->len is 0, nfs4_layoutget_prepare called rpc_exit */
8613 if (status == 0 && lgp->res.layoutp->len)
a0b0a6e3 8614 lseg = pnfs_layout_process(lgp);
2e80dbe7 8615 nfs4_sequence_free_slot(&lgp->res.seq_res);
b1f69b75
AA		 8616 rpc_put_task(task);
8617 dprintk("<-- %s status=%d\n", __func__, status);
a0b0a6e3
TM		 8618 if (status)
8619 return ERR_PTR(status);
8620 return lseg;
b1f69b75
AA		 8621}
8622
cbe82603
BH		 8623static void
8624nfs4_layoutreturn_prepare(struct rpc_task *task, void *calldata)
8625{
8626 struct nfs4_layoutreturn *lrp = calldata;
8627
8628 dprintk("--> %s\n", __func__);
7981c8a6 8629 nfs4_setup_sequence(lrp->clp,
d9afbd1b
TM		 8630 &lrp->args.seq_args,
8631 &lrp->res.seq_res,
8632 task);
cbe82603
BH		 8633}
8634
8635static void nfs4_layoutreturn_done(struct rpc_task *task, void *calldata)
8636{
8637 struct nfs4_layoutreturn *lrp = calldata;
8638 struct nfs_server *server;
8639
8640 dprintk("--> %s\n", __func__);
8641
2e80dbe7 8642 if (!nfs41_sequence_process(task, &lrp->res.seq_res))
cbe82603
BH		 8643 return;
8644
8645 server = NFS_SERVER(lrp->args.inode);
f22e5edd
TM		 8646 switch (task->tk_status) {
8647 default:
8648 task->tk_status = 0;
8649 case 0:
8650 break;
8651 case -NFS4ERR_DELAY:
8478eaa1 8652 if (nfs4_async_handle_error(task, server, NULL, NULL) != -EAGAIN)
f22e5edd 8653 break;
2e80dbe7 8654 nfs4_sequence_free_slot(&lrp->res.seq_res);
d00c5d43 8655 rpc_restart_call_prepare(task);
cbe82603
BH		 8656 return;
8657 }
cbe82603
BH		 8658 dprintk("<-- %s\n", __func__);
8659}
8660
8661static void nfs4_layoutreturn_release(void *calldata)
8662{
8663 struct nfs4_layoutreturn *lrp = calldata;
849b286f 8664 struct pnfs_layout_hdr *lo = lrp->args.layout;
cbe82603
BH		 8665
8666 dprintk("--> %s\n", __func__);
2a974425 8667 pnfs_layoutreturn_free_lsegs(lo, &lrp->args.stateid, &lrp->args.range,
68f74479 8668 lrp->res.lrs_present ? &lrp->res.stateid : NULL);
2e80dbe7 8669 nfs4_sequence_free_slot(&lrp->res.seq_res);
4d796d75
TM		 8670 if (lrp->ld_private.ops && lrp->ld_private.ops->free)
8671 lrp->ld_private.ops->free(&lrp->ld_private);
2f065ddb
TM		 8672 pnfs_put_layout_hdr(lrp->args.layout);
8673 nfs_iput_and_deactive(lrp->inode);
cbe82603
BH		 8674 kfree(calldata);
8675 dprintk("<-- %s\n", __func__);
8676}
8677
8678static const struct rpc_call_ops nfs4_layoutreturn_call_ops = {
8679 .rpc_call_prepare = nfs4_layoutreturn_prepare,
8680 .rpc_call_done = nfs4_layoutreturn_done,
8681 .rpc_release = nfs4_layoutreturn_release,
8682};
8683
6c16605d 8684int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp, bool sync)
cbe82603
BH		 8685{
8686 struct rpc_task *task;
8687 struct rpc_message msg = {
8688 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTRETURN],
8689 .rpc_argp = &lrp->args,
8690 .rpc_resp = &lrp->res,
9556000d 8691 .rpc_cred = lrp->cred,
cbe82603
BH		 8692 };
8693 struct rpc_task_setup task_setup_data = {
1771c577 8694 .rpc_client = NFS_SERVER(lrp->args.inode)->client,
cbe82603
BH		 8695 .rpc_message = &msg,
8696 .callback_ops = &nfs4_layoutreturn_call_ops,
8697 .callback_data = lrp,
8698 };
6c16605d 8699 int status = 0;
cbe82603 8700
99ade3c7
AE		 8701 nfs4_state_protect(NFS_SERVER(lrp->args.inode)->nfs_client,
8702 NFS_SP4_MACH_CRED_PNFS_CLEANUP,
8703 &task_setup_data.rpc_client, &msg);
8704
cbe82603 8705 dprintk("--> %s\n", __func__);
5a0ec8ac
TM		 8706 if (!sync) {
8707 lrp->inode = nfs_igrab_and_active(lrp->args.inode);
8708 if (!lrp->inode) {
8709 nfs4_layoutreturn_release(lrp);
8710 return -EAGAIN;
8711 }
8712 task_setup_data.flags |= RPC_TASK_ASYNC;
8713 }
a9c92d6b 8714 nfs4_init_sequence(&lrp->args.seq_args, &lrp->res.seq_res, 1);
cbe82603
BH		 8715 task = rpc_run_task(&task_setup_data);
8716 if (IS_ERR(task))
8717 return PTR_ERR(task);
5a0ec8ac
TM		 8718 if (sync)
8719 status = task->tk_status;
48c9579a 8720 trace_nfs4_layoutreturn(lrp->args.inode, &lrp->args.stateid, status);
cbe82603
BH		 8721 dprintk("<-- %s status=%d\n", __func__, status);
8722 rpc_put_task(task);
8723 return status;
8724}
8725
b1f69b75 8726static int
cd5875fe
TM		 8727_nfs4_proc_getdeviceinfo(struct nfs_server *server,
8728 struct pnfs_device *pdev,
8729 struct rpc_cred *cred)
b1f69b75
AA		 8730{
8731 struct nfs4_getdeviceinfo_args args = {
8732 .pdev = pdev,
4e590803
TM		 8733 .notify_types = NOTIFY_DEVICEID4_CHANGE |
8734 NOTIFY_DEVICEID4_DELETE,
b1f69b75
AA		 8735 };
8736 struct nfs4_getdeviceinfo_res res = {
8737 .pdev = pdev,
8738 };
8739 struct rpc_message msg = {
8740 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETDEVICEINFO],
8741 .rpc_argp = &args,
8742 .rpc_resp = &res,
cd5875fe 8743 .rpc_cred = cred,
b1f69b75
AA		 8744 };
8745 int status;
8746
8747 dprintk("--> %s\n", __func__);
7c513058 8748 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
4e590803
TM		 8749 if (res.notification & ~args.notify_types)
8750 dprintk("%s: unsupported notification\n", __func__);
df52699e
TM		 8751 if (res.notification != args.notify_types)
8752 pdev->nocache = 1;
4e590803 8753
b1f69b75
AA		 8754 dprintk("<-- %s status=%d\n", __func__, status);
8755
8756 return status;
8757}
8758
cd5875fe
TM		 8759int nfs4_proc_getdeviceinfo(struct nfs_server *server,
8760 struct pnfs_device *pdev,
8761 struct rpc_cred *cred)
b1f69b75
AA		 8762{
8763 struct nfs4_exception exception = { };
8764 int err;
8765
8766 do {
8767 err = nfs4_handle_exception(server,
cd5875fe 8768 _nfs4_proc_getdeviceinfo(server, pdev, cred),
b1f69b75
AA		 8769 &exception);
8770 } while (exception.retry);
8771 return err;
8772}
8773EXPORT_SYMBOL_GPL(nfs4_proc_getdeviceinfo);
8774
863a3c6c
AA		 8775static void nfs4_layoutcommit_prepare(struct rpc_task *task, void *calldata)
8776{
8777 struct nfs4_layoutcommit_data *data = calldata;
8778 struct nfs_server *server = NFS_SERVER(data->args.inode);
8779
7981c8a6 8780 nfs4_setup_sequence(server->nfs_client,
d9afbd1b
TM		 8781 &data->args.seq_args,
8782 &data->res.seq_res,
8783 task);
863a3c6c
AA		 8784}
8785
8786static void
8787nfs4_layoutcommit_done(struct rpc_task *task, void *calldata)
8788{
8789 struct nfs4_layoutcommit_data *data = calldata;
8790 struct nfs_server *server = NFS_SERVER(data->args.inode);
8791
6ba7db34 8792 if (!nfs41_sequence_done(task, &data->res.seq_res))
863a3c6c
AA		 8793 return;
8794
8795 switch (task->tk_status) { /* Just ignore these failures */
e59d27e0
TM		 8796 case -NFS4ERR_DELEG_REVOKED: /* layout was recalled */
8797 case -NFS4ERR_BADIOMODE: /* no IOMODE_RW layout for range */
8798 case -NFS4ERR_BADLAYOUT: /* no layout */
8799 case -NFS4ERR_GRACE: /* loca_recalim always false */
863a3c6c 8800 task->tk_status = 0;
e59d27e0 8801 case 0:
e59d27e0
TM		 8802 break;
8803 default:
8478eaa1 8804 if (nfs4_async_handle_error(task, server, NULL, NULL) == -EAGAIN) {
e59d27e0
TM		 8805 rpc_restart_call_prepare(task);
8806 return;
8807 }
8808 }
863a3c6c
AA		 8809}
8810
8811static void nfs4_layoutcommit_release(void *calldata)
8812{
8813 struct nfs4_layoutcommit_data *data = calldata;
8814
db29c089 8815 pnfs_cleanup_layoutcommit(data);
d8c951c3
TM		 8816 nfs_post_op_update_inode_force_wcc(data->args.inode,
8817 data->res.fattr);
863a3c6c 8818 put_rpccred(data->cred);
472e2594 8819 nfs_iput_and_deactive(data->inode);
863a3c6c
AA		 8820 kfree(data);
8821}
8822
8823static const struct rpc_call_ops nfs4_layoutcommit_ops = {
8824 .rpc_call_prepare = nfs4_layoutcommit_prepare,
8825 .rpc_call_done = nfs4_layoutcommit_done,
8826 .rpc_release = nfs4_layoutcommit_release,
8827};
8828
8829int
ef311537 8830nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data *data, bool sync)
863a3c6c
AA		 8831{
8832 struct rpc_message msg = {
8833 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTCOMMIT],
8834 .rpc_argp = &data->args,
8835 .rpc_resp = &data->res,
8836 .rpc_cred = data->cred,
8837 };
8838 struct rpc_task_setup task_setup_data = {
8839 .task = &data->task,
8840 .rpc_client = NFS_CLIENT(data->args.inode),
8841 .rpc_message = &msg,
8842 .callback_ops = &nfs4_layoutcommit_ops,
8843 .callback_data = data,
863a3c6c
AA		 8844 };
8845 struct rpc_task *task;
8846 int status = 0;
8847
b4839ebe
KM		 8848 dprintk("NFS: initiating layoutcommit call. sync %d "
8849 "lbw: %llu inode %lu\n", sync,
863a3c6c
AA		 8850 data->args.lastbytewritten,
8851 data->args.inode->i_ino);
8852
472e2594
TM		 8853 if (!sync) {
8854 data->inode = nfs_igrab_and_active(data->args.inode);
8855 if (data->inode == NULL) {
8856 nfs4_layoutcommit_release(data);
8857 return -EAGAIN;
8858 }
8859 task_setup_data.flags = RPC_TASK_ASYNC;
8860 }
a9c92d6b 8861 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
863a3c6c
AA		 8862 task = rpc_run_task(&task_setup_data);
8863 if (IS_ERR(task))
8864 return PTR_ERR(task);
472e2594
TM		 8865 if (sync)
8866 status = task->tk_status;
48c9579a 8867 trace_nfs4_layoutcommit(data->args.inode, &data->args.stateid, status);
863a3c6c
AA		 8868 dprintk("%s: status %d\n", __func__, status);
8869 rpc_put_task(task);
8870 return status;
8871}
fca78d6d 8872
97431204
AA		 8873/**
8874 * Use the state managment nfs_client cl_rpcclient, which uses krb5i (if
8875 * possible) as per RFC3530bis and RFC5661 Security Considerations sections
8876 */
fca78d6d
BS		 8877static int
8878_nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle,
b1b3e136
WAA		 8879 struct nfs_fsinfo *info,
8880 struct nfs4_secinfo_flavors *flavors, bool use_integrity)
fca78d6d
BS		 8881{
8882 struct nfs41_secinfo_no_name_args args = {
8883 .style = SECINFO_STYLE_CURRENT_FH,
8884 };
8885 struct nfs4_secinfo_res res = {
8886 .flavors = flavors,
8887 };
8888 struct rpc_message msg = {
8889 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SECINFO_NO_NAME],
8890 .rpc_argp = &args,
8891 .rpc_resp = &res,
8892 };
b1b3e136 8893 struct rpc_clnt *clnt = server->client;
7cb852df 8894 struct rpc_cred *cred = NULL;
b1b3e136
WAA		 8895 int status;
8896
8897 if (use_integrity) {
8898 clnt = server->nfs_client->cl_rpcclient;
7cb852df
WAA		 8899 cred = nfs4_get_clid_cred(server->nfs_client);
8900 msg.rpc_cred = cred;
b1b3e136
WAA		 8901 }
8902
8903 dprintk("--> %s\n", __func__);
8904 status = nfs4_call_sync(clnt, server, &msg, &args.seq_args,
8905 &res.seq_res, 0);
8906 dprintk("<-- %s status=%d\n", __func__, status);
8907
7cb852df
WAA		 8908 if (cred)
8909 put_rpccred(cred);
b1b3e136
WAA		 8910
8911 return status;
fca78d6d
BS		 8912}
8913
8914static int
8915nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle,
8916 struct nfs_fsinfo *info, struct nfs4_secinfo_flavors *flavors)
8917{
8918 struct nfs4_exception exception = { };
8919 int err;
8920 do {
b1b3e136
WAA		 8921 /* first try using integrity protection */
8922 err = -NFS4ERR_WRONGSEC;
8923
8924 /* try to use integrity protection with machine cred */
8925 if (_nfs4_is_integrity_protected(server->nfs_client))
8926 err = _nfs41_proc_secinfo_no_name(server, fhandle, info,
8927 flavors, true);
8928
8929 /*
8930 * if unable to use integrity protection, or SECINFO with
8931 * integrity protection returns NFS4ERR_WRONGSEC (which is
8932 * disallowed by spec, but exists in deployed servers) use
8933 * the current filesystem's rpc_client and the user cred.
8934 */
8935 if (err == -NFS4ERR_WRONGSEC)
8936 err = _nfs41_proc_secinfo_no_name(server, fhandle, info,
8937 flavors, false);
8938
fca78d6d
BS		 8939 switch (err) {
8940 case 0:
8941 case -NFS4ERR_WRONGSEC:
78b19bae 8942 case -ENOTSUPP:
05e9cfb4 8943 goto out;
fca78d6d
BS		 8944 default:
8945 err = nfs4_handle_exception(server, err, &exception);
8946 }
8947 } while (exception.retry);
05e9cfb4 8948out:
fca78d6d
BS		 8949 return err;
8950}
8951
8952static int
8953nfs41_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
8954 struct nfs_fsinfo *info)
8955{
8956 int err;
8957 struct page *page;
367156d9 8958 rpc_authflavor_t flavor = RPC_AUTH_MAXFLAVOR;
fca78d6d 8959 struct nfs4_secinfo_flavors *flavors;
58a8cf12
WAA		 8960 struct nfs4_secinfo4 *secinfo;
8961 int i;
fca78d6d
BS		 8962
8963 page = alloc_page(GFP_KERNEL);
8964 if (!page) {
8965 err = -ENOMEM;
8966 goto out;
8967 }
8968
8969 flavors = page_address(page);
8970 err = nfs41_proc_secinfo_no_name(server, fhandle, info, flavors);
8971
8972 /*
8973 * Fall back on "guess and check" method if
8974 * the server doesn't support SECINFO_NO_NAME
8975 */
78b19bae 8976 if (err == -NFS4ERR_WRONGSEC || err == -ENOTSUPP) {
fca78d6d
BS		 8977 err = nfs4_find_root_sec(server, fhandle, info);
8978 goto out_freepage;
8979 }
8980 if (err)
8981 goto out_freepage;
8982
58a8cf12
WAA		 8983 for (i = 0; i < flavors->num_flavors; i++) {
8984 secinfo = &flavors->flavors[i];
8985
8986 switch (secinfo->flavor) {
8987 case RPC_AUTH_NULL:
8988 case RPC_AUTH_UNIX:
8989 case RPC_AUTH_GSS:
8990 flavor = rpcauth_get_pseudoflavor(secinfo->flavor,
8991 &secinfo->flavor_info);
8992 break;
8993 default:
8994 flavor = RPC_AUTH_MAXFLAVOR;
8995 break;
8996 }
8997
4d4b69dd
WAA		 8998 if (!nfs_auth_info_match(&server->auth_info, flavor))
8999 flavor = RPC_AUTH_MAXFLAVOR;
9000
58a8cf12
WAA		 9001 if (flavor != RPC_AUTH_MAXFLAVOR) {
9002 err = nfs4_lookup_root_sec(server, fhandle,
9003 info, flavor);
9004 if (!err)
9005 break;
9006 }
9007 }
9008
9009 if (flavor == RPC_AUTH_MAXFLAVOR)
9010 err = -EPERM;
fca78d6d
BS		 9011
9012out_freepage:
9013 put_page(page);
9014 if (err == -EACCES)
9015 return -EPERM;
9016out:
9017 return err;
9018}
1cab0652 9019
ab7cb0df
TM		 9020static int _nfs41_test_stateid(struct nfs_server *server,
9021 nfs4_stateid *stateid,
9022 struct rpc_cred *cred)
7d974794
BS		 9023{
9024 int status;
9025 struct nfs41_test_stateid_args args = {
1cab0652 9026 .stateid = stateid,
7d974794
BS		 9027 };
9028 struct nfs41_test_stateid_res res;
9029 struct rpc_message msg = {
9030 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_TEST_STATEID],
9031 .rpc_argp = &args,
9032 .rpc_resp = &res,
ab7cb0df 9033 .rpc_cred = cred,
7d974794 9034 };
3787d506
WAA		 9035 struct rpc_clnt *rpc_client = server->client;
9036
9037 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_STATEID,
9038 &rpc_client, &msg);
1cab0652 9039
38527b15 9040 dprintk("NFS call test_stateid %p\n", stateid);
a9c92d6b 9041 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
8fe72bac 9042 nfs4_set_sequence_privileged(&args.seq_args);
3787d506 9043 status = nfs4_call_sync_sequence(rpc_client, server, &msg,
8fe72bac 9044 &args.seq_args, &res.seq_res);
38527b15
CL		 9045 if (status != NFS_OK) {
9046 dprintk("NFS reply test_stateid: failed, %d\n", status);
377e507d 9047 return status;
38527b15
CL		 9048 }
9049 dprintk("NFS reply test_stateid: succeeded, %d\n", -res.status);
377e507d 9050 return -res.status;
7d974794
BS		 9051}
9052
43912bbb
TM		 9053static void nfs4_handle_delay_or_session_error(struct nfs_server *server,
9054 int err, struct nfs4_exception *exception)
9055{
9056 exception->retry = 0;
9057 switch(err) {
9058 case -NFS4ERR_DELAY:
76e8a1bd 9059 case -NFS4ERR_RETRY_UNCACHED_REP:
43912bbb
TM		 9060 nfs4_handle_exception(server, err, exception);
9061 break;
9062 case -NFS4ERR_BADSESSION:
9063 case -NFS4ERR_BADSLOT:
9064 case -NFS4ERR_BAD_HIGH_SLOT:
9065 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
9066 case -NFS4ERR_DEADSESSION:
9067 nfs4_do_handle_exception(server, err, exception);
9068 }
9069}
9070
38527b15
CL		 9071/**
9072 * nfs41_test_stateid - perform a TEST_STATEID operation
9073 *
9074 * @server: server / transport on which to perform the operation
9075 * @stateid: state ID to test
ab7cb0df 9076 * @cred: credential
38527b15
CL		 9077 *
9078 * Returns NFS_OK if the server recognizes that "stateid" is valid.
9079 * Otherwise a negative NFS4ERR value is returned if the operation
9080 * failed or the state ID is not currently valid.
9081 */
ab7cb0df
TM		 9082static int nfs41_test_stateid(struct nfs_server *server,
9083 nfs4_stateid *stateid,
9084 struct rpc_cred *cred)
7d974794
BS		 9085{
9086 struct nfs4_exception exception = { };
9087 int err;
9088 do {
ab7cb0df 9089 err = _nfs41_test_stateid(server, stateid, cred);
43912bbb 9090 nfs4_handle_delay_or_session_error(server, err, &exception);
7d974794
BS		 9091 } while (exception.retry);
9092 return err;
9093}
9aeda35f 9094
7c1d5fae
TM		 9095struct nfs_free_stateid_data {
9096 struct nfs_server *server;
9097 struct nfs41_free_stateid_args args;
9aeda35f 9098 struct nfs41_free_stateid_res res;
7c1d5fae
TM		 9099};
9100
9101static void nfs41_free_stateid_prepare(struct rpc_task *task, void *calldata)
9102{
9103 struct nfs_free_stateid_data *data = calldata;
7981c8a6 9104 nfs4_setup_sequence(data->server->nfs_client,
7c1d5fae
TM		 9105 &data->args.seq_args,
9106 &data->res.seq_res,
9107 task);
9108}
9109
9110static void nfs41_free_stateid_done(struct rpc_task *task, void *calldata)
9111{
9112 struct nfs_free_stateid_data *data = calldata;
9113
9114 nfs41_sequence_done(task, &data->res.seq_res);
9115
9116 switch (task->tk_status) {
9117 case -NFS4ERR_DELAY:
8478eaa1 9118 if (nfs4_async_handle_error(task, data->server, NULL, NULL) == -EAGAIN)
7c1d5fae
TM		 9119 rpc_restart_call_prepare(task);
9120 }
9121}
9122
9123static void nfs41_free_stateid_release(void *calldata)
9124{
9125 kfree(calldata);
9126}
9127
17f26b12 9128static const struct rpc_call_ops nfs41_free_stateid_ops = {
7c1d5fae
TM		 9129 .rpc_call_prepare = nfs41_free_stateid_prepare,
9130 .rpc_call_done = nfs41_free_stateid_done,
9131 .rpc_release = nfs41_free_stateid_release,
9132};
9133
9134static struct rpc_task *_nfs41_free_stateid(struct nfs_server *server,
f0b0bf88 9135 const nfs4_stateid *stateid,
ab7cb0df 9136 struct rpc_cred *cred,
7c1d5fae
TM		 9137 bool privileged)
9138{
9aeda35f
BS		 9139 struct rpc_message msg = {
9140 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FREE_STATEID],
ab7cb0df 9141 .rpc_cred = cred,
9aeda35f 9142 };
7c1d5fae
TM		 9143 struct rpc_task_setup task_setup = {
9144 .rpc_client = server->client,
9145 .rpc_message = &msg,
9146 .callback_ops = &nfs41_free_stateid_ops,
9147 .flags = RPC_TASK_ASYNC,
9148 };
9149 struct nfs_free_stateid_data *data;
9aeda35f 9150
3787d506
WAA		 9151 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_STATEID,
9152 &task_setup.rpc_client, &msg);
9153
38527b15 9154 dprintk("NFS call free_stateid %p\n", stateid);
7c1d5fae
TM		 9155 data = kmalloc(sizeof(*data), GFP_NOFS);
9156 if (!data)
9157 return ERR_PTR(-ENOMEM);
9158 data->server = server;
9159 nfs4_stateid_copy(&data->args.stateid, stateid);
9160
9161 task_setup.callback_data = data;
9162
9163 msg.rpc_argp = &data->args;
9164 msg.rpc_resp = &data->res;
76e8a1bd 9165 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
7c1d5fae
TM		 9166 if (privileged)
9167 nfs4_set_sequence_privileged(&data->args.seq_args);
9168
9169 return rpc_run_task(&task_setup);
9aeda35f
BS		 9170}
9171
38527b15
CL		 9172/**
9173 * nfs41_free_stateid - perform a FREE_STATEID operation
9174 *
9175 * @server: server / transport on which to perform the operation
9176 * @stateid: state ID to release
ab7cb0df 9177 * @cred: credential
f0b0bf88 9178 * @is_recovery: set to true if this call needs to be privileged
38527b15 9179 *
f0b0bf88 9180 * Note: this function is always asynchronous.
38527b15 9181 */
ab7cb0df 9182static int nfs41_free_stateid(struct nfs_server *server,
f0b0bf88
TM		 9183 const nfs4_stateid *stateid,
9184 struct rpc_cred *cred,
9185 bool is_recovery)
9aeda35f 9186{
7c1d5fae 9187 struct rpc_task *task;
7c1d5fae 9188
f0b0bf88 9189 task = _nfs41_free_stateid(server, stateid, cred, is_recovery);
7c1d5fae
TM		 9190 if (IS_ERR(task))
9191 return PTR_ERR(task);
7c1d5fae 9192 rpc_put_task(task);
f0b0bf88 9193 return 0;
9aeda35f 9194}
36281caa 9195
f1cdae87
JL		 9196static void
9197nfs41_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp)
c8b2d0bf 9198{
ab7cb0df 9199 struct rpc_cred *cred = lsp->ls_state->owner->so_cred;
c8b2d0bf 9200
f0b0bf88 9201 nfs41_free_stateid(server, &lsp->ls_stateid, cred, false);
c8b2d0bf 9202 nfs4_free_lock_state(server, lsp);
c8b2d0bf
TM		 9203}
9204
36281caa
TM		 9205static bool nfs41_match_stateid(const nfs4_stateid *s1,
9206 const nfs4_stateid *s2)
9207{
93b717fd
TM		 9208 if (s1->type != s2->type)
9209 return false;
9210
2d2f24ad 9211 if (memcmp(s1->other, s2->other, sizeof(s1->other)) != 0)
36281caa
TM		 9212 return false;
9213
2d2f24ad 9214 if (s1->seqid == s2->seqid)
36281caa 9215 return true;
2d2f24ad 9216 if (s1->seqid == 0 || s2->seqid == 0)
36281caa
TM		 9217 return true;
9218
9219 return false;
9220}
9221
557134a3
AA		 9222#endif /* CONFIG_NFS_V4_1 */
9223
36281caa
TM		 9224static bool nfs4_match_stateid(const nfs4_stateid *s1,
9225 const nfs4_stateid *s2)
9226{
f597c537 9227 return nfs4_stateid_match(s1, s2);
36281caa
TM		 9228}
9229
9230
17280175 9231static const struct nfs4_state_recovery_ops nfs40_reboot_recovery_ops = {
7eff03ae 9232 .owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT,
b79a4a1b 9233 .state_flag_bit = NFS_STATE_RECLAIM_REBOOT,
1da177e4
LT		 9234 .recover_open = nfs4_open_reclaim,
9235 .recover_lock = nfs4_lock_reclaim,
591d71cb 9236 .establish_clid = nfs4_init_clientid,
05f4c350 9237 .detect_trunking = nfs40_discover_server_trunking,
1da177e4
LT		 9238};
9239
591d71cb 9240#if defined(CONFIG_NFS_V4_1)
17280175 9241static const struct nfs4_state_recovery_ops nfs41_reboot_recovery_ops = {
591d71cb
AA		 9242 .owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT,
9243 .state_flag_bit = NFS_STATE_RECLAIM_REBOOT,
9244 .recover_open = nfs4_open_reclaim,
9245 .recover_lock = nfs4_lock_reclaim,
4d643d1d 9246 .establish_clid = nfs41_init_clientid,
fce5c838 9247 .reclaim_complete = nfs41_proc_reclaim_complete,
05f4c350 9248 .detect_trunking = nfs41_discover_server_trunking,
591d71cb
AA		 9249};
9250#endif /* CONFIG_NFS_V4_1 */
9251
17280175 9252static const struct nfs4_state_recovery_ops nfs40_nograce_recovery_ops = {
591d71cb
AA		 9253 .owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE,
9254 .state_flag_bit = NFS_STATE_RECLAIM_NOGRACE,
4dfd4f7a 9255 .recover_open = nfs40_open_expired,
591d71cb
AA		 9256 .recover_lock = nfs4_lock_expired,
9257 .establish_clid = nfs4_init_clientid,
9258};
9259
9260#if defined(CONFIG_NFS_V4_1)
17280175 9261static const struct nfs4_state_recovery_ops nfs41_nograce_recovery_ops = {
7eff03ae 9262 .owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE,
b79a4a1b 9263 .state_flag_bit = NFS_STATE_RECLAIM_NOGRACE,
f062eb6c
BS		 9264 .recover_open = nfs41_open_expired,
9265 .recover_lock = nfs41_lock_expired,
4d643d1d 9266 .establish_clid = nfs41_init_clientid,
1da177e4 9267};
591d71cb 9268#endif /* CONFIG_NFS_V4_1 */
1da177e4 9269
17280175 9270static const struct nfs4_state_maintenance_ops nfs40_state_renewal_ops = {
29fba38b 9271 .sched_state_renewal = nfs4_proc_async_renew,
a7b72103 9272 .get_state_renewal_cred_locked = nfs4_get_renew_cred_locked,
8e69514f 9273 .renew_lease = nfs4_proc_renew,
29fba38b
BH		 9274};
9275
9276#if defined(CONFIG_NFS_V4_1)
17280175 9277static const struct nfs4_state_maintenance_ops nfs41_state_renewal_ops = {
29fba38b 9278 .sched_state_renewal = nfs41_proc_async_sequence,
a7b72103 9279 .get_state_renewal_cred_locked = nfs4_get_machine_cred_locked,
8e69514f 9280 .renew_lease = nfs4_proc_sequence,
29fba38b
BH		 9281};
9282#endif
9283
ec011fe8 9284static const struct nfs4_mig_recovery_ops nfs40_mig_recovery_ops = {
b03d735b 9285 .get_locations = _nfs40_proc_get_locations,
44c99933 9286 .fsid_present = _nfs40_proc_fsid_present,
ec011fe8
CL		 9287};
9288
9289#if defined(CONFIG_NFS_V4_1)
9290static const struct nfs4_mig_recovery_ops nfs41_mig_recovery_ops = {
b03d735b 9291 .get_locations = _nfs41_proc_get_locations,
44c99933 9292 .fsid_present = _nfs41_proc_fsid_present,
ec011fe8
CL		 9293};
9294#endif /* CONFIG_NFS_V4_1 */
9295
97dc1359
TM		 9296static const struct nfs4_minor_version_ops nfs_v4_0_minor_ops = {
9297 .minor_version = 0,
39c6daae
TM		 9298 .init_caps = NFS_CAP_READDIRPLUS
9299 | NFS_CAP_ATOMIC_OPEN
39c6daae 9300 | NFS_CAP_POSIX_LOCK,
abf79bb3
CL		 9301 .init_client = nfs40_init_client,
9302 .shutdown_client = nfs40_shutdown_client,
36281caa 9303 .match_stateid = nfs4_match_stateid,
fca78d6d 9304 .find_root_sec = nfs4_find_root_sec,
c8b2d0bf 9305 .free_lock_state = nfs4_release_lockowner,
45870d69 9306 .test_and_free_expired = nfs40_test_and_free_expired_stateid,
63f5f796 9307 .alloc_seqid = nfs_alloc_seqid,
9915ea7e 9308 .call_sync_ops = &nfs40_call_sync_ops,
c48f4f35
TM		 9309 .reboot_recovery_ops = &nfs40_reboot_recovery_ops,
9310 .nograce_recovery_ops = &nfs40_nograce_recovery_ops,
9311 .state_renewal_ops = &nfs40_state_renewal_ops,
ec011fe8 9312 .mig_recovery_ops = &nfs40_mig_recovery_ops,
97dc1359
TM		 9313};
9314
9315#if defined(CONFIG_NFS_V4_1)
63f5f796
TM		 9316static struct nfs_seqid *
9317nfs_alloc_no_seqid(struct nfs_seqid_counter *arg1, gfp_t arg2)
9318{
9319 return NULL;
9320}
9321
97dc1359
TM		 9322static const struct nfs4_minor_version_ops nfs_v4_1_minor_ops = {
9323 .minor_version = 1,
39c6daae
TM		 9324 .init_caps = NFS_CAP_READDIRPLUS
9325 | NFS_CAP_ATOMIC_OPEN
3b66486c 9326 | NFS_CAP_POSIX_LOCK
49f9a0fa 9327 | NFS_CAP_STATEID_NFSV41
e983120e 9328 | NFS_CAP_ATOMIC_OPEN_V1,
abf79bb3
CL		 9329 .init_client = nfs41_init_client,
9330 .shutdown_client = nfs41_shutdown_client,
36281caa 9331 .match_stateid = nfs41_match_stateid,
fca78d6d 9332 .find_root_sec = nfs41_find_root_sec,
c8b2d0bf 9333 .free_lock_state = nfs41_free_lock_state,
45870d69 9334 .test_and_free_expired = nfs41_test_and_free_expired_stateid,
63f5f796 9335 .alloc_seqid = nfs_alloc_no_seqid,
04fa2c6b 9336 .session_trunk = nfs4_test_session_trunk,
9915ea7e 9337 .call_sync_ops = &nfs41_call_sync_ops,
c48f4f35
TM		 9338 .reboot_recovery_ops = &nfs41_reboot_recovery_ops,
9339 .nograce_recovery_ops = &nfs41_nograce_recovery_ops,
9340 .state_renewal_ops = &nfs41_state_renewal_ops,
ec011fe8 9341 .mig_recovery_ops = &nfs41_mig_recovery_ops,
97dc1359
TM		 9342};
9343#endif
9344
42c2c424
SD		 9345#if defined(CONFIG_NFS_V4_2)
9346static const struct nfs4_minor_version_ops nfs_v4_2_minor_ops = {
9347 .minor_version = 2,
7017310a
BS		 9348 .init_caps = NFS_CAP_READDIRPLUS
9349 | NFS_CAP_ATOMIC_OPEN
7017310a
BS		 9350 | NFS_CAP_POSIX_LOCK
9351 | NFS_CAP_STATEID_NFSV41
e983120e 9352 | NFS_CAP_ATOMIC_OPEN_V1
f4ac1674 9353 | NFS_CAP_ALLOCATE
2e72448b 9354 | NFS_CAP_COPY
624bd5b7 9355 | NFS_CAP_DEALLOCATE
6c5a0d89 9356 | NFS_CAP_SEEK
e5341f3a
PT		 9357 | NFS_CAP_LAYOUTSTATS
9358 | NFS_CAP_CLONE,
abf79bb3
CL		 9359 .init_client = nfs41_init_client,
9360 .shutdown_client = nfs41_shutdown_client,
42c2c424
SD		 9361 .match_stateid = nfs41_match_stateid,
9362 .find_root_sec = nfs41_find_root_sec,
7017310a 9363 .free_lock_state = nfs41_free_lock_state,
9915ea7e 9364 .call_sync_ops = &nfs41_call_sync_ops,
45870d69 9365 .test_and_free_expired = nfs41_test_and_free_expired_stateid,
63f5f796 9366 .alloc_seqid = nfs_alloc_no_seqid,
04fa2c6b 9367 .session_trunk = nfs4_test_session_trunk,
42c2c424
SD		 9368 .reboot_recovery_ops = &nfs41_reboot_recovery_ops,
9369 .nograce_recovery_ops = &nfs41_nograce_recovery_ops,
9370 .state_renewal_ops = &nfs41_state_renewal_ops,
18e3b739 9371 .mig_recovery_ops = &nfs41_mig_recovery_ops,
42c2c424
SD		 9372};
9373#endif
9374
97dc1359
TM		 9375const struct nfs4_minor_version_ops *nfs_v4_minor_ops[] = {
9376 [0] = &nfs_v4_0_minor_ops,
9377#if defined(CONFIG_NFS_V4_1)
9378 [1] = &nfs_v4_1_minor_ops,
9379#endif
42c2c424
SD		 9380#if defined(CONFIG_NFS_V4_2)
9381 [2] = &nfs_v4_2_minor_ops,
9382#endif
97dc1359
TM		 9383};
9384
13997823 9385static ssize_t nfs4_listxattr(struct dentry *dentry, char *list, size_t size)
c4803c49
AG		 9386{
9387 ssize_t error, error2;
9388
9389 error = generic_listxattr(dentry, list, size);
9390 if (error < 0)
9391 return error;
9392 if (list) {
9393 list += error;
9394 size -= error;
9395 }
9396
9397 error2 = nfs4_listxattr_nfs4_label(d_inode(dentry), list, size);
9398 if (error2 < 0)
9399 return error2;
9400 return error + error2;
9401}
9402
17f26b12 9403static const struct inode_operations nfs4_dir_inode_operations = {
73a79706
BS		 9404 .create = nfs_create,
9405 .lookup = nfs_lookup,
9406 .atomic_open = nfs_atomic_open,
9407 .link = nfs_link,
9408 .unlink = nfs_unlink,
9409 .symlink = nfs_symlink,
9410 .mkdir = nfs_mkdir,
9411 .rmdir = nfs_rmdir,
9412 .mknod = nfs_mknod,
9413 .rename = nfs_rename,
9414 .permission = nfs_permission,
9415 .getattr = nfs_getattr,
9416 .setattr = nfs_setattr,
c4803c49 9417 .listxattr = nfs4_listxattr,
73a79706
BS		 9418};
9419
92e1d5be 9420static const struct inode_operations nfs4_file_inode_operations = {
6b3b5496
BF		 9421 .permission = nfs_permission,
9422 .getattr = nfs_getattr,
9423 .setattr = nfs_setattr,
c4803c49 9424 .listxattr = nfs4_listxattr,
6b3b5496
BF		 9425};
9426
509de811 9427const struct nfs_rpc_ops nfs_v4_clientops = {
1da177e4
LT		 9428 .version = 4, /* protocol version */
9429 .dentry_ops = &nfs4_dentry_operations,
9430 .dir_inode_ops = &nfs4_dir_inode_operations,
6b3b5496 9431 .file_inode_ops = &nfs4_file_inode_operations,
1788ea6e 9432 .file_ops = &nfs4_file_operations,
1da177e4 9433 .getroot = nfs4_proc_get_root,
281cad46 9434 .submount = nfs4_submount,
ff9099f2 9435 .try_mount = nfs4_try_mount,
1da177e4
LT		 9436 .getattr = nfs4_proc_getattr,
9437 .setattr = nfs4_proc_setattr,
9438 .lookup = nfs4_proc_lookup,
9439 .access = nfs4_proc_access,
9440 .readlink = nfs4_proc_readlink,
1da177e4
LT		 9441 .create = nfs4_proc_create,
9442 .remove = nfs4_proc_remove,
9443 .unlink_setup = nfs4_proc_unlink_setup,
34e137cc 9444 .unlink_rpc_prepare = nfs4_proc_unlink_rpc_prepare,
1da177e4 9445 .unlink_done = nfs4_proc_unlink_done,
d3d4152a 9446 .rename_setup = nfs4_proc_rename_setup,
c6bfa1a1 9447 .rename_rpc_prepare = nfs4_proc_rename_rpc_prepare,
d3d4152a 9448 .rename_done = nfs4_proc_rename_done,
1da177e4
LT		 9449 .link = nfs4_proc_link,
9450 .symlink = nfs4_proc_symlink,
9451 .mkdir = nfs4_proc_mkdir,
9452 .rmdir = nfs4_proc_remove,
9453 .readdir = nfs4_proc_readdir,
9454 .mknod = nfs4_proc_mknod,
9455 .statfs = nfs4_proc_statfs,
9456 .fsinfo = nfs4_proc_fsinfo,
9457 .pathconf = nfs4_proc_pathconf,
e9326dca 9458 .set_capabilities = nfs4_server_capabilities,
1da177e4 9459 .decode_dirent = nfs4_decode_dirent,
a4cdda59 9460 .pgio_rpc_prepare = nfs4_proc_pgio_rpc_prepare,
1da177e4 9461 .read_setup = nfs4_proc_read_setup,
ec06c096 9462 .read_done = nfs4_read_done,
1da177e4 9463 .write_setup = nfs4_proc_write_setup,
788e7a89 9464 .write_done = nfs4_write_done,
1da177e4 9465 .commit_setup = nfs4_proc_commit_setup,
0b7c0153 9466 .commit_rpc_prepare = nfs4_proc_commit_rpc_prepare,
788e7a89 9467 .commit_done = nfs4_commit_done,
1da177e4 9468 .lock = nfs4_proc_lock,
e50a1c2e 9469 .clear_acl_cache = nfs4_zap_acl_attr,
7fe5c398 9470 .close_context = nfs4_close_context,
2b484297 9471 .open_context = nfs4_atomic_open,
011e2a7f 9472 .have_delegation = nfs4_have_delegation,
57ec14c5 9473 .return_delegation = nfs4_inode_return_delegation,
6663ee7f 9474 .alloc_client = nfs4_alloc_client,
45a52a02 9475 .init_client = nfs4_init_client,
cdb7eced 9476 .free_client = nfs4_free_client,
1179acc6
BS		 9477 .create_server = nfs4_create_server,
9478 .clone_server = nfs_clone_server,
1da177e4
LT		 9479};
9480
64c2ce8b 9481static const struct xattr_handler nfs4_xattr_nfs4_acl_handler = {
98e9cb57 9482 .name = XATTR_NAME_NFSV4_ACL,
64c2ce8b
AK		 9483 .list = nfs4_xattr_list_nfs4_acl,
9484 .get = nfs4_xattr_get_nfs4_acl,
9485 .set = nfs4_xattr_set_nfs4_acl,
9486};
9487
9488const struct xattr_handler *nfs4_xattr_handlers[] = {
9489 &nfs4_xattr_nfs4_acl_handler,
c9bccef6
DQ		 9490#ifdef CONFIG_NFS_V4_SECURITY_LABEL
9491 &nfs4_xattr_nfs4_label_handler,
9492#endif
64c2ce8b
AK		 9493 NULL
9494};
9495
1da177e4
LT		 9496/*
9497 * Local variables:
9498 * c-basic-offset: 8
9499 * End:
9500 */
Ubuntu Hirsute Linux kernel mirror