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