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