]> 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
NFSv4: cleanup nfs4_close_done
[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,
91b30d2e
TM		 3171 calldata->inode))
3172 goto lr_restart;
7380020e 3173 /* Fallthrough */
cf805165
TM		 3174 case -NFS4ERR_ADMIN_REVOKED:
3175 case -NFS4ERR_DELEG_REVOKED:
3176 case -NFS4ERR_EXPIRED:
3177 case -NFS4ERR_BAD_STATEID:
cf805165
TM		 3178 case -NFS4ERR_UNKNOWN_LAYOUTTYPE:
3179 case -NFS4ERR_WRONG_CRED:
3180 calldata->arg.lr_args = NULL;
3181 calldata->res.lr_res = NULL;
91b30d2e 3182 goto lr_restart;
cf805165
TM		 3183 }
3184 }
3185
d9b67e1e 3186 /* hmm. we are done with the inode, and in the process of freeing
1da177e4
LT		 3187 * the state_owner. we keep this around to process errors
3188 */
1da177e4
LT		 3189 switch (task->tk_status) {
3190 case 0:
412f6c4c 3191 res_stateid = &calldata->res.stateid;
26e976a8 3192 renew_lease(server, calldata->timestamp);
412f6c4c 3193 break;
f07d4a31
TM		 3194 case -NFS4ERR_ACCESS:
3195 if (calldata->arg.bitmask != NULL) {
3196 calldata->arg.bitmask = NULL;
3197 calldata->res.fattr = NULL;
91b30d2e 3198 goto out_restart;
f07d4a31
TM		 3199
3200 }
3201 break;
12f275cd
TM		 3202 case -NFS4ERR_OLD_STATEID:
3203 /* Did we race with OPEN? */
3204 if (nfs4_refresh_open_stateid(&calldata->arg.stateid,
91b30d2e
TM		 3205 state))
3206 goto out_restart;
12f275cd 3207 goto out_release;
69794ad7 3208 case -NFS4ERR_ADMIN_REVOKED:
1da177e4 3209 case -NFS4ERR_STALE_STATEID:
26d36301
TM		 3210 case -NFS4ERR_EXPIRED:
3211 nfs4_free_revoked_stateid(server,
3212 &calldata->arg.stateid,
3213 task->tk_msg.rpc_cred);
12f275cd 3214 /* Fallthrough */
9e33bed5 3215 case -NFS4ERR_BAD_STATEID:
c82bac6f 3216 break;
1da177e4 3217 default:
91b30d2e
TM		 3218 if (nfs4_async_handle_error(task, server, state, NULL) == -EAGAIN)
3219 goto out_restart;
1da177e4 3220 }
4a1e2feb
TM		 3221 nfs_clear_open_stateid(state, &calldata->arg.stateid,
3222 res_stateid, calldata->arg.fmode);
69794ad7 3223out_release:
91b30d2e 3224 task->tk_status = 0;
72211dbe 3225 nfs_release_seqid(calldata->arg.seqid);
d8d84983 3226 nfs_refresh_inode(calldata->inode, &calldata->fattr);
a3ca5651 3227 dprintk("%s: done, ret = %d!\n", __func__, task->tk_status);
91b30d2e
TM		 3228 return;
3229lr_restart:
3230 calldata->res.lr_ret = 0;
3231out_restart:
3232 task->tk_status = 0;
3233 rpc_restart_call_prepare(task);
3234 goto out_release;
1da177e4
LT		 3235}
3236
4ce70ada 3237static void nfs4_close_prepare(struct rpc_task *task, void *data)
1da177e4 3238{
4ce70ada 3239 struct nfs4_closedata *calldata = data;
9512135d 3240 struct nfs4_state *state = calldata->state;
7fdab069 3241 struct inode *inode = calldata->inode;
aee7af35 3242 bool is_rdonly, is_wronly, is_rdwr;
88069f77 3243 int call_close = 0;
9512135d 3244
a3ca5651 3245 dprintk("%s: begin!\n", __func__);
963d8fe5 3246 if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
c8da19b9 3247 goto out_wait;
003707c7 3248
88069f77 3249 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE];
4cecb76f 3250 spin_lock(&state->owner->so_lock);
aee7af35
TM		 3251 is_rdwr = test_bit(NFS_O_RDWR_STATE, &state->flags);
3252 is_rdonly = test_bit(NFS_O_RDONLY_STATE, &state->flags);
3253 is_wronly = test_bit(NFS_O_WRONLY_STATE, &state->flags);
003707c7 3254 /* Calculate the change in open mode */
cd9288ff 3255 calldata->arg.fmode = 0;
e7616923 3256 if (state->n_rdwr == 0) {
cd9288ff
TM		 3257 if (state->n_rdonly == 0)
3258 call_close |= is_rdonly;
3259 else if (is_rdonly)
3260 calldata->arg.fmode |= FMODE_READ;
3261 if (state->n_wronly == 0)
3262 call_close |= is_wronly;
3263 else if (is_wronly)
3264 calldata->arg.fmode |= FMODE_WRITE;
e547f262
TM		 3265 if (calldata->arg.fmode != (FMODE_READ|FMODE_WRITE))
3266 call_close |= is_rdwr;
cd9288ff
TM		 3267 } else if (is_rdwr)
3268 calldata->arg.fmode |= FMODE_READ|FMODE_WRITE;
3269
5cc7861e 3270 if (!nfs4_valid_open_stateid(state) ||
c82bac6f 3271 !nfs4_refresh_open_stateid(&calldata->arg.stateid, state))
5d422301 3272 call_close = 0;
4cecb76f 3273 spin_unlock(&state->owner->so_lock);
88069f77
TM		 3274
3275 if (!call_close) {
963d8fe5 3276 /* Note: exit _without_ calling nfs4_close_done */
c8da19b9 3277 goto out_no_action;
9512135d 3278 }
88069f77 3279
1c5bd76d 3280 if (!calldata->lr.roc && nfs4_wait_on_layoutreturn(inode, task)) {
500d701f
PT		 3281 nfs_release_seqid(calldata->arg.seqid);
3282 goto out_wait;
3283 }
3284
9413a1a1 3285 if (calldata->arg.fmode == 0)
88069f77 3286 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE];
3ecefc92 3287
9413a1a1 3288 if (calldata->arg.fmode == 0 || calldata->arg.fmode == FMODE_READ) {
3ecefc92
TM		 3289 /* Close-to-open cache consistency revalidation */
3290 if (!nfs4_have_delegation(inode, FMODE_READ))
3291 calldata->arg.bitmask = NFS_SERVER(inode)->cache_consistency_bitmask;
3292 else
3293 calldata->arg.bitmask = NULL;
3294 }
3c13cb5b 3295
6ae37339
TM		 3296 calldata->arg.share_access =
3297 nfs4_map_atomic_open_share(NFS_SERVER(inode),
3298 calldata->arg.fmode, 0);
88069f77 3299
d8d84983
TM		 3300 if (calldata->res.fattr == NULL)
3301 calldata->arg.bitmask = NULL;
3302 else if (calldata->arg.bitmask == NULL)
3303 calldata->res.fattr = NULL;
26e976a8 3304 calldata->timestamp = jiffies;
42e1cca7 3305 if (nfs4_setup_sequence(NFS_SERVER(inode)->nfs_client,
9d12b216
TM		 3306 &calldata->arg.seq_args,
3307 &calldata->res.seq_res,
2240a9e2
TM		 3308 task) != 0)
3309 nfs_release_seqid(calldata->arg.seqid);
a3ca5651 3310 dprintk("%s: done!\n", __func__);
c8da19b9
TM		 3311 return;
3312out_no_action:
3313 task->tk_action = NULL;
3314out_wait:
3315 nfs4_sequence_done(task, &calldata->res.seq_res);
1da177e4
LT		 3316}
3317
963d8fe5 3318static const struct rpc_call_ops nfs4_close_ops = {
4ce70ada 3319 .rpc_call_prepare = nfs4_close_prepare,
963d8fe5
TM		 3320 .rpc_call_done = nfs4_close_done,
3321 .rpc_release = nfs4_free_closedata,
3322};
3323
1da177e4
LT		 3324/*
3325 * It is possible for data to be read/written from a mem-mapped file
3326 * after the sys_close call (which hits the vfs layer as a flush).
3327 * This means that we can't safely call nfsv4 close on a file until
3328 * the inode is cleared. This in turn means that we are not good
3329 * NFSv4 citizens - we do not indicate to the server to update the file's
3330 * share state even when we are done with one of the three share
3331 * stateid's in the inode.
3332 *
3333 * NOTE: Caller must be holding the sp->so_owner semaphore!
3334 */
1f7977c1 3335int nfs4_do_close(struct nfs4_state *state, gfp_t gfp_mask, int wait)
1da177e4 3336{
4a35bd41 3337 struct nfs_server *server = NFS_SERVER(state->inode);
63f5f796 3338 struct nfs_seqid *(*alloc_seqid)(struct nfs_seqid_counter *, gfp_t);
1da177e4 3339 struct nfs4_closedata *calldata;
b39e625b
TM		 3340 struct nfs4_state_owner *sp = state->owner;
3341 struct rpc_task *task;
5138fde0
TM		 3342 struct rpc_message msg = {
3343 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE],
3344 .rpc_cred = state->owner->so_cred,
3345 };
c970aa85
TM		 3346 struct rpc_task_setup task_setup_data = {
3347 .rpc_client = server->client,
5138fde0 3348 .rpc_message = &msg,
c970aa85 3349 .callback_ops = &nfs4_close_ops,
101070ca 3350 .workqueue = nfsiod_workqueue,
c970aa85
TM		 3351 .flags = RPC_TASK_ASYNC,
3352 };
9512135d 3353 int status = -ENOMEM;
1da177e4 3354
fa940720
WAA		 3355 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_CLEANUP,
3356 &task_setup_data.rpc_client, &msg);
3357
8535b2be 3358 calldata = kzalloc(sizeof(*calldata), gfp_mask);
1da177e4 3359 if (calldata == NULL)
9512135d 3360 goto out;
a9c92d6b 3361 nfs4_init_sequence(&calldata->arg.seq_args, &calldata->res.seq_res, 1);
4a35bd41 3362 calldata->inode = state->inode;
1da177e4 3363 calldata->state = state;
4a35bd41 3364 calldata->arg.fh = NFS_FH(state->inode);
c82bac6f
TM		 3365 if (!nfs4_copy_open_stateid(&calldata->arg.stateid, state))
3366 goto out_free_calldata;
1da177e4 3367 /* Serialization for the sequence id */
63f5f796
TM		 3368 alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid;
3369 calldata->arg.seqid = alloc_seqid(&state->owner->so_seqid, gfp_mask);
badc76dd 3370 if (IS_ERR(calldata->arg.seqid))
9512135d 3371 goto out_free_calldata;
d8d84983 3372 nfs_fattr_init(&calldata->fattr);
dc0b027d 3373 calldata->arg.fmode = 0;
4d796d75 3374 calldata->lr.arg.ld_private = &calldata->lr.ld_private;
516a6af6 3375 calldata->res.fattr = &calldata->fattr;
c1d51931 3376 calldata->res.seqid = calldata->arg.seqid;
516a6af6 3377 calldata->res.server = server;
cf805165 3378 calldata->res.lr_ret = -NFS4ERR_NOMATCHING_LAYOUT;
1c5bd76d
TM		 3379 calldata->lr.roc = pnfs_roc(state->inode,
3380 &calldata->lr.arg, &calldata->lr.res, msg.rpc_cred);
3381 if (calldata->lr.roc) {
3382 calldata->arg.lr_args = &calldata->lr.arg;
3383 calldata->res.lr_res = &calldata->lr.res;
3384 }
643168c2 3385 nfs_sb_active(calldata->inode->i_sb);
9512135d 3386
1174dd1f
TM		 3387 msg.rpc_argp = &calldata->arg;
3388 msg.rpc_resp = &calldata->res;
c970aa85
TM		 3389 task_setup_data.callback_data = calldata;
3390 task = rpc_run_task(&task_setup_data);
b39e625b
TM		 3391 if (IS_ERR(task))
3392 return PTR_ERR(task);
a49c3c77
TM		 3393 status = 0;
3394 if (wait)
3395 status = rpc_wait_for_completion_task(task);
b39e625b 3396 rpc_put_task(task);
a49c3c77 3397 return status;
9512135d
TM		 3398out_free_calldata:
3399 kfree(calldata);
3400out:
b39e625b
TM		 3401 nfs4_put_open_state(state);
3402 nfs4_put_state_owner(sp);
9512135d 3403 return status;
1da177e4
LT		 3404}
3405
2b484297 3406static struct inode *
5bc2afc2
TM		 3407nfs4_atomic_open(struct inode *dir, struct nfs_open_context *ctx,
3408 int open_flags, struct iattr *attr, int *opened)
1da177e4 3409{
1da177e4 3410 struct nfs4_state *state;
aa9c2669
DQ		 3411 struct nfs4_label l = {0, 0, 0, NULL}, *label = NULL;
3412
3413 label = nfs4_label_init_security(dir, ctx->dentry, attr, &l);
1da177e4 3414
565277f6 3415 /* Protect against concurrent sillydeletes */
5bc2afc2 3416 state = nfs4_do_open(dir, ctx, open_flags, attr, label, opened);
aa9c2669
DQ		 3417
3418 nfs4_label_release_security(label);
3419
f46e0bd3
TM		 3420 if (IS_ERR(state))
3421 return ERR_CAST(state);
275bb307 3422 return state->inode;
1da177e4
LT		 3423}
3424
1185a552 3425static void nfs4_close_context(struct nfs_open_context *ctx, int is_sync)
7fe5c398
TM		 3426{
3427 if (ctx->state == NULL)
3428 return;
3429 if (is_sync)
643168c2 3430 nfs4_close_sync(ctx->state, ctx->mode);
7fe5c398 3431 else
643168c2 3432 nfs4_close_state(ctx->state, ctx->mode);
7fe5c398 3433}
1da177e4 3434
b944dba3
TM		 3435#define FATTR4_WORD1_NFS40_MASK (2*FATTR4_WORD1_MOUNTED_ON_FILEID - 1UL)
3436#define FATTR4_WORD2_NFS41_MASK (2*FATTR4_WORD2_SUPPATTR_EXCLCREAT - 1UL)
dff25ddb 3437#define FATTR4_WORD2_NFS42_MASK (2*FATTR4_WORD2_MODE_UMASK - 1UL)
b944dba3 3438
1da177e4
LT		 3439static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
3440{
8c61282f 3441 u32 bitmask[3] = {}, minorversion = server->nfs_client->cl_minorversion;
43652ad5
BH		 3442 struct nfs4_server_caps_arg args = {
3443 .fhandle = fhandle,
8c61282f 3444 .bitmask = bitmask,
43652ad5 3445 };
1da177e4
LT		 3446 struct nfs4_server_caps_res res = {};
3447 struct rpc_message msg = {
3448 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SERVER_CAPS],
43652ad5 3449 .rpc_argp = &args,
1da177e4
LT		 3450 .rpc_resp = &res,
3451 };
3452 int status;
f4b23de3 3453 int i;
1da177e4 3454
8c61282f
KM		 3455 bitmask[0] = FATTR4_WORD0_SUPPORTED_ATTRS |
3456 FATTR4_WORD0_FH_EXPIRE_TYPE |
3457 FATTR4_WORD0_LINK_SUPPORT |
3458 FATTR4_WORD0_SYMLINK_SUPPORT |
3459 FATTR4_WORD0_ACLSUPPORT;
3460 if (minorversion)
3461 bitmask[2] = FATTR4_WORD2_SUPPATTR_EXCLCREAT;
3462
7c513058 3463 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
1da177e4 3464 if (status == 0) {
b944dba3 3465 /* Sanity check the server answers */
8c61282f 3466 switch (minorversion) {
b944dba3
TM		 3467 case 0:
3468 res.attr_bitmask[1] &= FATTR4_WORD1_NFS40_MASK;
3469 res.attr_bitmask[2] = 0;
3470 break;
3471 case 1:
3472 res.attr_bitmask[2] &= FATTR4_WORD2_NFS41_MASK;
3473 break;
3474 case 2:
3475 res.attr_bitmask[2] &= FATTR4_WORD2_NFS42_MASK;
3476 }
1da177e4 3477 memcpy(server->attr_bitmask, res.attr_bitmask, sizeof(server->attr_bitmask));
62ab460c
TM		 3478 server->caps &= ~(NFS_CAP_ACLS|NFS_CAP_HARDLINKS|
3479 NFS_CAP_SYMLINKS|NFS_CAP_FILEID|
3480 NFS_CAP_MODE|NFS_CAP_NLINK|NFS_CAP_OWNER|
3481 NFS_CAP_OWNER_GROUP|NFS_CAP_ATIME|
b944dba3
TM		 3482 NFS_CAP_CTIME|NFS_CAP_MTIME|
3483 NFS_CAP_SECURITY_LABEL);
7dd7d959
MN		 3484 if (res.attr_bitmask[0] & FATTR4_WORD0_ACL &&
3485 res.acl_bitmask & ACL4_SUPPORT_ALLOW_ACL)
1da177e4
LT		 3486 server->caps |= NFS_CAP_ACLS;
3487 if (res.has_links != 0)
3488 server->caps |= NFS_CAP_HARDLINKS;
3489 if (res.has_symlinks != 0)
3490 server->caps |= NFS_CAP_SYMLINKS;
62ab460c
TM		 3491 if (res.attr_bitmask[0] & FATTR4_WORD0_FILEID)
3492 server->caps |= NFS_CAP_FILEID;
3493 if (res.attr_bitmask[1] & FATTR4_WORD1_MODE)
3494 server->caps |= NFS_CAP_MODE;
3495 if (res.attr_bitmask[1] & FATTR4_WORD1_NUMLINKS)
3496 server->caps |= NFS_CAP_NLINK;
3497 if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER)
3498 server->caps |= NFS_CAP_OWNER;
3499 if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER_GROUP)
3500 server->caps |= NFS_CAP_OWNER_GROUP;
3501 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_ACCESS)
3502 server->caps |= NFS_CAP_ATIME;
3503 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_METADATA)
3504 server->caps |= NFS_CAP_CTIME;
3505 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_MODIFY)
3506 server->caps |= NFS_CAP_MTIME;
aa9c2669
DQ		 3507#ifdef CONFIG_NFS_V4_SECURITY_LABEL
3508 if (res.attr_bitmask[2] & FATTR4_WORD2_SECURITY_LABEL)
3509 server->caps |= NFS_CAP_SECURITY_LABEL;
3510#endif
3511 memcpy(server->attr_bitmask_nl, res.attr_bitmask,
3512 sizeof(server->attr_bitmask));
b944dba3 3513 server->attr_bitmask_nl[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
62ab460c 3514
a65318bf
TM		 3515 memcpy(server->cache_consistency_bitmask, res.attr_bitmask, sizeof(server->cache_consistency_bitmask));
3516 server->cache_consistency_bitmask[0] &= FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE;
3517 server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY;
b944dba3 3518 server->cache_consistency_bitmask[2] = 0;
f4b23de3
TM		 3519
3520 /* Avoid a regression due to buggy server */
3521 for (i = 0; i < ARRAY_SIZE(res.exclcreat_bitmask); i++)
3522 res.exclcreat_bitmask[i] &= res.attr_bitmask[i];
8c61282f
KM		 3523 memcpy(server->exclcreat_bitmask, res.exclcreat_bitmask,
3524 sizeof(server->exclcreat_bitmask));
f4b23de3 3525
1da177e4 3526 server->acl_bitmask = res.acl_bitmask;
264e6351 3527 server->fh_expire_type = res.fh_expire_type;
1da177e4 3528 }
cccef3b9 3529
1da177e4
LT		 3530 return status;
3531}
3532
55a97593 3533int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
1da177e4
LT		 3534{
3535 struct nfs4_exception exception = { };
3536 int err;
3537 do {
3538 err = nfs4_handle_exception(server,
3539 _nfs4_server_capabilities(server, fhandle),
3540 &exception);
3541 } while (exception.retry);
3542 return err;
3543}
3544
3545static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
3546 struct nfs_fsinfo *info)
3547{
aa9c2669 3548 u32 bitmask[3];
1da177e4 3549 struct nfs4_lookup_root_arg args = {
aa9c2669 3550 .bitmask = bitmask,
1da177e4
LT		 3551 };
3552 struct nfs4_lookup_res res = {
3553 .server = server,
0e574af1 3554 .fattr = info->fattr,
1da177e4
LT		 3555 .fh = fhandle,
3556 };
3557 struct rpc_message msg = {
3558 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP_ROOT],
3559 .rpc_argp = &args,
3560 .rpc_resp = &res,
3561 };
008f55d0 3562
aa9c2669
DQ		 3563 bitmask[0] = nfs4_fattr_bitmap[0];
3564 bitmask[1] = nfs4_fattr_bitmap[1];
3565 /*
3566 * Process the label in the upcoming getfattr
3567 */
3568 bitmask[2] = nfs4_fattr_bitmap[2] & ~FATTR4_WORD2_SECURITY_LABEL;
3569
0e574af1 3570 nfs_fattr_init(info->fattr);
7c513058 3571 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
1da177e4
LT		 3572}
3573
3574static int nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
3575 struct nfs_fsinfo *info)
3576{
3577 struct nfs4_exception exception = { };
3578 int err;
3579 do {
fb8a5ba8 3580 err = _nfs4_lookup_root(server, fhandle, info);
b5f875a9 3581 trace_nfs4_lookup_root(server, fhandle, info->fattr, err);
fb8a5ba8
BS		 3582 switch (err) {
3583 case 0:
3584 case -NFS4ERR_WRONGSEC:
05e9cfb4 3585 goto out;
fb8a5ba8
BS		 3586 default:
3587 err = nfs4_handle_exception(server, err, &exception);
3588 }
1da177e4 3589 } while (exception.retry);
05e9cfb4 3590out:
1da177e4
LT		 3591 return err;
3592}
3593
8f70e95f
BS		 3594static int nfs4_lookup_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
3595 struct nfs_fsinfo *info, rpc_authflavor_t flavor)
3596{
c2190661
TM		 3597 struct rpc_auth_create_args auth_args = {
3598 .pseudoflavor = flavor,
3599 };
8f70e95f 3600 struct rpc_auth *auth;
8f70e95f 3601
c2190661 3602 auth = rpcauth_create(&auth_args, server->client);
9df1336c
AS		 3603 if (IS_ERR(auth))
3604 return -EACCES;
3605 return nfs4_lookup_root(server, fhandle, info);
8f70e95f
BS		 3606}
3607
9a744ba3
CL		 3608/*
3609 * Retry pseudoroot lookup with various security flavors. We do this when:
3610 *
3611 * NFSv4.0: the PUTROOTFH operation returns NFS4ERR_WRONGSEC
3612 * NFSv4.1: the server does not support the SECINFO_NO_NAME operation
3613 *
3614 * Returns zero on success, or a negative NFS4ERR value, or a
3615 * negative errno value.
3616 */
801a16dc 3617static int nfs4_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
54ceac45 3618 struct nfs_fsinfo *info)
1da177e4 3619{
9a744ba3
CL		 3620 /* Per 3530bis 15.33.5 */
3621 static const rpc_authflavor_t flav_array[] = {
3622 RPC_AUTH_GSS_KRB5P,
3623 RPC_AUTH_GSS_KRB5I,
3624 RPC_AUTH_GSS_KRB5,
c4eafe11 3625 RPC_AUTH_UNIX, /* courtesy */
9a744ba3
CL		 3626 RPC_AUTH_NULL,
3627 };
3628 int status = -EPERM;
3629 size_t i;
6a1a1e34 3630
4d4b69dd
WAA		 3631 if (server->auth_info.flavor_len > 0) {
3632 /* try each flavor specified by user */
3633 for (i = 0; i < server->auth_info.flavor_len; i++) {
3634 status = nfs4_lookup_root_sec(server, fhandle, info,
3635 server->auth_info.flavors[i]);
3636 if (status == -NFS4ERR_WRONGSEC || status == -EACCES)
3637 continue;
3638 break;
3639 }
3640 } else {
3641 /* no flavors specified by user, try default list */
3642 for (i = 0; i < ARRAY_SIZE(flav_array); i++) {
3643 status = nfs4_lookup_root_sec(server, fhandle, info,
3644 flav_array[i]);
3645 if (status == -NFS4ERR_WRONGSEC || status == -EACCES)
3646 continue;
3647 break;
3648 }
8f70e95f 3649 }
9a744ba3 3650
fb8a5ba8
BS		 3651 /*
3652 * -EACCESS could mean that the user doesn't have correct permissions
3653 * to access the mount. It could also mean that we tried to mount
3654 * with a gss auth flavor, but rpc.gssd isn't running. Either way,
3655 * existing mount programs don't handle -EACCES very well so it should
3656 * be mapped to -EPERM instead.
3657 */
3658 if (status == -EACCES)
3659 status = -EPERM;
801a16dc
BS		 3660 return status;
3661}
3662
2ed4b95b
CL		 3663/**
3664 * nfs4_proc_get_rootfh - get file handle for server's pseudoroot
3665 * @server: initialized nfs_server handle
3666 * @fhandle: we fill in the pseudo-fs root file handle
3667 * @info: we fill in an FSINFO struct
5e6b1990 3668 * @auth_probe: probe the auth flavours
2ed4b95b
CL		 3669 *
3670 * Returns zero on success, or a negative errno.
801a16dc 3671 */
3028eb2b 3672int nfs4_proc_get_rootfh(struct nfs_server *server, struct nfs_fh *fhandle,
5e6b1990
TM		 3673 struct nfs_fsinfo *info,
3674 bool auth_probe)
801a16dc 3675{
c7757074 3676 int status = 0;
2ed4b95b 3677
c7757074 3678 if (!auth_probe)
5e6b1990 3679 status = nfs4_lookup_root(server, fhandle, info);
c7757074
AP		 3680
3681 if (auth_probe || status == NFS4ERR_WRONGSEC)
698c937b
TM		 3682 status = server->nfs_client->cl_mvops->find_root_sec(server,
3683 fhandle, info);
2ed4b95b 3684
1da177e4
LT		 3685 if (status == 0)
3686 status = nfs4_server_capabilities(server, fhandle);
3687 if (status == 0)
3688 status = nfs4_do_fsinfo(server, fhandle, info);
2ed4b95b 3689
c12e87f4 3690 return nfs4_map_errors(status);
1da177e4
LT		 3691}
3692
bae36241
BS		 3693static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *mntfh,
3694 struct nfs_fsinfo *info)
3695{
3696 int error;
3697 struct nfs_fattr *fattr = info->fattr;
1775fd3e 3698 struct nfs4_label *label = NULL;
bae36241
BS		 3699
3700 error = nfs4_server_capabilities(server, mntfh);
3701 if (error < 0) {
3702 dprintk("nfs4_get_root: getcaps error = %d\n", -error);
3703 return error;
3704 }
3705
14c43f76
DQ		 3706 label = nfs4_label_alloc(server, GFP_KERNEL);
3707 if (IS_ERR(label))
3708 return PTR_ERR(label);
3709
1775fd3e 3710 error = nfs4_proc_getattr(server, mntfh, fattr, label);
bae36241
BS		 3711 if (error < 0) {
3712 dprintk("nfs4_get_root: getattr error = %d\n", -error);
14c43f76 3713 goto err_free_label;
bae36241
BS		 3714 }
3715
3716 if (fattr->valid & NFS_ATTR_FATTR_FSID &&
3717 !nfs_fsid_equal(&server->fsid, &fattr->fsid))
3718 memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid));
3719
14c43f76
DQ		 3720err_free_label:
3721 nfs4_label_free(label);
3722
bae36241
BS		 3723 return error;
3724}
3725
6b97fd3d
MN		 3726/*
3727 * Get locations and (maybe) other attributes of a referral.
3728 * Note that we'll actually follow the referral later when
3729 * we detect fsid mismatch in inode revalidation
3730 */
f05d147f
BS		 3731static int nfs4_get_referral(struct rpc_clnt *client, struct inode *dir,
3732 const struct qstr *name, struct nfs_fattr *fattr,
3733 struct nfs_fh *fhandle)
6b97fd3d
MN		 3734{
3735 int status = -ENOMEM;
3736 struct page *page = NULL;
3737 struct nfs4_fs_locations *locations = NULL;
6b97fd3d
MN		 3738
3739 page = alloc_page(GFP_KERNEL);
3740 if (page == NULL)
3741 goto out;
3742 locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
3743 if (locations == NULL)
3744 goto out;
3745
f05d147f 3746 status = nfs4_proc_fs_locations(client, dir, name, locations, page);
6b97fd3d
MN		 3747 if (status != 0)
3748 goto out;
519ae255
CL		 3749
3750 /*
3751 * If the fsid didn't change, this is a migration event, not a
3752 * referral. Cause us to drop into the exception handler, which
3753 * will kick off migration recovery.
3754 */
6b97fd3d 3755 if (nfs_fsid_equal(&NFS_SERVER(dir)->fsid, &locations->fattr.fsid)) {
533eb461
AA		 3756 dprintk("%s: server did not return a different fsid for"
3757 " a referral at %s\n", __func__, name->name);
519ae255 3758 status = -NFS4ERR_MOVED;
6b97fd3d
MN		 3759 goto out;
3760 }
533eb461
AA		 3761 /* Fixup attributes for the nfs_lookup() call to nfs_fhget() */
3762 nfs_fixup_referral_attributes(&locations->fattr);
6b97fd3d 3763
533eb461 3764 /* replace the lookup nfs_fattr with the locations nfs_fattr */
6b97fd3d 3765 memcpy(fattr, &locations->fattr, sizeof(struct nfs_fattr));
6b97fd3d
MN		 3766 memset(fhandle, 0, sizeof(struct nfs_fh));
3767out:
3768 if (page)
3769 __free_page(page);
5d7ca35a 3770 kfree(locations);
6b97fd3d
MN		 3771 return status;
3772}
3773
1775fd3e
DQ		 3774static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
3775 struct nfs_fattr *fattr, struct nfs4_label *label)
1da177e4
LT		 3776{
3777 struct nfs4_getattr_arg args = {
3778 .fh = fhandle,
3779 .bitmask = server->attr_bitmask,
3780 };
3781 struct nfs4_getattr_res res = {
3782 .fattr = fattr,
1775fd3e 3783 .label = label,
1da177e4
LT		 3784 .server = server,
3785 };
3786 struct rpc_message msg = {
3787 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETATTR],
3788 .rpc_argp = &args,
3789 .rpc_resp = &res,
3790 };
aa9c2669
DQ		 3791
3792 args.bitmask = nfs4_bitmask(server, label);
3793
0e574af1 3794 nfs_fattr_init(fattr);
7c513058 3795 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
1da177e4
LT		 3796}
3797
1775fd3e
DQ		 3798static int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
3799 struct nfs_fattr *fattr, struct nfs4_label *label)
1da177e4
LT		 3800{
3801 struct nfs4_exception exception = { };
3802 int err;
3803 do {
b5f875a9
TM		 3804 err = _nfs4_proc_getattr(server, fhandle, fattr, label);
3805 trace_nfs4_getattr(server, fhandle, fattr, err);
3806 err = nfs4_handle_exception(server, err,
1da177e4
LT		 3807 &exception);
3808 } while (exception.retry);
3809 return err;
3810}
3811
3812/*
3813 * The file is not closed if it is opened due to the a request to change
3814 * the size of the file. The open call will not be needed once the
3815 * VFS layer lookup-intents are implemented.
3816 *
3817 * Close is called when the inode is destroyed.
3818 * If we haven't opened the file for O_WRONLY, we
3819 * need to in the size_change case to obtain a stateid.
3820 *
3821 * Got race?
3822 * Because OPEN is always done by name in nfsv4, it is
3823 * possible that we opened a different file by the same
3824 * name. We can recognize this race condition, but we
3825 * can't do anything about it besides returning an error.
3826 *
3827 * This will be fixed with VFS changes (lookup-intent).
3828 */
3829static int
3830nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
3831 struct iattr *sattr)
3832{
2b0143b5 3833 struct inode *inode = d_inode(dentry);
659bfcd6 3834 struct rpc_cred *cred = NULL;
29b59f94 3835 struct nfs_open_context *ctx = NULL;
14c43f76 3836 struct nfs4_label *label = NULL;
1da177e4
LT		 3837 int status;
3838
88ac815c
PT		 3839 if (pnfs_ld_layoutret_on_setattr(inode) &&
3840 sattr->ia_valid & ATTR_SIZE &&
3841 sattr->ia_size < i_size_read(inode))
24028672 3842 pnfs_commit_and_return_layout(inode);
8a1636c4 3843
0e574af1 3844 nfs_fattr_init(fattr);
1da177e4 3845
2669940d
AA		 3846 /* Deal with open(O_TRUNC) */
3847 if (sattr->ia_valid & ATTR_OPEN)
cc7936f9 3848 sattr->ia_valid &= ~(ATTR_MTIME|ATTR_CTIME);
2669940d
AA		 3849
3850 /* Optimization: if the end result is no change, don't RPC */
cc7936f9 3851 if ((sattr->ia_valid & ~(ATTR_FILE|ATTR_OPEN)) == 0)
2669940d
AA		 3852 return 0;
3853
d530838b 3854 /* Search for an existing open(O_WRITE) file */
659bfcd6 3855 if (sattr->ia_valid & ATTR_FILE) {
659bfcd6
TM		 3856
3857 ctx = nfs_file_open_context(sattr->ia_file);
29b59f94 3858 if (ctx)
504e5189 3859 cred = ctx->cred;
659bfcd6 3860 }
08e9eac4 3861
14c43f76
DQ		 3862 label = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL);
3863 if (IS_ERR(label))
3864 return PTR_ERR(label);
3865
29b59f94 3866 status = nfs4_do_setattr(inode, cred, fattr, sattr, ctx, NULL, label);
aa9c2669 3867 if (status == 0) {
f044636d 3868 nfs_setattr_update_inode(inode, sattr, fattr);
aa9c2669
DQ		 3869 nfs_setsecurity(inode, fattr, label);
3870 }
14c43f76 3871 nfs4_label_free(label);
1da177e4
LT		 3872 return status;
3873}
3874
0c2e53f1
TM		 3875static int _nfs4_proc_lookup(struct rpc_clnt *clnt, struct inode *dir,
3876 const struct qstr *name, struct nfs_fh *fhandle,
1775fd3e 3877 struct nfs_fattr *fattr, struct nfs4_label *label)
2b3de441 3878{
0c2e53f1 3879 struct nfs_server *server = NFS_SERVER(dir);
2b3de441
DH		 3880 int status;
3881 struct nfs4_lookup_arg args = {
3882 .bitmask = server->attr_bitmask,
0c2e53f1 3883 .dir_fh = NFS_FH(dir),
2b3de441
DH		 3884 .name = name,
3885 };
3886 struct nfs4_lookup_res res = {
3887 .server = server,
3888 .fattr = fattr,
aa9c2669 3889 .label = label,
2b3de441
DH		 3890 .fh = fhandle,
3891 };
3892 struct rpc_message msg = {
3893 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP],
3894 .rpc_argp = &args,
3895 .rpc_resp = &res,
3896 };
3897
aa9c2669
DQ		 3898 args.bitmask = nfs4_bitmask(server, label);
3899
2b3de441
DH		 3900 nfs_fattr_init(fattr);
3901
1da177e4 3902 dprintk("NFS call lookup %s\n", name->name);
0c2e53f1 3903 status = nfs4_call_sync(clnt, server, &msg, &args.seq_args, &res.seq_res, 0);
1da177e4
LT		 3904 dprintk("NFS reply lookup: %d\n", status);
3905 return status;
3906}
3907
72de53ec 3908static void nfs_fixup_secinfo_attributes(struct nfs_fattr *fattr)
7ebb9315 3909{
7ebb9315 3910 fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE |
72de53ec 3911 NFS_ATTR_FATTR_NLINK | NFS_ATTR_FATTR_MOUNTPOINT;
7ebb9315
BS		 3912 fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO;
3913 fattr->nlink = 2;
3914}
3915
72de53ec 3916static int nfs4_proc_lookup_common(struct rpc_clnt **clnt, struct inode *dir,
beffb8fe 3917 const struct qstr *name, struct nfs_fh *fhandle,
1775fd3e 3918 struct nfs_fattr *fattr, struct nfs4_label *label)
1da177e4
LT		 3919{
3920 struct nfs4_exception exception = { };
72de53ec 3921 struct rpc_clnt *client = *clnt;
1da177e4
LT		 3922 int err;
3923 do {
1775fd3e 3924 err = _nfs4_proc_lookup(client, dir, name, fhandle, fattr, label);
078ea3df 3925 trace_nfs4_lookup(dir, name, err);
72de53ec 3926 switch (err) {
08ef7bd3 3927 case -NFS4ERR_BADNAME:
72de53ec
BS		 3928 err = -ENOENT;
3929 goto out;
0c2e53f1 3930 case -NFS4ERR_MOVED:
f05d147f 3931 err = nfs4_get_referral(client, dir, name, fattr, fhandle);
c86c90c6
DM		 3932 if (err == -NFS4ERR_MOVED)
3933 err = nfs4_handle_exception(NFS_SERVER(dir), err, &exception);
72de53ec 3934 goto out;
0c2e53f1 3935 case -NFS4ERR_WRONGSEC:
72de53ec
BS		 3936 err = -EPERM;
3937 if (client != *clnt)
3938 goto out;
66b06860 3939 client = nfs4_negotiate_security(client, dir, name);
72de53ec
BS		 3940 if (IS_ERR(client))
3941 return PTR_ERR(client);
3942
3943 exception.retry = 1;
3944 break;
3945 default:
3946 err = nfs4_handle_exception(NFS_SERVER(dir), err, &exception);
0c2e53f1 3947 }
1da177e4 3948 } while (exception.retry);
72de53ec
BS		 3949
3950out:
3951 if (err == 0)
3952 *clnt = client;
3953 else if (client != *clnt)
3954 rpc_shutdown_client(client);
3955
1da177e4
LT		 3956 return err;
3957}
3958
beffb8fe 3959static int nfs4_proc_lookup(struct inode *dir, const struct qstr *name,
1775fd3e
DQ		 3960 struct nfs_fh *fhandle, struct nfs_fattr *fattr,
3961 struct nfs4_label *label)
72de53ec
BS		 3962{
3963 int status;
3964 struct rpc_clnt *client = NFS_CLIENT(dir);
3965
1775fd3e 3966 status = nfs4_proc_lookup_common(&client, dir, name, fhandle, fattr, label);
72de53ec
BS		 3967 if (client != NFS_CLIENT(dir)) {
3968 rpc_shutdown_client(client);
3969 nfs_fixup_secinfo_attributes(fattr);
3970 }
3971 return status;
3972}
3973
f05d147f 3974struct rpc_clnt *
beffb8fe 3975nfs4_proc_lookup_mountpoint(struct inode *dir, const struct qstr *name,
f05d147f
BS		 3976 struct nfs_fh *fhandle, struct nfs_fattr *fattr)
3977{
b72888cb 3978 struct rpc_clnt *client = NFS_CLIENT(dir);
f05d147f 3979 int status;
f05d147f 3980
1775fd3e 3981 status = nfs4_proc_lookup_common(&client, dir, name, fhandle, fattr, NULL);
b72888cb 3982 if (status < 0)
f05d147f 3983 return ERR_PTR(status);
b72888cb 3984 return (client == NFS_CLIENT(dir)) ? rpc_clone_client(client) : client;
f05d147f
BS		 3985}
3986
5b5faaf6
JL		 3987static int _nfs4_proc_lookupp(struct inode *inode,
3988 struct nfs_fh *fhandle, struct nfs_fattr *fattr,
3989 struct nfs4_label *label)
3990{
3991 struct rpc_clnt *clnt = NFS_CLIENT(inode);
3992 struct nfs_server *server = NFS_SERVER(inode);
3993 int status;
3994 struct nfs4_lookupp_arg args = {
3995 .bitmask = server->attr_bitmask,
3996 .fh = NFS_FH(inode),
3997 };
3998 struct nfs4_lookupp_res res = {
3999 .server = server,
4000 .fattr = fattr,
4001 .label = label,
4002 .fh = fhandle,
4003 };
4004 struct rpc_message msg = {
4005 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUPP],
4006 .rpc_argp = &args,
4007 .rpc_resp = &res,
4008 };
4009
4010 args.bitmask = nfs4_bitmask(server, label);
4011
4012 nfs_fattr_init(fattr);
4013
4014 dprintk("NFS call lookupp ino=0x%lx\n", inode->i_ino);
4015 status = nfs4_call_sync(clnt, server, &msg, &args.seq_args,
4016 &res.seq_res, 0);
4017 dprintk("NFS reply lookupp: %d\n", status);
4018 return status;
4019}
4020
4021static int nfs4_proc_lookupp(struct inode *inode, struct nfs_fh *fhandle,
4022 struct nfs_fattr *fattr, struct nfs4_label *label)
4023{
4024 struct nfs4_exception exception = { };
4025 int err;
4026 do {
4027 err = _nfs4_proc_lookupp(inode, fhandle, fattr, label);
4028 trace_nfs4_lookupp(inode, err);
4029 err = nfs4_handle_exception(NFS_SERVER(inode), err,
4030 &exception);
4031 } while (exception.retry);
4032 return err;
4033}
4034
1da177e4
LT		 4035static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)
4036{
76b32999 4037 struct nfs_server *server = NFS_SERVER(inode);
1da177e4
LT		 4038 struct nfs4_accessargs args = {
4039 .fh = NFS_FH(inode),
a4980e78 4040 .bitmask = server->cache_consistency_bitmask,
1750d929 4041 .access = entry->mask,
76b32999
TM		 4042 };
4043 struct nfs4_accessres res = {
4044 .server = server,
1da177e4 4045 };
1da177e4
LT		 4046 struct rpc_message msg = {
4047 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ACCESS],
4048 .rpc_argp = &args,
4049 .rpc_resp = &res,
4050 .rpc_cred = entry->cred,
4051 };
aa9c2669 4052 int status = 0;
1da177e4 4053
c407d41a
TM		 4054 res.fattr = nfs_alloc_fattr();
4055 if (res.fattr == NULL)
4056 return -ENOMEM;
4057
7c513058 4058 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
1da177e4 4059 if (!status) {
6168f62c 4060 nfs_access_set_mask(entry, res.access);
c407d41a 4061 nfs_refresh_inode(inode, res.fattr);
1da177e4 4062 }
c407d41a 4063 nfs_free_fattr(res.fattr);
1da177e4
LT		 4064 return status;
4065}
4066
4067static int nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)
4068{
4069 struct nfs4_exception exception = { };
4070 int err;
4071 do {
c1578b76
TM		 4072 err = _nfs4_proc_access(inode, entry);
4073 trace_nfs4_access(inode, err);
4074 err = nfs4_handle_exception(NFS_SERVER(inode), err,
1da177e4
LT		 4075 &exception);
4076 } while (exception.retry);
4077 return err;
4078}
4079
4080/*
4081 * TODO: For the time being, we don't try to get any attributes
4082 * along with any of the zero-copy operations READ, READDIR,
4083 * READLINK, WRITE.
4084 *
4085 * In the case of the first three, we want to put the GETATTR
4086 * after the read-type operation -- this is because it is hard
4087 * to predict the length of a GETATTR response in v4, and thus
4088 * align the READ data correctly. This means that the GETATTR
4089 * may end up partially falling into the page cache, and we should
4090 * shift it into the 'tail' of the xdr_buf before processing.
4091 * To do this efficiently, we need to know the total length
4092 * of data received, which doesn't seem to be available outside
4093 * of the RPC layer.
4094 *
4095 * In the case of WRITE, we also want to put the GETATTR after
4096 * the operation -- in this case because we want to make sure
140150db 4097 * we get the post-operation mtime and size.
1da177e4
LT		 4098 *
4099 * Both of these changes to the XDR layer would in fact be quite
4100 * minor, but I decided to leave them for a subsequent patch.
4101 */
4102static int _nfs4_proc_readlink(struct inode *inode, struct page *page,
4103 unsigned int pgbase, unsigned int pglen)
4104{
4105 struct nfs4_readlink args = {
4106 .fh = NFS_FH(inode),
4107 .pgbase = pgbase,
4108 .pglen = pglen,
4109 .pages = &page,
4110 };
f50c7000 4111 struct nfs4_readlink_res res;
1da177e4
LT		 4112 struct rpc_message msg = {
4113 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READLINK],
4114 .rpc_argp = &args,
f50c7000 4115 .rpc_resp = &res,
1da177e4
LT		 4116 };
4117
7c513058 4118 return nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode), &msg, &args.seq_args, &res.seq_res, 0);
1da177e4
LT		 4119}
4120
4121static int nfs4_proc_readlink(struct inode *inode, struct page *page,
4122 unsigned int pgbase, unsigned int pglen)
4123{
4124 struct nfs4_exception exception = { };
4125 int err;
4126 do {
c1578b76
TM		 4127 err = _nfs4_proc_readlink(inode, page, pgbase, pglen);
4128 trace_nfs4_readlink(inode, err);
4129 err = nfs4_handle_exception(NFS_SERVER(inode), err,
1da177e4
LT		 4130 &exception);
4131 } while (exception.retry);
4132 return err;
4133}
4134
1da177e4 4135/*
8867fe58 4136 * This is just for mknod. open(O_CREAT) will always do ->open_context().
1da177e4 4137 */
1da177e4
LT		 4138static int
4139nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
8867fe58 4140 int flags)
1da177e4 4141{
dff25ddb 4142 struct nfs_server *server = NFS_SERVER(dir);
aa9c2669 4143 struct nfs4_label l, *ilabel = NULL;
8867fe58 4144 struct nfs_open_context *ctx;
1da177e4 4145 struct nfs4_state *state;
1da177e4
LT		 4146 int status = 0;
4147
532d4def 4148 ctx = alloc_nfs_open_context(dentry, FMODE_READ, NULL);
8867fe58
MS		 4149 if (IS_ERR(ctx))
4150 return PTR_ERR(ctx);
4151
aa9c2669
DQ		 4152 ilabel = nfs4_label_init_security(dir, dentry, sattr, &l);
4153
dff25ddb
AG		 4154 if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK))
4155 sattr->ia_mode &= ~current_umask();
c5c3fb5f 4156 state = nfs4_do_open(dir, ctx, flags, sattr, ilabel, NULL);
1da177e4
LT		 4157 if (IS_ERR(state)) {
4158 status = PTR_ERR(state);
c0204fd2 4159 goto out;
1da177e4 4160 }
1da177e4 4161out:
aa9c2669 4162 nfs4_label_release_security(ilabel);
8867fe58 4163 put_nfs_open_context(ctx);
1da177e4
LT		 4164 return status;
4165}
4166
beffb8fe 4167static int _nfs4_proc_remove(struct inode *dir, const struct qstr *name)
1da177e4 4168{
16e42959 4169 struct nfs_server *server = NFS_SERVER(dir);
4fdc17b2 4170 struct nfs_removeargs args = {
1da177e4 4171 .fh = NFS_FH(dir),
26fe5750 4172 .name = *name,
16e42959 4173 };
4fdc17b2 4174 struct nfs_removeres res = {
16e42959 4175 .server = server,
1da177e4 4176 };
1da177e4 4177 struct rpc_message msg = {
4fdc17b2
TM		 4178 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE],
4179 .rpc_argp = &args,
4180 .rpc_resp = &res,
1da177e4 4181 };
d3129ef6 4182 unsigned long timestamp = jiffies;
778d2817 4183 int status;
1da177e4 4184
7c513058 4185 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 1);
778d2817 4186 if (status == 0)
d3129ef6 4187 update_changeattr(dir, &res.cinfo, timestamp);
1da177e4
LT		 4188 return status;
4189}
4190
beffb8fe 4191static int nfs4_proc_remove(struct inode *dir, const struct qstr *name)
1da177e4
LT		 4192{
4193 struct nfs4_exception exception = { };
4194 int err;
4195 do {
078ea3df
TM		 4196 err = _nfs4_proc_remove(dir, name);
4197 trace_nfs4_remove(dir, name, err);
4198 err = nfs4_handle_exception(NFS_SERVER(dir), err,
1da177e4
LT		 4199 &exception);
4200 } while (exception.retry);
4201 return err;
4202}
4203
e4eff1a6 4204static void nfs4_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
1da177e4 4205{
e4eff1a6
TM		 4206 struct nfs_server *server = NFS_SERVER(dir);
4207 struct nfs_removeargs *args = msg->rpc_argp;
4208 struct nfs_removeres *res = msg->rpc_resp;
1da177e4 4209
e4eff1a6 4210 res->server = server;
1da177e4 4211 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE];
a9c92d6b 4212 nfs4_init_sequence(&args->seq_args, &res->seq_res, 1);
aa9c2669
DQ		 4213
4214 nfs_fattr_init(res->dir_attr);
1da177e4
LT		 4215}
4216
34e137cc
BS		 4217static void nfs4_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
4218{
42e1cca7 4219 nfs4_setup_sequence(NFS_SB(data->dentry->d_sb)->nfs_client,
d9afbd1b
TM		 4220 &data->args.seq_args,
4221 &data->res.seq_res,
4222 task);
1da177e4
LT		 4223}
4224
e4eff1a6 4225static int nfs4_proc_unlink_done(struct rpc_task *task, struct inode *dir)
1da177e4 4226{
078ea3df
TM		 4227 struct nfs_unlinkdata *data = task->tk_calldata;
4228 struct nfs_removeres *res = &data->res;
e4eff1a6 4229
14516c3a
TM		 4230 if (!nfs4_sequence_done(task, &res->seq_res))
4231 return 0;
8478eaa1
N		 4232 if (nfs4_async_handle_error(task, res->server, NULL,
4233 &data->timeout) == -EAGAIN)
e4eff1a6 4234 return 0;
c40d52fe 4235 if (task->tk_status == 0)
d3129ef6 4236 update_changeattr(dir, &res->cinfo, res->dir_attr->time_start);
e4eff1a6 4237 return 1;
1da177e4
LT		 4238}
4239
d3d4152a
JL		 4240static void nfs4_proc_rename_setup(struct rpc_message *msg, struct inode *dir)
4241{
4242 struct nfs_server *server = NFS_SERVER(dir);
4243 struct nfs_renameargs *arg = msg->rpc_argp;
4244 struct nfs_renameres *res = msg->rpc_resp;
4245
4246 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME];
d3d4152a 4247 res->server = server;
a9c92d6b 4248 nfs4_init_sequence(&arg->seq_args, &res->seq_res, 1);
d3d4152a
JL		 4249}
4250
c6bfa1a1
BS		 4251static void nfs4_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
4252{
42e1cca7 4253 nfs4_setup_sequence(NFS_SERVER(data->old_dir)->nfs_client,
d9afbd1b
TM		 4254 &data->args.seq_args,
4255 &data->res.seq_res,
4256 task);
d3d4152a
JL		 4257}
4258
4259static int nfs4_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
4260 struct inode *new_dir)
4261{
fbc6f7c2
TM		 4262 struct nfs_renamedata *data = task->tk_calldata;
4263 struct nfs_renameres *res = &data->res;
d3d4152a
JL		 4264
4265 if (!nfs4_sequence_done(task, &res->seq_res))
4266 return 0;
8478eaa1 4267 if (nfs4_async_handle_error(task, res->server, NULL, &data->timeout) == -EAGAIN)
d3d4152a
JL		 4268 return 0;
4269
c733c49c 4270 if (task->tk_status == 0) {
d3129ef6 4271 update_changeattr(old_dir, &res->old_cinfo, res->old_fattr->time_start);
c733c49c 4272 if (new_dir != old_dir)
d3129ef6 4273 update_changeattr(new_dir, &res->new_cinfo, res->new_fattr->time_start);
c733c49c 4274 }
d3d4152a
JL		 4275 return 1;
4276}
4277
beffb8fe 4278static int _nfs4_proc_link(struct inode *inode, struct inode *dir, const struct qstr *name)
1da177e4 4279{
91ba2eee 4280 struct nfs_server *server = NFS_SERVER(inode);
1da177e4
LT		 4281 struct nfs4_link_arg arg = {
4282 .fh = NFS_FH(inode),
4283 .dir_fh = NFS_FH(dir),
4284 .name = name,
91ba2eee
TM		 4285 .bitmask = server->attr_bitmask,
4286 };
91ba2eee
TM		 4287 struct nfs4_link_res res = {
4288 .server = server,
1775fd3e 4289 .label = NULL,
1da177e4 4290 };
1da177e4
LT		 4291 struct rpc_message msg = {
4292 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LINK],
4293 .rpc_argp = &arg,
91ba2eee 4294 .rpc_resp = &res,
1da177e4 4295 };
136f2627
TM		 4296 int status = -ENOMEM;
4297
4298 res.fattr = nfs_alloc_fattr();
778d2817 4299 if (res.fattr == NULL)
136f2627 4300 goto out;
1da177e4 4301
14c43f76
DQ		 4302 res.label = nfs4_label_alloc(server, GFP_KERNEL);
4303 if (IS_ERR(res.label)) {
4304 status = PTR_ERR(res.label);
4305 goto out;
4306 }
aa9c2669 4307 arg.bitmask = nfs4_bitmask(server, res.label);
14c43f76 4308
7c513058 4309 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
91ba2eee 4310 if (!status) {
d3129ef6 4311 update_changeattr(dir, &res.cinfo, res.fattr->time_start);
aa9c2669
DQ		 4312 status = nfs_post_op_update_inode(inode, res.fattr);
4313 if (!status)
4314 nfs_setsecurity(inode, res.fattr, res.label);
91ba2eee 4315 }
14c43f76
DQ		 4316
4317
4318 nfs4_label_free(res.label);
4319
136f2627 4320out:
136f2627 4321 nfs_free_fattr(res.fattr);
1da177e4
LT		 4322 return status;
4323}
4324
beffb8fe 4325static int nfs4_proc_link(struct inode *inode, struct inode *dir, const struct qstr *name)
1da177e4
LT		 4326{
4327 struct nfs4_exception exception = { };
4328 int err;
4329 do {
4330 err = nfs4_handle_exception(NFS_SERVER(inode),
4331 _nfs4_proc_link(inode, dir, name),
4332 &exception);
4333 } while (exception.retry);
4334 return err;
4335}
4336
57dc9a57
TM		 4337struct nfs4_createdata {
4338 struct rpc_message msg;
4339 struct nfs4_create_arg arg;
4340 struct nfs4_create_res res;
4341 struct nfs_fh fh;
4342 struct nfs_fattr fattr;
1775fd3e 4343 struct nfs4_label *label;
57dc9a57
TM		 4344};
4345
4346static struct nfs4_createdata *nfs4_alloc_createdata(struct inode *dir,
beffb8fe 4347 const struct qstr *name, struct iattr *sattr, u32 ftype)
57dc9a57
TM		 4348{
4349 struct nfs4_createdata *data;
4350
4351 data = kzalloc(sizeof(*data), GFP_KERNEL);
4352 if (data != NULL) {
4353 struct nfs_server *server = NFS_SERVER(dir);
4354
14c43f76
DQ		 4355 data->label = nfs4_label_alloc(server, GFP_KERNEL);
4356 if (IS_ERR(data->label))
4357 goto out_free;
4358
57dc9a57
TM		 4359 data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE];
4360 data->msg.rpc_argp = &data->arg;
4361 data->msg.rpc_resp = &data->res;
4362 data->arg.dir_fh = NFS_FH(dir);
4363 data->arg.server = server;
4364 data->arg.name = name;
4365 data->arg.attrs = sattr;
4366 data->arg.ftype = ftype;
aa9c2669 4367 data->arg.bitmask = nfs4_bitmask(server, data->label);
dff25ddb 4368 data->arg.umask = current_umask();
57dc9a57
TM		 4369 data->res.server = server;
4370 data->res.fh = &data->fh;
4371 data->res.fattr = &data->fattr;
1775fd3e 4372 data->res.label = data->label;
57dc9a57 4373 nfs_fattr_init(data->res.fattr);
57dc9a57
TM		 4374 }
4375 return data;
14c43f76
DQ		 4376out_free:
4377 kfree(data);
4378 return NULL;
57dc9a57
TM		 4379}
4380
4381static int nfs4_do_create(struct inode *dir, struct dentry *dentry, struct nfs4_createdata *data)
4382{
7c513058 4383 int status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &data->msg,
e73b83f2 4384 &data->arg.seq_args, &data->res.seq_res, 1);
57dc9a57 4385 if (status == 0) {
d3129ef6
TM		 4386 update_changeattr(dir, &data->res.dir_cinfo,
4387 data->res.fattr->time_start);
1775fd3e 4388 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, data->res.label);
57dc9a57
TM		 4389 }
4390 return status;
4391}
4392
4393static void nfs4_free_createdata(struct nfs4_createdata *data)
4394{
14c43f76 4395 nfs4_label_free(data->label);
57dc9a57
TM		 4396 kfree(data);
4397}
4398
4f390c15 4399static int _nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
1775fd3e
DQ		 4400 struct page *page, unsigned int len, struct iattr *sattr,
4401 struct nfs4_label *label)
1da177e4 4402{
57dc9a57
TM		 4403 struct nfs4_createdata *data;
4404 int status = -ENAMETOOLONG;
1da177e4 4405
94a6d753 4406 if (len > NFS4_MAXPATHLEN)
57dc9a57 4407 goto out;
4f390c15 4408
57dc9a57
TM		 4409 status = -ENOMEM;
4410 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4LNK);
4411 if (data == NULL)
4412 goto out;
4413
4414 data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SYMLINK];
4415 data->arg.u.symlink.pages = &page;
4416 data->arg.u.symlink.len = len;
1775fd3e 4417 data->arg.label = label;
1da177e4 4418
57dc9a57
TM		 4419 status = nfs4_do_create(dir, dentry, data);
4420
4421 nfs4_free_createdata(data);
4422out:
1da177e4
LT		 4423 return status;
4424}
4425
4f390c15 4426static int nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
94a6d753 4427 struct page *page, unsigned int len, struct iattr *sattr)
1da177e4
LT		 4428{
4429 struct nfs4_exception exception = { };
aa9c2669 4430 struct nfs4_label l, *label = NULL;
1da177e4 4431 int err;
aa9c2669
DQ		 4432
4433 label = nfs4_label_init_security(dir, dentry, sattr, &l);
4434
1da177e4 4435 do {
078ea3df
TM		 4436 err = _nfs4_proc_symlink(dir, dentry, page, len, sattr, label);
4437 trace_nfs4_symlink(dir, &dentry->d_name, err);
4438 err = nfs4_handle_exception(NFS_SERVER(dir), err,
1da177e4
LT		 4439 &exception);
4440 } while (exception.retry);
aa9c2669
DQ		 4441
4442 nfs4_label_release_security(label);
1da177e4
LT		 4443 return err;
4444}
4445
4446static int _nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
1775fd3e 4447 struct iattr *sattr, struct nfs4_label *label)
1da177e4 4448{
57dc9a57
TM		 4449 struct nfs4_createdata *data;
4450 int status = -ENOMEM;
1da177e4 4451
57dc9a57
TM		 4452 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4DIR);
4453 if (data == NULL)
4454 goto out;
4455
1775fd3e 4456 data->arg.label = label;
57dc9a57
TM		 4457 status = nfs4_do_create(dir, dentry, data);
4458
4459 nfs4_free_createdata(data);
4460out:
1da177e4
LT		 4461 return status;
4462}
4463
4464static int nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
4465 struct iattr *sattr)
4466{
dff25ddb 4467 struct nfs_server *server = NFS_SERVER(dir);
1da177e4 4468 struct nfs4_exception exception = { };
aa9c2669 4469 struct nfs4_label l, *label = NULL;
1da177e4 4470 int err;
a8a5da99 4471
aa9c2669
DQ		 4472 label = nfs4_label_init_security(dir, dentry, sattr, &l);
4473
dff25ddb
AG		 4474 if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK))
4475 sattr->ia_mode &= ~current_umask();
1da177e4 4476 do {
078ea3df
TM		 4477 err = _nfs4_proc_mkdir(dir, dentry, sattr, label);
4478 trace_nfs4_mkdir(dir, &dentry->d_name, err);
4479 err = nfs4_handle_exception(NFS_SERVER(dir), err,
1da177e4
LT		 4480 &exception);
4481 } while (exception.retry);
aa9c2669
DQ		 4482 nfs4_label_release_security(label);
4483
1da177e4
LT		 4484 return err;
4485}
4486
4487static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
a7a3b1e9 4488 u64 cookie, struct page **pages, unsigned int count, bool plus)
1da177e4 4489{
2b0143b5 4490 struct inode *dir = d_inode(dentry);
1da177e4
LT		 4491 struct nfs4_readdir_arg args = {
4492 .fh = NFS_FH(dir),
56e4ebf8 4493 .pages = pages,
1da177e4
LT		 4494 .pgbase = 0,
4495 .count = count,
2b0143b5 4496 .bitmask = NFS_SERVER(d_inode(dentry))->attr_bitmask,
82f2e547 4497 .plus = plus,
1da177e4
LT		 4498 };
4499 struct nfs4_readdir_res res;
4500 struct rpc_message msg = {
4501 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READDIR],
4502 .rpc_argp = &args,
4503 .rpc_resp = &res,
4504 .rpc_cred = cred,
4505 };
4506 int status;
4507
6de1472f
AV		 4508 dprintk("%s: dentry = %pd2, cookie = %Lu\n", __func__,
4509 dentry,
eadf4598 4510 (unsigned long long)cookie);
c3f52af3 4511 nfs4_setup_readdir(cookie, NFS_I(dir)->cookieverf, dentry, &args);
1da177e4 4512 res.pgbase = args.pgbase;
7c513058 4513 status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &msg, &args.seq_args, &res.seq_res, 0);
ac396128 4514 if (status >= 0) {
c3f52af3 4515 memcpy(NFS_I(dir)->cookieverf, res.verifier.data, NFS4_VERIFIER_SIZE);
ac396128
TM		 4516 status += args.pgbase;
4517 }
c4812998
TM		 4518
4519 nfs_invalidate_atime(dir);
4520
3110ff80 4521 dprintk("%s: returns %d\n", __func__, status);
1da177e4
LT		 4522 return status;
4523}
4524
4525static int nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
a7a3b1e9 4526 u64 cookie, struct page **pages, unsigned int count, bool plus)
1da177e4
LT		 4527{
4528 struct nfs4_exception exception = { };
4529 int err;
4530 do {
c1578b76
TM		 4531 err = _nfs4_proc_readdir(dentry, cred, cookie,
4532 pages, count, plus);
2b0143b5
DH		 4533 trace_nfs4_readdir(d_inode(dentry), err);
4534 err = nfs4_handle_exception(NFS_SERVER(d_inode(dentry)), err,
1da177e4
LT		 4535 &exception);
4536 } while (exception.retry);
4537 return err;
4538}
4539
4540static int _nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
aa9c2669 4541 struct iattr *sattr, struct nfs4_label *label, dev_t rdev)
1da177e4 4542{
57dc9a57
TM		 4543 struct nfs4_createdata *data;
4544 int mode = sattr->ia_mode;
4545 int status = -ENOMEM;
1da177e4 4546
57dc9a57
TM		 4547 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4SOCK);
4548 if (data == NULL)
4549 goto out;
4550
1da177e4 4551 if (S_ISFIFO(mode))
57dc9a57 4552 data->arg.ftype = NF4FIFO;
1da177e4 4553 else if (S_ISBLK(mode)) {
57dc9a57
TM		 4554 data->arg.ftype = NF4BLK;
4555 data->arg.u.device.specdata1 = MAJOR(rdev);
4556 data->arg.u.device.specdata2 = MINOR(rdev);
1da177e4
LT		 4557 }
4558 else if (S_ISCHR(mode)) {
57dc9a57
TM		 4559 data->arg.ftype = NF4CHR;
4560 data->arg.u.device.specdata1 = MAJOR(rdev);
4561 data->arg.u.device.specdata2 = MINOR(rdev);
4ea8fed5
TM		 4562 } else if (!S_ISSOCK(mode)) {
4563 status = -EINVAL;
4564 goto out_free;
1da177e4 4565 }
1775fd3e 4566
aa9c2669 4567 data->arg.label = label;
57dc9a57 4568 status = nfs4_do_create(dir, dentry, data);
4ea8fed5 4569out_free:
57dc9a57
TM		 4570 nfs4_free_createdata(data);
4571out:
1da177e4
LT		 4572 return status;
4573}
4574
4575static int nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
4576 struct iattr *sattr, dev_t rdev)
4577{
dff25ddb 4578 struct nfs_server *server = NFS_SERVER(dir);
1da177e4 4579 struct nfs4_exception exception = { };
aa9c2669 4580 struct nfs4_label l, *label = NULL;
1da177e4 4581 int err;
a8a5da99 4582
aa9c2669
DQ		 4583 label = nfs4_label_init_security(dir, dentry, sattr, &l);
4584
dff25ddb
AG		 4585 if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK))
4586 sattr->ia_mode &= ~current_umask();
1da177e4 4587 do {
078ea3df
TM		 4588 err = _nfs4_proc_mknod(dir, dentry, sattr, label, rdev);
4589 trace_nfs4_mknod(dir, &dentry->d_name, err);
4590 err = nfs4_handle_exception(NFS_SERVER(dir), err,
1da177e4
LT		 4591 &exception);
4592 } while (exception.retry);
aa9c2669
DQ		 4593
4594 nfs4_label_release_security(label);
4595
1da177e4
LT		 4596 return err;
4597}
4598
4599static int _nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
4600 struct nfs_fsstat *fsstat)
4601{
4602 struct nfs4_statfs_arg args = {
4603 .fh = fhandle,
4604 .bitmask = server->attr_bitmask,
4605 };
24ad148a
BH		 4606 struct nfs4_statfs_res res = {
4607 .fsstat = fsstat,
4608 };
1da177e4
LT		 4609 struct rpc_message msg = {
4610 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_STATFS],
4611 .rpc_argp = &args,
24ad148a 4612 .rpc_resp = &res,
1da177e4
LT		 4613 };
4614
0e574af1 4615 nfs_fattr_init(fsstat->fattr);
7c513058 4616 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
1da177e4
LT		 4617}
4618
4619static int nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsstat *fsstat)
4620{
4621 struct nfs4_exception exception = { };
4622 int err;
4623 do {
4624 err = nfs4_handle_exception(server,
4625 _nfs4_proc_statfs(server, fhandle, fsstat),
4626 &exception);
4627 } while (exception.retry);
4628 return err;
4629}
4630
4631static int _nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
4632 struct nfs_fsinfo *fsinfo)
4633{
4634 struct nfs4_fsinfo_arg args = {
4635 .fh = fhandle,
4636 .bitmask = server->attr_bitmask,
4637 };
3dda5e43
BH		 4638 struct nfs4_fsinfo_res res = {
4639 .fsinfo = fsinfo,
4640 };
1da177e4
LT		 4641 struct rpc_message msg = {
4642 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSINFO],
4643 .rpc_argp = &args,
3dda5e43 4644 .rpc_resp = &res,
1da177e4
LT		 4645 };
4646
7c513058 4647 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
1da177e4
LT		 4648}
4649
4650static int nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
4651{
4652 struct nfs4_exception exception = { };
83ca7f5a 4653 unsigned long now = jiffies;
1da177e4
LT		 4654 int err;
4655
4656 do {
83ca7f5a 4657 err = _nfs4_do_fsinfo(server, fhandle, fsinfo);
b5f875a9 4658 trace_nfs4_fsinfo(server, fhandle, fsinfo->fattr, err);
83ca7f5a 4659 if (err == 0) {
fb10fb67
TM		 4660 nfs4_set_lease_period(server->nfs_client,
4661 fsinfo->lease_time * HZ,
4662 now);
83ca7f5a
CL		 4663 break;
4664 }
4665 err = nfs4_handle_exception(server, err, &exception);
1da177e4
LT		 4666 } while (exception.retry);
4667 return err;
4668}
4669
4670static int nfs4_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
4671{
e38eb650
BS		 4672 int error;
4673
0e574af1 4674 nfs_fattr_init(fsinfo->fattr);
e38eb650 4675 error = nfs4_do_fsinfo(server, fhandle, fsinfo);
dc182549
PT		 4676 if (error == 0) {
4677 /* block layout checks this! */
4678 server->pnfs_blksize = fsinfo->blksize;
ca440c38 4679 set_pnfs_layoutdriver(server, fhandle, fsinfo);
dc182549 4680 }
e38eb650
BS		 4681
4682 return error;
1da177e4
LT		 4683}
4684
4685static int _nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
4686 struct nfs_pathconf *pathconf)
4687{
4688 struct nfs4_pathconf_arg args = {
4689 .fh = fhandle,
4690 .bitmask = server->attr_bitmask,
4691 };
d45b2989
BH		 4692 struct nfs4_pathconf_res res = {
4693 .pathconf = pathconf,
4694 };
1da177e4
LT		 4695 struct rpc_message msg = {
4696 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_PATHCONF],
4697 .rpc_argp = &args,
d45b2989 4698 .rpc_resp = &res,
1da177e4
LT		 4699 };
4700
4701 /* None of the pathconf attributes are mandatory to implement */
4702 if ((args.bitmask[0] & nfs4_pathconf_bitmap[0]) == 0) {
4703 memset(pathconf, 0, sizeof(*pathconf));
4704 return 0;
4705 }
4706
0e574af1 4707 nfs_fattr_init(pathconf->fattr);
7c513058 4708 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
1da177e4
LT		 4709}
4710
4711static int nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
4712 struct nfs_pathconf *pathconf)
4713{
4714 struct nfs4_exception exception = { };
4715 int err;
4716
4717 do {
4718 err = nfs4_handle_exception(server,
4719 _nfs4_proc_pathconf(server, fhandle, pathconf),
4720 &exception);
4721 } while (exception.retry);
4722 return err;
4723}
4724
5521abfd 4725int nfs4_set_rw_stateid(nfs4_stateid *stateid,
9b206149
TM		 4726 const struct nfs_open_context *ctx,
4727 const struct nfs_lock_context *l_ctx,
4728 fmode_t fmode)
4729{
17393475 4730 return nfs4_select_rw_stateid(ctx->state, fmode, l_ctx, stateid, NULL);
9b206149
TM		 4731}
4732EXPORT_SYMBOL_GPL(nfs4_set_rw_stateid);
4733
5521abfd
TM		 4734static bool nfs4_stateid_is_current(nfs4_stateid *stateid,
4735 const struct nfs_open_context *ctx,
4736 const struct nfs_lock_context *l_ctx,
4737 fmode_t fmode)
4738{
4739 nfs4_stateid current_stateid;
4740
e1253be0
TM		 4741 /* If the current stateid represents a lost lock, then exit */
4742 if (nfs4_set_rw_stateid(&current_stateid, ctx, l_ctx, fmode) == -EIO)
4743 return true;
5521abfd
TM		 4744 return nfs4_stateid_match(stateid, &current_stateid);
4745}
4746
4747static bool nfs4_error_stateid_expired(int err)
4748{
4749 switch (err) {
4750 case -NFS4ERR_DELEG_REVOKED:
4751 case -NFS4ERR_ADMIN_REVOKED:
4752 case -NFS4ERR_BAD_STATEID:
4753 case -NFS4ERR_STALE_STATEID:
4754 case -NFS4ERR_OLD_STATEID:
4755 case -NFS4ERR_OPENMODE:
4756 case -NFS4ERR_EXPIRED:
4757 return true;
4758 }
4759 return false;
4760}
4761
d45f60c6 4762static int nfs4_read_done_cb(struct rpc_task *task, struct nfs_pgio_header *hdr)
1da177e4 4763{
d45f60c6 4764 struct nfs_server *server = NFS_SERVER(hdr->inode);
1da177e4 4765
d45f60c6 4766 trace_nfs4_read(hdr, task->tk_status);
9c27869d
TM		 4767 if (task->tk_status < 0) {
4768 struct nfs4_exception exception = {
4769 .inode = hdr->inode,
4770 .state = hdr->args.context->state,
4771 .stateid = &hdr->args.stateid,
4772 };
4773 task->tk_status = nfs4_async_handle_exception(task,
4774 server, task->tk_status, &exception);
4775 if (exception.retry) {
4776 rpc_restart_call_prepare(task);
4777 return -EAGAIN;
4778 }
1da177e4 4779 }
8850df99 4780
1da177e4 4781 if (task->tk_status > 0)
d45f60c6 4782 renew_lease(server, hdr->timestamp);
ec06c096 4783 return 0;
1da177e4
LT		 4784}
4785
5521abfd 4786static bool nfs4_read_stateid_changed(struct rpc_task *task,
3c6b899c 4787 struct nfs_pgio_args *args)
5521abfd
TM		 4788{
4789
4790 if (!nfs4_error_stateid_expired(task->tk_status) ||
4791 nfs4_stateid_is_current(&args->stateid,
4792 args->context,
4793 args->lock_context,
4794 FMODE_READ))
4795 return false;
4796 rpc_restart_call_prepare(task);
4797 return true;
4798}
4799
d45f60c6 4800static int nfs4_read_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
cbdabc7f
AA		 4801{
4802
4803 dprintk("--> %s\n", __func__);
4804
d45f60c6 4805 if (!nfs4_sequence_done(task, &hdr->res.seq_res))
cbdabc7f 4806 return -EAGAIN;
d45f60c6 4807 if (nfs4_read_stateid_changed(task, &hdr->args))
5521abfd 4808 return -EAGAIN;
bfc505de
TM		 4809 if (task->tk_status > 0)
4810 nfs_invalidate_atime(hdr->inode);
d45f60c6
WAA		 4811 return hdr->pgio_done_cb ? hdr->pgio_done_cb(task, hdr) :
4812 nfs4_read_done_cb(task, hdr);
cbdabc7f
AA		 4813}
4814
d45f60c6
WAA		 4815static void nfs4_proc_read_setup(struct nfs_pgio_header *hdr,
4816 struct rpc_message *msg)
1da177e4 4817{
d45f60c6 4818 hdr->timestamp = jiffies;
ca857cc1
TM		 4819 if (!hdr->pgio_done_cb)
4820 hdr->pgio_done_cb = nfs4_read_done_cb;
bdc7f021 4821 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READ];
d45f60c6 4822 nfs4_init_sequence(&hdr->args.seq_args, &hdr->res.seq_res, 0);
1da177e4
LT		 4823}
4824
d45f60c6
WAA		 4825static int nfs4_proc_pgio_rpc_prepare(struct rpc_task *task,
4826 struct nfs_pgio_header *hdr)
ea7c3303 4827{
42e1cca7 4828 if (nfs4_setup_sequence(NFS_SERVER(hdr->inode)->nfs_client,
d45f60c6
WAA		 4829 &hdr->args.seq_args,
4830 &hdr->res.seq_res,
9b206149 4831 task))
ef1820f9 4832 return 0;
d45f60c6
WAA		 4833 if (nfs4_set_rw_stateid(&hdr->args.stateid, hdr->args.context,
4834 hdr->args.lock_context,
fbe77c30 4835 hdr->rw_mode) == -EIO)
ef1820f9 4836 return -EIO;
d45f60c6 4837 if (unlikely(test_bit(NFS_CONTEXT_BAD, &hdr->args.context->flags)))
ef1820f9
N		 4838 return -EIO;
4839 return 0;
1da177e4
LT		 4840}
4841
d45f60c6
WAA		 4842static int nfs4_write_done_cb(struct rpc_task *task,
4843 struct nfs_pgio_header *hdr)
1da177e4 4844{
d45f60c6 4845 struct inode *inode = hdr->inode;
8478eaa1 4846
d45f60c6 4847 trace_nfs4_write(hdr, task->tk_status);
9c27869d
TM		 4848 if (task->tk_status < 0) {
4849 struct nfs4_exception exception = {
4850 .inode = hdr->inode,
4851 .state = hdr->args.context->state,
4852 .stateid = &hdr->args.stateid,
4853 };
4854 task->tk_status = nfs4_async_handle_exception(task,
4855 NFS_SERVER(inode), task->tk_status,
4856 &exception);
4857 if (exception.retry) {
4858 rpc_restart_call_prepare(task);
4859 return -EAGAIN;
4860 }
1da177e4 4861 }
4f9838c7 4862 if (task->tk_status >= 0) {
d45f60c6 4863 renew_lease(NFS_SERVER(inode), hdr->timestamp);
a08a8cd3 4864 nfs_writeback_update_inode(hdr);
4f9838c7 4865 }
788e7a89 4866 return 0;
1da177e4
LT		 4867}
4868
5521abfd 4869static bool nfs4_write_stateid_changed(struct rpc_task *task,
3c6b899c 4870 struct nfs_pgio_args *args)
5521abfd
TM		 4871{
4872
4873 if (!nfs4_error_stateid_expired(task->tk_status) ||
4874 nfs4_stateid_is_current(&args->stateid,
4875 args->context,
4876 args->lock_context,
4877 FMODE_WRITE))
4878 return false;
4879 rpc_restart_call_prepare(task);
4880 return true;
4881}
4882
d45f60c6 4883static int nfs4_write_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
b029bc9b 4884{
d45f60c6 4885 if (!nfs4_sequence_done(task, &hdr->res.seq_res))
b029bc9b 4886 return -EAGAIN;
d45f60c6 4887 if (nfs4_write_stateid_changed(task, &hdr->args))
5521abfd 4888 return -EAGAIN;
d45f60c6
WAA		 4889 return hdr->pgio_done_cb ? hdr->pgio_done_cb(task, hdr) :
4890 nfs4_write_done_cb(task, hdr);
b029bc9b
FI		 4891}
4892
5a37f851 4893static
d45f60c6 4894bool nfs4_write_need_cache_consistency_data(struct nfs_pgio_header *hdr)
a69aef14 4895{
5a37f851 4896 /* Don't request attributes for pNFS or O_DIRECT writes */
d45f60c6 4897 if (hdr->ds_clp != NULL || hdr->dreq != NULL)
5a37f851
TM		 4898 return false;
4899 /* Otherwise, request attributes if and only if we don't hold
4900 * a delegation
4901 */
011e2a7f 4902 return nfs4_have_delegation(hdr->inode, FMODE_READ) == 0;
a69aef14 4903}
a69aef14 4904
d45f60c6
WAA		 4905static void nfs4_proc_write_setup(struct nfs_pgio_header *hdr,
4906 struct rpc_message *msg)
1da177e4 4907{
d45f60c6 4908 struct nfs_server *server = NFS_SERVER(hdr->inode);
bdc7f021 4909
d45f60c6
WAA		 4910 if (!nfs4_write_need_cache_consistency_data(hdr)) {
4911 hdr->args.bitmask = NULL;
4912 hdr->res.fattr = NULL;
7ffd1064 4913 } else
d45f60c6 4914 hdr->args.bitmask = server->cache_consistency_bitmask;
5a37f851 4915
d45f60c6
WAA		 4916 if (!hdr->pgio_done_cb)
4917 hdr->pgio_done_cb = nfs4_write_done_cb;
4918 hdr->res.server = server;
4919 hdr->timestamp = jiffies;
1da177e4 4920
bdc7f021 4921 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_WRITE];
d45f60c6 4922 nfs4_init_sequence(&hdr->args.seq_args, &hdr->res.seq_res, 1);
1da177e4
LT		 4923}
4924
0b7c0153 4925static void nfs4_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data)
c6cb80d0 4926{
42e1cca7 4927 nfs4_setup_sequence(NFS_SERVER(data->inode)->nfs_client,
d9afbd1b
TM		 4928 &data->args.seq_args,
4929 &data->res.seq_res,
4930 task);
1da177e4
LT		 4931}
4932
0b7c0153 4933static int nfs4_commit_done_cb(struct rpc_task *task, struct nfs_commit_data *data)
1da177e4 4934{
1da177e4 4935 struct inode *inode = data->inode;
14516c3a 4936
cc668ab3 4937 trace_nfs4_commit(data, task->tk_status);
8478eaa1
N		 4938 if (nfs4_async_handle_error(task, NFS_SERVER(inode),
4939 NULL, NULL) == -EAGAIN) {
d00c5d43 4940 rpc_restart_call_prepare(task);
788e7a89 4941 return -EAGAIN;
1da177e4 4942 }
788e7a89 4943 return 0;
1da177e4
LT		 4944}
4945
0b7c0153 4946static int nfs4_commit_done(struct rpc_task *task, struct nfs_commit_data *data)
5f452431
FI		 4947{
4948 if (!nfs4_sequence_done(task, &data->res.seq_res))
4949 return -EAGAIN;
0b7c0153 4950 return data->commit_done_cb(task, data);
5f452431
FI		 4951}
4952
0b7c0153 4953static void nfs4_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg)
1da177e4 4954{
788e7a89 4955 struct nfs_server *server = NFS_SERVER(data->inode);
988b6dce 4956
0b7c0153
FI		 4957 if (data->commit_done_cb == NULL)
4958 data->commit_done_cb = nfs4_commit_done_cb;
4f9838c7 4959 data->res.server = server;
bdc7f021 4960 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COMMIT];
a9c92d6b 4961 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
1da177e4
LT		 4962}
4963
9bc4e3ca
CL		 4964struct nfs4_renewdata {
4965 struct nfs_client *client;
4966 unsigned long timestamp;
4967};
4968
1da177e4
LT		 4969/*
4970 * nfs4_proc_async_renew(): This is not one of the nfs_rpc_ops; it is a special
4971 * standalone procedure for queueing an asynchronous RENEW.
4972 */
9bc4e3ca 4973static void nfs4_renew_release(void *calldata)
dc96aef9 4974{
9bc4e3ca
CL		 4975 struct nfs4_renewdata *data = calldata;
4976 struct nfs_client *clp = data->client;
dc96aef9 4977
212bf41d 4978 if (refcount_read(&clp->cl_count) > 1)
0851de06
AB		 4979 nfs4_schedule_state_renewal(clp);
4980 nfs_put_client(clp);
9bc4e3ca 4981 kfree(data);
dc96aef9
AB		 4982}
4983
9bc4e3ca 4984static void nfs4_renew_done(struct rpc_task *task, void *calldata)
1da177e4 4985{
9bc4e3ca
CL		 4986 struct nfs4_renewdata *data = calldata;
4987 struct nfs_client *clp = data->client;
4988 unsigned long timestamp = data->timestamp;
1da177e4 4989
c6d01c6f 4990 trace_nfs4_renew_async(clp, task->tk_status);
f8aba1e8
CL		 4991 switch (task->tk_status) {
4992 case 0:
4993 break;
4994 case -NFS4ERR_LEASE_MOVED:
4995 nfs4_schedule_lease_moved_recovery(clp);
4996 break;
4997 default:
95baa25c 4998 /* Unless we're shutting down, schedule state recovery! */
042b60be
TM		 4999 if (test_bit(NFS_CS_RENEWD, &clp->cl_res_state) == 0)
5000 return;
5001 if (task->tk_status != NFS4ERR_CB_PATH_DOWN) {
0400a6b0 5002 nfs4_schedule_lease_recovery(clp);
042b60be
TM		 5003 return;
5004 }
5005 nfs4_schedule_path_down_recovery(clp);
1da177e4 5006 }
452e9352 5007 do_renew_lease(clp, timestamp);
1da177e4
LT		 5008}
5009
963d8fe5
TM		 5010static const struct rpc_call_ops nfs4_renew_ops = {
5011 .rpc_call_done = nfs4_renew_done,
dc96aef9 5012 .rpc_release = nfs4_renew_release,
963d8fe5
TM		 5013};
5014
2f60ea6b 5015static int nfs4_proc_async_renew(struct nfs_client *clp, struct rpc_cred *cred, unsigned renew_flags)
1da177e4
LT		 5016{
5017 struct rpc_message msg = {
5018 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW],
5019 .rpc_argp = clp,
b4454fe1 5020 .rpc_cred = cred,
1da177e4 5021 };
9bc4e3ca 5022 struct nfs4_renewdata *data;
1da177e4 5023
2f60ea6b
TM		 5024 if (renew_flags == 0)
5025 return 0;
212bf41d 5026 if (!refcount_inc_not_zero(&clp->cl_count))
0851de06 5027 return -EIO;
b569ad34 5028 data = kmalloc(sizeof(*data), GFP_NOFS);
5c737cb2
DW		 5029 if (data == NULL) {
5030 nfs_put_client(clp);
9bc4e3ca 5031 return -ENOMEM;
5c737cb2 5032 }
9bc4e3ca
CL		 5033 data->client = clp;
5034 data->timestamp = jiffies;
bc7a05ca 5035 return rpc_call_async(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT,
9bc4e3ca 5036 &nfs4_renew_ops, data);
1da177e4
LT		 5037}
5038
8534d4ec 5039static int nfs4_proc_renew(struct nfs_client *clp, struct rpc_cred *cred)
1da177e4
LT		 5040{
5041 struct rpc_message msg = {
5042 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW],
5043 .rpc_argp = clp,
b4454fe1 5044 .rpc_cred = cred,
1da177e4
LT		 5045 };
5046 unsigned long now = jiffies;
5047 int status;
5048
bc7a05ca 5049 status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
1da177e4
LT		 5050 if (status < 0)
5051 return status;
452e9352 5052 do_renew_lease(clp, now);
1da177e4
LT		 5053 return 0;
5054}
5055
aa1870af
BF		 5056static inline int nfs4_server_supports_acls(struct nfs_server *server)
5057{
7dd7d959 5058 return server->caps & NFS_CAP_ACLS;
aa1870af
BF		 5059}
5060
21f498c2
TM		 5061/* Assuming that XATTR_SIZE_MAX is a multiple of PAGE_SIZE, and that
5062 * it's OK to put sizeof(void) * (XATTR_SIZE_MAX/PAGE_SIZE) bytes on
aa1870af
BF		 5063 * the stack.
5064 */
21f498c2 5065#define NFS4ACL_MAXPAGES DIV_ROUND_UP(XATTR_SIZE_MAX, PAGE_SIZE)
aa1870af 5066
e9e3d724 5067static int buf_to_pages_noslab(const void *buf, size_t buflen,
8fbcf237 5068 struct page **pages)
e9e3d724
NH		 5069{
5070 struct page *newpage, **spages;
5071 int rc = 0;
5072 size_t len;
5073 spages = pages;
5074
5075 do {
21f498c2 5076 len = min_t(size_t, PAGE_SIZE, buflen);
e9e3d724
NH		 5077 newpage = alloc_page(GFP_KERNEL);
5078
5079 if (newpage == NULL)
5080 goto unwind;
5081 memcpy(page_address(newpage), buf, len);
d9b67e1e
AS		 5082 buf += len;
5083 buflen -= len;
e9e3d724
NH		 5084 *pages++ = newpage;
5085 rc++;
5086 } while (buflen != 0);
5087
5088 return rc;
5089
5090unwind:
5091 for(; rc > 0; rc--)
5092 __free_page(spages[rc-1]);
5093 return -ENOMEM;
5094}
5095
e50a1c2e
BF		 5096struct nfs4_cached_acl {
5097 int cached;
5098 size_t len;
3e9d4154 5099 char data[0];
e50a1c2e
BF		 5100};
5101
5102static void nfs4_set_cached_acl(struct inode *inode, struct nfs4_cached_acl *acl)
5103{
5104 struct nfs_inode *nfsi = NFS_I(inode);
5105
5106 spin_lock(&inode->i_lock);
5107 kfree(nfsi->nfs4_acl);
5108 nfsi->nfs4_acl = acl;
5109 spin_unlock(&inode->i_lock);
5110}
5111
5112static void nfs4_zap_acl_attr(struct inode *inode)
5113{
5114 nfs4_set_cached_acl(inode, NULL);
5115}
5116
5117static inline ssize_t nfs4_read_cached_acl(struct inode *inode, char *buf, size_t buflen)
5118{
5119 struct nfs_inode *nfsi = NFS_I(inode);
5120 struct nfs4_cached_acl *acl;
5121 int ret = -ENOENT;
5122
5123 spin_lock(&inode->i_lock);
5124 acl = nfsi->nfs4_acl;
5125 if (acl == NULL)
5126 goto out;
5127 if (buf == NULL) /* user is just asking for length */
5128 goto out_len;
5129 if (acl->cached == 0)
5130 goto out;
5131 ret = -ERANGE; /* see getxattr(2) man page */
5132 if (acl->len > buflen)
5133 goto out;
5134 memcpy(buf, acl->data, acl->len);
5135out_len:
5136 ret = acl->len;
5137out:
5138 spin_unlock(&inode->i_lock);
5139 return ret;
5140}
5141
5794d21e 5142static void nfs4_write_cached_acl(struct inode *inode, struct page **pages, size_t pgbase, size_t acl_len)
e50a1c2e
BF		 5143{
5144 struct nfs4_cached_acl *acl;
b291f1b1 5145 size_t buflen = sizeof(*acl) + acl_len;
e50a1c2e 5146
1f1ea6c2 5147 if (buflen <= PAGE_SIZE) {
b291f1b1 5148 acl = kmalloc(buflen, GFP_KERNEL);
e50a1c2e
BF		 5149 if (acl == NULL)
5150 goto out;
5151 acl->cached = 1;
5794d21e 5152 _copy_from_pages(acl->data, pages, pgbase, acl_len);
e50a1c2e
BF		 5153 } else {
5154 acl = kmalloc(sizeof(*acl), GFP_KERNEL);
5155 if (acl == NULL)
5156 goto out;
5157 acl->cached = 0;
5158 }
5159 acl->len = acl_len;
5160out:
5161 nfs4_set_cached_acl(inode, acl);
5162}
5163
bf118a34
AA		 5164/*
5165 * The getxattr API returns the required buffer length when called with a
5166 * NULL buf. The NFSv4 acl tool then calls getxattr again after allocating
5167 * the required buf. On a NULL buf, we send a page of data to the server
5168 * guessing that the ACL request can be serviced by a page. If so, we cache
5169 * up to the page of ACL data, and the 2nd call to getxattr is serviced by
5170 * the cache. If not so, we throw away the page, and cache the required
5171 * length. The next getxattr call will then produce another round trip to
5172 * the server, this time with the input buf of the required size.
5173 */
16b4289c 5174static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)
aa1870af 5175{
ed92d8c1 5176 struct page *pages[NFS4ACL_MAXPAGES + 1] = {NULL, };
aa1870af
BF		 5177 struct nfs_getaclargs args = {
5178 .fh = NFS_FH(inode),
5179 .acl_pages = pages,
5180 .acl_len = buflen,
5181 };
663c79b3
BH		 5182 struct nfs_getaclres res = {
5183 .acl_len = buflen,
5184 };
aa1870af
BF		 5185 struct rpc_message msg = {
5186 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETACL],
5187 .rpc_argp = &args,
663c79b3 5188 .rpc_resp = &res,
aa1870af 5189 };
ed92d8c1 5190 unsigned int npages = DIV_ROUND_UP(buflen, PAGE_SIZE) + 1;
21f498c2 5191 int ret = -ENOMEM, i;
aa1870af 5192
21f498c2
TM		 5193 if (npages > ARRAY_SIZE(pages))
5194 return -ERANGE;
5a006899 5195
bf118a34
AA		 5196 for (i = 0; i < npages; i++) {
5197 pages[i] = alloc_page(GFP_KERNEL);
5198 if (!pages[i])
5199 goto out_free;
e50a1c2e 5200 }
5a006899
SP		 5201
5202 /* for decoding across pages */
5203 res.acl_scratch = alloc_page(GFP_KERNEL);
5204 if (!res.acl_scratch)
5205 goto out_free;
5206
bf118a34 5207 args.acl_len = npages * PAGE_SIZE;
5a006899 5208
de040bec 5209 dprintk("%s buf %p buflen %zu npages %d args.acl_len %zu\n",
bf118a34
AA		 5210 __func__, buf, buflen, npages, args.acl_len);
5211 ret = nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode),
5212 &msg, &args.seq_args, &res.seq_res, 0);
e50a1c2e
BF		 5213 if (ret)
5214 goto out_free;
bf118a34 5215
1f1ea6c2
TM		 5216 /* Handle the case where the passed-in buffer is too short */
5217 if (res.acl_flags & NFS4_ACL_TRUNC) {
5218 /* Did the user only issue a request for the acl length? */
5219 if (buf == NULL)
5220 goto out_ok;
e50a1c2e 5221 ret = -ERANGE;
1f1ea6c2 5222 goto out_free;
e50a1c2e 5223 }
1f1ea6c2 5224 nfs4_write_cached_acl(inode, pages, res.acl_data_offset, res.acl_len);
7d3e91a8
SW		 5225 if (buf) {
5226 if (res.acl_len > buflen) {
5227 ret = -ERANGE;
5228 goto out_free;
5229 }
1f1ea6c2 5230 _copy_from_pages(buf, pages, res.acl_data_offset, res.acl_len);
7d3e91a8 5231 }
1f1ea6c2
TM		 5232out_ok:
5233 ret = res.acl_len;
e50a1c2e 5234out_free:
bf118a34
AA		 5235 for (i = 0; i < npages; i++)
5236 if (pages[i])
5237 __free_page(pages[i]);
331818f1
TM		 5238 if (res.acl_scratch)
5239 __free_page(res.acl_scratch);
aa1870af
BF		 5240 return ret;
5241}
5242
16b4289c
TM		 5243static ssize_t nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)
5244{
5245 struct nfs4_exception exception = { };
5246 ssize_t ret;
5247 do {
5248 ret = __nfs4_get_acl_uncached(inode, buf, buflen);
c1578b76 5249 trace_nfs4_get_acl(inode, ret);
16b4289c
TM		 5250 if (ret >= 0)
5251 break;
5252 ret = nfs4_handle_exception(NFS_SERVER(inode), ret, &exception);
5253 } while (exception.retry);
5254 return ret;
5255}
5256
e50a1c2e
BF		 5257static ssize_t nfs4_proc_get_acl(struct inode *inode, void *buf, size_t buflen)
5258{
5259 struct nfs_server *server = NFS_SERVER(inode);
5260 int ret;
5261
5262 if (!nfs4_server_supports_acls(server))
5263 return -EOPNOTSUPP;
5264 ret = nfs_revalidate_inode(server, inode);
5265 if (ret < 0)
5266 return ret;
08a22b39
AK		 5267 if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_ACL)
5268 nfs_zap_acl_cache(inode);
e50a1c2e
BF		 5269 ret = nfs4_read_cached_acl(inode, buf, buflen);
5270 if (ret != -ENOENT)
bf118a34
AA		 5271 /* -ENOENT is returned if there is no ACL or if there is an ACL
5272 * but no cached acl data, just the acl length */
e50a1c2e
BF		 5273 return ret;
5274 return nfs4_get_acl_uncached(inode, buf, buflen);
5275}
5276
16b4289c 5277static int __nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen)
4b580ee3
BF		 5278{
5279 struct nfs_server *server = NFS_SERVER(inode);
5280 struct page *pages[NFS4ACL_MAXPAGES];
5281 struct nfs_setaclargs arg = {
5282 .fh = NFS_FH(inode),
5283 .acl_pages = pages,
5284 .acl_len = buflen,
5285 };
73c403a9 5286 struct nfs_setaclres res;
4b580ee3
BF		 5287 struct rpc_message msg = {
5288 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETACL],
5289 .rpc_argp = &arg,
73c403a9 5290 .rpc_resp = &res,
4b580ee3 5291 };
21f498c2 5292 unsigned int npages = DIV_ROUND_UP(buflen, PAGE_SIZE);
e9e3d724 5293 int ret, i;
4b580ee3
BF		 5294
5295 if (!nfs4_server_supports_acls(server))
5296 return -EOPNOTSUPP;
21f498c2
TM		 5297 if (npages > ARRAY_SIZE(pages))
5298 return -ERANGE;
8fbcf237 5299 i = buf_to_pages_noslab(buf, buflen, arg.acl_pages);
e9e3d724
NH		 5300 if (i < 0)
5301 return i;
57ec14c5 5302 nfs4_inode_return_delegation(inode);
7c513058 5303 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
e9e3d724
NH		 5304
5305 /*
5306 * Free each page after tx, so the only ref left is
5307 * held by the network stack
5308 */
5309 for (; i > 0; i--)
5310 put_page(pages[i-1]);
5311
08a22b39
AK		 5312 /*
5313 * Acl update can result in inode attribute update.
5314 * so mark the attribute cache invalid.
5315 */
5316 spin_lock(&inode->i_lock);
5317 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATTR;
5318 spin_unlock(&inode->i_lock);
f41f7418
TM		 5319 nfs_access_zap_cache(inode);
5320 nfs_zap_acl_cache(inode);
4b580ee3
BF		 5321 return ret;
5322}
5323
16b4289c
TM		 5324static int nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen)
5325{
5326 struct nfs4_exception exception = { };
5327 int err;
5328 do {
c1578b76
TM		 5329 err = __nfs4_proc_set_acl(inode, buf, buflen);
5330 trace_nfs4_set_acl(inode, err);
5331 err = nfs4_handle_exception(NFS_SERVER(inode), err,
16b4289c
TM		 5332 &exception);
5333 } while (exception.retry);
5334 return err;
5335}
5336
aa9c2669
DQ		 5337#ifdef CONFIG_NFS_V4_SECURITY_LABEL
5338static int _nfs4_get_security_label(struct inode *inode, void *buf,
5339 size_t buflen)
5340{
5341 struct nfs_server *server = NFS_SERVER(inode);
5342 struct nfs_fattr fattr;
5343 struct nfs4_label label = {0, 0, buflen, buf};
5344
5345 u32 bitmask[3] = { 0, 0, FATTR4_WORD2_SECURITY_LABEL };
fcb63a9b 5346 struct nfs4_getattr_arg arg = {
aa9c2669
DQ		 5347 .fh = NFS_FH(inode),
5348 .bitmask = bitmask,
5349 };
5350 struct nfs4_getattr_res res = {
5351 .fattr = &fattr,
5352 .label = &label,
5353 .server = server,
5354 };
5355 struct rpc_message msg = {
5356 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETATTR],
fcb63a9b 5357 .rpc_argp = &arg,
aa9c2669
DQ		 5358 .rpc_resp = &res,
5359 };
5360 int ret;
5361
5362 nfs_fattr_init(&fattr);
5363
fcb63a9b 5364 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 0);
aa9c2669
DQ		 5365 if (ret)
5366 return ret;
5367 if (!(fattr.valid & NFS_ATTR_FATTR_V4_SECURITY_LABEL))
5368 return -ENOENT;
5369 if (buflen < label.len)
5370 return -ERANGE;
5371 return 0;
5372}
5373
5374static int nfs4_get_security_label(struct inode *inode, void *buf,
5375 size_t buflen)
5376{
5377 struct nfs4_exception exception = { };
5378 int err;
5379
5380 if (!nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL))
5381 return -EOPNOTSUPP;
5382
5383 do {
c1578b76
TM		 5384 err = _nfs4_get_security_label(inode, buf, buflen);
5385 trace_nfs4_get_security_label(inode, err);
5386 err = nfs4_handle_exception(NFS_SERVER(inode), err,
aa9c2669
DQ		 5387 &exception);
5388 } while (exception.retry);
5389 return err;
5390}
5391
5392static int _nfs4_do_set_security_label(struct inode *inode,
5393 struct nfs4_label *ilabel,
5394 struct nfs_fattr *fattr,
5395 struct nfs4_label *olabel)
5396{
5397
5398 struct iattr sattr = {0};
5399 struct nfs_server *server = NFS_SERVER(inode);
5400 const u32 bitmask[3] = { 0, 0, FATTR4_WORD2_SECURITY_LABEL };
12207f69 5401 struct nfs_setattrargs arg = {
d9b67e1e
AS		 5402 .fh = NFS_FH(inode),
5403 .iap = &sattr,
aa9c2669
DQ		 5404 .server = server,
5405 .bitmask = bitmask,
5406 .label = ilabel,
5407 };
5408 struct nfs_setattrres res = {
5409 .fattr = fattr,
5410 .label = olabel,
5411 .server = server,
5412 };
5413 struct rpc_message msg = {
d9b67e1e
AS		 5414 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETATTR],
5415 .rpc_argp = &arg,
5416 .rpc_resp = &res,
aa9c2669
DQ		 5417 };
5418 int status;
5419
12207f69 5420 nfs4_stateid_copy(&arg.stateid, &zero_stateid);
aa9c2669 5421
12207f69 5422 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
aa9c2669
DQ		 5423 if (status)
5424 dprintk("%s failed: %d\n", __func__, status);
5425
5426 return status;
5427}
5428
5429static int nfs4_do_set_security_label(struct inode *inode,
5430 struct nfs4_label *ilabel,
5431 struct nfs_fattr *fattr,
5432 struct nfs4_label *olabel)
5433{
5434 struct nfs4_exception exception = { };
5435 int err;
5436
5437 do {
c1578b76
TM		 5438 err = _nfs4_do_set_security_label(inode, ilabel,
5439 fattr, olabel);
5440 trace_nfs4_set_security_label(inode, err);
5441 err = nfs4_handle_exception(NFS_SERVER(inode), err,
aa9c2669
DQ		 5442 &exception);
5443 } while (exception.retry);
5444 return err;
5445}
5446
5447static int
59301226 5448nfs4_set_security_label(struct inode *inode, const void *buf, size_t buflen)
aa9c2669
DQ		 5449{
5450 struct nfs4_label ilabel, *olabel = NULL;
5451 struct nfs_fattr fattr;
5452 struct rpc_cred *cred;
aa9c2669
DQ		 5453 int status;
5454
5455 if (!nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL))
5456 return -EOPNOTSUPP;
5457
5458 nfs_fattr_init(&fattr);
5459
5460 ilabel.pi = 0;
5461 ilabel.lfs = 0;
5462 ilabel.label = (char *)buf;
5463 ilabel.len = buflen;
5464
5465 cred = rpc_lookup_cred();
5466 if (IS_ERR(cred))
5467 return PTR_ERR(cred);
5468
5469 olabel = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL);
5470 if (IS_ERR(olabel)) {
5471 status = -PTR_ERR(olabel);
5472 goto out;
5473 }
5474
5475 status = nfs4_do_set_security_label(inode, &ilabel, &fattr, olabel);
5476 if (status == 0)
5477 nfs_setsecurity(inode, &fattr, olabel);
5478
5479 nfs4_label_free(olabel);
5480out:
5481 put_rpccred(cred);
5482 return status;
5483}
5484#endif /* CONFIG_NFS_V4_SECURITY_LABEL */
5485
5486
f092075d
CL		 5487static void nfs4_init_boot_verifier(const struct nfs_client *clp,
5488 nfs4_verifier *bootverf)
cd93710e
CL		 5489{
5490 __be32 verf[2];
5491
2c820d9a
CL		 5492 if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) {
5493 /* An impossible timestamp guarantees this value
5494 * will never match a generated boot time. */
2f86e091
DD		 5495 verf[0] = cpu_to_be32(U32_MAX);
5496 verf[1] = cpu_to_be32(U32_MAX);
2c820d9a 5497 } else {
f092075d 5498 struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
2f86e091
DD		 5499 u64 ns = ktime_to_ns(nn->boot_time);
5500
5501 verf[0] = cpu_to_be32(ns >> 32);
5502 verf[1] = cpu_to_be32(ns);
2c820d9a 5503 }
cd93710e
CL		 5504 memcpy(bootverf->data, verf, sizeof(bootverf->data));
5505}
5506
a3192688
JL		 5507static int
5508nfs4_init_nonuniform_client_string(struct nfs_client *clp)
e984a55a 5509{
a3192688
JL		 5510 size_t len;
5511 char *str;
e984a55a 5512
ceb3a16c 5513 if (clp->cl_owner_id != NULL)
a3192688 5514 return 0;
4a3e5779 5515
a3192688 5516 rcu_read_lock();
4a70316c 5517 len = 14 + strlen(clp->cl_ipaddr) + 1 +
a3192688
JL		 5518 strlen(rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR)) +
5519 1 +
5520 strlen(rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_PROTO)) +
5521 1;
5522 rcu_read_unlock();
5523
5524 if (len > NFS4_OPAQUE_LIMIT + 1)
5525 return -EINVAL;
5526
5527 /*
5528 * Since this string is allocated at mount time, and held until the
5529 * nfs_client is destroyed, we can use GFP_KERNEL here w/o worrying
5530 * about a memory-reclaim deadlock.
5531 */
5532 str = kmalloc(len, GFP_KERNEL);
5533 if (!str)
5534 return -ENOMEM;
ceb3a16c 5535
e984a55a 5536 rcu_read_lock();
f2dd436e 5537 scnprintf(str, len, "Linux NFSv4.0 %s/%s %s",
a3192688
JL		 5538 clp->cl_ipaddr,
5539 rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR),
5540 rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_PROTO));
e984a55a 5541 rcu_read_unlock();
a3192688 5542
a3192688
JL		 5543 clp->cl_owner_id = str;
5544 return 0;
e984a55a
CL		 5545}
5546
873e3851
JL		 5547static int
5548nfs4_init_uniquifier_client_string(struct nfs_client *clp)
5549{
873e3851
JL		 5550 size_t len;
5551 char *str;
5552
5553 len = 10 + 10 + 1 + 10 + 1 +
5554 strlen(nfs4_client_id_uniquifier) + 1 +
5555 strlen(clp->cl_rpcclient->cl_nodename) + 1;
5556
5557 if (len > NFS4_OPAQUE_LIMIT + 1)
5558 return -EINVAL;
5559
5560 /*
5561 * Since this string is allocated at mount time, and held until the
5562 * nfs_client is destroyed, we can use GFP_KERNEL here w/o worrying
5563 * about a memory-reclaim deadlock.
5564 */
5565 str = kmalloc(len, GFP_KERNEL);
5566 if (!str)
5567 return -ENOMEM;
5568
f2dd436e 5569 scnprintf(str, len, "Linux NFSv%u.%u %s/%s",
873e3851
JL		 5570 clp->rpc_ops->version, clp->cl_minorversion,
5571 nfs4_client_id_uniquifier,
5572 clp->cl_rpcclient->cl_nodename);
873e3851
JL		 5573 clp->cl_owner_id = str;
5574 return 0;
5575}
5576
5577static int
5578nfs4_init_uniform_client_string(struct nfs_client *clp)
e984a55a 5579{
873e3851
JL		 5580 size_t len;
5581 char *str;
ceb3a16c
TM		 5582
5583 if (clp->cl_owner_id != NULL)
873e3851 5584 return 0;
6f2ea7f2
CL		 5585
5586 if (nfs4_client_id_uniquifier[0] != '\0')
873e3851
JL		 5587 return nfs4_init_uniquifier_client_string(clp);
5588
5589 len = 10 + 10 + 1 + 10 + 1 +
5590 strlen(clp->cl_rpcclient->cl_nodename) + 1;
5591
5592 if (len > NFS4_OPAQUE_LIMIT + 1)
5593 return -EINVAL;
5594
5595 /*
5596 * Since this string is allocated at mount time, and held until the
5597 * nfs_client is destroyed, we can use GFP_KERNEL here w/o worrying
5598 * about a memory-reclaim deadlock.
5599 */
5600 str = kmalloc(len, GFP_KERNEL);
5601 if (!str)
5602 return -ENOMEM;
5603
f2dd436e 5604 scnprintf(str, len, "Linux NFSv%u.%u %s",
873e3851
JL		 5605 clp->rpc_ops->version, clp->cl_minorversion,
5606 clp->cl_rpcclient->cl_nodename);
873e3851
JL		 5607 clp->cl_owner_id = str;
5608 return 0;
e984a55a
CL		 5609}
5610
706cb8db
CL		 5611/*
5612 * nfs4_callback_up_net() starts only "tcp" and "tcp6" callback
5613 * services. Advertise one based on the address family of the
5614 * clientaddr.
5615 */
5616static unsigned int
5617nfs4_init_callback_netid(const struct nfs_client *clp, char *buf, size_t len)
5618{
5619 if (strchr(clp->cl_ipaddr, ':') != NULL)
5620 return scnprintf(buf, len, "tcp6");
5621 else
5622 return scnprintf(buf, len, "tcp");
5623}
5624
f11b2a1c
JL		 5625static void nfs4_setclientid_done(struct rpc_task *task, void *calldata)
5626{
5627 struct nfs4_setclientid *sc = calldata;
5628
5629 if (task->tk_status == 0)
5630 sc->sc_cred = get_rpccred(task->tk_rqstp->rq_cred);
5631}
5632
5633static const struct rpc_call_ops nfs4_setclientid_ops = {
5634 .rpc_call_done = nfs4_setclientid_done,
5635};
5636
6bbb4ae8
CL		 5637/**
5638 * nfs4_proc_setclientid - Negotiate client ID
5639 * @clp: state data structure
5640 * @program: RPC program for NFSv4 callback service
5641 * @port: IP port number for NFS4 callback service
5642 * @cred: RPC credential to use for this call
5643 * @res: where to place the result
5644 *
5645 * Returns zero, a negative errno, or a negative NFS4ERR status code.
5646 */
bb8b27e5
TM		 5647int nfs4_proc_setclientid(struct nfs_client *clp, u32 program,
5648 unsigned short port, struct rpc_cred *cred,
5649 struct nfs4_setclientid_res *res)
1da177e4
LT		 5650{
5651 nfs4_verifier sc_verifier;
5652 struct nfs4_setclientid setclientid = {
5653 .sc_verifier = &sc_verifier,
5654 .sc_prog = program,
3a6bb738 5655 .sc_clnt = clp,
1da177e4
LT		 5656 };
5657 struct rpc_message msg = {
5658 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID],
5659 .rpc_argp = &setclientid,
bb8b27e5 5660 .rpc_resp = res,
286d7d6a 5661 .rpc_cred = cred,
1da177e4 5662 };
f11b2a1c
JL		 5663 struct rpc_task *task;
5664 struct rpc_task_setup task_setup_data = {
5665 .rpc_client = clp->cl_rpcclient,
5666 .rpc_message = &msg,
5667 .callback_ops = &nfs4_setclientid_ops,
5668 .callback_data = &setclientid,
5669 .flags = RPC_TASK_TIMEOUT,
5670 };
6bbb4ae8 5671 int status;
1da177e4 5672
de734831 5673 /* nfs_client_id4 */
f092075d 5674 nfs4_init_boot_verifier(clp, &sc_verifier);
873e3851
JL		 5675
5676 if (test_bit(NFS_CS_MIGRATION, &clp->cl_flags))
5677 status = nfs4_init_uniform_client_string(clp);
5678 else
a3192688 5679 status = nfs4_init_nonuniform_client_string(clp);
873e3851
JL		 5680
5681 if (status)
5682 goto out;
3a6bb738 5683
de734831 5684 /* cb_client4 */
706cb8db
CL		 5685 setclientid.sc_netid_len =
5686 nfs4_init_callback_netid(clp,
5687 setclientid.sc_netid,
5688 sizeof(setclientid.sc_netid));
de734831 5689 setclientid.sc_uaddr_len = scnprintf(setclientid.sc_uaddr,
d4d3c507 5690 sizeof(setclientid.sc_uaddr), "%s.%u.%u",
1da177e4
LT		 5691 clp->cl_ipaddr, port >> 8, port & 255);
5692
3a6bb738 5693 dprintk("NFS call setclientid auth=%s, '%s'\n",
6bbb4ae8 5694 clp->cl_rpcclient->cl_auth->au_ops->au_name,
3a6bb738 5695 clp->cl_owner_id);
f11b2a1c
JL		 5696 task = rpc_run_task(&task_setup_data);
5697 if (IS_ERR(task)) {
5698 status = PTR_ERR(task);
5699 goto out;
5700 }
5701 status = task->tk_status;
5702 if (setclientid.sc_cred) {
5703 clp->cl_acceptor = rpcauth_stringify_acceptor(setclientid.sc_cred);
5704 put_rpccred(setclientid.sc_cred);
5705 }
5706 rpc_put_task(task);
5707out:
c6d01c6f 5708 trace_nfs4_setclientid(clp, status);
6bbb4ae8
CL		 5709 dprintk("NFS reply setclientid: %d\n", status);
5710 return status;
1da177e4
LT		 5711}
5712
6bbb4ae8
CL		 5713/**
5714 * nfs4_proc_setclientid_confirm - Confirm client ID
5715 * @clp: state data structure
5716 * @res: result of a previous SETCLIENTID
5717 * @cred: RPC credential to use for this call
5718 *
5719 * Returns zero, a negative errno, or a negative NFS4ERR status code.
5720 */
fd954ae1 5721int nfs4_proc_setclientid_confirm(struct nfs_client *clp,
bb8b27e5
TM		 5722 struct nfs4_setclientid_res *arg,
5723 struct rpc_cred *cred)
1da177e4 5724{
1da177e4
LT		 5725 struct rpc_message msg = {
5726 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID_CONFIRM],
bb8b27e5 5727 .rpc_argp = arg,
286d7d6a 5728 .rpc_cred = cred,
1da177e4 5729 };
1da177e4
LT		 5730 int status;
5731
6bbb4ae8
CL		 5732 dprintk("NFS call setclientid_confirm auth=%s, (client ID %llx)\n",
5733 clp->cl_rpcclient->cl_auth->au_ops->au_name,
5734 clp->cl_clientid);
1bd714f2 5735 status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
c6d01c6f 5736 trace_nfs4_setclientid_confirm(clp, status);
6bbb4ae8 5737 dprintk("NFS reply setclientid_confirm: %d\n", status);
1da177e4
LT		 5738 return status;
5739}
5740
fe650407
TM		 5741struct nfs4_delegreturndata {
5742 struct nfs4_delegreturnargs args;
fa178f29 5743 struct nfs4_delegreturnres res;
fe650407
TM		 5744 struct nfs_fh fh;
5745 nfs4_stateid stateid;
26e976a8 5746 unsigned long timestamp;
586f1c39
TM		 5747 struct {
5748 struct nfs4_layoutreturn_args arg;
5749 struct nfs4_layoutreturn_res res;
4d796d75 5750 struct nfs4_xdr_opaque_data ld_private;
586f1c39
TM		 5751 u32 roc_barrier;
5752 bool roc;
5753 } lr;
fa178f29 5754 struct nfs_fattr fattr;
fe650407 5755 int rpc_status;
039b756a 5756 struct inode *inode;
fe650407
TM		 5757};
5758
fe650407
TM		 5759static void nfs4_delegreturn_done(struct rpc_task *task, void *calldata)
5760{
5761 struct nfs4_delegreturndata *data = calldata;
938e1010 5762
14516c3a
TM		 5763 if (!nfs4_sequence_done(task, &data->res.seq_res))
5764 return;
938e1010 5765
ca8acf8d 5766 trace_nfs4_delegreturn_exit(&data->args, &data->res, task->tk_status);
586f1c39
TM		 5767
5768 /* Handle Layoutreturn errors */
5769 if (data->args.lr_args && task->tk_status != 0) {
5770 switch(data->res.lr_ret) {
5771 default:
5772 data->res.lr_ret = -NFS4ERR_NOMATCHING_LAYOUT;
5773 break;
5774 case 0:
5775 data->args.lr_args = NULL;
5776 data->res.lr_res = NULL;
5777 break;
7380020e
TM		 5778 case -NFS4ERR_OLD_STATEID:
5779 if (nfs4_refresh_layout_stateid(&data->args.lr_args->stateid,
5780 data->inode)) {
5781 data->res.lr_ret = 0;
5782 rpc_restart_call_prepare(task);
5783 return;
5784 }
5785 /* Fallthrough */
586f1c39
TM		 5786 case -NFS4ERR_ADMIN_REVOKED:
5787 case -NFS4ERR_DELEG_REVOKED:
5788 case -NFS4ERR_EXPIRED:
5789 case -NFS4ERR_BAD_STATEID:
586f1c39
TM		 5790 case -NFS4ERR_UNKNOWN_LAYOUTTYPE:
5791 case -NFS4ERR_WRONG_CRED:
5792 data->args.lr_args = NULL;
5793 data->res.lr_res = NULL;
5794 data->res.lr_ret = 0;
5795 rpc_restart_call_prepare(task);
5796 return;
5797 }
5798 }
5799
79708861 5800 switch (task->tk_status) {
79708861 5801 case 0:
fa178f29 5802 renew_lease(data->res.server, data->timestamp);
23ea44c2 5803 break;
c97cf606
TM		 5804 case -NFS4ERR_ADMIN_REVOKED:
5805 case -NFS4ERR_DELEG_REVOKED:
26d36301
TM		 5806 case -NFS4ERR_EXPIRED:
5807 nfs4_free_revoked_stateid(data->res.server,
5808 data->args.stateid,
5809 task->tk_msg.rpc_cred);
12f275cd 5810 /* Fallthrough */
c97cf606 5811 case -NFS4ERR_BAD_STATEID:
c97cf606 5812 case -NFS4ERR_STALE_STATEID:
c97cf606
TM		 5813 task->tk_status = 0;
5814 break;
12f275cd
TM		 5815 case -NFS4ERR_OLD_STATEID:
5816 if (nfs4_refresh_delegation_stateid(&data->stateid, data->inode)) {
5817 task->tk_status = 0;
5818 rpc_restart_call_prepare(task);
5819 return;
5820 }
5821 task->tk_status = 0;
5822 break;
8ac2b422
TM		 5823 case -NFS4ERR_ACCESS:
5824 if (data->args.bitmask) {
5825 data->args.bitmask = NULL;
5826 data->res.fattr = NULL;
5827 task->tk_status = 0;
5828 rpc_restart_call_prepare(task);
5829 return;
5830 }
79708861 5831 default:
8478eaa1
N		 5832 if (nfs4_async_handle_error(task, data->res.server,
5833 NULL, NULL) == -EAGAIN) {
d00c5d43 5834 rpc_restart_call_prepare(task);
79708861
RL		 5835 return;
5836 }
5837 }
5838 data->rpc_status = task->tk_status;
fe650407
TM		 5839}
5840
5841static void nfs4_delegreturn_release(void *calldata)
5842{
039b756a 5843 struct nfs4_delegreturndata *data = calldata;
ea7c38fe 5844 struct inode *inode = data->inode;
039b756a 5845
ea7c38fe 5846 if (inode) {
586f1c39 5847 if (data->lr.roc)
1c5bd76d
TM		 5848 pnfs_roc_release(&data->lr.arg, &data->lr.res,
5849 data->res.lr_ret);
0bc2c9b4 5850 nfs_post_op_update_inode_force_wcc(inode, &data->fattr);
ea7c38fe
TM		 5851 nfs_iput_and_deactive(inode);
5852 }
fe650407
TM		 5853 kfree(calldata);
5854}
5855
938e1010
AA		 5856static void nfs4_delegreturn_prepare(struct rpc_task *task, void *data)
5857{
5858 struct nfs4_delegreturndata *d_data;
5859
5860 d_data = (struct nfs4_delegreturndata *)data;
5861
1c5bd76d 5862 if (!d_data->lr.roc && nfs4_wait_on_layoutreturn(d_data->inode, task))
500d701f
PT		 5863 return;
5864
42e1cca7 5865 nfs4_setup_sequence(d_data->res.server->nfs_client,
d9afbd1b
TM		 5866 &d_data->args.seq_args,
5867 &d_data->res.seq_res,
5868 task);
938e1010 5869}
938e1010 5870
c8d149f3 5871static const struct rpc_call_ops nfs4_delegreturn_ops = {
938e1010 5872 .rpc_call_prepare = nfs4_delegreturn_prepare,
fe650407
TM		 5873 .rpc_call_done = nfs4_delegreturn_done,
5874 .rpc_release = nfs4_delegreturn_release,
5875};
5876
e6f81075 5877static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync)
fe650407
TM		 5878{
5879 struct nfs4_delegreturndata *data;
fa178f29 5880 struct nfs_server *server = NFS_SERVER(inode);
fe650407 5881 struct rpc_task *task;
5138fde0
TM		 5882 struct rpc_message msg = {
5883 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DELEGRETURN],
5884 .rpc_cred = cred,
5885 };
c970aa85
TM		 5886 struct rpc_task_setup task_setup_data = {
5887 .rpc_client = server->client,
5138fde0 5888 .rpc_message = &msg,
c970aa85
TM		 5889 .callback_ops = &nfs4_delegreturn_ops,
5890 .flags = RPC_TASK_ASYNC,
5891 };
e6f81075 5892 int status = 0;
fe650407 5893
8535b2be 5894 data = kzalloc(sizeof(*data), GFP_NOFS);
fe650407
TM		 5895 if (data == NULL)
5896 return -ENOMEM;
a9c92d6b 5897 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
99ade3c7
AE		 5898
5899 nfs4_state_protect(server->nfs_client,
5900 NFS_SP4_MACH_CRED_CLEANUP,
5901 &task_setup_data.rpc_client, &msg);
5902
fe650407
TM		 5903 data->args.fhandle = &data->fh;
5904 data->args.stateid = &data->stateid;
9e907fec 5905 data->args.bitmask = server->cache_consistency_bitmask;
fe650407 5906 nfs_copy_fh(&data->fh, NFS_FH(inode));
f597c537 5907 nfs4_stateid_copy(&data->stateid, stateid);
fa178f29
TM		 5908 data->res.fattr = &data->fattr;
5909 data->res.server = server;
586f1c39 5910 data->res.lr_ret = -NFS4ERR_NOMATCHING_LAYOUT;
4d796d75 5911 data->lr.arg.ld_private = &data->lr.ld_private;
5138fde0 5912 nfs_fattr_init(data->res.fattr);
26e976a8 5913 data->timestamp = jiffies;
fe650407 5914 data->rpc_status = 0;
53e6fc86 5915 data->lr.roc = pnfs_roc(inode, &data->lr.arg, &data->lr.res, cred);
ea7c38fe 5916 data->inode = nfs_igrab_and_active(inode);
1c5bd76d 5917 if (data->inode) {
1c5bd76d
TM		 5918 if (data->lr.roc) {
5919 data->args.lr_args = &data->lr.arg;
5920 data->res.lr_res = &data->lr.res;
5921 }
53e6fc86
TM		 5922 } else if (data->lr.roc) {
5923 pnfs_roc_release(&data->lr.arg, &data->lr.res, 0);
5924 data->lr.roc = false;
1c5bd76d 5925 }
fe650407 5926
c970aa85 5927 task_setup_data.callback_data = data;
1174dd1f
TM		 5928 msg.rpc_argp = &data->args;
5929 msg.rpc_resp = &data->res;
c970aa85 5930 task = rpc_run_task(&task_setup_data);
7a1218a2 5931 if (IS_ERR(task))
fe650407 5932 return PTR_ERR(task);
e6f81075
TM		 5933 if (!issync)
5934 goto out;
820bf85c 5935 status = rpc_wait_for_completion_task(task);
e6f81075
TM		 5936 if (status != 0)
5937 goto out;
5938 status = data->rpc_status;
e6f81075 5939out:
e6b3c4db 5940 rpc_put_task(task);
fe650407 5941 return status;
1da177e4
LT		 5942}
5943
e6f81075 5944int nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync)
1da177e4
LT		 5945{
5946 struct nfs_server *server = NFS_SERVER(inode);
5947 struct nfs4_exception exception = { };
5948 int err;
5949 do {
e6f81075 5950 err = _nfs4_proc_delegreturn(inode, cred, stateid, issync);
48c9579a 5951 trace_nfs4_delegreturn(inode, stateid, err);
1da177e4
LT		 5952 switch (err) {
5953 case -NFS4ERR_STALE_STATEID:
5954 case -NFS4ERR_EXPIRED:
1da177e4
LT		 5955 case 0:
5956 return 0;
5957 }
5958 err = nfs4_handle_exception(server, err, &exception);
5959 } while (exception.retry);
5960 return err;
5961}
5962
1da177e4
LT		 5963static int _nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)
5964{
5965 struct inode *inode = state->inode;
5966 struct nfs_server *server = NFS_SERVER(inode);
7539bbab 5967 struct nfs_client *clp = server->nfs_client;
911d1aaf 5968 struct nfs_lockt_args arg = {
1da177e4 5969 .fh = NFS_FH(inode),
911d1aaf 5970 .fl = request,
1da177e4 5971 };
911d1aaf
TM		 5972 struct nfs_lockt_res res = {
5973 .denied = request,
1da177e4
LT		 5974 };
5975 struct rpc_message msg = {
5976 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKT],
d9b67e1e
AS		 5977 .rpc_argp = &arg,
5978 .rpc_resp = &res,
1da177e4
LT		 5979 .rpc_cred = state->owner->so_cred,
5980 };
1da177e4
LT		 5981 struct nfs4_lock_state *lsp;
5982 int status;
5983
911d1aaf 5984 arg.lock_owner.clientid = clp->cl_clientid;
8d0a8a9d
TM		 5985 status = nfs4_set_lock_state(state, request);
5986 if (status != 0)
5987 goto out;
5988 lsp = request->fl_u.nfs4_fl.owner;
48c22eb2 5989 arg.lock_owner.id = lsp->ls_seqid.owner_id;
d035c36c 5990 arg.lock_owner.s_dev = server->s_dev;
7c513058 5991 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
911d1aaf
TM		 5992 switch (status) {
5993 case 0:
5994 request->fl_type = F_UNLCK;
5995 break;
5996 case -NFS4ERR_DENIED:
5997 status = 0;
1da177e4 5998 }
70cc6487 5999 request->fl_ops->fl_release_private(request);
a6f951dd 6000 request->fl_ops = NULL;
8d0a8a9d 6001out:
1da177e4
LT		 6002 return status;
6003}
6004
6005static int nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)
6006{
6007 struct nfs4_exception exception = { };
6008 int err;
6009
6010 do {
d1b748a5
TM		 6011 err = _nfs4_proc_getlk(state, cmd, request);
6012 trace_nfs4_get_lock(request, state, cmd, err);
6013 err = nfs4_handle_exception(NFS_SERVER(state->inode), err,
1da177e4
LT		 6014 &exception);
6015 } while (exception.retry);
6016 return err;
6017}
6018
faf5f49c 6019struct nfs4_unlockdata {
911d1aaf
TM		 6020 struct nfs_locku_args arg;
6021 struct nfs_locku_res res;
faf5f49c
TM		 6022 struct nfs4_lock_state *lsp;
6023 struct nfs_open_context *ctx;
f30cb757 6024 struct nfs_lock_context *l_ctx;
911d1aaf 6025 struct file_lock fl;
516285eb 6026 struct nfs_server *server;
26e976a8 6027 unsigned long timestamp;
faf5f49c
TM		 6028};
6029
911d1aaf
TM		 6030static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl,
6031 struct nfs_open_context *ctx,
6032 struct nfs4_lock_state *lsp,
6033 struct nfs_seqid *seqid)
6034{
6035 struct nfs4_unlockdata *p;
6036 struct inode *inode = lsp->ls_state->inode;
6037
8535b2be 6038 p = kzalloc(sizeof(*p), GFP_NOFS);
911d1aaf
TM		 6039 if (p == NULL)
6040 return NULL;
6041 p->arg.fh = NFS_FH(inode);
6042 p->arg.fl = &p->fl;
6043 p->arg.seqid = seqid;
c1d51931 6044 p->res.seqid = seqid;
911d1aaf 6045 p->lsp = lsp;
194bc1f4 6046 refcount_inc(&lsp->ls_count);
911d1aaf
TM		 6047 /* Ensure we don't close file until we're done freeing locks! */
6048 p->ctx = get_nfs_open_context(ctx);
f30cb757 6049 p->l_ctx = nfs_get_lock_context(ctx);
911d1aaf
TM		 6050 memcpy(&p->fl, fl, sizeof(p->fl));
6051 p->server = NFS_SERVER(inode);
6052 return p;
6053}
6054
06f814a3 6055static void nfs4_locku_release_calldata(void *data)
faf5f49c 6056{
963d8fe5 6057 struct nfs4_unlockdata *calldata = data;
911d1aaf 6058 nfs_free_seqid(calldata->arg.seqid);
06f814a3 6059 nfs4_put_lock_state(calldata->lsp);
f30cb757 6060 nfs_put_lock_context(calldata->l_ctx);
06f814a3
TM		 6061 put_nfs_open_context(calldata->ctx);
6062 kfree(calldata);
faf5f49c
TM		 6063}
6064
963d8fe5 6065static void nfs4_locku_done(struct rpc_task *task, void *data)
faf5f49c 6066{
963d8fe5 6067 struct nfs4_unlockdata *calldata = data;
faf5f49c 6068
14516c3a
TM		 6069 if (!nfs4_sequence_done(task, &calldata->res.seq_res))
6070 return;
faf5f49c
TM		 6071 switch (task->tk_status) {
6072 case 0:
26e976a8 6073 renew_lease(calldata->server, calldata->timestamp);
75575ddf 6074 locks_lock_inode_wait(calldata->lsp->ls_state->inode, &calldata->fl);
c69899a1
TM		 6075 if (nfs4_update_lock_stateid(calldata->lsp,
6076 &calldata->res.stateid))
6077 break;
26d36301
TM		 6078 case -NFS4ERR_ADMIN_REVOKED:
6079 case -NFS4ERR_EXPIRED:
6080 nfs4_free_revoked_stateid(calldata->server,
6081 &calldata->arg.stateid,
6082 task->tk_msg.rpc_cred);
9e33bed5
TM		 6083 case -NFS4ERR_BAD_STATEID:
6084 case -NFS4ERR_OLD_STATEID:
faf5f49c 6085 case -NFS4ERR_STALE_STATEID:
425c1d4e
TM		 6086 if (!nfs4_stateid_match(&calldata->arg.stateid,
6087 &calldata->lsp->ls_stateid))
6088 rpc_restart_call_prepare(task);
faf5f49c
TM		 6089 break;
6090 default:
8478eaa1
N		 6091 if (nfs4_async_handle_error(task, calldata->server,
6092 NULL, NULL) == -EAGAIN)
d00c5d43 6093 rpc_restart_call_prepare(task);
faf5f49c 6094 }
2b1bc308 6095 nfs_release_seqid(calldata->arg.seqid);
faf5f49c
TM		 6096}
6097
4ce70ada 6098static void nfs4_locku_prepare(struct rpc_task *task, void *data)
faf5f49c 6099{
4ce70ada 6100 struct nfs4_unlockdata *calldata = data;
faf5f49c 6101
f30cb757
BC		 6102 if (test_bit(NFS_CONTEXT_UNLOCK, &calldata->l_ctx->open_context->flags) &&
6103 nfs_async_iocounter_wait(task, calldata->l_ctx))
6104 return;
6105
911d1aaf 6106 if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
c8da19b9 6107 goto out_wait;
425c1d4e 6108 nfs4_stateid_copy(&calldata->arg.stateid, &calldata->lsp->ls_stateid);
795a88c9 6109 if (test_bit(NFS_LOCK_INITIALIZED, &calldata->lsp->ls_flags) == 0) {
963d8fe5 6110 /* Note: exit _without_ running nfs4_locku_done */
c8da19b9 6111 goto out_no_action;
faf5f49c 6112 }
26e976a8 6113 calldata->timestamp = jiffies;
42e1cca7 6114 if (nfs4_setup_sequence(calldata->server->nfs_client,
a893693c 6115 &calldata->arg.seq_args,
2240a9e2
TM		 6116 &calldata->res.seq_res,
6117 task) != 0)
6118 nfs_release_seqid(calldata->arg.seqid);
c8da19b9
TM		 6119 return;
6120out_no_action:
6121 task->tk_action = NULL;
6122out_wait:
6123 nfs4_sequence_done(task, &calldata->res.seq_res);
faf5f49c
TM		 6124}
6125
963d8fe5 6126static const struct rpc_call_ops nfs4_locku_ops = {
4ce70ada 6127 .rpc_call_prepare = nfs4_locku_prepare,
963d8fe5 6128 .rpc_call_done = nfs4_locku_done,
06f814a3 6129 .rpc_release = nfs4_locku_release_calldata,
963d8fe5
TM		 6130};
6131
a5d16a4d
TM		 6132static struct rpc_task *nfs4_do_unlck(struct file_lock *fl,
6133 struct nfs_open_context *ctx,
6134 struct nfs4_lock_state *lsp,
6135 struct nfs_seqid *seqid)
6136{
6137 struct nfs4_unlockdata *data;
5138fde0
TM		 6138 struct rpc_message msg = {
6139 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKU],
6140 .rpc_cred = ctx->cred,
6141 };
c970aa85
TM		 6142 struct rpc_task_setup task_setup_data = {
6143 .rpc_client = NFS_CLIENT(lsp->ls_state->inode),
5138fde0 6144 .rpc_message = &msg,
c970aa85 6145 .callback_ops = &nfs4_locku_ops,
101070ca 6146 .workqueue = nfsiod_workqueue,
c970aa85
TM		 6147 .flags = RPC_TASK_ASYNC,
6148 };
a5d16a4d 6149
fa940720
WAA		 6150 nfs4_state_protect(NFS_SERVER(lsp->ls_state->inode)->nfs_client,
6151 NFS_SP4_MACH_CRED_CLEANUP, &task_setup_data.rpc_client, &msg);
6152
137d6aca
FF		 6153 /* Ensure this is an unlock - when canceling a lock, the
6154 * canceled lock is passed in, and it won't be an unlock.
6155 */
6156 fl->fl_type = F_UNLCK;
f30cb757
BC		 6157 if (fl->fl_flags & FL_CLOSE)
6158 set_bit(NFS_CONTEXT_UNLOCK, &ctx->flags);
137d6aca 6159
a5d16a4d
TM		 6160 data = nfs4_alloc_unlockdata(fl, ctx, lsp, seqid);
6161 if (data == NULL) {
6162 nfs_free_seqid(seqid);
6163 return ERR_PTR(-ENOMEM);
6164 }
6165
a9c92d6b 6166 nfs4_init_sequence(&data->arg.seq_args, &data->res.seq_res, 1);
1174dd1f
TM		 6167 msg.rpc_argp = &data->arg;
6168 msg.rpc_resp = &data->res;
c970aa85
TM		 6169 task_setup_data.callback_data = data;
6170 return rpc_run_task(&task_setup_data);
a5d16a4d
TM		 6171}
6172
faf5f49c
TM		 6173static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock *request)
6174{
65b62a29
TM		 6175 struct inode *inode = state->inode;
6176 struct nfs4_state_owner *sp = state->owner;
6177 struct nfs_inode *nfsi = NFS_I(inode);
911d1aaf 6178 struct nfs_seqid *seqid;
1da177e4 6179 struct nfs4_lock_state *lsp;
06f814a3 6180 struct rpc_task *task;
b4019c0e 6181 struct nfs_seqid *(*alloc_seqid)(struct nfs_seqid_counter *, gfp_t);
06f814a3 6182 int status = 0;
536ff0f8 6183 unsigned char fl_flags = request->fl_flags;
faf5f49c 6184
8d0a8a9d 6185 status = nfs4_set_lock_state(state, request);
9b073574
TM		 6186 /* Unlock _before_ we do the RPC call */
6187 request->fl_flags |= FL_EXISTS;
65b62a29
TM		 6188 /* Exclude nfs_delegation_claim_locks() */
6189 mutex_lock(&sp->so_delegreturn_mutex);
6190 /* Exclude nfs4_reclaim_open_stateid() - note nesting! */
19e03c57 6191 down_read(&nfsi->rwsem);
75575ddf 6192 if (locks_lock_inode_wait(inode, request) == -ENOENT) {
19e03c57 6193 up_read(&nfsi->rwsem);
65b62a29 6194 mutex_unlock(&sp->so_delegreturn_mutex);
9b073574 6195 goto out;
19e03c57
TM		 6196 }
6197 up_read(&nfsi->rwsem);
65b62a29 6198 mutex_unlock(&sp->so_delegreturn_mutex);
8d0a8a9d 6199 if (status != 0)
9b073574
TM		 6200 goto out;
6201 /* Is this a delegated lock? */
8d0a8a9d 6202 lsp = request->fl_u.nfs4_fl.owner;
c5a2a15f
TM		 6203 if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) == 0)
6204 goto out;
b4019c0e
TM		 6205 alloc_seqid = NFS_SERVER(inode)->nfs_client->cl_mvops->alloc_seqid;
6206 seqid = alloc_seqid(&lsp->ls_seqid, GFP_KERNEL);
9b073574 6207 status = -ENOMEM;
badc76dd 6208 if (IS_ERR(seqid))
9b073574 6209 goto out;
cd3758e3 6210 task = nfs4_do_unlck(request, nfs_file_open_context(request->fl_file), lsp, seqid);
a5d16a4d
TM		 6211 status = PTR_ERR(task);
6212 if (IS_ERR(task))
9b073574 6213 goto out;
820bf85c 6214 status = rpc_wait_for_completion_task(task);
e6b3c4db 6215 rpc_put_task(task);
9b073574 6216out:
536ff0f8 6217 request->fl_flags = fl_flags;
d1b748a5 6218 trace_nfs4_unlock(request, state, F_SETLK, status);
1da177e4
LT		 6219 return status;
6220}
6221
a5d16a4d
TM		 6222struct nfs4_lockdata {
6223 struct nfs_lock_args arg;
6224 struct nfs_lock_res res;
6225 struct nfs4_lock_state *lsp;
6226 struct nfs_open_context *ctx;
6227 struct file_lock fl;
26e976a8 6228 unsigned long timestamp;
a5d16a4d
TM		 6229 int rpc_status;
6230 int cancelled;
66179efe 6231 struct nfs_server *server;
a5d16a4d
TM		 6232};
6233
6234static struct nfs4_lockdata *nfs4_alloc_lockdata(struct file_lock *fl,
8535b2be
TM		 6235 struct nfs_open_context *ctx, struct nfs4_lock_state *lsp,
6236 gfp_t gfp_mask)
1da177e4 6237{
a5d16a4d
TM		 6238 struct nfs4_lockdata *p;
6239 struct inode *inode = lsp->ls_state->inode;
1da177e4 6240 struct nfs_server *server = NFS_SERVER(inode);
b4019c0e 6241 struct nfs_seqid *(*alloc_seqid)(struct nfs_seqid_counter *, gfp_t);
a5d16a4d 6242
8535b2be 6243 p = kzalloc(sizeof(*p), gfp_mask);
a5d16a4d
TM		 6244 if (p == NULL)
6245 return NULL;
6246
6247 p->arg.fh = NFS_FH(inode);
6248 p->arg.fl = &p->fl;
8535b2be 6249 p->arg.open_seqid = nfs_alloc_seqid(&lsp->ls_state->owner->so_seqid, gfp_mask);
badc76dd 6250 if (IS_ERR(p->arg.open_seqid))
2f74c0a0 6251 goto out_free;
b4019c0e
TM		 6252 alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid;
6253 p->arg.lock_seqid = alloc_seqid(&lsp->ls_seqid, gfp_mask);
badc76dd 6254 if (IS_ERR(p->arg.lock_seqid))
2f74c0a0 6255 goto out_free_seqid;
7539bbab 6256 p->arg.lock_owner.clientid = server->nfs_client->cl_clientid;
48c22eb2 6257 p->arg.lock_owner.id = lsp->ls_seqid.owner_id;
d035c36c 6258 p->arg.lock_owner.s_dev = server->s_dev;
c1d51931 6259 p->res.lock_seqid = p->arg.lock_seqid;
a5d16a4d 6260 p->lsp = lsp;
66179efe 6261 p->server = server;
194bc1f4 6262 refcount_inc(&lsp->ls_count);
a5d16a4d
TM		 6263 p->ctx = get_nfs_open_context(ctx);
6264 memcpy(&p->fl, fl, sizeof(p->fl));
6265 return p;
2f74c0a0
TM		 6266out_free_seqid:
6267 nfs_free_seqid(p->arg.open_seqid);
a5d16a4d
TM		 6268out_free:
6269 kfree(p);
6270 return NULL;
6271}
6272
6273static void nfs4_lock_prepare(struct rpc_task *task, void *calldata)
6274{
6275 struct nfs4_lockdata *data = calldata;
6276 struct nfs4_state *state = data->lsp->ls_state;
06735b34 6277
3110ff80 6278 dprintk("%s: begin!\n", __func__);
2f74c0a0 6279 if (nfs_wait_on_sequence(data->arg.lock_seqid, task) != 0)
c8da19b9 6280 goto out_wait;
a5d16a4d 6281 /* Do we need to do an open_to_lock_owner? */
6b447539 6282 if (!test_bit(NFS_LOCK_INITIALIZED, &data->lsp->ls_flags)) {
8fe72bac 6283 if (nfs_wait_on_sequence(data->arg.open_seqid, task) != 0) {
2240a9e2 6284 goto out_release_lock_seqid;
8fe72bac 6285 }
425c1d4e
TM		 6286 nfs4_stateid_copy(&data->arg.open_stateid,
6287 &state->open_stateid);
a5d16a4d 6288 data->arg.new_lock_owner = 1;
c1d51931 6289 data->res.open_seqid = data->arg.open_seqid;
425c1d4e 6290 } else {
2f74c0a0 6291 data->arg.new_lock_owner = 0;
425c1d4e
TM		 6292 nfs4_stateid_copy(&data->arg.lock_stateid,
6293 &data->lsp->ls_stateid);
6294 }
5d422301
TM		 6295 if (!nfs4_valid_open_stateid(state)) {
6296 data->rpc_status = -EBADF;
6297 task->tk_action = NULL;
6298 goto out_release_open_seqid;
6299 }
26e976a8 6300 data->timestamp = jiffies;
42e1cca7 6301 if (nfs4_setup_sequence(data->server->nfs_client,
035168ab 6302 &data->arg.seq_args,
2240a9e2 6303 &data->res.seq_res,
d9afbd1b 6304 task) == 0)
66179efe 6305 return;
5d422301 6306out_release_open_seqid:
2240a9e2
TM		 6307 nfs_release_seqid(data->arg.open_seqid);
6308out_release_lock_seqid:
6309 nfs_release_seqid(data->arg.lock_seqid);
c8da19b9
TM		 6310out_wait:
6311 nfs4_sequence_done(task, &data->res.seq_res);
8fe72bac 6312 dprintk("%s: done!, ret = %d\n", __func__, data->rpc_status);
b257957e
AB		 6313}
6314
a5d16a4d
TM		 6315static void nfs4_lock_done(struct rpc_task *task, void *calldata)
6316{
6317 struct nfs4_lockdata *data = calldata;
39071e6f 6318 struct nfs4_lock_state *lsp = data->lsp;
a5d16a4d 6319
3110ff80 6320 dprintk("%s: begin!\n", __func__);
a5d16a4d 6321
14516c3a
TM		 6322 if (!nfs4_sequence_done(task, &data->res.seq_res))
6323 return;
66179efe 6324
a5d16a4d 6325 data->rpc_status = task->tk_status;
425c1d4e
TM		 6326 switch (task->tk_status) {
6327 case 0:
2b0143b5 6328 renew_lease(NFS_SERVER(d_inode(data->ctx->dentry)),
39071e6f 6329 data->timestamp);
c69899a1
TM		 6330 if (data->arg.new_lock) {
6331 data->fl.fl_flags &= ~(FL_SLEEP | FL_ACCESS);
75575ddf 6332 if (locks_lock_inode_wait(lsp->ls_state->inode, &data->fl) < 0) {
c69899a1
TM		 6333 rpc_restart_call_prepare(task);
6334 break;
6335 }
6336 }
39071e6f
TM		 6337 if (data->arg.new_lock_owner != 0) {
6338 nfs_confirm_seqid(&lsp->ls_seqid, 0);
6339 nfs4_stateid_copy(&lsp->ls_stateid, &data->res.stateid);
6340 set_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags);
6341 } else if (!nfs4_update_lock_stateid(lsp, &data->res.stateid))
6342 rpc_restart_call_prepare(task);
425c1d4e
TM		 6343 break;
6344 case -NFS4ERR_BAD_STATEID:
6345 case -NFS4ERR_OLD_STATEID:
6346 case -NFS4ERR_STALE_STATEID:
6347 case -NFS4ERR_EXPIRED:
6348 if (data->arg.new_lock_owner != 0) {
6349 if (!nfs4_stateid_match(&data->arg.open_stateid,
6350 &lsp->ls_state->open_stateid))
6351 rpc_restart_call_prepare(task);
6352 } else if (!nfs4_stateid_match(&data->arg.lock_stateid,
6353 &lsp->ls_stateid))
6354 rpc_restart_call_prepare(task);
a5d16a4d 6355 }
3110ff80 6356 dprintk("%s: done, ret = %d!\n", __func__, data->rpc_status);
a5d16a4d
TM		 6357}
6358
6359static void nfs4_lock_release(void *calldata)
6360{
6361 struct nfs4_lockdata *data = calldata;
6362
3110ff80 6363 dprintk("%s: begin!\n", __func__);
2f74c0a0 6364 nfs_free_seqid(data->arg.open_seqid);
a7a3b1e9 6365 if (data->cancelled) {
a5d16a4d
TM		 6366 struct rpc_task *task;
6367 task = nfs4_do_unlck(&data->fl, data->ctx, data->lsp,
6368 data->arg.lock_seqid);
6369 if (!IS_ERR(task))
bf294b41 6370 rpc_put_task_async(task);
3110ff80 6371 dprintk("%s: cancelling lock!\n", __func__);
a5d16a4d
TM		 6372 } else
6373 nfs_free_seqid(data->arg.lock_seqid);
6374 nfs4_put_lock_state(data->lsp);
6375 put_nfs_open_context(data->ctx);
6376 kfree(data);
3110ff80 6377 dprintk("%s: done!\n", __func__);
a5d16a4d
TM		 6378}
6379
6380static const struct rpc_call_ops nfs4_lock_ops = {
6381 .rpc_call_prepare = nfs4_lock_prepare,
6382 .rpc_call_done = nfs4_lock_done,
6383 .rpc_release = nfs4_lock_release,
6384};
6385
2bee72a6
TM		 6386static void nfs4_handle_setlk_error(struct nfs_server *server, struct nfs4_lock_state *lsp, int new_lock_owner, int error)
6387{
2bee72a6
TM		 6388 switch (error) {
6389 case -NFS4ERR_ADMIN_REVOKED:
d7f3e4bf 6390 case -NFS4ERR_EXPIRED:
2bee72a6 6391 case -NFS4ERR_BAD_STATEID:
ecac799a 6392 lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED;
2bee72a6 6393 if (new_lock_owner != 0 ||
795a88c9 6394 test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) != 0)
ecac799a 6395 nfs4_schedule_stateid_recovery(server, lsp->ls_state);
a2c0b9e2
TM		 6396 break;
6397 case -NFS4ERR_STALE_STATEID:
a2c0b9e2 6398 lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED;
ecac799a 6399 nfs4_schedule_lease_recovery(server->nfs_client);
2bee72a6
TM		 6400 };
6401}
6402
afe6c27c 6403static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *fl, int recovery_type)
a5d16a4d
TM		 6404{
6405 struct nfs4_lockdata *data;
6406 struct rpc_task *task;
5138fde0
TM		 6407 struct rpc_message msg = {
6408 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCK],
6409 .rpc_cred = state->owner->so_cred,
6410 };
c970aa85
TM		 6411 struct rpc_task_setup task_setup_data = {
6412 .rpc_client = NFS_CLIENT(state->inode),
5138fde0 6413 .rpc_message = &msg,
c970aa85 6414 .callback_ops = &nfs4_lock_ops,
101070ca 6415 .workqueue = nfsiod_workqueue,
c970aa85
TM		 6416 .flags = RPC_TASK_ASYNC,
6417 };
a5d16a4d
TM		 6418 int ret;
6419
3110ff80 6420 dprintk("%s: begin!\n", __func__);
cd3758e3 6421 data = nfs4_alloc_lockdata(fl, nfs_file_open_context(fl->fl_file),
8535b2be
TM		 6422 fl->fl_u.nfs4_fl.owner,
6423 recovery_type == NFS_LOCK_NEW ? GFP_KERNEL : GFP_NOFS);
a5d16a4d
TM		 6424 if (data == NULL)
6425 return -ENOMEM;
6426 if (IS_SETLKW(cmd))
6427 data->arg.block = 1;
a9c92d6b 6428 nfs4_init_sequence(&data->arg.seq_args, &data->res.seq_res, 1);
1174dd1f
TM		 6429 msg.rpc_argp = &data->arg;
6430 msg.rpc_resp = &data->res;
c970aa85 6431 task_setup_data.callback_data = data;
8fe72bac
TM		 6432 if (recovery_type > NFS_LOCK_NEW) {
6433 if (recovery_type == NFS_LOCK_RECLAIM)
6434 data->arg.reclaim = NFS_LOCK_RECLAIM;
6435 nfs4_set_sequence_privileged(&data->arg.seq_args);
c69899a1
TM		 6436 } else
6437 data->arg.new_lock = 1;
c970aa85 6438 task = rpc_run_task(&task_setup_data);
7a1218a2 6439 if (IS_ERR(task))
a5d16a4d 6440 return PTR_ERR(task);
820bf85c 6441 ret = rpc_wait_for_completion_task(task);
a5d16a4d
TM		 6442 if (ret == 0) {
6443 ret = data->rpc_status;
2bee72a6
TM		 6444 if (ret)
6445 nfs4_handle_setlk_error(data->server, data->lsp,
6446 data->arg.new_lock_owner, ret);
a5d16a4d 6447 } else
a7a3b1e9 6448 data->cancelled = true;
e6b3c4db 6449 rpc_put_task(task);
3110ff80 6450 dprintk("%s: done, ret = %d!\n", __func__, ret);
48c9579a 6451 trace_nfs4_set_lock(fl, state, &data->res.stateid, cmd, ret);
a5d16a4d 6452 return ret;
1da177e4
LT		 6453}
6454
6455static int nfs4_lock_reclaim(struct nfs4_state *state, struct file_lock *request)
6456{
202b50dc 6457 struct nfs_server *server = NFS_SERVER(state->inode);
05ffe24f
TM		 6458 struct nfs4_exception exception = {
6459 .inode = state->inode,
6460 };
202b50dc
TM		 6461 int err;
6462
6463 do {
42a2d13e
TM		 6464 /* Cache the lock if possible... */
6465 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)
6466 return 0;
afe6c27c 6467 err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_RECLAIM);
168667c4 6468 if (err != -NFS4ERR_DELAY)
202b50dc
TM		 6469 break;
6470 nfs4_handle_exception(server, err, &exception);
6471 } while (exception.retry);
6472 return err;
1da177e4
LT		 6473}
6474
6475static int nfs4_lock_expired(struct nfs4_state *state, struct file_lock *request)
6476{
202b50dc 6477 struct nfs_server *server = NFS_SERVER(state->inode);
05ffe24f
TM		 6478 struct nfs4_exception exception = {
6479 .inode = state->inode,
6480 };
202b50dc
TM		 6481 int err;
6482
6bfc93ef
TM		 6483 err = nfs4_set_lock_state(state, request);
6484 if (err != 0)
6485 return err;
f6de7a39 6486 if (!recover_lost_locks) {
ef1820f9
N		 6487 set_bit(NFS_LOCK_LOST, &request->fl_u.nfs4_fl.owner->ls_flags);
6488 return 0;
6489 }
202b50dc 6490 do {
42a2d13e
TM		 6491 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)
6492 return 0;
afe6c27c 6493 err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_EXPIRED);
a9ed2e25
TM		 6494 switch (err) {
6495 default:
6496 goto out;
6497 case -NFS4ERR_GRACE:
6498 case -NFS4ERR_DELAY:
6499 nfs4_handle_exception(server, err, &exception);
6500 err = 0;
6501 }
202b50dc 6502 } while (exception.retry);
a9ed2e25 6503out:
202b50dc 6504 return err;
1da177e4
LT		 6505}
6506
f062eb6c 6507#if defined(CONFIG_NFS_V4_1)
b01dd1d8
BS		 6508static int nfs41_lock_expired(struct nfs4_state *state, struct file_lock *request)
6509{
c5896fc8
TM		 6510 struct nfs4_lock_state *lsp;
6511 int status;
b01dd1d8 6512
c5896fc8
TM		 6513 status = nfs4_set_lock_state(state, request);
6514 if (status != 0)
6515 return status;
6516 lsp = request->fl_u.nfs4_fl.owner;
6517 if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) ||
6518 test_bit(NFS_LOCK_LOST, &lsp->ls_flags))
6519 return 0;
81b68de4 6520 return nfs4_lock_expired(state, request);
f062eb6c
BS		 6521}
6522#endif
6523
1da177e4
LT		 6524static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
6525{
19e03c57 6526 struct nfs_inode *nfsi = NFS_I(state->inode);
11476e9d 6527 struct nfs4_state_owner *sp = state->owner;
01c3b861 6528 unsigned char fl_flags = request->fl_flags;
1ea67dbd 6529 int status;
1da177e4 6530
01c3b861 6531 request->fl_flags |= FL_ACCESS;
75575ddf 6532 status = locks_lock_inode_wait(state->inode, request);
01c3b861
TM		 6533 if (status < 0)
6534 goto out;
11476e9d 6535 mutex_lock(&sp->so_delegreturn_mutex);
19e03c57 6536 down_read(&nfsi->rwsem);
01c3b861 6537 if (test_bit(NFS_DELEGATED_STATE, &state->flags)) {
01c3b861 6538 /* Yes: cache locks! */
01c3b861 6539 /* ...but avoid races with delegation recall... */
19e03c57 6540 request->fl_flags = fl_flags & ~FL_SLEEP;
75575ddf 6541 status = locks_lock_inode_wait(state->inode, request);
c69899a1 6542 up_read(&nfsi->rwsem);
11476e9d 6543 mutex_unlock(&sp->so_delegreturn_mutex);
9a99af49 6544 goto out;
9a99af49 6545 }
19e03c57 6546 up_read(&nfsi->rwsem);
11476e9d 6547 mutex_unlock(&sp->so_delegreturn_mutex);
c69899a1 6548 status = _nfs4_do_setlk(state, cmd, request, NFS_LOCK_NEW);
01c3b861
TM		 6549out:
6550 request->fl_flags = fl_flags;
1da177e4
LT		 6551 return status;
6552}
6553
6554static int nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
6555{
a1d0b5ee
TM		 6556 struct nfs4_exception exception = {
6557 .state = state,
05ffe24f 6558 .inode = state->inode,
a1d0b5ee 6559 };
1da177e4
LT		 6560 int err;
6561
6562 do {
965b5d67
TM		 6563 err = _nfs4_proc_setlk(state, cmd, request);
6564 if (err == -NFS4ERR_DENIED)
6565 err = -EAGAIN;
1da177e4 6566 err = nfs4_handle_exception(NFS_SERVER(state->inode),
965b5d67 6567 err, &exception);
1da177e4
LT		 6568 } while (exception.retry);
6569 return err;
6570}
6571
d2f3a7f9
JL		 6572#define NFS4_LOCK_MINTIMEOUT (1 * HZ)
6573#define NFS4_LOCK_MAXTIMEOUT (30 * HZ)
6574
6575static int
a1d617d8
JL		 6576nfs4_retry_setlk_simple(struct nfs4_state *state, int cmd,
6577 struct file_lock *request)
d2f3a7f9
JL		 6578{
6579 int status = -ERESTARTSYS;
6580 unsigned long timeout = NFS4_LOCK_MINTIMEOUT;
6581
6582 while(!signalled()) {
6583 status = nfs4_proc_setlk(state, cmd, request);
6584 if ((status != -EAGAIN) || IS_SETLK(cmd))
6585 break;
6586 freezable_schedule_timeout_interruptible(timeout);
6587 timeout *= 2;
6588 timeout = min_t(unsigned long, NFS4_LOCK_MAXTIMEOUT, timeout);
6589 status = -ERESTARTSYS;
6590 }
6591 return status;
6592}
6593
a1d617d8
JL		 6594#ifdef CONFIG_NFS_V4_1
6595struct nfs4_lock_waiter {
6596 struct task_struct *task;
6597 struct inode *inode;
6598 struct nfs_lowner *owner;
6599 bool notified;
6600};
6601
6602static int
ac6424b9 6603nfs4_wake_lock_waiter(wait_queue_entry_t *wait, unsigned int mode, int flags, void *key)
a1d617d8
JL		 6604{
6605 int ret;
6606 struct cb_notify_lock_args *cbnl = key;
6607 struct nfs4_lock_waiter *waiter = wait->private;
6608 struct nfs_lowner *lowner = &cbnl->cbnl_owner,
6609 *wowner = waiter->owner;
6610
6611 /* Only wake if the callback was for the same owner */
6612 if (lowner->clientid != wowner->clientid ||
6613 lowner->id != wowner->id ||
6614 lowner->s_dev != wowner->s_dev)
6615 return 0;
6616
6617 /* Make sure it's for the right inode */
6618 if (nfs_compare_fh(NFS_FH(waiter->inode), &cbnl->cbnl_fh))
6619 return 0;
6620
6621 waiter->notified = true;
6622
6623 /* override "private" so we can use default_wake_function */
6624 wait->private = waiter->task;
6625 ret = autoremove_wake_function(wait, mode, flags, key);
6626 wait->private = waiter;
6627 return ret;
6628}
6629
6630static int
6631nfs4_retry_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
6632{
6633 int status = -ERESTARTSYS;
6634 unsigned long flags;
6635 struct nfs4_lock_state *lsp = request->fl_u.nfs4_fl.owner;
6636 struct nfs_server *server = NFS_SERVER(state->inode);
6637 struct nfs_client *clp = server->nfs_client;
6638 wait_queue_head_t *q = &clp->cl_lock_waitq;
6639 struct nfs_lowner owner = { .clientid = clp->cl_clientid,
6640 .id = lsp->ls_seqid.owner_id,
6641 .s_dev = server->s_dev };
6642 struct nfs4_lock_waiter waiter = { .task = current,
6643 .inode = state->inode,
6644 .owner = &owner,
6645 .notified = false };
ac6424b9 6646 wait_queue_entry_t wait;
a1d617d8
JL		 6647
6648 /* Don't bother with waitqueue if we don't expect a callback */
6649 if (!test_bit(NFS_STATE_MAY_NOTIFY_LOCK, &state->flags))
6650 return nfs4_retry_setlk_simple(state, cmd, request);
6651
6652 init_wait(&wait);
6653 wait.private = &waiter;
6654 wait.func = nfs4_wake_lock_waiter;
6655 add_wait_queue(q, &wait);
6656
6657 while(!signalled()) {
6658 status = nfs4_proc_setlk(state, cmd, request);
6659 if ((status != -EAGAIN) || IS_SETLK(cmd))
6660 break;
6661
6662 status = -ERESTARTSYS;
6663 spin_lock_irqsave(&q->lock, flags);
6664 if (waiter.notified) {
6665 spin_unlock_irqrestore(&q->lock, flags);
6666 continue;
6667 }
6668 set_current_state(TASK_INTERRUPTIBLE);
6669 spin_unlock_irqrestore(&q->lock, flags);
6670
b7dbcc0e 6671 freezable_schedule_timeout(NFS4_LOCK_MAXTIMEOUT);
a1d617d8
JL		 6672 }
6673
6674 finish_wait(q, &wait);
6675 return status;
6676}
6677#else /* !CONFIG_NFS_V4_1 */
6678static inline int
6679nfs4_retry_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
6680{
6681 return nfs4_retry_setlk_simple(state, cmd, request);
6682}
6683#endif
6684
1da177e4
LT		 6685static int
6686nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request)
6687{
6688 struct nfs_open_context *ctx;
6689 struct nfs4_state *state;
1da177e4
LT		 6690 int status;
6691
6692 /* verify open state */
cd3758e3 6693 ctx = nfs_file_open_context(filp);
1da177e4
LT		 6694 state = ctx->state;
6695
d953126a
TM		 6696 if (IS_GETLK(cmd)) {
6697 if (state != NULL)
6698 return nfs4_proc_getlk(state, F_GETLK, request);
6699 return 0;
6700 }
1da177e4
LT		 6701
6702 if (!(IS_SETLK(cmd) || IS_SETLKW(cmd)))
6703 return -EINVAL;
6704
d953126a
TM		 6705 if (request->fl_type == F_UNLCK) {
6706 if (state != NULL)
6707 return nfs4_proc_unlck(state, cmd, request);
6708 return 0;
6709 }
1da177e4 6710
d953126a
TM		 6711 if (state == NULL)
6712 return -ENOLCK;
1ea67dbd
JL		 6713
6714 if ((request->fl_flags & FL_POSIX) &&
6715 !test_bit(NFS_STATE_POSIX_LOCKS, &state->flags))
6716 return -ENOLCK;
6717
1ea67dbd
JL		 6718 status = nfs4_set_lock_state(state, request);
6719 if (status != 0)
6720 return status;
6721
d2f3a7f9 6722 return nfs4_retry_setlk(state, cmd, request);
1da177e4
LT		 6723}
6724
db4f2e63 6725int nfs4_lock_delegation_recall(struct file_lock *fl, struct nfs4_state *state, const nfs4_stateid *stateid)
888e694c
TM		 6726{
6727 struct nfs_server *server = NFS_SERVER(state->inode);
888e694c
TM		 6728 int err;
6729
6730 err = nfs4_set_lock_state(state, fl);
6731 if (err != 0)
db4f2e63 6732 return err;
4a706fa0 6733 err = _nfs4_do_setlk(state, F_SETLK, fl, NFS_LOCK_NEW);
db4f2e63 6734 return nfs4_handle_delegation_recall_error(server, state, stateid, err);
888e694c 6735}
6b3b5496 6736
cf470c3e
TM		 6737struct nfs_release_lockowner_data {
6738 struct nfs4_lock_state *lsp;
5ae67c4f 6739 struct nfs_server *server;
cf470c3e 6740 struct nfs_release_lockowner_args args;
b7e63a10 6741 struct nfs_release_lockowner_res res;
60ea6812 6742 unsigned long timestamp;
cf470c3e
TM		 6743};
6744
fbd4bfd1
CL		 6745static void nfs4_release_lockowner_prepare(struct rpc_task *task, void *calldata)
6746{
6747 struct nfs_release_lockowner_data *data = calldata;
5b53dc88 6748 struct nfs_server *server = data->server;
7981c8a6
AS		 6749 nfs4_setup_sequence(server->nfs_client, &data->args.seq_args,
6750 &data->res.seq_res, task);
5b53dc88 6751 data->args.lock_owner.clientid = server->nfs_client->cl_clientid;
60ea6812 6752 data->timestamp = jiffies;
fbd4bfd1
CL		 6753}
6754
6755static void nfs4_release_lockowner_done(struct rpc_task *task, void *calldata)
6756{
6757 struct nfs_release_lockowner_data *data = calldata;
60ea6812
CL		 6758 struct nfs_server *server = data->server;
6759
b7e63a10 6760 nfs40_sequence_done(task, &data->res.seq_res);
60ea6812
CL		 6761
6762 switch (task->tk_status) {
6763 case 0:
6764 renew_lease(server, data->timestamp);
6765 break;
6766 case -NFS4ERR_STALE_CLIENTID:
6767 case -NFS4ERR_EXPIRED:
5b53dc88
KM		 6768 nfs4_schedule_lease_recovery(server->nfs_client);
6769 break;
60ea6812
CL		 6770 case -NFS4ERR_LEASE_MOVED:
6771 case -NFS4ERR_DELAY:
8478eaa1
N		 6772 if (nfs4_async_handle_error(task, server,
6773 NULL, NULL) == -EAGAIN)
60ea6812
CL		 6774 rpc_restart_call_prepare(task);
6775 }
fbd4bfd1
CL		 6776}
6777
d3c7b7cc
TM		 6778static void nfs4_release_lockowner_release(void *calldata)
6779{
cf470c3e 6780 struct nfs_release_lockowner_data *data = calldata;
5ae67c4f 6781 nfs4_free_lock_state(data->server, data->lsp);
d3c7b7cc
TM		 6782 kfree(calldata);
6783}
6784
17280175 6785static const struct rpc_call_ops nfs4_release_lockowner_ops = {
fbd4bfd1
CL		 6786 .rpc_call_prepare = nfs4_release_lockowner_prepare,
6787 .rpc_call_done = nfs4_release_lockowner_done,
d3c7b7cc
TM		 6788 .rpc_release = nfs4_release_lockowner_release,
6789};
6790
f1cdae87
JL		 6791static void
6792nfs4_release_lockowner(struct nfs_server *server, struct nfs4_lock_state *lsp)
d3c7b7cc 6793{
cf470c3e 6794 struct nfs_release_lockowner_data *data;
d3c7b7cc
TM		 6795 struct rpc_message msg = {
6796 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RELEASE_LOCKOWNER],
6797 };
6798
6799 if (server->nfs_client->cl_mvops->minor_version != 0)
f1cdae87 6800 return;
fbd4bfd1 6801
cf470c3e
TM		 6802 data = kmalloc(sizeof(*data), GFP_NOFS);
6803 if (!data)
f1cdae87 6804 return;
cf470c3e 6805 data->lsp = lsp;
5ae67c4f 6806 data->server = server;
cf470c3e
TM		 6807 data->args.lock_owner.clientid = server->nfs_client->cl_clientid;
6808 data->args.lock_owner.id = lsp->ls_seqid.owner_id;
6809 data->args.lock_owner.s_dev = server->s_dev;
fbd4bfd1 6810
cf470c3e 6811 msg.rpc_argp = &data->args;
b7e63a10
TM		 6812 msg.rpc_resp = &data->res;
6813 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 0);
cf470c3e 6814 rpc_call_async(server->client, &msg, 0, &nfs4_release_lockowner_ops, data);
d3c7b7cc
TM		 6815}
6816
aa1870af
BF		 6817#define XATTR_NAME_NFSV4_ACL "system.nfs4_acl"
6818
d9a82a04 6819static int nfs4_xattr_set_nfs4_acl(const struct xattr_handler *handler,
59301226
AV		 6820 struct dentry *unused, struct inode *inode,
6821 const char *key, const void *buf,
6822 size_t buflen, int flags)
6b3b5496 6823{
59301226 6824 return nfs4_proc_set_acl(inode, buf, buflen);
6b3b5496
BF		 6825}
6826
d9a82a04 6827static int nfs4_xattr_get_nfs4_acl(const struct xattr_handler *handler,
b296821a
AV		 6828 struct dentry *unused, struct inode *inode,
6829 const char *key, void *buf, size_t buflen)
6b3b5496 6830{
b296821a 6831 return nfs4_proc_get_acl(inode, buf, buflen);
6b3b5496
BF		 6832}
6833
764a5c6b 6834static bool nfs4_xattr_list_nfs4_acl(struct dentry *dentry)
6b3b5496 6835{
764a5c6b 6836 return nfs4_server_supports_acls(NFS_SERVER(d_inode(dentry)));
6b3b5496
BF		 6837}
6838
c9bccef6 6839#ifdef CONFIG_NFS_V4_SECURITY_LABEL
c9bccef6 6840
d9a82a04 6841static int nfs4_xattr_set_nfs4_label(const struct xattr_handler *handler,
59301226
AV		 6842 struct dentry *unused, struct inode *inode,
6843 const char *key, const void *buf,
6844 size_t buflen, int flags)
c9bccef6
DQ		 6845{
6846 if (security_ismaclabel(key))
59301226 6847 return nfs4_set_security_label(inode, buf, buflen);
c9bccef6
DQ		 6848
6849 return -EOPNOTSUPP;
6850}
6851
d9a82a04 6852static int nfs4_xattr_get_nfs4_label(const struct xattr_handler *handler,
b296821a
AV		 6853 struct dentry *unused, struct inode *inode,
6854 const char *key, void *buf, size_t buflen)
c9bccef6
DQ		 6855{
6856 if (security_ismaclabel(key))
b296821a 6857 return nfs4_get_security_label(inode, buf, buflen);
c9bccef6
DQ		 6858 return -EOPNOTSUPP;
6859}
6860
c4803c49
AG		 6861static ssize_t
6862nfs4_listxattr_nfs4_label(struct inode *inode, char *list, size_t list_len)
c9bccef6 6863{
c4803c49 6864 int len = 0;
c9bccef6 6865
c4803c49
AG		 6866 if (nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL)) {
6867 len = security_inode_listsecurity(inode, list, list_len);
6868 if (list_len && len > list_len)
6869 return -ERANGE;
c9bccef6
DQ		 6870 }
6871 return len;
6872}
6873
6874static const struct xattr_handler nfs4_xattr_nfs4_label_handler = {
6875 .prefix = XATTR_SECURITY_PREFIX,
c9bccef6
DQ		 6876 .get = nfs4_xattr_get_nfs4_label,
6877 .set = nfs4_xattr_set_nfs4_label,
6878};
c9bccef6 6879
c4803c49
AG		 6880#else
6881
6882static ssize_t
6883nfs4_listxattr_nfs4_label(struct inode *inode, char *list, size_t list_len)
6884{
6885 return 0;
6886}
6887
6888#endif
c9bccef6 6889
533eb461
AA		 6890/*
6891 * nfs_fhget will use either the mounted_on_fileid or the fileid
6892 */
69aaaae1
TM		 6893static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr)
6894{
533eb461
AA		 6895 if (!(((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) ||
6896 (fattr->valid & NFS_ATTR_FATTR_FILEID)) &&
6897 (fattr->valid & NFS_ATTR_FATTR_FSID) &&
81934ddb 6898 (fattr->valid & NFS_ATTR_FATTR_V4_LOCATIONS)))
69aaaae1
TM		 6899 return;
6900
6901 fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE |
81934ddb 6902 NFS_ATTR_FATTR_NLINK | NFS_ATTR_FATTR_V4_REFERRAL;
69aaaae1
TM		 6903 fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO;
6904 fattr->nlink = 2;
6905}
6906
f05d147f
BS		 6907static int _nfs4_proc_fs_locations(struct rpc_clnt *client, struct inode *dir,
6908 const struct qstr *name,
6909 struct nfs4_fs_locations *fs_locations,
6910 struct page *page)
683b57b4
TM		 6911{
6912 struct nfs_server *server = NFS_SERVER(dir);
a09df2ca 6913 u32 bitmask[3] = {
361e624f 6914 [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS,
683b57b4
TM		 6915 };
6916 struct nfs4_fs_locations_arg args = {
6917 .dir_fh = NFS_FH(dir),
c228fd3a 6918 .name = name,
683b57b4
TM		 6919 .page = page,
6920 .bitmask = bitmask,
6921 };
22958463
BH		 6922 struct nfs4_fs_locations_res res = {
6923 .fs_locations = fs_locations,
6924 };
683b57b4
TM		 6925 struct rpc_message msg = {
6926 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS],
6927 .rpc_argp = &args,
22958463 6928 .rpc_resp = &res,
683b57b4
TM		 6929 };
6930 int status;
6931
3110ff80 6932 dprintk("%s: start\n", __func__);
533eb461
AA		 6933
6934 /* Ask for the fileid of the absent filesystem if mounted_on_fileid
6935 * is not supported */
6936 if (NFS_SERVER(dir)->attr_bitmask[1] & FATTR4_WORD1_MOUNTED_ON_FILEID)
6937 bitmask[1] |= FATTR4_WORD1_MOUNTED_ON_FILEID;
6938 else
6939 bitmask[0] |= FATTR4_WORD0_FILEID;
6940
c228fd3a 6941 nfs_fattr_init(&fs_locations->fattr);
683b57b4 6942 fs_locations->server = server;
830b8e33 6943 fs_locations->nlocations = 0;
f05d147f 6944 status = nfs4_call_sync(client, server, &msg, &args.seq_args, &res.seq_res, 0);
3110ff80 6945 dprintk("%s: returned status = %d\n", __func__, status);
683b57b4
TM		 6946 return status;
6947}
6948
f05d147f
BS		 6949int nfs4_proc_fs_locations(struct rpc_clnt *client, struct inode *dir,
6950 const struct qstr *name,
6951 struct nfs4_fs_locations *fs_locations,
6952 struct page *page)
db0a9593
BS		 6953{
6954 struct nfs4_exception exception = { };
6955 int err;
6956 do {
078ea3df
TM		 6957 err = _nfs4_proc_fs_locations(client, dir, name,
6958 fs_locations, page);
6959 trace_nfs4_get_fs_locations(dir, name, err);
6960 err = nfs4_handle_exception(NFS_SERVER(dir), err,
db0a9593
BS		 6961 &exception);
6962 } while (exception.retry);
6963 return err;
6964}
6965
b03d735b
CL		 6966/*
6967 * This operation also signals the server that this client is
6968 * performing migration recovery. The server can stop returning
6969 * NFS4ERR_LEASE_MOVED to this client. A RENEW operation is
6970 * appended to this compound to identify the client ID which is
6971 * performing recovery.
6972 */
6973static int _nfs40_proc_get_locations(struct inode *inode,
6974 struct nfs4_fs_locations *locations,
6975 struct page *page, struct rpc_cred *cred)
6976{
6977 struct nfs_server *server = NFS_SERVER(inode);
6978 struct rpc_clnt *clnt = server->client;
6979 u32 bitmask[2] = {
6980 [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS,
6981 };
6982 struct nfs4_fs_locations_arg args = {
6983 .clientid = server->nfs_client->cl_clientid,
6984 .fh = NFS_FH(inode),
6985 .page = page,
6986 .bitmask = bitmask,
6987 .migration = 1, /* skip LOOKUP */
6988 .renew = 1, /* append RENEW */
6989 };
6990 struct nfs4_fs_locations_res res = {
6991 .fs_locations = locations,
6992 .migration = 1,
6993 .renew = 1,
6994 };
6995 struct rpc_message msg = {
6996 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS],
6997 .rpc_argp = &args,
6998 .rpc_resp = &res,
6999 .rpc_cred = cred,
7000 };
7001 unsigned long now = jiffies;
7002 int status;
7003
7004 nfs_fattr_init(&locations->fattr);
7005 locations->server = server;
7006 locations->nlocations = 0;
7007
7008 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
7009 nfs4_set_sequence_privileged(&args.seq_args);
7010 status = nfs4_call_sync_sequence(clnt, server, &msg,
7011 &args.seq_args, &res.seq_res);
7012 if (status)
7013 return status;
7014
7015 renew_lease(server, now);
7016 return 0;
7017}
7018
7019#ifdef CONFIG_NFS_V4_1
7020
7021/*
7022 * This operation also signals the server that this client is
7023 * performing migration recovery. The server can stop asserting
7024 * SEQ4_STATUS_LEASE_MOVED for this client. The client ID
7025 * performing this operation is identified in the SEQUENCE
7026 * operation in this compound.
7027 *
7028 * When the client supports GETATTR(fs_locations_info), it can
7029 * be plumbed in here.
7030 */
7031static int _nfs41_proc_get_locations(struct inode *inode,
7032 struct nfs4_fs_locations *locations,
7033 struct page *page, struct rpc_cred *cred)
7034{
7035 struct nfs_server *server = NFS_SERVER(inode);
7036 struct rpc_clnt *clnt = server->client;
7037 u32 bitmask[2] = {
7038 [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS,
7039 };
7040 struct nfs4_fs_locations_arg args = {
7041 .fh = NFS_FH(inode),
7042 .page = page,
7043 .bitmask = bitmask,
7044 .migration = 1, /* skip LOOKUP */
7045 };
7046 struct nfs4_fs_locations_res res = {
7047 .fs_locations = locations,
7048 .migration = 1,
7049 };
7050 struct rpc_message msg = {
7051 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS],
7052 .rpc_argp = &args,
7053 .rpc_resp = &res,
7054 .rpc_cred = cred,
7055 };
7056 int status;
7057
7058 nfs_fattr_init(&locations->fattr);
7059 locations->server = server;
7060 locations->nlocations = 0;
7061
7062 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
7063 nfs4_set_sequence_privileged(&args.seq_args);
7064 status = nfs4_call_sync_sequence(clnt, server, &msg,
7065 &args.seq_args, &res.seq_res);
7066 if (status == NFS4_OK &&
7067 res.seq_res.sr_status_flags & SEQ4_STATUS_LEASE_MOVED)
7068 status = -NFS4ERR_LEASE_MOVED;
7069 return status;
7070}
7071
7072#endif /* CONFIG_NFS_V4_1 */
7073
7074/**
7075 * nfs4_proc_get_locations - discover locations for a migrated FSID
7076 * @inode: inode on FSID that is migrating
7077 * @locations: result of query
7078 * @page: buffer
7079 * @cred: credential to use for this operation
7080 *
7081 * Returns NFS4_OK on success, a negative NFS4ERR status code if the
7082 * operation failed, or a negative errno if a local error occurred.
7083 *
7084 * On success, "locations" is filled in, but if the server has
7085 * no locations information, NFS_ATTR_FATTR_V4_LOCATIONS is not
7086 * asserted.
7087 *
7088 * -NFS4ERR_LEASE_MOVED is returned if the server still has leases
7089 * from this client that require migration recovery.
7090 */
7091int nfs4_proc_get_locations(struct inode *inode,
7092 struct nfs4_fs_locations *locations,
7093 struct page *page, struct rpc_cred *cred)
7094{
7095 struct nfs_server *server = NFS_SERVER(inode);
7096 struct nfs_client *clp = server->nfs_client;
7097 const struct nfs4_mig_recovery_ops *ops =
7098 clp->cl_mvops->mig_recovery_ops;
7099 struct nfs4_exception exception = { };
7100 int status;
7101
7102 dprintk("%s: FSID %llx:%llx on \"%s\"\n", __func__,
7103 (unsigned long long)server->fsid.major,
7104 (unsigned long long)server->fsid.minor,
7105 clp->cl_hostname);
7106 nfs_display_fhandle(NFS_FH(inode), __func__);
7107
7108 do {
7109 status = ops->get_locations(inode, locations, page, cred);
7110 if (status != -NFS4ERR_DELAY)
7111 break;
7112 nfs4_handle_exception(server, status, &exception);
7113 } while (exception.retry);
7114 return status;
7115}
7116
44c99933
CL		 7117/*
7118 * This operation also signals the server that this client is
7119 * performing "lease moved" recovery. The server can stop
7120 * returning NFS4ERR_LEASE_MOVED to this client. A RENEW operation
7121 * is appended to this compound to identify the client ID which is
7122 * performing recovery.
7123 */
7124static int _nfs40_proc_fsid_present(struct inode *inode, struct rpc_cred *cred)
7125{
7126 struct nfs_server *server = NFS_SERVER(inode);
7127 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
7128 struct rpc_clnt *clnt = server->client;
7129 struct nfs4_fsid_present_arg args = {
7130 .fh = NFS_FH(inode),
7131 .clientid = clp->cl_clientid,
7132 .renew = 1, /* append RENEW */
7133 };
7134 struct nfs4_fsid_present_res res = {
7135 .renew = 1,
7136 };
7137 struct rpc_message msg = {
7138 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSID_PRESENT],
7139 .rpc_argp = &args,
7140 .rpc_resp = &res,
7141 .rpc_cred = cred,
7142 };
7143 unsigned long now = jiffies;
7144 int status;
7145
7146 res.fh = nfs_alloc_fhandle();
7147 if (res.fh == NULL)
7148 return -ENOMEM;
7149
7150 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
7151 nfs4_set_sequence_privileged(&args.seq_args);
7152 status = nfs4_call_sync_sequence(clnt, server, &msg,
7153 &args.seq_args, &res.seq_res);
7154 nfs_free_fhandle(res.fh);
7155 if (status)
7156 return status;
7157
7158 do_renew_lease(clp, now);
7159 return 0;
7160}
7161
7162#ifdef CONFIG_NFS_V4_1
7163
7164/*
7165 * This operation also signals the server that this client is
7166 * performing "lease moved" recovery. The server can stop asserting
7167 * SEQ4_STATUS_LEASE_MOVED for this client. The client ID performing
7168 * this operation is identified in the SEQUENCE operation in this
7169 * compound.
7170 */
7171static int _nfs41_proc_fsid_present(struct inode *inode, struct rpc_cred *cred)
7172{
7173 struct nfs_server *server = NFS_SERVER(inode);
7174 struct rpc_clnt *clnt = server->client;
7175 struct nfs4_fsid_present_arg args = {
7176 .fh = NFS_FH(inode),
7177 };
7178 struct nfs4_fsid_present_res res = {
7179 };
7180 struct rpc_message msg = {
7181 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSID_PRESENT],
7182 .rpc_argp = &args,
7183 .rpc_resp = &res,
7184 .rpc_cred = cred,
7185 };
7186 int status;
7187
7188 res.fh = nfs_alloc_fhandle();
7189 if (res.fh == NULL)
7190 return -ENOMEM;
7191
7192 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
7193 nfs4_set_sequence_privileged(&args.seq_args);
7194 status = nfs4_call_sync_sequence(clnt, server, &msg,
7195 &args.seq_args, &res.seq_res);
7196 nfs_free_fhandle(res.fh);
7197 if (status == NFS4_OK &&
7198 res.seq_res.sr_status_flags & SEQ4_STATUS_LEASE_MOVED)
7199 status = -NFS4ERR_LEASE_MOVED;
7200 return status;
7201}
7202
7203#endif /* CONFIG_NFS_V4_1 */
7204
7205/**
7206 * nfs4_proc_fsid_present - Is this FSID present or absent on server?
7207 * @inode: inode on FSID to check
7208 * @cred: credential to use for this operation
7209 *
7210 * Server indicates whether the FSID is present, moved, or not
7211 * recognized. This operation is necessary to clear a LEASE_MOVED
7212 * condition for this client ID.
7213 *
7214 * Returns NFS4_OK if the FSID is present on this server,
7215 * -NFS4ERR_MOVED if the FSID is no longer present, a negative
7216 * NFS4ERR code if some error occurred on the server, or a
7217 * negative errno if a local failure occurred.
7218 */
7219int nfs4_proc_fsid_present(struct inode *inode, struct rpc_cred *cred)
7220{
7221 struct nfs_server *server = NFS_SERVER(inode);
7222 struct nfs_client *clp = server->nfs_client;
7223 const struct nfs4_mig_recovery_ops *ops =
7224 clp->cl_mvops->mig_recovery_ops;
7225 struct nfs4_exception exception = { };
7226 int status;
7227
7228 dprintk("%s: FSID %llx:%llx on \"%s\"\n", __func__,
7229 (unsigned long long)server->fsid.major,
7230 (unsigned long long)server->fsid.minor,
7231 clp->cl_hostname);
7232 nfs_display_fhandle(NFS_FH(inode), __func__);
7233
7234 do {
7235 status = ops->fsid_present(inode, cred);
7236 if (status != -NFS4ERR_DELAY)
7237 break;
7238 nfs4_handle_exception(server, status, &exception);
7239 } while (exception.retry);
7240 return status;
7241}
7242
5ec16a85 7243/**
a5250def
WAA		 7244 * If 'use_integrity' is true and the state managment nfs_client
7245 * cl_rpcclient is using krb5i/p, use the integrity protected cl_rpcclient
7246 * and the machine credential as per RFC3530bis and RFC5661 Security
7247 * Considerations sections. Otherwise, just use the user cred with the
7248 * filesystem's rpc_client.
5ec16a85 7249 */
a5250def 7250static int _nfs4_proc_secinfo(struct inode *dir, const struct qstr *name, struct nfs4_secinfo_flavors *flavors, bool use_integrity)
5a5ea0d4
BS		 7251{
7252 int status;
7253 struct nfs4_secinfo_arg args = {
7254 .dir_fh = NFS_FH(dir),
7255 .name = name,
7256 };
7257 struct nfs4_secinfo_res res = {
7258 .flavors = flavors,
7259 };
7260 struct rpc_message msg = {
7261 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SECINFO],
7262 .rpc_argp = &args,
7263 .rpc_resp = &res,
7264 };
a5250def 7265 struct rpc_clnt *clnt = NFS_SERVER(dir)->client;
7cb852df 7266 struct rpc_cred *cred = NULL;
a5250def
WAA		 7267
7268 if (use_integrity) {
7269 clnt = NFS_SERVER(dir)->nfs_client->cl_rpcclient;
7cb852df
WAA		 7270 cred = nfs4_get_clid_cred(NFS_SERVER(dir)->nfs_client);
7271 msg.rpc_cred = cred;
a5250def 7272 }
5a5ea0d4
BS		 7273
7274 dprintk("NFS call secinfo %s\n", name->name);
8b5bee2e
WAA		 7275
7276 nfs4_state_protect(NFS_SERVER(dir)->nfs_client,
7277 NFS_SP4_MACH_CRED_SECINFO, &clnt, &msg);
7278
a5250def
WAA		 7279 status = nfs4_call_sync(clnt, NFS_SERVER(dir), &msg, &args.seq_args,
7280 &res.seq_res, 0);
5a5ea0d4 7281 dprintk("NFS reply secinfo: %d\n", status);
a5250def 7282
7cb852df
WAA		 7283 if (cred)
7284 put_rpccred(cred);
a5250def 7285
5a5ea0d4
BS		 7286 return status;
7287}
7288
72de53ec
BS		 7289int nfs4_proc_secinfo(struct inode *dir, const struct qstr *name,
7290 struct nfs4_secinfo_flavors *flavors)
5a5ea0d4
BS		 7291{
7292 struct nfs4_exception exception = { };
7293 int err;
7294 do {
a5250def
WAA		 7295 err = -NFS4ERR_WRONGSEC;
7296
7297 /* try to use integrity protection with machine cred */
7298 if (_nfs4_is_integrity_protected(NFS_SERVER(dir)->nfs_client))
7299 err = _nfs4_proc_secinfo(dir, name, flavors, true);
7300
7301 /*
7302 * if unable to use integrity protection, or SECINFO with
7303 * integrity protection returns NFS4ERR_WRONGSEC (which is
7304 * disallowed by spec, but exists in deployed servers) use
7305 * the current filesystem's rpc_client and the user cred.
7306 */
7307 if (err == -NFS4ERR_WRONGSEC)
7308 err = _nfs4_proc_secinfo(dir, name, flavors, false);
7309
078ea3df
TM		 7310 trace_nfs4_secinfo(dir, name, err);
7311 err = nfs4_handle_exception(NFS_SERVER(dir), err,
5a5ea0d4
BS		 7312 &exception);
7313 } while (exception.retry);
7314 return err;
7315}
7316
557134a3 7317#ifdef CONFIG_NFS_V4_1
357f54d6
AA		 7318/*
7319 * Check the exchange flags returned by the server for invalid flags, having
7320 * both PNFS and NON_PNFS flags set, and not having one of NON_PNFS, PNFS, or
7321 * DS flags set.
7322 */
7323static int nfs4_check_cl_exchange_flags(u32 flags)
7324{
7325 if (flags & ~EXCHGID4_FLAG_MASK_R)
7326 goto out_inval;
7327 if ((flags & EXCHGID4_FLAG_USE_PNFS_MDS) &&
7328 (flags & EXCHGID4_FLAG_USE_NON_PNFS))
7329 goto out_inval;
7330 if (!(flags & (EXCHGID4_FLAG_MASK_PNFS)))
7331 goto out_inval;
7332 return NFS_OK;
7333out_inval:
7334 return -NFS4ERR_INVAL;
7335}
7336
78fe0f41 7337static bool
79d4e1f0
CL		 7338nfs41_same_server_scope(struct nfs41_server_scope *a,
7339 struct nfs41_server_scope *b)
78fe0f41 7340{
49ad0145
AS		 7341 if (a->server_scope_sz != b->server_scope_sz)
7342 return false;
7343 return memcmp(a->server_scope, b->server_scope, a->server_scope_sz) == 0;
78fe0f41
WAA		 7344}
7345
02a95dee
AA		 7346static void
7347nfs4_bind_one_conn_to_session_done(struct rpc_task *task, void *calldata)
7348{
7349}
7350
7351static const struct rpc_call_ops nfs4_bind_one_conn_to_session_ops = {
7352 .rpc_call_done = &nfs4_bind_one_conn_to_session_done,
7353};
7354
7c44f1ae 7355/*
d9ddbf5d 7356 * nfs4_proc_bind_one_conn_to_session()
7c44f1ae
WAA		 7357 *
7358 * The 4.1 client currently uses the same TCP connection for the
7359 * fore and backchannel.
7360 */
d9ddbf5d
TM		 7361static
7362int nfs4_proc_bind_one_conn_to_session(struct rpc_clnt *clnt,
7363 struct rpc_xprt *xprt,
7364 struct nfs_client *clp,
7365 struct rpc_cred *cred)
7c44f1ae
WAA		 7366{
7367 int status;
71a097c6
TM		 7368 struct nfs41_bind_conn_to_session_args args = {
7369 .client = clp,
7370 .dir = NFS4_CDFC4_FORE_OR_BOTH,
7371 };
7c44f1ae
WAA		 7372 struct nfs41_bind_conn_to_session_res res;
7373 struct rpc_message msg = {
7374 .rpc_proc =
7375 &nfs4_procedures[NFSPROC4_CLNT_BIND_CONN_TO_SESSION],
71a097c6 7376 .rpc_argp = &args,
7c44f1ae 7377 .rpc_resp = &res,
2cf047c9 7378 .rpc_cred = cred,
7c44f1ae 7379 };
d9ddbf5d
TM		 7380 struct rpc_task_setup task_setup_data = {
7381 .rpc_client = clnt,
7382 .rpc_xprt = xprt,
02a95dee 7383 .callback_ops = &nfs4_bind_one_conn_to_session_ops,
d9ddbf5d
TM		 7384 .rpc_message = &msg,
7385 .flags = RPC_TASK_TIMEOUT,
7386 };
7387 struct rpc_task *task;
7c44f1ae 7388
71a097c6
TM		 7389 nfs4_copy_sessionid(&args.sessionid, &clp->cl_session->sess_id);
7390 if (!(clp->cl_session->flags & SESSION4_BACK_CHAN))
7391 args.dir = NFS4_CDFC4_FORE;
7c44f1ae 7392
d9ddbf5d
TM		 7393 /* Do not set the backchannel flag unless this is clnt->cl_xprt */
7394 if (xprt != rcu_access_pointer(clnt->cl_xprt))
7395 args.dir = NFS4_CDFC4_FORE;
7396
7397 task = rpc_run_task(&task_setup_data);
7398 if (!IS_ERR(task)) {
7399 status = task->tk_status;
7400 rpc_put_task(task);
7401 } else
7402 status = PTR_ERR(task);
c6d01c6f 7403 trace_nfs4_bind_conn_to_session(clp, status);
7c44f1ae 7404 if (status == 0) {
71a097c6 7405 if (memcmp(res.sessionid.data,
7c44f1ae
WAA		 7406 clp->cl_session->sess_id.data, NFS4_MAX_SESSIONID_LEN)) {
7407 dprintk("NFS: %s: Session ID mismatch\n", __func__);
c7ae7639 7408 return -EIO;
7c44f1ae 7409 }
71a097c6 7410 if ((res.dir & args.dir) != res.dir || res.dir == 0) {
7c44f1ae
WAA		 7411 dprintk("NFS: %s: Unexpected direction from server\n",
7412 __func__);
c7ae7639 7413 return -EIO;
7c44f1ae 7414 }
71a097c6 7415 if (res.use_conn_in_rdma_mode != args.use_conn_in_rdma_mode) {
7c44f1ae
WAA		 7416 dprintk("NFS: %s: Server returned RDMA mode = true\n",
7417 __func__);
c7ae7639 7418 return -EIO;
7c44f1ae
WAA		 7419 }
7420 }
c7ae7639 7421
7c44f1ae
WAA		 7422 return status;
7423}
7424
d9ddbf5d
TM		 7425struct rpc_bind_conn_calldata {
7426 struct nfs_client *clp;
7427 struct rpc_cred *cred;
7428};
7429
7430static int
7431nfs4_proc_bind_conn_to_session_callback(struct rpc_clnt *clnt,
7432 struct rpc_xprt *xprt,
7433 void *calldata)
7434{
7435 struct rpc_bind_conn_calldata *p = calldata;
7436
7437 return nfs4_proc_bind_one_conn_to_session(clnt, xprt, p->clp, p->cred);
7438}
7439
7440int nfs4_proc_bind_conn_to_session(struct nfs_client *clp, struct rpc_cred *cred)
7441{
7442 struct rpc_bind_conn_calldata data = {
7443 .clp = clp,
7444 .cred = cred,
7445 };
7446 return rpc_clnt_iterate_for_each_xprt(clp->cl_rpcclient,
7447 nfs4_proc_bind_conn_to_session_callback, &data);
7448}
7449
99fe60d0 7450/*
fa940720
WAA		 7451 * Minimum set of SP4_MACH_CRED operations from RFC 5661 in the enforce map
7452 * and operations we'd like to see to enable certain features in the allow map
2031cd1a
WAA		 7453 */
7454static const struct nfs41_state_protection nfs4_sp4_mach_cred_request = {
7455 .how = SP4_MACH_CRED,
7456 .enforce.u.words = {
7457 [1] = 1 << (OP_BIND_CONN_TO_SESSION - 32) |
7458 1 << (OP_EXCHANGE_ID - 32) |
7459 1 << (OP_CREATE_SESSION - 32) |
7460 1 << (OP_DESTROY_SESSION - 32) |
7461 1 << (OP_DESTROY_CLIENTID - 32)
fa940720
WAA		 7462 },
7463 .allow.u.words = {
7464 [0] = 1 << (OP_CLOSE) |
99ade3c7 7465 1 << (OP_OPEN_DOWNGRADE) |
a0279625 7466 1 << (OP_LOCKU) |
99ade3c7 7467 1 << (OP_DELEGRETURN) |
a0279625 7468 1 << (OP_COMMIT),
8b5bee2e 7469 [1] = 1 << (OP_SECINFO - 32) |
3787d506 7470 1 << (OP_SECINFO_NO_NAME - 32) |
99ade3c7 7471 1 << (OP_LAYOUTRETURN - 32) |
3787d506 7472 1 << (OP_TEST_STATEID - 32) |
a0279625
WAA		 7473 1 << (OP_FREE_STATEID - 32) |
7474 1 << (OP_WRITE - 32)
2031cd1a
WAA		 7475 }
7476};
7477
7478/*
7479 * Select the state protection mode for client `clp' given the server results
7480 * from exchange_id in `sp'.
99fe60d0 7481 *
2031cd1a
WAA		 7482 * Returns 0 on success, negative errno otherwise.
7483 */
7484static int nfs4_sp4_select_mode(struct nfs_client *clp,
7485 struct nfs41_state_protection *sp)
7486{
7487 static const u32 supported_enforce[NFS4_OP_MAP_NUM_WORDS] = {
7488 [1] = 1 << (OP_BIND_CONN_TO_SESSION - 32) |
7489 1 << (OP_EXCHANGE_ID - 32) |
7490 1 << (OP_CREATE_SESSION - 32) |
7491 1 << (OP_DESTROY_SESSION - 32) |
7492 1 << (OP_DESTROY_CLIENTID - 32)
7493 };
937e3133 7494 unsigned long flags = 0;
2031cd1a 7495 unsigned int i;
937e3133 7496 int ret = 0;
2031cd1a
WAA		 7497
7498 if (sp->how == SP4_MACH_CRED) {
7499 /* Print state protect result */
7500 dfprintk(MOUNT, "Server SP4_MACH_CRED support:\n");
7501 for (i = 0; i <= LAST_NFS4_OP; i++) {
7502 if (test_bit(i, sp->enforce.u.longs))
7503 dfprintk(MOUNT, " enforce op %d\n", i);
7504 if (test_bit(i, sp->allow.u.longs))
7505 dfprintk(MOUNT, " allow op %d\n", i);
7506 }
7507
7508 /* make sure nothing is on enforce list that isn't supported */
7509 for (i = 0; i < NFS4_OP_MAP_NUM_WORDS; i++) {
7510 if (sp->enforce.u.words[i] & ~supported_enforce[i]) {
7511 dfprintk(MOUNT, "sp4_mach_cred: disabled\n");
937e3133
TM		 7512 ret = -EINVAL;
7513 goto out;
2031cd1a
WAA		 7514 }
7515 }
7516
7517 /*
7518 * Minimal mode - state operations are allowed to use machine
7519 * credential. Note this already happens by default, so the
7520 * client doesn't have to do anything more than the negotiation.
7521 *
7522 * NOTE: we don't care if EXCHANGE_ID is in the list -
7523 * we're already using the machine cred for exchange_id
7524 * and will never use a different cred.
7525 */
7526 if (test_bit(OP_BIND_CONN_TO_SESSION, sp->enforce.u.longs) &&
7527 test_bit(OP_CREATE_SESSION, sp->enforce.u.longs) &&
7528 test_bit(OP_DESTROY_SESSION, sp->enforce.u.longs) &&
7529 test_bit(OP_DESTROY_CLIENTID, sp->enforce.u.longs)) {
7530 dfprintk(MOUNT, "sp4_mach_cred:\n");
7531 dfprintk(MOUNT, " minimal mode enabled\n");
937e3133 7532 __set_bit(NFS_SP4_MACH_CRED_MINIMAL, &flags);
2031cd1a
WAA		 7533 } else {
7534 dfprintk(MOUNT, "sp4_mach_cred: disabled\n");
937e3133
TM		 7535 ret = -EINVAL;
7536 goto out;
2031cd1a 7537 }
fa940720
WAA		 7538
7539 if (test_bit(OP_CLOSE, sp->allow.u.longs) &&
99ade3c7
AE		 7540 test_bit(OP_OPEN_DOWNGRADE, sp->allow.u.longs) &&
7541 test_bit(OP_DELEGRETURN, sp->allow.u.longs) &&
fa940720
WAA		 7542 test_bit(OP_LOCKU, sp->allow.u.longs)) {
7543 dfprintk(MOUNT, " cleanup mode enabled\n");
937e3133 7544 __set_bit(NFS_SP4_MACH_CRED_CLEANUP, &flags);
fa940720 7545 }
8b5bee2e 7546
99ade3c7
AE		 7547 if (test_bit(OP_LAYOUTRETURN, sp->allow.u.longs)) {
7548 dfprintk(MOUNT, " pnfs cleanup mode enabled\n");
937e3133 7549 __set_bit(NFS_SP4_MACH_CRED_PNFS_CLEANUP, &flags);
99ade3c7
AE		 7550 }
7551
8b5bee2e
WAA		 7552 if (test_bit(OP_SECINFO, sp->allow.u.longs) &&
7553 test_bit(OP_SECINFO_NO_NAME, sp->allow.u.longs)) {
7554 dfprintk(MOUNT, " secinfo mode enabled\n");
937e3133 7555 __set_bit(NFS_SP4_MACH_CRED_SECINFO, &flags);
8b5bee2e 7556 }
3787d506
WAA		 7557
7558 if (test_bit(OP_TEST_STATEID, sp->allow.u.longs) &&
7559 test_bit(OP_FREE_STATEID, sp->allow.u.longs)) {
7560 dfprintk(MOUNT, " stateid mode enabled\n");
937e3133 7561 __set_bit(NFS_SP4_MACH_CRED_STATEID, &flags);
3787d506 7562 }
8c21c62c
WAA		 7563
7564 if (test_bit(OP_WRITE, sp->allow.u.longs)) {
7565 dfprintk(MOUNT, " write mode enabled\n");
937e3133 7566 __set_bit(NFS_SP4_MACH_CRED_WRITE, &flags);
8c21c62c
WAA		 7567 }
7568
7569 if (test_bit(OP_COMMIT, sp->allow.u.longs)) {
7570 dfprintk(MOUNT, " commit mode enabled\n");
937e3133 7571 __set_bit(NFS_SP4_MACH_CRED_COMMIT, &flags);
8c21c62c 7572 }
2031cd1a 7573 }
937e3133
TM		 7574out:
7575 clp->cl_sp4_flags = flags;
2031cd1a
WAA		 7576 return 0;
7577}
7578
8d89bd70
AA		 7579struct nfs41_exchange_id_data {
7580 struct nfs41_exchange_id_res res;
7581 struct nfs41_exchange_id_args args;
8d89bd70
AA		 7582};
7583
8d89bd70
AA		 7584static void nfs4_exchange_id_release(void *data)
7585{
7586 struct nfs41_exchange_id_data *cdata =
7587 (struct nfs41_exchange_id_data *)data;
7588
63513232 7589 nfs_put_client(cdata->args.client);
8d89bd70
AA		 7590 kfree(cdata->res.impl_id);
7591 kfree(cdata->res.server_scope);
7592 kfree(cdata->res.server_owner);
7593 kfree(cdata);
7594}
7595
7596static const struct rpc_call_ops nfs4_exchange_id_call_ops = {
8d89bd70
AA		 7597 .rpc_release = nfs4_exchange_id_release,
7598};
7599
2031cd1a
WAA		 7600/*
7601 * _nfs4_proc_exchange_id()
6bbb4ae8 7602 *
2031cd1a 7603 * Wrapper for EXCHANGE_ID operation.
99fe60d0 7604 */
9c760d1f
TM		 7605static struct rpc_task *
7606nfs4_run_exchange_id(struct nfs_client *clp, struct rpc_cred *cred,
ad0849a7 7607 u32 sp4_how, struct rpc_xprt *xprt)
99fe60d0 7608{
99fe60d0
BH		 7609 struct rpc_message msg = {
7610 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_EXCHANGE_ID],
99fe60d0
BH		 7611 .rpc_cred = cred,
7612 };
8d89bd70
AA		 7613 struct rpc_task_setup task_setup_data = {
7614 .rpc_client = clp->cl_rpcclient,
7615 .callback_ops = &nfs4_exchange_id_call_ops,
7616 .rpc_message = &msg,
d9cb7330 7617 .flags = RPC_TASK_TIMEOUT,
8d89bd70
AA		 7618 };
7619 struct nfs41_exchange_id_data *calldata;
e917f0d1 7620 int status;
8d89bd70 7621
212bf41d 7622 if (!refcount_inc_not_zero(&clp->cl_count))
9c760d1f 7623 return ERR_PTR(-EIO);
8d89bd70 7624
9c760d1f 7625 status = -ENOMEM;
8d89bd70 7626 calldata = kzalloc(sizeof(*calldata), GFP_NOFS);
9c760d1f
TM		 7627 if (!calldata)
7628 goto out;
99fe60d0 7629
fd40559c 7630 nfs4_init_boot_verifier(clp, &calldata->args.verifier);
873e3851
JL		 7631
7632 status = nfs4_init_uniform_client_string(clp);
7633 if (status)
8d89bd70 7634 goto out_calldata;
3a6bb738 7635
8d89bd70
AA		 7636 calldata->res.server_owner = kzalloc(sizeof(struct nfs41_server_owner),
7637 GFP_NOFS);
7638 status = -ENOMEM;
7639 if (unlikely(calldata->res.server_owner == NULL))
7640 goto out_calldata;
78fe0f41 7641
8d89bd70 7642 calldata->res.server_scope = kzalloc(sizeof(struct nfs41_server_scope),
bbafffd2 7643 GFP_NOFS);
8d89bd70 7644 if (unlikely(calldata->res.server_scope == NULL))
acdeb69d 7645 goto out_server_owner;
78fe0f41 7646
8d89bd70
AA		 7647 calldata->res.impl_id = kzalloc(sizeof(struct nfs41_impl_id), GFP_NOFS);
7648 if (unlikely(calldata->res.impl_id == NULL))
7d2ed9ac 7649 goto out_server_scope;
7d2ed9ac 7650
2031cd1a
WAA		 7651 switch (sp4_how) {
7652 case SP4_NONE:
8d89bd70 7653 calldata->args.state_protect.how = SP4_NONE;
2031cd1a
WAA		 7654 break;
7655
7656 case SP4_MACH_CRED:
8d89bd70 7657 calldata->args.state_protect = nfs4_sp4_mach_cred_request;
2031cd1a
WAA		 7658 break;
7659
7660 default:
7661 /* unsupported! */
7662 WARN_ON_ONCE(1);
7663 status = -EINVAL;
6b55970b 7664 goto out_impl_id;
2031cd1a 7665 }
ad0849a7 7666 if (xprt) {
ad0849a7 7667 task_setup_data.rpc_xprt = xprt;
d9cb7330 7668 task_setup_data.flags |= RPC_TASK_SOFTCONN;
fd40559c
TM		 7669 memcpy(calldata->args.verifier.data, clp->cl_confirm.data,
7670 sizeof(calldata->args.verifier.data));
ad0849a7 7671 }
8d89bd70 7672 calldata->args.client = clp;
8d89bd70 7673 calldata->args.flags = EXCHGID4_FLAG_SUPP_MOVED_REFER |
bfab2817
TM		 7674 EXCHGID4_FLAG_BIND_PRINC_STATEID;
7675#ifdef CONFIG_NFS_V4_1_MIGRATION
7676 calldata->args.flags |= EXCHGID4_FLAG_SUPP_MOVED_MIGR;
8d89bd70
AA		 7677#endif
7678 msg.rpc_argp = &calldata->args;
7679 msg.rpc_resp = &calldata->res;
7680 task_setup_data.callback_data = calldata;
2031cd1a 7681
9c760d1f 7682 return rpc_run_task(&task_setup_data);
8d89bd70
AA		 7683
7684out_impl_id:
7685 kfree(calldata->res.impl_id);
7686out_server_scope:
7687 kfree(calldata->res.server_scope);
7688out_server_owner:
7689 kfree(calldata->res.server_owner);
7690out_calldata:
7691 kfree(calldata);
9c760d1f 7692out:
63513232 7693 nfs_put_client(clp);
9c760d1f
TM		 7694 return ERR_PTR(status);
7695}
7696
7697/*
7698 * _nfs4_proc_exchange_id()
7699 *
7700 * Wrapper for EXCHANGE_ID operation.
7701 */
7702static int _nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred,
7703 u32 sp4_how)
7704{
7705 struct rpc_task *task;
7706 struct nfs41_exchange_id_args *argp;
7707 struct nfs41_exchange_id_res *resp;
7708 int status;
7709
7710 task = nfs4_run_exchange_id(clp, cred, sp4_how, NULL);
7711 if (IS_ERR(task))
7712 return PTR_ERR(task);
7713
7714 argp = task->tk_msg.rpc_argp;
7715 resp = task->tk_msg.rpc_resp;
7716 status = task->tk_status;
7717 if (status != 0)
7718 goto out;
7719
7720 status = nfs4_check_cl_exchange_flags(resp->flags);
7721 if (status != 0)
7722 goto out;
7723
7724 status = nfs4_sp4_select_mode(clp, &resp->state_protect);
7725 if (status != 0)
7726 goto out;
7727
7728 clp->cl_clientid = resp->clientid;
7729 clp->cl_exchange_flags = resp->flags;
7730 clp->cl_seqid = resp->seqid;
7731 /* Client ID is not confirmed */
7732 if (!(resp->flags & EXCHGID4_FLAG_CONFIRMED_R))
7733 clear_bit(NFS4_SESSION_ESTABLISHED,
7734 &clp->cl_session->session_state);
7735
7736 if (clp->cl_serverscope != NULL &&
7737 !nfs41_same_server_scope(clp->cl_serverscope,
7738 resp->server_scope)) {
7739 dprintk("%s: server_scope mismatch detected\n",
7740 __func__);
7741 set_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state);
7742 }
7743
7744 swap(clp->cl_serverowner, resp->server_owner);
7745 swap(clp->cl_serverscope, resp->server_scope);
7746 swap(clp->cl_implid, resp->impl_id);
7747
7748 /* Save the EXCHANGE_ID verifier session trunk tests */
7749 memcpy(clp->cl_confirm.data, argp->verifier.data,
7750 sizeof(clp->cl_confirm.data));
7751out:
7752 trace_nfs4_exchange_id(clp, status);
7753 rpc_put_task(task);
7754 return status;
99fe60d0
BH		 7755}
7756
2031cd1a
WAA		 7757/*
7758 * nfs4_proc_exchange_id()
7759 *
7760 * Returns zero, a negative errno, or a negative NFS4ERR status code.
7761 *
7762 * Since the clientid has expired, all compounds using sessions
7763 * associated with the stale clientid will be returning
7764 * NFS4ERR_BADSESSION in the sequence operation, and will therefore
7765 * be in some phase of session reset.
7766 *
7767 * Will attempt to negotiate SP4_MACH_CRED if krb5i / krb5p auth is used.
7768 */
7769int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred)
7770{
7771 rpc_authflavor_t authflavor = clp->cl_rpcclient->cl_auth->au_flavor;
7772 int status;
7773
7774 /* try SP4_MACH_CRED if krb5i/p */
7775 if (authflavor == RPC_AUTH_GSS_KRB5I ||
7776 authflavor == RPC_AUTH_GSS_KRB5P) {
9c760d1f 7777 status = _nfs4_proc_exchange_id(clp, cred, SP4_MACH_CRED);
2031cd1a
WAA		 7778 if (!status)
7779 return 0;
7780 }
7781
7782 /* try SP4_NONE */
9c760d1f 7783 return _nfs4_proc_exchange_id(clp, cred, SP4_NONE);
2031cd1a
WAA		 7784}
7785
04fa2c6b
AA		 7786/**
7787 * nfs4_test_session_trunk
7788 *
7789 * This is an add_xprt_test() test function called from
7790 * rpc_clnt_setup_test_and_add_xprt.
7791 *
7792 * The rpc_xprt_switch is referrenced by rpc_clnt_setup_test_and_add_xprt
7793 * and is dereferrenced in nfs4_exchange_id_release
7794 *
7795 * Upon success, add the new transport to the rpc_clnt
7796 *
7797 * @clnt: struct rpc_clnt to get new transport
7798 * @xprt: the rpc_xprt to test
7799 * @data: call data for _nfs4_proc_exchange_id.
7800 */
7801int nfs4_test_session_trunk(struct rpc_clnt *clnt, struct rpc_xprt *xprt,
7802 void *data)
7803{
7804 struct nfs4_add_xprt_data *adata = (struct nfs4_add_xprt_data *)data;
9c760d1f
TM		 7805 struct rpc_task *task;
7806 int status;
7807
04fa2c6b
AA		 7808 u32 sp4_how;
7809
7810 dprintk("--> %s try %s\n", __func__,
7811 xprt->address_strings[RPC_DISPLAY_ADDR]);
7812
7813 sp4_how = (adata->clp->cl_sp4_flags == 0 ? SP4_NONE : SP4_MACH_CRED);
7814
7815 /* Test connection for session trunking. Async exchange_id call */
9c760d1f
TM		 7816 task = nfs4_run_exchange_id(adata->clp, adata->cred, sp4_how, xprt);
7817 if (IS_ERR(task))
7818 return PTR_ERR(task);
7819
7820 status = task->tk_status;
7821 if (status == 0)
7822 status = nfs4_detect_session_trunking(adata->clp,
7823 task->tk_msg.rpc_resp, xprt);
7824
7825 rpc_put_task(task);
7826 return status;
2031cd1a 7827}
04fa2c6b 7828EXPORT_SYMBOL_GPL(nfs4_test_session_trunk);
2031cd1a 7829
66245539
TM		 7830static int _nfs4_proc_destroy_clientid(struct nfs_client *clp,
7831 struct rpc_cred *cred)
7832{
7833 struct rpc_message msg = {
7834 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_CLIENTID],
7835 .rpc_argp = clp,
7836 .rpc_cred = cred,
7837 };
7838 int status;
7839
7840 status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
c6d01c6f 7841 trace_nfs4_destroy_clientid(clp, status);
66245539 7842 if (status)
02c67525 7843 dprintk("NFS: Got error %d from the server %s on "
66245539
TM		 7844 "DESTROY_CLIENTID.", status, clp->cl_hostname);
7845 return status;
7846}
7847
7848static int nfs4_proc_destroy_clientid(struct nfs_client *clp,
7849 struct rpc_cred *cred)
7850{
7851 unsigned int loop;
7852 int ret;
7853
7854 for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) {
7855 ret = _nfs4_proc_destroy_clientid(clp, cred);
7856 switch (ret) {
7857 case -NFS4ERR_DELAY:
7858 case -NFS4ERR_CLIENTID_BUSY:
7859 ssleep(1);
7860 break;
7861 default:
7862 return ret;
7863 }
7864 }
7865 return 0;
7866}
7867
7868int nfs4_destroy_clientid(struct nfs_client *clp)
7869{
7870 struct rpc_cred *cred;
7871 int ret = 0;
7872
7873 if (clp->cl_mvops->minor_version < 1)
7874 goto out;
7875 if (clp->cl_exchange_flags == 0)
7876 goto out;
05f4c350
CL		 7877 if (clp->cl_preserve_clid)
7878 goto out;
73d8bde5 7879 cred = nfs4_get_clid_cred(clp);
66245539
TM		 7880 ret = nfs4_proc_destroy_clientid(clp, cred);
7881 if (cred)
7882 put_rpccred(cred);
7883 switch (ret) {
7884 case 0:
7885 case -NFS4ERR_STALE_CLIENTID:
7886 clp->cl_exchange_flags = 0;
7887 }
7888out:
7889 return ret;
7890}
7891
2050f0cc
AA		 7892struct nfs4_get_lease_time_data {
7893 struct nfs4_get_lease_time_args *args;
7894 struct nfs4_get_lease_time_res *res;
7895 struct nfs_client *clp;
7896};
7897
7898static void nfs4_get_lease_time_prepare(struct rpc_task *task,
7899 void *calldata)
7900{
2050f0cc
AA		 7901 struct nfs4_get_lease_time_data *data =
7902 (struct nfs4_get_lease_time_data *)calldata;
7903
7904 dprintk("--> %s\n", __func__);
7905 /* just setup sequence, do not trigger session recovery
7906 since we're invoked within one */
7981c8a6 7907 nfs4_setup_sequence(data->clp,
d9afbd1b
TM		 7908 &data->args->la_seq_args,
7909 &data->res->lr_seq_res,
7910 task);
2050f0cc
AA		 7911 dprintk("<-- %s\n", __func__);
7912}
7913
7914/*
7915 * Called from nfs4_state_manager thread for session setup, so don't recover
7916 * from sequence operation or clientid errors.
7917 */
7918static void nfs4_get_lease_time_done(struct rpc_task *task, void *calldata)
7919{
7920 struct nfs4_get_lease_time_data *data =
7921 (struct nfs4_get_lease_time_data *)calldata;
7922
7923 dprintk("--> %s\n", __func__);
14516c3a
TM		 7924 if (!nfs41_sequence_done(task, &data->res->lr_seq_res))
7925 return;
2050f0cc
AA		 7926 switch (task->tk_status) {
7927 case -NFS4ERR_DELAY:
7928 case -NFS4ERR_GRACE:
7929 dprintk("%s Retry: tk_status %d\n", __func__, task->tk_status);
7930 rpc_delay(task, NFS4_POLL_RETRY_MIN);
7931 task->tk_status = 0;
a8a4ae3a
AA		 7932 /* fall through */
7933 case -NFS4ERR_RETRY_UNCACHED_REP:
d00c5d43 7934 rpc_restart_call_prepare(task);
2050f0cc
AA		 7935 return;
7936 }
2050f0cc
AA		 7937 dprintk("<-- %s\n", __func__);
7938}
7939
17280175 7940static const struct rpc_call_ops nfs4_get_lease_time_ops = {
2050f0cc
AA		 7941 .rpc_call_prepare = nfs4_get_lease_time_prepare,
7942 .rpc_call_done = nfs4_get_lease_time_done,
7943};
7944
7945int nfs4_proc_get_lease_time(struct nfs_client *clp, struct nfs_fsinfo *fsinfo)
7946{
7947 struct rpc_task *task;
7948 struct nfs4_get_lease_time_args args;
7949 struct nfs4_get_lease_time_res res = {
7950 .lr_fsinfo = fsinfo,
7951 };
7952 struct nfs4_get_lease_time_data data = {
7953 .args = &args,
7954 .res = &res,
7955 .clp = clp,
7956 };
7957 struct rpc_message msg = {
7958 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GET_LEASE_TIME],
7959 .rpc_argp = &args,
7960 .rpc_resp = &res,
7961 };
7962 struct rpc_task_setup task_setup = {
7963 .rpc_client = clp->cl_rpcclient,
7964 .rpc_message = &msg,
7965 .callback_ops = &nfs4_get_lease_time_ops,
1bd714f2
TM		 7966 .callback_data = &data,
7967 .flags = RPC_TASK_TIMEOUT,
2050f0cc
AA		 7968 };
7969 int status;
7970
a9c92d6b 7971 nfs4_init_sequence(&args.la_seq_args, &res.lr_seq_res, 0);
8fe72bac 7972 nfs4_set_sequence_privileged(&args.la_seq_args);
2050f0cc
AA		 7973 task = rpc_run_task(&task_setup);
7974
7975 if (IS_ERR(task))
f6148713 7976 return PTR_ERR(task);
2050f0cc 7977
f6148713
AS		 7978 status = task->tk_status;
7979 rpc_put_task(task);
2050f0cc
AA		 7980 return status;
7981}
7982
fc931582
AA		 7983/*
7984 * Initialize the values to be used by the client in CREATE_SESSION
7985 * If nfs4_init_session set the fore channel request and response sizes,
7986 * use them.
7987 *
7988 * Set the back channel max_resp_sz_cached to zero to force the client to
7989 * always set csa_cachethis to FALSE because the current implementation
7990 * of the back channel DRC only supports caching the CB_SEQUENCE operation.
7991 */
6b26cc8c
CL		 7992static void nfs4_init_channel_attrs(struct nfs41_create_session_args *args,
7993 struct rpc_clnt *clnt)
fc931582 7994{
18aad3d5 7995 unsigned int max_rqst_sz, max_resp_sz;
6b26cc8c 7996 unsigned int max_bc_payload = rpc_max_bc_payload(clnt);
18aad3d5
AA		 7997
7998 max_rqst_sz = NFS_MAX_FILE_IO_SIZE + nfs41_maxwrite_overhead;
7999 max_resp_sz = NFS_MAX_FILE_IO_SIZE + nfs41_maxread_overhead;
fc931582 8000
fc931582 8001 /* Fore channel attributes */
18aad3d5
AA		 8002 args->fc_attrs.max_rqst_sz = max_rqst_sz;
8003 args->fc_attrs.max_resp_sz = max_resp_sz;
fc931582 8004 args->fc_attrs.max_ops = NFS4_MAX_OPS;
ef159e91 8005 args->fc_attrs.max_reqs = max_session_slots;
fc931582
AA		 8006
8007 dprintk("%s: Fore Channel : max_rqst_sz=%u max_resp_sz=%u "
8e0d46e1 8008 "max_ops=%u max_reqs=%u\n",
fc931582
AA		 8009 __func__,
8010 args->fc_attrs.max_rqst_sz, args->fc_attrs.max_resp_sz,
8e0d46e1 8011 args->fc_attrs.max_ops, args->fc_attrs.max_reqs);
fc931582
AA		 8012
8013 /* Back channel attributes */
6b26cc8c
CL		 8014 args->bc_attrs.max_rqst_sz = max_bc_payload;
8015 args->bc_attrs.max_resp_sz = max_bc_payload;
fc931582
AA		 8016 args->bc_attrs.max_resp_sz_cached = 0;
8017 args->bc_attrs.max_ops = NFS4_MAX_BACK_CHANNEL_OPS;
5405fc44 8018 args->bc_attrs.max_reqs = min_t(unsigned short, max_session_cb_slots, 1);
fc931582
AA		 8019
8020 dprintk("%s: Back Channel : max_rqst_sz=%u max_resp_sz=%u "
8021 "max_resp_sz_cached=%u max_ops=%u max_reqs=%u\n",
8022 __func__,
8023 args->bc_attrs.max_rqst_sz, args->bc_attrs.max_resp_sz,
8024 args->bc_attrs.max_resp_sz_cached, args->bc_attrs.max_ops,
8025 args->bc_attrs.max_reqs);
8026}
8027
79969dd1
TM		 8028static int nfs4_verify_fore_channel_attrs(struct nfs41_create_session_args *args,
8029 struct nfs41_create_session_res *res)
8d35301d 8030{
43c2e885 8031 struct nfs4_channel_attrs *sent = &args->fc_attrs;
79969dd1 8032 struct nfs4_channel_attrs *rcvd = &res->fc_attrs;
43c2e885 8033
43c2e885
BF		 8034 if (rcvd->max_resp_sz > sent->max_resp_sz)
8035 return -EINVAL;
8036 /*
8037 * Our requested max_ops is the minimum we need; we're not
8038 * prepared to break up compounds into smaller pieces than that.
8039 * So, no point even trying to continue if the server won't
8040 * cooperate:
8041 */
8042 if (rcvd->max_ops < sent->max_ops)
8043 return -EINVAL;
8044 if (rcvd->max_reqs == 0)
8045 return -EINVAL;
b4b9a0c1
VG		 8046 if (rcvd->max_reqs > NFS4_MAX_SLOT_TABLE)
8047 rcvd->max_reqs = NFS4_MAX_SLOT_TABLE;
43c2e885 8048 return 0;
8d35301d
AA		 8049}
8050
79969dd1
TM		 8051static int nfs4_verify_back_channel_attrs(struct nfs41_create_session_args *args,
8052 struct nfs41_create_session_res *res)
43c2e885
BF		 8053{
8054 struct nfs4_channel_attrs *sent = &args->bc_attrs;
79969dd1 8055 struct nfs4_channel_attrs *rcvd = &res->bc_attrs;
8d35301d 8056
b1c0df5f
TM		 8057 if (!(res->flags & SESSION4_BACK_CHAN))
8058 goto out;
43c2e885
BF		 8059 if (rcvd->max_rqst_sz > sent->max_rqst_sz)
8060 return -EINVAL;
8061 if (rcvd->max_resp_sz < sent->max_resp_sz)
8062 return -EINVAL;
8063 if (rcvd->max_resp_sz_cached > sent->max_resp_sz_cached)
8064 return -EINVAL;
5405fc44 8065 if (rcvd->max_ops > sent->max_ops)
43c2e885 8066 return -EINVAL;
5405fc44 8067 if (rcvd->max_reqs > sent->max_reqs)
43c2e885 8068 return -EINVAL;
b1c0df5f 8069out:
43c2e885
BF		 8070 return 0;
8071}
8d35301d 8072
8d35301d 8073static int nfs4_verify_channel_attrs(struct nfs41_create_session_args *args,
79969dd1 8074 struct nfs41_create_session_res *res)
8d35301d 8075{
43c2e885 8076 int ret;
8d35301d 8077
79969dd1 8078 ret = nfs4_verify_fore_channel_attrs(args, res);
43c2e885
BF		 8079 if (ret)
8080 return ret;
79969dd1
TM		 8081 return nfs4_verify_back_channel_attrs(args, res);
8082}
8083
8084static void nfs4_update_session(struct nfs4_session *session,
8085 struct nfs41_create_session_res *res)
8086{
8087 nfs4_copy_sessionid(&session->sess_id, &res->sessionid);
e11259f9
TM		 8088 /* Mark client id and session as being confirmed */
8089 session->clp->cl_exchange_flags |= EXCHGID4_FLAG_CONFIRMED_R;
8090 set_bit(NFS4_SESSION_ESTABLISHED, &session->session_state);
79969dd1
TM		 8091 session->flags = res->flags;
8092 memcpy(&session->fc_attrs, &res->fc_attrs, sizeof(session->fc_attrs));
b1c0df5f
TM		 8093 if (res->flags & SESSION4_BACK_CHAN)
8094 memcpy(&session->bc_attrs, &res->bc_attrs,
8095 sizeof(session->bc_attrs));
8d35301d
AA		 8096}
8097
848f5bda
TM		 8098static int _nfs4_proc_create_session(struct nfs_client *clp,
8099 struct rpc_cred *cred)
fc931582
AA		 8100{
8101 struct nfs4_session *session = clp->cl_session;
8102 struct nfs41_create_session_args args = {
8103 .client = clp,
79969dd1
TM		 8104 .clientid = clp->cl_clientid,
8105 .seqid = clp->cl_seqid,
fc931582
AA		 8106 .cb_program = NFS4_CALLBACK,
8107 };
79969dd1
TM		 8108 struct nfs41_create_session_res res;
8109
fc931582
AA		 8110 struct rpc_message msg = {
8111 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE_SESSION],
8112 .rpc_argp = &args,
8113 .rpc_resp = &res,
848f5bda 8114 .rpc_cred = cred,
fc931582
AA		 8115 };
8116 int status;
8117
6b26cc8c 8118 nfs4_init_channel_attrs(&args, clp->cl_rpcclient);
0f91421e 8119 args.flags = (SESSION4_PERSIST | SESSION4_BACK_CHAN);
fc931582 8120
1bd714f2 8121 status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
c6d01c6f 8122 trace_nfs4_create_session(clp, status);
fc931582 8123
b519d408
TM		 8124 switch (status) {
8125 case -NFS4ERR_STALE_CLIENTID:
8126 case -NFS4ERR_DELAY:
8127 case -ETIMEDOUT:
8128 case -EACCES:
8129 case -EAGAIN:
8130 goto out;
8131 };
8132
8133 clp->cl_seqid++;
43095d39 8134 if (!status) {
8d35301d 8135 /* Verify the session's negotiated channel_attrs values */
79969dd1 8136 status = nfs4_verify_channel_attrs(&args, &res);
fc931582 8137 /* Increment the clientid slot sequence id */
79969dd1
TM		 8138 if (status)
8139 goto out;
8140 nfs4_update_session(session, &res);
fc931582 8141 }
79969dd1 8142out:
fc931582
AA		 8143 return status;
8144}
8145
8146/*
8147 * Issues a CREATE_SESSION operation to the server.
8148 * It is the responsibility of the caller to verify the session is
8149 * expired before calling this routine.
8150 */
848f5bda 8151int nfs4_proc_create_session(struct nfs_client *clp, struct rpc_cred *cred)
fc931582
AA		 8152{
8153 int status;
8154 unsigned *ptr;
fc931582
AA		 8155 struct nfs4_session *session = clp->cl_session;
8156
8157 dprintk("--> %s clp=%p session=%p\n", __func__, clp, session);
8158
848f5bda 8159 status = _nfs4_proc_create_session(clp, cred);
fc931582
AA		 8160 if (status)
8161 goto out;
8162
aacd5537
AA		 8163 /* Init or reset the session slot tables */
8164 status = nfs4_setup_session_slot_tables(session);
8165 dprintk("slot table setup returned %d\n", status);
fc931582
AA		 8166 if (status)
8167 goto out;
8168
8169 ptr = (unsigned *)&session->sess_id.data[0];
8170 dprintk("%s client>seqid %d sessionid %u:%u:%u:%u\n", __func__,
8171 clp->cl_seqid, ptr[0], ptr[1], ptr[2], ptr[3]);
fc931582
AA		 8172out:
8173 dprintk("<-- %s\n", __func__);
8174 return status;
8175}
8176
0f3e66c6
AA		 8177/*
8178 * Issue the over-the-wire RPC DESTROY_SESSION.
8179 * The caller must serialize access to this routine.
8180 */
848f5bda
TM		 8181int nfs4_proc_destroy_session(struct nfs4_session *session,
8182 struct rpc_cred *cred)
0f3e66c6 8183{
848f5bda
TM		 8184 struct rpc_message msg = {
8185 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_SESSION],
8186 .rpc_argp = session,
8187 .rpc_cred = cred,
8188 };
0f3e66c6 8189 int status = 0;
0f3e66c6
AA		 8190
8191 dprintk("--> nfs4_proc_destroy_session\n");
8192
8193 /* session is still being setup */
e11259f9
TM		 8194 if (!test_and_clear_bit(NFS4_SESSION_ESTABLISHED, &session->session_state))
8195 return 0;
0f3e66c6 8196
1bd714f2 8197 status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
c6d01c6f 8198 trace_nfs4_destroy_session(session->clp, status);
0f3e66c6
AA		 8199
8200 if (status)
08106ac7 8201 dprintk("NFS: Got error %d from the server on DESTROY_SESSION. "
0f3e66c6
AA		 8202 "Session has been destroyed regardless...\n", status);
8203
8204 dprintk("<-- nfs4_proc_destroy_session\n");
8205 return status;
8206}
8207
fc01cea9
AA		 8208/*
8209 * Renew the cl_session lease.
8210 */
d5f8d3fe
TM		 8211struct nfs4_sequence_data {
8212 struct nfs_client *clp;
8213 struct nfs4_sequence_args args;
8214 struct nfs4_sequence_res res;
8215};
8216
dc96aef9
AB		 8217static void nfs41_sequence_release(void *data)
8218{
d5f8d3fe
TM		 8219 struct nfs4_sequence_data *calldata = data;
8220 struct nfs_client *clp = calldata->clp;
dc96aef9 8221
212bf41d 8222 if (refcount_read(&clp->cl_count) > 1)
7135840f
AB		 8223 nfs4_schedule_state_renewal(clp);
8224 nfs_put_client(clp);
d5f8d3fe 8225 kfree(calldata);
dc96aef9
AB		 8226}
8227
aa5190d0
TM		 8228static int nfs41_sequence_handle_errors(struct rpc_task *task, struct nfs_client *clp)
8229{
8230 switch(task->tk_status) {
8231 case -NFS4ERR_DELAY:
aa5190d0
TM		 8232 rpc_delay(task, NFS4_POLL_RETRY_MAX);
8233 return -EAGAIN;
8234 default:
0400a6b0 8235 nfs4_schedule_lease_recovery(clp);
aa5190d0
TM		 8236 }
8237 return 0;
8238}
8239
dc96aef9 8240static void nfs41_sequence_call_done(struct rpc_task *task, void *data)
fc01cea9 8241{
d5f8d3fe
TM		 8242 struct nfs4_sequence_data *calldata = data;
8243 struct nfs_client *clp = calldata->clp;
fc01cea9 8244
14516c3a
TM		 8245 if (!nfs41_sequence_done(task, task->tk_msg.rpc_resp))
8246 return;
fc01cea9 8247
c6d01c6f 8248 trace_nfs4_sequence(clp, task->tk_status);
fc01cea9
AA		 8249 if (task->tk_status < 0) {
8250 dprintk("%s ERROR %d\n", __func__, task->tk_status);
212bf41d 8251 if (refcount_read(&clp->cl_count) == 1)
7135840f 8252 goto out;
fc01cea9 8253
aa5190d0
TM		 8254 if (nfs41_sequence_handle_errors(task, clp) == -EAGAIN) {
8255 rpc_restart_call_prepare(task);
fc01cea9
AA		 8256 return;
8257 }
8258 }
fc01cea9 8259 dprintk("%s rpc_cred %p\n", __func__, task->tk_msg.rpc_cred);
7135840f 8260out:
fc01cea9
AA		 8261 dprintk("<-- %s\n", __func__);
8262}
8263
8264static void nfs41_sequence_prepare(struct rpc_task *task, void *data)
8265{
d5f8d3fe
TM		 8266 struct nfs4_sequence_data *calldata = data;
8267 struct nfs_client *clp = calldata->clp;
fc01cea9
AA		 8268 struct nfs4_sequence_args *args;
8269 struct nfs4_sequence_res *res;
8270
fc01cea9
AA		 8271 args = task->tk_msg.rpc_argp;
8272 res = task->tk_msg.rpc_resp;
8273
7981c8a6 8274 nfs4_setup_sequence(clp, args, res, task);
fc01cea9
AA		 8275}
8276
8277static const struct rpc_call_ops nfs41_sequence_ops = {
8278 .rpc_call_done = nfs41_sequence_call_done,
8279 .rpc_call_prepare = nfs41_sequence_prepare,
dc96aef9 8280 .rpc_release = nfs41_sequence_release,
fc01cea9
AA		 8281};
8282
8fe72bac
TM		 8283static struct rpc_task *_nfs41_proc_sequence(struct nfs_client *clp,
8284 struct rpc_cred *cred,
3be0f80b 8285 struct nfs4_slot *slot,
8fe72bac 8286 bool is_privileged)
fc01cea9 8287{
d5f8d3fe 8288 struct nfs4_sequence_data *calldata;
fc01cea9
AA		 8289 struct rpc_message msg = {
8290 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SEQUENCE],
8291 .rpc_cred = cred,
8292 };
71ac6da9
TM		 8293 struct rpc_task_setup task_setup_data = {
8294 .rpc_client = clp->cl_rpcclient,
8295 .rpc_message = &msg,
8fe72bac 8296 .callback_ops = &nfs41_sequence_ops,
bc7a05ca 8297 .flags = RPC_TASK_ASYNC | RPC_TASK_TIMEOUT,
71ac6da9 8298 };
3be0f80b 8299 struct rpc_task *ret;
fc01cea9 8300
3be0f80b 8301 ret = ERR_PTR(-EIO);
212bf41d 8302 if (!refcount_inc_not_zero(&clp->cl_count))
3be0f80b
TM		 8303 goto out_err;
8304
8305 ret = ERR_PTR(-ENOMEM);
dfb4f309 8306 calldata = kzalloc(sizeof(*calldata), GFP_NOFS);
3be0f80b
TM		 8307 if (calldata == NULL)
8308 goto out_put_clp;
a9c92d6b 8309 nfs4_init_sequence(&calldata->args, &calldata->res, 0);
3be0f80b 8310 nfs4_sequence_attach_slot(&calldata->args, &calldata->res, slot);
8fe72bac
TM		 8311 if (is_privileged)
8312 nfs4_set_sequence_privileged(&calldata->args);
d5f8d3fe
TM		 8313 msg.rpc_argp = &calldata->args;
8314 msg.rpc_resp = &calldata->res;
8315 calldata->clp = clp;
71ac6da9 8316 task_setup_data.callback_data = calldata;
fc01cea9 8317
3be0f80b
TM		 8318 ret = rpc_run_task(&task_setup_data);
8319 if (IS_ERR(ret))
8320 goto out_err;
8321 return ret;
8322out_put_clp:
8323 nfs_put_client(clp);
8324out_err:
8325 nfs41_release_slot(slot);
8326 return ret;
71ac6da9
TM		 8327}
8328
2f60ea6b 8329static int nfs41_proc_async_sequence(struct nfs_client *clp, struct rpc_cred *cred, unsigned renew_flags)
71ac6da9
TM		 8330{
8331 struct rpc_task *task;
8332 int ret = 0;
8333
2f60ea6b 8334 if ((renew_flags & NFS4_RENEW_TIMEOUT) == 0)
d1f456b0 8335 return -EAGAIN;
3be0f80b 8336 task = _nfs41_proc_sequence(clp, cred, NULL, false);
71ac6da9
TM		 8337 if (IS_ERR(task))
8338 ret = PTR_ERR(task);
8339 else
bf294b41 8340 rpc_put_task_async(task);
71ac6da9
TM		 8341 dprintk("<-- %s status=%d\n", __func__, ret);
8342 return ret;
8343}
8344
8345static int nfs4_proc_sequence(struct nfs_client *clp, struct rpc_cred *cred)
8346{
8347 struct rpc_task *task;
8348 int ret;
8349
3be0f80b 8350 task = _nfs41_proc_sequence(clp, cred, NULL, true);
71ac6da9
TM		 8351 if (IS_ERR(task)) {
8352 ret = PTR_ERR(task);
8353 goto out;
8354 }
8355 ret = rpc_wait_for_completion_task(task);
be824167 8356 if (!ret)
71ac6da9
TM		 8357 ret = task->tk_status;
8358 rpc_put_task(task);
8359out:
8360 dprintk("<-- %s status=%d\n", __func__, ret);
8361 return ret;
fc01cea9
AA		 8362}
8363
fce5c838
RL		 8364struct nfs4_reclaim_complete_data {
8365 struct nfs_client *clp;
8366 struct nfs41_reclaim_complete_args arg;
8367 struct nfs41_reclaim_complete_res res;
8368};
8369
8370static void nfs4_reclaim_complete_prepare(struct rpc_task *task, void *data)
8371{
8372 struct nfs4_reclaim_complete_data *calldata = data;
8373
7981c8a6 8374 nfs4_setup_sequence(calldata->clp,
d9afbd1b
TM		 8375 &calldata->arg.seq_args,
8376 &calldata->res.seq_res,
8377 task);
fce5c838
RL		 8378}
8379
aa5190d0
TM		 8380static int nfs41_reclaim_complete_handle_errors(struct rpc_task *task, struct nfs_client *clp)
8381{
8382 switch(task->tk_status) {
8383 case 0:
8384 case -NFS4ERR_COMPLETE_ALREADY:
8385 case -NFS4ERR_WRONG_CRED: /* What to do here? */
8386 break;
8387 case -NFS4ERR_DELAY:
aa5190d0 8388 rpc_delay(task, NFS4_POLL_RETRY_MAX);
a8a4ae3a
AA		 8389 /* fall through */
8390 case -NFS4ERR_RETRY_UNCACHED_REP:
aa5190d0 8391 return -EAGAIN;
0048fdd0
TM		 8392 case -NFS4ERR_BADSESSION:
8393 case -NFS4ERR_DEADSESSION:
8394 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
8395 nfs4_schedule_session_recovery(clp->cl_session,
8396 task->tk_status);
8397 break;
aa5190d0 8398 default:
0400a6b0 8399 nfs4_schedule_lease_recovery(clp);
aa5190d0
TM		 8400 }
8401 return 0;
8402}
8403
fce5c838
RL		 8404static void nfs4_reclaim_complete_done(struct rpc_task *task, void *data)
8405{
8406 struct nfs4_reclaim_complete_data *calldata = data;
8407 struct nfs_client *clp = calldata->clp;
8408 struct nfs4_sequence_res *res = &calldata->res.seq_res;
8409
8410 dprintk("--> %s\n", __func__);
14516c3a
TM		 8411 if (!nfs41_sequence_done(task, res))
8412 return;
fce5c838 8413
c6d01c6f 8414 trace_nfs4_reclaim_complete(clp, task->tk_status);
aa5190d0
TM		 8415 if (nfs41_reclaim_complete_handle_errors(task, clp) == -EAGAIN) {
8416 rpc_restart_call_prepare(task);
8417 return;
8418 }
fce5c838
RL		 8419 dprintk("<-- %s\n", __func__);
8420}
8421
8422static void nfs4_free_reclaim_complete_data(void *data)
8423{
8424 struct nfs4_reclaim_complete_data *calldata = data;
8425
8426 kfree(calldata);
8427}
8428
8429static const struct rpc_call_ops nfs4_reclaim_complete_call_ops = {
8430 .rpc_call_prepare = nfs4_reclaim_complete_prepare,
8431 .rpc_call_done = nfs4_reclaim_complete_done,
8432 .rpc_release = nfs4_free_reclaim_complete_data,
8433};
8434
8435/*
8436 * Issue a global reclaim complete.
8437 */
965e9c23
TM		 8438static int nfs41_proc_reclaim_complete(struct nfs_client *clp,
8439 struct rpc_cred *cred)
fce5c838
RL		 8440{
8441 struct nfs4_reclaim_complete_data *calldata;
8442 struct rpc_task *task;
8443 struct rpc_message msg = {
8444 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RECLAIM_COMPLETE],
965e9c23 8445 .rpc_cred = cred,
fce5c838
RL		 8446 };
8447 struct rpc_task_setup task_setup_data = {
8448 .rpc_client = clp->cl_rpcclient,
8449 .rpc_message = &msg,
8450 .callback_ops = &nfs4_reclaim_complete_call_ops,
8451 .flags = RPC_TASK_ASYNC,
8452 };
8453 int status = -ENOMEM;
8454
8455 dprintk("--> %s\n", __func__);
8535b2be 8456 calldata = kzalloc(sizeof(*calldata), GFP_NOFS);
fce5c838
RL		 8457 if (calldata == NULL)
8458 goto out;
8459 calldata->clp = clp;
8460 calldata->arg.one_fs = 0;
fce5c838 8461
a9c92d6b 8462 nfs4_init_sequence(&calldata->arg.seq_args, &calldata->res.seq_res, 0);
8fe72bac 8463 nfs4_set_sequence_privileged(&calldata->arg.seq_args);
fce5c838
RL		 8464 msg.rpc_argp = &calldata->arg;
8465 msg.rpc_resp = &calldata->res;
8466 task_setup_data.callback_data = calldata;
8467 task = rpc_run_task(&task_setup_data);
acf82b85 8468 if (IS_ERR(task)) {
fce5c838 8469 status = PTR_ERR(task);
acf82b85
DC		 8470 goto out;
8471 }
820bf85c 8472 status = rpc_wait_for_completion_task(task);
c34c32ea
AA		 8473 if (status == 0)
8474 status = task->tk_status;
fce5c838
RL		 8475 rpc_put_task(task);
8476out:
8477 dprintk("<-- %s status=%d\n", __func__, status);
8478 return status;
8479}
b1f69b75
AA		 8480
8481static void
8482nfs4_layoutget_prepare(struct rpc_task *task, void *calldata)
8483{
8484 struct nfs4_layoutget *lgp = calldata;
c31663d4 8485 struct nfs_server *server = NFS_SERVER(lgp->args.inode);
b1f69b75
AA		 8486
8487 dprintk("--> %s\n", __func__);
7981c8a6 8488 nfs4_setup_sequence(server->nfs_client, &lgp->args.seq_args,
183d9e7b
JL		 8489 &lgp->res.seq_res, task);
8490 dprintk("<-- %s\n", __func__);
b1f69b75
AA		 8491}
8492
8493static void nfs4_layoutget_done(struct rpc_task *task, void *calldata)
8494{
8495 struct nfs4_layoutget *lgp = calldata;
183d9e7b
JL		 8496
8497 dprintk("--> %s\n", __func__);
2e80dbe7 8498 nfs41_sequence_process(task, &lgp->res.seq_res);
183d9e7b
JL		 8499 dprintk("<-- %s\n", __func__);
8500}
8501
8502static int
8503nfs4_layoutget_handle_exception(struct rpc_task *task,
8504 struct nfs4_layoutget *lgp, struct nfs4_exception *exception)
8505{
ee314c2a
TM		 8506 struct inode *inode = lgp->args.inode;
8507 struct nfs_server *server = NFS_SERVER(inode);
8508 struct pnfs_layout_hdr *lo;
e85d7ee4
TM		 8509 int nfs4err = task->tk_status;
8510 int err, status = 0;
f7db0b28 8511 LIST_HEAD(head);
b1f69b75 8512
ed7e5423 8513 dprintk("--> %s tk_status => %d\n", __func__, -task->tk_status);
b1f69b75 8514
e85d7ee4 8515 switch (nfs4err) {
b1f69b75 8516 case 0:
ee314c2a 8517 goto out;
7c1e6e58
PT		 8518
8519 /*
8520 * NFS4ERR_LAYOUTUNAVAILABLE means we are not supposed to use pnfs
8521 * on the file. set tk_status to -ENODATA to tell upper layer to
8522 * retry go inband.
8523 */
8524 case -NFS4ERR_LAYOUTUNAVAILABLE:
183d9e7b 8525 status = -ENODATA;
7c1e6e58 8526 goto out;
21b874c8
TM		 8527 /*
8528 * NFS4ERR_BADLAYOUT means the MDS cannot return a layout of
8529 * length lgp->args.minlength != 0 (see RFC5661 section 18.43.3).
8530 */
8531 case -NFS4ERR_BADLAYOUT:
183d9e7b
JL		 8532 status = -EOVERFLOW;
8533 goto out;
ed7e5423
BH		 8534 /*
8535 * NFS4ERR_LAYOUTTRYLATER is a conflict with another client
21b874c8
TM		 8536 * (or clients) writing to the same RAID stripe except when
8537 * the minlength argument is 0 (see RFC5661 section 18.43.3).
183d9e7b
JL		 8538 *
8539 * Treat it like we would RECALLCONFLICT -- we retry for a little
8540 * while, and then eventually give up.
ed7e5423 8541 */
b1f69b75 8542 case -NFS4ERR_LAYOUTTRYLATER:
183d9e7b
JL		 8543 if (lgp->args.minlength == 0) {
8544 status = -EOVERFLOW;
8545 goto out;
ed7e5423 8546 }
e85d7ee4
TM		 8547 status = -EBUSY;
8548 break;
183d9e7b 8549 case -NFS4ERR_RECALLCONFLICT:
183d9e7b 8550 status = -ERECALLCONFLICT;
e85d7ee4 8551 break;
26f47443
TM		 8552 case -NFS4ERR_DELEG_REVOKED:
8553 case -NFS4ERR_ADMIN_REVOKED:
ee314c2a
TM		 8554 case -NFS4ERR_EXPIRED:
8555 case -NFS4ERR_BAD_STATEID:
183d9e7b 8556 exception->timeout = 0;
ee314c2a 8557 spin_lock(&inode->i_lock);
f7db0b28
TM		 8558 lo = NFS_I(inode)->layout;
8559 /* If the open stateid was bad, then recover it. */
8560 if (!lo || test_bit(NFS_LAYOUT_INVALID_STID, &lo->plh_flags) ||
e8fa33a6 8561 !nfs4_stateid_match_other(&lgp->args.stateid, &lo->plh_stateid)) {
ee314c2a 8562 spin_unlock(&inode->i_lock);
183d9e7b 8563 exception->state = lgp->args.ctx->state;
26f47443 8564 exception->stateid = &lgp->args.stateid;
2259f960
TM		 8565 break;
8566 }
f7db0b28
TM		 8567
8568 /*
8569 * Mark the bad layout state as invalid, then retry
8570 */
668f455d 8571 pnfs_mark_layout_stateid_invalid(lo, &head);
f7db0b28 8572 spin_unlock(&inode->i_lock);
1f18b82c 8573 nfs_commit_inode(inode, 0);
f7db0b28
TM		 8574 pnfs_free_lseg_list(&head);
8575 status = -EAGAIN;
8576 goto out;
b1f69b75 8577 }
183d9e7b 8578
8ac09251 8579 nfs4_sequence_free_slot(&lgp->res.seq_res);
e85d7ee4
TM		 8580 err = nfs4_handle_exception(server, nfs4err, exception);
8581 if (!status) {
8582 if (exception->retry)
8583 status = -EAGAIN;
8584 else
8585 status = err;
8586 }
ee314c2a 8587out:
b1f69b75 8588 dprintk("<-- %s\n", __func__);
183d9e7b 8589 return status;
b1f69b75
AA		 8590}
8591
8554116e
IK		 8592static size_t max_response_pages(struct nfs_server *server)
8593{
8594 u32 max_resp_sz = server->nfs_client->cl_session->fc_attrs.max_resp_sz;
8595 return nfs_page_array_len(0, max_resp_sz);
8596}
8597
8598static void nfs4_free_pages(struct page **pages, size_t size)
8599{
8600 int i;
8601
8602 if (!pages)
8603 return;
8604
8605 for (i = 0; i < size; i++) {
8606 if (!pages[i])
8607 break;
8608 __free_page(pages[i]);
8609 }
8610 kfree(pages);
8611}
8612
8613static struct page **nfs4_alloc_pages(size_t size, gfp_t gfp_flags)
8614{
8615 struct page **pages;
8616 int i;
8617
8618 pages = kcalloc(size, sizeof(struct page *), gfp_flags);
8619 if (!pages) {
8620 dprintk("%s: can't alloc array of %zu pages\n", __func__, size);
8621 return NULL;
8622 }
8623
8624 for (i = 0; i < size; i++) {
8625 pages[i] = alloc_page(gfp_flags);
8626 if (!pages[i]) {
8627 dprintk("%s: failed to allocate page\n", __func__);
8628 nfs4_free_pages(pages, size);
8629 return NULL;
8630 }
8631 }
8632
8633 return pages;
8634}
8635
b1f69b75
AA		 8636static void nfs4_layoutget_release(void *calldata)
8637{
8638 struct nfs4_layoutget *lgp = calldata;
a47970ff
WAA		 8639 struct inode *inode = lgp->args.inode;
8640 struct nfs_server *server = NFS_SERVER(inode);
8554116e 8641 size_t max_pages = max_response_pages(server);
b1f69b75
AA		 8642
8643 dprintk("--> %s\n", __func__);
bd171930 8644 nfs4_sequence_free_slot(&lgp->res.seq_res);
8554116e 8645 nfs4_free_pages(lgp->args.layout.pages, max_pages);
a47970ff 8646 pnfs_put_layout_hdr(NFS_I(inode)->layout);
b1f69b75
AA		 8647 put_nfs_open_context(lgp->args.ctx);
8648 kfree(calldata);
8649 dprintk("<-- %s\n", __func__);
8650}
8651
8652static const struct rpc_call_ops nfs4_layoutget_call_ops = {
8653 .rpc_call_prepare = nfs4_layoutget_prepare,
8654 .rpc_call_done = nfs4_layoutget_done,
8655 .rpc_release = nfs4_layoutget_release,
8656};
8657
a0b0a6e3 8658struct pnfs_layout_segment *
183d9e7b 8659nfs4_proc_layoutget(struct nfs4_layoutget *lgp, long *timeout, gfp_t gfp_flags)
b1f69b75 8660{
a47970ff
WAA		 8661 struct inode *inode = lgp->args.inode;
8662 struct nfs_server *server = NFS_SERVER(inode);
8554116e 8663 size_t max_pages = max_response_pages(server);
b1f69b75
AA		 8664 struct rpc_task *task;
8665 struct rpc_message msg = {
8666 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTGET],
8667 .rpc_argp = &lgp->args,
8668 .rpc_resp = &lgp->res,
6ab59344 8669 .rpc_cred = lgp->cred,
b1f69b75
AA		 8670 };
8671 struct rpc_task_setup task_setup_data = {
8672 .rpc_client = server->client,
8673 .rpc_message = &msg,
8674 .callback_ops = &nfs4_layoutget_call_ops,
8675 .callback_data = lgp,
8676 .flags = RPC_TASK_ASYNC,
8677 };
a0b0a6e3 8678 struct pnfs_layout_segment *lseg = NULL;
bc23676c
TM		 8679 struct nfs4_exception exception = {
8680 .inode = inode,
8681 .timeout = *timeout,
8682 };
b1f69b75
AA		 8683 int status = 0;
8684
8685 dprintk("--> %s\n", __func__);
8686
4bd5a980
PT		 8687 /* nfs4_layoutget_release calls pnfs_put_layout_hdr */
8688 pnfs_get_layout_hdr(NFS_I(inode)->layout);
8689
8554116e
IK		 8690 lgp->args.layout.pages = nfs4_alloc_pages(max_pages, gfp_flags);
8691 if (!lgp->args.layout.pages) {
8692 nfs4_layoutget_release(lgp);
a0b0a6e3 8693 return ERR_PTR(-ENOMEM);
8554116e
IK		 8694 }
8695 lgp->args.layout.pglen = max_pages * PAGE_SIZE;
8696
35124a09 8697 lgp->res.layoutp = &lgp->args.layout;
b1f69b75 8698 lgp->res.seq_res.sr_slot = NULL;
a9c92d6b 8699 nfs4_init_sequence(&lgp->args.seq_args, &lgp->res.seq_res, 0);
a47970ff 8700
b1f69b75
AA		 8701 task = rpc_run_task(&task_setup_data);
8702 if (IS_ERR(task))
a0b0a6e3 8703 return ERR_CAST(task);
820bf85c 8704 status = rpc_wait_for_completion_task(task);
183d9e7b
JL		 8705 if (status == 0) {
8706 status = nfs4_layoutget_handle_exception(task, lgp, &exception);
8707 *timeout = exception.timeout;
8708 }
8709
1037e6ea
TM		 8710 trace_nfs4_layoutget(lgp->args.ctx,
8711 &lgp->args.range,
8712 &lgp->res.range,
48c9579a 8713 &lgp->res.stateid,
1037e6ea 8714 status);
183d9e7b 8715
085b7a45
WAA		 8716 /* if layoutp->len is 0, nfs4_layoutget_prepare called rpc_exit */
8717 if (status == 0 && lgp->res.layoutp->len)
a0b0a6e3 8718 lseg = pnfs_layout_process(lgp);
b1f69b75
AA		 8719 rpc_put_task(task);
8720 dprintk("<-- %s status=%d\n", __func__, status);
a0b0a6e3
TM		 8721 if (status)
8722 return ERR_PTR(status);
8723 return lseg;
b1f69b75
AA		 8724}
8725
cbe82603
BH		 8726static void
8727nfs4_layoutreturn_prepare(struct rpc_task *task, void *calldata)
8728{
8729 struct nfs4_layoutreturn *lrp = calldata;
8730
8731 dprintk("--> %s\n", __func__);
7981c8a6 8732 nfs4_setup_sequence(lrp->clp,
d9afbd1b
TM		 8733 &lrp->args.seq_args,
8734 &lrp->res.seq_res,
8735 task);
cbe82603
BH		 8736}
8737
8738static void nfs4_layoutreturn_done(struct rpc_task *task, void *calldata)
8739{
8740 struct nfs4_layoutreturn *lrp = calldata;
8741 struct nfs_server *server;
8742
8743 dprintk("--> %s\n", __func__);
8744
2e80dbe7 8745 if (!nfs41_sequence_process(task, &lrp->res.seq_res))
cbe82603
BH		 8746 return;
8747
8748 server = NFS_SERVER(lrp->args.inode);
f22e5edd 8749 switch (task->tk_status) {
ff90514e
TM		 8750 case -NFS4ERR_OLD_STATEID:
8751 if (nfs4_refresh_layout_stateid(&lrp->args.stateid,
8752 lrp->args.inode))
8753 goto out_restart;
8754 /* Fallthrough */
f22e5edd
TM		 8755 default:
8756 task->tk_status = 0;
ff90514e 8757 /* Fallthrough */
f22e5edd
TM		 8758 case 0:
8759 break;
8760 case -NFS4ERR_DELAY:
8478eaa1 8761 if (nfs4_async_handle_error(task, server, NULL, NULL) != -EAGAIN)
f22e5edd 8762 break;
ff90514e 8763 goto out_restart;
cbe82603 8764 }
cbe82603 8765 dprintk("<-- %s\n", __func__);
ff90514e
TM		 8766 return;
8767out_restart:
8768 task->tk_status = 0;
8769 nfs4_sequence_free_slot(&lrp->res.seq_res);
8770 rpc_restart_call_prepare(task);
cbe82603
BH		 8771}
8772
8773static void nfs4_layoutreturn_release(void *calldata)
8774{
8775 struct nfs4_layoutreturn *lrp = calldata;
849b286f 8776 struct pnfs_layout_hdr *lo = lrp->args.layout;
cbe82603
BH		 8777
8778 dprintk("--> %s\n", __func__);
2a974425 8779 pnfs_layoutreturn_free_lsegs(lo, &lrp->args.stateid, &lrp->args.range,
68f74479 8780 lrp->res.lrs_present ? &lrp->res.stateid : NULL);
2e80dbe7 8781 nfs4_sequence_free_slot(&lrp->res.seq_res);
4d796d75
TM		 8782 if (lrp->ld_private.ops && lrp->ld_private.ops->free)
8783 lrp->ld_private.ops->free(&lrp->ld_private);
2f065ddb
TM		 8784 pnfs_put_layout_hdr(lrp->args.layout);
8785 nfs_iput_and_deactive(lrp->inode);
cbe82603
BH		 8786 kfree(calldata);
8787 dprintk("<-- %s\n", __func__);
8788}
8789
8790static const struct rpc_call_ops nfs4_layoutreturn_call_ops = {
8791 .rpc_call_prepare = nfs4_layoutreturn_prepare,
8792 .rpc_call_done = nfs4_layoutreturn_done,
8793 .rpc_release = nfs4_layoutreturn_release,
8794};
8795
6c16605d 8796int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp, bool sync)
cbe82603
BH		 8797{
8798 struct rpc_task *task;
8799 struct rpc_message msg = {
8800 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTRETURN],
8801 .rpc_argp = &lrp->args,
8802 .rpc_resp = &lrp->res,
9556000d 8803 .rpc_cred = lrp->cred,
cbe82603
BH		 8804 };
8805 struct rpc_task_setup task_setup_data = {
1771c577 8806 .rpc_client = NFS_SERVER(lrp->args.inode)->client,
cbe82603
BH		 8807 .rpc_message = &msg,
8808 .callback_ops = &nfs4_layoutreturn_call_ops,
8809 .callback_data = lrp,
8810 };
6c16605d 8811 int status = 0;
cbe82603 8812
99ade3c7
AE		 8813 nfs4_state_protect(NFS_SERVER(lrp->args.inode)->nfs_client,
8814 NFS_SP4_MACH_CRED_PNFS_CLEANUP,
8815 &task_setup_data.rpc_client, &msg);
8816
cbe82603 8817 dprintk("--> %s\n", __func__);
5a0ec8ac
TM		 8818 if (!sync) {
8819 lrp->inode = nfs_igrab_and_active(lrp->args.inode);
8820 if (!lrp->inode) {
8821 nfs4_layoutreturn_release(lrp);
8822 return -EAGAIN;
8823 }
8824 task_setup_data.flags |= RPC_TASK_ASYNC;
8825 }
a9c92d6b 8826 nfs4_init_sequence(&lrp->args.seq_args, &lrp->res.seq_res, 1);
cbe82603
BH		 8827 task = rpc_run_task(&task_setup_data);
8828 if (IS_ERR(task))
8829 return PTR_ERR(task);
5a0ec8ac
TM		 8830 if (sync)
8831 status = task->tk_status;
48c9579a 8832 trace_nfs4_layoutreturn(lrp->args.inode, &lrp->args.stateid, status);
cbe82603
BH		 8833 dprintk("<-- %s status=%d\n", __func__, status);
8834 rpc_put_task(task);
8835 return status;
8836}
8837
b1f69b75 8838static int
cd5875fe
TM		 8839_nfs4_proc_getdeviceinfo(struct nfs_server *server,
8840 struct pnfs_device *pdev,
8841 struct rpc_cred *cred)
b1f69b75
AA		 8842{
8843 struct nfs4_getdeviceinfo_args args = {
8844 .pdev = pdev,
4e590803
TM		 8845 .notify_types = NOTIFY_DEVICEID4_CHANGE |
8846 NOTIFY_DEVICEID4_DELETE,
b1f69b75
AA		 8847 };
8848 struct nfs4_getdeviceinfo_res res = {
8849 .pdev = pdev,
8850 };
8851 struct rpc_message msg = {
8852 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETDEVICEINFO],
8853 .rpc_argp = &args,
8854 .rpc_resp = &res,
cd5875fe 8855 .rpc_cred = cred,
b1f69b75
AA		 8856 };
8857 int status;
8858
8859 dprintk("--> %s\n", __func__);
7c513058 8860 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
4e590803
TM		 8861 if (res.notification & ~args.notify_types)
8862 dprintk("%s: unsupported notification\n", __func__);
df52699e
TM		 8863 if (res.notification != args.notify_types)
8864 pdev->nocache = 1;
4e590803 8865
b1f69b75
AA		 8866 dprintk("<-- %s status=%d\n", __func__, status);
8867
8868 return status;
8869}
8870
cd5875fe
TM		 8871int nfs4_proc_getdeviceinfo(struct nfs_server *server,
8872 struct pnfs_device *pdev,
8873 struct rpc_cred *cred)
b1f69b75
AA		 8874{
8875 struct nfs4_exception exception = { };
8876 int err;
8877
8878 do {
8879 err = nfs4_handle_exception(server,
cd5875fe 8880 _nfs4_proc_getdeviceinfo(server, pdev, cred),
b1f69b75
AA		 8881 &exception);
8882 } while (exception.retry);
8883 return err;
8884}
8885EXPORT_SYMBOL_GPL(nfs4_proc_getdeviceinfo);
8886
863a3c6c
AA		 8887static void nfs4_layoutcommit_prepare(struct rpc_task *task, void *calldata)
8888{
8889 struct nfs4_layoutcommit_data *data = calldata;
8890 struct nfs_server *server = NFS_SERVER(data->args.inode);
8891
7981c8a6 8892 nfs4_setup_sequence(server->nfs_client,
d9afbd1b
TM		 8893 &data->args.seq_args,
8894 &data->res.seq_res,
8895 task);
863a3c6c
AA		 8896}
8897
8898static void
8899nfs4_layoutcommit_done(struct rpc_task *task, void *calldata)
8900{
8901 struct nfs4_layoutcommit_data *data = calldata;
8902 struct nfs_server *server = NFS_SERVER(data->args.inode);
8903
6ba7db34 8904 if (!nfs41_sequence_done(task, &data->res.seq_res))
863a3c6c
AA		 8905 return;
8906
8907 switch (task->tk_status) { /* Just ignore these failures */
e59d27e0
TM		 8908 case -NFS4ERR_DELEG_REVOKED: /* layout was recalled */
8909 case -NFS4ERR_BADIOMODE: /* no IOMODE_RW layout for range */
8910 case -NFS4ERR_BADLAYOUT: /* no layout */
8911 case -NFS4ERR_GRACE: /* loca_recalim always false */
863a3c6c 8912 task->tk_status = 0;
e59d27e0 8913 case 0:
e59d27e0
TM		 8914 break;
8915 default:
8478eaa1 8916 if (nfs4_async_handle_error(task, server, NULL, NULL) == -EAGAIN) {
e59d27e0
TM		 8917 rpc_restart_call_prepare(task);
8918 return;
8919 }
8920 }
863a3c6c
AA		 8921}
8922
8923static void nfs4_layoutcommit_release(void *calldata)
8924{
8925 struct nfs4_layoutcommit_data *data = calldata;
8926
db29c089 8927 pnfs_cleanup_layoutcommit(data);
d8c951c3
TM		 8928 nfs_post_op_update_inode_force_wcc(data->args.inode,
8929 data->res.fattr);
863a3c6c 8930 put_rpccred(data->cred);
472e2594 8931 nfs_iput_and_deactive(data->inode);
863a3c6c
AA		 8932 kfree(data);
8933}
8934
8935static const struct rpc_call_ops nfs4_layoutcommit_ops = {
8936 .rpc_call_prepare = nfs4_layoutcommit_prepare,
8937 .rpc_call_done = nfs4_layoutcommit_done,
8938 .rpc_release = nfs4_layoutcommit_release,
8939};
8940
8941int
ef311537 8942nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data *data, bool sync)
863a3c6c
AA		 8943{
8944 struct rpc_message msg = {
8945 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTCOMMIT],
8946 .rpc_argp = &data->args,
8947 .rpc_resp = &data->res,
8948 .rpc_cred = data->cred,
8949 };
8950 struct rpc_task_setup task_setup_data = {
8951 .task = &data->task,
8952 .rpc_client = NFS_CLIENT(data->args.inode),
8953 .rpc_message = &msg,
8954 .callback_ops = &nfs4_layoutcommit_ops,
8955 .callback_data = data,
863a3c6c
AA		 8956 };
8957 struct rpc_task *task;
8958 int status = 0;
8959
b4839ebe
KM		 8960 dprintk("NFS: initiating layoutcommit call. sync %d "
8961 "lbw: %llu inode %lu\n", sync,
863a3c6c
AA		 8962 data->args.lastbytewritten,
8963 data->args.inode->i_ino);
8964
472e2594
TM		 8965 if (!sync) {
8966 data->inode = nfs_igrab_and_active(data->args.inode);
8967 if (data->inode == NULL) {
8968 nfs4_layoutcommit_release(data);
8969 return -EAGAIN;
8970 }
8971 task_setup_data.flags = RPC_TASK_ASYNC;
8972 }
a9c92d6b 8973 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
863a3c6c
AA		 8974 task = rpc_run_task(&task_setup_data);
8975 if (IS_ERR(task))
8976 return PTR_ERR(task);
472e2594
TM		 8977 if (sync)
8978 status = task->tk_status;
48c9579a 8979 trace_nfs4_layoutcommit(data->args.inode, &data->args.stateid, status);
863a3c6c
AA		 8980 dprintk("%s: status %d\n", __func__, status);
8981 rpc_put_task(task);
8982 return status;
8983}
fca78d6d 8984
97431204
AA		 8985/**
8986 * Use the state managment nfs_client cl_rpcclient, which uses krb5i (if
8987 * possible) as per RFC3530bis and RFC5661 Security Considerations sections
8988 */
fca78d6d
BS		 8989static int
8990_nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle,
b1b3e136
WAA		 8991 struct nfs_fsinfo *info,
8992 struct nfs4_secinfo_flavors *flavors, bool use_integrity)
fca78d6d
BS		 8993{
8994 struct nfs41_secinfo_no_name_args args = {
8995 .style = SECINFO_STYLE_CURRENT_FH,
8996 };
8997 struct nfs4_secinfo_res res = {
8998 .flavors = flavors,
8999 };
9000 struct rpc_message msg = {
9001 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SECINFO_NO_NAME],
9002 .rpc_argp = &args,
9003 .rpc_resp = &res,
9004 };
b1b3e136 9005 struct rpc_clnt *clnt = server->client;
7cb852df 9006 struct rpc_cred *cred = NULL;
b1b3e136
WAA		 9007 int status;
9008
9009 if (use_integrity) {
9010 clnt = server->nfs_client->cl_rpcclient;
7cb852df
WAA		 9011 cred = nfs4_get_clid_cred(server->nfs_client);
9012 msg.rpc_cred = cred;
b1b3e136
WAA		 9013 }
9014
9015 dprintk("--> %s\n", __func__);
9016 status = nfs4_call_sync(clnt, server, &msg, &args.seq_args,
9017 &res.seq_res, 0);
9018 dprintk("<-- %s status=%d\n", __func__, status);
9019
7cb852df
WAA		 9020 if (cred)
9021 put_rpccred(cred);
b1b3e136
WAA		 9022
9023 return status;
fca78d6d
BS		 9024}
9025
9026static int
9027nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle,
9028 struct nfs_fsinfo *info, struct nfs4_secinfo_flavors *flavors)
9029{
9030 struct nfs4_exception exception = { };
9031 int err;
9032 do {
b1b3e136
WAA		 9033 /* first try using integrity protection */
9034 err = -NFS4ERR_WRONGSEC;
9035
9036 /* try to use integrity protection with machine cred */
9037 if (_nfs4_is_integrity_protected(server->nfs_client))
9038 err = _nfs41_proc_secinfo_no_name(server, fhandle, info,
9039 flavors, true);
9040
9041 /*
9042 * if unable to use integrity protection, or SECINFO with
9043 * integrity protection returns NFS4ERR_WRONGSEC (which is
9044 * disallowed by spec, but exists in deployed servers) use
9045 * the current filesystem's rpc_client and the user cred.
9046 */
9047 if (err == -NFS4ERR_WRONGSEC)
9048 err = _nfs41_proc_secinfo_no_name(server, fhandle, info,
9049 flavors, false);
9050
fca78d6d
BS		 9051 switch (err) {
9052 case 0:
9053 case -NFS4ERR_WRONGSEC:
78b19bae 9054 case -ENOTSUPP:
05e9cfb4 9055 goto out;
fca78d6d
BS		 9056 default:
9057 err = nfs4_handle_exception(server, err, &exception);
9058 }
9059 } while (exception.retry);
05e9cfb4 9060out:
fca78d6d
BS		 9061 return err;
9062}
9063
9064static int
9065nfs41_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
9066 struct nfs_fsinfo *info)
9067{
9068 int err;
9069 struct page *page;
367156d9 9070 rpc_authflavor_t flavor = RPC_AUTH_MAXFLAVOR;
fca78d6d 9071 struct nfs4_secinfo_flavors *flavors;
58a8cf12
WAA		 9072 struct nfs4_secinfo4 *secinfo;
9073 int i;
fca78d6d
BS		 9074
9075 page = alloc_page(GFP_KERNEL);
9076 if (!page) {
9077 err = -ENOMEM;
9078 goto out;
9079 }
9080
9081 flavors = page_address(page);
9082 err = nfs41_proc_secinfo_no_name(server, fhandle, info, flavors);
9083
9084 /*
9085 * Fall back on "guess and check" method if
9086 * the server doesn't support SECINFO_NO_NAME
9087 */
78b19bae 9088 if (err == -NFS4ERR_WRONGSEC || err == -ENOTSUPP) {
fca78d6d
BS		 9089 err = nfs4_find_root_sec(server, fhandle, info);
9090 goto out_freepage;
9091 }
9092 if (err)
9093 goto out_freepage;
9094
58a8cf12
WAA		 9095 for (i = 0; i < flavors->num_flavors; i++) {
9096 secinfo = &flavors->flavors[i];
9097
9098 switch (secinfo->flavor) {
9099 case RPC_AUTH_NULL:
9100 case RPC_AUTH_UNIX:
9101 case RPC_AUTH_GSS:
9102 flavor = rpcauth_get_pseudoflavor(secinfo->flavor,
9103 &secinfo->flavor_info);
9104 break;
9105 default:
9106 flavor = RPC_AUTH_MAXFLAVOR;
9107 break;
9108 }
9109
4d4b69dd
WAA		 9110 if (!nfs_auth_info_match(&server->auth_info, flavor))
9111 flavor = RPC_AUTH_MAXFLAVOR;
9112
58a8cf12
WAA		 9113 if (flavor != RPC_AUTH_MAXFLAVOR) {
9114 err = nfs4_lookup_root_sec(server, fhandle,
9115 info, flavor);
9116 if (!err)
9117 break;
9118 }
9119 }
9120
9121 if (flavor == RPC_AUTH_MAXFLAVOR)
9122 err = -EPERM;
fca78d6d
BS		 9123
9124out_freepage:
9125 put_page(page);
9126 if (err == -EACCES)
9127 return -EPERM;
9128out:
9129 return err;
9130}
1cab0652 9131
ab7cb0df
TM		 9132static int _nfs41_test_stateid(struct nfs_server *server,
9133 nfs4_stateid *stateid,
9134 struct rpc_cred *cred)
7d974794
BS		 9135{
9136 int status;
9137 struct nfs41_test_stateid_args args = {
1cab0652 9138 .stateid = stateid,
7d974794
BS		 9139 };
9140 struct nfs41_test_stateid_res res;
9141 struct rpc_message msg = {
9142 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_TEST_STATEID],
9143 .rpc_argp = &args,
9144 .rpc_resp = &res,
ab7cb0df 9145 .rpc_cred = cred,
7d974794 9146 };
3787d506
WAA		 9147 struct rpc_clnt *rpc_client = server->client;
9148
9149 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_STATEID,
9150 &rpc_client, &msg);
1cab0652 9151
38527b15 9152 dprintk("NFS call test_stateid %p\n", stateid);
a9c92d6b 9153 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
8fe72bac 9154 nfs4_set_sequence_privileged(&args.seq_args);
3787d506 9155 status = nfs4_call_sync_sequence(rpc_client, server, &msg,
8fe72bac 9156 &args.seq_args, &res.seq_res);
38527b15
CL		 9157 if (status != NFS_OK) {
9158 dprintk("NFS reply test_stateid: failed, %d\n", status);
377e507d 9159 return status;
38527b15
CL		 9160 }
9161 dprintk("NFS reply test_stateid: succeeded, %d\n", -res.status);
377e507d 9162 return -res.status;
7d974794
BS		 9163}
9164
43912bbb
TM		 9165static void nfs4_handle_delay_or_session_error(struct nfs_server *server,
9166 int err, struct nfs4_exception *exception)
9167{
9168 exception->retry = 0;
9169 switch(err) {
9170 case -NFS4ERR_DELAY:
76e8a1bd 9171 case -NFS4ERR_RETRY_UNCACHED_REP:
43912bbb
TM		 9172 nfs4_handle_exception(server, err, exception);
9173 break;
9174 case -NFS4ERR_BADSESSION:
9175 case -NFS4ERR_BADSLOT:
9176 case -NFS4ERR_BAD_HIGH_SLOT:
9177 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
9178 case -NFS4ERR_DEADSESSION:
9179 nfs4_do_handle_exception(server, err, exception);
9180 }
9181}
9182
38527b15
CL		 9183/**
9184 * nfs41_test_stateid - perform a TEST_STATEID operation
9185 *
9186 * @server: server / transport on which to perform the operation
9187 * @stateid: state ID to test
ab7cb0df 9188 * @cred: credential
38527b15
CL		 9189 *
9190 * Returns NFS_OK if the server recognizes that "stateid" is valid.
9191 * Otherwise a negative NFS4ERR value is returned if the operation
9192 * failed or the state ID is not currently valid.
9193 */
ab7cb0df
TM		 9194static int nfs41_test_stateid(struct nfs_server *server,
9195 nfs4_stateid *stateid,
9196 struct rpc_cred *cred)
7d974794
BS		 9197{
9198 struct nfs4_exception exception = { };
9199 int err;
9200 do {
ab7cb0df 9201 err = _nfs41_test_stateid(server, stateid, cred);
43912bbb 9202 nfs4_handle_delay_or_session_error(server, err, &exception);
7d974794
BS		 9203 } while (exception.retry);
9204 return err;
9205}
9aeda35f 9206
7c1d5fae
TM		 9207struct nfs_free_stateid_data {
9208 struct nfs_server *server;
9209 struct nfs41_free_stateid_args args;
9aeda35f 9210 struct nfs41_free_stateid_res res;
7c1d5fae
TM		 9211};
9212
9213static void nfs41_free_stateid_prepare(struct rpc_task *task, void *calldata)
9214{
9215 struct nfs_free_stateid_data *data = calldata;
7981c8a6 9216 nfs4_setup_sequence(data->server->nfs_client,
7c1d5fae
TM		 9217 &data->args.seq_args,
9218 &data->res.seq_res,
9219 task);
9220}
9221
9222static void nfs41_free_stateid_done(struct rpc_task *task, void *calldata)
9223{
9224 struct nfs_free_stateid_data *data = calldata;
9225
9226 nfs41_sequence_done(task, &data->res.seq_res);
9227
9228 switch (task->tk_status) {
9229 case -NFS4ERR_DELAY:
8478eaa1 9230 if (nfs4_async_handle_error(task, data->server, NULL, NULL) == -EAGAIN)
7c1d5fae
TM		 9231 rpc_restart_call_prepare(task);
9232 }
9233}
9234
9235static void nfs41_free_stateid_release(void *calldata)
9236{
9237 kfree(calldata);
9238}
9239
17f26b12 9240static const struct rpc_call_ops nfs41_free_stateid_ops = {
7c1d5fae
TM		 9241 .rpc_call_prepare = nfs41_free_stateid_prepare,
9242 .rpc_call_done = nfs41_free_stateid_done,
9243 .rpc_release = nfs41_free_stateid_release,
9244};
9245
9246static struct rpc_task *_nfs41_free_stateid(struct nfs_server *server,
f0b0bf88 9247 const nfs4_stateid *stateid,
ab7cb0df 9248 struct rpc_cred *cred,
7c1d5fae
TM		 9249 bool privileged)
9250{
9aeda35f
BS		 9251 struct rpc_message msg = {
9252 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FREE_STATEID],
ab7cb0df 9253 .rpc_cred = cred,
9aeda35f 9254 };
7c1d5fae
TM		 9255 struct rpc_task_setup task_setup = {
9256 .rpc_client = server->client,
9257 .rpc_message = &msg,
9258 .callback_ops = &nfs41_free_stateid_ops,
9259 .flags = RPC_TASK_ASYNC,
9260 };
9261 struct nfs_free_stateid_data *data;
9aeda35f 9262
3787d506
WAA		 9263 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_STATEID,
9264 &task_setup.rpc_client, &msg);
9265
38527b15 9266 dprintk("NFS call free_stateid %p\n", stateid);
7c1d5fae
TM		 9267 data = kmalloc(sizeof(*data), GFP_NOFS);
9268 if (!data)
9269 return ERR_PTR(-ENOMEM);
9270 data->server = server;
9271 nfs4_stateid_copy(&data->args.stateid, stateid);
9272
9273 task_setup.callback_data = data;
9274
9275 msg.rpc_argp = &data->args;
9276 msg.rpc_resp = &data->res;
76e8a1bd 9277 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
7c1d5fae
TM		 9278 if (privileged)
9279 nfs4_set_sequence_privileged(&data->args.seq_args);
9280
9281 return rpc_run_task(&task_setup);
9aeda35f
BS		 9282}
9283
38527b15
CL		 9284/**
9285 * nfs41_free_stateid - perform a FREE_STATEID operation
9286 *
9287 * @server: server / transport on which to perform the operation
9288 * @stateid: state ID to release
ab7cb0df 9289 * @cred: credential
f0b0bf88 9290 * @is_recovery: set to true if this call needs to be privileged
38527b15 9291 *
f0b0bf88 9292 * Note: this function is always asynchronous.
38527b15 9293 */
ab7cb0df 9294static int nfs41_free_stateid(struct nfs_server *server,
f0b0bf88
TM		 9295 const nfs4_stateid *stateid,
9296 struct rpc_cred *cred,
9297 bool is_recovery)
9aeda35f 9298{
7c1d5fae 9299 struct rpc_task *task;
7c1d5fae 9300
f0b0bf88 9301 task = _nfs41_free_stateid(server, stateid, cred, is_recovery);
7c1d5fae
TM		 9302 if (IS_ERR(task))
9303 return PTR_ERR(task);
7c1d5fae 9304 rpc_put_task(task);
f0b0bf88 9305 return 0;
9aeda35f 9306}
36281caa 9307
f1cdae87
JL		 9308static void
9309nfs41_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp)
c8b2d0bf 9310{
ab7cb0df 9311 struct rpc_cred *cred = lsp->ls_state->owner->so_cred;
c8b2d0bf 9312
f0b0bf88 9313 nfs41_free_stateid(server, &lsp->ls_stateid, cred, false);
c8b2d0bf 9314 nfs4_free_lock_state(server, lsp);
c8b2d0bf
TM		 9315}
9316
36281caa
TM		 9317static bool nfs41_match_stateid(const nfs4_stateid *s1,
9318 const nfs4_stateid *s2)
9319{
93b717fd
TM		 9320 if (s1->type != s2->type)
9321 return false;
9322
2d2f24ad 9323 if (memcmp(s1->other, s2->other, sizeof(s1->other)) != 0)
36281caa
TM		 9324 return false;
9325
2d2f24ad 9326 if (s1->seqid == s2->seqid)
36281caa 9327 return true;
36281caa 9328
045c5519 9329 return s1->seqid == 0 || s2->seqid == 0;
36281caa
TM		 9330}
9331
557134a3
AA		 9332#endif /* CONFIG_NFS_V4_1 */
9333
36281caa
TM		 9334static bool nfs4_match_stateid(const nfs4_stateid *s1,
9335 const nfs4_stateid *s2)
9336{
f597c537 9337 return nfs4_stateid_match(s1, s2);
36281caa
TM		 9338}
9339
9340
17280175 9341static const struct nfs4_state_recovery_ops nfs40_reboot_recovery_ops = {
7eff03ae 9342 .owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT,
b79a4a1b 9343 .state_flag_bit = NFS_STATE_RECLAIM_REBOOT,
1da177e4
LT		 9344 .recover_open = nfs4_open_reclaim,
9345 .recover_lock = nfs4_lock_reclaim,
591d71cb 9346 .establish_clid = nfs4_init_clientid,
05f4c350 9347 .detect_trunking = nfs40_discover_server_trunking,
1da177e4
LT		 9348};
9349
591d71cb 9350#if defined(CONFIG_NFS_V4_1)
17280175 9351static const struct nfs4_state_recovery_ops nfs41_reboot_recovery_ops = {
591d71cb
AA		 9352 .owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT,
9353 .state_flag_bit = NFS_STATE_RECLAIM_REBOOT,
9354 .recover_open = nfs4_open_reclaim,
9355 .recover_lock = nfs4_lock_reclaim,
4d643d1d 9356 .establish_clid = nfs41_init_clientid,
fce5c838 9357 .reclaim_complete = nfs41_proc_reclaim_complete,
05f4c350 9358 .detect_trunking = nfs41_discover_server_trunking,
591d71cb
AA		 9359};
9360#endif /* CONFIG_NFS_V4_1 */
9361
17280175 9362static const struct nfs4_state_recovery_ops nfs40_nograce_recovery_ops = {
591d71cb
AA		 9363 .owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE,
9364 .state_flag_bit = NFS_STATE_RECLAIM_NOGRACE,
4dfd4f7a 9365 .recover_open = nfs40_open_expired,
591d71cb
AA		 9366 .recover_lock = nfs4_lock_expired,
9367 .establish_clid = nfs4_init_clientid,
9368};
9369
9370#if defined(CONFIG_NFS_V4_1)
17280175 9371static const struct nfs4_state_recovery_ops nfs41_nograce_recovery_ops = {
7eff03ae 9372 .owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE,
b79a4a1b 9373 .state_flag_bit = NFS_STATE_RECLAIM_NOGRACE,
f062eb6c
BS		 9374 .recover_open = nfs41_open_expired,
9375 .recover_lock = nfs41_lock_expired,
4d643d1d 9376 .establish_clid = nfs41_init_clientid,
1da177e4 9377};
591d71cb 9378#endif /* CONFIG_NFS_V4_1 */
1da177e4 9379
17280175 9380static const struct nfs4_state_maintenance_ops nfs40_state_renewal_ops = {
29fba38b 9381 .sched_state_renewal = nfs4_proc_async_renew,
a7b72103 9382 .get_state_renewal_cred_locked = nfs4_get_renew_cred_locked,
8e69514f 9383 .renew_lease = nfs4_proc_renew,
29fba38b
BH		 9384};
9385
9386#if defined(CONFIG_NFS_V4_1)
17280175 9387static const struct nfs4_state_maintenance_ops nfs41_state_renewal_ops = {
29fba38b 9388 .sched_state_renewal = nfs41_proc_async_sequence,
a7b72103 9389 .get_state_renewal_cred_locked = nfs4_get_machine_cred_locked,
8e69514f 9390 .renew_lease = nfs4_proc_sequence,
29fba38b
BH		 9391};
9392#endif
9393
ec011fe8 9394static const struct nfs4_mig_recovery_ops nfs40_mig_recovery_ops = {
b03d735b 9395 .get_locations = _nfs40_proc_get_locations,
44c99933 9396 .fsid_present = _nfs40_proc_fsid_present,
ec011fe8
CL		 9397};
9398
9399#if defined(CONFIG_NFS_V4_1)
9400static const struct nfs4_mig_recovery_ops nfs41_mig_recovery_ops = {
b03d735b 9401 .get_locations = _nfs41_proc_get_locations,
44c99933 9402 .fsid_present = _nfs41_proc_fsid_present,
ec011fe8
CL		 9403};
9404#endif /* CONFIG_NFS_V4_1 */
9405
97dc1359
TM		 9406static const struct nfs4_minor_version_ops nfs_v4_0_minor_ops = {
9407 .minor_version = 0,
39c6daae
TM		 9408 .init_caps = NFS_CAP_READDIRPLUS
9409 | NFS_CAP_ATOMIC_OPEN
39c6daae 9410 | NFS_CAP_POSIX_LOCK,
abf79bb3
CL		 9411 .init_client = nfs40_init_client,
9412 .shutdown_client = nfs40_shutdown_client,
36281caa 9413 .match_stateid = nfs4_match_stateid,
fca78d6d 9414 .find_root_sec = nfs4_find_root_sec,
c8b2d0bf 9415 .free_lock_state = nfs4_release_lockowner,
45870d69 9416 .test_and_free_expired = nfs40_test_and_free_expired_stateid,
63f5f796 9417 .alloc_seqid = nfs_alloc_seqid,
9915ea7e 9418 .call_sync_ops = &nfs40_call_sync_ops,
c48f4f35
TM		 9419 .reboot_recovery_ops = &nfs40_reboot_recovery_ops,
9420 .nograce_recovery_ops = &nfs40_nograce_recovery_ops,
9421 .state_renewal_ops = &nfs40_state_renewal_ops,
ec011fe8 9422 .mig_recovery_ops = &nfs40_mig_recovery_ops,
97dc1359
TM		 9423};
9424
9425#if defined(CONFIG_NFS_V4_1)
63f5f796
TM		 9426static struct nfs_seqid *
9427nfs_alloc_no_seqid(struct nfs_seqid_counter *arg1, gfp_t arg2)
9428{
9429 return NULL;
9430}
9431
97dc1359
TM		 9432static const struct nfs4_minor_version_ops nfs_v4_1_minor_ops = {
9433 .minor_version = 1,
39c6daae
TM		 9434 .init_caps = NFS_CAP_READDIRPLUS
9435 | NFS_CAP_ATOMIC_OPEN
3b66486c 9436 | NFS_CAP_POSIX_LOCK
49f9a0fa 9437 | NFS_CAP_STATEID_NFSV41
e983120e 9438 | NFS_CAP_ATOMIC_OPEN_V1,
abf79bb3
CL		 9439 .init_client = nfs41_init_client,
9440 .shutdown_client = nfs41_shutdown_client,
36281caa 9441 .match_stateid = nfs41_match_stateid,
fca78d6d 9442 .find_root_sec = nfs41_find_root_sec,
c8b2d0bf 9443 .free_lock_state = nfs41_free_lock_state,
45870d69 9444 .test_and_free_expired = nfs41_test_and_free_expired_stateid,
63f5f796 9445 .alloc_seqid = nfs_alloc_no_seqid,
04fa2c6b 9446 .session_trunk = nfs4_test_session_trunk,
9915ea7e 9447 .call_sync_ops = &nfs41_call_sync_ops,
c48f4f35
TM		 9448 .reboot_recovery_ops = &nfs41_reboot_recovery_ops,
9449 .nograce_recovery_ops = &nfs41_nograce_recovery_ops,
9450 .state_renewal_ops = &nfs41_state_renewal_ops,
ec011fe8 9451 .mig_recovery_ops = &nfs41_mig_recovery_ops,
97dc1359
TM		 9452};
9453#endif
9454
42c2c424
SD		 9455#if defined(CONFIG_NFS_V4_2)
9456static const struct nfs4_minor_version_ops nfs_v4_2_minor_ops = {
9457 .minor_version = 2,
7017310a
BS		 9458 .init_caps = NFS_CAP_READDIRPLUS
9459 | NFS_CAP_ATOMIC_OPEN
7017310a
BS		 9460 | NFS_CAP_POSIX_LOCK
9461 | NFS_CAP_STATEID_NFSV41
e983120e 9462 | NFS_CAP_ATOMIC_OPEN_V1
f4ac1674 9463 | NFS_CAP_ALLOCATE
2e72448b 9464 | NFS_CAP_COPY
624bd5b7 9465 | NFS_CAP_DEALLOCATE
6c5a0d89 9466 | NFS_CAP_SEEK
e5341f3a
PT		 9467 | NFS_CAP_LAYOUTSTATS
9468 | NFS_CAP_CLONE,
abf79bb3
CL		 9469 .init_client = nfs41_init_client,
9470 .shutdown_client = nfs41_shutdown_client,
42c2c424
SD		 9471 .match_stateid = nfs41_match_stateid,
9472 .find_root_sec = nfs41_find_root_sec,
7017310a 9473 .free_lock_state = nfs41_free_lock_state,
9915ea7e 9474 .call_sync_ops = &nfs41_call_sync_ops,
45870d69 9475 .test_and_free_expired = nfs41_test_and_free_expired_stateid,
63f5f796 9476 .alloc_seqid = nfs_alloc_no_seqid,
04fa2c6b 9477 .session_trunk = nfs4_test_session_trunk,
42c2c424
SD		 9478 .reboot_recovery_ops = &nfs41_reboot_recovery_ops,
9479 .nograce_recovery_ops = &nfs41_nograce_recovery_ops,
9480 .state_renewal_ops = &nfs41_state_renewal_ops,
18e3b739 9481 .mig_recovery_ops = &nfs41_mig_recovery_ops,
42c2c424
SD		 9482};
9483#endif
9484
97dc1359
TM		 9485const struct nfs4_minor_version_ops *nfs_v4_minor_ops[] = {
9486 [0] = &nfs_v4_0_minor_ops,
9487#if defined(CONFIG_NFS_V4_1)
9488 [1] = &nfs_v4_1_minor_ops,
9489#endif
42c2c424
SD		 9490#if defined(CONFIG_NFS_V4_2)
9491 [2] = &nfs_v4_2_minor_ops,
9492#endif
97dc1359
TM		 9493};
9494
13997823 9495static ssize_t nfs4_listxattr(struct dentry *dentry, char *list, size_t size)
c4803c49
AG		 9496{
9497 ssize_t error, error2;
9498
9499 error = generic_listxattr(dentry, list, size);
9500 if (error < 0)
9501 return error;
9502 if (list) {
9503 list += error;
9504 size -= error;
9505 }
9506
9507 error2 = nfs4_listxattr_nfs4_label(d_inode(dentry), list, size);
9508 if (error2 < 0)
9509 return error2;
9510 return error + error2;
9511}
9512
17f26b12 9513static const struct inode_operations nfs4_dir_inode_operations = {
73a79706
BS		 9514 .create = nfs_create,
9515 .lookup = nfs_lookup,
9516 .atomic_open = nfs_atomic_open,
9517 .link = nfs_link,
9518 .unlink = nfs_unlink,
9519 .symlink = nfs_symlink,
9520 .mkdir = nfs_mkdir,
9521 .rmdir = nfs_rmdir,
9522 .mknod = nfs_mknod,
9523 .rename = nfs_rename,
9524 .permission = nfs_permission,
9525 .getattr = nfs_getattr,
9526 .setattr = nfs_setattr,
c4803c49 9527 .listxattr = nfs4_listxattr,
73a79706
BS		 9528};
9529
92e1d5be 9530static const struct inode_operations nfs4_file_inode_operations = {
6b3b5496
BF		 9531 .permission = nfs_permission,
9532 .getattr = nfs_getattr,
9533 .setattr = nfs_setattr,
c4803c49 9534 .listxattr = nfs4_listxattr,
6b3b5496
BF		 9535};
9536
509de811 9537const struct nfs_rpc_ops nfs_v4_clientops = {
1da177e4
LT		 9538 .version = 4, /* protocol version */
9539 .dentry_ops = &nfs4_dentry_operations,
9540 .dir_inode_ops = &nfs4_dir_inode_operations,
6b3b5496 9541 .file_inode_ops = &nfs4_file_inode_operations,
1788ea6e 9542 .file_ops = &nfs4_file_operations,
1da177e4 9543 .getroot = nfs4_proc_get_root,
281cad46 9544 .submount = nfs4_submount,
ff9099f2 9545 .try_mount = nfs4_try_mount,
1da177e4
LT		 9546 .getattr = nfs4_proc_getattr,
9547 .setattr = nfs4_proc_setattr,
9548 .lookup = nfs4_proc_lookup,
5b5faaf6 9549 .lookupp = nfs4_proc_lookupp,
1da177e4
LT		 9550 .access = nfs4_proc_access,
9551 .readlink = nfs4_proc_readlink,
1da177e4
LT		 9552 .create = nfs4_proc_create,
9553 .remove = nfs4_proc_remove,
9554 .unlink_setup = nfs4_proc_unlink_setup,
34e137cc 9555 .unlink_rpc_prepare = nfs4_proc_unlink_rpc_prepare,
1da177e4 9556 .unlink_done = nfs4_proc_unlink_done,
d3d4152a 9557 .rename_setup = nfs4_proc_rename_setup,
c6bfa1a1 9558 .rename_rpc_prepare = nfs4_proc_rename_rpc_prepare,
d3d4152a 9559 .rename_done = nfs4_proc_rename_done,
1da177e4
LT		 9560 .link = nfs4_proc_link,
9561 .symlink = nfs4_proc_symlink,
9562 .mkdir = nfs4_proc_mkdir,
9563 .rmdir = nfs4_proc_remove,
9564 .readdir = nfs4_proc_readdir,
9565 .mknod = nfs4_proc_mknod,
9566 .statfs = nfs4_proc_statfs,
9567 .fsinfo = nfs4_proc_fsinfo,
9568 .pathconf = nfs4_proc_pathconf,
e9326dca 9569 .set_capabilities = nfs4_server_capabilities,
1da177e4 9570 .decode_dirent = nfs4_decode_dirent,
a4cdda59 9571 .pgio_rpc_prepare = nfs4_proc_pgio_rpc_prepare,
1da177e4 9572 .read_setup = nfs4_proc_read_setup,
ec06c096 9573 .read_done = nfs4_read_done,
1da177e4 9574 .write_setup = nfs4_proc_write_setup,
788e7a89 9575 .write_done = nfs4_write_done,
1da177e4 9576 .commit_setup = nfs4_proc_commit_setup,
0b7c0153 9577 .commit_rpc_prepare = nfs4_proc_commit_rpc_prepare,
788e7a89 9578 .commit_done = nfs4_commit_done,
1da177e4 9579 .lock = nfs4_proc_lock,
e50a1c2e 9580 .clear_acl_cache = nfs4_zap_acl_attr,
7fe5c398 9581 .close_context = nfs4_close_context,
2b484297 9582 .open_context = nfs4_atomic_open,
011e2a7f 9583 .have_delegation = nfs4_have_delegation,
57ec14c5 9584 .return_delegation = nfs4_inode_return_delegation,
6663ee7f 9585 .alloc_client = nfs4_alloc_client,
45a52a02 9586 .init_client = nfs4_init_client,
cdb7eced 9587 .free_client = nfs4_free_client,
1179acc6
BS		 9588 .create_server = nfs4_create_server,
9589 .clone_server = nfs_clone_server,
1da177e4
LT		 9590};
9591
64c2ce8b 9592static const struct xattr_handler nfs4_xattr_nfs4_acl_handler = {
98e9cb57 9593 .name = XATTR_NAME_NFSV4_ACL,
64c2ce8b
AK		 9594 .list = nfs4_xattr_list_nfs4_acl,
9595 .get = nfs4_xattr_get_nfs4_acl,
9596 .set = nfs4_xattr_set_nfs4_acl,
9597};
9598
9599const struct xattr_handler *nfs4_xattr_handlers[] = {
9600 &nfs4_xattr_nfs4_acl_handler,
c9bccef6
DQ		 9601#ifdef CONFIG_NFS_V4_SECURITY_LABEL
9602 &nfs4_xattr_nfs4_label_handler,
9603#endif
64c2ce8b
AK		 9604 NULL
9605};
9606
1da177e4
LT		 9607/*
9608 * Local variables:
9609 * c-basic-offset: 8
9610 * End:
9611 */
Empty description
This page took 3.584875 seconds and 4 git commands to generate.