projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
NFSv4.1: change nfs4_free_slot parameters for dynamic slots
[linux-2.6-block.git] / fs / nfs / nfs4proc.c
CommitLineData
1da177e4
LT		 1/*
2 * fs/nfs/nfs4proc.c
3 *
4 * Client-side procedure declarations for NFSv4.
5 *
6 * Copyright (c) 2002 The Regents of the University of Michigan.
7 * All rights reserved.
8 *
9 * Kendrick Smith <kmsmith@umich.edu>
10 * Andy Adamson <andros@umich.edu>
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 *
16 * 1. Redistributions of source code must retain the above copyright
17 * notice, this list of conditions and the following disclaimer.
18 * 2. Redistributions in binary form must reproduce the above copyright
19 * notice, this list of conditions and the following disclaimer in the
20 * documentation and/or other materials provided with the distribution.
21 * 3. Neither the name of the University nor the names of its
22 * contributors may be used to endorse or promote products derived
23 * from this software without specific prior written permission.
24 *
25 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
26 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
27 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
28 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
30 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
31 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
32 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 */
37
38#include <linux/mm.h>
1da177e4
LT		 39#include <linux/delay.h>
40#include <linux/errno.h>
41#include <linux/string.h>
652f89f6
TM		 42#include <linux/ratelimit.h>
43#include <linux/printk.h>
5a0e3ad6 44#include <linux/slab.h>
1da177e4 45#include <linux/sunrpc/clnt.h>
8f70e95f 46#include <linux/sunrpc/gss_api.h>
1da177e4
LT		 47#include <linux/nfs.h>
48#include <linux/nfs4.h>
49#include <linux/nfs_fs.h>
50#include <linux/nfs_page.h>
9b7160c5 51#include <linux/nfs_mount.h>
1da177e4 52#include <linux/namei.h>
02a913a7 53#include <linux/mount.h>
99fe60d0 54#include <linux/module.h>
5a0ffe54 55#include <linux/sunrpc/bc_xprt.h>
64c2ce8b 56#include <linux/xattr.h>
c7a360b0 57#include <linux/utsname.h>
1da177e4 58
4ce79717 59#include "nfs4_fs.h"
1da177e4 60#include "delegation.h"
101070ca 61#include "internal.h"
006ea73e 62#include "iostat.h"
fc931582 63#include "callback.h"
b1f69b75 64#include "pnfs.h"
1da177e4
LT		 65
66#define NFSDBG_FACILITY NFSDBG_PROC
67
2066fe89 68#define NFS4_POLL_RETRY_MIN (HZ/10)
1da177e4
LT		 69#define NFS4_POLL_RETRY_MAX (15*HZ)
70
a78cb57a
TM		 71#define NFS4_MAX_LOOP_ON_RECOVER (10)
72
cdd4e68b 73struct nfs4_opendata;
864472e9 74static int _nfs4_proc_open(struct nfs4_opendata *data);
b257957e 75static int _nfs4_recover_proc_open(struct nfs4_opendata *data);
1da177e4 76static int nfs4_do_fsinfo(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *);
9e33bed5 77static int nfs4_async_handle_error(struct rpc_task *, const struct nfs_server *, struct nfs4_state *);
9936781d 78static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr);
0ab64e0e
TM		 79static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
80 struct nfs_fattr *fattr, struct iattr *sattr,
81 struct nfs4_state *state);
f062eb6c
BS		 82#ifdef CONFIG_NFS_V4_1
83static int nfs41_test_stateid(struct nfs_server *, struct nfs4_state *);
84static int nfs41_free_stateid(struct nfs_server *, struct nfs4_state *);
85#endif
1da177e4 86/* Prevent leaks of NFSv4 errors into userland */
46f72f57 87static int nfs4_map_errors(int err)
1da177e4 88{
52567b03
TM		 89 if (err >= -1000)
90 return err;
91 switch (err) {
92 case -NFS4ERR_RESOURCE:
93 return -EREMOTEIO;
7ebb9315
BS		 94 case -NFS4ERR_WRONGSEC:
95 return -EPERM;
3ddeb7c5
TM		 96 case -NFS4ERR_BADOWNER:
97 case -NFS4ERR_BADNAME:
98 return -EINVAL;
52567b03 99 default:
1da177e4 100 dprintk("%s could not handle NFSv4 error %d\n",
3110ff80 101 __func__, -err);
52567b03 102 break;
1da177e4 103 }
52567b03 104 return -EIO;
1da177e4
LT		 105}
106
107/*
108 * This is our standard bitmap for GETATTR requests.
109 */
110const u32 nfs4_fattr_bitmap[2] = {
111 FATTR4_WORD0_TYPE
112 | FATTR4_WORD0_CHANGE
113 | FATTR4_WORD0_SIZE
114 | FATTR4_WORD0_FSID
115 | FATTR4_WORD0_FILEID,
116 FATTR4_WORD1_MODE
117 | FATTR4_WORD1_NUMLINKS
118 | FATTR4_WORD1_OWNER
119 | FATTR4_WORD1_OWNER_GROUP
120 | FATTR4_WORD1_RAWDEV
121 | FATTR4_WORD1_SPACE_USED
122 | FATTR4_WORD1_TIME_ACCESS
123 | FATTR4_WORD1_TIME_METADATA
124 | FATTR4_WORD1_TIME_MODIFY
125};
126
127const u32 nfs4_statfs_bitmap[2] = {
128 FATTR4_WORD0_FILES_AVAIL
129 | FATTR4_WORD0_FILES_FREE
130 | FATTR4_WORD0_FILES_TOTAL,
131 FATTR4_WORD1_SPACE_AVAIL
132 | FATTR4_WORD1_SPACE_FREE
133 | FATTR4_WORD1_SPACE_TOTAL
134};
135
4ce79717 136const u32 nfs4_pathconf_bitmap[2] = {
1da177e4
LT		 137 FATTR4_WORD0_MAXLINK
138 | FATTR4_WORD0_MAXNAME,
139 0
140};
141
dae100c2 142const u32 nfs4_fsinfo_bitmap[3] = { FATTR4_WORD0_MAXFILESIZE
1da177e4
LT		 143 | FATTR4_WORD0_MAXREAD
144 | FATTR4_WORD0_MAXWRITE
145 | FATTR4_WORD0_LEASE_TIME,
55b6e774 146 FATTR4_WORD1_TIME_DELTA
dae100c2
FI		 147 | FATTR4_WORD1_FS_LAYOUT_TYPES,
148 FATTR4_WORD2_LAYOUT_BLKSIZE
1da177e4
LT		 149};
150
830b8e33
MN		 151const u32 nfs4_fs_locations_bitmap[2] = {
152 FATTR4_WORD0_TYPE
153 | FATTR4_WORD0_CHANGE
154 | FATTR4_WORD0_SIZE
155 | FATTR4_WORD0_FSID
156 | FATTR4_WORD0_FILEID
157 | FATTR4_WORD0_FS_LOCATIONS,
158 FATTR4_WORD1_MODE
159 | FATTR4_WORD1_NUMLINKS
160 | FATTR4_WORD1_OWNER
161 | FATTR4_WORD1_OWNER_GROUP
162 | FATTR4_WORD1_RAWDEV
163 | FATTR4_WORD1_SPACE_USED
164 | FATTR4_WORD1_TIME_ACCESS
165 | FATTR4_WORD1_TIME_METADATA
166 | FATTR4_WORD1_TIME_MODIFY
167 | FATTR4_WORD1_MOUNTED_ON_FILEID
168};
169
bc4785cd 170static void nfs4_setup_readdir(u64 cookie, __be32 *verifier, struct dentry *dentry,
1da177e4
LT		 171 struct nfs4_readdir_arg *readdir)
172{
0dbb4c67 173 __be32 *start, *p;
1da177e4
LT		 174
175 BUG_ON(readdir->count < 80);
176 if (cookie > 2) {
b7ef1956 177 readdir->cookie = cookie;
1da177e4
LT		 178 memcpy(&readdir->verifier, verifier, sizeof(readdir->verifier));
179 return;
180 }
181
182 readdir->cookie = 0;
183 memset(&readdir->verifier, 0, sizeof(readdir->verifier));
184 if (cookie == 2)
185 return;
186
187 /*
188 * NFSv4 servers do not return entries for '.' and '..'
189 * Therefore, we fake these entries here. We let '.'
190 * have cookie 0 and '..' have cookie 1. Note that
191 * when talking to the server, we always send cookie 0
192 * instead of 1 or 2.
193 */
0dbb4c67 194 start = p = kmap_atomic(*readdir->pages, KM_USER0);
1da177e4
LT		 195
196 if (cookie == 0) {
197 *p++ = xdr_one; /* next */
198 *p++ = xdr_zero; /* cookie, first word */
199 *p++ = xdr_one; /* cookie, second word */
200 *p++ = xdr_one; /* entry len */
201 memcpy(p, ".\0\0\0", 4); /* entry */
202 p++;
203 *p++ = xdr_one; /* bitmap length */
204 *p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */
205 *p++ = htonl(8); /* attribute buffer length */
4e769b93 206 p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_inode));
1da177e4
LT		 207 }
208
209 *p++ = xdr_one; /* next */
210 *p++ = xdr_zero; /* cookie, first word */
211 *p++ = xdr_two; /* cookie, second word */
212 *p++ = xdr_two; /* entry len */
213 memcpy(p, "..\0\0", 4); /* entry */
214 p++;
215 *p++ = xdr_one; /* bitmap length */
216 *p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */
217 *p++ = htonl(8); /* attribute buffer length */
4e769b93 218 p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_parent->d_inode));
1da177e4
LT		 219
220 readdir->pgbase = (char *)p - (char *)start;
221 readdir->count -= readdir->pgbase;
222 kunmap_atomic(start, KM_USER0);
223}
224
65de872e
TM		 225static int nfs4_wait_clnt_recover(struct nfs_client *clp)
226{
227 int res;
228
229 might_sleep();
230
e005e804 231 res = wait_on_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING,
72cb77f4 232 nfs_wait_bit_killable, TASK_KILLABLE);
65de872e
TM		 233 return res;
234}
235
236static int nfs4_delay(struct rpc_clnt *clnt, long *timeout)
237{
238 int res = 0;
239
240 might_sleep();
241
242 if (*timeout <= 0)
243 *timeout = NFS4_POLL_RETRY_MIN;
244 if (*timeout > NFS4_POLL_RETRY_MAX)
245 *timeout = NFS4_POLL_RETRY_MAX;
246 schedule_timeout_killable(*timeout);
247 if (fatal_signal_pending(current))
248 res = -ERESTARTSYS;
249 *timeout <<= 1;
250 return res;
251}
252
253/* This is the error handling routine for processes that are allowed
254 * to sleep.
255 */
b064eca2 256static int nfs4_handle_exception(struct nfs_server *server, int errorcode, struct nfs4_exception *exception)
65de872e
TM		 257{
258 struct nfs_client *clp = server->nfs_client;
9e33bed5 259 struct nfs4_state *state = exception->state;
65de872e
TM		 260 int ret = errorcode;
261
262 exception->retry = 0;
263 switch(errorcode) {
264 case 0:
265 return 0;
9e33bed5
TM		 266 case -NFS4ERR_ADMIN_REVOKED:
267 case -NFS4ERR_BAD_STATEID:
268 case -NFS4ERR_OPENMODE:
269 if (state == NULL)
270 break;
0400a6b0
TM		 271 nfs4_schedule_stateid_recovery(server, state);
272 goto wait_on_recovery;
0ced63d1
TM		 273 case -NFS4ERR_EXPIRED:
274 if (state != NULL)
275 nfs4_schedule_stateid_recovery(server, state);
65de872e 276 case -NFS4ERR_STALE_STATEID:
a2c0b9e2 277 case -NFS4ERR_STALE_CLIENTID:
0400a6b0
TM		 278 nfs4_schedule_lease_recovery(clp);
279 goto wait_on_recovery;
03391693 280#if defined(CONFIG_NFS_V4_1)
4745e315
AA		 281 case -NFS4ERR_BADSESSION:
282 case -NFS4ERR_BADSLOT:
283 case -NFS4ERR_BAD_HIGH_SLOT:
284 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
285 case -NFS4ERR_DEADSESSION:
286 case -NFS4ERR_SEQ_FALSE_RETRY:
287 case -NFS4ERR_SEQ_MISORDERED:
288 dprintk("%s ERROR: %d Reset session\n", __func__,
289 errorcode);
0400a6b0 290 nfs4_schedule_session_recovery(clp->cl_session);
4745e315 291 exception->retry = 1;
b9179237 292 break;
03391693 293#endif /* defined(CONFIG_NFS_V4_1) */
65de872e 294 case -NFS4ERR_FILE_OPEN:
44ed3556
N		 295 if (exception->timeout > HZ) {
296 /* We have retried a decent amount, time to
297 * fail
298 */
299 ret = -EBUSY;
300 break;
301 }
65de872e
TM		 302 case -NFS4ERR_GRACE:
303 case -NFS4ERR_DELAY:
2c643488 304 case -EKEYEXPIRED:
65de872e
TM		 305 ret = nfs4_delay(server->client, &exception->timeout);
306 if (ret != 0)
307 break;
a8a4ae3a 308 case -NFS4ERR_RETRY_UNCACHED_REP:
65de872e
TM		 309 case -NFS4ERR_OLD_STATEID:
310 exception->retry = 1;
b064eca2
TM		 311 break;
312 case -NFS4ERR_BADOWNER:
313 /* The following works around a Linux server bug! */
314 case -NFS4ERR_BADNAME:
315 if (server->caps & NFS_CAP_UIDGID_NOMAP) {
316 server->caps &= ~NFS_CAP_UIDGID_NOMAP;
317 exception->retry = 1;
318 printk(KERN_WARNING "NFS: v4 server %s "
319 "does not accept raw "
320 "uid/gids. "
321 "Reenabling the idmapper.\n",
322 server->nfs_client->cl_hostname);
323 }
65de872e
TM		 324 }
325 /* We failed to handle the error */
326 return nfs4_map_errors(ret);
0400a6b0 327wait_on_recovery:
a2c0b9e2
TM		 328 ret = nfs4_wait_clnt_recover(clp);
329 if (ret == 0)
330 exception->retry = 1;
331 return ret;
65de872e
TM		 332}
333
334
452e9352 335static void do_renew_lease(struct nfs_client *clp, unsigned long timestamp)
1da177e4 336{
1da177e4
LT		 337 spin_lock(&clp->cl_lock);
338 if (time_before(clp->cl_last_renewal,timestamp))
339 clp->cl_last_renewal = timestamp;
340 spin_unlock(&clp->cl_lock);
341}
342
452e9352
TM		 343static void renew_lease(const struct nfs_server *server, unsigned long timestamp)
344{
345 do_renew_lease(server->nfs_client, timestamp);
346}
347
cccef3b9
AA		 348#if defined(CONFIG_NFS_V4_1)
349
e2c4ab3c
AA		 350/*
351 * nfs4_free_slot - free a slot and efficiently update slot table.
352 *
353 * freeing a slot is trivially done by clearing its respective bit
354 * in the bitmap.
355 * If the freed slotid equals highest_used_slotid we want to update it
356 * so that the server would be able to size down the slot table if needed,
357 * otherwise we know that the highest_used_slotid is still in use.
358 * When updating highest_used_slotid there may be "holes" in the bitmap
359 * so we need to scan down from highest_used_slotid to 0 looking for the now
360 * highest slotid in use.
361 * If none found, highest_used_slotid is set to -1.
35dc1d74
TM		 362 *
363 * Must be called while holding tbl->slot_tbl_lock
e2c4ab3c
AA		 364 */
365static void
aabd0b40 366nfs4_free_slot(struct nfs4_slot_table *tbl, u8 free_slotid)
e2c4ab3c
AA		 367{
368 int slotid = free_slotid;
369
dfb4f309 370 BUG_ON(slotid < 0 || slotid >= NFS4_MAX_SLOT_TABLE);
e2c4ab3c
AA		 371 /* clear used bit in bitmap */
372 __clear_bit(slotid, tbl->used_slots);
373
374 /* update highest_used_slotid when it is freed */
375 if (slotid == tbl->highest_used_slotid) {
376 slotid = find_last_bit(tbl->used_slots, tbl->max_slots);
bcb56164 377 if (slotid < tbl->max_slots)
e2c4ab3c
AA		 378 tbl->highest_used_slotid = slotid;
379 else
380 tbl->highest_used_slotid = -1;
381 }
e2c4ab3c
AA		 382 dprintk("%s: free_slotid %u highest_used_slotid %d\n", __func__,
383 free_slotid, tbl->highest_used_slotid);
384}
385
3bfb0fc5 386/*
42acd021 387 * Signal state manager thread if session fore channel is drained
3bfb0fc5 388 */
42acd021 389static void nfs4_check_drain_fc_complete(struct nfs4_session *ses)
3bfb0fc5 390{
689cf5c1
AB		 391 struct rpc_task *task;
392
a2118c33 393 if (!test_bit(NFS4_SESSION_DRAINING, &ses->session_state)) {
689cf5c1
AB		 394 task = rpc_wake_up_next(&ses->fc_slot_table.slot_tbl_waitq);
395 if (task)
396 rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED);
3bfb0fc5
AB		 397 return;
398 }
399
400 if (ses->fc_slot_table.highest_used_slotid != -1)
401 return;
402
42acd021
AA		 403 dprintk("%s COMPLETE: Session Fore Channel Drained\n", __func__);
404 complete(&ses->fc_slot_table.complete);
405}
406
407/*
408 * Signal state manager thread if session back channel is drained
409 */
410void nfs4_check_drain_bc_complete(struct nfs4_session *ses)
411{
412 if (!test_bit(NFS4_SESSION_DRAINING, &ses->session_state) ||
413 ses->bc_slot_table.highest_used_slotid != -1)
414 return;
415 dprintk("%s COMPLETE: Session Back Channel Drained\n", __func__);
416 complete(&ses->bc_slot_table.complete);
3bfb0fc5
AB		 417}
418
d185a334 419static void nfs41_sequence_free_slot(struct nfs4_sequence_res *res)
13615871
AA		 420{
421 struct nfs4_slot_table *tbl;
422
d185a334 423 tbl = &res->sr_session->fc_slot_table;
dfb4f309 424 if (!res->sr_slot) {
13615871
AA		 425 /* just wake up the next guy waiting since
426 * we may have not consumed a slot after all */
691daf3b 427 dprintk("%s: No slot\n", __func__);
35dc1d74 428 return;
13615871 429 }
ea028ac9 430
35dc1d74 431 spin_lock(&tbl->slot_tbl_lock);
aabd0b40 432 nfs4_free_slot(tbl, res->sr_slot - tbl->slots);
42acd021 433 nfs4_check_drain_fc_complete(res->sr_session);
35dc1d74 434 spin_unlock(&tbl->slot_tbl_lock);
dfb4f309 435 res->sr_slot = NULL;
13615871
AA		 436}
437
14516c3a 438static int nfs41_sequence_done(struct rpc_task *task, struct nfs4_sequence_res *res)
b0df806c
AA		 439{
440 unsigned long timestamp;
14516c3a 441 struct nfs_client *clp;
b0df806c
AA		 442
443 /*
444 * sr_status remains 1 if an RPC level error occurred. The server
445 * may or may not have processed the sequence operation..
446 * Proceed as if the server received and processed the sequence
447 * operation.
448 */
449 if (res->sr_status == 1)
450 res->sr_status = NFS_OK;
451
468f8613
BS		 452 /* don't increment the sequence number if the task wasn't sent */
453 if (!RPC_WAS_SENT(task))
b0df806c
AA		 454 goto out;
455
691daf3b 456 /* Check the SEQUENCE operation status */
14516c3a
TM		 457 switch (res->sr_status) {
458 case 0:
b0df806c 459 /* Update the slot's sequence and clientid lease timer */
dfb4f309 460 ++res->sr_slot->seq_nr;
b0df806c 461 timestamp = res->sr_renewal_time;
14516c3a 462 clp = res->sr_session->clp;
452e9352 463 do_renew_lease(clp, timestamp);
0629e370 464 /* Check sequence flags */
b4410c2f
TM		 465 if (res->sr_status_flags != 0)
466 nfs4_schedule_lease_recovery(clp);
14516c3a
TM		 467 break;
468 case -NFS4ERR_DELAY:
469 /* The server detected a resend of the RPC call and
470 * returned NFS4ERR_DELAY as per Section 2.10.6.2
471 * of RFC5661.
472 */
12364a4f 473 dprintk("%s: slot=%td seq=%d: Operation in progress\n",
dfb4f309
BH		 474 __func__,
475 res->sr_slot - res->sr_session->fc_slot_table.slots,
476 res->sr_slot->seq_nr);
14516c3a
TM		 477 goto out_retry;
478 default:
479 /* Just update the slot sequence no. */
dfb4f309 480 ++res->sr_slot->seq_nr;
b0df806c
AA		 481 }
482out:
483 /* The session may be reset by one of the error handlers. */
484 dprintk("%s: Error %d free the slot \n", __func__, res->sr_status);
d185a334 485 nfs41_sequence_free_slot(res);
14516c3a
TM		 486 return 1;
487out_retry:
d05dd4e9 488 if (!rpc_restart_call(task))
14516c3a
TM		 489 goto out;
490 rpc_delay(task, NFS4_POLL_RETRY_MAX);
491 return 0;
b0df806c
AA		 492}
493
14516c3a
TM		 494static int nfs4_sequence_done(struct rpc_task *task,
495 struct nfs4_sequence_res *res)
df896455 496{
14516c3a
TM		 497 if (res->sr_session == NULL)
498 return 1;
499 return nfs41_sequence_done(task, res);
df896455
TM		 500}
501
510b8175
BH		 502/*
503 * nfs4_find_slot - efficiently look for a free slot
504 *
505 * nfs4_find_slot looks for an unset bit in the used_slots bitmap.
506 * If found, we mark the slot as used, update the highest_used_slotid,
507 * and respectively set up the sequence operation args.
508 * The slot number is returned if found, or NFS4_MAX_SLOT_TABLE otherwise.
fbcd4abc
AA		 509 *
510 * Note: must be called with under the slot_tbl_lock.
510b8175
BH		 511 */
512static u8
40ead580 513nfs4_find_slot(struct nfs4_slot_table *tbl)
510b8175
BH		 514{
515 int slotid;
516 u8 ret_id = NFS4_MAX_SLOT_TABLE;
517 BUILD_BUG_ON((u8)NFS4_MAX_SLOT_TABLE != (int)NFS4_MAX_SLOT_TABLE);
518
510b8175
BH		 519 dprintk("--> %s used_slots=%04lx highest_used=%d max_slots=%d\n",
520 __func__, tbl->used_slots[0], tbl->highest_used_slotid,
521 tbl->max_slots);
522 slotid = find_first_zero_bit(tbl->used_slots, tbl->max_slots);
523 if (slotid >= tbl->max_slots)
524 goto out;
525 __set_bit(slotid, tbl->used_slots);
526 if (slotid > tbl->highest_used_slotid)
527 tbl->highest_used_slotid = slotid;
528 ret_id = slotid;
529out:
530 dprintk("<-- %s used_slots=%04lx highest_used=%d slotid=%d \n",
531 __func__, tbl->used_slots[0], tbl->highest_used_slotid, ret_id);
510b8175
BH		 532 return ret_id;
533}
534
dc70d7b3 535int nfs41_setup_sequence(struct nfs4_session *session,
ce5039c1
AA		 536 struct nfs4_sequence_args *args,
537 struct nfs4_sequence_res *res,
538 int cache_reply,
539 struct rpc_task *task)
540{
fbcd4abc
AA		 541 struct nfs4_slot *slot;
542 struct nfs4_slot_table *tbl;
543 u8 slotid;
544
545 dprintk("--> %s\n", __func__);
ce5039c1 546 /* slot already allocated? */
dfb4f309 547 if (res->sr_slot != NULL)
ce5039c1
AA		 548 return 0;
549
fbcd4abc
AA		 550 tbl = &session->fc_slot_table;
551
552 spin_lock(&tbl->slot_tbl_lock);
a2118c33 553 if (test_bit(NFS4_SESSION_DRAINING, &session->session_state) &&
5601a00d 554 !rpc_task_has_priority(task, RPC_PRIORITY_PRIVILEGED)) {
ea028ac9
AA		 555 /*
556 * The state manager will wait until the slot table is empty.
557 * Schedule the reset thread
558 */
05f0d236 559 rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL);
b069d94a 560 spin_unlock(&tbl->slot_tbl_lock);
bcb56164 561 dprintk("%s Schedule Session Reset\n", __func__);
05f0d236 562 return -EAGAIN;
b069d94a
AA		 563 }
564
689cf5c1
AB		 565 if (!rpc_queue_empty(&tbl->slot_tbl_waitq) &&
566 !rpc_task_has_priority(task, RPC_PRIORITY_PRIVILEGED)) {
567 rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL);
568 spin_unlock(&tbl->slot_tbl_lock);
569 dprintk("%s enforce FIFO order\n", __func__);
570 return -EAGAIN;
571 }
572
40ead580 573 slotid = nfs4_find_slot(tbl);
fbcd4abc
AA		 574 if (slotid == NFS4_MAX_SLOT_TABLE) {
575 rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL);
576 spin_unlock(&tbl->slot_tbl_lock);
577 dprintk("<-- %s: no free slots\n", __func__);
578 return -EAGAIN;
579 }
580 spin_unlock(&tbl->slot_tbl_lock);
581
689cf5c1 582 rpc_task_set_priority(task, RPC_PRIORITY_NORMAL);
fbcd4abc 583 slot = tbl->slots + slotid;
99fe60d0 584 args->sa_session = session;
fbcd4abc
AA		 585 args->sa_slotid = slotid;
586 args->sa_cache_this = cache_reply;
587
588 dprintk("<-- %s slotid=%d seqid=%d\n", __func__, slotid, slot->seq_nr);
589
99fe60d0 590 res->sr_session = session;
dfb4f309 591 res->sr_slot = slot;
fbcd4abc 592 res->sr_renewal_time = jiffies;
2a6e26cd 593 res->sr_status_flags = 0;
fbcd4abc
AA		 594 /*
595 * sr_status is only set in decode_sequence, and so will remain
596 * set to 1 if an rpc level failure occurs.
597 */
598 res->sr_status = 1;
ce5039c1
AA		 599 return 0;
600}
dc70d7b3 601EXPORT_SYMBOL_GPL(nfs41_setup_sequence);
ce5039c1 602
035168ab 603int nfs4_setup_sequence(const struct nfs_server *server,
ce5039c1
AA		 604 struct nfs4_sequence_args *args,
605 struct nfs4_sequence_res *res,
606 int cache_reply,
607 struct rpc_task *task)
608{
035168ab 609 struct nfs4_session *session = nfs4_get_session(server);
ce5039c1
AA		 610 int ret = 0;
611
035168ab
TM		 612 if (session == NULL) {
613 args->sa_session = NULL;
614 res->sr_session = NULL;
615 goto out;
616 }
617
12364a4f 618 dprintk("--> %s clp %p session %p sr_slot %td\n",
dfb4f309
BH		 619 __func__, session->clp, session, res->sr_slot ?
620 res->sr_slot - session->fc_slot_table.slots : -1);
ce5039c1 621
035168ab 622 ret = nfs41_setup_sequence(session, args, res, cache_reply,
ce5039c1 623 task);
ce5039c1
AA		 624out:
625 dprintk("<-- %s status=%d\n", __func__, ret);
626 return ret;
627}
628
629struct nfs41_call_sync_data {
035168ab 630 const struct nfs_server *seq_server;
ce5039c1
AA		 631 struct nfs4_sequence_args *seq_args;
632 struct nfs4_sequence_res *seq_res;
633 int cache_reply;
634};
635
636static void nfs41_call_sync_prepare(struct rpc_task *task, void *calldata)
637{
638 struct nfs41_call_sync_data *data = calldata;
639
035168ab
TM		 640 dprintk("--> %s data->seq_server %p\n", __func__, data->seq_server);
641
642 if (nfs4_setup_sequence(data->seq_server, data->seq_args,
ce5039c1
AA		 643 data->seq_res, data->cache_reply, task))
644 return;
645 rpc_call_start(task);
646}
647
b257957e
AB		 648static void nfs41_call_priv_sync_prepare(struct rpc_task *task, void *calldata)
649{
650 rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED);
651 nfs41_call_sync_prepare(task, calldata);
652}
653
69ab40c4
AA		 654static void nfs41_call_sync_done(struct rpc_task *task, void *calldata)
655{
656 struct nfs41_call_sync_data *data = calldata;
657
14516c3a 658 nfs41_sequence_done(task, data->seq_res);
69ab40c4
AA		 659}
660
ce5039c1
AA		 661struct rpc_call_ops nfs41_call_sync_ops = {
662 .rpc_call_prepare = nfs41_call_sync_prepare,
69ab40c4 663 .rpc_call_done = nfs41_call_sync_done,
ce5039c1
AA		 664};
665
b257957e
AB		 666struct rpc_call_ops nfs41_call_priv_sync_ops = {
667 .rpc_call_prepare = nfs41_call_priv_sync_prepare,
668 .rpc_call_done = nfs41_call_sync_done,
669};
670
7c513058
BS		 671static int nfs4_call_sync_sequence(struct rpc_clnt *clnt,
672 struct nfs_server *server,
ce5039c1
AA		 673 struct rpc_message *msg,
674 struct nfs4_sequence_args *args,
675 struct nfs4_sequence_res *res,
b257957e
AB		 676 int cache_reply,
677 int privileged)
ce5039c1
AA		 678{
679 int ret;
680 struct rpc_task *task;
681 struct nfs41_call_sync_data data = {
035168ab 682 .seq_server = server,
ce5039c1
AA		 683 .seq_args = args,
684 .seq_res = res,
685 .cache_reply = cache_reply,
686 };
687 struct rpc_task_setup task_setup = {
7c513058 688 .rpc_client = clnt,
ce5039c1
AA		 689 .rpc_message = msg,
690 .callback_ops = &nfs41_call_sync_ops,
691 .callback_data = &data
692 };
693
dfb4f309 694 res->sr_slot = NULL;
b257957e
AB		 695 if (privileged)
696 task_setup.callback_ops = &nfs41_call_priv_sync_ops;
ce5039c1
AA		 697 task = rpc_run_task(&task_setup);
698 if (IS_ERR(task))
699 ret = PTR_ERR(task);
700 else {
701 ret = task->tk_status;
702 rpc_put_task(task);
703 }
704 return ret;
705}
706
7c513058
BS		 707int _nfs4_call_sync_session(struct rpc_clnt *clnt,
708 struct nfs_server *server,
cccef3b9
AA		 709 struct rpc_message *msg,
710 struct nfs4_sequence_args *args,
711 struct nfs4_sequence_res *res,
712 int cache_reply)
713{
7c513058 714 return nfs4_call_sync_sequence(clnt, server, msg, args, res, cache_reply, 0);
cccef3b9
AA		 715}
716
df896455 717#else
14516c3a
TM		 718static int nfs4_sequence_done(struct rpc_task *task,
719 struct nfs4_sequence_res *res)
df896455 720{
14516c3a 721 return 1;
df896455 722}
cccef3b9
AA		 723#endif /* CONFIG_NFS_V4_1 */
724
7c513058
BS		 725int _nfs4_call_sync(struct rpc_clnt *clnt,
726 struct nfs_server *server,
cccef3b9
AA		 727 struct rpc_message *msg,
728 struct nfs4_sequence_args *args,
729 struct nfs4_sequence_res *res,
730 int cache_reply)
731{
f3752975 732 args->sa_session = res->sr_session = NULL;
7c513058 733 return rpc_call_sync(clnt, msg, 0);
cccef3b9
AA		 734}
735
e73b83f2 736static inline
7c513058
BS		 737int nfs4_call_sync(struct rpc_clnt *clnt,
738 struct nfs_server *server,
e73b83f2
BS		 739 struct rpc_message *msg,
740 struct nfs4_sequence_args *args,
741 struct nfs4_sequence_res *res,
742 int cache_reply)
743{
7c513058
BS		 744 return server->nfs_client->cl_mvops->call_sync(clnt, server, msg,
745 args, res, cache_reply);
e73b83f2 746}
cccef3b9 747
38478b24 748static void update_changeattr(struct inode *dir, struct nfs4_change_info *cinfo)
1da177e4 749{
38478b24 750 struct nfs_inode *nfsi = NFS_I(dir);
1da177e4 751
38478b24 752 spin_lock(&dir->i_lock);
40d24704 753 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE|NFS_INO_INVALID_DATA;
a9a4a87a 754 if (!cinfo->atomic || cinfo->before != dir->i_version)
bfc69a45 755 nfs_force_lookup_revalidate(dir);
a9a4a87a 756 dir->i_version = cinfo->after;
38478b24 757 spin_unlock(&dir->i_lock);
1da177e4
LT		 758}
759
e56e0b78 760struct nfs4_opendata {
c6d00e63 761 struct kref kref;
e56e0b78
TM		 762 struct nfs_openargs o_arg;
763 struct nfs_openres o_res;
cdd4e68b
TM		 764 struct nfs_open_confirmargs c_arg;
765 struct nfs_open_confirmres c_res;
e56e0b78
TM		 766 struct nfs_fattr f_attr;
767 struct nfs_fattr dir_attr;
e56e0b78 768 struct dentry *dir;
82a2c1b7 769 struct dentry *dentry;
e56e0b78 770 struct nfs4_state_owner *owner;
aac00a8d 771 struct nfs4_state *state;
e56e0b78 772 struct iattr attrs;
26e976a8 773 unsigned long timestamp;
3e309914 774 unsigned int rpc_done : 1;
24ac23ab
TM		 775 int rpc_status;
776 int cancelled;
e56e0b78
TM		 777};
778
2ced46c2
TM		 779
780static void nfs4_init_opendata_res(struct nfs4_opendata *p)
781{
782 p->o_res.f_attr = &p->f_attr;
783 p->o_res.dir_attr = &p->dir_attr;
c1d51931
TM		 784 p->o_res.seqid = p->o_arg.seqid;
785 p->c_res.seqid = p->c_arg.seqid;
2ced46c2
TM		 786 p->o_res.server = p->o_arg.server;
787 nfs_fattr_init(&p->f_attr);
788 nfs_fattr_init(&p->dir_attr);
789}
790
82a2c1b7 791static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
dc0b027d 792 struct nfs4_state_owner *sp, fmode_t fmode, int flags,
8535b2be
TM		 793 const struct iattr *attrs,
794 gfp_t gfp_mask)
e56e0b78 795{
82a2c1b7 796 struct dentry *parent = dget_parent(dentry);
e56e0b78
TM		 797 struct inode *dir = parent->d_inode;
798 struct nfs_server *server = NFS_SERVER(dir);
799 struct nfs4_opendata *p;
800
8535b2be 801 p = kzalloc(sizeof(*p), gfp_mask);
e56e0b78
TM		 802 if (p == NULL)
803 goto err;
8535b2be 804 p->o_arg.seqid = nfs_alloc_seqid(&sp->so_seqid, gfp_mask);
e56e0b78
TM		 805 if (p->o_arg.seqid == NULL)
806 goto err_free;
82a2c1b7
AV		 807 nfs_sb_active(dentry->d_sb);
808 p->dentry = dget(dentry);
e56e0b78
TM		 809 p->dir = parent;
810 p->owner = sp;
811 atomic_inc(&sp->so_count);
812 p->o_arg.fh = NFS_FH(dir);
dc0b027d
TM		 813 p->o_arg.open_flags = flags;
814 p->o_arg.fmode = fmode & (FMODE_READ|FMODE_WRITE);
7539bbab 815 p->o_arg.clientid = server->nfs_client->cl_clientid;
9f958ab8 816 p->o_arg.id = sp->so_owner_id.id;
82a2c1b7 817 p->o_arg.name = &dentry->d_name;
e56e0b78
TM		 818 p->o_arg.server = server;
819 p->o_arg.bitmask = server->attr_bitmask;
820 p->o_arg.claim = NFS4_OPEN_CLAIM_NULL;
d77d76ff
TM		 821 if (flags & O_CREAT) {
822 u32 *s;
823
e56e0b78
TM		 824 p->o_arg.u.attrs = &p->attrs;
825 memcpy(&p->attrs, attrs, sizeof(p->attrs));
d77d76ff
TM		 826 s = (u32 *) p->o_arg.u.verifier.data;
827 s[0] = jiffies;
828 s[1] = current->pid;
e56e0b78 829 }
cdd4e68b
TM		 830 p->c_arg.fh = &p->o_res.fh;
831 p->c_arg.stateid = &p->o_res.stateid;
832 p->c_arg.seqid = p->o_arg.seqid;
2ced46c2 833 nfs4_init_opendata_res(p);
c6d00e63 834 kref_init(&p->kref);
e56e0b78
TM		 835 return p;
836err_free:
837 kfree(p);
838err:
839 dput(parent);
840 return NULL;
841}
842
c6d00e63 843static void nfs4_opendata_free(struct kref *kref)
e56e0b78 844{
c6d00e63
TM		 845 struct nfs4_opendata *p = container_of(kref,
846 struct nfs4_opendata, kref);
82a2c1b7 847 struct super_block *sb = p->dentry->d_sb;
c6d00e63
TM		 848
849 nfs_free_seqid(p->o_arg.seqid);
aac00a8d
TM		 850 if (p->state != NULL)
851 nfs4_put_open_state(p->state);
c6d00e63
TM		 852 nfs4_put_state_owner(p->owner);
853 dput(p->dir);
82a2c1b7
AV		 854 dput(p->dentry);
855 nfs_sb_deactive(sb);
c6d00e63
TM		 856 kfree(p);
857}
858
859static void nfs4_opendata_put(struct nfs4_opendata *p)
860{
861 if (p != NULL)
862 kref_put(&p->kref, nfs4_opendata_free);
e56e0b78
TM		 863}
864
06f814a3
TM		 865static int nfs4_wait_for_completion_rpc_task(struct rpc_task *task)
866{
06f814a3
TM		 867 int ret;
868
06f814a3 869 ret = rpc_wait_for_completion_task(task);
06f814a3
TM		 870 return ret;
871}
872
dc0b027d 873static int can_open_cached(struct nfs4_state *state, fmode_t mode, int open_mode)
6ee41268
TM		 874{
875 int ret = 0;
dc0b027d
TM		 876
877 if (open_mode & O_EXCL)
878 goto out;
879 switch (mode & (FMODE_READ|FMODE_WRITE)) {
6ee41268 880 case FMODE_READ:
88069f77
TM		 881 ret |= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0
882 && state->n_rdonly != 0;
6ee41268
TM		 883 break;
884 case FMODE_WRITE:
88069f77
TM		 885 ret |= test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0
886 && state->n_wronly != 0;
6ee41268
TM		 887 break;
888 case FMODE_READ|FMODE_WRITE:
88069f77
TM		 889 ret |= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0
890 && state->n_rdwr != 0;
6ee41268 891 }
dc0b027d 892out:
6ee41268
TM		 893 return ret;
894}
895
dc0b027d 896static int can_open_delegated(struct nfs_delegation *delegation, fmode_t fmode)
aac00a8d 897{
652f89f6
TM		 898 if (delegation == NULL)
899 return 0;
dc0b027d 900 if ((delegation->type & fmode) != fmode)
aac00a8d 901 return 0;
15c831bf 902 if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags))
aac00a8d 903 return 0;
b7391f44 904 nfs_mark_delegation_referenced(delegation);
aac00a8d
TM		 905 return 1;
906}
907
dc0b027d 908static void update_open_stateflags(struct nfs4_state *state, fmode_t fmode)
e7616923 909{
dc0b027d 910 switch (fmode) {
e7616923
TM		 911 case FMODE_WRITE:
912 state->n_wronly++;
913 break;
914 case FMODE_READ:
915 state->n_rdonly++;
916 break;
917 case FMODE_READ|FMODE_WRITE:
918 state->n_rdwr++;
919 }
dc0b027d 920 nfs4_state_set_mode_locked(state, state->state | fmode);
003707c7
TM		 921}
922
dc0b027d 923static void nfs_set_open_stateid_locked(struct nfs4_state *state, nfs4_stateid *stateid, fmode_t fmode)
003707c7
TM		 924{
925 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
926 memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data));
927 memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data));
dc0b027d 928 switch (fmode) {
003707c7
TM		 929 case FMODE_READ:
930 set_bit(NFS_O_RDONLY_STATE, &state->flags);
931 break;
932 case FMODE_WRITE:
933 set_bit(NFS_O_WRONLY_STATE, &state->flags);
934 break;
935 case FMODE_READ|FMODE_WRITE:
936 set_bit(NFS_O_RDWR_STATE, &state->flags);
937 }
e7616923
TM		 938}
939
dc0b027d 940static void nfs_set_open_stateid(struct nfs4_state *state, nfs4_stateid *stateid, fmode_t fmode)
003707c7 941{
8bda4e4c 942 write_seqlock(&state->seqlock);
dc0b027d 943 nfs_set_open_stateid_locked(state, stateid, fmode);
8bda4e4c 944 write_sequnlock(&state->seqlock);
003707c7
TM		 945}
946
dc0b027d 947static void __update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_stateid, const nfs4_stateid *deleg_stateid, fmode_t fmode)
1da177e4 948{
8bda4e4c
TM		 949 /*
950 * Protect the call to nfs4_state_set_mode_locked and
951 * serialise the stateid update
952 */
953 write_seqlock(&state->seqlock);
003707c7
TM		 954 if (deleg_stateid != NULL) {
955 memcpy(state->stateid.data, deleg_stateid->data, sizeof(state->stateid.data));
956 set_bit(NFS_DELEGATED_STATE, &state->flags);
957 }
958 if (open_stateid != NULL)
dc0b027d 959 nfs_set_open_stateid_locked(state, open_stateid, fmode);
8bda4e4c
TM		 960 write_sequnlock(&state->seqlock);
961 spin_lock(&state->owner->so_lock);
dc0b027d 962 update_open_stateflags(state, fmode);
ec073428 963 spin_unlock(&state->owner->so_lock);
1da177e4
LT		 964}
965
dc0b027d 966static int update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_stateid, nfs4_stateid *delegation, fmode_t fmode)
34310430
TM		 967{
968 struct nfs_inode *nfsi = NFS_I(state->inode);
969 struct nfs_delegation *deleg_cur;
970 int ret = 0;
971
dc0b027d 972 fmode &= (FMODE_READ|FMODE_WRITE);
34310430
TM		 973
974 rcu_read_lock();
975 deleg_cur = rcu_dereference(nfsi->delegation);
976 if (deleg_cur == NULL)
977 goto no_delegation;
978
979 spin_lock(&deleg_cur->lock);
980 if (nfsi->delegation != deleg_cur ||
dc0b027d 981 (deleg_cur->type & fmode) != fmode)
34310430
TM		 982 goto no_delegation_unlock;
983
984 if (delegation == NULL)
985 delegation = &deleg_cur->stateid;
986 else if (memcmp(deleg_cur->stateid.data, delegation->data, NFS4_STATEID_SIZE) != 0)
987 goto no_delegation_unlock;
988
b7391f44 989 nfs_mark_delegation_referenced(deleg_cur);
dc0b027d 990 __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode);
34310430
TM		 991 ret = 1;
992no_delegation_unlock:
993 spin_unlock(&deleg_cur->lock);
994no_delegation:
995 rcu_read_unlock();
996
997 if (!ret && open_stateid != NULL) {
dc0b027d 998 __update_open_stateid(state, open_stateid, NULL, fmode);
34310430
TM		 999 ret = 1;
1000 }
1001
1002 return ret;
1003}
1004
1005
dc0b027d 1006static void nfs4_return_incompatible_delegation(struct inode *inode, fmode_t fmode)
aac00a8d
TM		 1007{
1008 struct nfs_delegation *delegation;
1009
1010 rcu_read_lock();
1011 delegation = rcu_dereference(NFS_I(inode)->delegation);
dc0b027d 1012 if (delegation == NULL || (delegation->type & fmode) == fmode) {
aac00a8d
TM		 1013 rcu_read_unlock();
1014 return;
1015 }
1016 rcu_read_unlock();
1017 nfs_inode_return_delegation(inode);
1018}
1019
6ee41268 1020static struct nfs4_state *nfs4_try_open_cached(struct nfs4_opendata *opendata)
aac00a8d
TM		 1021{
1022 struct nfs4_state *state = opendata->state;
1023 struct nfs_inode *nfsi = NFS_I(state->inode);
1024 struct nfs_delegation *delegation;
dc0b027d
TM		 1025 int open_mode = opendata->o_arg.open_flags & O_EXCL;
1026 fmode_t fmode = opendata->o_arg.fmode;
aac00a8d
TM		 1027 nfs4_stateid stateid;
1028 int ret = -EAGAIN;
1029
aac00a8d 1030 for (;;) {
dc0b027d 1031 if (can_open_cached(state, fmode, open_mode)) {
6ee41268 1032 spin_lock(&state->owner->so_lock);
dc0b027d
TM		 1033 if (can_open_cached(state, fmode, open_mode)) {
1034 update_open_stateflags(state, fmode);
6ee41268 1035 spin_unlock(&state->owner->so_lock);
6ee41268
TM		 1036 goto out_return_state;
1037 }
1038 spin_unlock(&state->owner->so_lock);
1039 }
34310430
TM		 1040 rcu_read_lock();
1041 delegation = rcu_dereference(nfsi->delegation);
652f89f6 1042 if (!can_open_delegated(delegation, fmode)) {
34310430 1043 rcu_read_unlock();
aac00a8d 1044 break;
34310430 1045 }
aac00a8d
TM		 1046 /* Save the delegation */
1047 memcpy(stateid.data, delegation->stateid.data, sizeof(stateid.data));
1048 rcu_read_unlock();
af22f94a 1049 ret = nfs_may_open(state->inode, state->owner->so_cred, open_mode);
aac00a8d
TM		 1050 if (ret != 0)
1051 goto out;
1052 ret = -EAGAIN;
34310430
TM		 1053
1054 /* Try to update the stateid using the delegation */
dc0b027d 1055 if (update_open_stateid(state, NULL, &stateid, fmode))
34310430 1056 goto out_return_state;
aac00a8d 1057 }
aac00a8d
TM		 1058out:
1059 return ERR_PTR(ret);
1060out_return_state:
1061 atomic_inc(&state->count);
1062 return state;
1063}
1064
24ac23ab
TM		 1065static struct nfs4_state *nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
1066{
1067 struct inode *inode;
1068 struct nfs4_state *state = NULL;
003707c7 1069 struct nfs_delegation *delegation;
1b370bc2 1070 int ret;
24ac23ab 1071
aac00a8d 1072 if (!data->rpc_done) {
6ee41268 1073 state = nfs4_try_open_cached(data);
aac00a8d
TM		 1074 goto out;
1075 }
1076
1b370bc2 1077 ret = -EAGAIN;
24ac23ab 1078 if (!(data->f_attr.valid & NFS_ATTR_FATTR))
1b370bc2 1079 goto err;
24ac23ab 1080 inode = nfs_fhget(data->dir->d_sb, &data->o_res.fh, &data->f_attr);
1b370bc2 1081 ret = PTR_ERR(inode);
03f28e3a 1082 if (IS_ERR(inode))
1b370bc2
TM		 1083 goto err;
1084 ret = -ENOMEM;
24ac23ab
TM		 1085 state = nfs4_get_open_state(inode, data->owner);
1086 if (state == NULL)
1b370bc2 1087 goto err_put_inode;
549d6ed5 1088 if (data->o_res.delegation_type != 0) {
549d6ed5
TM		 1089 int delegation_flags = 0;
1090
003707c7
TM		 1091 rcu_read_lock();
1092 delegation = rcu_dereference(NFS_I(inode)->delegation);
1093 if (delegation)
1094 delegation_flags = delegation->flags;
1095 rcu_read_unlock();
652f89f6
TM		 1096 if (data->o_arg.claim == NFS4_OPEN_CLAIM_DELEGATE_CUR) {
1097 pr_err_ratelimited("NFS: Broken NFSv4 server %s is "
1098 "returning a delegation for "
1099 "OPEN(CLAIM_DELEGATE_CUR)\n",
1100 NFS_CLIENT(inode)->cl_server);
1101 } else if ((delegation_flags & 1UL<<NFS_DELEGATION_NEED_RECLAIM) == 0)
549d6ed5
TM		 1102 nfs_inode_set_delegation(state->inode,
1103 data->owner->so_cred,
1104 &data->o_res);
1105 else
1106 nfs_inode_reclaim_delegation(state->inode,
1107 data->owner->so_cred,
1108 &data->o_res);
1109 }
34310430
TM		 1110
1111 update_open_stateid(state, &data->o_res.stateid, NULL,
dc0b027d 1112 data->o_arg.fmode);
24ac23ab 1113 iput(inode);
aac00a8d 1114out:
24ac23ab 1115 return state;
1b370bc2
TM		 1116err_put_inode:
1117 iput(inode);
1118err:
1119 return ERR_PTR(ret);
24ac23ab
TM		 1120}
1121
864472e9
TM		 1122static struct nfs_open_context *nfs4_state_find_open_context(struct nfs4_state *state)
1123{
1124 struct nfs_inode *nfsi = NFS_I(state->inode);
1125 struct nfs_open_context *ctx;
1126
1127 spin_lock(&state->inode->i_lock);
1128 list_for_each_entry(ctx, &nfsi->open_files, list) {
1129 if (ctx->state != state)
1130 continue;
1131 get_nfs_open_context(ctx);
1132 spin_unlock(&state->inode->i_lock);
1133 return ctx;
1134 }
1135 spin_unlock(&state->inode->i_lock);
1136 return ERR_PTR(-ENOENT);
1137}
1138
6f220ed5
TM		 1139static struct nfs4_opendata *nfs4_open_recoverdata_alloc(struct nfs_open_context *ctx, struct nfs4_state *state)
1140{
1141 struct nfs4_opendata *opendata;
1142
3d4ff43d 1143 opendata = nfs4_opendata_alloc(ctx->dentry, state->owner, 0, 0, NULL, GFP_NOFS);
6f220ed5
TM		 1144 if (opendata == NULL)
1145 return ERR_PTR(-ENOMEM);
1146 opendata->state = state;
1147 atomic_inc(&state->count);
1148 return opendata;
1149}
1150
dc0b027d 1151static int nfs4_open_recover_helper(struct nfs4_opendata *opendata, fmode_t fmode, struct nfs4_state **res)
864472e9 1152{
2ced46c2 1153 struct nfs4_state *newstate;
864472e9
TM		 1154 int ret;
1155
dc0b027d
TM		 1156 opendata->o_arg.open_flags = 0;
1157 opendata->o_arg.fmode = fmode;
2ced46c2
TM		 1158 memset(&opendata->o_res, 0, sizeof(opendata->o_res));
1159 memset(&opendata->c_res, 0, sizeof(opendata->c_res));
1160 nfs4_init_opendata_res(opendata);
b257957e 1161 ret = _nfs4_recover_proc_open(opendata);
864472e9
TM		 1162 if (ret != 0)
1163 return ret;
2ced46c2 1164 newstate = nfs4_opendata_to_nfs4_state(opendata);
1b370bc2
TM		 1165 if (IS_ERR(newstate))
1166 return PTR_ERR(newstate);
643168c2 1167 nfs4_close_state(newstate, fmode);
2ced46c2 1168 *res = newstate;
864472e9
TM		 1169 return 0;
1170}
1171
1172static int nfs4_open_recover(struct nfs4_opendata *opendata, struct nfs4_state *state)
1173{
864472e9 1174 struct nfs4_state *newstate;
864472e9
TM		 1175 int ret;
1176
1177 /* memory barrier prior to reading state->n_* */
2ced46c2 1178 clear_bit(NFS_DELEGATED_STATE, &state->flags);
864472e9
TM		 1179 smp_rmb();
1180 if (state->n_rdwr != 0) {
b0ed9dbc 1181 clear_bit(NFS_O_RDWR_STATE, &state->flags);
2ced46c2 1182 ret = nfs4_open_recover_helper(opendata, FMODE_READ|FMODE_WRITE, &newstate);
864472e9
TM		 1183 if (ret != 0)
1184 return ret;
2ced46c2
TM		 1185 if (newstate != state)
1186 return -ESTALE;
864472e9
TM		 1187 }
1188 if (state->n_wronly != 0) {
b0ed9dbc 1189 clear_bit(NFS_O_WRONLY_STATE, &state->flags);
2ced46c2 1190 ret = nfs4_open_recover_helper(opendata, FMODE_WRITE, &newstate);
864472e9
TM		 1191 if (ret != 0)
1192 return ret;
2ced46c2
TM		 1193 if (newstate != state)
1194 return -ESTALE;
864472e9
TM		 1195 }
1196 if (state->n_rdonly != 0) {
b0ed9dbc 1197 clear_bit(NFS_O_RDONLY_STATE, &state->flags);
2ced46c2 1198 ret = nfs4_open_recover_helper(opendata, FMODE_READ, &newstate);
864472e9
TM		 1199 if (ret != 0)
1200 return ret;
2ced46c2
TM		 1201 if (newstate != state)
1202 return -ESTALE;
864472e9 1203 }
1ac7e2fd
TM		 1204 /*
1205 * We may have performed cached opens for all three recoveries.
1206 * Check if we need to update the current stateid.
1207 */
1208 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0 &&
1209 memcmp(state->stateid.data, state->open_stateid.data, sizeof(state->stateid.data)) != 0) {
8bda4e4c 1210 write_seqlock(&state->seqlock);
1ac7e2fd
TM		 1211 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
1212 memcpy(state->stateid.data, state->open_stateid.data, sizeof(state->stateid.data));
8bda4e4c 1213 write_sequnlock(&state->seqlock);
1ac7e2fd 1214 }
864472e9
TM		 1215 return 0;
1216}
1217
1da177e4
LT		 1218/*
1219 * OPEN_RECLAIM:
1220 * reclaim state on the server after a reboot.
1da177e4 1221 */
539cd03a 1222static int _nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state)
1da177e4 1223{
1ac7e2fd 1224 struct nfs_delegation *delegation;
864472e9 1225 struct nfs4_opendata *opendata;
dc0b027d 1226 fmode_t delegation_type = 0;
1da177e4
LT		 1227 int status;
1228
6f220ed5
TM		 1229 opendata = nfs4_open_recoverdata_alloc(ctx, state);
1230 if (IS_ERR(opendata))
1231 return PTR_ERR(opendata);
864472e9
TM		 1232 opendata->o_arg.claim = NFS4_OPEN_CLAIM_PREVIOUS;
1233 opendata->o_arg.fh = NFS_FH(state->inode);
1ac7e2fd
TM		 1234 rcu_read_lock();
1235 delegation = rcu_dereference(NFS_I(state->inode)->delegation);
15c831bf 1236 if (delegation != NULL && test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags) != 0)
65bbf6bd 1237 delegation_type = delegation->type;
1ac7e2fd 1238 rcu_read_unlock();
864472e9
TM		 1239 opendata->o_arg.u.delegation_type = delegation_type;
1240 status = nfs4_open_recover(opendata, state);
c6d00e63 1241 nfs4_opendata_put(opendata);
1da177e4
LT		 1242 return status;
1243}
1244
539cd03a 1245static int nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state)
1da177e4
LT		 1246{
1247 struct nfs_server *server = NFS_SERVER(state->inode);
1248 struct nfs4_exception exception = { };
1249 int err;
1250 do {
539cd03a 1251 err = _nfs4_do_open_reclaim(ctx, state);
168667c4 1252 if (err != -NFS4ERR_DELAY)
202b50dc
TM		 1253 break;
1254 nfs4_handle_exception(server, err, &exception);
1da177e4
LT		 1255 } while (exception.retry);
1256 return err;
1257}
1258
864472e9
TM		 1259static int nfs4_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *state)
1260{
1261 struct nfs_open_context *ctx;
1262 int ret;
1263
1264 ctx = nfs4_state_find_open_context(state);
1265 if (IS_ERR(ctx))
1266 return PTR_ERR(ctx);
539cd03a 1267 ret = nfs4_do_open_reclaim(ctx, state);
864472e9
TM		 1268 put_nfs_open_context(ctx);
1269 return ret;
1270}
1271
13437e12 1272static int _nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid)
1da177e4 1273{
e56e0b78 1274 struct nfs4_opendata *opendata;
864472e9 1275 int ret;
1da177e4 1276
6f220ed5
TM		 1277 opendata = nfs4_open_recoverdata_alloc(ctx, state);
1278 if (IS_ERR(opendata))
1279 return PTR_ERR(opendata);
e56e0b78 1280 opendata->o_arg.claim = NFS4_OPEN_CLAIM_DELEGATE_CUR;
13437e12 1281 memcpy(opendata->o_arg.u.delegation.data, stateid->data,
e56e0b78 1282 sizeof(opendata->o_arg.u.delegation.data));
864472e9 1283 ret = nfs4_open_recover(opendata, state);
c6d00e63 1284 nfs4_opendata_put(opendata);
864472e9 1285 return ret;
1da177e4
LT		 1286}
1287
13437e12 1288int nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid)
1da177e4
LT		 1289{
1290 struct nfs4_exception exception = { };
539cd03a 1291 struct nfs_server *server = NFS_SERVER(state->inode);
1da177e4
LT		 1292 int err;
1293 do {
13437e12 1294 err = _nfs4_open_delegation_recall(ctx, state, stateid);
1da177e4
LT		 1295 switch (err) {
1296 case 0:
965b5d67
TM		 1297 case -ENOENT:
1298 case -ESTALE:
1299 goto out;
bcfa49f6
RL		 1300 case -NFS4ERR_BADSESSION:
1301 case -NFS4ERR_BADSLOT:
1302 case -NFS4ERR_BAD_HIGH_SLOT:
1303 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1304 case -NFS4ERR_DEADSESSION:
0400a6b0 1305 nfs4_schedule_session_recovery(server->nfs_client->cl_session);
bcfa49f6 1306 goto out;
1da177e4
LT		 1307 case -NFS4ERR_STALE_CLIENTID:
1308 case -NFS4ERR_STALE_STATEID:
1309 case -NFS4ERR_EXPIRED:
1310 /* Don't recall a delegation if it was lost */
0400a6b0 1311 nfs4_schedule_lease_recovery(server->nfs_client);
965b5d67
TM		 1312 goto out;
1313 case -ERESTARTSYS:
1314 /*
1315 * The show must go on: exit, but mark the
1316 * stateid as needing recovery.
1317 */
1318 case -NFS4ERR_ADMIN_REVOKED:
1319 case -NFS4ERR_BAD_STATEID:
0400a6b0 1320 nfs4_schedule_stateid_recovery(server, state);
168667c4
TM		 1321 case -EKEYEXPIRED:
1322 /*
1323 * User RPCSEC_GSS context has expired.
1324 * We cannot recover this stateid now, so
1325 * skip it and allow recovery thread to
1326 * proceed.
1327 */
965b5d67
TM		 1328 case -ENOMEM:
1329 err = 0;
1330 goto out;
1da177e4
LT		 1331 }
1332 err = nfs4_handle_exception(server, err, &exception);
1333 } while (exception.retry);
965b5d67 1334out:
1da177e4
LT		 1335 return err;
1336}
1337
cdd4e68b
TM		 1338static void nfs4_open_confirm_done(struct rpc_task *task, void *calldata)
1339{
1340 struct nfs4_opendata *data = calldata;
1341
1342 data->rpc_status = task->tk_status;
26e976a8 1343 if (data->rpc_status == 0) {
cdd4e68b
TM		 1344 memcpy(data->o_res.stateid.data, data->c_res.stateid.data,
1345 sizeof(data->o_res.stateid.data));
bb22629e 1346 nfs_confirm_seqid(&data->owner->so_seqid, 0);
26e976a8 1347 renew_lease(data->o_res.server, data->timestamp);
3e309914 1348 data->rpc_done = 1;
26e976a8 1349 }
cdd4e68b
TM		 1350}
1351
1352static void nfs4_open_confirm_release(void *calldata)
1353{
1354 struct nfs4_opendata *data = calldata;
1355 struct nfs4_state *state = NULL;
1356
1357 /* If this request hasn't been cancelled, do nothing */
1358 if (data->cancelled == 0)
1359 goto out_free;
1360 /* In case of error, no cleanup! */
3e309914 1361 if (!data->rpc_done)
cdd4e68b 1362 goto out_free;
cdd4e68b 1363 state = nfs4_opendata_to_nfs4_state(data);
1b370bc2 1364 if (!IS_ERR(state))
643168c2 1365 nfs4_close_state(state, data->o_arg.fmode);
cdd4e68b 1366out_free:
c6d00e63 1367 nfs4_opendata_put(data);
cdd4e68b
TM		 1368}
1369
1370static const struct rpc_call_ops nfs4_open_confirm_ops = {
cdd4e68b
TM		 1371 .rpc_call_done = nfs4_open_confirm_done,
1372 .rpc_release = nfs4_open_confirm_release,
1373};
1374
1375/*
1376 * Note: On error, nfs4_proc_open_confirm will free the struct nfs4_opendata
1377 */
1378static int _nfs4_proc_open_confirm(struct nfs4_opendata *data)
1379{
1380 struct nfs_server *server = NFS_SERVER(data->dir->d_inode);
1381 struct rpc_task *task;
5138fde0
TM		 1382 struct rpc_message msg = {
1383 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_CONFIRM],
1384 .rpc_argp = &data->c_arg,
1385 .rpc_resp = &data->c_res,
1386 .rpc_cred = data->owner->so_cred,
1387 };
c970aa85
TM		 1388 struct rpc_task_setup task_setup_data = {
1389 .rpc_client = server->client,
5138fde0 1390 .rpc_message = &msg,
c970aa85
TM		 1391 .callback_ops = &nfs4_open_confirm_ops,
1392 .callback_data = data,
101070ca 1393 .workqueue = nfsiod_workqueue,
c970aa85
TM		 1394 .flags = RPC_TASK_ASYNC,
1395 };
1da177e4
LT		 1396 int status;
1397
c6d00e63 1398 kref_get(&data->kref);
3e309914
TM		 1399 data->rpc_done = 0;
1400 data->rpc_status = 0;
5138fde0 1401 data->timestamp = jiffies;
c970aa85 1402 task = rpc_run_task(&task_setup_data);
7a1218a2 1403 if (IS_ERR(task))
cdd4e68b 1404 return PTR_ERR(task);
cdd4e68b
TM		 1405 status = nfs4_wait_for_completion_rpc_task(task);
1406 if (status != 0) {
1407 data->cancelled = 1;
1408 smp_wmb();
1409 } else
1410 status = data->rpc_status;
e6b3c4db 1411 rpc_put_task(task);
1da177e4
LT		 1412 return status;
1413}
1414
24ac23ab 1415static void nfs4_open_prepare(struct rpc_task *task, void *calldata)
1da177e4 1416{
24ac23ab
TM		 1417 struct nfs4_opendata *data = calldata;
1418 struct nfs4_state_owner *sp = data->owner;
5138fde0 1419
24ac23ab
TM		 1420 if (nfs_wait_on_sequence(data->o_arg.seqid, task) != 0)
1421 return;
aac00a8d
TM		 1422 /*
1423 * Check if we still need to send an OPEN call, or if we can use
1424 * a delegation instead.
1425 */
1426 if (data->state != NULL) {
1427 struct nfs_delegation *delegation;
1428
dc0b027d 1429 if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags))
6ee41268 1430 goto out_no_action;
aac00a8d
TM		 1431 rcu_read_lock();
1432 delegation = rcu_dereference(NFS_I(data->state->inode)->delegation);
652f89f6
TM		 1433 if (data->o_arg.claim != NFS4_OPEN_CLAIM_DELEGATE_CUR &&
1434 can_open_delegated(delegation, data->o_arg.fmode))
1435 goto unlock_no_action;
aac00a8d
TM		 1436 rcu_read_unlock();
1437 }
24ac23ab 1438 /* Update sequence id. */
9f958ab8 1439 data->o_arg.id = sp->so_owner_id.id;
1f0e890d 1440 data->o_arg.clientid = sp->so_server->nfs_client->cl_clientid;
6f220ed5 1441 if (data->o_arg.claim == NFS4_OPEN_CLAIM_PREVIOUS) {
5138fde0 1442 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_NOATTR];
6f220ed5
TM		 1443 nfs_copy_fh(&data->o_res.fh, data->o_arg.fh);
1444 }
26e976a8 1445 data->timestamp = jiffies;
035168ab 1446 if (nfs4_setup_sequence(data->o_arg.server,
d898528c
AA		 1447 &data->o_arg.seq_args,
1448 &data->o_res.seq_res, 1, task))
1449 return;
5138fde0 1450 rpc_call_start(task);
6ee41268 1451 return;
652f89f6
TM		 1452unlock_no_action:
1453 rcu_read_unlock();
6ee41268
TM		 1454out_no_action:
1455 task->tk_action = NULL;
1456
24ac23ab 1457}
1da177e4 1458
b257957e
AB		 1459static void nfs4_recover_open_prepare(struct rpc_task *task, void *calldata)
1460{
1461 rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED);
1462 nfs4_open_prepare(task, calldata);
1463}
1464
24ac23ab
TM		 1465static void nfs4_open_done(struct rpc_task *task, void *calldata)
1466{
1467 struct nfs4_opendata *data = calldata;
1da177e4 1468
24ac23ab 1469 data->rpc_status = task->tk_status;
d898528c 1470
14516c3a
TM		 1471 if (!nfs4_sequence_done(task, &data->o_res.seq_res))
1472 return;
d898528c 1473
24ac23ab
TM		 1474 if (task->tk_status == 0) {
1475 switch (data->o_res.f_attr->mode & S_IFMT) {
6f926b5b
TM		 1476 case S_IFREG:
1477 break;
1478 case S_IFLNK:
24ac23ab 1479 data->rpc_status = -ELOOP;
6f926b5b
TM		 1480 break;
1481 case S_IFDIR:
24ac23ab 1482 data->rpc_status = -EISDIR;
6f926b5b
TM		 1483 break;
1484 default:
24ac23ab 1485 data->rpc_status = -ENOTDIR;
6f926b5b 1486 }
26e976a8 1487 renew_lease(data->o_res.server, data->timestamp);
0f9f95e0
TM		 1488 if (!(data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM))
1489 nfs_confirm_seqid(&data->owner->so_seqid, 0);
6f926b5b 1490 }
3e309914 1491 data->rpc_done = 1;
24ac23ab 1492}
6f926b5b 1493
24ac23ab
TM		 1494static void nfs4_open_release(void *calldata)
1495{
1496 struct nfs4_opendata *data = calldata;
1497 struct nfs4_state *state = NULL;
1498
1499 /* If this request hasn't been cancelled, do nothing */
1500 if (data->cancelled == 0)
1501 goto out_free;
1502 /* In case of error, no cleanup! */
3e309914 1503 if (data->rpc_status != 0 || !data->rpc_done)
24ac23ab
TM		 1504 goto out_free;
1505 /* In case we need an open_confirm, no cleanup! */
1506 if (data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM)
1507 goto out_free;
24ac23ab 1508 state = nfs4_opendata_to_nfs4_state(data);
1b370bc2 1509 if (!IS_ERR(state))
643168c2 1510 nfs4_close_state(state, data->o_arg.fmode);
24ac23ab 1511out_free:
c6d00e63 1512 nfs4_opendata_put(data);
24ac23ab
TM		 1513}
1514
1515static const struct rpc_call_ops nfs4_open_ops = {
1516 .rpc_call_prepare = nfs4_open_prepare,
1517 .rpc_call_done = nfs4_open_done,
1518 .rpc_release = nfs4_open_release,
1519};
1520
b257957e
AB		 1521static const struct rpc_call_ops nfs4_recover_open_ops = {
1522 .rpc_call_prepare = nfs4_recover_open_prepare,
1523 .rpc_call_done = nfs4_open_done,
1524 .rpc_release = nfs4_open_release,
1525};
1526
1527static int nfs4_run_open_task(struct nfs4_opendata *data, int isrecover)
24ac23ab
TM		 1528{
1529 struct inode *dir = data->dir->d_inode;
1530 struct nfs_server *server = NFS_SERVER(dir);
1531 struct nfs_openargs *o_arg = &data->o_arg;
1532 struct nfs_openres *o_res = &data->o_res;
1533 struct rpc_task *task;
5138fde0
TM		 1534 struct rpc_message msg = {
1535 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN],
1536 .rpc_argp = o_arg,
1537 .rpc_resp = o_res,
1538 .rpc_cred = data->owner->so_cred,
1539 };
c970aa85
TM		 1540 struct rpc_task_setup task_setup_data = {
1541 .rpc_client = server->client,
5138fde0 1542 .rpc_message = &msg,
c970aa85
TM		 1543 .callback_ops = &nfs4_open_ops,
1544 .callback_data = data,
101070ca 1545 .workqueue = nfsiod_workqueue,
c970aa85
TM		 1546 .flags = RPC_TASK_ASYNC,
1547 };
24ac23ab
TM		 1548 int status;
1549
c6d00e63 1550 kref_get(&data->kref);
3e309914
TM		 1551 data->rpc_done = 0;
1552 data->rpc_status = 0;
2ced46c2 1553 data->cancelled = 0;
b257957e
AB		 1554 if (isrecover)
1555 task_setup_data.callback_ops = &nfs4_recover_open_ops;
c970aa85 1556 task = rpc_run_task(&task_setup_data);
b257957e
AB		 1557 if (IS_ERR(task))
1558 return PTR_ERR(task);
1559 status = nfs4_wait_for_completion_rpc_task(task);
1560 if (status != 0) {
1561 data->cancelled = 1;
1562 smp_wmb();
1563 } else
1564 status = data->rpc_status;
1565 rpc_put_task(task);
1566
1567 return status;
1568}
1569
1570static int _nfs4_recover_proc_open(struct nfs4_opendata *data)
1571{
1572 struct inode *dir = data->dir->d_inode;
1573 struct nfs_openres *o_res = &data->o_res;
1574 int status;
1575
1576 status = nfs4_run_open_task(data, 1);
1577 if (status != 0 || !data->rpc_done)
1578 return status;
1579
1580 nfs_refresh_inode(dir, o_res->dir_attr);
1581
1582 if (o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) {
1583 status = _nfs4_proc_open_confirm(data);
1584 if (status != 0)
1585 return status;
1586 }
1587
1588 return status;
1589}
1590
1591/*
1592 * Note: On error, nfs4_proc_open will free the struct nfs4_opendata
1593 */
1594static int _nfs4_proc_open(struct nfs4_opendata *data)
1595{
1596 struct inode *dir = data->dir->d_inode;
1597 struct nfs_server *server = NFS_SERVER(dir);
1598 struct nfs_openargs *o_arg = &data->o_arg;
1599 struct nfs_openres *o_res = &data->o_res;
1600 int status;
1601
1602 status = nfs4_run_open_task(data, 0);
08ef7bd3
TM		 1603 if (!data->rpc_done)
1604 return status;
1605 if (status != 0) {
1606 if (status == -NFS4ERR_BADNAME &&
1607 !(o_arg->open_flags & O_CREAT))
1608 return -ENOENT;
24ac23ab 1609 return status;
08ef7bd3 1610 }
24ac23ab 1611
56ae19f3
TM		 1612 if (o_arg->open_flags & O_CREAT) {
1613 update_changeattr(dir, &o_res->cinfo);
1614 nfs_post_op_update_inode(dir, o_res->dir_attr);
1615 } else
1616 nfs_refresh_inode(dir, o_res->dir_attr);
0df5dd4a
TM		 1617 if ((o_res->rflags & NFS4_OPEN_RESULT_LOCKTYPE_POSIX) == 0)
1618 server->caps &= ~NFS_CAP_POSIX_LOCK;
1da177e4 1619 if(o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) {
cdd4e68b 1620 status = _nfs4_proc_open_confirm(data);
1da177e4 1621 if (status != 0)
24ac23ab 1622 return status;
1da177e4
LT		 1623 }
1624 if (!(o_res->f_attr->valid & NFS_ATTR_FATTR))
9936781d 1625 _nfs4_proc_getattr(server, &o_res->fh, o_res->f_attr);
24ac23ab 1626 return 0;
1da177e4
LT		 1627}
1628
d83217c1 1629static int nfs4_client_recover_expired_lease(struct nfs_client *clp)
58d9714a 1630{
a78cb57a 1631 unsigned int loop;
6b30954e 1632 int ret;
58d9714a 1633
a78cb57a 1634 for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) {
65de872e 1635 ret = nfs4_wait_clnt_recover(clp);
6b30954e 1636 if (ret != 0)
a78cb57a 1637 break;
e598d843
TM		 1638 if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) &&
1639 !test_bit(NFS4CLNT_CHECK_LEASE,&clp->cl_state))
6b30954e 1640 break;
0400a6b0 1641 nfs4_schedule_state_manager(clp);
a78cb57a 1642 ret = -EIO;
6b30954e 1643 }
a78cb57a 1644 return ret;
58d9714a
TM		 1645}
1646
d83217c1
AA		 1647static int nfs4_recover_expired_lease(struct nfs_server *server)
1648{
1649 return nfs4_client_recover_expired_lease(server->nfs_client);
1650}
1651
1da177e4
LT		 1652/*
1653 * OPEN_EXPIRED:
1654 * reclaim state on the server after a network partition.
1655 * Assumes caller holds the appropriate lock
1656 */
539cd03a 1657static int _nfs4_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state)
1da177e4 1658{
e56e0b78 1659 struct nfs4_opendata *opendata;
864472e9 1660 int ret;
1da177e4 1661
6f220ed5
TM		 1662 opendata = nfs4_open_recoverdata_alloc(ctx, state);
1663 if (IS_ERR(opendata))
1664 return PTR_ERR(opendata);
864472e9 1665 ret = nfs4_open_recover(opendata, state);
35d05778 1666 if (ret == -ESTALE)
3d4ff43d 1667 d_drop(ctx->dentry);
c6d00e63 1668 nfs4_opendata_put(opendata);
864472e9 1669 return ret;
1da177e4
LT		 1670}
1671
a9ed2e25 1672static int nfs4_do_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state)
202b50dc 1673{
539cd03a 1674 struct nfs_server *server = NFS_SERVER(state->inode);
202b50dc
TM		 1675 struct nfs4_exception exception = { };
1676 int err;
1677
1678 do {
539cd03a 1679 err = _nfs4_open_expired(ctx, state);
a9ed2e25
TM		 1680 switch (err) {
1681 default:
1682 goto out;
1683 case -NFS4ERR_GRACE:
1684 case -NFS4ERR_DELAY:
1685 nfs4_handle_exception(server, err, &exception);
1686 err = 0;
1687 }
202b50dc 1688 } while (exception.retry);
a9ed2e25 1689out:
202b50dc
TM		 1690 return err;
1691}
1692
1da177e4
LT		 1693static int nfs4_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)
1694{
1da177e4 1695 struct nfs_open_context *ctx;
864472e9 1696 int ret;
1da177e4 1697
864472e9
TM		 1698 ctx = nfs4_state_find_open_context(state);
1699 if (IS_ERR(ctx))
1700 return PTR_ERR(ctx);
539cd03a 1701 ret = nfs4_do_open_expired(ctx, state);
864472e9
TM		 1702 put_nfs_open_context(ctx);
1703 return ret;
1da177e4
LT		 1704}
1705
f062eb6c
BS		 1706#if defined(CONFIG_NFS_V4_1)
1707static int nfs41_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)
1708{
1709 int status;
1710 struct nfs_server *server = NFS_SERVER(state->inode);
1711
1712 status = nfs41_test_stateid(server, state);
1713 if (status == NFS_OK)
1714 return 0;
1715 nfs41_free_stateid(server, state);
1716 return nfs4_open_expired(sp, state);
1717}
1718#endif
1719
aa53ed54
JL		 1720/*
1721 * on an EXCLUSIVE create, the server should send back a bitmask with FATTR4-*
1722 * fields corresponding to attributes that were used to store the verifier.
1723 * Make sure we clobber those fields in the later setattr call
1724 */
1725static inline void nfs4_exclusive_attrset(struct nfs4_opendata *opendata, struct iattr *sattr)
1726{
1727 if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_ACCESS) &&
1728 !(sattr->ia_valid & ATTR_ATIME_SET))
1729 sattr->ia_valid |= ATTR_ATIME;
1730
1731 if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_MODIFY) &&
1732 !(sattr->ia_valid & ATTR_MTIME_SET))
1733 sattr->ia_valid |= ATTR_MTIME;
1734}
1735
1da177e4 1736/*
24ac23ab 1737 * Returns a referenced nfs4_state
1da177e4 1738 */
82a2c1b7 1739static int _nfs4_do_open(struct inode *dir, struct dentry *dentry, fmode_t fmode, int flags, struct iattr *sattr, struct rpc_cred *cred, struct nfs4_state **res)
1da177e4
LT		 1740{
1741 struct nfs4_state_owner *sp;
1742 struct nfs4_state *state = NULL;
1743 struct nfs_server *server = NFS_SERVER(dir);
e56e0b78 1744 struct nfs4_opendata *opendata;
aac00a8d 1745 int status;
1da177e4
LT		 1746
1747 /* Protect against reboot recovery conflicts */
1da177e4
LT		 1748 status = -ENOMEM;
1749 if (!(sp = nfs4_get_state_owner(server, cred))) {
1750 dprintk("nfs4_do_open: nfs4_get_state_owner failed!\n");
1751 goto out_err;
1752 }
58d9714a
TM		 1753 status = nfs4_recover_expired_lease(server);
1754 if (status != 0)
b4454fe1 1755 goto err_put_state_owner;
82a2c1b7
AV		 1756 if (dentry->d_inode != NULL)
1757 nfs4_return_incompatible_delegation(dentry->d_inode, fmode);
58d9714a 1758 status = -ENOMEM;
82a2c1b7 1759 opendata = nfs4_opendata_alloc(dentry, sp, fmode, flags, sattr, GFP_KERNEL);
e56e0b78 1760 if (opendata == NULL)
95d35cb4 1761 goto err_put_state_owner;
1da177e4 1762
82a2c1b7
AV		 1763 if (dentry->d_inode != NULL)
1764 opendata->state = nfs4_get_open_state(dentry->d_inode, sp);
aac00a8d 1765
24ac23ab 1766 status = _nfs4_proc_open(opendata);
1da177e4 1767 if (status != 0)
c6d00e63 1768 goto err_opendata_put;
1da177e4 1769
24ac23ab 1770 state = nfs4_opendata_to_nfs4_state(opendata);
1b370bc2
TM		 1771 status = PTR_ERR(state);
1772 if (IS_ERR(state))
c6d00e63 1773 goto err_opendata_put;
0df5dd4a 1774 if (server->caps & NFS_CAP_POSIX_LOCK)
8e469ebd 1775 set_bit(NFS_STATE_POSIX_LOCKS, &state->flags);
0ab64e0e
TM		 1776
1777 if (opendata->o_arg.open_flags & O_EXCL) {
1778 nfs4_exclusive_attrset(opendata, sattr);
1779
1780 nfs_fattr_init(opendata->o_res.f_attr);
1781 status = nfs4_do_setattr(state->inode, cred,
1782 opendata->o_res.f_attr, sattr,
1783 state);
1784 if (status == 0)
1785 nfs_setattr_update_inode(state->inode, sattr);
1786 nfs_post_op_update_inode(state->inode, opendata->o_res.f_attr);
1787 }
c6d00e63 1788 nfs4_opendata_put(opendata);
1da177e4 1789 nfs4_put_state_owner(sp);
1da177e4
LT		 1790 *res = state;
1791 return 0;
c6d00e63
TM		 1792err_opendata_put:
1793 nfs4_opendata_put(opendata);
e56e0b78
TM		 1794err_put_state_owner:
1795 nfs4_put_state_owner(sp);
1da177e4 1796out_err:
1da177e4
LT		 1797 *res = NULL;
1798 return status;
1799}
1800
1801
82a2c1b7 1802static struct nfs4_state *nfs4_do_open(struct inode *dir, struct dentry *dentry, fmode_t fmode, int flags, struct iattr *sattr, struct rpc_cred *cred)
1da177e4
LT		 1803{
1804 struct nfs4_exception exception = { };
1805 struct nfs4_state *res;
1806 int status;
1807
1808 do {
82a2c1b7 1809 status = _nfs4_do_open(dir, dentry, fmode, flags, sattr, cred, &res);
1da177e4
LT		 1810 if (status == 0)
1811 break;
1812 /* NOTE: BAD_SEQID means the server and client disagree about the
1813 * book-keeping w.r.t. state-changing operations
1814 * (OPEN/CLOSE/LOCK/LOCKU...)
1815 * It is actually a sign of a bug on the client or on the server.
1816 *
1817 * If we receive a BAD_SEQID error in the particular case of
cee54fc9 1818 * doing an OPEN, we assume that nfs_increment_open_seqid() will
1da177e4
LT		 1819 * have unhashed the old state_owner for us, and that we can
1820 * therefore safely retry using a new one. We should still warn
1821 * the user though...
1822 */
1823 if (status == -NFS4ERR_BAD_SEQID) {
6f43ddcc
TM		 1824 printk(KERN_WARNING "NFS: v4 server %s "
1825 " returned a bad sequence-id error!\n",
1826 NFS_SERVER(dir)->nfs_client->cl_hostname);
1da177e4
LT		 1827 exception.retry = 1;
1828 continue;
1829 }
550f5747
TM		 1830 /*
1831 * BAD_STATEID on OPEN means that the server cancelled our
1832 * state before it received the OPEN_CONFIRM.
1833 * Recover by retrying the request as per the discussion
1834 * on Page 181 of RFC3530.
1835 */
1836 if (status == -NFS4ERR_BAD_STATEID) {
1837 exception.retry = 1;
1838 continue;
1839 }
aac00a8d
TM		 1840 if (status == -EAGAIN) {
1841 /* We must have found a delegation */
1842 exception.retry = 1;
1843 continue;
1844 }
1da177e4
LT		 1845 res = ERR_PTR(nfs4_handle_exception(NFS_SERVER(dir),
1846 status, &exception));
1847 } while (exception.retry);
1848 return res;
1849}
1850
659bfcd6
TM		 1851static int _nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
1852 struct nfs_fattr *fattr, struct iattr *sattr,
1853 struct nfs4_state *state)
1da177e4 1854{
3e4f6290 1855 struct nfs_server *server = NFS_SERVER(inode);
1da177e4 1856 struct nfs_setattrargs arg = {
3e4f6290 1857 .fh = NFS_FH(inode),
1da177e4
LT		 1858 .iap = sattr,
1859 .server = server,
1860 .bitmask = server->attr_bitmask,
1861 };
1862 struct nfs_setattrres res = {
1863 .fattr = fattr,
1864 .server = server,
1865 };
1866 struct rpc_message msg = {
659bfcd6
TM		 1867 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETATTR],
1868 .rpc_argp = &arg,
1869 .rpc_resp = &res,
1870 .rpc_cred = cred,
1da177e4 1871 };
26e976a8 1872 unsigned long timestamp = jiffies;
65e4308d 1873 int status;
1da177e4 1874
0e574af1 1875 nfs_fattr_init(fattr);
1da177e4 1876
3e4f6290
TM		 1877 if (nfs4_copy_delegation_stateid(&arg.stateid, inode)) {
1878 /* Use that stateid */
1879 } else if (state != NULL) {
77041ed9 1880 nfs4_copy_stateid(&arg.stateid, state, current->files, current->tgid);
08e9eac4 1881 } else
1da177e4
LT		 1882 memcpy(&arg.stateid, &zero_stateid, sizeof(arg.stateid));
1883
7c513058 1884 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
26e976a8
TM		 1885 if (status == 0 && state != NULL)
1886 renew_lease(server, timestamp);
65e4308d 1887 return status;
1da177e4
LT		 1888}
1889
659bfcd6
TM		 1890static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
1891 struct nfs_fattr *fattr, struct iattr *sattr,
1892 struct nfs4_state *state)
1da177e4 1893{
3e4f6290 1894 struct nfs_server *server = NFS_SERVER(inode);
1da177e4
LT		 1895 struct nfs4_exception exception = { };
1896 int err;
1897 do {
1898 err = nfs4_handle_exception(server,
659bfcd6 1899 _nfs4_do_setattr(inode, cred, fattr, sattr, state),
1da177e4
LT		 1900 &exception);
1901 } while (exception.retry);
1902 return err;
1903}
1904
1905struct nfs4_closedata {
1906 struct inode *inode;
1907 struct nfs4_state *state;
1908 struct nfs_closeargs arg;
1909 struct nfs_closeres res;
516a6af6 1910 struct nfs_fattr fattr;
26e976a8 1911 unsigned long timestamp;
f7e8917a
FI		 1912 bool roc;
1913 u32 roc_barrier;
1da177e4
LT		 1914};
1915
963d8fe5 1916static void nfs4_free_closedata(void *data)
9512135d 1917{
963d8fe5
TM		 1918 struct nfs4_closedata *calldata = data;
1919 struct nfs4_state_owner *sp = calldata->state->owner;
643168c2 1920 struct super_block *sb = calldata->state->inode->i_sb;
9512135d 1921
f7e8917a
FI		 1922 if (calldata->roc)
1923 pnfs_roc_release(calldata->state->inode);
9512135d
TM		 1924 nfs4_put_open_state(calldata->state);
1925 nfs_free_seqid(calldata->arg.seqid);
9512135d 1926 nfs4_put_state_owner(sp);
643168c2 1927 nfs_sb_deactive(sb);
9512135d
TM		 1928 kfree(calldata);
1929}
1930
88069f77
TM		 1931static void nfs4_close_clear_stateid_flags(struct nfs4_state *state,
1932 fmode_t fmode)
1933{
1934 spin_lock(&state->owner->so_lock);
1935 if (!(fmode & FMODE_READ))
1936 clear_bit(NFS_O_RDONLY_STATE, &state->flags);
1937 if (!(fmode & FMODE_WRITE))
1938 clear_bit(NFS_O_WRONLY_STATE, &state->flags);
1939 clear_bit(NFS_O_RDWR_STATE, &state->flags);
1940 spin_unlock(&state->owner->so_lock);
1941}
1942
963d8fe5 1943static void nfs4_close_done(struct rpc_task *task, void *data)
1da177e4 1944{
963d8fe5 1945 struct nfs4_closedata *calldata = data;
1da177e4 1946 struct nfs4_state *state = calldata->state;
1da177e4
LT		 1947 struct nfs_server *server = NFS_SERVER(calldata->inode);
1948
14516c3a
TM		 1949 if (!nfs4_sequence_done(task, &calldata->res.seq_res))
1950 return;
1da177e4
LT		 1951 /* hmm. we are done with the inode, and in the process of freeing
1952 * the state_owner. we keep this around to process errors
1953 */
1da177e4
LT		 1954 switch (task->tk_status) {
1955 case 0:
f7e8917a
FI		 1956 if (calldata->roc)
1957 pnfs_roc_set_barrier(state->inode,
1958 calldata->roc_barrier);
45328c35 1959 nfs_set_open_stateid(state, &calldata->res.stateid, 0);
26e976a8 1960 renew_lease(server, calldata->timestamp);
88069f77
TM		 1961 nfs4_close_clear_stateid_flags(state,
1962 calldata->arg.fmode);
1da177e4
LT		 1963 break;
1964 case -NFS4ERR_STALE_STATEID:
9e33bed5
TM		 1965 case -NFS4ERR_OLD_STATEID:
1966 case -NFS4ERR_BAD_STATEID:
1da177e4 1967 case -NFS4ERR_EXPIRED:
dc0b027d 1968 if (calldata->arg.fmode == 0)
9e33bed5 1969 break;
1da177e4 1970 default:
72211dbe
TM		 1971 if (nfs4_async_handle_error(task, server, state) == -EAGAIN)
1972 rpc_restart_call_prepare(task);
1da177e4 1973 }
72211dbe 1974 nfs_release_seqid(calldata->arg.seqid);
516a6af6 1975 nfs_refresh_inode(calldata->inode, calldata->res.fattr);
1da177e4
LT		 1976}
1977
4ce70ada 1978static void nfs4_close_prepare(struct rpc_task *task, void *data)
1da177e4 1979{
4ce70ada 1980 struct nfs4_closedata *calldata = data;
9512135d 1981 struct nfs4_state *state = calldata->state;
88069f77 1982 int call_close = 0;
9512135d 1983
963d8fe5 1984 if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
9512135d 1985 return;
003707c7 1986
88069f77
TM		 1987 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE];
1988 calldata->arg.fmode = FMODE_READ|FMODE_WRITE;
4cecb76f 1989 spin_lock(&state->owner->so_lock);
003707c7 1990 /* Calculate the change in open mode */
e7616923 1991 if (state->n_rdwr == 0) {
003707c7 1992 if (state->n_rdonly == 0) {
88069f77
TM		 1993 call_close |= test_bit(NFS_O_RDONLY_STATE, &state->flags);
1994 call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);
1995 calldata->arg.fmode &= ~FMODE_READ;
003707c7
TM		 1996 }
1997 if (state->n_wronly == 0) {
88069f77
TM		 1998 call_close |= test_bit(NFS_O_WRONLY_STATE, &state->flags);
1999 call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);
2000 calldata->arg.fmode &= ~FMODE_WRITE;
003707c7 2001 }
e7616923 2002 }
4cecb76f 2003 spin_unlock(&state->owner->so_lock);
88069f77
TM		 2004
2005 if (!call_close) {
963d8fe5
TM		 2006 /* Note: exit _without_ calling nfs4_close_done */
2007 task->tk_action = NULL;
9512135d
TM		 2008 return;
2009 }
88069f77 2010
f7e8917a 2011 if (calldata->arg.fmode == 0) {
88069f77 2012 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE];
f7e8917a
FI		 2013 if (calldata->roc &&
2014 pnfs_roc_drain(calldata->inode, &calldata->roc_barrier)) {
2015 rpc_sleep_on(&NFS_SERVER(calldata->inode)->roc_rpcwaitq,
2016 task, NULL);
2017 return;
2018 }
2019 }
88069f77 2020
516a6af6 2021 nfs_fattr_init(calldata->res.fattr);
26e976a8 2022 calldata->timestamp = jiffies;
035168ab 2023 if (nfs4_setup_sequence(NFS_SERVER(calldata->inode),
19ddab06
AA		 2024 &calldata->arg.seq_args, &calldata->res.seq_res,
2025 1, task))
2026 return;
5138fde0 2027 rpc_call_start(task);
1da177e4
LT		 2028}
2029
963d8fe5 2030static const struct rpc_call_ops nfs4_close_ops = {
4ce70ada 2031 .rpc_call_prepare = nfs4_close_prepare,
963d8fe5
TM		 2032 .rpc_call_done = nfs4_close_done,
2033 .rpc_release = nfs4_free_closedata,
2034};
2035
1da177e4
LT		 2036/*
2037 * It is possible for data to be read/written from a mem-mapped file
2038 * after the sys_close call (which hits the vfs layer as a flush).
2039 * This means that we can't safely call nfsv4 close on a file until
2040 * the inode is cleared. This in turn means that we are not good
2041 * NFSv4 citizens - we do not indicate to the server to update the file's
2042 * share state even when we are done with one of the three share
2043 * stateid's in the inode.
2044 *
2045 * NOTE: Caller must be holding the sp->so_owner semaphore!
2046 */
643168c2 2047int nfs4_do_close(struct nfs4_state *state, gfp_t gfp_mask, int wait, bool roc)
1da177e4 2048{
4a35bd41 2049 struct nfs_server *server = NFS_SERVER(state->inode);
1da177e4 2050 struct nfs4_closedata *calldata;
b39e625b
TM		 2051 struct nfs4_state_owner *sp = state->owner;
2052 struct rpc_task *task;
5138fde0
TM		 2053 struct rpc_message msg = {
2054 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE],
2055 .rpc_cred = state->owner->so_cred,
2056 };
c970aa85
TM		 2057 struct rpc_task_setup task_setup_data = {
2058 .rpc_client = server->client,
5138fde0 2059 .rpc_message = &msg,
c970aa85 2060 .callback_ops = &nfs4_close_ops,
101070ca 2061 .workqueue = nfsiod_workqueue,
c970aa85
TM		 2062 .flags = RPC_TASK_ASYNC,
2063 };
9512135d 2064 int status = -ENOMEM;
1da177e4 2065
8535b2be 2066 calldata = kzalloc(sizeof(*calldata), gfp_mask);
1da177e4 2067 if (calldata == NULL)
9512135d 2068 goto out;
4a35bd41 2069 calldata->inode = state->inode;
1da177e4 2070 calldata->state = state;
4a35bd41 2071 calldata->arg.fh = NFS_FH(state->inode);
003707c7 2072 calldata->arg.stateid = &state->open_stateid;
1da177e4 2073 /* Serialization for the sequence id */
8535b2be 2074 calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid, gfp_mask);
9512135d
TM		 2075 if (calldata->arg.seqid == NULL)
2076 goto out_free_calldata;
dc0b027d 2077 calldata->arg.fmode = 0;
a65318bf 2078 calldata->arg.bitmask = server->cache_consistency_bitmask;
516a6af6 2079 calldata->res.fattr = &calldata->fattr;
c1d51931 2080 calldata->res.seqid = calldata->arg.seqid;
516a6af6 2081 calldata->res.server = server;
f7e8917a 2082 calldata->roc = roc;
643168c2 2083 nfs_sb_active(calldata->inode->i_sb);
9512135d 2084
1174dd1f
TM		 2085 msg.rpc_argp = &calldata->arg;
2086 msg.rpc_resp = &calldata->res;
c970aa85
TM		 2087 task_setup_data.callback_data = calldata;
2088 task = rpc_run_task(&task_setup_data);
b39e625b
TM		 2089 if (IS_ERR(task))
2090 return PTR_ERR(task);
a49c3c77
TM		 2091 status = 0;
2092 if (wait)
2093 status = rpc_wait_for_completion_task(task);
b39e625b 2094 rpc_put_task(task);
a49c3c77 2095 return status;
9512135d
TM		 2096out_free_calldata:
2097 kfree(calldata);
2098out:
f7e8917a
FI		 2099 if (roc)
2100 pnfs_roc_release(state->inode);
b39e625b
TM		 2101 nfs4_put_open_state(state);
2102 nfs4_put_state_owner(sp);
9512135d 2103 return status;
1da177e4
LT		 2104}
2105
2b484297 2106static struct inode *
cd9a1c0e 2107nfs4_atomic_open(struct inode *dir, struct nfs_open_context *ctx, int open_flags, struct iattr *attr)
1da177e4 2108{
1da177e4 2109 struct nfs4_state *state;
1da177e4 2110
565277f6 2111 /* Protect against concurrent sillydeletes */
3d4ff43d 2112 state = nfs4_do_open(dir, ctx->dentry, ctx->mode, open_flags, attr, ctx->cred);
f46e0bd3
TM		 2113 if (IS_ERR(state))
2114 return ERR_CAST(state);
cd9a1c0e 2115 ctx->state = state;
f46e0bd3 2116 return igrab(state->inode);
1da177e4
LT		 2117}
2118
1185a552 2119static void nfs4_close_context(struct nfs_open_context *ctx, int is_sync)
7fe5c398
TM		 2120{
2121 if (ctx->state == NULL)
2122 return;
2123 if (is_sync)
643168c2 2124 nfs4_close_sync(ctx->state, ctx->mode);
7fe5c398 2125 else
643168c2 2126 nfs4_close_state(ctx->state, ctx->mode);
7fe5c398 2127}
1da177e4
LT		 2128
2129static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
2130{
43652ad5
BH		 2131 struct nfs4_server_caps_arg args = {
2132 .fhandle = fhandle,
2133 };
1da177e4
LT		 2134 struct nfs4_server_caps_res res = {};
2135 struct rpc_message msg = {
2136 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SERVER_CAPS],
43652ad5 2137 .rpc_argp = &args,
1da177e4
LT		 2138 .rpc_resp = &res,
2139 };
2140 int status;
2141
7c513058 2142 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
1da177e4
LT		 2143 if (status == 0) {
2144 memcpy(server->attr_bitmask, res.attr_bitmask, sizeof(server->attr_bitmask));
62ab460c
TM		 2145 server->caps &= ~(NFS_CAP_ACLS|NFS_CAP_HARDLINKS|
2146 NFS_CAP_SYMLINKS|NFS_CAP_FILEID|
2147 NFS_CAP_MODE|NFS_CAP_NLINK|NFS_CAP_OWNER|
2148 NFS_CAP_OWNER_GROUP|NFS_CAP_ATIME|
2149 NFS_CAP_CTIME|NFS_CAP_MTIME);
1da177e4
LT		 2150 if (res.attr_bitmask[0] & FATTR4_WORD0_ACL)
2151 server->caps |= NFS_CAP_ACLS;
2152 if (res.has_links != 0)
2153 server->caps |= NFS_CAP_HARDLINKS;
2154 if (res.has_symlinks != 0)
2155 server->caps |= NFS_CAP_SYMLINKS;
62ab460c
TM		 2156 if (res.attr_bitmask[0] & FATTR4_WORD0_FILEID)
2157 server->caps |= NFS_CAP_FILEID;
2158 if (res.attr_bitmask[1] & FATTR4_WORD1_MODE)
2159 server->caps |= NFS_CAP_MODE;
2160 if (res.attr_bitmask[1] & FATTR4_WORD1_NUMLINKS)
2161 server->caps |= NFS_CAP_NLINK;
2162 if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER)
2163 server->caps |= NFS_CAP_OWNER;
2164 if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER_GROUP)
2165 server->caps |= NFS_CAP_OWNER_GROUP;
2166 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_ACCESS)
2167 server->caps |= NFS_CAP_ATIME;
2168 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_METADATA)
2169 server->caps |= NFS_CAP_CTIME;
2170 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_MODIFY)
2171 server->caps |= NFS_CAP_MTIME;
2172
a65318bf
TM		 2173 memcpy(server->cache_consistency_bitmask, res.attr_bitmask, sizeof(server->cache_consistency_bitmask));
2174 server->cache_consistency_bitmask[0] &= FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE;
2175 server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY;
1da177e4
LT		 2176 server->acl_bitmask = res.acl_bitmask;
2177 }
cccef3b9 2178
1da177e4
LT		 2179 return status;
2180}
2181
55a97593 2182int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
1da177e4
LT		 2183{
2184 struct nfs4_exception exception = { };
2185 int err;
2186 do {
2187 err = nfs4_handle_exception(server,
2188 _nfs4_server_capabilities(server, fhandle),
2189 &exception);
2190 } while (exception.retry);
2191 return err;
2192}
2193
2194static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
2195 struct nfs_fsinfo *info)
2196{
1da177e4
LT		 2197 struct nfs4_lookup_root_arg args = {
2198 .bitmask = nfs4_fattr_bitmap,
2199 };
2200 struct nfs4_lookup_res res = {
2201 .server = server,
0e574af1 2202 .fattr = info->fattr,
1da177e4
LT		 2203 .fh = fhandle,
2204 };
2205 struct rpc_message msg = {
2206 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP_ROOT],
2207 .rpc_argp = &args,
2208 .rpc_resp = &res,
2209 };
008f55d0 2210
0e574af1 2211 nfs_fattr_init(info->fattr);
7c513058 2212 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
1da177e4
LT		 2213}
2214
2215static int nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
2216 struct nfs_fsinfo *info)
2217{
2218 struct nfs4_exception exception = { };
2219 int err;
2220 do {
fb8a5ba8
BS		 2221 err = _nfs4_lookup_root(server, fhandle, info);
2222 switch (err) {
2223 case 0:
2224 case -NFS4ERR_WRONGSEC:
2225 break;
2226 default:
2227 err = nfs4_handle_exception(server, err, &exception);
2228 }
1da177e4
LT		 2229 } while (exception.retry);
2230 return err;
2231}
2232
8f70e95f
BS		 2233static int nfs4_lookup_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
2234 struct nfs_fsinfo *info, rpc_authflavor_t flavor)
2235{
2236 struct rpc_auth *auth;
2237 int ret;
2238
2239 auth = rpcauth_create(flavor, server->client);
2240 if (!auth) {
2241 ret = -EIO;
2242 goto out;
2243 }
2244 ret = nfs4_lookup_root(server, fhandle, info);
8f70e95f
BS		 2245out:
2246 return ret;
2247}
2248
801a16dc 2249static int nfs4_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
54ceac45 2250 struct nfs_fsinfo *info)
1da177e4 2251{
8f70e95f 2252 int i, len, status = 0;
0fabee24 2253 rpc_authflavor_t flav_array[NFS_MAX_SECFLAVORS];
1da177e4 2254
801a16dc
BS		 2255 len = gss_mech_list_pseudoflavors(&flav_array[0]);
2256 flav_array[len] = RPC_AUTH_NULL;
2257 len += 1;
8f70e95f
BS		 2258
2259 for (i = 0; i < len; i++) {
2260 status = nfs4_lookup_root_sec(server, fhandle, info, flav_array[i]);
fb8a5ba8 2261 if (status == -NFS4ERR_WRONGSEC || status == -EACCES)
d1a8016a
BS		 2262 continue;
2263 break;
8f70e95f 2264 }
fb8a5ba8
BS		 2265 /*
2266 * -EACCESS could mean that the user doesn't have correct permissions
2267 * to access the mount. It could also mean that we tried to mount
2268 * with a gss auth flavor, but rpc.gssd isn't running. Either way,
2269 * existing mount programs don't handle -EACCES very well so it should
2270 * be mapped to -EPERM instead.
2271 */
2272 if (status == -EACCES)
2273 status = -EPERM;
801a16dc
BS		 2274 return status;
2275}
2276
2277/*
2278 * get the file handle for the "/" directory on the server
2279 */
2280static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
2281 struct nfs_fsinfo *info)
2282{
fca78d6d 2283 int minor_version = server->nfs_client->cl_minorversion;
801a16dc 2284 int status = nfs4_lookup_root(server, fhandle, info);
fb8a5ba8
BS		 2285 if ((status == -NFS4ERR_WRONGSEC) && !(server->flags & NFS_MOUNT_SECFLAVOUR))
2286 /*
2287 * A status of -NFS4ERR_WRONGSEC will be mapped to -EPERM
2288 * by nfs4_map_errors() as this function exits.
2289 */
fca78d6d 2290 status = nfs_v4_minor_ops[minor_version]->find_root_sec(server, fhandle, info);
1da177e4
LT		 2291 if (status == 0)
2292 status = nfs4_server_capabilities(server, fhandle);
2293 if (status == 0)
2294 status = nfs4_do_fsinfo(server, fhandle, info);
c12e87f4 2295 return nfs4_map_errors(status);
1da177e4
LT		 2296}
2297
533eb461 2298static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr);
6b97fd3d
MN		 2299/*
2300 * Get locations and (maybe) other attributes of a referral.
2301 * Note that we'll actually follow the referral later when
2302 * we detect fsid mismatch in inode revalidation
2303 */
533eb461
AA		 2304static int nfs4_get_referral(struct inode *dir, const struct qstr *name,
2305 struct nfs_fattr *fattr, struct nfs_fh *fhandle)
6b97fd3d
MN		 2306{
2307 int status = -ENOMEM;
2308 struct page *page = NULL;
2309 struct nfs4_fs_locations *locations = NULL;
6b97fd3d
MN		 2310
2311 page = alloc_page(GFP_KERNEL);
2312 if (page == NULL)
2313 goto out;
2314 locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
2315 if (locations == NULL)
2316 goto out;
2317
c228fd3a 2318 status = nfs4_proc_fs_locations(dir, name, locations, page);
6b97fd3d
MN		 2319 if (status != 0)
2320 goto out;
2321 /* Make sure server returned a different fsid for the referral */
2322 if (nfs_fsid_equal(&NFS_SERVER(dir)->fsid, &locations->fattr.fsid)) {
533eb461
AA		 2323 dprintk("%s: server did not return a different fsid for"
2324 " a referral at %s\n", __func__, name->name);
6b97fd3d
MN		 2325 status = -EIO;
2326 goto out;
2327 }
533eb461
AA		 2328 /* Fixup attributes for the nfs_lookup() call to nfs_fhget() */
2329 nfs_fixup_referral_attributes(&locations->fattr);
6b97fd3d 2330
533eb461 2331 /* replace the lookup nfs_fattr with the locations nfs_fattr */
6b97fd3d 2332 memcpy(fattr, &locations->fattr, sizeof(struct nfs_fattr));
6b97fd3d
MN		 2333 memset(fhandle, 0, sizeof(struct nfs_fh));
2334out:
2335 if (page)
2336 __free_page(page);
5d7ca35a 2337 kfree(locations);
6b97fd3d
MN		 2338 return status;
2339}
2340
1da177e4
LT		 2341static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr)
2342{
2343 struct nfs4_getattr_arg args = {
2344 .fh = fhandle,
2345 .bitmask = server->attr_bitmask,
2346 };
2347 struct nfs4_getattr_res res = {
2348 .fattr = fattr,
2349 .server = server,
2350 };
2351 struct rpc_message msg = {
2352 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETATTR],
2353 .rpc_argp = &args,
2354 .rpc_resp = &res,
2355 };
2356
0e574af1 2357 nfs_fattr_init(fattr);
7c513058 2358 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
1da177e4
LT		 2359}
2360
2361static int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr)
2362{
2363 struct nfs4_exception exception = { };
2364 int err;
2365 do {
2366 err = nfs4_handle_exception(server,
2367 _nfs4_proc_getattr(server, fhandle, fattr),
2368 &exception);
2369 } while (exception.retry);
2370 return err;
2371}
2372
2373/*
2374 * The file is not closed if it is opened due to the a request to change
2375 * the size of the file. The open call will not be needed once the
2376 * VFS layer lookup-intents are implemented.
2377 *
2378 * Close is called when the inode is destroyed.
2379 * If we haven't opened the file for O_WRONLY, we
2380 * need to in the size_change case to obtain a stateid.
2381 *
2382 * Got race?
2383 * Because OPEN is always done by name in nfsv4, it is
2384 * possible that we opened a different file by the same
2385 * name. We can recognize this race condition, but we
2386 * can't do anything about it besides returning an error.
2387 *
2388 * This will be fixed with VFS changes (lookup-intent).
2389 */
2390static int
2391nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
2392 struct iattr *sattr)
2393{
08e9eac4 2394 struct inode *inode = dentry->d_inode;
659bfcd6 2395 struct rpc_cred *cred = NULL;
d530838b 2396 struct nfs4_state *state = NULL;
1da177e4
LT		 2397 int status;
2398
8a1636c4
BH		 2399 if (pnfs_ld_layoutret_on_setattr(inode))
2400 pnfs_return_layout(inode);
2401
0e574af1 2402 nfs_fattr_init(fattr);
1da177e4 2403
d530838b 2404 /* Search for an existing open(O_WRITE) file */
659bfcd6
TM		 2405 if (sattr->ia_valid & ATTR_FILE) {
2406 struct nfs_open_context *ctx;
2407
2408 ctx = nfs_file_open_context(sattr->ia_file);
504e5189
NB		 2409 if (ctx) {
2410 cred = ctx->cred;
2411 state = ctx->state;
2412 }
659bfcd6 2413 }
08e9eac4 2414
659bfcd6 2415 status = nfs4_do_setattr(inode, cred, fattr, sattr, state);
65e4308d
TM		 2416 if (status == 0)
2417 nfs_setattr_update_inode(inode, sattr);
1da177e4
LT		 2418 return status;
2419}
2420
0c2e53f1
TM		 2421static int _nfs4_proc_lookup(struct rpc_clnt *clnt, struct inode *dir,
2422 const struct qstr *name, struct nfs_fh *fhandle,
2423 struct nfs_fattr *fattr)
2b3de441 2424{
0c2e53f1 2425 struct nfs_server *server = NFS_SERVER(dir);
2b3de441
DH		 2426 int status;
2427 struct nfs4_lookup_arg args = {
2428 .bitmask = server->attr_bitmask,
0c2e53f1 2429 .dir_fh = NFS_FH(dir),
2b3de441
DH		 2430 .name = name,
2431 };
2432 struct nfs4_lookup_res res = {
2433 .server = server,
2434 .fattr = fattr,
2435 .fh = fhandle,
2436 };
2437 struct rpc_message msg = {
2438 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP],
2439 .rpc_argp = &args,
2440 .rpc_resp = &res,
2441 };
2442
2443 nfs_fattr_init(fattr);
2444
1da177e4 2445 dprintk("NFS call lookup %s\n", name->name);
0c2e53f1 2446 status = nfs4_call_sync(clnt, server, &msg, &args.seq_args, &res.seq_res, 0);
1da177e4
LT		 2447 dprintk("NFS reply lookup: %d\n", status);
2448 return status;
2449}
2450
7ebb9315
BS		 2451void nfs_fixup_secinfo_attributes(struct nfs_fattr *fattr, struct nfs_fh *fh)
2452{
2453 memset(fh, 0, sizeof(struct nfs_fh));
2454 fattr->fsid.major = 1;
2455 fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE |
2456 NFS_ATTR_FATTR_NLINK | NFS_ATTR_FATTR_FSID | NFS_ATTR_FATTR_MOUNTPOINT;
2457 fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO;
2458 fattr->nlink = 2;
2459}
2460
7c513058
BS		 2461static int nfs4_proc_lookup(struct rpc_clnt *clnt, struct inode *dir, struct qstr *name,
2462 struct nfs_fh *fhandle, struct nfs_fattr *fattr)
1da177e4
LT		 2463{
2464 struct nfs4_exception exception = { };
2465 int err;
2466 do {
0c2e53f1
TM		 2467 int status;
2468
2469 status = _nfs4_proc_lookup(clnt, dir, name, fhandle, fattr);
2470 switch (status) {
08ef7bd3
TM		 2471 case -NFS4ERR_BADNAME:
2472 return -ENOENT;
0c2e53f1 2473 case -NFS4ERR_MOVED:
a6f498a8 2474 return nfs4_get_referral(dir, name, fattr, fhandle);
0c2e53f1 2475 case -NFS4ERR_WRONGSEC:
7ebb9315 2476 nfs_fixup_secinfo_attributes(fattr, fhandle);
0c2e53f1
TM		 2477 }
2478 err = nfs4_handle_exception(NFS_SERVER(dir),
2479 status, &exception);
1da177e4
LT		 2480 } while (exception.retry);
2481 return err;
2482}
2483
2484static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)
2485{
76b32999 2486 struct nfs_server *server = NFS_SERVER(inode);
1da177e4
LT		 2487 struct nfs4_accessargs args = {
2488 .fh = NFS_FH(inode),
76b32999
TM		 2489 .bitmask = server->attr_bitmask,
2490 };
2491 struct nfs4_accessres res = {
2492 .server = server,
1da177e4 2493 };
1da177e4
LT		 2494 struct rpc_message msg = {
2495 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ACCESS],
2496 .rpc_argp = &args,
2497 .rpc_resp = &res,
2498 .rpc_cred = entry->cred,
2499 };
2500 int mode = entry->mask;
2501 int status;
2502
2503 /*
2504 * Determine which access bits we want to ask for...
2505 */
2506 if (mode & MAY_READ)
2507 args.access |= NFS4_ACCESS_READ;
2508 if (S_ISDIR(inode->i_mode)) {
2509 if (mode & MAY_WRITE)
2510 args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE;
2511 if (mode & MAY_EXEC)
2512 args.access |= NFS4_ACCESS_LOOKUP;
2513 } else {
2514 if (mode & MAY_WRITE)
2515 args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND;
2516 if (mode & MAY_EXEC)
2517 args.access |= NFS4_ACCESS_EXECUTE;
2518 }
c407d41a
TM		 2519
2520 res.fattr = nfs_alloc_fattr();
2521 if (res.fattr == NULL)
2522 return -ENOMEM;
2523
7c513058 2524 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
1da177e4
LT		 2525 if (!status) {
2526 entry->mask = 0;
2527 if (res.access & NFS4_ACCESS_READ)
2528 entry->mask |= MAY_READ;
2529 if (res.access & (NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE))
2530 entry->mask |= MAY_WRITE;
2531 if (res.access & (NFS4_ACCESS_LOOKUP|NFS4_ACCESS_EXECUTE))
2532 entry->mask |= MAY_EXEC;
c407d41a 2533 nfs_refresh_inode(inode, res.fattr);
1da177e4 2534 }
c407d41a 2535 nfs_free_fattr(res.fattr);
1da177e4
LT		 2536 return status;
2537}
2538
2539static int nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)
2540{
2541 struct nfs4_exception exception = { };
2542 int err;
2543 do {
2544 err = nfs4_handle_exception(NFS_SERVER(inode),
2545 _nfs4_proc_access(inode, entry),
2546 &exception);
2547 } while (exception.retry);
2548 return err;
2549}
2550
2551/*
2552 * TODO: For the time being, we don't try to get any attributes
2553 * along with any of the zero-copy operations READ, READDIR,
2554 * READLINK, WRITE.
2555 *
2556 * In the case of the first three, we want to put the GETATTR
2557 * after the read-type operation -- this is because it is hard
2558 * to predict the length of a GETATTR response in v4, and thus
2559 * align the READ data correctly. This means that the GETATTR
2560 * may end up partially falling into the page cache, and we should
2561 * shift it into the 'tail' of the xdr_buf before processing.
2562 * To do this efficiently, we need to know the total length
2563 * of data received, which doesn't seem to be available outside
2564 * of the RPC layer.
2565 *
2566 * In the case of WRITE, we also want to put the GETATTR after
2567 * the operation -- in this case because we want to make sure
2568 * we get the post-operation mtime and size. This means that
2569 * we can't use xdr_encode_pages() as written: we need a variant
2570 * of it which would leave room in the 'tail' iovec.
2571 *
2572 * Both of these changes to the XDR layer would in fact be quite
2573 * minor, but I decided to leave them for a subsequent patch.
2574 */
2575static int _nfs4_proc_readlink(struct inode *inode, struct page *page,
2576 unsigned int pgbase, unsigned int pglen)
2577{
2578 struct nfs4_readlink args = {
2579 .fh = NFS_FH(inode),
2580 .pgbase = pgbase,
2581 .pglen = pglen,
2582 .pages = &page,
2583 };
f50c7000 2584 struct nfs4_readlink_res res;
1da177e4
LT		 2585 struct rpc_message msg = {
2586 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READLINK],
2587 .rpc_argp = &args,
f50c7000 2588 .rpc_resp = &res,
1da177e4
LT		 2589 };
2590
7c513058 2591 return nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode), &msg, &args.seq_args, &res.seq_res, 0);
1da177e4
LT		 2592}
2593
2594static int nfs4_proc_readlink(struct inode *inode, struct page *page,
2595 unsigned int pgbase, unsigned int pglen)
2596{
2597 struct nfs4_exception exception = { };
2598 int err;
2599 do {
2600 err = nfs4_handle_exception(NFS_SERVER(inode),
2601 _nfs4_proc_readlink(inode, page, pgbase, pglen),
2602 &exception);
2603 } while (exception.retry);
2604 return err;
2605}
2606
1da177e4
LT		 2607/*
2608 * Got race?
2609 * We will need to arrange for the VFS layer to provide an atomic open.
2610 * Until then, this create/open method is prone to inefficiency and race
2611 * conditions due to the lookup, create, and open VFS calls from sys_open()
2612 * placed on the wire.
2613 *
2614 * Given the above sorry state of affairs, I'm simply sending an OPEN.
2615 * The file will be opened again in the subsequent VFS open call
2616 * (nfs4_proc_file_open).
2617 *
2618 * The open for read will just hang around to be used by any process that
2619 * opens the file O_RDONLY. This will all be resolved with the VFS changes.
2620 */
2621
2622static int
2623nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
c0204fd2 2624 int flags, struct nfs_open_context *ctx)
1da177e4 2625{
82a2c1b7 2626 struct dentry *de = dentry;
1da177e4 2627 struct nfs4_state *state;
c0204fd2
TM		 2628 struct rpc_cred *cred = NULL;
2629 fmode_t fmode = 0;
1da177e4
LT		 2630 int status = 0;
2631
c0204fd2
TM		 2632 if (ctx != NULL) {
2633 cred = ctx->cred;
3d4ff43d 2634 de = ctx->dentry;
c0204fd2 2635 fmode = ctx->mode;
1da177e4 2636 }
a8a5da99 2637 sattr->ia_mode &= ~current_umask();
82a2c1b7 2638 state = nfs4_do_open(dir, de, fmode, flags, sattr, cred);
d4d9cdcb 2639 d_drop(dentry);
1da177e4
LT		 2640 if (IS_ERR(state)) {
2641 status = PTR_ERR(state);
c0204fd2 2642 goto out;
1da177e4 2643 }
d4d9cdcb 2644 d_add(dentry, igrab(state->inode));
d75340cc 2645 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
c0204fd2
TM		 2646 if (ctx != NULL)
2647 ctx->state = state;
02a913a7 2648 else
643168c2 2649 nfs4_close_sync(state, fmode);
1da177e4
LT		 2650out:
2651 return status;
2652}
2653
2654static int _nfs4_proc_remove(struct inode *dir, struct qstr *name)
2655{
16e42959 2656 struct nfs_server *server = NFS_SERVER(dir);
4fdc17b2 2657 struct nfs_removeargs args = {
1da177e4 2658 .fh = NFS_FH(dir),
4fdc17b2
TM		 2659 .name.len = name->len,
2660 .name.name = name->name,
16e42959
TM		 2661 .bitmask = server->attr_bitmask,
2662 };
4fdc17b2 2663 struct nfs_removeres res = {
16e42959 2664 .server = server,
1da177e4 2665 };
1da177e4 2666 struct rpc_message msg = {
4fdc17b2
TM		 2667 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE],
2668 .rpc_argp = &args,
2669 .rpc_resp = &res,
1da177e4 2670 };
d346890b
TM		 2671 int status = -ENOMEM;
2672
2673 res.dir_attr = nfs_alloc_fattr();
2674 if (res.dir_attr == NULL)
2675 goto out;
1da177e4 2676
7c513058 2677 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 1);
16e42959
TM		 2678 if (status == 0) {
2679 update_changeattr(dir, &res.cinfo);
d346890b 2680 nfs_post_op_update_inode(dir, res.dir_attr);
16e42959 2681 }
d346890b
TM		 2682 nfs_free_fattr(res.dir_attr);
2683out:
1da177e4
LT		 2684 return status;
2685}
2686
2687static int nfs4_proc_remove(struct inode *dir, struct qstr *name)
2688{
2689 struct nfs4_exception exception = { };
2690 int err;
2691 do {
2692 err = nfs4_handle_exception(NFS_SERVER(dir),
2693 _nfs4_proc_remove(dir, name),
2694 &exception);
2695 } while (exception.retry);
2696 return err;
2697}
2698
e4eff1a6 2699static void nfs4_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
1da177e4 2700{
e4eff1a6
TM		 2701 struct nfs_server *server = NFS_SERVER(dir);
2702 struct nfs_removeargs *args = msg->rpc_argp;
2703 struct nfs_removeres *res = msg->rpc_resp;
1da177e4 2704
a65318bf 2705 args->bitmask = server->cache_consistency_bitmask;
e4eff1a6 2706 res->server = server;
dfb4f309 2707 res->seq_res.sr_slot = NULL;
1da177e4 2708 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE];
1da177e4
LT		 2709}
2710
e4eff1a6 2711static int nfs4_proc_unlink_done(struct rpc_task *task, struct inode *dir)
1da177e4 2712{
e4eff1a6
TM		 2713 struct nfs_removeres *res = task->tk_msg.rpc_resp;
2714
14516c3a
TM		 2715 if (!nfs4_sequence_done(task, &res->seq_res))
2716 return 0;
9e33bed5 2717 if (nfs4_async_handle_error(task, res->server, NULL) == -EAGAIN)
e4eff1a6
TM		 2718 return 0;
2719 update_changeattr(dir, &res->cinfo);
d346890b 2720 nfs_post_op_update_inode(dir, res->dir_attr);
e4eff1a6 2721 return 1;
1da177e4
LT		 2722}
2723
d3d4152a
JL		 2724static void nfs4_proc_rename_setup(struct rpc_message *msg, struct inode *dir)
2725{
2726 struct nfs_server *server = NFS_SERVER(dir);
2727 struct nfs_renameargs *arg = msg->rpc_argp;
2728 struct nfs_renameres *res = msg->rpc_resp;
2729
2730 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME];
2731 arg->bitmask = server->attr_bitmask;
2732 res->server = server;
2733}
2734
2735static int nfs4_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
2736 struct inode *new_dir)
2737{
2738 struct nfs_renameres *res = task->tk_msg.rpc_resp;
2739
2740 if (!nfs4_sequence_done(task, &res->seq_res))
2741 return 0;
2742 if (nfs4_async_handle_error(task, res->server, NULL) == -EAGAIN)
2743 return 0;
2744
2745 update_changeattr(old_dir, &res->old_cinfo);
2746 nfs_post_op_update_inode(old_dir, res->old_fattr);
2747 update_changeattr(new_dir, &res->new_cinfo);
2748 nfs_post_op_update_inode(new_dir, res->new_fattr);
2749 return 1;
2750}
2751
1da177e4
LT		 2752static int _nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name,
2753 struct inode *new_dir, struct qstr *new_name)
2754{
6caf2c82 2755 struct nfs_server *server = NFS_SERVER(old_dir);
920769f0 2756 struct nfs_renameargs arg = {
1da177e4
LT		 2757 .old_dir = NFS_FH(old_dir),
2758 .new_dir = NFS_FH(new_dir),
2759 .old_name = old_name,
2760 .new_name = new_name,
6caf2c82
TM		 2761 .bitmask = server->attr_bitmask,
2762 };
e8582a8b 2763 struct nfs_renameres res = {
6caf2c82 2764 .server = server,
1da177e4 2765 };
1da177e4
LT		 2766 struct rpc_message msg = {
2767 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME],
2768 .rpc_argp = &arg,
2769 .rpc_resp = &res,
2770 };
011fff72 2771 int status = -ENOMEM;
1da177e4 2772
011fff72
TM		 2773 res.old_fattr = nfs_alloc_fattr();
2774 res.new_fattr = nfs_alloc_fattr();
2775 if (res.old_fattr == NULL || res.new_fattr == NULL)
2776 goto out;
1da177e4 2777
7c513058 2778 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
1da177e4
LT		 2779 if (!status) {
2780 update_changeattr(old_dir, &res.old_cinfo);
6caf2c82 2781 nfs_post_op_update_inode(old_dir, res.old_fattr);
1da177e4 2782 update_changeattr(new_dir, &res.new_cinfo);
6caf2c82 2783 nfs_post_op_update_inode(new_dir, res.new_fattr);
1da177e4 2784 }
011fff72
TM		 2785out:
2786 nfs_free_fattr(res.new_fattr);
2787 nfs_free_fattr(res.old_fattr);
1da177e4
LT		 2788 return status;
2789}
2790
2791static int nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name,
2792 struct inode *new_dir, struct qstr *new_name)
2793{
2794 struct nfs4_exception exception = { };
2795 int err;
2796 do {
2797 err = nfs4_handle_exception(NFS_SERVER(old_dir),
2798 _nfs4_proc_rename(old_dir, old_name,
2799 new_dir, new_name),
2800 &exception);
2801 } while (exception.retry);
2802 return err;
2803}
2804
2805static int _nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
2806{
91ba2eee 2807 struct nfs_server *server = NFS_SERVER(inode);
1da177e4
LT		 2808 struct nfs4_link_arg arg = {
2809 .fh = NFS_FH(inode),
2810 .dir_fh = NFS_FH(dir),
2811 .name = name,
91ba2eee
TM		 2812 .bitmask = server->attr_bitmask,
2813 };
91ba2eee
TM		 2814 struct nfs4_link_res res = {
2815 .server = server,
1da177e4 2816 };
1da177e4
LT		 2817 struct rpc_message msg = {
2818 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LINK],
2819 .rpc_argp = &arg,
91ba2eee 2820 .rpc_resp = &res,
1da177e4 2821 };
136f2627
TM		 2822 int status = -ENOMEM;
2823
2824 res.fattr = nfs_alloc_fattr();
2825 res.dir_attr = nfs_alloc_fattr();
2826 if (res.fattr == NULL || res.dir_attr == NULL)
2827 goto out;
1da177e4 2828
7c513058 2829 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
91ba2eee
TM		 2830 if (!status) {
2831 update_changeattr(dir, &res.cinfo);
2832 nfs_post_op_update_inode(dir, res.dir_attr);
73a3d07c 2833 nfs_post_op_update_inode(inode, res.fattr);
91ba2eee 2834 }
136f2627
TM		 2835out:
2836 nfs_free_fattr(res.dir_attr);
2837 nfs_free_fattr(res.fattr);
1da177e4
LT		 2838 return status;
2839}
2840
2841static int nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
2842{
2843 struct nfs4_exception exception = { };
2844 int err;
2845 do {
2846 err = nfs4_handle_exception(NFS_SERVER(inode),
2847 _nfs4_proc_link(inode, dir, name),
2848 &exception);
2849 } while (exception.retry);
2850 return err;
2851}
2852
57dc9a57
TM		 2853struct nfs4_createdata {
2854 struct rpc_message msg;
2855 struct nfs4_create_arg arg;
2856 struct nfs4_create_res res;
2857 struct nfs_fh fh;
2858 struct nfs_fattr fattr;
2859 struct nfs_fattr dir_fattr;
2860};
2861
2862static struct nfs4_createdata *nfs4_alloc_createdata(struct inode *dir,
2863 struct qstr *name, struct iattr *sattr, u32 ftype)
2864{
2865 struct nfs4_createdata *data;
2866
2867 data = kzalloc(sizeof(*data), GFP_KERNEL);
2868 if (data != NULL) {
2869 struct nfs_server *server = NFS_SERVER(dir);
2870
2871 data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE];
2872 data->msg.rpc_argp = &data->arg;
2873 data->msg.rpc_resp = &data->res;
2874 data->arg.dir_fh = NFS_FH(dir);
2875 data->arg.server = server;
2876 data->arg.name = name;
2877 data->arg.attrs = sattr;
2878 data->arg.ftype = ftype;
2879 data->arg.bitmask = server->attr_bitmask;
2880 data->res.server = server;
2881 data->res.fh = &data->fh;
2882 data->res.fattr = &data->fattr;
2883 data->res.dir_fattr = &data->dir_fattr;
2884 nfs_fattr_init(data->res.fattr);
2885 nfs_fattr_init(data->res.dir_fattr);
2886 }
2887 return data;
2888}
2889
2890static int nfs4_do_create(struct inode *dir, struct dentry *dentry, struct nfs4_createdata *data)
2891{
7c513058 2892 int status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &data->msg,
e73b83f2 2893 &data->arg.seq_args, &data->res.seq_res, 1);
57dc9a57
TM		 2894 if (status == 0) {
2895 update_changeattr(dir, &data->res.dir_cinfo);
2896 nfs_post_op_update_inode(dir, data->res.dir_fattr);
2897 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
2898 }
2899 return status;
2900}
2901
2902static void nfs4_free_createdata(struct nfs4_createdata *data)
2903{
2904 kfree(data);
2905}
2906
4f390c15 2907static int _nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
94a6d753 2908 struct page *page, unsigned int len, struct iattr *sattr)
1da177e4 2909{
57dc9a57
TM		 2910 struct nfs4_createdata *data;
2911 int status = -ENAMETOOLONG;
1da177e4 2912
94a6d753 2913 if (len > NFS4_MAXPATHLEN)
57dc9a57 2914 goto out;
4f390c15 2915
57dc9a57
TM		 2916 status = -ENOMEM;
2917 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4LNK);
2918 if (data == NULL)
2919 goto out;
2920
2921 data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SYMLINK];
2922 data->arg.u.symlink.pages = &page;
2923 data->arg.u.symlink.len = len;
1da177e4 2924
57dc9a57
TM		 2925 status = nfs4_do_create(dir, dentry, data);
2926
2927 nfs4_free_createdata(data);
2928out:
1da177e4
LT		 2929 return status;
2930}
2931
4f390c15 2932static int nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
94a6d753 2933 struct page *page, unsigned int len, struct iattr *sattr)
1da177e4
LT		 2934{
2935 struct nfs4_exception exception = { };
2936 int err;
2937 do {
2938 err = nfs4_handle_exception(NFS_SERVER(dir),
94a6d753
CL		 2939 _nfs4_proc_symlink(dir, dentry, page,
2940 len, sattr),
1da177e4
LT		 2941 &exception);
2942 } while (exception.retry);
2943 return err;
2944}
2945
2946static int _nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
2947 struct iattr *sattr)
2948{
57dc9a57
TM		 2949 struct nfs4_createdata *data;
2950 int status = -ENOMEM;
1da177e4 2951
57dc9a57
TM		 2952 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4DIR);
2953 if (data == NULL)
2954 goto out;
2955
2956 status = nfs4_do_create(dir, dentry, data);
2957
2958 nfs4_free_createdata(data);
2959out:
1da177e4
LT		 2960 return status;
2961}
2962
2963static int nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
2964 struct iattr *sattr)
2965{
2966 struct nfs4_exception exception = { };
2967 int err;
a8a5da99
AK		 2968
2969 sattr->ia_mode &= ~current_umask();
1da177e4
LT		 2970 do {
2971 err = nfs4_handle_exception(NFS_SERVER(dir),
2972 _nfs4_proc_mkdir(dir, dentry, sattr),
2973 &exception);
2974 } while (exception.retry);
2975 return err;
2976}
2977
2978static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
56e4ebf8 2979 u64 cookie, struct page **pages, unsigned int count, int plus)
1da177e4
LT		 2980{
2981 struct inode *dir = dentry->d_inode;
2982 struct nfs4_readdir_arg args = {
2983 .fh = NFS_FH(dir),
56e4ebf8 2984 .pages = pages,
1da177e4
LT		 2985 .pgbase = 0,
2986 .count = count,
96d25e53 2987 .bitmask = NFS_SERVER(dentry->d_inode)->attr_bitmask,
82f2e547 2988 .plus = plus,
1da177e4
LT		 2989 };
2990 struct nfs4_readdir_res res;
2991 struct rpc_message msg = {
2992 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READDIR],
2993 .rpc_argp = &args,
2994 .rpc_resp = &res,
2995 .rpc_cred = cred,
2996 };
2997 int status;
2998
3110ff80 2999 dprintk("%s: dentry = %s/%s, cookie = %Lu\n", __func__,
eadf4598
TM		 3000 dentry->d_parent->d_name.name,
3001 dentry->d_name.name,
3002 (unsigned long long)cookie);
1da177e4
LT		 3003 nfs4_setup_readdir(cookie, NFS_COOKIEVERF(dir), dentry, &args);
3004 res.pgbase = args.pgbase;
7c513058 3005 status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &msg, &args.seq_args, &res.seq_res, 0);
ac396128 3006 if (status >= 0) {
1da177e4 3007 memcpy(NFS_COOKIEVERF(dir), res.verifier.data, NFS4_VERIFIER_SIZE);
ac396128
TM		 3008 status += args.pgbase;
3009 }
c4812998
TM		 3010
3011 nfs_invalidate_atime(dir);
3012
3110ff80 3013 dprintk("%s: returns %d\n", __func__, status);
1da177e4
LT		 3014 return status;
3015}
3016
3017static int nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
56e4ebf8 3018 u64 cookie, struct page **pages, unsigned int count, int plus)
1da177e4
LT		 3019{
3020 struct nfs4_exception exception = { };
3021 int err;
3022 do {
3023 err = nfs4_handle_exception(NFS_SERVER(dentry->d_inode),
3024 _nfs4_proc_readdir(dentry, cred, cookie,
56e4ebf8 3025 pages, count, plus),
1da177e4
LT		 3026 &exception);
3027 } while (exception.retry);
3028 return err;
3029}
3030
3031static int _nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
3032 struct iattr *sattr, dev_t rdev)
3033{
57dc9a57
TM		 3034 struct nfs4_createdata *data;
3035 int mode = sattr->ia_mode;
3036 int status = -ENOMEM;
1da177e4
LT		 3037
3038 BUG_ON(!(sattr->ia_valid & ATTR_MODE));
3039 BUG_ON(!S_ISFIFO(mode) && !S_ISBLK(mode) && !S_ISCHR(mode) && !S_ISSOCK(mode));
57dc9a57
TM		 3040
3041 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4SOCK);
3042 if (data == NULL)
3043 goto out;
3044
1da177e4 3045 if (S_ISFIFO(mode))
57dc9a57 3046 data->arg.ftype = NF4FIFO;
1da177e4 3047 else if (S_ISBLK(mode)) {
57dc9a57
TM		 3048 data->arg.ftype = NF4BLK;
3049 data->arg.u.device.specdata1 = MAJOR(rdev);
3050 data->arg.u.device.specdata2 = MINOR(rdev);
1da177e4
LT		 3051 }
3052 else if (S_ISCHR(mode)) {
57dc9a57
TM		 3053 data->arg.ftype = NF4CHR;
3054 data->arg.u.device.specdata1 = MAJOR(rdev);
3055 data->arg.u.device.specdata2 = MINOR(rdev);
1da177e4 3056 }
1da177e4 3057
57dc9a57
TM		 3058 status = nfs4_do_create(dir, dentry, data);
3059
3060 nfs4_free_createdata(data);
3061out:
1da177e4
LT		 3062 return status;
3063}
3064
3065static int nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
3066 struct iattr *sattr, dev_t rdev)
3067{
3068 struct nfs4_exception exception = { };
3069 int err;
a8a5da99
AK		 3070
3071 sattr->ia_mode &= ~current_umask();
1da177e4
LT		 3072 do {
3073 err = nfs4_handle_exception(NFS_SERVER(dir),
3074 _nfs4_proc_mknod(dir, dentry, sattr, rdev),
3075 &exception);
3076 } while (exception.retry);
3077 return err;
3078}
3079
3080static int _nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
3081 struct nfs_fsstat *fsstat)
3082{
3083 struct nfs4_statfs_arg args = {
3084 .fh = fhandle,
3085 .bitmask = server->attr_bitmask,
3086 };
24ad148a
BH		 3087 struct nfs4_statfs_res res = {
3088 .fsstat = fsstat,
3089 };
1da177e4
LT		 3090 struct rpc_message msg = {
3091 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_STATFS],
3092 .rpc_argp = &args,
24ad148a 3093 .rpc_resp = &res,
1da177e4
LT		 3094 };
3095
0e574af1 3096 nfs_fattr_init(fsstat->fattr);
7c513058 3097 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
1da177e4
LT		 3098}
3099
3100static int nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsstat *fsstat)
3101{
3102 struct nfs4_exception exception = { };
3103 int err;
3104 do {
3105 err = nfs4_handle_exception(server,
3106 _nfs4_proc_statfs(server, fhandle, fsstat),
3107 &exception);
3108 } while (exception.retry);
3109 return err;
3110}
3111
3112static int _nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
3113 struct nfs_fsinfo *fsinfo)
3114{
3115 struct nfs4_fsinfo_arg args = {
3116 .fh = fhandle,
3117 .bitmask = server->attr_bitmask,
3118 };
3dda5e43
BH		 3119 struct nfs4_fsinfo_res res = {
3120 .fsinfo = fsinfo,
3121 };
1da177e4
LT		 3122 struct rpc_message msg = {
3123 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSINFO],
3124 .rpc_argp = &args,
3dda5e43 3125 .rpc_resp = &res,
1da177e4
LT		 3126 };
3127
7c513058 3128 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
1da177e4
LT		 3129}
3130
3131static int nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
3132{
3133 struct nfs4_exception exception = { };
3134 int err;
3135
3136 do {
3137 err = nfs4_handle_exception(server,
3138 _nfs4_do_fsinfo(server, fhandle, fsinfo),
3139 &exception);
3140 } while (exception.retry);
3141 return err;
3142}
3143
3144static int nfs4_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
3145{
0e574af1 3146 nfs_fattr_init(fsinfo->fattr);
1da177e4
LT		 3147 return nfs4_do_fsinfo(server, fhandle, fsinfo);
3148}
3149
3150static int _nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
3151 struct nfs_pathconf *pathconf)
3152{
3153 struct nfs4_pathconf_arg args = {
3154 .fh = fhandle,
3155 .bitmask = server->attr_bitmask,
3156 };
d45b2989
BH		 3157 struct nfs4_pathconf_res res = {
3158 .pathconf = pathconf,
3159 };
1da177e4
LT		 3160 struct rpc_message msg = {
3161 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_PATHCONF],
3162 .rpc_argp = &args,
d45b2989 3163 .rpc_resp = &res,
1da177e4
LT		 3164 };
3165
3166 /* None of the pathconf attributes are mandatory to implement */
3167 if ((args.bitmask[0] & nfs4_pathconf_bitmap[0]) == 0) {
3168 memset(pathconf, 0, sizeof(*pathconf));
3169 return 0;
3170 }
3171
0e574af1 3172 nfs_fattr_init(pathconf->fattr);
7c513058 3173 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
1da177e4
LT		 3174}
3175
3176static int nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
3177 struct nfs_pathconf *pathconf)
3178{
3179 struct nfs4_exception exception = { };
3180 int err;
3181
3182 do {
3183 err = nfs4_handle_exception(server,
3184 _nfs4_proc_pathconf(server, fhandle, pathconf),
3185 &exception);
3186 } while (exception.retry);
3187 return err;
3188}
3189
d20581aa
BH		 3190void __nfs4_read_done_cb(struct nfs_read_data *data)
3191{
3192 nfs_invalidate_atime(data->inode);
3193}
3194
cbdabc7f 3195static int nfs4_read_done_cb(struct rpc_task *task, struct nfs_read_data *data)
1da177e4 3196{
ec06c096 3197 struct nfs_server *server = NFS_SERVER(data->inode);
1da177e4 3198
9e33bed5 3199 if (nfs4_async_handle_error(task, server, data->args.context->state) == -EAGAIN) {
d00c5d43 3200 rpc_restart_call_prepare(task);
ec06c096 3201 return -EAGAIN;
1da177e4 3202 }
8850df99 3203
d20581aa 3204 __nfs4_read_done_cb(data);
1da177e4 3205 if (task->tk_status > 0)
ec06c096
TM		 3206 renew_lease(server, data->timestamp);
3207 return 0;
1da177e4
LT		 3208}
3209
cbdabc7f
AA		 3210static int nfs4_read_done(struct rpc_task *task, struct nfs_read_data *data)
3211{
3212
3213 dprintk("--> %s\n", __func__);
3214
3215 if (!nfs4_sequence_done(task, &data->res.seq_res))
3216 return -EAGAIN;
3217
d20581aa
BH		 3218 return data->read_done_cb ? data->read_done_cb(task, data) :
3219 nfs4_read_done_cb(task, data);
cbdabc7f
AA		 3220}
3221
bdc7f021 3222static void nfs4_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg)
1da177e4 3223{
1da177e4 3224 data->timestamp = jiffies;
cbdabc7f 3225 data->read_done_cb = nfs4_read_done_cb;
bdc7f021 3226 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READ];
1da177e4
LT		 3227}
3228
cbdabc7f
AA		 3229/* Reset the the nfs_read_data to send the read to the MDS. */
3230void nfs4_reset_read(struct rpc_task *task, struct nfs_read_data *data)
3231{
3232 dprintk("%s Reset task for i/o through\n", __func__);
3233 put_lseg(data->lseg);
3234 data->lseg = NULL;
3235 /* offsets will differ in the dense stripe case */
3236 data->args.offset = data->mds_offset;
3237 data->ds_clp = NULL;
3238 data->args.fh = NFS_FH(data->inode);
3239 data->read_done_cb = nfs4_read_done_cb;
3240 task->tk_ops = data->mds_ops;
3241 rpc_task_reset_client(task, NFS_CLIENT(data->inode));
3242}
3243EXPORT_SYMBOL_GPL(nfs4_reset_read);
3244
b029bc9b 3245static int nfs4_write_done_cb(struct rpc_task *task, struct nfs_write_data *data)
1da177e4 3246{
1da177e4
LT		 3247 struct inode *inode = data->inode;
3248
9e33bed5 3249 if (nfs4_async_handle_error(task, NFS_SERVER(inode), data->args.context->state) == -EAGAIN) {
d00c5d43 3250 rpc_restart_call_prepare(task);
788e7a89 3251 return -EAGAIN;
1da177e4 3252 }
4f9838c7 3253 if (task->tk_status >= 0) {
1da177e4 3254 renew_lease(NFS_SERVER(inode), data->timestamp);
70ca8852 3255 nfs_post_op_update_inode_force_wcc(inode, data->res.fattr);
4f9838c7 3256 }
788e7a89 3257 return 0;
1da177e4
LT		 3258}
3259
b029bc9b
FI		 3260static int nfs4_write_done(struct rpc_task *task, struct nfs_write_data *data)
3261{
3262 if (!nfs4_sequence_done(task, &data->res.seq_res))
3263 return -EAGAIN;
d20581aa
BH		 3264 return data->write_done_cb ? data->write_done_cb(task, data) :
3265 nfs4_write_done_cb(task, data);
b029bc9b
FI		 3266}
3267
a69aef14
FI		 3268/* Reset the the nfs_write_data to send the write to the MDS. */
3269void nfs4_reset_write(struct rpc_task *task, struct nfs_write_data *data)
3270{
3271 dprintk("%s Reset task for i/o through\n", __func__);
3272 put_lseg(data->lseg);
3273 data->lseg = NULL;
3274 data->ds_clp = NULL;
3275 data->write_done_cb = nfs4_write_done_cb;
3276 data->args.fh = NFS_FH(data->inode);
3277 data->args.bitmask = data->res.server->cache_consistency_bitmask;
3278 data->args.offset = data->mds_offset;
3279 data->res.fattr = &data->fattr;
3280 task->tk_ops = data->mds_ops;
3281 rpc_task_reset_client(task, NFS_CLIENT(data->inode));
3282}
3283EXPORT_SYMBOL_GPL(nfs4_reset_write);
3284
bdc7f021 3285static void nfs4_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg)
1da177e4 3286{
bdc7f021
TM		 3287 struct nfs_server *server = NFS_SERVER(data->inode);
3288
7ffd1064
FI		 3289 if (data->lseg) {
3290 data->args.bitmask = NULL;
3291 data->res.fattr = NULL;
3292 } else
3293 data->args.bitmask = server->cache_consistency_bitmask;
b029bc9b
FI		 3294 if (!data->write_done_cb)
3295 data->write_done_cb = nfs4_write_done_cb;
4f9838c7 3296 data->res.server = server;
1da177e4
LT		 3297 data->timestamp = jiffies;
3298
bdc7f021 3299 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_WRITE];
1da177e4
LT		 3300}
3301
5f452431 3302static int nfs4_commit_done_cb(struct rpc_task *task, struct nfs_write_data *data)
1da177e4 3303{
1da177e4 3304 struct inode *inode = data->inode;
14516c3a 3305
9e33bed5 3306 if (nfs4_async_handle_error(task, NFS_SERVER(inode), NULL) == -EAGAIN) {
d00c5d43 3307 rpc_restart_call_prepare(task);
788e7a89 3308 return -EAGAIN;
1da177e4 3309 }
9e08a3c5 3310 nfs_refresh_inode(inode, data->res.fattr);
788e7a89 3311 return 0;
1da177e4
LT		 3312}
3313
5f452431
FI		 3314static int nfs4_commit_done(struct rpc_task *task, struct nfs_write_data *data)
3315{
3316 if (!nfs4_sequence_done(task, &data->res.seq_res))
3317 return -EAGAIN;
3318 return data->write_done_cb(task, data);
3319}
3320
bdc7f021 3321static void nfs4_proc_commit_setup(struct nfs_write_data *data, struct rpc_message *msg)
1da177e4 3322{
788e7a89 3323 struct nfs_server *server = NFS_SERVER(data->inode);
988b6dce
FI		 3324
3325 if (data->lseg) {
3326 data->args.bitmask = NULL;
3327 data->res.fattr = NULL;
3328 } else
3329 data->args.bitmask = server->cache_consistency_bitmask;
5f452431
FI		 3330 if (!data->write_done_cb)
3331 data->write_done_cb = nfs4_commit_done_cb;
4f9838c7 3332 data->res.server = server;
bdc7f021 3333 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COMMIT];
1da177e4
LT		 3334}
3335
9bc4e3ca
CL		 3336struct nfs4_renewdata {
3337 struct nfs_client *client;
3338 unsigned long timestamp;
3339};
3340
1da177e4
LT		 3341/*
3342 * nfs4_proc_async_renew(): This is not one of the nfs_rpc_ops; it is a special
3343 * standalone procedure for queueing an asynchronous RENEW.
3344 */
9bc4e3ca 3345static void nfs4_renew_release(void *calldata)
dc96aef9 3346{
9bc4e3ca
CL		 3347 struct nfs4_renewdata *data = calldata;
3348 struct nfs_client *clp = data->client;
dc96aef9 3349
0851de06
AB		 3350 if (atomic_read(&clp->cl_count) > 1)
3351 nfs4_schedule_state_renewal(clp);
3352 nfs_put_client(clp);
9bc4e3ca 3353 kfree(data);
dc96aef9
AB		 3354}
3355
9bc4e3ca 3356static void nfs4_renew_done(struct rpc_task *task, void *calldata)
1da177e4 3357{
9bc4e3ca
CL		 3358 struct nfs4_renewdata *data = calldata;
3359 struct nfs_client *clp = data->client;
3360 unsigned long timestamp = data->timestamp;
1da177e4
LT		 3361
3362 if (task->tk_status < 0) {
95baa25c 3363 /* Unless we're shutting down, schedule state recovery! */
042b60be
TM		 3364 if (test_bit(NFS_CS_RENEWD, &clp->cl_res_state) == 0)
3365 return;
3366 if (task->tk_status != NFS4ERR_CB_PATH_DOWN) {
0400a6b0 3367 nfs4_schedule_lease_recovery(clp);
042b60be
TM		 3368 return;
3369 }
3370 nfs4_schedule_path_down_recovery(clp);
1da177e4 3371 }
452e9352 3372 do_renew_lease(clp, timestamp);
1da177e4
LT		 3373}
3374
963d8fe5
TM		 3375static const struct rpc_call_ops nfs4_renew_ops = {
3376 .rpc_call_done = nfs4_renew_done,
dc96aef9 3377 .rpc_release = nfs4_renew_release,
963d8fe5
TM		 3378};
3379
2f60ea6b 3380static int nfs4_proc_async_renew(struct nfs_client *clp, struct rpc_cred *cred, unsigned renew_flags)
1da177e4
LT		 3381{
3382 struct rpc_message msg = {
3383 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW],
3384 .rpc_argp = clp,
b4454fe1 3385 .rpc_cred = cred,
1da177e4 3386 };
9bc4e3ca 3387 struct nfs4_renewdata *data;
1da177e4 3388
2f60ea6b
TM		 3389 if (renew_flags == 0)
3390 return 0;
0851de06
AB		 3391 if (!atomic_inc_not_zero(&clp->cl_count))
3392 return -EIO;
b569ad34 3393 data = kmalloc(sizeof(*data), GFP_NOFS);
9bc4e3ca
CL		 3394 if (data == NULL)
3395 return -ENOMEM;
3396 data->client = clp;
3397 data->timestamp = jiffies;
1da177e4 3398 return rpc_call_async(clp->cl_rpcclient, &msg, RPC_TASK_SOFT,
9bc4e3ca 3399 &nfs4_renew_ops, data);
1da177e4
LT		 3400}
3401
8534d4ec 3402static int nfs4_proc_renew(struct nfs_client *clp, struct rpc_cred *cred)
1da177e4
LT		 3403{
3404 struct rpc_message msg = {
3405 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW],
3406 .rpc_argp = clp,
b4454fe1 3407 .rpc_cred = cred,
1da177e4
LT		 3408 };
3409 unsigned long now = jiffies;
3410 int status;
3411
3412 status = rpc_call_sync(clp->cl_rpcclient, &msg, 0);
3413 if (status < 0)
3414 return status;
452e9352 3415 do_renew_lease(clp, now);
1da177e4
LT		 3416 return 0;
3417}
3418
aa1870af
BF		 3419static inline int nfs4_server_supports_acls(struct nfs_server *server)
3420{
3421 return (server->caps & NFS_CAP_ACLS)
3422 && (server->acl_bitmask & ACL4_SUPPORT_ALLOW_ACL)
3423 && (server->acl_bitmask & ACL4_SUPPORT_DENY_ACL);
3424}
3425
3426/* Assuming that XATTR_SIZE_MAX is a multiple of PAGE_CACHE_SIZE, and that
3427 * it's OK to put sizeof(void) * (XATTR_SIZE_MAX/PAGE_CACHE_SIZE) bytes on
3428 * the stack.
3429 */
3430#define NFS4ACL_MAXPAGES (XATTR_SIZE_MAX >> PAGE_CACHE_SHIFT)
3431
3432static void buf_to_pages(const void *buf, size_t buflen,
3433 struct page **pages, unsigned int *pgbase)
3434{
3435 const void *p = buf;
3436
3437 *pgbase = offset_in_page(buf);
3438 p -= *pgbase;
3439 while (p < buf + buflen) {
3440 *(pages++) = virt_to_page(p);
3441 p += PAGE_CACHE_SIZE;
3442 }
3443}
3444
e9e3d724
NH		 3445static int buf_to_pages_noslab(const void *buf, size_t buflen,
3446 struct page **pages, unsigned int *pgbase)
3447{
3448 struct page *newpage, **spages;
3449 int rc = 0;
3450 size_t len;
3451 spages = pages;
3452
3453 do {
43b7c3f0 3454 len = min_t(size_t, PAGE_CACHE_SIZE, buflen);
e9e3d724
NH		 3455 newpage = alloc_page(GFP_KERNEL);
3456
3457 if (newpage == NULL)
3458 goto unwind;
3459 memcpy(page_address(newpage), buf, len);
3460 buf += len;
3461 buflen -= len;
3462 *pages++ = newpage;
3463 rc++;
3464 } while (buflen != 0);
3465
3466 return rc;
3467
3468unwind:
3469 for(; rc > 0; rc--)
3470 __free_page(spages[rc-1]);
3471 return -ENOMEM;
3472}
3473
e50a1c2e
BF		 3474struct nfs4_cached_acl {
3475 int cached;
3476 size_t len;
3e9d4154 3477 char data[0];
e50a1c2e
BF		 3478};
3479
3480static void nfs4_set_cached_acl(struct inode *inode, struct nfs4_cached_acl *acl)
3481{
3482 struct nfs_inode *nfsi = NFS_I(inode);
3483
3484 spin_lock(&inode->i_lock);
3485 kfree(nfsi->nfs4_acl);
3486 nfsi->nfs4_acl = acl;
3487 spin_unlock(&inode->i_lock);
3488}
3489
3490static void nfs4_zap_acl_attr(struct inode *inode)
3491{
3492 nfs4_set_cached_acl(inode, NULL);
3493}
3494
3495static inline ssize_t nfs4_read_cached_acl(struct inode *inode, char *buf, size_t buflen)
3496{
3497 struct nfs_inode *nfsi = NFS_I(inode);
3498 struct nfs4_cached_acl *acl;
3499 int ret = -ENOENT;
3500
3501 spin_lock(&inode->i_lock);
3502 acl = nfsi->nfs4_acl;
3503 if (acl == NULL)
3504 goto out;
3505 if (buf == NULL) /* user is just asking for length */
3506 goto out_len;
3507 if (acl->cached == 0)
3508 goto out;
3509 ret = -ERANGE; /* see getxattr(2) man page */
3510 if (acl->len > buflen)
3511 goto out;
3512 memcpy(buf, acl->data, acl->len);
3513out_len:
3514 ret = acl->len;
3515out:
3516 spin_unlock(&inode->i_lock);
3517 return ret;
3518}
3519
3520static void nfs4_write_cached_acl(struct inode *inode, const char *buf, size_t acl_len)
3521{
3522 struct nfs4_cached_acl *acl;
3523
3524 if (buf && acl_len <= PAGE_SIZE) {
3525 acl = kmalloc(sizeof(*acl) + acl_len, GFP_KERNEL);
3526 if (acl == NULL)
3527 goto out;
3528 acl->cached = 1;
3529 memcpy(acl->data, buf, acl_len);
3530 } else {
3531 acl = kmalloc(sizeof(*acl), GFP_KERNEL);
3532 if (acl == NULL)
3533 goto out;
3534 acl->cached = 0;
3535 }
3536 acl->len = acl_len;
3537out:
3538 nfs4_set_cached_acl(inode, acl);
3539}
3540
16b4289c 3541static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)
aa1870af 3542{
aa1870af
BF		 3543 struct page *pages[NFS4ACL_MAXPAGES];
3544 struct nfs_getaclargs args = {
3545 .fh = NFS_FH(inode),
3546 .acl_pages = pages,
3547 .acl_len = buflen,
3548 };
663c79b3
BH		 3549 struct nfs_getaclres res = {
3550 .acl_len = buflen,
3551 };
e50a1c2e 3552 void *resp_buf;
aa1870af
BF		 3553 struct rpc_message msg = {
3554 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETACL],
3555 .rpc_argp = &args,
663c79b3 3556 .rpc_resp = &res,
aa1870af 3557 };
e50a1c2e 3558 struct page *localpage = NULL;
aa1870af
BF		 3559 int ret;
3560
e50a1c2e
BF		 3561 if (buflen < PAGE_SIZE) {
3562 /* As long as we're doing a round trip to the server anyway,
3563 * let's be prepared for a page of acl data. */
3564 localpage = alloc_page(GFP_KERNEL);
3565 resp_buf = page_address(localpage);
3566 if (localpage == NULL)
3567 return -ENOMEM;
3568 args.acl_pages[0] = localpage;
3569 args.acl_pgbase = 0;
663c79b3 3570 args.acl_len = PAGE_SIZE;
e50a1c2e
BF		 3571 } else {
3572 resp_buf = buf;
3573 buf_to_pages(buf, buflen, args.acl_pages, &args.acl_pgbase);
3574 }
7c513058 3575 ret = nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode), &msg, &args.seq_args, &res.seq_res, 0);
e50a1c2e
BF		 3576 if (ret)
3577 goto out_free;
663c79b3
BH		 3578 if (res.acl_len > args.acl_len)
3579 nfs4_write_cached_acl(inode, NULL, res.acl_len);
e50a1c2e 3580 else
663c79b3 3581 nfs4_write_cached_acl(inode, resp_buf, res.acl_len);
e50a1c2e
BF		 3582 if (buf) {
3583 ret = -ERANGE;
663c79b3 3584 if (res.acl_len > buflen)
e50a1c2e
BF		 3585 goto out_free;
3586 if (localpage)
663c79b3 3587 memcpy(buf, resp_buf, res.acl_len);
e50a1c2e 3588 }
663c79b3 3589 ret = res.acl_len;
e50a1c2e
BF		 3590out_free:
3591 if (localpage)
3592 __free_page(localpage);
aa1870af
BF		 3593 return ret;
3594}
3595
16b4289c
TM		 3596static ssize_t nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)
3597{
3598 struct nfs4_exception exception = { };
3599 ssize_t ret;
3600 do {
3601 ret = __nfs4_get_acl_uncached(inode, buf, buflen);
3602 if (ret >= 0)
3603 break;
3604 ret = nfs4_handle_exception(NFS_SERVER(inode), ret, &exception);
3605 } while (exception.retry);
3606 return ret;
3607}
3608
e50a1c2e
BF		 3609static ssize_t nfs4_proc_get_acl(struct inode *inode, void *buf, size_t buflen)
3610{
3611 struct nfs_server *server = NFS_SERVER(inode);
3612 int ret;
3613
3614 if (!nfs4_server_supports_acls(server))
3615 return -EOPNOTSUPP;
3616 ret = nfs_revalidate_inode(server, inode);
3617 if (ret < 0)
3618 return ret;
08a22b39
AK		 3619 if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_ACL)
3620 nfs_zap_acl_cache(inode);
e50a1c2e
BF		 3621 ret = nfs4_read_cached_acl(inode, buf, buflen);
3622 if (ret != -ENOENT)
3623 return ret;
3624 return nfs4_get_acl_uncached(inode, buf, buflen);
3625}
3626
16b4289c 3627static int __nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen)
4b580ee3
BF		 3628{
3629 struct nfs_server *server = NFS_SERVER(inode);
3630 struct page *pages[NFS4ACL_MAXPAGES];
3631 struct nfs_setaclargs arg = {
3632 .fh = NFS_FH(inode),
3633 .acl_pages = pages,
3634 .acl_len = buflen,
3635 };
73c403a9 3636 struct nfs_setaclres res;
4b580ee3
BF		 3637 struct rpc_message msg = {
3638 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETACL],
3639 .rpc_argp = &arg,
73c403a9 3640 .rpc_resp = &res,
4b580ee3 3641 };
e9e3d724 3642 int ret, i;
4b580ee3
BF		 3643
3644 if (!nfs4_server_supports_acls(server))
3645 return -EOPNOTSUPP;
e9e3d724
NH		 3646 i = buf_to_pages_noslab(buf, buflen, arg.acl_pages, &arg.acl_pgbase);
3647 if (i < 0)
3648 return i;
642ac549 3649 nfs_inode_return_delegation(inode);
7c513058 3650 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
e9e3d724
NH		 3651
3652 /*
3653 * Free each page after tx, so the only ref left is
3654 * held by the network stack
3655 */
3656 for (; i > 0; i--)
3657 put_page(pages[i-1]);
3658
08a22b39
AK		 3659 /*
3660 * Acl update can result in inode attribute update.
3661 * so mark the attribute cache invalid.
3662 */
3663 spin_lock(&inode->i_lock);
3664 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATTR;
3665 spin_unlock(&inode->i_lock);
f41f7418
TM		 3666 nfs_access_zap_cache(inode);
3667 nfs_zap_acl_cache(inode);
4b580ee3
BF		 3668 return ret;
3669}
3670
16b4289c
TM		 3671static int nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen)
3672{
3673 struct nfs4_exception exception = { };
3674 int err;
3675 do {
3676 err = nfs4_handle_exception(NFS_SERVER(inode),
3677 __nfs4_proc_set_acl(inode, buf, buflen),
3678 &exception);
3679 } while (exception.retry);
3680 return err;
3681}
3682
1da177e4 3683static int
aa5190d0 3684nfs4_async_handle_error(struct rpc_task *task, const struct nfs_server *server, struct nfs4_state *state)
1da177e4 3685{
aa5190d0
TM		 3686 struct nfs_client *clp = server->nfs_client;
3687
3688 if (task->tk_status >= 0)
1da177e4
LT		 3689 return 0;
3690 switch(task->tk_status) {
9e33bed5
TM		 3691 case -NFS4ERR_ADMIN_REVOKED:
3692 case -NFS4ERR_BAD_STATEID:
3693 case -NFS4ERR_OPENMODE:
3694 if (state == NULL)
3695 break;
0400a6b0
TM		 3696 nfs4_schedule_stateid_recovery(server, state);
3697 goto wait_on_recovery;
0ced63d1
TM		 3698 case -NFS4ERR_EXPIRED:
3699 if (state != NULL)
3700 nfs4_schedule_stateid_recovery(server, state);
1da177e4 3701 case -NFS4ERR_STALE_STATEID:
a2c0b9e2 3702 case -NFS4ERR_STALE_CLIENTID:
0400a6b0
TM		 3703 nfs4_schedule_lease_recovery(clp);
3704 goto wait_on_recovery;
4745e315
AA		 3705#if defined(CONFIG_NFS_V4_1)
3706 case -NFS4ERR_BADSESSION:
3707 case -NFS4ERR_BADSLOT:
3708 case -NFS4ERR_BAD_HIGH_SLOT:
3709 case -NFS4ERR_DEADSESSION:
3710 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
3711 case -NFS4ERR_SEQ_FALSE_RETRY:
3712 case -NFS4ERR_SEQ_MISORDERED:
3713 dprintk("%s ERROR %d, Reset session\n", __func__,
3714 task->tk_status);
0400a6b0 3715 nfs4_schedule_session_recovery(clp->cl_session);
4745e315
AA		 3716 task->tk_status = 0;
3717 return -EAGAIN;
3718#endif /* CONFIG_NFS_V4_1 */
1da177e4 3719 case -NFS4ERR_DELAY:
aa5190d0 3720 nfs_inc_server_stats(server, NFSIOS_DELAY);
006ea73e 3721 case -NFS4ERR_GRACE:
2c643488 3722 case -EKEYEXPIRED:
1da177e4
LT		 3723 rpc_delay(task, NFS4_POLL_RETRY_MAX);
3724 task->tk_status = 0;
3725 return -EAGAIN;
a8a4ae3a 3726 case -NFS4ERR_RETRY_UNCACHED_REP:
1da177e4
LT		 3727 case -NFS4ERR_OLD_STATEID:
3728 task->tk_status = 0;
3729 return -EAGAIN;
3730 }
3731 task->tk_status = nfs4_map_errors(task->tk_status);
3732 return 0;
0400a6b0 3733wait_on_recovery:
a2c0b9e2 3734 rpc_sleep_on(&clp->cl_rpcwaitq, task, NULL);
a2c0b9e2
TM		 3735 if (test_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) == 0)
3736 rpc_wake_up_queued_task(&clp->cl_rpcwaitq, task);
3737 task->tk_status = 0;
3738 return -EAGAIN;
1da177e4
LT		 3739}
3740
bb8b27e5
TM		 3741int nfs4_proc_setclientid(struct nfs_client *clp, u32 program,
3742 unsigned short port, struct rpc_cred *cred,
3743 struct nfs4_setclientid_res *res)
1da177e4
LT		 3744{
3745 nfs4_verifier sc_verifier;
3746 struct nfs4_setclientid setclientid = {
3747 .sc_verifier = &sc_verifier,
3748 .sc_prog = program,
f4eecd5d 3749 .sc_cb_ident = clp->cl_cb_ident,
1da177e4
LT		 3750 };
3751 struct rpc_message msg = {
3752 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID],
3753 .rpc_argp = &setclientid,
bb8b27e5 3754 .rpc_resp = res,
286d7d6a 3755 .rpc_cred = cred,
1da177e4 3756 };
bc4785cd 3757 __be32 *p;
1da177e4
LT		 3758 int loop = 0;
3759 int status;
3760
bc4785cd 3761 p = (__be32*)sc_verifier.data;
1da177e4
LT		 3762 *p++ = htonl((u32)clp->cl_boot_time.tv_sec);
3763 *p = htonl((u32)clp->cl_boot_time.tv_nsec);
3764
3765 for(;;) {
3766 setclientid.sc_name_len = scnprintf(setclientid.sc_name,
69dd716c 3767 sizeof(setclientid.sc_name), "%s/%s %s %s %u",
d4d3c507
CL		 3768 clp->cl_ipaddr,
3769 rpc_peeraddr2str(clp->cl_rpcclient,
3770 RPC_DISPLAY_ADDR),
69dd716c
TM		 3771 rpc_peeraddr2str(clp->cl_rpcclient,
3772 RPC_DISPLAY_PROTO),
78ea323b 3773 clp->cl_rpcclient->cl_auth->au_ops->au_name,
1da177e4
LT		 3774 clp->cl_id_uniquifier);
3775 setclientid.sc_netid_len = scnprintf(setclientid.sc_netid,
d4d3c507
CL		 3776 sizeof(setclientid.sc_netid),
3777 rpc_peeraddr2str(clp->cl_rpcclient,
3778 RPC_DISPLAY_NETID));
1da177e4 3779 setclientid.sc_uaddr_len = scnprintf(setclientid.sc_uaddr,
d4d3c507 3780 sizeof(setclientid.sc_uaddr), "%s.%u.%u",
1da177e4
LT		 3781 clp->cl_ipaddr, port >> 8, port & 255);
3782
1bd714f2 3783 status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
1da177e4
LT		 3784 if (status != -NFS4ERR_CLID_INUSE)
3785 break;
fd954ae1
TM		 3786 if (loop != 0) {
3787 ++clp->cl_id_uniquifier;
1da177e4 3788 break;
fd954ae1
TM		 3789 }
3790 ++loop;
3791 ssleep(clp->cl_lease_time / HZ + 1);
1da177e4
LT		 3792 }
3793 return status;
3794}
3795
fd954ae1 3796int nfs4_proc_setclientid_confirm(struct nfs_client *clp,
bb8b27e5
TM		 3797 struct nfs4_setclientid_res *arg,
3798 struct rpc_cred *cred)
1da177e4
LT		 3799{
3800 struct nfs_fsinfo fsinfo;
3801 struct rpc_message msg = {
3802 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID_CONFIRM],
bb8b27e5 3803 .rpc_argp = arg,
1da177e4 3804 .rpc_resp = &fsinfo,
286d7d6a 3805 .rpc_cred = cred,
1da177e4
LT		 3806 };
3807 unsigned long now;
3808 int status;
3809
3810 now = jiffies;
1bd714f2 3811 status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
1da177e4
LT		 3812 if (status == 0) {
3813 spin_lock(&clp->cl_lock);
3814 clp->cl_lease_time = fsinfo.lease_time * HZ;
3815 clp->cl_last_renewal = now;
3816 spin_unlock(&clp->cl_lock);
3817 }
3818 return status;
3819}
3820
fe650407
TM		 3821struct nfs4_delegreturndata {
3822 struct nfs4_delegreturnargs args;
fa178f29 3823 struct nfs4_delegreturnres res;
fe650407
TM		 3824 struct nfs_fh fh;
3825 nfs4_stateid stateid;
26e976a8 3826 unsigned long timestamp;
fa178f29 3827 struct nfs_fattr fattr;
fe650407
TM		 3828 int rpc_status;
3829};
3830
fe650407
TM		 3831static void nfs4_delegreturn_done(struct rpc_task *task, void *calldata)
3832{
3833 struct nfs4_delegreturndata *data = calldata;
938e1010 3834
14516c3a
TM		 3835 if (!nfs4_sequence_done(task, &data->res.seq_res))
3836 return;
938e1010 3837
79708861
RL		 3838 switch (task->tk_status) {
3839 case -NFS4ERR_STALE_STATEID:
3840 case -NFS4ERR_EXPIRED:
3841 case 0:
fa178f29 3842 renew_lease(data->res.server, data->timestamp);
79708861
RL		 3843 break;
3844 default:
3845 if (nfs4_async_handle_error(task, data->res.server, NULL) ==
3846 -EAGAIN) {
d00c5d43 3847 rpc_restart_call_prepare(task);
79708861
RL		 3848 return;
3849 }
3850 }
3851 data->rpc_status = task->tk_status;
fe650407
TM		 3852}
3853
3854static void nfs4_delegreturn_release(void *calldata)
3855{
fe650407
TM		 3856 kfree(calldata);
3857}
3858
938e1010
AA		 3859#if defined(CONFIG_NFS_V4_1)
3860static void nfs4_delegreturn_prepare(struct rpc_task *task, void *data)
3861{
3862 struct nfs4_delegreturndata *d_data;
3863
3864 d_data = (struct nfs4_delegreturndata *)data;
3865
035168ab 3866 if (nfs4_setup_sequence(d_data->res.server,
938e1010
AA		 3867 &d_data->args.seq_args,
3868 &d_data->res.seq_res, 1, task))
3869 return;
3870 rpc_call_start(task);
3871}
3872#endif /* CONFIG_NFS_V4_1 */
3873
c8d149f3 3874static const struct rpc_call_ops nfs4_delegreturn_ops = {
938e1010
AA		 3875#if defined(CONFIG_NFS_V4_1)
3876 .rpc_call_prepare = nfs4_delegreturn_prepare,
3877#endif /* CONFIG_NFS_V4_1 */
fe650407
TM		 3878 .rpc_call_done = nfs4_delegreturn_done,
3879 .rpc_release = nfs4_delegreturn_release,
3880};
3881
e6f81075 3882static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync)
fe650407
TM		 3883{
3884 struct nfs4_delegreturndata *data;
fa178f29 3885 struct nfs_server *server = NFS_SERVER(inode);
fe650407 3886 struct rpc_task *task;
5138fde0
TM		 3887 struct rpc_message msg = {
3888 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DELEGRETURN],
3889 .rpc_cred = cred,
3890 };
c970aa85
TM		 3891 struct rpc_task_setup task_setup_data = {
3892 .rpc_client = server->client,
5138fde0 3893 .rpc_message = &msg,
c970aa85
TM		 3894 .callback_ops = &nfs4_delegreturn_ops,
3895 .flags = RPC_TASK_ASYNC,
3896 };
e6f81075 3897 int status = 0;
fe650407 3898
8535b2be 3899 data = kzalloc(sizeof(*data), GFP_NOFS);
fe650407
TM		 3900 if (data == NULL)
3901 return -ENOMEM;
3902 data->args.fhandle = &data->fh;
3903 data->args.stateid = &data->stateid;
fa178f29 3904 data->args.bitmask = server->attr_bitmask;
fe650407
TM		 3905 nfs_copy_fh(&data->fh, NFS_FH(inode));
3906 memcpy(&data->stateid, stateid, sizeof(data->stateid));
fa178f29
TM		 3907 data->res.fattr = &data->fattr;
3908 data->res.server = server;
5138fde0 3909 nfs_fattr_init(data->res.fattr);
26e976a8 3910 data->timestamp = jiffies;
fe650407
TM		 3911 data->rpc_status = 0;
3912
c970aa85 3913 task_setup_data.callback_data = data;
1174dd1f
TM		 3914 msg.rpc_argp = &data->args;
3915 msg.rpc_resp = &data->res;
c970aa85 3916 task = rpc_run_task(&task_setup_data);
7a1218a2 3917 if (IS_ERR(task))
fe650407 3918 return PTR_ERR(task);
e6f81075
TM		 3919 if (!issync)
3920 goto out;
fe650407 3921 status = nfs4_wait_for_completion_rpc_task(task);
e6f81075
TM		 3922 if (status != 0)
3923 goto out;
3924 status = data->rpc_status;
3925 if (status != 0)
3926 goto out;
3927 nfs_refresh_inode(inode, &data->fattr);
3928out:
e6b3c4db 3929 rpc_put_task(task);
fe650407 3930 return status;
1da177e4
LT		 3931}
3932
e6f81075 3933int nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync)
1da177e4
LT		 3934{
3935 struct nfs_server *server = NFS_SERVER(inode);
3936 struct nfs4_exception exception = { };
3937 int err;
3938 do {
e6f81075 3939 err = _nfs4_proc_delegreturn(inode, cred, stateid, issync);
1da177e4
LT		 3940 switch (err) {
3941 case -NFS4ERR_STALE_STATEID:
3942 case -NFS4ERR_EXPIRED:
1da177e4
LT		 3943 case 0:
3944 return 0;
3945 }
3946 err = nfs4_handle_exception(server, err, &exception);
3947 } while (exception.retry);
3948 return err;
3949}
3950
3951#define NFS4_LOCK_MINTIMEOUT (1 * HZ)
3952#define NFS4_LOCK_MAXTIMEOUT (30 * HZ)
3953
3954/*
3955 * sleep, with exponential backoff, and retry the LOCK operation.
3956 */
3957static unsigned long
3958nfs4_set_lock_task_retry(unsigned long timeout)
3959{
150030b7 3960 schedule_timeout_killable(timeout);
1da177e4
LT		 3961 timeout <<= 1;
3962 if (timeout > NFS4_LOCK_MAXTIMEOUT)
3963 return NFS4_LOCK_MAXTIMEOUT;
3964 return timeout;
3965}
3966
1da177e4
LT		 3967static int _nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)
3968{
3969 struct inode *inode = state->inode;
3970 struct nfs_server *server = NFS_SERVER(inode);
7539bbab 3971 struct nfs_client *clp = server->nfs_client;
911d1aaf 3972 struct nfs_lockt_args arg = {
1da177e4 3973 .fh = NFS_FH(inode),
911d1aaf 3974 .fl = request,
1da177e4 3975 };
911d1aaf
TM		 3976 struct nfs_lockt_res res = {
3977 .denied = request,
1da177e4
LT		 3978 };
3979 struct rpc_message msg = {
3980 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKT],
3981 .rpc_argp = &arg,
3982 .rpc_resp = &res,
3983 .rpc_cred = state->owner->so_cred,
3984 };
1da177e4
LT		 3985 struct nfs4_lock_state *lsp;
3986 int status;
3987
911d1aaf 3988 arg.lock_owner.clientid = clp->cl_clientid;
8d0a8a9d
TM		 3989 status = nfs4_set_lock_state(state, request);
3990 if (status != 0)
3991 goto out;
3992 lsp = request->fl_u.nfs4_fl.owner;
9f958ab8 3993 arg.lock_owner.id = lsp->ls_id.id;
d035c36c 3994 arg.lock_owner.s_dev = server->s_dev;
7c513058 3995 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
911d1aaf
TM		 3996 switch (status) {
3997 case 0:
3998 request->fl_type = F_UNLCK;
3999 break;
4000 case -NFS4ERR_DENIED:
4001 status = 0;
1da177e4 4002 }
70cc6487 4003 request->fl_ops->fl_release_private(request);
8d0a8a9d 4004out:
1da177e4
LT		 4005 return status;
4006}
4007
4008static int nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)
4009{
4010 struct nfs4_exception exception = { };
4011 int err;
4012
4013 do {
4014 err = nfs4_handle_exception(NFS_SERVER(state->inode),
4015 _nfs4_proc_getlk(state, cmd, request),
4016 &exception);
4017 } while (exception.retry);
4018 return err;
4019}
4020
4021static int do_vfs_lock(struct file *file, struct file_lock *fl)
4022{
4023 int res = 0;
4024 switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) {
4025 case FL_POSIX:
4026 res = posix_lock_file_wait(file, fl);
4027 break;
4028 case FL_FLOCK:
4029 res = flock_lock_file_wait(file, fl);
4030 break;
4031 default:
4032 BUG();
4033 }
1da177e4
LT		 4034 return res;
4035}
4036
faf5f49c 4037struct nfs4_unlockdata {
911d1aaf
TM		 4038 struct nfs_locku_args arg;
4039 struct nfs_locku_res res;
faf5f49c
TM		 4040 struct nfs4_lock_state *lsp;
4041 struct nfs_open_context *ctx;
911d1aaf
TM		 4042 struct file_lock fl;
4043 const struct nfs_server *server;
26e976a8 4044 unsigned long timestamp;
faf5f49c
TM		 4045};
4046
911d1aaf
TM		 4047static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl,
4048 struct nfs_open_context *ctx,
4049 struct nfs4_lock_state *lsp,
4050 struct nfs_seqid *seqid)
4051{
4052 struct nfs4_unlockdata *p;
4053 struct inode *inode = lsp->ls_state->inode;
4054
8535b2be 4055 p = kzalloc(sizeof(*p), GFP_NOFS);
911d1aaf
TM		 4056 if (p == NULL)
4057 return NULL;
4058 p->arg.fh = NFS_FH(inode);
4059 p->arg.fl = &p->fl;
4060 p->arg.seqid = seqid;
c1d51931 4061 p->res.seqid = seqid;
911d1aaf
TM		 4062 p->arg.stateid = &lsp->ls_stateid;
4063 p->lsp = lsp;
4064 atomic_inc(&lsp->ls_count);
4065 /* Ensure we don't close file until we're done freeing locks! */
4066 p->ctx = get_nfs_open_context(ctx);
4067 memcpy(&p->fl, fl, sizeof(p->fl));
4068 p->server = NFS_SERVER(inode);
4069 return p;
4070}
4071
06f814a3 4072static void nfs4_locku_release_calldata(void *data)
faf5f49c 4073{
963d8fe5 4074 struct nfs4_unlockdata *calldata = data;
911d1aaf 4075 nfs_free_seqid(calldata->arg.seqid);
06f814a3
TM		 4076 nfs4_put_lock_state(calldata->lsp);
4077 put_nfs_open_context(calldata->ctx);
4078 kfree(calldata);
faf5f49c
TM		 4079}
4080
963d8fe5 4081static void nfs4_locku_done(struct rpc_task *task, void *data)
faf5f49c 4082{
963d8fe5 4083 struct nfs4_unlockdata *calldata = data;
faf5f49c 4084
14516c3a
TM		 4085 if (!nfs4_sequence_done(task, &calldata->res.seq_res))
4086 return;
faf5f49c
TM		 4087 switch (task->tk_status) {
4088 case 0:
4089 memcpy(calldata->lsp->ls_stateid.data,
911d1aaf 4090 calldata->res.stateid.data,
faf5f49c 4091 sizeof(calldata->lsp->ls_stateid.data));
26e976a8 4092 renew_lease(calldata->server, calldata->timestamp);
faf5f49c 4093 break;
9e33bed5
TM		 4094 case -NFS4ERR_BAD_STATEID:
4095 case -NFS4ERR_OLD_STATEID:
faf5f49c
TM		 4096 case -NFS4ERR_STALE_STATEID:
4097 case -NFS4ERR_EXPIRED:
faf5f49c
TM		 4098 break;
4099 default:
9e33bed5 4100 if (nfs4_async_handle_error(task, calldata->server, NULL) == -EAGAIN)
d00c5d43 4101 rpc_restart_call_prepare(task);
faf5f49c 4102 }
faf5f49c
TM		 4103}
4104
4ce70ada 4105static void nfs4_locku_prepare(struct rpc_task *task, void *data)
faf5f49c 4106{
4ce70ada 4107 struct nfs4_unlockdata *calldata = data;
faf5f49c 4108
911d1aaf 4109 if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
faf5f49c
TM		 4110 return;
4111 if ((calldata->lsp->ls_flags & NFS_LOCK_INITIALIZED) == 0) {
963d8fe5
TM		 4112 /* Note: exit _without_ running nfs4_locku_done */
4113 task->tk_action = NULL;
faf5f49c
TM		 4114 return;
4115 }
26e976a8 4116 calldata->timestamp = jiffies;
035168ab 4117 if (nfs4_setup_sequence(calldata->server,
a893693c
AA		 4118 &calldata->arg.seq_args,
4119 &calldata->res.seq_res, 1, task))
4120 return;
5138fde0 4121 rpc_call_start(task);
faf5f49c
TM		 4122}
4123
963d8fe5 4124static const struct rpc_call_ops nfs4_locku_ops = {
4ce70ada 4125 .rpc_call_prepare = nfs4_locku_prepare,
963d8fe5 4126 .rpc_call_done = nfs4_locku_done,
06f814a3 4127 .rpc_release = nfs4_locku_release_calldata,
963d8fe5
TM		 4128};
4129
a5d16a4d
TM		 4130static struct rpc_task *nfs4_do_unlck(struct file_lock *fl,
4131 struct nfs_open_context *ctx,
4132 struct nfs4_lock_state *lsp,
4133 struct nfs_seqid *seqid)
4134{
4135 struct nfs4_unlockdata *data;
5138fde0
TM		 4136 struct rpc_message msg = {
4137 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKU],
4138 .rpc_cred = ctx->cred,
4139 };
c970aa85
TM		 4140 struct rpc_task_setup task_setup_data = {
4141 .rpc_client = NFS_CLIENT(lsp->ls_state->inode),
5138fde0 4142 .rpc_message = &msg,
c970aa85 4143 .callback_ops = &nfs4_locku_ops,
101070ca 4144 .workqueue = nfsiod_workqueue,
c970aa85
TM		 4145 .flags = RPC_TASK_ASYNC,
4146 };
a5d16a4d 4147
137d6aca
FF		 4148 /* Ensure this is an unlock - when canceling a lock, the
4149 * canceled lock is passed in, and it won't be an unlock.
4150 */
4151 fl->fl_type = F_UNLCK;
4152
a5d16a4d
TM		 4153 data = nfs4_alloc_unlockdata(fl, ctx, lsp, seqid);
4154 if (data == NULL) {
4155 nfs_free_seqid(seqid);
4156 return ERR_PTR(-ENOMEM);
4157 }
4158
1174dd1f
TM		 4159 msg.rpc_argp = &data->arg;
4160 msg.rpc_resp = &data->res;
c970aa85
TM		 4161 task_setup_data.callback_data = data;
4162 return rpc_run_task(&task_setup_data);
a5d16a4d
TM		 4163}
4164
faf5f49c
TM		 4165static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock *request)
4166{
19e03c57 4167 struct nfs_inode *nfsi = NFS_I(state->inode);
911d1aaf 4168 struct nfs_seqid *seqid;
1da177e4 4169 struct nfs4_lock_state *lsp;
06f814a3
TM		 4170 struct rpc_task *task;
4171 int status = 0;
536ff0f8 4172 unsigned char fl_flags = request->fl_flags;
faf5f49c 4173
8d0a8a9d 4174 status = nfs4_set_lock_state(state, request);
9b073574
TM		 4175 /* Unlock _before_ we do the RPC call */
4176 request->fl_flags |= FL_EXISTS;
19e03c57
TM		 4177 down_read(&nfsi->rwsem);
4178 if (do_vfs_lock(request->fl_file, request) == -ENOENT) {
4179 up_read(&nfsi->rwsem);
9b073574 4180 goto out;
19e03c57
TM		 4181 }
4182 up_read(&nfsi->rwsem);
8d0a8a9d 4183 if (status != 0)
9b073574
TM		 4184 goto out;
4185 /* Is this a delegated lock? */
4186 if (test_bit(NFS_DELEGATED_STATE, &state->flags))
4187 goto out;
8d0a8a9d 4188 lsp = request->fl_u.nfs4_fl.owner;
8535b2be 4189 seqid = nfs_alloc_seqid(&lsp->ls_seqid, GFP_KERNEL);
9b073574 4190 status = -ENOMEM;
911d1aaf 4191 if (seqid == NULL)
9b073574 4192 goto out;
cd3758e3 4193 task = nfs4_do_unlck(request, nfs_file_open_context(request->fl_file), lsp, seqid);
a5d16a4d
TM		 4194 status = PTR_ERR(task);
4195 if (IS_ERR(task))
9b073574 4196 goto out;
a5d16a4d 4197 status = nfs4_wait_for_completion_rpc_task(task);
e6b3c4db 4198 rpc_put_task(task);
9b073574 4199out:
536ff0f8 4200 request->fl_flags = fl_flags;
1da177e4
LT		 4201 return status;
4202}
4203
a5d16a4d
TM		 4204struct nfs4_lockdata {
4205 struct nfs_lock_args arg;
4206 struct nfs_lock_res res;
4207 struct nfs4_lock_state *lsp;
4208 struct nfs_open_context *ctx;
4209 struct file_lock fl;
26e976a8 4210 unsigned long timestamp;
a5d16a4d
TM		 4211 int rpc_status;
4212 int cancelled;
66179efe 4213 struct nfs_server *server;
a5d16a4d
TM		 4214};
4215
4216static struct nfs4_lockdata *nfs4_alloc_lockdata(struct file_lock *fl,
8535b2be
TM		 4217 struct nfs_open_context *ctx, struct nfs4_lock_state *lsp,
4218 gfp_t gfp_mask)
1da177e4 4219{
a5d16a4d
TM		 4220 struct nfs4_lockdata *p;
4221 struct inode *inode = lsp->ls_state->inode;
1da177e4 4222 struct nfs_server *server = NFS_SERVER(inode);
a5d16a4d 4223
8535b2be 4224 p = kzalloc(sizeof(*p), gfp_mask);
a5d16a4d
TM		 4225 if (p == NULL)
4226 return NULL;
4227
4228 p->arg.fh = NFS_FH(inode);
4229 p->arg.fl = &p->fl;
8535b2be 4230 p->arg.open_seqid = nfs_alloc_seqid(&lsp->ls_state->owner->so_seqid, gfp_mask);
2f74c0a0
TM		 4231 if (p->arg.open_seqid == NULL)
4232 goto out_free;
8535b2be 4233 p->arg.lock_seqid = nfs_alloc_seqid(&lsp->ls_seqid, gfp_mask);
a5d16a4d 4234 if (p->arg.lock_seqid == NULL)
2f74c0a0 4235 goto out_free_seqid;
a5d16a4d 4236 p->arg.lock_stateid = &lsp->ls_stateid;
7539bbab 4237 p->arg.lock_owner.clientid = server->nfs_client->cl_clientid;
9f958ab8 4238 p->arg.lock_owner.id = lsp->ls_id.id;
d035c36c 4239 p->arg.lock_owner.s_dev = server->s_dev;
c1d51931 4240 p->res.lock_seqid = p->arg.lock_seqid;
a5d16a4d 4241 p->lsp = lsp;
66179efe 4242 p->server = server;
a5d16a4d
TM		 4243 atomic_inc(&lsp->ls_count);
4244 p->ctx = get_nfs_open_context(ctx);
4245 memcpy(&p->fl, fl, sizeof(p->fl));
4246 return p;
2f74c0a0
TM		 4247out_free_seqid:
4248 nfs_free_seqid(p->arg.open_seqid);
a5d16a4d
TM		 4249out_free:
4250 kfree(p);
4251 return NULL;
4252}
4253
4254static void nfs4_lock_prepare(struct rpc_task *task, void *calldata)
4255{
4256 struct nfs4_lockdata *data = calldata;
4257 struct nfs4_state *state = data->lsp->ls_state;
06735b34 4258
3110ff80 4259 dprintk("%s: begin!\n", __func__);
2f74c0a0
TM		 4260 if (nfs_wait_on_sequence(data->arg.lock_seqid, task) != 0)
4261 return;
a5d16a4d
TM		 4262 /* Do we need to do an open_to_lock_owner? */
4263 if (!(data->arg.lock_seqid->sequence->flags & NFS_SEQID_CONFIRMED)) {
e6e21970
TM		 4264 if (nfs_wait_on_sequence(data->arg.open_seqid, task) != 0)
4265 return;
a5d16a4d
TM		 4266 data->arg.open_stateid = &state->stateid;
4267 data->arg.new_lock_owner = 1;
c1d51931 4268 data->res.open_seqid = data->arg.open_seqid;
2f74c0a0
TM		 4269 } else
4270 data->arg.new_lock_owner = 0;
26e976a8 4271 data->timestamp = jiffies;
035168ab
TM		 4272 if (nfs4_setup_sequence(data->server,
4273 &data->arg.seq_args,
66179efe
AA		 4274 &data->res.seq_res, 1, task))
4275 return;
5138fde0 4276 rpc_call_start(task);
3110ff80 4277 dprintk("%s: done!, ret = %d\n", __func__, data->rpc_status);
a5d16a4d
TM		 4278}
4279
b257957e
AB		 4280static void nfs4_recover_lock_prepare(struct rpc_task *task, void *calldata)
4281{
4282 rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED);
4283 nfs4_lock_prepare(task, calldata);
4284}
4285
a5d16a4d
TM		 4286static void nfs4_lock_done(struct rpc_task *task, void *calldata)
4287{
4288 struct nfs4_lockdata *data = calldata;
4289
3110ff80 4290 dprintk("%s: begin!\n", __func__);
a5d16a4d 4291
14516c3a
TM		 4292 if (!nfs4_sequence_done(task, &data->res.seq_res))
4293 return;
66179efe 4294
a5d16a4d 4295 data->rpc_status = task->tk_status;
a5d16a4d 4296 if (data->arg.new_lock_owner != 0) {
a5d16a4d
TM		 4297 if (data->rpc_status == 0)
4298 nfs_confirm_seqid(&data->lsp->ls_seqid, 0);
4299 else
4300 goto out;
4301 }
4302 if (data->rpc_status == 0) {
4303 memcpy(data->lsp->ls_stateid.data, data->res.stateid.data,
4304 sizeof(data->lsp->ls_stateid.data));
4305 data->lsp->ls_flags |= NFS_LOCK_INITIALIZED;
3d4ff43d 4306 renew_lease(NFS_SERVER(data->ctx->dentry->d_inode), data->timestamp);
a5d16a4d 4307 }
a5d16a4d 4308out:
3110ff80 4309 dprintk("%s: done, ret = %d!\n", __func__, data->rpc_status);
a5d16a4d
TM		 4310}
4311
4312static void nfs4_lock_release(void *calldata)
4313{
4314 struct nfs4_lockdata *data = calldata;
4315
3110ff80 4316 dprintk("%s: begin!\n", __func__);
2f74c0a0 4317 nfs_free_seqid(data->arg.open_seqid);
a5d16a4d
TM		 4318 if (data->cancelled != 0) {
4319 struct rpc_task *task;
4320 task = nfs4_do_unlck(&data->fl, data->ctx, data->lsp,
4321 data->arg.lock_seqid);
4322 if (!IS_ERR(task))
bf294b41 4323 rpc_put_task_async(task);
3110ff80 4324 dprintk("%s: cancelling lock!\n", __func__);
a5d16a4d
TM		 4325 } else
4326 nfs_free_seqid(data->arg.lock_seqid);
4327 nfs4_put_lock_state(data->lsp);
4328 put_nfs_open_context(data->ctx);
4329 kfree(data);
3110ff80 4330 dprintk("%s: done!\n", __func__);
a5d16a4d
TM		 4331}
4332
4333static const struct rpc_call_ops nfs4_lock_ops = {
4334 .rpc_call_prepare = nfs4_lock_prepare,
4335 .rpc_call_done = nfs4_lock_done,
4336 .rpc_release = nfs4_lock_release,
4337};
4338
b257957e
AB		 4339static const struct rpc_call_ops nfs4_recover_lock_ops = {
4340 .rpc_call_prepare = nfs4_recover_lock_prepare,
4341 .rpc_call_done = nfs4_lock_done,
4342 .rpc_release = nfs4_lock_release,
4343};
4344
2bee72a6
TM		 4345static void nfs4_handle_setlk_error(struct nfs_server *server, struct nfs4_lock_state *lsp, int new_lock_owner, int error)
4346{
2bee72a6
TM		 4347 switch (error) {
4348 case -NFS4ERR_ADMIN_REVOKED:
4349 case -NFS4ERR_BAD_STATEID:
ecac799a 4350 lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED;
2bee72a6
TM		 4351 if (new_lock_owner != 0 ||
4352 (lsp->ls_flags & NFS_LOCK_INITIALIZED) != 0)
ecac799a 4353 nfs4_schedule_stateid_recovery(server, lsp->ls_state);
a2c0b9e2
TM		 4354 break;
4355 case -NFS4ERR_STALE_STATEID:
a2c0b9e2 4356 lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED;
ecac799a
TM		 4357 case -NFS4ERR_EXPIRED:
4358 nfs4_schedule_lease_recovery(server->nfs_client);
2bee72a6
TM		 4359 };
4360}
4361
afe6c27c 4362static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *fl, int recovery_type)
a5d16a4d
TM		 4363{
4364 struct nfs4_lockdata *data;
4365 struct rpc_task *task;
5138fde0
TM		 4366 struct rpc_message msg = {
4367 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCK],
4368 .rpc_cred = state->owner->so_cred,
4369 };
c970aa85
TM		 4370 struct rpc_task_setup task_setup_data = {
4371 .rpc_client = NFS_CLIENT(state->inode),
5138fde0 4372 .rpc_message = &msg,
c970aa85 4373 .callback_ops = &nfs4_lock_ops,
101070ca 4374 .workqueue = nfsiod_workqueue,
c970aa85
TM		 4375 .flags = RPC_TASK_ASYNC,
4376 };
a5d16a4d
TM		 4377 int ret;
4378
3110ff80 4379 dprintk("%s: begin!\n", __func__);
cd3758e3 4380 data = nfs4_alloc_lockdata(fl, nfs_file_open_context(fl->fl_file),
8535b2be
TM		 4381 fl->fl_u.nfs4_fl.owner,
4382 recovery_type == NFS_LOCK_NEW ? GFP_KERNEL : GFP_NOFS);
a5d16a4d
TM		 4383 if (data == NULL)
4384 return -ENOMEM;
4385 if (IS_SETLKW(cmd))
4386 data->arg.block = 1;
b257957e
AB		 4387 if (recovery_type > NFS_LOCK_NEW) {
4388 if (recovery_type == NFS_LOCK_RECLAIM)
afe6c27c 4389 data->arg.reclaim = NFS_LOCK_RECLAIM;
b257957e
AB		 4390 task_setup_data.callback_ops = &nfs4_recover_lock_ops;
4391 }
1174dd1f
TM		 4392 msg.rpc_argp = &data->arg;
4393 msg.rpc_resp = &data->res;
c970aa85
TM		 4394 task_setup_data.callback_data = data;
4395 task = rpc_run_task(&task_setup_data);
7a1218a2 4396 if (IS_ERR(task))
a5d16a4d 4397 return PTR_ERR(task);
a5d16a4d
TM		 4398 ret = nfs4_wait_for_completion_rpc_task(task);
4399 if (ret == 0) {
4400 ret = data->rpc_status;
2bee72a6
TM		 4401 if (ret)
4402 nfs4_handle_setlk_error(data->server, data->lsp,
4403 data->arg.new_lock_owner, ret);
a5d16a4d
TM		 4404 } else
4405 data->cancelled = 1;
e6b3c4db 4406 rpc_put_task(task);
3110ff80 4407 dprintk("%s: done, ret = %d!\n", __func__, ret);
a5d16a4d 4408 return ret;
1da177e4
LT		 4409}
4410
4411static int nfs4_lock_reclaim(struct nfs4_state *state, struct file_lock *request)
4412{
202b50dc
TM		 4413 struct nfs_server *server = NFS_SERVER(state->inode);
4414 struct nfs4_exception exception = { };
4415 int err;
4416
4417 do {
42a2d13e
TM		 4418 /* Cache the lock if possible... */
4419 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)
4420 return 0;
afe6c27c 4421 err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_RECLAIM);
168667c4 4422 if (err != -NFS4ERR_DELAY)
202b50dc
TM		 4423 break;
4424 nfs4_handle_exception(server, err, &exception);
4425 } while (exception.retry);
4426 return err;
1da177e4
LT		 4427}
4428
4429static int nfs4_lock_expired(struct nfs4_state *state, struct file_lock *request)
4430{
202b50dc
TM		 4431 struct nfs_server *server = NFS_SERVER(state->inode);
4432 struct nfs4_exception exception = { };
4433 int err;
4434
6bfc93ef
TM		 4435 err = nfs4_set_lock_state(state, request);
4436 if (err != 0)
4437 return err;
202b50dc 4438 do {
42a2d13e
TM		 4439 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)
4440 return 0;
afe6c27c 4441 err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_EXPIRED);
a9ed2e25
TM		 4442 switch (err) {
4443 default:
4444 goto out;
4445 case -NFS4ERR_GRACE:
4446 case -NFS4ERR_DELAY:
4447 nfs4_handle_exception(server, err, &exception);
4448 err = 0;
4449 }
202b50dc 4450 } while (exception.retry);
a9ed2e25 4451out:
202b50dc 4452 return err;
1da177e4
LT		 4453}
4454
f062eb6c
BS		 4455#if defined(CONFIG_NFS_V4_1)
4456static int nfs41_lock_expired(struct nfs4_state *state, struct file_lock *request)
4457{
4458 int status;
4459 struct nfs_server *server = NFS_SERVER(state->inode);
4460
4461 status = nfs41_test_stateid(server, state);
4462 if (status == NFS_OK)
4463 return 0;
4464 nfs41_free_stateid(server, state);
4465 return nfs4_lock_expired(state, request);
4466}
4467#endif
4468
1da177e4
LT		 4469static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
4470{
19e03c57 4471 struct nfs_inode *nfsi = NFS_I(state->inode);
01c3b861 4472 unsigned char fl_flags = request->fl_flags;
8e469ebd 4473 int status = -ENOLCK;
1da177e4 4474
8e469ebd
TM		 4475 if ((fl_flags & FL_POSIX) &&
4476 !test_bit(NFS_STATE_POSIX_LOCKS, &state->flags))
4477 goto out;
6bfc93ef 4478 /* Is this a delegated open? */
6bfc93ef
TM		 4479 status = nfs4_set_lock_state(state, request);
4480 if (status != 0)
4481 goto out;
01c3b861
TM		 4482 request->fl_flags |= FL_ACCESS;
4483 status = do_vfs_lock(request->fl_file, request);
4484 if (status < 0)
4485 goto out;
19e03c57 4486 down_read(&nfsi->rwsem);
01c3b861 4487 if (test_bit(NFS_DELEGATED_STATE, &state->flags)) {
01c3b861 4488 /* Yes: cache locks! */
01c3b861 4489 /* ...but avoid races with delegation recall... */
19e03c57
TM		 4490 request->fl_flags = fl_flags & ~FL_SLEEP;
4491 status = do_vfs_lock(request->fl_file, request);
4492 goto out_unlock;
01c3b861 4493 }
afe6c27c 4494 status = _nfs4_do_setlk(state, cmd, request, NFS_LOCK_NEW);
6bfc93ef 4495 if (status != 0)
01c3b861 4496 goto out_unlock;
6bfc93ef 4497 /* Note: we always want to sleep here! */
01c3b861 4498 request->fl_flags = fl_flags | FL_SLEEP;
6bfc93ef 4499 if (do_vfs_lock(request->fl_file, request) < 0)
3110ff80 4500 printk(KERN_WARNING "%s: VFS is out of sync with lock manager!\n", __func__);
01c3b861 4501out_unlock:
19e03c57 4502 up_read(&nfsi->rwsem);
01c3b861
TM		 4503out:
4504 request->fl_flags = fl_flags;
1da177e4
LT		 4505 return status;
4506}
4507
4508static int nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
4509{
4510 struct nfs4_exception exception = { };
4511 int err;
4512
4513 do {
965b5d67
TM		 4514 err = _nfs4_proc_setlk(state, cmd, request);
4515 if (err == -NFS4ERR_DENIED)
4516 err = -EAGAIN;
1da177e4 4517 err = nfs4_handle_exception(NFS_SERVER(state->inode),
965b5d67 4518 err, &exception);
1da177e4
LT		 4519 } while (exception.retry);
4520 return err;
4521}
4522
4523static int
4524nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request)
4525{
4526 struct nfs_open_context *ctx;
4527 struct nfs4_state *state;
4528 unsigned long timeout = NFS4_LOCK_MINTIMEOUT;
4529 int status;
4530
4531 /* verify open state */
cd3758e3 4532 ctx = nfs_file_open_context(filp);
1da177e4
LT		 4533 state = ctx->state;
4534
4535 if (request->fl_start < 0 || request->fl_end < 0)
4536 return -EINVAL;
4537
d953126a
TM		 4538 if (IS_GETLK(cmd)) {
4539 if (state != NULL)
4540 return nfs4_proc_getlk(state, F_GETLK, request);
4541 return 0;
4542 }
1da177e4
LT		 4543
4544 if (!(IS_SETLK(cmd) || IS_SETLKW(cmd)))
4545 return -EINVAL;
4546
d953126a
TM		 4547 if (request->fl_type == F_UNLCK) {
4548 if (state != NULL)
4549 return nfs4_proc_unlck(state, cmd, request);
4550 return 0;
4551 }
1da177e4 4552
d953126a
TM		 4553 if (state == NULL)
4554 return -ENOLCK;
1da177e4
LT		 4555 do {
4556 status = nfs4_proc_setlk(state, cmd, request);
4557 if ((status != -EAGAIN) || IS_SETLK(cmd))
4558 break;
4559 timeout = nfs4_set_lock_task_retry(timeout);
4560 status = -ERESTARTSYS;
4561 if (signalled())
4562 break;
4563 } while(status < 0);
1da177e4
LT		 4564 return status;
4565}
4566
888e694c
TM		 4567int nfs4_lock_delegation_recall(struct nfs4_state *state, struct file_lock *fl)
4568{
4569 struct nfs_server *server = NFS_SERVER(state->inode);
4570 struct nfs4_exception exception = { };
4571 int err;
4572
4573 err = nfs4_set_lock_state(state, fl);
4574 if (err != 0)
4575 goto out;
4576 do {
afe6c27c 4577 err = _nfs4_do_setlk(state, F_SETLK, fl, NFS_LOCK_NEW);
d5122201
TM		 4578 switch (err) {
4579 default:
4580 printk(KERN_ERR "%s: unhandled error %d.\n",
4581 __func__, err);
4582 case 0:
965b5d67 4583 case -ESTALE:
d5122201
TM		 4584 goto out;
4585 case -NFS4ERR_EXPIRED:
0ced63d1 4586 nfs4_schedule_stateid_recovery(server, state);
d5122201 4587 case -NFS4ERR_STALE_CLIENTID:
965b5d67 4588 case -NFS4ERR_STALE_STATEID:
0400a6b0
TM		 4589 nfs4_schedule_lease_recovery(server->nfs_client);
4590 goto out;
74e7bb73
RL		 4591 case -NFS4ERR_BADSESSION:
4592 case -NFS4ERR_BADSLOT:
4593 case -NFS4ERR_BAD_HIGH_SLOT:
4594 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
4595 case -NFS4ERR_DEADSESSION:
0400a6b0 4596 nfs4_schedule_session_recovery(server->nfs_client->cl_session);
d5122201 4597 goto out;
965b5d67
TM		 4598 case -ERESTARTSYS:
4599 /*
4600 * The show must go on: exit, but mark the
4601 * stateid as needing recovery.
4602 */
4603 case -NFS4ERR_ADMIN_REVOKED:
4604 case -NFS4ERR_BAD_STATEID:
4605 case -NFS4ERR_OPENMODE:
0400a6b0 4606 nfs4_schedule_stateid_recovery(server, state);
965b5d67
TM		 4607 err = 0;
4608 goto out;
168667c4
TM		 4609 case -EKEYEXPIRED:
4610 /*
4611 * User RPCSEC_GSS context has expired.
4612 * We cannot recover this stateid now, so
4613 * skip it and allow recovery thread to
4614 * proceed.
4615 */
4616 err = 0;
4617 goto out;
965b5d67
TM		 4618 case -ENOMEM:
4619 case -NFS4ERR_DENIED:
4620 /* kill_proc(fl->fl_pid, SIGLOST, 1); */
4621 err = 0;
4622 goto out;
d5122201
TM		 4623 case -NFS4ERR_DELAY:
4624 break;
4625 }
888e694c
TM		 4626 err = nfs4_handle_exception(server, err, &exception);
4627 } while (exception.retry);
4628out:
4629 return err;
4630}
6b3b5496 4631
d3c7b7cc
TM		 4632static void nfs4_release_lockowner_release(void *calldata)
4633{
4634 kfree(calldata);
4635}
4636
4637const struct rpc_call_ops nfs4_release_lockowner_ops = {
4638 .rpc_release = nfs4_release_lockowner_release,
4639};
4640
4641void nfs4_release_lockowner(const struct nfs4_lock_state *lsp)
4642{
4643 struct nfs_server *server = lsp->ls_state->owner->so_server;
4644 struct nfs_release_lockowner_args *args;
4645 struct rpc_message msg = {
4646 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RELEASE_LOCKOWNER],
4647 };
4648
4649 if (server->nfs_client->cl_mvops->minor_version != 0)
4650 return;
4651 args = kmalloc(sizeof(*args), GFP_NOFS);
4652 if (!args)
4653 return;
4654 args->lock_owner.clientid = server->nfs_client->cl_clientid;
4655 args->lock_owner.id = lsp->ls_id.id;
d035c36c 4656 args->lock_owner.s_dev = server->s_dev;
d3c7b7cc
TM		 4657 msg.rpc_argp = args;
4658 rpc_call_async(server->client, &msg, 0, &nfs4_release_lockowner_ops, args);
4659}
4660
aa1870af
BF		 4661#define XATTR_NAME_NFSV4_ACL "system.nfs4_acl"
4662
64c2ce8b
AK		 4663static int nfs4_xattr_set_nfs4_acl(struct dentry *dentry, const char *key,
4664 const void *buf, size_t buflen,
4665 int flags, int type)
6b3b5496 4666{
64c2ce8b
AK		 4667 if (strcmp(key, "") != 0)
4668 return -EINVAL;
4b580ee3 4669
64c2ce8b 4670 return nfs4_proc_set_acl(dentry->d_inode, buf, buflen);
6b3b5496
BF		 4671}
4672
64c2ce8b
AK		 4673static int nfs4_xattr_get_nfs4_acl(struct dentry *dentry, const char *key,
4674 void *buf, size_t buflen, int type)
6b3b5496 4675{
64c2ce8b
AK		 4676 if (strcmp(key, "") != 0)
4677 return -EINVAL;
aa1870af 4678
64c2ce8b 4679 return nfs4_proc_get_acl(dentry->d_inode, buf, buflen);
6b3b5496
BF		 4680}
4681
64c2ce8b
AK		 4682static size_t nfs4_xattr_list_nfs4_acl(struct dentry *dentry, char *list,
4683 size_t list_len, const char *name,
4684 size_t name_len, int type)
6b3b5496 4685{
64c2ce8b 4686 size_t len = sizeof(XATTR_NAME_NFSV4_ACL);
6b3b5496 4687
096455a2
BF		 4688 if (!nfs4_server_supports_acls(NFS_SERVER(dentry->d_inode)))
4689 return 0;
64c2ce8b
AK		 4690
4691 if (list && len <= list_len)
4692 memcpy(list, XATTR_NAME_NFSV4_ACL, len);
aa1870af 4693 return len;
6b3b5496
BF		 4694}
4695
533eb461
AA		 4696/*
4697 * nfs_fhget will use either the mounted_on_fileid or the fileid
4698 */
69aaaae1
TM		 4699static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr)
4700{
533eb461
AA		 4701 if (!(((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) ||
4702 (fattr->valid & NFS_ATTR_FATTR_FILEID)) &&
4703 (fattr->valid & NFS_ATTR_FATTR_FSID) &&
4704 (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL)))
69aaaae1
TM		 4705 return;
4706
4707 fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE |
4708 NFS_ATTR_FATTR_NLINK;
4709 fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO;
4710 fattr->nlink = 2;
4711}
4712
56659e99 4713int nfs4_proc_fs_locations(struct inode *dir, const struct qstr *name,
7aaa0b3b 4714 struct nfs4_fs_locations *fs_locations, struct page *page)
683b57b4
TM		 4715{
4716 struct nfs_server *server = NFS_SERVER(dir);
4717 u32 bitmask[2] = {
361e624f 4718 [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS,
683b57b4
TM		 4719 };
4720 struct nfs4_fs_locations_arg args = {
4721 .dir_fh = NFS_FH(dir),
c228fd3a 4722 .name = name,
683b57b4
TM		 4723 .page = page,
4724 .bitmask = bitmask,
4725 };
22958463
BH		 4726 struct nfs4_fs_locations_res res = {
4727 .fs_locations = fs_locations,
4728 };
683b57b4
TM		 4729 struct rpc_message msg = {
4730 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS],
4731 .rpc_argp = &args,
22958463 4732 .rpc_resp = &res,
683b57b4
TM		 4733 };
4734 int status;
4735
3110ff80 4736 dprintk("%s: start\n", __func__);
533eb461
AA		 4737
4738 /* Ask for the fileid of the absent filesystem if mounted_on_fileid
4739 * is not supported */
4740 if (NFS_SERVER(dir)->attr_bitmask[1] & FATTR4_WORD1_MOUNTED_ON_FILEID)
4741 bitmask[1] |= FATTR4_WORD1_MOUNTED_ON_FILEID;
4742 else
4743 bitmask[0] |= FATTR4_WORD0_FILEID;
4744
c228fd3a 4745 nfs_fattr_init(&fs_locations->fattr);
683b57b4 4746 fs_locations->server = server;
830b8e33 4747 fs_locations->nlocations = 0;
7c513058 4748 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
3110ff80 4749 dprintk("%s: returned status = %d\n", __func__, status);
683b57b4
TM		 4750 return status;
4751}
4752
5a5ea0d4
BS		 4753static int _nfs4_proc_secinfo(struct inode *dir, const struct qstr *name, struct nfs4_secinfo_flavors *flavors)
4754{
4755 int status;
4756 struct nfs4_secinfo_arg args = {
4757 .dir_fh = NFS_FH(dir),
4758 .name = name,
4759 };
4760 struct nfs4_secinfo_res res = {
4761 .flavors = flavors,
4762 };
4763 struct rpc_message msg = {
4764 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SECINFO],
4765 .rpc_argp = &args,
4766 .rpc_resp = &res,
4767 };
4768
4769 dprintk("NFS call secinfo %s\n", name->name);
4770 status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &msg, &args.seq_args, &res.seq_res, 0);
4771 dprintk("NFS reply secinfo: %d\n", status);
4772 return status;
4773}
4774
4775int nfs4_proc_secinfo(struct inode *dir, const struct qstr *name, struct nfs4_secinfo_flavors *flavors)
4776{
4777 struct nfs4_exception exception = { };
4778 int err;
4779 do {
4780 err = nfs4_handle_exception(NFS_SERVER(dir),
4781 _nfs4_proc_secinfo(dir, name, flavors),
4782 &exception);
4783 } while (exception.retry);
4784 return err;
4785}
4786
557134a3 4787#ifdef CONFIG_NFS_V4_1
357f54d6
AA		 4788/*
4789 * Check the exchange flags returned by the server for invalid flags, having
4790 * both PNFS and NON_PNFS flags set, and not having one of NON_PNFS, PNFS, or
4791 * DS flags set.
4792 */
4793static int nfs4_check_cl_exchange_flags(u32 flags)
4794{
4795 if (flags & ~EXCHGID4_FLAG_MASK_R)
4796 goto out_inval;
4797 if ((flags & EXCHGID4_FLAG_USE_PNFS_MDS) &&
4798 (flags & EXCHGID4_FLAG_USE_NON_PNFS))
4799 goto out_inval;
4800 if (!(flags & (EXCHGID4_FLAG_MASK_PNFS)))
4801 goto out_inval;
4802 return NFS_OK;
4803out_inval:
4804 return -NFS4ERR_INVAL;
4805}
4806
78fe0f41
WAA		 4807static bool
4808nfs41_same_server_scope(struct server_scope *a, struct server_scope *b)
4809{
4810 if (a->server_scope_sz == b->server_scope_sz &&
4811 memcmp(a->server_scope, b->server_scope, a->server_scope_sz) == 0)
4812 return true;
4813
4814 return false;
4815}
4816
99fe60d0
BH		 4817/*
4818 * nfs4_proc_exchange_id()
4819 *
4820 * Since the clientid has expired, all compounds using sessions
4821 * associated with the stale clientid will be returning
4822 * NFS4ERR_BADSESSION in the sequence operation, and will therefore
4823 * be in some phase of session reset.
4824 */
4d643d1d 4825int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred)
99fe60d0
BH		 4826{
4827 nfs4_verifier verifier;
4828 struct nfs41_exchange_id_args args = {
4829 .client = clp,
357f54d6 4830 .flags = EXCHGID4_FLAG_SUPP_MOVED_REFER,
99fe60d0
BH		 4831 };
4832 struct nfs41_exchange_id_res res = {
4833 .client = clp,
4834 };
4835 int status;
4836 struct rpc_message msg = {
4837 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_EXCHANGE_ID],
4838 .rpc_argp = &args,
4839 .rpc_resp = &res,
4840 .rpc_cred = cred,
4841 };
4842 __be32 *p;
4843
4844 dprintk("--> %s\n", __func__);
4845 BUG_ON(clp == NULL);
a7b72103 4846
99fe60d0
BH		 4847 p = (u32 *)verifier.data;
4848 *p++ = htonl((u32)clp->cl_boot_time.tv_sec);
4849 *p = htonl((u32)clp->cl_boot_time.tv_nsec);
4850 args.verifier = &verifier;
4851
c7a360b0
AA		 4852 args.id_len = scnprintf(args.id, sizeof(args.id),
4853 "%s/%s.%s/%u",
4854 clp->cl_ipaddr,
4855 init_utsname()->nodename,
4856 init_utsname()->domainname,
4857 clp->cl_rpcclient->cl_auth->au_flavor);
99fe60d0 4858
78fe0f41
WAA		 4859 res.server_scope = kzalloc(sizeof(struct server_scope), GFP_KERNEL);
4860 if (unlikely(!res.server_scope))
4861 return -ENOMEM;
4862
1bd714f2 4863 status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
c7a360b0
AA		 4864 if (!status)
4865 status = nfs4_check_cl_exchange_flags(clp->cl_exchange_flags);
78fe0f41
WAA		 4866
4867 if (!status) {
4868 if (clp->server_scope &&
4869 !nfs41_same_server_scope(clp->server_scope,
4870 res.server_scope)) {
4871 dprintk("%s: server_scope mismatch detected\n",
4872 __func__);
4873 set_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state);
4874 kfree(clp->server_scope);
4875 clp->server_scope = NULL;
4876 }
4877
4878 if (!clp->server_scope)
4879 clp->server_scope = res.server_scope;
4880 else
4881 kfree(res.server_scope);
4882 }
4883
99fe60d0
BH		 4884 dprintk("<-- %s status= %d\n", __func__, status);
4885 return status;
4886}
4887
2050f0cc
AA		 4888struct nfs4_get_lease_time_data {
4889 struct nfs4_get_lease_time_args *args;
4890 struct nfs4_get_lease_time_res *res;
4891 struct nfs_client *clp;
4892};
4893
4894static void nfs4_get_lease_time_prepare(struct rpc_task *task,
4895 void *calldata)
4896{
4897 int ret;
4898 struct nfs4_get_lease_time_data *data =
4899 (struct nfs4_get_lease_time_data *)calldata;
4900
4901 dprintk("--> %s\n", __func__);
689cf5c1 4902 rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED);
2050f0cc
AA		 4903 /* just setup sequence, do not trigger session recovery
4904 since we're invoked within one */
4905 ret = nfs41_setup_sequence(data->clp->cl_session,
689cf5c1
AB		 4906 &data->args->la_seq_args,
4907 &data->res->lr_seq_res, 0, task);
2050f0cc
AA		 4908
4909 BUG_ON(ret == -EAGAIN);
4910 rpc_call_start(task);
4911 dprintk("<-- %s\n", __func__);
4912}
4913
4914/*
4915 * Called from nfs4_state_manager thread for session setup, so don't recover
4916 * from sequence operation or clientid errors.
4917 */
4918static void nfs4_get_lease_time_done(struct rpc_task *task, void *calldata)
4919{
4920 struct nfs4_get_lease_time_data *data =
4921 (struct nfs4_get_lease_time_data *)calldata;
4922
4923 dprintk("--> %s\n", __func__);
14516c3a
TM		 4924 if (!nfs41_sequence_done(task, &data->res->lr_seq_res))
4925 return;
2050f0cc
AA		 4926 switch (task->tk_status) {
4927 case -NFS4ERR_DELAY:
4928 case -NFS4ERR_GRACE:
4929 dprintk("%s Retry: tk_status %d\n", __func__, task->tk_status);
4930 rpc_delay(task, NFS4_POLL_RETRY_MIN);
4931 task->tk_status = 0;
a8a4ae3a
AA		 4932 /* fall through */
4933 case -NFS4ERR_RETRY_UNCACHED_REP:
d00c5d43 4934 rpc_restart_call_prepare(task);
2050f0cc
AA		 4935 return;
4936 }
2050f0cc
AA		 4937 dprintk("<-- %s\n", __func__);
4938}
4939
4940struct rpc_call_ops nfs4_get_lease_time_ops = {
4941 .rpc_call_prepare = nfs4_get_lease_time_prepare,
4942 .rpc_call_done = nfs4_get_lease_time_done,
4943};
4944
4945int nfs4_proc_get_lease_time(struct nfs_client *clp, struct nfs_fsinfo *fsinfo)
4946{
4947 struct rpc_task *task;
4948 struct nfs4_get_lease_time_args args;
4949 struct nfs4_get_lease_time_res res = {
4950 .lr_fsinfo = fsinfo,
4951 };
4952 struct nfs4_get_lease_time_data data = {
4953 .args = &args,
4954 .res = &res,
4955 .clp = clp,
4956 };
4957 struct rpc_message msg = {
4958 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GET_LEASE_TIME],
4959 .rpc_argp = &args,
4960 .rpc_resp = &res,
4961 };
4962 struct rpc_task_setup task_setup = {
4963 .rpc_client = clp->cl_rpcclient,
4964 .rpc_message = &msg,
4965 .callback_ops = &nfs4_get_lease_time_ops,
1bd714f2
TM		 4966 .callback_data = &data,
4967 .flags = RPC_TASK_TIMEOUT,
2050f0cc
AA		 4968 };
4969 int status;
4970
2050f0cc
AA		 4971 dprintk("--> %s\n", __func__);
4972 task = rpc_run_task(&task_setup);
4973
4974 if (IS_ERR(task))
4975 status = PTR_ERR(task);
4976 else {
4977 status = task->tk_status;
4978 rpc_put_task(task);
4979 }
4980 dprintk("<-- %s return %d\n", __func__, status);
4981
4982 return status;
4983}
4984
b73dafa7
RL		 4985/*
4986 * Reset a slot table
4987 */
104aeba4
AA		 4988static int nfs4_reset_slot_table(struct nfs4_slot_table *tbl, u32 max_reqs,
4989 int ivalue)
ac72b7b3 4990{
104aeba4 4991 struct nfs4_slot *new = NULL;
b73dafa7 4992 int i;
ac72b7b3
AA		 4993 int ret = 0;
4994
104aeba4
AA		 4995 dprintk("--> %s: max_reqs=%u, tbl->max_slots %d\n", __func__,
4996 max_reqs, tbl->max_slots);
ac72b7b3 4997
104aeba4
AA		 4998 /* Does the newly negotiated max_reqs match the existing slot table? */
4999 if (max_reqs != tbl->max_slots) {
5000 ret = -ENOMEM;
5001 new = kmalloc(max_reqs * sizeof(struct nfs4_slot),
8535b2be 5002 GFP_NOFS);
104aeba4
AA		 5003 if (!new)
5004 goto out;
5005 ret = 0;
5006 kfree(tbl->slots);
ac72b7b3
AA		 5007 }
5008 spin_lock(&tbl->slot_tbl_lock);
104aeba4
AA		 5009 if (new) {
5010 tbl->slots = new;
5011 tbl->max_slots = max_reqs;
5012 }
5013 for (i = 0; i < tbl->max_slots; ++i)
b73dafa7 5014 tbl->slots[i].seq_nr = ivalue;
ac72b7b3
AA		 5015 spin_unlock(&tbl->slot_tbl_lock);
5016 dprintk("%s: tbl=%p slots=%p max_slots=%d\n", __func__,
5017 tbl, tbl->slots, tbl->max_slots);
5018out:
5019 dprintk("<-- %s: return %d\n", __func__, ret);
5020 return ret;
5021}
5022
f8625a6a
RL		 5023/* Destroy the slot table */
5024static void nfs4_destroy_slot_tables(struct nfs4_session *session)
5025{
5026 if (session->fc_slot_table.slots != NULL) {
5027 kfree(session->fc_slot_table.slots);
5028 session->fc_slot_table.slots = NULL;
5029 }
5030 if (session->bc_slot_table.slots != NULL) {
5031 kfree(session->bc_slot_table.slots);
5032 session->bc_slot_table.slots = NULL;
5033 }
5034 return;
5035}
5036
fc931582
AA		 5037/*
5038 * Initialize slot table
5039 */
050047ce
RL		 5040static int nfs4_init_slot_table(struct nfs4_slot_table *tbl,
5041 int max_slots, int ivalue)
fc931582 5042{
fc931582
AA		 5043 struct nfs4_slot *slot;
5044 int ret = -ENOMEM;
5045
5046 BUG_ON(max_slots > NFS4_MAX_SLOT_TABLE);
5047
050047ce 5048 dprintk("--> %s: max_reqs=%u\n", __func__, max_slots);
fc931582 5049
8535b2be 5050 slot = kcalloc(max_slots, sizeof(struct nfs4_slot), GFP_NOFS);
fc931582
AA		 5051 if (!slot)
5052 goto out;
fc931582
AA		 5053 ret = 0;
5054
5055 spin_lock(&tbl->slot_tbl_lock);
fc931582
AA		 5056 tbl->max_slots = max_slots;
5057 tbl->slots = slot;
5058 tbl->highest_used_slotid = -1; /* no slot is currently used */
5059 spin_unlock(&tbl->slot_tbl_lock);
5060 dprintk("%s: tbl=%p slots=%p max_slots=%d\n", __func__,
5061 tbl, tbl->slots, tbl->max_slots);
5062out:
5063 dprintk("<-- %s: return %d\n", __func__, ret);
5064 return ret;
fc931582
AA		 5065}
5066
050047ce 5067/*
aacd5537 5068 * Initialize or reset the forechannel and backchannel tables
050047ce 5069 */
aacd5537 5070static int nfs4_setup_session_slot_tables(struct nfs4_session *ses)
050047ce 5071{
f26468fb 5072 struct nfs4_slot_table *tbl;
aacd5537 5073 int status;
050047ce 5074
aacd5537
AA		 5075 dprintk("--> %s\n", __func__);
5076 /* Fore channel */
5077 tbl = &ses->fc_slot_table;
f26468fb 5078 if (tbl->slots == NULL) {
aacd5537
AA		 5079 status = nfs4_init_slot_table(tbl, ses->fc_attrs.max_reqs, 1);
5080 if (status) /* -ENOMEM */
5081 return status;
5082 } else {
5083 status = nfs4_reset_slot_table(tbl, ses->fc_attrs.max_reqs, 1);
f26468fb
TM		 5084 if (status)
5085 return status;
5086 }
aacd5537
AA		 5087 /* Back channel */
5088 tbl = &ses->bc_slot_table;
f26468fb 5089 if (tbl->slots == NULL) {
aacd5537 5090 status = nfs4_init_slot_table(tbl, ses->bc_attrs.max_reqs, 0);
f26468fb 5091 if (status)
aacd5537
AA		 5092 /* Fore and back channel share a connection so get
5093 * both slot tables or neither */
5094 nfs4_destroy_slot_tables(ses);
5095 } else
5096 status = nfs4_reset_slot_table(tbl, ses->bc_attrs.max_reqs, 0);
f8625a6a 5097 return status;
557134a3
AA		 5098}
5099
5100struct nfs4_session *nfs4_alloc_session(struct nfs_client *clp)
5101{
5102 struct nfs4_session *session;
5103 struct nfs4_slot_table *tbl;
5104
8535b2be 5105 session = kzalloc(sizeof(struct nfs4_session), GFP_NOFS);
557134a3
AA		 5106 if (!session)
5107 return NULL;
76db6d95 5108
557134a3 5109 tbl = &session->fc_slot_table;
9dfdf404 5110 tbl->highest_used_slotid = -1;
557134a3 5111 spin_lock_init(&tbl->slot_tbl_lock);
689cf5c1 5112 rpc_init_priority_wait_queue(&tbl->slot_tbl_waitq, "ForeChannel Slot table");
42acd021 5113 init_completion(&tbl->complete);
f8625a6a
RL		 5114
5115 tbl = &session->bc_slot_table;
9dfdf404 5116 tbl->highest_used_slotid = -1;
f8625a6a
RL		 5117 spin_lock_init(&tbl->slot_tbl_lock);
5118 rpc_init_wait_queue(&tbl->slot_tbl_waitq, "BackChannel Slot table");
42acd021 5119 init_completion(&tbl->complete);
f8625a6a 5120
1055d76d
TM		 5121 session->session_state = 1<<NFS4_SESSION_INITING;
5122
557134a3
AA		 5123 session->clp = clp;
5124 return session;
5125}
5126
5127void nfs4_destroy_session(struct nfs4_session *session)
5128{
5a0ffe54
AA		 5129 nfs4_proc_destroy_session(session);
5130 dprintk("%s Destroy backchannel for xprt %p\n",
5131 __func__, session->clp->cl_rpcclient->cl_xprt);
5132 xprt_destroy_backchannel(session->clp->cl_rpcclient->cl_xprt,
5133 NFS41_BC_MIN_CALLBACKS);
f8625a6a 5134 nfs4_destroy_slot_tables(session);
557134a3
AA		 5135 kfree(session);
5136}
5137
fc931582
AA		 5138/*
5139 * Initialize the values to be used by the client in CREATE_SESSION
5140 * If nfs4_init_session set the fore channel request and response sizes,
5141 * use them.
5142 *
5143 * Set the back channel max_resp_sz_cached to zero to force the client to
5144 * always set csa_cachethis to FALSE because the current implementation
5145 * of the back channel DRC only supports caching the CB_SEQUENCE operation.
5146 */
5147static void nfs4_init_channel_attrs(struct nfs41_create_session_args *args)
5148{
5149 struct nfs4_session *session = args->client->cl_session;
5150 unsigned int mxrqst_sz = session->fc_attrs.max_rqst_sz,
5151 mxresp_sz = session->fc_attrs.max_resp_sz;
5152
5153 if (mxrqst_sz == 0)
5154 mxrqst_sz = NFS_MAX_FILE_IO_SIZE;
5155 if (mxresp_sz == 0)
5156 mxresp_sz = NFS_MAX_FILE_IO_SIZE;
5157 /* Fore channel attributes */
fc931582
AA		 5158 args->fc_attrs.max_rqst_sz = mxrqst_sz;
5159 args->fc_attrs.max_resp_sz = mxresp_sz;
fc931582
AA		 5160 args->fc_attrs.max_ops = NFS4_MAX_OPS;
5161 args->fc_attrs.max_reqs = session->clp->cl_rpcclient->cl_xprt->max_reqs;
5162
5163 dprintk("%s: Fore Channel : max_rqst_sz=%u max_resp_sz=%u "
8e0d46e1 5164 "max_ops=%u max_reqs=%u\n",
fc931582
AA		 5165 __func__,
5166 args->fc_attrs.max_rqst_sz, args->fc_attrs.max_resp_sz,
8e0d46e1 5167 args->fc_attrs.max_ops, args->fc_attrs.max_reqs);
fc931582
AA		 5168
5169 /* Back channel attributes */
fc931582
AA		 5170 args->bc_attrs.max_rqst_sz = PAGE_SIZE;
5171 args->bc_attrs.max_resp_sz = PAGE_SIZE;
5172 args->bc_attrs.max_resp_sz_cached = 0;
5173 args->bc_attrs.max_ops = NFS4_MAX_BACK_CHANNEL_OPS;
5174 args->bc_attrs.max_reqs = 1;
5175
5176 dprintk("%s: Back Channel : max_rqst_sz=%u max_resp_sz=%u "
5177 "max_resp_sz_cached=%u max_ops=%u max_reqs=%u\n",
5178 __func__,
5179 args->bc_attrs.max_rqst_sz, args->bc_attrs.max_resp_sz,
5180 args->bc_attrs.max_resp_sz_cached, args->bc_attrs.max_ops,
5181 args->bc_attrs.max_reqs);
5182}
5183
43c2e885 5184static int nfs4_verify_fore_channel_attrs(struct nfs41_create_session_args *args, struct nfs4_session *session)
8d35301d 5185{
43c2e885
BF		 5186 struct nfs4_channel_attrs *sent = &args->fc_attrs;
5187 struct nfs4_channel_attrs *rcvd = &session->fc_attrs;
5188
43c2e885
BF		 5189 if (rcvd->max_resp_sz > sent->max_resp_sz)
5190 return -EINVAL;
5191 /*
5192 * Our requested max_ops is the minimum we need; we're not
5193 * prepared to break up compounds into smaller pieces than that.
5194 * So, no point even trying to continue if the server won't
5195 * cooperate:
5196 */
5197 if (rcvd->max_ops < sent->max_ops)
5198 return -EINVAL;
5199 if (rcvd->max_reqs == 0)
5200 return -EINVAL;
5201 return 0;
8d35301d
AA		 5202}
5203
43c2e885
BF		 5204static int nfs4_verify_back_channel_attrs(struct nfs41_create_session_args *args, struct nfs4_session *session)
5205{
5206 struct nfs4_channel_attrs *sent = &args->bc_attrs;
5207 struct nfs4_channel_attrs *rcvd = &session->bc_attrs;
8d35301d 5208
43c2e885
BF		 5209 if (rcvd->max_rqst_sz > sent->max_rqst_sz)
5210 return -EINVAL;
5211 if (rcvd->max_resp_sz < sent->max_resp_sz)
5212 return -EINVAL;
5213 if (rcvd->max_resp_sz_cached > sent->max_resp_sz_cached)
5214 return -EINVAL;
5215 /* These would render the backchannel useless: */
5216 if (rcvd->max_ops == 0)
5217 return -EINVAL;
5218 if (rcvd->max_reqs == 0)
5219 return -EINVAL;
5220 return 0;
5221}
8d35301d 5222
8d35301d
AA		 5223static int nfs4_verify_channel_attrs(struct nfs41_create_session_args *args,
5224 struct nfs4_session *session)
5225{
43c2e885 5226 int ret;
8d35301d 5227
43c2e885
BF		 5228 ret = nfs4_verify_fore_channel_attrs(args, session);
5229 if (ret)
5230 return ret;
5231 return nfs4_verify_back_channel_attrs(args, session);
8d35301d
AA		 5232}
5233
fc931582
AA		 5234static int _nfs4_proc_create_session(struct nfs_client *clp)
5235{
5236 struct nfs4_session *session = clp->cl_session;
5237 struct nfs41_create_session_args args = {
5238 .client = clp,
5239 .cb_program = NFS4_CALLBACK,
5240 };
5241 struct nfs41_create_session_res res = {
5242 .client = clp,
5243 };
5244 struct rpc_message msg = {
5245 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE_SESSION],
5246 .rpc_argp = &args,
5247 .rpc_resp = &res,
5248 };
5249 int status;
5250
5251 nfs4_init_channel_attrs(&args);
0f91421e 5252 args.flags = (SESSION4_PERSIST | SESSION4_BACK_CHAN);
fc931582 5253
1bd714f2 5254 status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
fc931582 5255
8d35301d
AA		 5256 if (!status)
5257 /* Verify the session's negotiated channel_attrs values */
5258 status = nfs4_verify_channel_attrs(&args, session);
fc931582
AA		 5259 if (!status) {
5260 /* Increment the clientid slot sequence id */
5261 clp->cl_seqid++;
5262 }
5263
5264 return status;
5265}
5266
5267/*
5268 * Issues a CREATE_SESSION operation to the server.
5269 * It is the responsibility of the caller to verify the session is
5270 * expired before calling this routine.
5271 */
f26468fb 5272int nfs4_proc_create_session(struct nfs_client *clp)
fc931582
AA		 5273{
5274 int status;
5275 unsigned *ptr;
fc931582
AA		 5276 struct nfs4_session *session = clp->cl_session;
5277
5278 dprintk("--> %s clp=%p session=%p\n", __func__, clp, session);
5279
fd954ae1 5280 status = _nfs4_proc_create_session(clp);
fc931582
AA		 5281 if (status)
5282 goto out;
5283
aacd5537
AA		 5284 /* Init or reset the session slot tables */
5285 status = nfs4_setup_session_slot_tables(session);
5286 dprintk("slot table setup returned %d\n", status);
fc931582
AA		 5287 if (status)
5288 goto out;
5289
5290 ptr = (unsigned *)&session->sess_id.data[0];
5291 dprintk("%s client>seqid %d sessionid %u:%u:%u:%u\n", __func__,
5292 clp->cl_seqid, ptr[0], ptr[1], ptr[2], ptr[3]);
fc931582
AA		 5293out:
5294 dprintk("<-- %s\n", __func__);
5295 return status;
5296}
5297
0f3e66c6
AA		 5298/*
5299 * Issue the over-the-wire RPC DESTROY_SESSION.
5300 * The caller must serialize access to this routine.
5301 */
5302int nfs4_proc_destroy_session(struct nfs4_session *session)
5303{
5304 int status = 0;
5305 struct rpc_message msg;
5306
5307 dprintk("--> nfs4_proc_destroy_session\n");
5308
5309 /* session is still being setup */
5310 if (session->clp->cl_cons_state != NFS_CS_READY)
5311 return status;
5312
5313 msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_SESSION];
5314 msg.rpc_argp = session;
5315 msg.rpc_resp = NULL;
5316 msg.rpc_cred = NULL;
1bd714f2 5317 status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
0f3e66c6
AA		 5318
5319 if (status)
5320 printk(KERN_WARNING
5321 "Got error %d from the server on DESTROY_SESSION. "
5322 "Session has been destroyed regardless...\n", status);
5323
5324 dprintk("<-- nfs4_proc_destroy_session\n");
5325 return status;
5326}
5327
fccba804
TM		 5328int nfs4_init_session(struct nfs_server *server)
5329{
5330 struct nfs_client *clp = server->nfs_client;
2449ea2e 5331 struct nfs4_session *session;
68bf05ef 5332 unsigned int rsize, wsize;
fccba804
TM		 5333 int ret;
5334
5335 if (!nfs4_has_session(clp))
5336 return 0;
5337
1055d76d
TM		 5338 session = clp->cl_session;
5339 if (!test_and_clear_bit(NFS4_SESSION_INITING, &session->session_state))
5340 return 0;
5341
68bf05ef
AA		 5342 rsize = server->rsize;
5343 if (rsize == 0)
5344 rsize = NFS_MAX_FILE_IO_SIZE;
5345 wsize = server->wsize;
5346 if (wsize == 0)
5347 wsize = NFS_MAX_FILE_IO_SIZE;
5348
68bf05ef
AA		 5349 session->fc_attrs.max_rqst_sz = wsize + nfs41_maxwrite_overhead;
5350 session->fc_attrs.max_resp_sz = rsize + nfs41_maxread_overhead;
2449ea2e 5351
fccba804
TM		 5352 ret = nfs4_recover_expired_lease(server);
5353 if (!ret)
5354 ret = nfs4_check_client_ready(clp);
5355 return ret;
5356}
5357
d83217c1
AA		 5358int nfs4_init_ds_session(struct nfs_client *clp)
5359{
5360 struct nfs4_session *session = clp->cl_session;
5361 int ret;
5362
5363 if (!test_and_clear_bit(NFS4_SESSION_INITING, &session->session_state))
5364 return 0;
5365
5366 ret = nfs4_client_recover_expired_lease(clp);
5367 if (!ret)
5368 /* Test for the DS role */
5369 if (!is_ds_client(clp))
5370 ret = -ENODEV;
5371 if (!ret)
5372 ret = nfs4_check_client_ready(clp);
5373 return ret;
5374
5375}
5376EXPORT_SYMBOL_GPL(nfs4_init_ds_session);
5377
5378
fc01cea9
AA		 5379/*
5380 * Renew the cl_session lease.
5381 */
d5f8d3fe
TM		 5382struct nfs4_sequence_data {
5383 struct nfs_client *clp;
5384 struct nfs4_sequence_args args;
5385 struct nfs4_sequence_res res;
5386};
5387
dc96aef9
AB		 5388static void nfs41_sequence_release(void *data)
5389{
d5f8d3fe
TM		 5390 struct nfs4_sequence_data *calldata = data;
5391 struct nfs_client *clp = calldata->clp;
dc96aef9 5392
7135840f
AB		 5393 if (atomic_read(&clp->cl_count) > 1)
5394 nfs4_schedule_state_renewal(clp);
5395 nfs_put_client(clp);
d5f8d3fe 5396 kfree(calldata);
dc96aef9
AB		 5397}
5398
aa5190d0
TM		 5399static int nfs41_sequence_handle_errors(struct rpc_task *task, struct nfs_client *clp)
5400{
5401 switch(task->tk_status) {
5402 case -NFS4ERR_DELAY:
aa5190d0
TM		 5403 rpc_delay(task, NFS4_POLL_RETRY_MAX);
5404 return -EAGAIN;
5405 default:
0400a6b0 5406 nfs4_schedule_lease_recovery(clp);
aa5190d0
TM		 5407 }
5408 return 0;
5409}
5410
dc96aef9 5411static void nfs41_sequence_call_done(struct rpc_task *task, void *data)
fc01cea9 5412{
d5f8d3fe
TM		 5413 struct nfs4_sequence_data *calldata = data;
5414 struct nfs_client *clp = calldata->clp;
fc01cea9 5415
14516c3a
TM		 5416 if (!nfs41_sequence_done(task, task->tk_msg.rpc_resp))
5417 return;
fc01cea9
AA		 5418
5419 if (task->tk_status < 0) {
5420 dprintk("%s ERROR %d\n", __func__, task->tk_status);
7135840f
AB		 5421 if (atomic_read(&clp->cl_count) == 1)
5422 goto out;
fc01cea9 5423
aa5190d0
TM		 5424 if (nfs41_sequence_handle_errors(task, clp) == -EAGAIN) {
5425 rpc_restart_call_prepare(task);
fc01cea9
AA		 5426 return;
5427 }
5428 }
fc01cea9 5429 dprintk("%s rpc_cred %p\n", __func__, task->tk_msg.rpc_cred);
7135840f 5430out:
fc01cea9
AA		 5431 dprintk("<-- %s\n", __func__);
5432}
5433
5434static void nfs41_sequence_prepare(struct rpc_task *task, void *data)
5435{
d5f8d3fe
TM		 5436 struct nfs4_sequence_data *calldata = data;
5437 struct nfs_client *clp = calldata->clp;
fc01cea9
AA		 5438 struct nfs4_sequence_args *args;
5439 struct nfs4_sequence_res *res;
5440
fc01cea9
AA		 5441 args = task->tk_msg.rpc_argp;
5442 res = task->tk_msg.rpc_resp;
5443
035168ab 5444 if (nfs41_setup_sequence(clp->cl_session, args, res, 0, task))
fc01cea9
AA		 5445 return;
5446 rpc_call_start(task);
5447}
5448
5449static const struct rpc_call_ops nfs41_sequence_ops = {
5450 .rpc_call_done = nfs41_sequence_call_done,
5451 .rpc_call_prepare = nfs41_sequence_prepare,
dc96aef9 5452 .rpc_release = nfs41_sequence_release,
fc01cea9
AA		 5453};
5454
71ac6da9 5455static struct rpc_task *_nfs41_proc_sequence(struct nfs_client *clp, struct rpc_cred *cred)
fc01cea9 5456{
d5f8d3fe 5457 struct nfs4_sequence_data *calldata;
fc01cea9
AA		 5458 struct rpc_message msg = {
5459 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SEQUENCE],
5460 .rpc_cred = cred,
5461 };
71ac6da9
TM		 5462 struct rpc_task_setup task_setup_data = {
5463 .rpc_client = clp->cl_rpcclient,
5464 .rpc_message = &msg,
5465 .callback_ops = &nfs41_sequence_ops,
5466 .flags = RPC_TASK_ASYNC | RPC_TASK_SOFT,
5467 };
fc01cea9 5468
7135840f 5469 if (!atomic_inc_not_zero(&clp->cl_count))
71ac6da9 5470 return ERR_PTR(-EIO);
dfb4f309 5471 calldata = kzalloc(sizeof(*calldata), GFP_NOFS);
d5f8d3fe 5472 if (calldata == NULL) {
7135840f 5473 nfs_put_client(clp);
71ac6da9 5474 return ERR_PTR(-ENOMEM);
fc01cea9 5475 }
d5f8d3fe
TM		 5476 msg.rpc_argp = &calldata->args;
5477 msg.rpc_resp = &calldata->res;
5478 calldata->clp = clp;
71ac6da9 5479 task_setup_data.callback_data = calldata;
fc01cea9 5480
71ac6da9
TM		 5481 return rpc_run_task(&task_setup_data);
5482}
5483
2f60ea6b 5484static int nfs41_proc_async_sequence(struct nfs_client *clp, struct rpc_cred *cred, unsigned renew_flags)
71ac6da9
TM		 5485{
5486 struct rpc_task *task;
5487 int ret = 0;
5488
2f60ea6b
TM		 5489 if ((renew_flags & NFS4_RENEW_TIMEOUT) == 0)
5490 return 0;
71ac6da9
TM		 5491 task = _nfs41_proc_sequence(clp, cred);
5492 if (IS_ERR(task))
5493 ret = PTR_ERR(task);
5494 else
bf294b41 5495 rpc_put_task_async(task);
71ac6da9
TM		 5496 dprintk("<-- %s status=%d\n", __func__, ret);
5497 return ret;
5498}
5499
5500static int nfs4_proc_sequence(struct nfs_client *clp, struct rpc_cred *cred)
5501{
5502 struct rpc_task *task;
5503 int ret;
5504
5505 task = _nfs41_proc_sequence(clp, cred);
5506 if (IS_ERR(task)) {
5507 ret = PTR_ERR(task);
5508 goto out;
5509 }
5510 ret = rpc_wait_for_completion_task(task);
b4410c2f
TM		 5511 if (!ret) {
5512 struct nfs4_sequence_res *res = task->tk_msg.rpc_resp;
5513
5514 if (task->tk_status == 0)
5515 nfs41_handle_sequence_flag_errors(clp, res->sr_status_flags);
71ac6da9 5516 ret = task->tk_status;
b4410c2f 5517 }
71ac6da9
TM		 5518 rpc_put_task(task);
5519out:
5520 dprintk("<-- %s status=%d\n", __func__, ret);
5521 return ret;
fc01cea9
AA		 5522}
5523
fce5c838
RL		 5524struct nfs4_reclaim_complete_data {
5525 struct nfs_client *clp;
5526 struct nfs41_reclaim_complete_args arg;
5527 struct nfs41_reclaim_complete_res res;
5528};
5529
5530static void nfs4_reclaim_complete_prepare(struct rpc_task *task, void *data)
5531{
5532 struct nfs4_reclaim_complete_data *calldata = data;
5533
b257957e 5534 rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED);
035168ab
TM		 5535 if (nfs41_setup_sequence(calldata->clp->cl_session,
5536 &calldata->arg.seq_args,
fce5c838
RL		 5537 &calldata->res.seq_res, 0, task))
5538 return;
5539
5540 rpc_call_start(task);
5541}
5542
aa5190d0
TM		 5543static int nfs41_reclaim_complete_handle_errors(struct rpc_task *task, struct nfs_client *clp)
5544{
5545 switch(task->tk_status) {
5546 case 0:
5547 case -NFS4ERR_COMPLETE_ALREADY:
5548 case -NFS4ERR_WRONG_CRED: /* What to do here? */
5549 break;
5550 case -NFS4ERR_DELAY:
aa5190d0 5551 rpc_delay(task, NFS4_POLL_RETRY_MAX);
a8a4ae3a
AA		 5552 /* fall through */
5553 case -NFS4ERR_RETRY_UNCACHED_REP:
aa5190d0
TM		 5554 return -EAGAIN;
5555 default:
0400a6b0 5556 nfs4_schedule_lease_recovery(clp);
aa5190d0
TM		 5557 }
5558 return 0;
5559}
5560
fce5c838
RL		 5561static void nfs4_reclaim_complete_done(struct rpc_task *task, void *data)
5562{
5563 struct nfs4_reclaim_complete_data *calldata = data;
5564 struct nfs_client *clp = calldata->clp;
5565 struct nfs4_sequence_res *res = &calldata->res.seq_res;
5566
5567 dprintk("--> %s\n", __func__);
14516c3a
TM		 5568 if (!nfs41_sequence_done(task, res))
5569 return;
fce5c838 5570
aa5190d0
TM		 5571 if (nfs41_reclaim_complete_handle_errors(task, clp) == -EAGAIN) {
5572 rpc_restart_call_prepare(task);
5573 return;
5574 }
fce5c838
RL		 5575 dprintk("<-- %s\n", __func__);
5576}
5577
5578static void nfs4_free_reclaim_complete_data(void *data)
5579{
5580 struct nfs4_reclaim_complete_data *calldata = data;
5581
5582 kfree(calldata);
5583}
5584
5585static const struct rpc_call_ops nfs4_reclaim_complete_call_ops = {
5586 .rpc_call_prepare = nfs4_reclaim_complete_prepare,
5587 .rpc_call_done = nfs4_reclaim_complete_done,
5588 .rpc_release = nfs4_free_reclaim_complete_data,
5589};
5590
5591/*
5592 * Issue a global reclaim complete.
5593 */
5594static int nfs41_proc_reclaim_complete(struct nfs_client *clp)
5595{
5596 struct nfs4_reclaim_complete_data *calldata;
5597 struct rpc_task *task;
5598 struct rpc_message msg = {
5599 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RECLAIM_COMPLETE],
5600 };
5601 struct rpc_task_setup task_setup_data = {
5602 .rpc_client = clp->cl_rpcclient,
5603 .rpc_message = &msg,
5604 .callback_ops = &nfs4_reclaim_complete_call_ops,
5605 .flags = RPC_TASK_ASYNC,
5606 };
5607 int status = -ENOMEM;
5608
5609 dprintk("--> %s\n", __func__);
8535b2be 5610 calldata = kzalloc(sizeof(*calldata), GFP_NOFS);
fce5c838
RL		 5611 if (calldata == NULL)
5612 goto out;
5613 calldata->clp = clp;
5614 calldata->arg.one_fs = 0;
fce5c838
RL		 5615
5616 msg.rpc_argp = &calldata->arg;
5617 msg.rpc_resp = &calldata->res;
5618 task_setup_data.callback_data = calldata;
5619 task = rpc_run_task(&task_setup_data);
acf82b85 5620 if (IS_ERR(task)) {
fce5c838 5621 status = PTR_ERR(task);
acf82b85
DC		 5622 goto out;
5623 }
c34c32ea
AA		 5624 status = nfs4_wait_for_completion_rpc_task(task);
5625 if (status == 0)
5626 status = task->tk_status;
fce5c838 5627 rpc_put_task(task);
acf82b85 5628 return 0;
fce5c838
RL		 5629out:
5630 dprintk("<-- %s status=%d\n", __func__, status);
5631 return status;
5632}
b1f69b75
AA		 5633
5634static void
5635nfs4_layoutget_prepare(struct rpc_task *task, void *calldata)
5636{
5637 struct nfs4_layoutget *lgp = calldata;
c31663d4 5638 struct nfs_server *server = NFS_SERVER(lgp->args.inode);
b1f69b75
AA		 5639
5640 dprintk("--> %s\n", __func__);
c31663d4
FI		 5641 /* Note the is a race here, where a CB_LAYOUTRECALL can come in
5642 * right now covering the LAYOUTGET we are about to send.
5643 * However, that is not so catastrophic, and there seems
5644 * to be no way to prevent it completely.
5645 */
b1f69b75
AA		 5646 if (nfs4_setup_sequence(server, &lgp->args.seq_args,
5647 &lgp->res.seq_res, 0, task))
5648 return;
cf7d63f1
FI		 5649 if (pnfs_choose_layoutget_stateid(&lgp->args.stateid,
5650 NFS_I(lgp->args.inode)->layout,
5651 lgp->args.ctx->state)) {
5652 rpc_exit(task, NFS4_OK);
5653 return;
5654 }
b1f69b75
AA		 5655 rpc_call_start(task);
5656}
5657
5658static void nfs4_layoutget_done(struct rpc_task *task, void *calldata)
5659{
5660 struct nfs4_layoutget *lgp = calldata;
5661 struct nfs_server *server = NFS_SERVER(lgp->args.inode);
5662
5663 dprintk("--> %s\n", __func__);
5664
5665 if (!nfs4_sequence_done(task, &lgp->res.seq_res))
5666 return;
5667
5668 switch (task->tk_status) {
5669 case 0:
5670 break;
5671 case -NFS4ERR_LAYOUTTRYLATER:
5672 case -NFS4ERR_RECALLCONFLICT:
5673 task->tk_status = -NFS4ERR_DELAY;
5674 /* Fall through */
5675 default:
5676 if (nfs4_async_handle_error(task, server, NULL) == -EAGAIN) {
5677 rpc_restart_call_prepare(task);
5678 return;
5679 }
5680 }
b1f69b75
AA		 5681 dprintk("<-- %s\n", __func__);
5682}
5683
5684static void nfs4_layoutget_release(void *calldata)
5685{
5686 struct nfs4_layoutget *lgp = calldata;
5687
5688 dprintk("--> %s\n", __func__);
b1f69b75
AA		 5689 put_nfs_open_context(lgp->args.ctx);
5690 kfree(calldata);
5691 dprintk("<-- %s\n", __func__);
5692}
5693
5694static const struct rpc_call_ops nfs4_layoutget_call_ops = {
5695 .rpc_call_prepare = nfs4_layoutget_prepare,
5696 .rpc_call_done = nfs4_layoutget_done,
5697 .rpc_release = nfs4_layoutget_release,
5698};
5699
5700int nfs4_proc_layoutget(struct nfs4_layoutget *lgp)
5701{
5702 struct nfs_server *server = NFS_SERVER(lgp->args.inode);
5703 struct rpc_task *task;
5704 struct rpc_message msg = {
5705 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTGET],
5706 .rpc_argp = &lgp->args,
5707 .rpc_resp = &lgp->res,
5708 };
5709 struct rpc_task_setup task_setup_data = {
5710 .rpc_client = server->client,
5711 .rpc_message = &msg,
5712 .callback_ops = &nfs4_layoutget_call_ops,
5713 .callback_data = lgp,
5714 .flags = RPC_TASK_ASYNC,
5715 };
5716 int status = 0;
5717
5718 dprintk("--> %s\n", __func__);
5719
35124a09 5720 lgp->res.layoutp = &lgp->args.layout;
b1f69b75
AA		 5721 lgp->res.seq_res.sr_slot = NULL;
5722 task = rpc_run_task(&task_setup_data);
5723 if (IS_ERR(task))
5724 return PTR_ERR(task);
5725 status = nfs4_wait_for_completion_rpc_task(task);
c31663d4
FI		 5726 if (status == 0)
5727 status = task->tk_status;
5728 if (status == 0)
5729 status = pnfs_layout_process(lgp);
b1f69b75
AA		 5730 rpc_put_task(task);
5731 dprintk("<-- %s status=%d\n", __func__, status);
5732 return status;
5733}
5734
cbe82603
BH		 5735static void
5736nfs4_layoutreturn_prepare(struct rpc_task *task, void *calldata)
5737{
5738 struct nfs4_layoutreturn *lrp = calldata;
5739
5740 dprintk("--> %s\n", __func__);
5741 if (nfs41_setup_sequence(lrp->clp->cl_session, &lrp->args.seq_args,
5742 &lrp->res.seq_res, 0, task))
5743 return;
5744 rpc_call_start(task);
5745}
5746
5747static void nfs4_layoutreturn_done(struct rpc_task *task, void *calldata)
5748{
5749 struct nfs4_layoutreturn *lrp = calldata;
5750 struct nfs_server *server;
a56aaa02 5751 struct pnfs_layout_hdr *lo = lrp->args.layout;
cbe82603
BH		 5752
5753 dprintk("--> %s\n", __func__);
5754
5755 if (!nfs4_sequence_done(task, &lrp->res.seq_res))
5756 return;
5757
5758 server = NFS_SERVER(lrp->args.inode);
5759 if (nfs4_async_handle_error(task, server, NULL) == -EAGAIN) {
d00c5d43 5760 rpc_restart_call_prepare(task);
cbe82603
BH		 5761 return;
5762 }
a2e1d4f2 5763 spin_lock(&lo->plh_inode->i_lock);
cbe82603 5764 if (task->tk_status == 0) {
cbe82603 5765 if (lrp->res.lrs_present) {
cbe82603 5766 pnfs_set_layout_stateid(lo, &lrp->res.stateid, true);
cbe82603
BH		 5767 } else
5768 BUG_ON(!list_empty(&lo->plh_segs));
5769 }
a2e1d4f2
FI		 5770 lo->plh_block_lgets--;
5771 spin_unlock(&lo->plh_inode->i_lock);
cbe82603
BH		 5772 dprintk("<-- %s\n", __func__);
5773}
5774
5775static void nfs4_layoutreturn_release(void *calldata)
5776{
5777 struct nfs4_layoutreturn *lrp = calldata;
5778
5779 dprintk("--> %s\n", __func__);
a56aaa02 5780 put_layout_hdr(lrp->args.layout);
cbe82603
BH		 5781 kfree(calldata);
5782 dprintk("<-- %s\n", __func__);
5783}
5784
5785static const struct rpc_call_ops nfs4_layoutreturn_call_ops = {
5786 .rpc_call_prepare = nfs4_layoutreturn_prepare,
5787 .rpc_call_done = nfs4_layoutreturn_done,
5788 .rpc_release = nfs4_layoutreturn_release,
5789};
5790
5791int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp)
5792{
5793 struct rpc_task *task;
5794 struct rpc_message msg = {
5795 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTRETURN],
5796 .rpc_argp = &lrp->args,
5797 .rpc_resp = &lrp->res,
5798 };
5799 struct rpc_task_setup task_setup_data = {
5800 .rpc_client = lrp->clp->cl_rpcclient,
5801 .rpc_message = &msg,
5802 .callback_ops = &nfs4_layoutreturn_call_ops,
5803 .callback_data = lrp,
5804 };
5805 int status;
5806
5807 dprintk("--> %s\n", __func__);
5808 task = rpc_run_task(&task_setup_data);
5809 if (IS_ERR(task))
5810 return PTR_ERR(task);
5811 status = task->tk_status;
5812 dprintk("<-- %s status=%d\n", __func__, status);
5813 rpc_put_task(task);
5814 return status;
5815}
5816
7f11d8d3
AA		 5817/*
5818 * Retrieve the list of Data Server devices from the MDS.
5819 */
5820static int _nfs4_getdevicelist(struct nfs_server *server,
5821 const struct nfs_fh *fh,
5822 struct pnfs_devicelist *devlist)
5823{
5824 struct nfs4_getdevicelist_args args = {
5825 .fh = fh,
5826 .layoutclass = server->pnfs_curr_ld->id,
5827 };
5828 struct nfs4_getdevicelist_res res = {
5829 .devlist = devlist,
5830 };
5831 struct rpc_message msg = {
5832 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETDEVICELIST],
5833 .rpc_argp = &args,
5834 .rpc_resp = &res,
5835 };
5836 int status;
5837
5838 dprintk("--> %s\n", __func__);
5839 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args,
5840 &res.seq_res, 0);
5841 dprintk("<-- %s status=%d\n", __func__, status);
5842 return status;
5843}
5844
5845int nfs4_proc_getdevicelist(struct nfs_server *server,
5846 const struct nfs_fh *fh,
5847 struct pnfs_devicelist *devlist)
5848{
5849 struct nfs4_exception exception = { };
5850 int err;
5851
5852 do {
5853 err = nfs4_handle_exception(server,
5854 _nfs4_getdevicelist(server, fh, devlist),
5855 &exception);
5856 } while (exception.retry);
5857
5858 dprintk("%s: err=%d, num_devs=%u\n", __func__,
5859 err, devlist->num_devs);
5860
5861 return err;
5862}
5863EXPORT_SYMBOL_GPL(nfs4_proc_getdevicelist);
5864
b1f69b75
AA		 5865static int
5866_nfs4_proc_getdeviceinfo(struct nfs_server *server, struct pnfs_device *pdev)
5867{
5868 struct nfs4_getdeviceinfo_args args = {
5869 .pdev = pdev,
5870 };
5871 struct nfs4_getdeviceinfo_res res = {
5872 .pdev = pdev,
5873 };
5874 struct rpc_message msg = {
5875 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETDEVICEINFO],
5876 .rpc_argp = &args,
5877 .rpc_resp = &res,
5878 };
5879 int status;
5880
5881 dprintk("--> %s\n", __func__);
7c513058 5882 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
b1f69b75
AA		 5883 dprintk("<-- %s status=%d\n", __func__, status);
5884
5885 return status;
5886}
5887
5888int nfs4_proc_getdeviceinfo(struct nfs_server *server, struct pnfs_device *pdev)
5889{
5890 struct nfs4_exception exception = { };
5891 int err;
5892
5893 do {
5894 err = nfs4_handle_exception(server,
5895 _nfs4_proc_getdeviceinfo(server, pdev),
5896 &exception);
5897 } while (exception.retry);
5898 return err;
5899}
5900EXPORT_SYMBOL_GPL(nfs4_proc_getdeviceinfo);
5901
863a3c6c
AA		 5902static void nfs4_layoutcommit_prepare(struct rpc_task *task, void *calldata)
5903{
5904 struct nfs4_layoutcommit_data *data = calldata;
5905 struct nfs_server *server = NFS_SERVER(data->args.inode);
5906
5907 if (nfs4_setup_sequence(server, &data->args.seq_args,
5908 &data->res.seq_res, 1, task))
5909 return;
5910 rpc_call_start(task);
5911}
5912
5913static void
5914nfs4_layoutcommit_done(struct rpc_task *task, void *calldata)
5915{
5916 struct nfs4_layoutcommit_data *data = calldata;
5917 struct nfs_server *server = NFS_SERVER(data->args.inode);
5918
5919 if (!nfs4_sequence_done(task, &data->res.seq_res))
5920 return;
5921
5922 switch (task->tk_status) { /* Just ignore these failures */
5923 case NFS4ERR_DELEG_REVOKED: /* layout was recalled */
5924 case NFS4ERR_BADIOMODE: /* no IOMODE_RW layout for range */
5925 case NFS4ERR_BADLAYOUT: /* no layout */
5926 case NFS4ERR_GRACE: /* loca_recalim always false */
5927 task->tk_status = 0;
5928 }
5929
5930 if (nfs4_async_handle_error(task, server, NULL) == -EAGAIN) {
d00c5d43 5931 rpc_restart_call_prepare(task);
863a3c6c
AA		 5932 return;
5933 }
5934
5935 if (task->tk_status == 0)
5936 nfs_post_op_update_inode_force_wcc(data->args.inode,
5937 data->res.fattr);
5938}
5939
5940static void nfs4_layoutcommit_release(void *calldata)
5941{
5942 struct nfs4_layoutcommit_data *data = calldata;
a9bae566 5943 struct pnfs_layout_segment *lseg, *tmp;
92407e75 5944 unsigned long *bitlock = &NFS_I(data->args.inode)->flags;
863a3c6c 5945
db29c089 5946 pnfs_cleanup_layoutcommit(data);
863a3c6c 5947 /* Matched by references in pnfs_set_layoutcommit */
a9bae566
PT		 5948 list_for_each_entry_safe(lseg, tmp, &data->lseg_list, pls_lc_list) {
5949 list_del_init(&lseg->pls_lc_list);
5950 if (test_and_clear_bit(NFS_LSEG_LAYOUTCOMMIT,
5951 &lseg->pls_flags))
5952 put_lseg(lseg);
5953 }
92407e75
PT		 5954
5955 clear_bit_unlock(NFS_INO_LAYOUTCOMMITTING, bitlock);
5956 smp_mb__after_clear_bit();
5957 wake_up_bit(bitlock, NFS_INO_LAYOUTCOMMITTING);
5958
863a3c6c
AA		 5959 put_rpccred(data->cred);
5960 kfree(data);
5961}
5962
5963static const struct rpc_call_ops nfs4_layoutcommit_ops = {
5964 .rpc_call_prepare = nfs4_layoutcommit_prepare,
5965 .rpc_call_done = nfs4_layoutcommit_done,
5966 .rpc_release = nfs4_layoutcommit_release,
5967};
5968
5969int
ef311537 5970nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data *data, bool sync)
863a3c6c
AA		 5971{
5972 struct rpc_message msg = {
5973 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTCOMMIT],
5974 .rpc_argp = &data->args,
5975 .rpc_resp = &data->res,
5976 .rpc_cred = data->cred,
5977 };
5978 struct rpc_task_setup task_setup_data = {
5979 .task = &data->task,
5980 .rpc_client = NFS_CLIENT(data->args.inode),
5981 .rpc_message = &msg,
5982 .callback_ops = &nfs4_layoutcommit_ops,
5983 .callback_data = data,
5984 .flags = RPC_TASK_ASYNC,
5985 };
5986 struct rpc_task *task;
5987 int status = 0;
5988
5989 dprintk("NFS: %4d initiating layoutcommit call. sync %d "
5990 "lbw: %llu inode %lu\n",
5991 data->task.tk_pid, sync,
5992 data->args.lastbytewritten,
5993 data->args.inode->i_ino);
5994
5995 task = rpc_run_task(&task_setup_data);
5996 if (IS_ERR(task))
5997 return PTR_ERR(task);
ef311537 5998 if (sync == false)
863a3c6c
AA		 5999 goto out;
6000 status = nfs4_wait_for_completion_rpc_task(task);
6001 if (status != 0)
6002 goto out;
6003 status = task->tk_status;
6004out:
6005 dprintk("%s: status %d\n", __func__, status);
6006 rpc_put_task(task);
6007 return status;
6008}
fca78d6d
BS		 6009
6010static int
6011_nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle,
6012 struct nfs_fsinfo *info, struct nfs4_secinfo_flavors *flavors)
6013{
6014 struct nfs41_secinfo_no_name_args args = {
6015 .style = SECINFO_STYLE_CURRENT_FH,
6016 };
6017 struct nfs4_secinfo_res res = {
6018 .flavors = flavors,
6019 };
6020 struct rpc_message msg = {
6021 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SECINFO_NO_NAME],
6022 .rpc_argp = &args,
6023 .rpc_resp = &res,
6024 };
6025 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
6026}
6027
6028static int
6029nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle,
6030 struct nfs_fsinfo *info, struct nfs4_secinfo_flavors *flavors)
6031{
6032 struct nfs4_exception exception = { };
6033 int err;
6034 do {
6035 err = _nfs41_proc_secinfo_no_name(server, fhandle, info, flavors);
6036 switch (err) {
6037 case 0:
6038 case -NFS4ERR_WRONGSEC:
6039 case -NFS4ERR_NOTSUPP:
6040 break;
6041 default:
6042 err = nfs4_handle_exception(server, err, &exception);
6043 }
6044 } while (exception.retry);
6045 return err;
6046}
6047
6048static int
6049nfs41_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
6050 struct nfs_fsinfo *info)
6051{
6052 int err;
6053 struct page *page;
6054 rpc_authflavor_t flavor;
6055 struct nfs4_secinfo_flavors *flavors;
6056
6057 page = alloc_page(GFP_KERNEL);
6058 if (!page) {
6059 err = -ENOMEM;
6060 goto out;
6061 }
6062
6063 flavors = page_address(page);
6064 err = nfs41_proc_secinfo_no_name(server, fhandle, info, flavors);
6065
6066 /*
6067 * Fall back on "guess and check" method if
6068 * the server doesn't support SECINFO_NO_NAME
6069 */
6070 if (err == -NFS4ERR_WRONGSEC || err == -NFS4ERR_NOTSUPP) {
6071 err = nfs4_find_root_sec(server, fhandle, info);
6072 goto out_freepage;
6073 }
6074 if (err)
6075 goto out_freepage;
6076
6077 flavor = nfs_find_best_sec(flavors);
6078 if (err == 0)
6079 err = nfs4_lookup_root_sec(server, fhandle, info, flavor);
6080
6081out_freepage:
6082 put_page(page);
6083 if (err == -EACCES)
6084 return -EPERM;
6085out:
6086 return err;
6087}
7d974794
BS		 6088static int _nfs41_test_stateid(struct nfs_server *server, struct nfs4_state *state)
6089{
6090 int status;
6091 struct nfs41_test_stateid_args args = {
6092 .stateid = &state->stateid,
6093 };
6094 struct nfs41_test_stateid_res res;
6095 struct rpc_message msg = {
6096 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_TEST_STATEID],
6097 .rpc_argp = &args,
6098 .rpc_resp = &res,
6099 };
6100 args.seq_args.sa_session = res.seq_res.sr_session = NULL;
6101 status = nfs4_call_sync_sequence(server->client, server, &msg, &args.seq_args, &res.seq_res, 0, 1);
6102 return status;
6103}
6104
6105static int nfs41_test_stateid(struct nfs_server *server, struct nfs4_state *state)
6106{
6107 struct nfs4_exception exception = { };
6108 int err;
6109 do {
6110 err = nfs4_handle_exception(server,
6111 _nfs41_test_stateid(server, state),
6112 &exception);
6113 } while (exception.retry);
6114 return err;
6115}
9aeda35f
BS		 6116
6117static int _nfs4_free_stateid(struct nfs_server *server, struct nfs4_state *state)
6118{
6119 int status;
6120 struct nfs41_free_stateid_args args = {
6121 .stateid = &state->stateid,
6122 };
6123 struct nfs41_free_stateid_res res;
6124 struct rpc_message msg = {
6125 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FREE_STATEID],
6126 .rpc_argp = &args,
6127 .rpc_resp = &res,
6128 };
6129
6130 args.seq_args.sa_session = res.seq_res.sr_session = NULL;
6131 status = nfs4_call_sync_sequence(server->client, server, &msg, &args.seq_args, &res.seq_res, 0, 1);
6132 return status;
6133}
6134
6135static int nfs41_free_stateid(struct nfs_server *server, struct nfs4_state *state)
6136{
6137 struct nfs4_exception exception = { };
6138 int err;
6139 do {
6140 err = nfs4_handle_exception(server,
6141 _nfs4_free_stateid(server, state),
6142 &exception);
6143 } while (exception.retry);
6144 return err;
6145}
557134a3
AA		 6146#endif /* CONFIG_NFS_V4_1 */
6147
591d71cb 6148struct nfs4_state_recovery_ops nfs40_reboot_recovery_ops = {
7eff03ae 6149 .owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT,
b79a4a1b 6150 .state_flag_bit = NFS_STATE_RECLAIM_REBOOT,
1da177e4
LT		 6151 .recover_open = nfs4_open_reclaim,
6152 .recover_lock = nfs4_lock_reclaim,
591d71cb 6153 .establish_clid = nfs4_init_clientid,
90a16617 6154 .get_clid_cred = nfs4_get_setclientid_cred,
1da177e4
LT		 6155};
6156
591d71cb
AA		 6157#if defined(CONFIG_NFS_V4_1)
6158struct nfs4_state_recovery_ops nfs41_reboot_recovery_ops = {
6159 .owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT,
6160 .state_flag_bit = NFS_STATE_RECLAIM_REBOOT,
6161 .recover_open = nfs4_open_reclaim,
6162 .recover_lock = nfs4_lock_reclaim,
4d643d1d 6163 .establish_clid = nfs41_init_clientid,
b4b82607 6164 .get_clid_cred = nfs4_get_exchange_id_cred,
fce5c838 6165 .reclaim_complete = nfs41_proc_reclaim_complete,
591d71cb
AA		 6166};
6167#endif /* CONFIG_NFS_V4_1 */
6168
6169struct nfs4_state_recovery_ops nfs40_nograce_recovery_ops = {
6170 .owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE,
6171 .state_flag_bit = NFS_STATE_RECLAIM_NOGRACE,
6172 .recover_open = nfs4_open_expired,
6173 .recover_lock = nfs4_lock_expired,
6174 .establish_clid = nfs4_init_clientid,
90a16617 6175 .get_clid_cred = nfs4_get_setclientid_cred,
591d71cb
AA		 6176};
6177
6178#if defined(CONFIG_NFS_V4_1)
6179struct nfs4_state_recovery_ops nfs41_nograce_recovery_ops = {
7eff03ae 6180 .owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE,
b79a4a1b 6181 .state_flag_bit = NFS_STATE_RECLAIM_NOGRACE,
f062eb6c
BS		 6182 .recover_open = nfs41_open_expired,
6183 .recover_lock = nfs41_lock_expired,
4d643d1d 6184 .establish_clid = nfs41_init_clientid,
b4b82607 6185 .get_clid_cred = nfs4_get_exchange_id_cred,
1da177e4 6186};
591d71cb 6187#endif /* CONFIG_NFS_V4_1 */
1da177e4 6188
29fba38b
BH		 6189struct nfs4_state_maintenance_ops nfs40_state_renewal_ops = {
6190 .sched_state_renewal = nfs4_proc_async_renew,
a7b72103 6191 .get_state_renewal_cred_locked = nfs4_get_renew_cred_locked,
8e69514f 6192 .renew_lease = nfs4_proc_renew,
29fba38b
BH		 6193};
6194
6195#if defined(CONFIG_NFS_V4_1)
6196struct nfs4_state_maintenance_ops nfs41_state_renewal_ops = {
6197 .sched_state_renewal = nfs41_proc_async_sequence,
a7b72103 6198 .get_state_renewal_cred_locked = nfs4_get_machine_cred_locked,
8e69514f 6199 .renew_lease = nfs4_proc_sequence,
29fba38b
BH		 6200};
6201#endif
6202
97dc1359
TM		 6203static const struct nfs4_minor_version_ops nfs_v4_0_minor_ops = {
6204 .minor_version = 0,
6205 .call_sync = _nfs4_call_sync,
e047a10c 6206 .validate_stateid = nfs4_validate_delegation_stateid,
fca78d6d 6207 .find_root_sec = nfs4_find_root_sec,
c48f4f35
TM		 6208 .reboot_recovery_ops = &nfs40_reboot_recovery_ops,
6209 .nograce_recovery_ops = &nfs40_nograce_recovery_ops,
6210 .state_renewal_ops = &nfs40_state_renewal_ops,
97dc1359
TM		 6211};
6212
6213#if defined(CONFIG_NFS_V4_1)
6214static const struct nfs4_minor_version_ops nfs_v4_1_minor_ops = {
6215 .minor_version = 1,
6216 .call_sync = _nfs4_call_sync_session,
e047a10c 6217 .validate_stateid = nfs41_validate_delegation_stateid,
fca78d6d 6218 .find_root_sec = nfs41_find_root_sec,
c48f4f35
TM		 6219 .reboot_recovery_ops = &nfs41_reboot_recovery_ops,
6220 .nograce_recovery_ops = &nfs41_nograce_recovery_ops,
6221 .state_renewal_ops = &nfs41_state_renewal_ops,
97dc1359
TM		 6222};
6223#endif
6224
97dc1359
TM		 6225const struct nfs4_minor_version_ops *nfs_v4_minor_ops[] = {
6226 [0] = &nfs_v4_0_minor_ops,
6227#if defined(CONFIG_NFS_V4_1)
6228 [1] = &nfs_v4_1_minor_ops,
6229#endif
6230};
6231
92e1d5be 6232static const struct inode_operations nfs4_file_inode_operations = {
6b3b5496
BF		 6233 .permission = nfs_permission,
6234 .getattr = nfs_getattr,
6235 .setattr = nfs_setattr,
64c2ce8b
AK		 6236 .getxattr = generic_getxattr,
6237 .setxattr = generic_setxattr,
6238 .listxattr = generic_listxattr,
6239 .removexattr = generic_removexattr,
6b3b5496
BF		 6240};
6241
509de811 6242const struct nfs_rpc_ops nfs_v4_clientops = {
1da177e4
LT		 6243 .version = 4, /* protocol version */
6244 .dentry_ops = &nfs4_dentry_operations,
6245 .dir_inode_ops = &nfs4_dir_inode_operations,
6b3b5496 6246 .file_inode_ops = &nfs4_file_inode_operations,
1788ea6e 6247 .file_ops = &nfs4_file_operations,
1da177e4
LT		 6248 .getroot = nfs4_proc_get_root,
6249 .getattr = nfs4_proc_getattr,
6250 .setattr = nfs4_proc_setattr,
6251 .lookup = nfs4_proc_lookup,
6252 .access = nfs4_proc_access,
6253 .readlink = nfs4_proc_readlink,
1da177e4
LT		 6254 .create = nfs4_proc_create,
6255 .remove = nfs4_proc_remove,
6256 .unlink_setup = nfs4_proc_unlink_setup,
6257 .unlink_done = nfs4_proc_unlink_done,
6258 .rename = nfs4_proc_rename,
d3d4152a
JL		 6259 .rename_setup = nfs4_proc_rename_setup,
6260 .rename_done = nfs4_proc_rename_done,
1da177e4
LT		 6261 .link = nfs4_proc_link,
6262 .symlink = nfs4_proc_symlink,
6263 .mkdir = nfs4_proc_mkdir,
6264 .rmdir = nfs4_proc_remove,
6265 .readdir = nfs4_proc_readdir,
6266 .mknod = nfs4_proc_mknod,
6267 .statfs = nfs4_proc_statfs,
6268 .fsinfo = nfs4_proc_fsinfo,
6269 .pathconf = nfs4_proc_pathconf,
e9326dca 6270 .set_capabilities = nfs4_server_capabilities,
1da177e4
LT		 6271 .decode_dirent = nfs4_decode_dirent,
6272 .read_setup = nfs4_proc_read_setup,
ec06c096 6273 .read_done = nfs4_read_done,
1da177e4 6274 .write_setup = nfs4_proc_write_setup,
788e7a89 6275 .write_done = nfs4_write_done,
1da177e4 6276 .commit_setup = nfs4_proc_commit_setup,
788e7a89 6277 .commit_done = nfs4_commit_done,
1da177e4 6278 .lock = nfs4_proc_lock,
e50a1c2e 6279 .clear_acl_cache = nfs4_zap_acl_attr,
7fe5c398 6280 .close_context = nfs4_close_context,
2b484297 6281 .open_context = nfs4_atomic_open,
45a52a02 6282 .init_client = nfs4_init_client,
5a5ea0d4 6283 .secinfo = nfs4_proc_secinfo,
1da177e4
LT		 6284};
6285
64c2ce8b
AK		 6286static const struct xattr_handler nfs4_xattr_nfs4_acl_handler = {
6287 .prefix = XATTR_NAME_NFSV4_ACL,
6288 .list = nfs4_xattr_list_nfs4_acl,
6289 .get = nfs4_xattr_get_nfs4_acl,
6290 .set = nfs4_xattr_set_nfs4_acl,
6291};
6292
6293const struct xattr_handler *nfs4_xattr_handlers[] = {
6294 &nfs4_xattr_nfs4_acl_handler,
6295 NULL
6296};
6297
1da177e4
LT		 6298/*
6299 * Local variables:
6300 * c-basic-offset: 8
6301 * End:
6302 */
Linux 6.x block layer and io_uring tree(s)