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> 39#include <linux/delay.h> 40#include <linux/errno.h> 41#include <linux/string.h> 42#include <linux/slab.h> 43#include <linux/sunrpc/clnt.h> 44#include <linux/nfs.h> 45#include <linux/nfs4.h> 46#include <linux/nfs_fs.h> 47#include <linux/nfs_page.h> 48#include <linux/namei.h> 49#include <linux/mount.h> 50#include <linux/module.h> 51#include <linux/sunrpc/bc_xprt.h> 52 53#include "nfs4_fs.h" 54#include "delegation.h" 55#include "internal.h" 56#include "iostat.h" 57#include "callback.h" 58 59#define NFSDBG_FACILITY NFSDBG_PROC 60 61#define NFS4_POLL_RETRY_MIN (HZ/10) 62#define NFS4_POLL_RETRY_MAX (15*HZ) 63 64#define NFS4_MAX_LOOP_ON_RECOVER (10) 65 66struct nfs4_opendata; 67static int _nfs4_proc_open(struct nfs4_opendata *data); 68static int _nfs4_recover_proc_open(struct nfs4_opendata *data); 69static int nfs4_do_fsinfo(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *); 70static int nfs4_async_handle_error(struct rpc_task *, const struct nfs_server *, struct nfs4_state *); 71static int _nfs4_proc_lookup(struct inode *dir, const struct qstr *name, struct nfs_fh *fhandle, struct nfs_fattr *fattr); 72static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr); 73static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred, 74 struct nfs_fattr *fattr, struct iattr *sattr, 75 struct nfs4_state *state); 76 77/* Prevent leaks of NFSv4 errors into userland */ 78static int nfs4_map_errors(int err) 79{ 80 if (err >= -1000) 81 return err; 82 switch (err) { 83 case -NFS4ERR_RESOURCE: 84 return -EREMOTEIO; 85 default: 86 dprintk("%s could not handle NFSv4 error %d\n", 87 __func__, -err); 88 break; 89 } 90 return -EIO; 91} 92 93/* 94 * This is our standard bitmap for GETATTR requests. 95 */ 96const u32 nfs4_fattr_bitmap[2] = { 97 FATTR4_WORD0_TYPE 98 | FATTR4_WORD0_CHANGE 99 | FATTR4_WORD0_SIZE 100 | FATTR4_WORD0_FSID 101 | FATTR4_WORD0_FILEID, 102 FATTR4_WORD1_MODE 103 | FATTR4_WORD1_NUMLINKS 104 | FATTR4_WORD1_OWNER 105 | FATTR4_WORD1_OWNER_GROUP 106 | FATTR4_WORD1_RAWDEV 107 | FATTR4_WORD1_SPACE_USED 108 | FATTR4_WORD1_TIME_ACCESS 109 | FATTR4_WORD1_TIME_METADATA 110 | FATTR4_WORD1_TIME_MODIFY 111}; 112 113const u32 nfs4_statfs_bitmap[2] = { 114 FATTR4_WORD0_FILES_AVAIL 115 | FATTR4_WORD0_FILES_FREE 116 | FATTR4_WORD0_FILES_TOTAL, 117 FATTR4_WORD1_SPACE_AVAIL 118 | FATTR4_WORD1_SPACE_FREE 119 | FATTR4_WORD1_SPACE_TOTAL 120}; 121 122const u32 nfs4_pathconf_bitmap[2] = { 123 FATTR4_WORD0_MAXLINK 124 | FATTR4_WORD0_MAXNAME, 125 0 126}; 127 128const u32 nfs4_fsinfo_bitmap[2] = { FATTR4_WORD0_MAXFILESIZE 129 | FATTR4_WORD0_MAXREAD 130 | FATTR4_WORD0_MAXWRITE 131 | FATTR4_WORD0_LEASE_TIME, 132 0 133}; 134 135const u32 nfs4_fs_locations_bitmap[2] = { 136 FATTR4_WORD0_TYPE 137 | FATTR4_WORD0_CHANGE 138 | FATTR4_WORD0_SIZE 139 | FATTR4_WORD0_FSID 140 | FATTR4_WORD0_FILEID 141 | FATTR4_WORD0_FS_LOCATIONS, 142 FATTR4_WORD1_MODE 143 | FATTR4_WORD1_NUMLINKS 144 | FATTR4_WORD1_OWNER 145 | FATTR4_WORD1_OWNER_GROUP 146 | FATTR4_WORD1_RAWDEV 147 | FATTR4_WORD1_SPACE_USED 148 | FATTR4_WORD1_TIME_ACCESS 149 | FATTR4_WORD1_TIME_METADATA 150 | FATTR4_WORD1_TIME_MODIFY 151 | FATTR4_WORD1_MOUNTED_ON_FILEID 152}; 153 154static void nfs4_setup_readdir(u64 cookie, __be32 *verifier, struct dentry *dentry, 155 struct nfs4_readdir_arg *readdir) 156{ 157 __be32 *start, *p; 158 159 BUG_ON(readdir->count < 80); 160 if (cookie > 2) { 161 readdir->cookie = cookie; 162 memcpy(&readdir->verifier, verifier, sizeof(readdir->verifier)); 163 return; 164 } 165 166 readdir->cookie = 0; 167 memset(&readdir->verifier, 0, sizeof(readdir->verifier)); 168 if (cookie == 2) 169 return; 170 171 /* 172 * NFSv4 servers do not return entries for '.' and '..' 173 * Therefore, we fake these entries here. We let '.' 174 * have cookie 0 and '..' have cookie 1. Note that 175 * when talking to the server, we always send cookie 0 176 * instead of 1 or 2. 177 */ 178 start = p = kmap_atomic(*readdir->pages, KM_USER0); 179 180 if (cookie == 0) { 181 *p++ = xdr_one; /* next */ 182 *p++ = xdr_zero; /* cookie, first word */ 183 *p++ = xdr_one; /* cookie, second word */ 184 *p++ = xdr_one; /* entry len */ 185 memcpy(p, ".\0\0\0", 4); /* entry */ 186 p++; 187 *p++ = xdr_one; /* bitmap length */ 188 *p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */ 189 *p++ = htonl(8); /* attribute buffer length */ 190 p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_inode)); 191 } 192 193 *p++ = xdr_one; /* next */ 194 *p++ = xdr_zero; /* cookie, first word */ 195 *p++ = xdr_two; /* cookie, second word */ 196 *p++ = xdr_two; /* entry len */ 197 memcpy(p, "..\0\0", 4); /* entry */ 198 p++; 199 *p++ = xdr_one; /* bitmap length */ 200 *p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */ 201 *p++ = htonl(8); /* attribute buffer length */ 202 p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_parent->d_inode)); 203 204 readdir->pgbase = (char *)p - (char *)start; 205 readdir->count -= readdir->pgbase; 206 kunmap_atomic(start, KM_USER0); 207} 208 209static int nfs4_wait_clnt_recover(struct nfs_client *clp) 210{ 211 int res; 212 213 might_sleep(); 214 215 res = wait_on_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING, 216 nfs_wait_bit_killable, TASK_KILLABLE); 217 return res; 218} 219 220static int nfs4_delay(struct rpc_clnt *clnt, long *timeout) 221{ 222 int res = 0; 223 224 might_sleep(); 225 226 if (*timeout <= 0) 227 *timeout = NFS4_POLL_RETRY_MIN; 228 if (*timeout > NFS4_POLL_RETRY_MAX) 229 *timeout = NFS4_POLL_RETRY_MAX; 230 schedule_timeout_killable(*timeout); 231 if (fatal_signal_pending(current)) 232 res = -ERESTARTSYS; 233 *timeout <<= 1; 234 return res; 235} 236 237/* This is the error handling routine for processes that are allowed 238 * to sleep. 239 */ 240static int nfs4_handle_exception(const struct nfs_server *server, int errorcode, struct nfs4_exception *exception) 241{ 242 struct nfs_client *clp = server->nfs_client; 243 struct nfs4_state *state = exception->state; 244 int ret = errorcode; 245 246 exception->retry = 0; 247 switch(errorcode) { 248 case 0: 249 return 0; 250 case -NFS4ERR_ADMIN_REVOKED: 251 case -NFS4ERR_BAD_STATEID: 252 case -NFS4ERR_OPENMODE: 253 if (state == NULL) 254 break; 255 nfs4_state_mark_reclaim_nograce(clp, state); 256 goto do_state_recovery; 257 case -NFS4ERR_STALE_STATEID: 258 case -NFS4ERR_STALE_CLIENTID: 259 case -NFS4ERR_EXPIRED: 260 goto do_state_recovery; 261#if defined(CONFIG_NFS_V4_1) 262 case -NFS4ERR_BADSESSION: 263 case -NFS4ERR_BADSLOT: 264 case -NFS4ERR_BAD_HIGH_SLOT: 265 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 266 case -NFS4ERR_DEADSESSION: 267 case -NFS4ERR_SEQ_FALSE_RETRY: 268 case -NFS4ERR_SEQ_MISORDERED: 269 dprintk("%s ERROR: %d Reset session\n", __func__, 270 errorcode); 271 nfs4_schedule_state_recovery(clp); 272 exception->retry = 1; 273 break; 274#endif /* defined(CONFIG_NFS_V4_1) */ 275 case -NFS4ERR_FILE_OPEN: 276 if (exception->timeout > HZ) { 277 /* We have retried a decent amount, time to 278 * fail 279 */ 280 ret = -EBUSY; 281 break; 282 } 283 case -NFS4ERR_GRACE: 284 case -NFS4ERR_DELAY: 285 case -EKEYEXPIRED: 286 ret = nfs4_delay(server->client, &exception->timeout); 287 if (ret != 0) 288 break; 289 case -NFS4ERR_OLD_STATEID: 290 exception->retry = 1; 291 } 292 /* We failed to handle the error */ 293 return nfs4_map_errors(ret); 294do_state_recovery: 295 nfs4_schedule_state_recovery(clp); 296 ret = nfs4_wait_clnt_recover(clp); 297 if (ret == 0) 298 exception->retry = 1; 299 return ret; 300} 301 302 303static void do_renew_lease(struct nfs_client *clp, unsigned long timestamp) 304{ 305 spin_lock(&clp->cl_lock); 306 if (time_before(clp->cl_last_renewal,timestamp)) 307 clp->cl_last_renewal = timestamp; 308 spin_unlock(&clp->cl_lock); 309} 310 311static void renew_lease(const struct nfs_server *server, unsigned long timestamp) 312{ 313 do_renew_lease(server->nfs_client, timestamp); 314} 315 316#if defined(CONFIG_NFS_V4_1) 317 318/* 319 * nfs4_free_slot - free a slot and efficiently update slot table. 320 * 321 * freeing a slot is trivially done by clearing its respective bit 322 * in the bitmap. 323 * If the freed slotid equals highest_used_slotid we want to update it 324 * so that the server would be able to size down the slot table if needed, 325 * otherwise we know that the highest_used_slotid is still in use. 326 * When updating highest_used_slotid there may be "holes" in the bitmap 327 * so we need to scan down from highest_used_slotid to 0 looking for the now 328 * highest slotid in use. 329 * If none found, highest_used_slotid is set to -1. 330 * 331 * Must be called while holding tbl->slot_tbl_lock 332 */ 333static void 334nfs4_free_slot(struct nfs4_slot_table *tbl, u8 free_slotid) 335{ 336 int slotid = free_slotid; 337 338 /* clear used bit in bitmap */ 339 __clear_bit(slotid, tbl->used_slots); 340 341 /* update highest_used_slotid when it is freed */ 342 if (slotid == tbl->highest_used_slotid) { 343 slotid = find_last_bit(tbl->used_slots, tbl->max_slots); 344 if (slotid < tbl->max_slots) 345 tbl->highest_used_slotid = slotid; 346 else 347 tbl->highest_used_slotid = -1; 348 } 349 dprintk("%s: free_slotid %u highest_used_slotid %d\n", __func__, 350 free_slotid, tbl->highest_used_slotid); 351} 352 353/* 354 * Signal state manager thread if session is drained 355 */ 356static void nfs41_check_drain_session_complete(struct nfs4_session *ses) 357{ 358 struct rpc_task *task; 359 360 if (!test_bit(NFS4_SESSION_DRAINING, &ses->session_state)) { 361 task = rpc_wake_up_next(&ses->fc_slot_table.slot_tbl_waitq); 362 if (task) 363 rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED); 364 return; 365 } 366 367 if (ses->fc_slot_table.highest_used_slotid != -1) 368 return; 369 370 dprintk("%s COMPLETE: Session Drained\n", __func__); 371 complete(&ses->complete); 372} 373 374static void nfs41_sequence_free_slot(struct nfs4_sequence_res *res) 375{ 376 struct nfs4_slot_table *tbl; 377 378 tbl = &res->sr_session->fc_slot_table; 379 if (res->sr_slotid == NFS4_MAX_SLOT_TABLE) { 380 /* just wake up the next guy waiting since 381 * we may have not consumed a slot after all */ 382 dprintk("%s: No slot\n", __func__); 383 return; 384 } 385 386 spin_lock(&tbl->slot_tbl_lock); 387 nfs4_free_slot(tbl, res->sr_slotid); 388 nfs41_check_drain_session_complete(res->sr_session); 389 spin_unlock(&tbl->slot_tbl_lock); 390 res->sr_slotid = NFS4_MAX_SLOT_TABLE; 391} 392 393static int nfs41_sequence_done(struct rpc_task *task, struct nfs4_sequence_res *res) 394{ 395 unsigned long timestamp; 396 struct nfs4_slot_table *tbl; 397 struct nfs4_slot *slot; 398 struct nfs_client *clp; 399 400 /* 401 * sr_status remains 1 if an RPC level error occurred. The server 402 * may or may not have processed the sequence operation.. 403 * Proceed as if the server received and processed the sequence 404 * operation. 405 */ 406 if (res->sr_status == 1) 407 res->sr_status = NFS_OK; 408 409 /* -ERESTARTSYS can result in skipping nfs41_sequence_setup */ 410 if (res->sr_slotid == NFS4_MAX_SLOT_TABLE) 411 goto out; 412 413 tbl = &res->sr_session->fc_slot_table; 414 slot = tbl->slots + res->sr_slotid; 415 416 /* Check the SEQUENCE operation status */ 417 switch (res->sr_status) { 418 case 0: 419 /* Update the slot's sequence and clientid lease timer */ 420 ++slot->seq_nr; 421 timestamp = res->sr_renewal_time; 422 clp = res->sr_session->clp; 423 do_renew_lease(clp, timestamp); 424 /* Check sequence flags */ 425 if (atomic_read(&clp->cl_count) > 1) 426 nfs41_handle_sequence_flag_errors(clp, res->sr_status_flags); 427 break; 428 case -NFS4ERR_DELAY: 429 /* The server detected a resend of the RPC call and 430 * returned NFS4ERR_DELAY as per Section 2.10.6.2 431 * of RFC5661. 432 */ 433 dprintk("%s: slot=%d seq=%d: Operation in progress\n", 434 __func__, res->sr_slotid, slot->seq_nr); 435 goto out_retry; 436 default: 437 /* Just update the slot sequence no. */ 438 ++slot->seq_nr; 439 } 440out: 441 /* The session may be reset by one of the error handlers. */ 442 dprintk("%s: Error %d free the slot \n", __func__, res->sr_status); 443 nfs41_sequence_free_slot(res); 444 return 1; 445out_retry: 446 if (!rpc_restart_call(task)) 447 goto out; 448 rpc_delay(task, NFS4_POLL_RETRY_MAX); 449 return 0; 450} 451 452static int nfs4_sequence_done(struct rpc_task *task, 453 struct nfs4_sequence_res *res) 454{ 455 if (res->sr_session == NULL) 456 return 1; 457 return nfs41_sequence_done(task, res); 458} 459 460/* 461 * nfs4_find_slot - efficiently look for a free slot 462 * 463 * nfs4_find_slot looks for an unset bit in the used_slots bitmap. 464 * If found, we mark the slot as used, update the highest_used_slotid, 465 * and respectively set up the sequence operation args. 466 * The slot number is returned if found, or NFS4_MAX_SLOT_TABLE otherwise. 467 * 468 * Note: must be called with under the slot_tbl_lock. 469 */ 470static u8 471nfs4_find_slot(struct nfs4_slot_table *tbl) 472{ 473 int slotid; 474 u8 ret_id = NFS4_MAX_SLOT_TABLE; 475 BUILD_BUG_ON((u8)NFS4_MAX_SLOT_TABLE != (int)NFS4_MAX_SLOT_TABLE); 476 477 dprintk("--> %s used_slots=%04lx highest_used=%d max_slots=%d\n", 478 __func__, tbl->used_slots[0], tbl->highest_used_slotid, 479 tbl->max_slots); 480 slotid = find_first_zero_bit(tbl->used_slots, tbl->max_slots); 481 if (slotid >= tbl->max_slots) 482 goto out; 483 __set_bit(slotid, tbl->used_slots); 484 if (slotid > tbl->highest_used_slotid) 485 tbl->highest_used_slotid = slotid; 486 ret_id = slotid; 487out: 488 dprintk("<-- %s used_slots=%04lx highest_used=%d slotid=%d \n", 489 __func__, tbl->used_slots[0], tbl->highest_used_slotid, ret_id); 490 return ret_id; 491} 492 493static int nfs41_setup_sequence(struct nfs4_session *session, 494 struct nfs4_sequence_args *args, 495 struct nfs4_sequence_res *res, 496 int cache_reply, 497 struct rpc_task *task) 498{ 499 struct nfs4_slot *slot; 500 struct nfs4_slot_table *tbl; 501 u8 slotid; 502 503 dprintk("--> %s\n", __func__); 504 /* slot already allocated? */ 505 if (res->sr_slotid != NFS4_MAX_SLOT_TABLE) 506 return 0; 507 508 res->sr_slotid = NFS4_MAX_SLOT_TABLE; 509 tbl = &session->fc_slot_table; 510 511 spin_lock(&tbl->slot_tbl_lock); 512 if (test_bit(NFS4_SESSION_DRAINING, &session->session_state) && 513 !rpc_task_has_priority(task, RPC_PRIORITY_PRIVILEGED)) { 514 /* 515 * The state manager will wait until the slot table is empty. 516 * Schedule the reset thread 517 */ 518 rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL); 519 spin_unlock(&tbl->slot_tbl_lock); 520 dprintk("%s Schedule Session Reset\n", __func__); 521 return -EAGAIN; 522 } 523 524 if (!rpc_queue_empty(&tbl->slot_tbl_waitq) && 525 !rpc_task_has_priority(task, RPC_PRIORITY_PRIVILEGED)) { 526 rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL); 527 spin_unlock(&tbl->slot_tbl_lock); 528 dprintk("%s enforce FIFO order\n", __func__); 529 return -EAGAIN; 530 } 531 532 slotid = nfs4_find_slot(tbl); 533 if (slotid == NFS4_MAX_SLOT_TABLE) { 534 rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL); 535 spin_unlock(&tbl->slot_tbl_lock); 536 dprintk("<-- %s: no free slots\n", __func__); 537 return -EAGAIN; 538 } 539 spin_unlock(&tbl->slot_tbl_lock); 540 541 rpc_task_set_priority(task, RPC_PRIORITY_NORMAL); 542 slot = tbl->slots + slotid; 543 args->sa_session = session; 544 args->sa_slotid = slotid; 545 args->sa_cache_this = cache_reply; 546 547 dprintk("<-- %s slotid=%d seqid=%d\n", __func__, slotid, slot->seq_nr); 548 549 res->sr_session = session; 550 res->sr_slotid = slotid; 551 res->sr_renewal_time = jiffies; 552 res->sr_status_flags = 0; 553 /* 554 * sr_status is only set in decode_sequence, and so will remain 555 * set to 1 if an rpc level failure occurs. 556 */ 557 res->sr_status = 1; 558 return 0; 559} 560 561int nfs4_setup_sequence(const struct nfs_server *server, 562 struct nfs4_sequence_args *args, 563 struct nfs4_sequence_res *res, 564 int cache_reply, 565 struct rpc_task *task) 566{ 567 struct nfs4_session *session = nfs4_get_session(server); 568 int ret = 0; 569 570 if (session == NULL) { 571 args->sa_session = NULL; 572 res->sr_session = NULL; 573 goto out; 574 } 575 576 dprintk("--> %s clp %p session %p sr_slotid %d\n", 577 __func__, session->clp, session, res->sr_slotid); 578 579 ret = nfs41_setup_sequence(session, args, res, cache_reply, 580 task); 581out: 582 dprintk("<-- %s status=%d\n", __func__, ret); 583 return ret; 584} 585 586struct nfs41_call_sync_data { 587 const struct nfs_server *seq_server; 588 struct nfs4_sequence_args *seq_args; 589 struct nfs4_sequence_res *seq_res; 590 int cache_reply; 591}; 592 593static void nfs41_call_sync_prepare(struct rpc_task *task, void *calldata) 594{ 595 struct nfs41_call_sync_data *data = calldata; 596 597 dprintk("--> %s data->seq_server %p\n", __func__, data->seq_server); 598 599 if (nfs4_setup_sequence(data->seq_server, data->seq_args, 600 data->seq_res, data->cache_reply, task)) 601 return; 602 rpc_call_start(task); 603} 604 605static void nfs41_call_priv_sync_prepare(struct rpc_task *task, void *calldata) 606{ 607 rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED); 608 nfs41_call_sync_prepare(task, calldata); 609} 610 611static void nfs41_call_sync_done(struct rpc_task *task, void *calldata) 612{ 613 struct nfs41_call_sync_data *data = calldata; 614 615 nfs41_sequence_done(task, data->seq_res); 616} 617 618struct rpc_call_ops nfs41_call_sync_ops = { 619 .rpc_call_prepare = nfs41_call_sync_prepare, 620 .rpc_call_done = nfs41_call_sync_done, 621}; 622 623struct rpc_call_ops nfs41_call_priv_sync_ops = { 624 .rpc_call_prepare = nfs41_call_priv_sync_prepare, 625 .rpc_call_done = nfs41_call_sync_done, 626}; 627 628static int nfs4_call_sync_sequence(struct nfs_server *server, 629 struct rpc_message *msg, 630 struct nfs4_sequence_args *args, 631 struct nfs4_sequence_res *res, 632 int cache_reply, 633 int privileged) 634{ 635 int ret; 636 struct rpc_task *task; 637 struct nfs41_call_sync_data data = { 638 .seq_server = server, 639 .seq_args = args, 640 .seq_res = res, 641 .cache_reply = cache_reply, 642 }; 643 struct rpc_task_setup task_setup = { 644 .rpc_client = server->client, 645 .rpc_message = msg, 646 .callback_ops = &nfs41_call_sync_ops, 647 .callback_data = &data 648 }; 649 650 res->sr_slotid = NFS4_MAX_SLOT_TABLE; 651 if (privileged) 652 task_setup.callback_ops = &nfs41_call_priv_sync_ops; 653 task = rpc_run_task(&task_setup); 654 if (IS_ERR(task)) 655 ret = PTR_ERR(task); 656 else { 657 ret = task->tk_status; 658 rpc_put_task(task); 659 } 660 return ret; 661} 662 663int _nfs4_call_sync_session(struct nfs_server *server, 664 struct rpc_message *msg, 665 struct nfs4_sequence_args *args, 666 struct nfs4_sequence_res *res, 667 int cache_reply) 668{ 669 return nfs4_call_sync_sequence(server, msg, args, res, cache_reply, 0); 670} 671 672#else 673static int nfs4_sequence_done(struct rpc_task *task, 674 struct nfs4_sequence_res *res) 675{ 676 return 1; 677} 678#endif /* CONFIG_NFS_V4_1 */ 679 680int _nfs4_call_sync(struct nfs_server *server, 681 struct rpc_message *msg, 682 struct nfs4_sequence_args *args, 683 struct nfs4_sequence_res *res, 684 int cache_reply) 685{ 686 args->sa_session = res->sr_session = NULL; 687 return rpc_call_sync(server->client, msg, 0); 688} 689 690#define nfs4_call_sync(server, msg, args, res, cache_reply) \ 691 (server)->nfs_client->cl_mvops->call_sync((server), (msg), &(args)->seq_args, \ 692 &(res)->seq_res, (cache_reply)) 693 694static void update_changeattr(struct inode *dir, struct nfs4_change_info *cinfo) 695{ 696 struct nfs_inode *nfsi = NFS_I(dir); 697 698 spin_lock(&dir->i_lock); 699 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE|NFS_INO_INVALID_DATA; 700 if (!cinfo->atomic || cinfo->before != nfsi->change_attr) 701 nfs_force_lookup_revalidate(dir); 702 nfsi->change_attr = cinfo->after; 703 spin_unlock(&dir->i_lock); 704} 705 706struct nfs4_opendata { 707 struct kref kref; 708 struct nfs_openargs o_arg; 709 struct nfs_openres o_res; 710 struct nfs_open_confirmargs c_arg; 711 struct nfs_open_confirmres c_res; 712 struct nfs_fattr f_attr; 713 struct nfs_fattr dir_attr; 714 struct path path; 715 struct dentry *dir; 716 struct nfs4_state_owner *owner; 717 struct nfs4_state *state; 718 struct iattr attrs; 719 unsigned long timestamp; 720 unsigned int rpc_done : 1; 721 int rpc_status; 722 int cancelled; 723}; 724 725 726static void nfs4_init_opendata_res(struct nfs4_opendata *p) 727{ 728 p->o_res.f_attr = &p->f_attr; 729 p->o_res.dir_attr = &p->dir_attr; 730 p->o_res.seqid = p->o_arg.seqid; 731 p->c_res.seqid = p->c_arg.seqid; 732 p->o_res.server = p->o_arg.server; 733 nfs_fattr_init(&p->f_attr); 734 nfs_fattr_init(&p->dir_attr); 735 p->o_res.seq_res.sr_slotid = NFS4_MAX_SLOT_TABLE; 736} 737 738static struct nfs4_opendata *nfs4_opendata_alloc(struct path *path, 739 struct nfs4_state_owner *sp, fmode_t fmode, int flags, 740 const struct iattr *attrs, 741 gfp_t gfp_mask) 742{ 743 struct dentry *parent = dget_parent(path->dentry); 744 struct inode *dir = parent->d_inode; 745 struct nfs_server *server = NFS_SERVER(dir); 746 struct nfs4_opendata *p; 747 748 p = kzalloc(sizeof(*p), gfp_mask); 749 if (p == NULL) 750 goto err; 751 p->o_arg.seqid = nfs_alloc_seqid(&sp->so_seqid, gfp_mask); 752 if (p->o_arg.seqid == NULL) 753 goto err_free; 754 path_get(path); 755 p->path = *path; 756 p->dir = parent; 757 p->owner = sp; 758 atomic_inc(&sp->so_count); 759 p->o_arg.fh = NFS_FH(dir); 760 p->o_arg.open_flags = flags; 761 p->o_arg.fmode = fmode & (FMODE_READ|FMODE_WRITE); 762 p->o_arg.clientid = server->nfs_client->cl_clientid; 763 p->o_arg.id = sp->so_owner_id.id; 764 p->o_arg.name = &p->path.dentry->d_name; 765 p->o_arg.server = server; 766 p->o_arg.bitmask = server->attr_bitmask; 767 p->o_arg.claim = NFS4_OPEN_CLAIM_NULL; 768 if (flags & O_CREAT) { 769 u32 *s; 770 771 p->o_arg.u.attrs = &p->attrs; 772 memcpy(&p->attrs, attrs, sizeof(p->attrs)); 773 s = (u32 *) p->o_arg.u.verifier.data; 774 s[0] = jiffies; 775 s[1] = current->pid; 776 } 777 p->c_arg.fh = &p->o_res.fh; 778 p->c_arg.stateid = &p->o_res.stateid; 779 p->c_arg.seqid = p->o_arg.seqid; 780 nfs4_init_opendata_res(p); 781 kref_init(&p->kref); 782 return p; 783err_free: 784 kfree(p); 785err: 786 dput(parent); 787 return NULL; 788} 789 790static void nfs4_opendata_free(struct kref *kref) 791{ 792 struct nfs4_opendata *p = container_of(kref, 793 struct nfs4_opendata, kref); 794 795 nfs_free_seqid(p->o_arg.seqid); 796 if (p->state != NULL) 797 nfs4_put_open_state(p->state); 798 nfs4_put_state_owner(p->owner); 799 dput(p->dir); 800 path_put(&p->path); 801 kfree(p); 802} 803 804static void nfs4_opendata_put(struct nfs4_opendata *p) 805{ 806 if (p != NULL) 807 kref_put(&p->kref, nfs4_opendata_free); 808} 809 810static int nfs4_wait_for_completion_rpc_task(struct rpc_task *task) 811{ 812 int ret; 813 814 ret = rpc_wait_for_completion_task(task); 815 return ret; 816} 817 818static int can_open_cached(struct nfs4_state *state, fmode_t mode, int open_mode) 819{ 820 int ret = 0; 821 822 if (open_mode & O_EXCL) 823 goto out; 824 switch (mode & (FMODE_READ|FMODE_WRITE)) { 825 case FMODE_READ: 826 ret |= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0 827 && state->n_rdonly != 0; 828 break; 829 case FMODE_WRITE: 830 ret |= test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0 831 && state->n_wronly != 0; 832 break; 833 case FMODE_READ|FMODE_WRITE: 834 ret |= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0 835 && state->n_rdwr != 0; 836 } 837out: 838 return ret; 839} 840 841static int can_open_delegated(struct nfs_delegation *delegation, fmode_t fmode) 842{ 843 if ((delegation->type & fmode) != fmode) 844 return 0; 845 if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags)) 846 return 0; 847 nfs_mark_delegation_referenced(delegation); 848 return 1; 849} 850 851static void update_open_stateflags(struct nfs4_state *state, fmode_t fmode) 852{ 853 switch (fmode) { 854 case FMODE_WRITE: 855 state->n_wronly++; 856 break; 857 case FMODE_READ: 858 state->n_rdonly++; 859 break; 860 case FMODE_READ|FMODE_WRITE: 861 state->n_rdwr++; 862 } 863 nfs4_state_set_mode_locked(state, state->state | fmode); 864} 865 866static void nfs_set_open_stateid_locked(struct nfs4_state *state, nfs4_stateid *stateid, fmode_t fmode) 867{ 868 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) 869 memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data)); 870 memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data)); 871 switch (fmode) { 872 case FMODE_READ: 873 set_bit(NFS_O_RDONLY_STATE, &state->flags); 874 break; 875 case FMODE_WRITE: 876 set_bit(NFS_O_WRONLY_STATE, &state->flags); 877 break; 878 case FMODE_READ|FMODE_WRITE: 879 set_bit(NFS_O_RDWR_STATE, &state->flags); 880 } 881} 882 883static void nfs_set_open_stateid(struct nfs4_state *state, nfs4_stateid *stateid, fmode_t fmode) 884{ 885 write_seqlock(&state->seqlock); 886 nfs_set_open_stateid_locked(state, stateid, fmode); 887 write_sequnlock(&state->seqlock); 888} 889 890static void __update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_stateid, const nfs4_stateid *deleg_stateid, fmode_t fmode) 891{ 892 /* 893 * Protect the call to nfs4_state_set_mode_locked and 894 * serialise the stateid update 895 */ 896 write_seqlock(&state->seqlock); 897 if (deleg_stateid != NULL) { 898 memcpy(state->stateid.data, deleg_stateid->data, sizeof(state->stateid.data)); 899 set_bit(NFS_DELEGATED_STATE, &state->flags); 900 } 901 if (open_stateid != NULL) 902 nfs_set_open_stateid_locked(state, open_stateid, fmode); 903 write_sequnlock(&state->seqlock); 904 spin_lock(&state->owner->so_lock); 905 update_open_stateflags(state, fmode); 906 spin_unlock(&state->owner->so_lock); 907} 908 909static int update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_stateid, nfs4_stateid *delegation, fmode_t fmode) 910{ 911 struct nfs_inode *nfsi = NFS_I(state->inode); 912 struct nfs_delegation *deleg_cur; 913 int ret = 0; 914 915 fmode &= (FMODE_READ|FMODE_WRITE); 916 917 rcu_read_lock(); 918 deleg_cur = rcu_dereference(nfsi->delegation); 919 if (deleg_cur == NULL) 920 goto no_delegation; 921 922 spin_lock(&deleg_cur->lock); 923 if (nfsi->delegation != deleg_cur || 924 (deleg_cur->type & fmode) != fmode) 925 goto no_delegation_unlock; 926 927 if (delegation == NULL) 928 delegation = &deleg_cur->stateid; 929 else if (memcmp(deleg_cur->stateid.data, delegation->data, NFS4_STATEID_SIZE) != 0) 930 goto no_delegation_unlock; 931 932 nfs_mark_delegation_referenced(deleg_cur); 933 __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode); 934 ret = 1; 935no_delegation_unlock: 936 spin_unlock(&deleg_cur->lock); 937no_delegation: 938 rcu_read_unlock(); 939 940 if (!ret && open_stateid != NULL) { 941 __update_open_stateid(state, open_stateid, NULL, fmode); 942 ret = 1; 943 } 944 945 return ret; 946} 947 948 949static void nfs4_return_incompatible_delegation(struct inode *inode, fmode_t fmode) 950{ 951 struct nfs_delegation *delegation; 952 953 rcu_read_lock(); 954 delegation = rcu_dereference(NFS_I(inode)->delegation); 955 if (delegation == NULL || (delegation->type & fmode) == fmode) { 956 rcu_read_unlock(); 957 return; 958 } 959 rcu_read_unlock(); 960 nfs_inode_return_delegation(inode); 961} 962 963static struct nfs4_state *nfs4_try_open_cached(struct nfs4_opendata *opendata) 964{ 965 struct nfs4_state *state = opendata->state; 966 struct nfs_inode *nfsi = NFS_I(state->inode); 967 struct nfs_delegation *delegation; 968 int open_mode = opendata->o_arg.open_flags & O_EXCL; 969 fmode_t fmode = opendata->o_arg.fmode; 970 nfs4_stateid stateid; 971 int ret = -EAGAIN; 972 973 for (;;) { 974 if (can_open_cached(state, fmode, open_mode)) { 975 spin_lock(&state->owner->so_lock); 976 if (can_open_cached(state, fmode, open_mode)) { 977 update_open_stateflags(state, fmode); 978 spin_unlock(&state->owner->so_lock); 979 goto out_return_state; 980 } 981 spin_unlock(&state->owner->so_lock); 982 } 983 rcu_read_lock(); 984 delegation = rcu_dereference(nfsi->delegation); 985 if (delegation == NULL || 986 !can_open_delegated(delegation, fmode)) { 987 rcu_read_unlock(); 988 break; 989 } 990 /* Save the delegation */ 991 memcpy(stateid.data, delegation->stateid.data, sizeof(stateid.data)); 992 rcu_read_unlock(); 993 ret = nfs_may_open(state->inode, state->owner->so_cred, open_mode); 994 if (ret != 0) 995 goto out; 996 ret = -EAGAIN; 997 998 /* Try to update the stateid using the delegation */ 999 if (update_open_stateid(state, NULL, &stateid, fmode)) 1000 goto out_return_state; 1001 } 1002out: 1003 return ERR_PTR(ret); 1004out_return_state: 1005 atomic_inc(&state->count); 1006 return state; 1007} 1008 1009static struct nfs4_state *nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data) 1010{ 1011 struct inode *inode; 1012 struct nfs4_state *state = NULL; 1013 struct nfs_delegation *delegation; 1014 int ret; 1015 1016 if (!data->rpc_done) { 1017 state = nfs4_try_open_cached(data); 1018 goto out; 1019 } 1020 1021 ret = -EAGAIN; 1022 if (!(data->f_attr.valid & NFS_ATTR_FATTR)) 1023 goto err; 1024 inode = nfs_fhget(data->dir->d_sb, &data->o_res.fh, &data->f_attr); 1025 ret = PTR_ERR(inode); 1026 if (IS_ERR(inode)) 1027 goto err; 1028 ret = -ENOMEM; 1029 state = nfs4_get_open_state(inode, data->owner); 1030 if (state == NULL) 1031 goto err_put_inode; 1032 if (data->o_res.delegation_type != 0) { 1033 int delegation_flags = 0; 1034 1035 rcu_read_lock(); 1036 delegation = rcu_dereference(NFS_I(inode)->delegation); 1037 if (delegation) 1038 delegation_flags = delegation->flags; 1039 rcu_read_unlock(); 1040 if ((delegation_flags & 1UL<<NFS_DELEGATION_NEED_RECLAIM) == 0) 1041 nfs_inode_set_delegation(state->inode, 1042 data->owner->so_cred, 1043 &data->o_res); 1044 else 1045 nfs_inode_reclaim_delegation(state->inode, 1046 data->owner->so_cred, 1047 &data->o_res); 1048 } 1049 1050 update_open_stateid(state, &data->o_res.stateid, NULL, 1051 data->o_arg.fmode); 1052 iput(inode); 1053out: 1054 return state; 1055err_put_inode: 1056 iput(inode); 1057err: 1058 return ERR_PTR(ret); 1059} 1060 1061static struct nfs_open_context *nfs4_state_find_open_context(struct nfs4_state *state) 1062{ 1063 struct nfs_inode *nfsi = NFS_I(state->inode); 1064 struct nfs_open_context *ctx; 1065 1066 spin_lock(&state->inode->i_lock); 1067 list_for_each_entry(ctx, &nfsi->open_files, list) { 1068 if (ctx->state != state) 1069 continue; 1070 get_nfs_open_context(ctx); 1071 spin_unlock(&state->inode->i_lock); 1072 return ctx; 1073 } 1074 spin_unlock(&state->inode->i_lock); 1075 return ERR_PTR(-ENOENT); 1076} 1077 1078static struct nfs4_opendata *nfs4_open_recoverdata_alloc(struct nfs_open_context *ctx, struct nfs4_state *state) 1079{ 1080 struct nfs4_opendata *opendata; 1081 1082 opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, 0, NULL, GFP_NOFS); 1083 if (opendata == NULL) 1084 return ERR_PTR(-ENOMEM); 1085 opendata->state = state; 1086 atomic_inc(&state->count); 1087 return opendata; 1088} 1089 1090static int nfs4_open_recover_helper(struct nfs4_opendata *opendata, fmode_t fmode, struct nfs4_state **res) 1091{ 1092 struct nfs4_state *newstate; 1093 int ret; 1094 1095 opendata->o_arg.open_flags = 0; 1096 opendata->o_arg.fmode = fmode; 1097 memset(&opendata->o_res, 0, sizeof(opendata->o_res)); 1098 memset(&opendata->c_res, 0, sizeof(opendata->c_res)); 1099 nfs4_init_opendata_res(opendata); 1100 ret = _nfs4_recover_proc_open(opendata); 1101 if (ret != 0) 1102 return ret; 1103 newstate = nfs4_opendata_to_nfs4_state(opendata); 1104 if (IS_ERR(newstate)) 1105 return PTR_ERR(newstate); 1106 nfs4_close_state(&opendata->path, newstate, fmode); 1107 *res = newstate; 1108 return 0; 1109} 1110 1111static int nfs4_open_recover(struct nfs4_opendata *opendata, struct nfs4_state *state) 1112{ 1113 struct nfs4_state *newstate; 1114 int ret; 1115 1116 /* memory barrier prior to reading state->n_* */ 1117 clear_bit(NFS_DELEGATED_STATE, &state->flags); 1118 smp_rmb(); 1119 if (state->n_rdwr != 0) { 1120 clear_bit(NFS_O_RDWR_STATE, &state->flags); 1121 ret = nfs4_open_recover_helper(opendata, FMODE_READ|FMODE_WRITE, &newstate); 1122 if (ret != 0) 1123 return ret; 1124 if (newstate != state) 1125 return -ESTALE; 1126 } 1127 if (state->n_wronly != 0) { 1128 clear_bit(NFS_O_WRONLY_STATE, &state->flags); 1129 ret = nfs4_open_recover_helper(opendata, FMODE_WRITE, &newstate); 1130 if (ret != 0) 1131 return ret; 1132 if (newstate != state) 1133 return -ESTALE; 1134 } 1135 if (state->n_rdonly != 0) { 1136 clear_bit(NFS_O_RDONLY_STATE, &state->flags); 1137 ret = nfs4_open_recover_helper(opendata, FMODE_READ, &newstate); 1138 if (ret != 0) 1139 return ret; 1140 if (newstate != state) 1141 return -ESTALE; 1142 } 1143 /* 1144 * We may have performed cached opens for all three recoveries. 1145 * Check if we need to update the current stateid. 1146 */ 1147 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0 && 1148 memcmp(state->stateid.data, state->open_stateid.data, sizeof(state->stateid.data)) != 0) { 1149 write_seqlock(&state->seqlock); 1150 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) 1151 memcpy(state->stateid.data, state->open_stateid.data, sizeof(state->stateid.data)); 1152 write_sequnlock(&state->seqlock); 1153 } 1154 return 0; 1155} 1156 1157/* 1158 * OPEN_RECLAIM: 1159 * reclaim state on the server after a reboot. 1160 */ 1161static int _nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state) 1162{ 1163 struct nfs_delegation *delegation; 1164 struct nfs4_opendata *opendata; 1165 fmode_t delegation_type = 0; 1166 int status; 1167 1168 opendata = nfs4_open_recoverdata_alloc(ctx, state); 1169 if (IS_ERR(opendata)) 1170 return PTR_ERR(opendata); 1171 opendata->o_arg.claim = NFS4_OPEN_CLAIM_PREVIOUS; 1172 opendata->o_arg.fh = NFS_FH(state->inode); 1173 rcu_read_lock(); 1174 delegation = rcu_dereference(NFS_I(state->inode)->delegation); 1175 if (delegation != NULL && test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags) != 0) 1176 delegation_type = delegation->type; 1177 rcu_read_unlock(); 1178 opendata->o_arg.u.delegation_type = delegation_type; 1179 status = nfs4_open_recover(opendata, state); 1180 nfs4_opendata_put(opendata); 1181 return status; 1182} 1183 1184static int nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state) 1185{ 1186 struct nfs_server *server = NFS_SERVER(state->inode); 1187 struct nfs4_exception exception = { }; 1188 int err; 1189 do { 1190 err = _nfs4_do_open_reclaim(ctx, state); 1191 if (err != -NFS4ERR_DELAY && err != -EKEYEXPIRED) 1192 break; 1193 nfs4_handle_exception(server, err, &exception); 1194 } while (exception.retry); 1195 return err; 1196} 1197 1198static int nfs4_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *state) 1199{ 1200 struct nfs_open_context *ctx; 1201 int ret; 1202 1203 ctx = nfs4_state_find_open_context(state); 1204 if (IS_ERR(ctx)) 1205 return PTR_ERR(ctx); 1206 ret = nfs4_do_open_reclaim(ctx, state); 1207 put_nfs_open_context(ctx); 1208 return ret; 1209} 1210 1211static int _nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid) 1212{ 1213 struct nfs4_opendata *opendata; 1214 int ret; 1215 1216 opendata = nfs4_open_recoverdata_alloc(ctx, state); 1217 if (IS_ERR(opendata)) 1218 return PTR_ERR(opendata); 1219 opendata->o_arg.claim = NFS4_OPEN_CLAIM_DELEGATE_CUR; 1220 memcpy(opendata->o_arg.u.delegation.data, stateid->data, 1221 sizeof(opendata->o_arg.u.delegation.data)); 1222 ret = nfs4_open_recover(opendata, state); 1223 nfs4_opendata_put(opendata); 1224 return ret; 1225} 1226 1227int nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid) 1228{ 1229 struct nfs4_exception exception = { }; 1230 struct nfs_server *server = NFS_SERVER(state->inode); 1231 int err; 1232 do { 1233 err = _nfs4_open_delegation_recall(ctx, state, stateid); 1234 switch (err) { 1235 case 0: 1236 case -ENOENT: 1237 case -ESTALE: 1238 goto out; 1239 case -NFS4ERR_BADSESSION: 1240 case -NFS4ERR_BADSLOT: 1241 case -NFS4ERR_BAD_HIGH_SLOT: 1242 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 1243 case -NFS4ERR_DEADSESSION: 1244 nfs4_schedule_state_recovery( 1245 server->nfs_client); 1246 goto out; 1247 case -NFS4ERR_STALE_CLIENTID: 1248 case -NFS4ERR_STALE_STATEID: 1249 case -NFS4ERR_EXPIRED: 1250 /* Don't recall a delegation if it was lost */ 1251 nfs4_schedule_state_recovery(server->nfs_client); 1252 goto out; 1253 case -ERESTARTSYS: 1254 /* 1255 * The show must go on: exit, but mark the 1256 * stateid as needing recovery. 1257 */ 1258 case -NFS4ERR_ADMIN_REVOKED: 1259 case -NFS4ERR_BAD_STATEID: 1260 nfs4_state_mark_reclaim_nograce(server->nfs_client, state); 1261 case -ENOMEM: 1262 err = 0; 1263 goto out; 1264 } 1265 err = nfs4_handle_exception(server, err, &exception); 1266 } while (exception.retry); 1267out: 1268 return err; 1269} 1270 1271static void nfs4_open_confirm_done(struct rpc_task *task, void *calldata) 1272{ 1273 struct nfs4_opendata *data = calldata; 1274 1275 data->rpc_status = task->tk_status; 1276 if (data->rpc_status == 0) { 1277 memcpy(data->o_res.stateid.data, data->c_res.stateid.data, 1278 sizeof(data->o_res.stateid.data)); 1279 nfs_confirm_seqid(&data->owner->so_seqid, 0); 1280 renew_lease(data->o_res.server, data->timestamp); 1281 data->rpc_done = 1; 1282 } 1283} 1284 1285static void nfs4_open_confirm_release(void *calldata) 1286{ 1287 struct nfs4_opendata *data = calldata; 1288 struct nfs4_state *state = NULL; 1289 1290 /* If this request hasn't been cancelled, do nothing */ 1291 if (data->cancelled == 0) 1292 goto out_free; 1293 /* In case of error, no cleanup! */ 1294 if (!data->rpc_done) 1295 goto out_free; 1296 state = nfs4_opendata_to_nfs4_state(data); 1297 if (!IS_ERR(state)) 1298 nfs4_close_state(&data->path, state, data->o_arg.fmode); 1299out_free: 1300 nfs4_opendata_put(data); 1301} 1302 1303static const struct rpc_call_ops nfs4_open_confirm_ops = { 1304 .rpc_call_done = nfs4_open_confirm_done, 1305 .rpc_release = nfs4_open_confirm_release, 1306}; 1307 1308/* 1309 * Note: On error, nfs4_proc_open_confirm will free the struct nfs4_opendata 1310 */ 1311static int _nfs4_proc_open_confirm(struct nfs4_opendata *data) 1312{ 1313 struct nfs_server *server = NFS_SERVER(data->dir->d_inode); 1314 struct rpc_task *task; 1315 struct rpc_message msg = { 1316 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_CONFIRM], 1317 .rpc_argp = &data->c_arg, 1318 .rpc_resp = &data->c_res, 1319 .rpc_cred = data->owner->so_cred, 1320 }; 1321 struct rpc_task_setup task_setup_data = { 1322 .rpc_client = server->client, 1323 .rpc_message = &msg, 1324 .callback_ops = &nfs4_open_confirm_ops, 1325 .callback_data = data, 1326 .workqueue = nfsiod_workqueue, 1327 .flags = RPC_TASK_ASYNC, 1328 }; 1329 int status; 1330 1331 kref_get(&data->kref); 1332 data->rpc_done = 0; 1333 data->rpc_status = 0; 1334 data->timestamp = jiffies; 1335 task = rpc_run_task(&task_setup_data); 1336 if (IS_ERR(task)) 1337 return PTR_ERR(task); 1338 status = nfs4_wait_for_completion_rpc_task(task); 1339 if (status != 0) { 1340 data->cancelled = 1; 1341 smp_wmb(); 1342 } else 1343 status = data->rpc_status; 1344 rpc_put_task(task); 1345 return status; 1346} 1347 1348static void nfs4_open_prepare(struct rpc_task *task, void *calldata) 1349{ 1350 struct nfs4_opendata *data = calldata; 1351 struct nfs4_state_owner *sp = data->owner; 1352 1353 if (nfs_wait_on_sequence(data->o_arg.seqid, task) != 0) 1354 return; 1355 /* 1356 * Check if we still need to send an OPEN call, or if we can use 1357 * a delegation instead. 1358 */ 1359 if (data->state != NULL) { 1360 struct nfs_delegation *delegation; 1361 1362 if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags)) 1363 goto out_no_action; 1364 rcu_read_lock(); 1365 delegation = rcu_dereference(NFS_I(data->state->inode)->delegation); 1366 if (delegation != NULL && 1367 test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags) == 0) { 1368 rcu_read_unlock(); 1369 goto out_no_action; 1370 } 1371 rcu_read_unlock(); 1372 } 1373 /* Update sequence id. */ 1374 data->o_arg.id = sp->so_owner_id.id; 1375 data->o_arg.clientid = sp->so_server->nfs_client->cl_clientid; 1376 if (data->o_arg.claim == NFS4_OPEN_CLAIM_PREVIOUS) { 1377 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_NOATTR]; 1378 nfs_copy_fh(&data->o_res.fh, data->o_arg.fh); 1379 } 1380 data->timestamp = jiffies; 1381 if (nfs4_setup_sequence(data->o_arg.server, 1382 &data->o_arg.seq_args, 1383 &data->o_res.seq_res, 1, task)) 1384 return; 1385 rpc_call_start(task); 1386 return; 1387out_no_action: 1388 task->tk_action = NULL; 1389 1390} 1391 1392static void nfs4_recover_open_prepare(struct rpc_task *task, void *calldata) 1393{ 1394 rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED); 1395 nfs4_open_prepare(task, calldata); 1396} 1397 1398static void nfs4_open_done(struct rpc_task *task, void *calldata) 1399{ 1400 struct nfs4_opendata *data = calldata; 1401 1402 data->rpc_status = task->tk_status; 1403 1404 if (!nfs4_sequence_done(task, &data->o_res.seq_res)) 1405 return; 1406 1407 if (task->tk_status == 0) { 1408 switch (data->o_res.f_attr->mode & S_IFMT) { 1409 case S_IFREG: 1410 break; 1411 case S_IFLNK: 1412 data->rpc_status = -ELOOP; 1413 break; 1414 case S_IFDIR: 1415 data->rpc_status = -EISDIR; 1416 break; 1417 default: 1418 data->rpc_status = -ENOTDIR; 1419 } 1420 renew_lease(data->o_res.server, data->timestamp); 1421 if (!(data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM)) 1422 nfs_confirm_seqid(&data->owner->so_seqid, 0); 1423 } 1424 data->rpc_done = 1; 1425} 1426 1427static void nfs4_open_release(void *calldata) 1428{ 1429 struct nfs4_opendata *data = calldata; 1430 struct nfs4_state *state = NULL; 1431 1432 /* If this request hasn't been cancelled, do nothing */ 1433 if (data->cancelled == 0) 1434 goto out_free; 1435 /* In case of error, no cleanup! */ 1436 if (data->rpc_status != 0 || !data->rpc_done) 1437 goto out_free; 1438 /* In case we need an open_confirm, no cleanup! */ 1439 if (data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM) 1440 goto out_free; 1441 state = nfs4_opendata_to_nfs4_state(data); 1442 if (!IS_ERR(state)) 1443 nfs4_close_state(&data->path, state, data->o_arg.fmode); 1444out_free: 1445 nfs4_opendata_put(data); 1446} 1447 1448static const struct rpc_call_ops nfs4_open_ops = { 1449 .rpc_call_prepare = nfs4_open_prepare, 1450 .rpc_call_done = nfs4_open_done, 1451 .rpc_release = nfs4_open_release, 1452}; 1453 1454static const struct rpc_call_ops nfs4_recover_open_ops = { 1455 .rpc_call_prepare = nfs4_recover_open_prepare, 1456 .rpc_call_done = nfs4_open_done, 1457 .rpc_release = nfs4_open_release, 1458}; 1459 1460static int nfs4_run_open_task(struct nfs4_opendata *data, int isrecover) 1461{ 1462 struct inode *dir = data->dir->d_inode; 1463 struct nfs_server *server = NFS_SERVER(dir); 1464 struct nfs_openargs *o_arg = &data->o_arg; 1465 struct nfs_openres *o_res = &data->o_res; 1466 struct rpc_task *task; 1467 struct rpc_message msg = { 1468 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN], 1469 .rpc_argp = o_arg, 1470 .rpc_resp = o_res, 1471 .rpc_cred = data->owner->so_cred, 1472 }; 1473 struct rpc_task_setup task_setup_data = { 1474 .rpc_client = server->client, 1475 .rpc_message = &msg, 1476 .callback_ops = &nfs4_open_ops, 1477 .callback_data = data, 1478 .workqueue = nfsiod_workqueue, 1479 .flags = RPC_TASK_ASYNC, 1480 }; 1481 int status; 1482 1483 kref_get(&data->kref); 1484 data->rpc_done = 0; 1485 data->rpc_status = 0; 1486 data->cancelled = 0; 1487 if (isrecover) 1488 task_setup_data.callback_ops = &nfs4_recover_open_ops; 1489 task = rpc_run_task(&task_setup_data); 1490 if (IS_ERR(task)) 1491 return PTR_ERR(task); 1492 status = nfs4_wait_for_completion_rpc_task(task); 1493 if (status != 0) { 1494 data->cancelled = 1; 1495 smp_wmb(); 1496 } else 1497 status = data->rpc_status; 1498 rpc_put_task(task); 1499 1500 return status; 1501} 1502 1503static int _nfs4_recover_proc_open(struct nfs4_opendata *data) 1504{ 1505 struct inode *dir = data->dir->d_inode; 1506 struct nfs_openres *o_res = &data->o_res; 1507 int status; 1508 1509 status = nfs4_run_open_task(data, 1); 1510 if (status != 0 || !data->rpc_done) 1511 return status; 1512 1513 nfs_refresh_inode(dir, o_res->dir_attr); 1514 1515 if (o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) { 1516 status = _nfs4_proc_open_confirm(data); 1517 if (status != 0) 1518 return status; 1519 } 1520 1521 return status; 1522} 1523 1524/* 1525 * Note: On error, nfs4_proc_open will free the struct nfs4_opendata 1526 */ 1527static int _nfs4_proc_open(struct nfs4_opendata *data) 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 int status; 1534 1535 status = nfs4_run_open_task(data, 0); 1536 if (status != 0 || !data->rpc_done) 1537 return status; 1538 1539 if (o_arg->open_flags & O_CREAT) { 1540 update_changeattr(dir, &o_res->cinfo); 1541 nfs_post_op_update_inode(dir, o_res->dir_attr); 1542 } else 1543 nfs_refresh_inode(dir, o_res->dir_attr); 1544 if ((o_res->rflags & NFS4_OPEN_RESULT_LOCKTYPE_POSIX) == 0) 1545 server->caps &= ~NFS_CAP_POSIX_LOCK; 1546 if(o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) { 1547 status = _nfs4_proc_open_confirm(data); 1548 if (status != 0) 1549 return status; 1550 } 1551 if (!(o_res->f_attr->valid & NFS_ATTR_FATTR)) 1552 _nfs4_proc_getattr(server, &o_res->fh, o_res->f_attr); 1553 return 0; 1554} 1555 1556static int nfs4_recover_expired_lease(struct nfs_server *server) 1557{ 1558 struct nfs_client *clp = server->nfs_client; 1559 unsigned int loop; 1560 int ret; 1561 1562 for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) { 1563 ret = nfs4_wait_clnt_recover(clp); 1564 if (ret != 0) 1565 break; 1566 if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) && 1567 !test_bit(NFS4CLNT_CHECK_LEASE,&clp->cl_state)) 1568 break; 1569 nfs4_schedule_state_recovery(clp); 1570 ret = -EIO; 1571 } 1572 return ret; 1573} 1574 1575/* 1576 * OPEN_EXPIRED: 1577 * reclaim state on the server after a network partition. 1578 * Assumes caller holds the appropriate lock 1579 */ 1580static int _nfs4_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state) 1581{ 1582 struct nfs4_opendata *opendata; 1583 int ret; 1584 1585 opendata = nfs4_open_recoverdata_alloc(ctx, state); 1586 if (IS_ERR(opendata)) 1587 return PTR_ERR(opendata); 1588 ret = nfs4_open_recover(opendata, state); 1589 if (ret == -ESTALE) 1590 d_drop(ctx->path.dentry); 1591 nfs4_opendata_put(opendata); 1592 return ret; 1593} 1594 1595static int nfs4_do_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state) 1596{ 1597 struct nfs_server *server = NFS_SERVER(state->inode); 1598 struct nfs4_exception exception = { }; 1599 int err; 1600 1601 do { 1602 err = _nfs4_open_expired(ctx, state); 1603 switch (err) { 1604 default: 1605 goto out; 1606 case -NFS4ERR_GRACE: 1607 case -NFS4ERR_DELAY: 1608 case -EKEYEXPIRED: 1609 nfs4_handle_exception(server, err, &exception); 1610 err = 0; 1611 } 1612 } while (exception.retry); 1613out: 1614 return err; 1615} 1616 1617static int nfs4_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state) 1618{ 1619 struct nfs_open_context *ctx; 1620 int ret; 1621 1622 ctx = nfs4_state_find_open_context(state); 1623 if (IS_ERR(ctx)) 1624 return PTR_ERR(ctx); 1625 ret = nfs4_do_open_expired(ctx, state); 1626 put_nfs_open_context(ctx); 1627 return ret; 1628} 1629 1630/* 1631 * on an EXCLUSIVE create, the server should send back a bitmask with FATTR4-* 1632 * fields corresponding to attributes that were used to store the verifier. 1633 * Make sure we clobber those fields in the later setattr call 1634 */ 1635static inline void nfs4_exclusive_attrset(struct nfs4_opendata *opendata, struct iattr *sattr) 1636{ 1637 if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_ACCESS) && 1638 !(sattr->ia_valid & ATTR_ATIME_SET)) 1639 sattr->ia_valid |= ATTR_ATIME; 1640 1641 if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_MODIFY) && 1642 !(sattr->ia_valid & ATTR_MTIME_SET)) 1643 sattr->ia_valid |= ATTR_MTIME; 1644} 1645 1646/* 1647 * Returns a referenced nfs4_state 1648 */ 1649static int _nfs4_do_open(struct inode *dir, struct path *path, fmode_t fmode, int flags, struct iattr *sattr, struct rpc_cred *cred, struct nfs4_state **res) 1650{ 1651 struct nfs4_state_owner *sp; 1652 struct nfs4_state *state = NULL; 1653 struct nfs_server *server = NFS_SERVER(dir); 1654 struct nfs4_opendata *opendata; 1655 int status; 1656 1657 /* Protect against reboot recovery conflicts */ 1658 status = -ENOMEM; 1659 if (!(sp = nfs4_get_state_owner(server, cred))) { 1660 dprintk("nfs4_do_open: nfs4_get_state_owner failed!\n"); 1661 goto out_err; 1662 } 1663 status = nfs4_recover_expired_lease(server); 1664 if (status != 0) 1665 goto err_put_state_owner; 1666 if (path->dentry->d_inode != NULL) 1667 nfs4_return_incompatible_delegation(path->dentry->d_inode, fmode); 1668 status = -ENOMEM; 1669 opendata = nfs4_opendata_alloc(path, sp, fmode, flags, sattr, GFP_KERNEL); 1670 if (opendata == NULL) 1671 goto err_put_state_owner; 1672 1673 if (path->dentry->d_inode != NULL) 1674 opendata->state = nfs4_get_open_state(path->dentry->d_inode, sp); 1675 1676 status = _nfs4_proc_open(opendata); 1677 if (status != 0) 1678 goto err_opendata_put; 1679 1680 state = nfs4_opendata_to_nfs4_state(opendata); 1681 status = PTR_ERR(state); 1682 if (IS_ERR(state)) 1683 goto err_opendata_put; 1684 if (server->caps & NFS_CAP_POSIX_LOCK) 1685 set_bit(NFS_STATE_POSIX_LOCKS, &state->flags); 1686 1687 if (opendata->o_arg.open_flags & O_EXCL) { 1688 nfs4_exclusive_attrset(opendata, sattr); 1689 1690 nfs_fattr_init(opendata->o_res.f_attr); 1691 status = nfs4_do_setattr(state->inode, cred, 1692 opendata->o_res.f_attr, sattr, 1693 state); 1694 if (status == 0) 1695 nfs_setattr_update_inode(state->inode, sattr); 1696 nfs_post_op_update_inode(state->inode, opendata->o_res.f_attr); 1697 } 1698 nfs4_opendata_put(opendata); 1699 nfs4_put_state_owner(sp); 1700 *res = state; 1701 return 0; 1702err_opendata_put: 1703 nfs4_opendata_put(opendata); 1704err_put_state_owner: 1705 nfs4_put_state_owner(sp); 1706out_err: 1707 *res = NULL; 1708 return status; 1709} 1710 1711 1712static struct nfs4_state *nfs4_do_open(struct inode *dir, struct path *path, fmode_t fmode, int flags, struct iattr *sattr, struct rpc_cred *cred) 1713{ 1714 struct nfs4_exception exception = { }; 1715 struct nfs4_state *res; 1716 int status; 1717 1718 do { 1719 status = _nfs4_do_open(dir, path, fmode, flags, sattr, cred, &res); 1720 if (status == 0) 1721 break; 1722 /* NOTE: BAD_SEQID means the server and client disagree about the 1723 * book-keeping w.r.t. state-changing operations 1724 * (OPEN/CLOSE/LOCK/LOCKU...) 1725 * It is actually a sign of a bug on the client or on the server. 1726 * 1727 * If we receive a BAD_SEQID error in the particular case of 1728 * doing an OPEN, we assume that nfs_increment_open_seqid() will 1729 * have unhashed the old state_owner for us, and that we can 1730 * therefore safely retry using a new one. We should still warn 1731 * the user though... 1732 */ 1733 if (status == -NFS4ERR_BAD_SEQID) { 1734 printk(KERN_WARNING "NFS: v4 server %s " 1735 " returned a bad sequence-id error!\n", 1736 NFS_SERVER(dir)->nfs_client->cl_hostname); 1737 exception.retry = 1; 1738 continue; 1739 } 1740 /* 1741 * BAD_STATEID on OPEN means that the server cancelled our 1742 * state before it received the OPEN_CONFIRM. 1743 * Recover by retrying the request as per the discussion 1744 * on Page 181 of RFC3530. 1745 */ 1746 if (status == -NFS4ERR_BAD_STATEID) { 1747 exception.retry = 1; 1748 continue; 1749 } 1750 if (status == -EAGAIN) { 1751 /* We must have found a delegation */ 1752 exception.retry = 1; 1753 continue; 1754 } 1755 res = ERR_PTR(nfs4_handle_exception(NFS_SERVER(dir), 1756 status, &exception)); 1757 } while (exception.retry); 1758 return res; 1759} 1760 1761static int _nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred, 1762 struct nfs_fattr *fattr, struct iattr *sattr, 1763 struct nfs4_state *state) 1764{ 1765 struct nfs_server *server = NFS_SERVER(inode); 1766 struct nfs_setattrargs arg = { 1767 .fh = NFS_FH(inode), 1768 .iap = sattr, 1769 .server = server, 1770 .bitmask = server->attr_bitmask, 1771 }; 1772 struct nfs_setattrres res = { 1773 .fattr = fattr, 1774 .server = server, 1775 }; 1776 struct rpc_message msg = { 1777 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETATTR], 1778 .rpc_argp = &arg, 1779 .rpc_resp = &res, 1780 .rpc_cred = cred, 1781 }; 1782 unsigned long timestamp = jiffies; 1783 int status; 1784 1785 nfs_fattr_init(fattr); 1786 1787 if (nfs4_copy_delegation_stateid(&arg.stateid, inode)) { 1788 /* Use that stateid */ 1789 } else if (state != NULL) { 1790 nfs4_copy_stateid(&arg.stateid, state, current->files, current->tgid); 1791 } else 1792 memcpy(&arg.stateid, &zero_stateid, sizeof(arg.stateid)); 1793 1794 status = nfs4_call_sync(server, &msg, &arg, &res, 1); 1795 if (status == 0 && state != NULL) 1796 renew_lease(server, timestamp); 1797 return status; 1798} 1799 1800static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred, 1801 struct nfs_fattr *fattr, struct iattr *sattr, 1802 struct nfs4_state *state) 1803{ 1804 struct nfs_server *server = NFS_SERVER(inode); 1805 struct nfs4_exception exception = { }; 1806 int err; 1807 do { 1808 err = nfs4_handle_exception(server, 1809 _nfs4_do_setattr(inode, cred, fattr, sattr, state), 1810 &exception); 1811 } while (exception.retry); 1812 return err; 1813} 1814 1815struct nfs4_closedata { 1816 struct path path; 1817 struct inode *inode; 1818 struct nfs4_state *state; 1819 struct nfs_closeargs arg; 1820 struct nfs_closeres res; 1821 struct nfs_fattr fattr; 1822 unsigned long timestamp; 1823}; 1824 1825static void nfs4_free_closedata(void *data) 1826{ 1827 struct nfs4_closedata *calldata = data; 1828 struct nfs4_state_owner *sp = calldata->state->owner; 1829 1830 nfs4_put_open_state(calldata->state); 1831 nfs_free_seqid(calldata->arg.seqid); 1832 nfs4_put_state_owner(sp); 1833 path_put(&calldata->path); 1834 kfree(calldata); 1835} 1836 1837static void nfs4_close_clear_stateid_flags(struct nfs4_state *state, 1838 fmode_t fmode) 1839{ 1840 spin_lock(&state->owner->so_lock); 1841 if (!(fmode & FMODE_READ)) 1842 clear_bit(NFS_O_RDONLY_STATE, &state->flags); 1843 if (!(fmode & FMODE_WRITE)) 1844 clear_bit(NFS_O_WRONLY_STATE, &state->flags); 1845 clear_bit(NFS_O_RDWR_STATE, &state->flags); 1846 spin_unlock(&state->owner->so_lock); 1847} 1848 1849static void nfs4_close_done(struct rpc_task *task, void *data) 1850{ 1851 struct nfs4_closedata *calldata = data; 1852 struct nfs4_state *state = calldata->state; 1853 struct nfs_server *server = NFS_SERVER(calldata->inode); 1854 1855 if (!nfs4_sequence_done(task, &calldata->res.seq_res)) 1856 return; 1857 /* hmm. we are done with the inode, and in the process of freeing 1858 * the state_owner. we keep this around to process errors 1859 */ 1860 switch (task->tk_status) { 1861 case 0: 1862 nfs_set_open_stateid(state, &calldata->res.stateid, 0); 1863 renew_lease(server, calldata->timestamp); 1864 nfs4_close_clear_stateid_flags(state, 1865 calldata->arg.fmode); 1866 break; 1867 case -NFS4ERR_STALE_STATEID: 1868 case -NFS4ERR_OLD_STATEID: 1869 case -NFS4ERR_BAD_STATEID: 1870 case -NFS4ERR_EXPIRED: 1871 if (calldata->arg.fmode == 0) 1872 break; 1873 default: 1874 if (nfs4_async_handle_error(task, server, state) == -EAGAIN) 1875 rpc_restart_call_prepare(task); 1876 } 1877 nfs_release_seqid(calldata->arg.seqid); 1878 nfs_refresh_inode(calldata->inode, calldata->res.fattr); 1879} 1880 1881static void nfs4_close_prepare(struct rpc_task *task, void *data) 1882{ 1883 struct nfs4_closedata *calldata = data; 1884 struct nfs4_state *state = calldata->state; 1885 int call_close = 0; 1886 1887 if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0) 1888 return; 1889 1890 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; 1891 calldata->arg.fmode = FMODE_READ|FMODE_WRITE; 1892 spin_lock(&state->owner->so_lock); 1893 /* Calculate the change in open mode */ 1894 if (state->n_rdwr == 0) { 1895 if (state->n_rdonly == 0) { 1896 call_close |= test_bit(NFS_O_RDONLY_STATE, &state->flags); 1897 call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags); 1898 calldata->arg.fmode &= ~FMODE_READ; 1899 } 1900 if (state->n_wronly == 0) { 1901 call_close |= test_bit(NFS_O_WRONLY_STATE, &state->flags); 1902 call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags); 1903 calldata->arg.fmode &= ~FMODE_WRITE; 1904 } 1905 } 1906 spin_unlock(&state->owner->so_lock); 1907 1908 if (!call_close) { 1909 /* Note: exit _without_ calling nfs4_close_done */ 1910 task->tk_action = NULL; 1911 return; 1912 } 1913 1914 if (calldata->arg.fmode == 0) 1915 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE]; 1916 1917 nfs_fattr_init(calldata->res.fattr); 1918 calldata->timestamp = jiffies; 1919 if (nfs4_setup_sequence(NFS_SERVER(calldata->inode), 1920 &calldata->arg.seq_args, &calldata->res.seq_res, 1921 1, task)) 1922 return; 1923 rpc_call_start(task); 1924} 1925 1926static const struct rpc_call_ops nfs4_close_ops = { 1927 .rpc_call_prepare = nfs4_close_prepare, 1928 .rpc_call_done = nfs4_close_done, 1929 .rpc_release = nfs4_free_closedata, 1930}; 1931 1932/* 1933 * It is possible for data to be read/written from a mem-mapped file 1934 * after the sys_close call (which hits the vfs layer as a flush). 1935 * This means that we can't safely call nfsv4 close on a file until 1936 * the inode is cleared. This in turn means that we are not good 1937 * NFSv4 citizens - we do not indicate to the server to update the file's 1938 * share state even when we are done with one of the three share 1939 * stateid's in the inode. 1940 * 1941 * NOTE: Caller must be holding the sp->so_owner semaphore! 1942 */ 1943int nfs4_do_close(struct path *path, struct nfs4_state *state, gfp_t gfp_mask, int wait) 1944{ 1945 struct nfs_server *server = NFS_SERVER(state->inode); 1946 struct nfs4_closedata *calldata; 1947 struct nfs4_state_owner *sp = state->owner; 1948 struct rpc_task *task; 1949 struct rpc_message msg = { 1950 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE], 1951 .rpc_cred = state->owner->so_cred, 1952 }; 1953 struct rpc_task_setup task_setup_data = { 1954 .rpc_client = server->client, 1955 .rpc_message = &msg, 1956 .callback_ops = &nfs4_close_ops, 1957 .workqueue = nfsiod_workqueue, 1958 .flags = RPC_TASK_ASYNC, 1959 }; 1960 int status = -ENOMEM; 1961 1962 calldata = kzalloc(sizeof(*calldata), gfp_mask); 1963 if (calldata == NULL) 1964 goto out; 1965 calldata->inode = state->inode; 1966 calldata->state = state; 1967 calldata->arg.fh = NFS_FH(state->inode); 1968 calldata->arg.stateid = &state->open_stateid; 1969 /* Serialization for the sequence id */ 1970 calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid, gfp_mask); 1971 if (calldata->arg.seqid == NULL) 1972 goto out_free_calldata; 1973 calldata->arg.fmode = 0; 1974 calldata->arg.bitmask = server->cache_consistency_bitmask; 1975 calldata->res.fattr = &calldata->fattr; 1976 calldata->res.seqid = calldata->arg.seqid; 1977 calldata->res.server = server; 1978 calldata->res.seq_res.sr_slotid = NFS4_MAX_SLOT_TABLE; 1979 path_get(path); 1980 calldata->path = *path; 1981 1982 msg.rpc_argp = &calldata->arg, 1983 msg.rpc_resp = &calldata->res, 1984 task_setup_data.callback_data = calldata; 1985 task = rpc_run_task(&task_setup_data); 1986 if (IS_ERR(task)) 1987 return PTR_ERR(task); 1988 status = 0; 1989 if (wait) 1990 status = rpc_wait_for_completion_task(task); 1991 rpc_put_task(task); 1992 return status; 1993out_free_calldata: 1994 kfree(calldata); 1995out: 1996 nfs4_put_open_state(state); 1997 nfs4_put_state_owner(sp); 1998 return status; 1999} 2000 2001static int nfs4_intent_set_file(struct nameidata *nd, struct path *path, struct nfs4_state *state, fmode_t fmode) 2002{ 2003 struct file *filp; 2004 int ret; 2005 2006 /* If the open_intent is for execute, we have an extra check to make */ 2007 if (fmode & FMODE_EXEC) { 2008 ret = nfs_may_open(state->inode, 2009 state->owner->so_cred, 2010 nd->intent.open.flags); 2011 if (ret < 0) 2012 goto out_close; 2013 } 2014 filp = lookup_instantiate_filp(nd, path->dentry, NULL); 2015 if (!IS_ERR(filp)) { 2016 struct nfs_open_context *ctx; 2017 ctx = nfs_file_open_context(filp); 2018 ctx->state = state; 2019 return 0; 2020 } 2021 ret = PTR_ERR(filp); 2022out_close: 2023 nfs4_close_sync(path, state, fmode & (FMODE_READ|FMODE_WRITE)); 2024 return ret; 2025} 2026 2027struct dentry * 2028nfs4_atomic_open(struct inode *dir, struct dentry *dentry, struct nameidata *nd) 2029{ 2030 struct path path = { 2031 .mnt = nd->path.mnt, 2032 .dentry = dentry, 2033 }; 2034 struct dentry *parent; 2035 struct iattr attr; 2036 struct rpc_cred *cred; 2037 struct nfs4_state *state; 2038 struct dentry *res; 2039 int open_flags = nd->intent.open.flags; 2040 fmode_t fmode = open_flags & (FMODE_READ | FMODE_WRITE | FMODE_EXEC); 2041 2042 if (nd->flags & LOOKUP_CREATE) { 2043 attr.ia_mode = nd->intent.open.create_mode; 2044 attr.ia_valid = ATTR_MODE; 2045 if (!IS_POSIXACL(dir)) 2046 attr.ia_mode &= ~current_umask(); 2047 } else { 2048 open_flags &= ~O_EXCL; 2049 attr.ia_valid = 0; 2050 BUG_ON(open_flags & O_CREAT); 2051 } 2052 2053 cred = rpc_lookup_cred(); 2054 if (IS_ERR(cred)) 2055 return (struct dentry *)cred; 2056 parent = dentry->d_parent; 2057 /* Protect against concurrent sillydeletes */ 2058 nfs_block_sillyrename(parent); 2059 state = nfs4_do_open(dir, &path, fmode, open_flags, &attr, cred); 2060 put_rpccred(cred); 2061 if (IS_ERR(state)) { 2062 if (PTR_ERR(state) == -ENOENT) { 2063 d_add(dentry, NULL); 2064 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 2065 } 2066 nfs_unblock_sillyrename(parent); 2067 return (struct dentry *)state; 2068 } 2069 res = d_add_unique(dentry, igrab(state->inode)); 2070 if (res != NULL) 2071 path.dentry = res; 2072 nfs_set_verifier(path.dentry, nfs_save_change_attribute(dir)); 2073 nfs_unblock_sillyrename(parent); 2074 nfs4_intent_set_file(nd, &path, state, fmode); 2075 return res; 2076} 2077 2078int 2079nfs4_open_revalidate(struct inode *dir, struct dentry *dentry, int openflags, struct nameidata *nd) 2080{ 2081 struct path path = { 2082 .mnt = nd->path.mnt, 2083 .dentry = dentry, 2084 }; 2085 struct rpc_cred *cred; 2086 struct nfs4_state *state; 2087 fmode_t fmode = openflags & (FMODE_READ | FMODE_WRITE); 2088 2089 cred = rpc_lookup_cred(); 2090 if (IS_ERR(cred)) 2091 return PTR_ERR(cred); 2092 state = nfs4_do_open(dir, &path, fmode, openflags, NULL, cred); 2093 put_rpccred(cred); 2094 if (IS_ERR(state)) { 2095 switch (PTR_ERR(state)) { 2096 case -EPERM: 2097 case -EACCES: 2098 case -EDQUOT: 2099 case -ENOSPC: 2100 case -EROFS: 2101 return PTR_ERR(state); 2102 default: 2103 goto out_drop; 2104 } 2105 } 2106 if (state->inode == dentry->d_inode) { 2107 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 2108 nfs4_intent_set_file(nd, &path, state, fmode); 2109 return 1; 2110 } 2111 nfs4_close_sync(&path, state, fmode); 2112out_drop: 2113 d_drop(dentry); 2114 return 0; 2115} 2116 2117static void nfs4_close_context(struct nfs_open_context *ctx, int is_sync) 2118{ 2119 if (ctx->state == NULL) 2120 return; 2121 if (is_sync) 2122 nfs4_close_sync(&ctx->path, ctx->state, ctx->mode); 2123 else 2124 nfs4_close_state(&ctx->path, ctx->state, ctx->mode); 2125} 2126 2127static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle) 2128{ 2129 struct nfs4_server_caps_arg args = { 2130 .fhandle = fhandle, 2131 }; 2132 struct nfs4_server_caps_res res = {}; 2133 struct rpc_message msg = { 2134 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SERVER_CAPS], 2135 .rpc_argp = &args, 2136 .rpc_resp = &res, 2137 }; 2138 int status; 2139 2140 status = nfs4_call_sync(server, &msg, &args, &res, 0); 2141 if (status == 0) { 2142 memcpy(server->attr_bitmask, res.attr_bitmask, sizeof(server->attr_bitmask)); 2143 server->caps &= ~(NFS_CAP_ACLS|NFS_CAP_HARDLINKS| 2144 NFS_CAP_SYMLINKS|NFS_CAP_FILEID| 2145 NFS_CAP_MODE|NFS_CAP_NLINK|NFS_CAP_OWNER| 2146 NFS_CAP_OWNER_GROUP|NFS_CAP_ATIME| 2147 NFS_CAP_CTIME|NFS_CAP_MTIME); 2148 if (res.attr_bitmask[0] & FATTR4_WORD0_ACL) 2149 server->caps |= NFS_CAP_ACLS; 2150 if (res.has_links != 0) 2151 server->caps |= NFS_CAP_HARDLINKS; 2152 if (res.has_symlinks != 0) 2153 server->caps |= NFS_CAP_SYMLINKS; 2154 if (res.attr_bitmask[0] & FATTR4_WORD0_FILEID) 2155 server->caps |= NFS_CAP_FILEID; 2156 if (res.attr_bitmask[1] & FATTR4_WORD1_MODE) 2157 server->caps |= NFS_CAP_MODE; 2158 if (res.attr_bitmask[1] & FATTR4_WORD1_NUMLINKS) 2159 server->caps |= NFS_CAP_NLINK; 2160 if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER) 2161 server->caps |= NFS_CAP_OWNER; 2162 if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER_GROUP) 2163 server->caps |= NFS_CAP_OWNER_GROUP; 2164 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_ACCESS) 2165 server->caps |= NFS_CAP_ATIME; 2166 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_METADATA) 2167 server->caps |= NFS_CAP_CTIME; 2168 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_MODIFY) 2169 server->caps |= NFS_CAP_MTIME; 2170 2171 memcpy(server->cache_consistency_bitmask, res.attr_bitmask, sizeof(server->cache_consistency_bitmask)); 2172 server->cache_consistency_bitmask[0] &= FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE; 2173 server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY; 2174 server->acl_bitmask = res.acl_bitmask; 2175 } 2176 2177 return status; 2178} 2179 2180int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle) 2181{ 2182 struct nfs4_exception exception = { }; 2183 int err; 2184 do { 2185 err = nfs4_handle_exception(server, 2186 _nfs4_server_capabilities(server, fhandle), 2187 &exception); 2188 } while (exception.retry); 2189 return err; 2190} 2191 2192static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle, 2193 struct nfs_fsinfo *info) 2194{ 2195 struct nfs4_lookup_root_arg args = { 2196 .bitmask = nfs4_fattr_bitmap, 2197 }; 2198 struct nfs4_lookup_res res = { 2199 .server = server, 2200 .fattr = info->fattr, 2201 .fh = fhandle, 2202 }; 2203 struct rpc_message msg = { 2204 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP_ROOT], 2205 .rpc_argp = &args, 2206 .rpc_resp = &res, 2207 }; 2208 2209 nfs_fattr_init(info->fattr); 2210 return nfs4_call_sync(server, &msg, &args, &res, 0); 2211} 2212 2213static int nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle, 2214 struct nfs_fsinfo *info) 2215{ 2216 struct nfs4_exception exception = { }; 2217 int err; 2218 do { 2219 err = nfs4_handle_exception(server, 2220 _nfs4_lookup_root(server, fhandle, info), 2221 &exception); 2222 } while (exception.retry); 2223 return err; 2224} 2225 2226/* 2227 * get the file handle for the "/" directory on the server 2228 */ 2229static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle, 2230 struct nfs_fsinfo *info) 2231{ 2232 int status; 2233 2234 status = nfs4_lookup_root(server, fhandle, info); 2235 if (status == 0) 2236 status = nfs4_server_capabilities(server, fhandle); 2237 if (status == 0) 2238 status = nfs4_do_fsinfo(server, fhandle, info); 2239 return nfs4_map_errors(status); 2240} 2241 2242/* 2243 * Get locations and (maybe) other attributes of a referral. 2244 * Note that we'll actually follow the referral later when 2245 * we detect fsid mismatch in inode revalidation 2246 */ 2247static int nfs4_get_referral(struct inode *dir, const struct qstr *name, struct nfs_fattr *fattr, struct nfs_fh *fhandle) 2248{ 2249 int status = -ENOMEM; 2250 struct page *page = NULL; 2251 struct nfs4_fs_locations *locations = NULL; 2252 2253 page = alloc_page(GFP_KERNEL); 2254 if (page == NULL) 2255 goto out; 2256 locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL); 2257 if (locations == NULL) 2258 goto out; 2259 2260 status = nfs4_proc_fs_locations(dir, name, locations, page); 2261 if (status != 0) 2262 goto out; 2263 /* Make sure server returned a different fsid for the referral */ 2264 if (nfs_fsid_equal(&NFS_SERVER(dir)->fsid, &locations->fattr.fsid)) { 2265 dprintk("%s: server did not return a different fsid for a referral at %s\n", __func__, name->name); 2266 status = -EIO; 2267 goto out; 2268 } 2269 2270 memcpy(fattr, &locations->fattr, sizeof(struct nfs_fattr)); 2271 fattr->valid |= NFS_ATTR_FATTR_V4_REFERRAL; 2272 if (!fattr->mode) 2273 fattr->mode = S_IFDIR; 2274 memset(fhandle, 0, sizeof(struct nfs_fh)); 2275out: 2276 if (page) 2277 __free_page(page); 2278 kfree(locations); 2279 return status; 2280} 2281 2282static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr) 2283{ 2284 struct nfs4_getattr_arg args = { 2285 .fh = fhandle, 2286 .bitmask = server->attr_bitmask, 2287 }; 2288 struct nfs4_getattr_res res = { 2289 .fattr = fattr, 2290 .server = server, 2291 }; 2292 struct rpc_message msg = { 2293 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETATTR], 2294 .rpc_argp = &args, 2295 .rpc_resp = &res, 2296 }; 2297 2298 nfs_fattr_init(fattr); 2299 return nfs4_call_sync(server, &msg, &args, &res, 0); 2300} 2301 2302static int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr) 2303{ 2304 struct nfs4_exception exception = { }; 2305 int err; 2306 do { 2307 err = nfs4_handle_exception(server, 2308 _nfs4_proc_getattr(server, fhandle, fattr), 2309 &exception); 2310 } while (exception.retry); 2311 return err; 2312} 2313 2314/* 2315 * The file is not closed if it is opened due to the a request to change 2316 * the size of the file. The open call will not be needed once the 2317 * VFS layer lookup-intents are implemented. 2318 * 2319 * Close is called when the inode is destroyed. 2320 * If we haven't opened the file for O_WRONLY, we 2321 * need to in the size_change case to obtain a stateid. 2322 * 2323 * Got race? 2324 * Because OPEN is always done by name in nfsv4, it is 2325 * possible that we opened a different file by the same 2326 * name. We can recognize this race condition, but we 2327 * can't do anything about it besides returning an error. 2328 * 2329 * This will be fixed with VFS changes (lookup-intent). 2330 */ 2331static int 2332nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr, 2333 struct iattr *sattr) 2334{ 2335 struct inode *inode = dentry->d_inode; 2336 struct rpc_cred *cred = NULL; 2337 struct nfs4_state *state = NULL; 2338 int status; 2339 2340 nfs_fattr_init(fattr); 2341 2342 /* Search for an existing open(O_WRITE) file */ 2343 if (sattr->ia_valid & ATTR_FILE) { 2344 struct nfs_open_context *ctx; 2345 2346 ctx = nfs_file_open_context(sattr->ia_file); 2347 if (ctx) { 2348 cred = ctx->cred; 2349 state = ctx->state; 2350 } 2351 } 2352 2353 status = nfs4_do_setattr(inode, cred, fattr, sattr, state); 2354 if (status == 0) 2355 nfs_setattr_update_inode(inode, sattr); 2356 return status; 2357} 2358 2359static int _nfs4_proc_lookupfh(struct nfs_server *server, const struct nfs_fh *dirfh, 2360 const struct qstr *name, struct nfs_fh *fhandle, 2361 struct nfs_fattr *fattr) 2362{ 2363 int status; 2364 struct nfs4_lookup_arg args = { 2365 .bitmask = server->attr_bitmask, 2366 .dir_fh = dirfh, 2367 .name = name, 2368 }; 2369 struct nfs4_lookup_res res = { 2370 .server = server, 2371 .fattr = fattr, 2372 .fh = fhandle, 2373 }; 2374 struct rpc_message msg = { 2375 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP], 2376 .rpc_argp = &args, 2377 .rpc_resp = &res, 2378 }; 2379 2380 nfs_fattr_init(fattr); 2381 2382 dprintk("NFS call lookupfh %s\n", name->name); 2383 status = nfs4_call_sync(server, &msg, &args, &res, 0); 2384 dprintk("NFS reply lookupfh: %d\n", status); 2385 return status; 2386} 2387 2388static int nfs4_proc_lookupfh(struct nfs_server *server, struct nfs_fh *dirfh, 2389 struct qstr *name, struct nfs_fh *fhandle, 2390 struct nfs_fattr *fattr) 2391{ 2392 struct nfs4_exception exception = { }; 2393 int err; 2394 do { 2395 err = _nfs4_proc_lookupfh(server, dirfh, name, fhandle, fattr); 2396 if (err == -NFS4ERR_MOVED) { 2397 err = -EREMOTE; 2398 break; 2399 } 2400 err = nfs4_handle_exception(server, err, &exception); 2401 } while (exception.retry); 2402 return err; 2403} 2404 2405static int _nfs4_proc_lookup(struct inode *dir, const struct qstr *name, 2406 struct nfs_fh *fhandle, struct nfs_fattr *fattr) 2407{ 2408 int status; 2409 2410 dprintk("NFS call lookup %s\n", name->name); 2411 status = _nfs4_proc_lookupfh(NFS_SERVER(dir), NFS_FH(dir), name, fhandle, fattr); 2412 if (status == -NFS4ERR_MOVED) 2413 status = nfs4_get_referral(dir, name, fattr, fhandle); 2414 dprintk("NFS reply lookup: %d\n", status); 2415 return status; 2416} 2417 2418static int nfs4_proc_lookup(struct inode *dir, struct qstr *name, struct nfs_fh *fhandle, struct nfs_fattr *fattr) 2419{ 2420 struct nfs4_exception exception = { }; 2421 int err; 2422 do { 2423 err = nfs4_handle_exception(NFS_SERVER(dir), 2424 _nfs4_proc_lookup(dir, name, fhandle, fattr), 2425 &exception); 2426 } while (exception.retry); 2427 return err; 2428} 2429 2430static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry) 2431{ 2432 struct nfs_server *server = NFS_SERVER(inode); 2433 struct nfs4_accessargs args = { 2434 .fh = NFS_FH(inode), 2435 .bitmask = server->attr_bitmask, 2436 }; 2437 struct nfs4_accessres res = { 2438 .server = server, 2439 }; 2440 struct rpc_message msg = { 2441 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ACCESS], 2442 .rpc_argp = &args, 2443 .rpc_resp = &res, 2444 .rpc_cred = entry->cred, 2445 }; 2446 int mode = entry->mask; 2447 int status; 2448 2449 /* 2450 * Determine which access bits we want to ask for... 2451 */ 2452 if (mode & MAY_READ) 2453 args.access |= NFS4_ACCESS_READ; 2454 if (S_ISDIR(inode->i_mode)) { 2455 if (mode & MAY_WRITE) 2456 args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE; 2457 if (mode & MAY_EXEC) 2458 args.access |= NFS4_ACCESS_LOOKUP; 2459 } else { 2460 if (mode & MAY_WRITE) 2461 args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND; 2462 if (mode & MAY_EXEC) 2463 args.access |= NFS4_ACCESS_EXECUTE; 2464 } 2465 2466 res.fattr = nfs_alloc_fattr(); 2467 if (res.fattr == NULL) 2468 return -ENOMEM; 2469 2470 status = nfs4_call_sync(server, &msg, &args, &res, 0); 2471 if (!status) { 2472 entry->mask = 0; 2473 if (res.access & NFS4_ACCESS_READ) 2474 entry->mask |= MAY_READ; 2475 if (res.access & (NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE)) 2476 entry->mask |= MAY_WRITE; 2477 if (res.access & (NFS4_ACCESS_LOOKUP|NFS4_ACCESS_EXECUTE)) 2478 entry->mask |= MAY_EXEC; 2479 nfs_refresh_inode(inode, res.fattr); 2480 } 2481 nfs_free_fattr(res.fattr); 2482 return status; 2483} 2484 2485static int nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry) 2486{ 2487 struct nfs4_exception exception = { }; 2488 int err; 2489 do { 2490 err = nfs4_handle_exception(NFS_SERVER(inode), 2491 _nfs4_proc_access(inode, entry), 2492 &exception); 2493 } while (exception.retry); 2494 return err; 2495} 2496 2497/* 2498 * TODO: For the time being, we don't try to get any attributes 2499 * along with any of the zero-copy operations READ, READDIR, 2500 * READLINK, WRITE. 2501 * 2502 * In the case of the first three, we want to put the GETATTR 2503 * after the read-type operation -- this is because it is hard 2504 * to predict the length of a GETATTR response in v4, and thus 2505 * align the READ data correctly. This means that the GETATTR 2506 * may end up partially falling into the page cache, and we should 2507 * shift it into the 'tail' of the xdr_buf before processing. 2508 * To do this efficiently, we need to know the total length 2509 * of data received, which doesn't seem to be available outside 2510 * of the RPC layer. 2511 * 2512 * In the case of WRITE, we also want to put the GETATTR after 2513 * the operation -- in this case because we want to make sure 2514 * we get the post-operation mtime and size. This means that 2515 * we can't use xdr_encode_pages() as written: we need a variant 2516 * of it which would leave room in the 'tail' iovec. 2517 * 2518 * Both of these changes to the XDR layer would in fact be quite 2519 * minor, but I decided to leave them for a subsequent patch. 2520 */ 2521static int _nfs4_proc_readlink(struct inode *inode, struct page *page, 2522 unsigned int pgbase, unsigned int pglen) 2523{ 2524 struct nfs4_readlink args = { 2525 .fh = NFS_FH(inode), 2526 .pgbase = pgbase, 2527 .pglen = pglen, 2528 .pages = &page, 2529 }; 2530 struct nfs4_readlink_res res; 2531 struct rpc_message msg = { 2532 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READLINK], 2533 .rpc_argp = &args, 2534 .rpc_resp = &res, 2535 }; 2536 2537 return nfs4_call_sync(NFS_SERVER(inode), &msg, &args, &res, 0); 2538} 2539 2540static int nfs4_proc_readlink(struct inode *inode, struct page *page, 2541 unsigned int pgbase, unsigned int pglen) 2542{ 2543 struct nfs4_exception exception = { }; 2544 int err; 2545 do { 2546 err = nfs4_handle_exception(NFS_SERVER(inode), 2547 _nfs4_proc_readlink(inode, page, pgbase, pglen), 2548 &exception); 2549 } while (exception.retry); 2550 return err; 2551} 2552 2553/* 2554 * Got race? 2555 * We will need to arrange for the VFS layer to provide an atomic open. 2556 * Until then, this create/open method is prone to inefficiency and race 2557 * conditions due to the lookup, create, and open VFS calls from sys_open() 2558 * placed on the wire. 2559 * 2560 * Given the above sorry state of affairs, I'm simply sending an OPEN. 2561 * The file will be opened again in the subsequent VFS open call 2562 * (nfs4_proc_file_open). 2563 * 2564 * The open for read will just hang around to be used by any process that 2565 * opens the file O_RDONLY. This will all be resolved with the VFS changes. 2566 */ 2567 2568static int 2569nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr, 2570 int flags, struct nameidata *nd) 2571{ 2572 struct path path = { 2573 .mnt = nd->path.mnt, 2574 .dentry = dentry, 2575 }; 2576 struct nfs4_state *state; 2577 struct rpc_cred *cred; 2578 fmode_t fmode = flags & (FMODE_READ | FMODE_WRITE); 2579 int status = 0; 2580 2581 cred = rpc_lookup_cred(); 2582 if (IS_ERR(cred)) { 2583 status = PTR_ERR(cred); 2584 goto out; 2585 } 2586 state = nfs4_do_open(dir, &path, fmode, flags, sattr, cred); 2587 d_drop(dentry); 2588 if (IS_ERR(state)) { 2589 status = PTR_ERR(state); 2590 goto out_putcred; 2591 } 2592 d_add(dentry, igrab(state->inode)); 2593 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 2594 if (status == 0 && (nd->flags & LOOKUP_OPEN) != 0) 2595 status = nfs4_intent_set_file(nd, &path, state, fmode); 2596 else 2597 nfs4_close_sync(&path, state, fmode); 2598out_putcred: 2599 put_rpccred(cred); 2600out: 2601 return status; 2602} 2603 2604static int _nfs4_proc_remove(struct inode *dir, struct qstr *name) 2605{ 2606 struct nfs_server *server = NFS_SERVER(dir); 2607 struct nfs_removeargs args = { 2608 .fh = NFS_FH(dir), 2609 .name.len = name->len, 2610 .name.name = name->name, 2611 .bitmask = server->attr_bitmask, 2612 }; 2613 struct nfs_removeres res = { 2614 .server = server, 2615 }; 2616 struct rpc_message msg = { 2617 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE], 2618 .rpc_argp = &args, 2619 .rpc_resp = &res, 2620 }; 2621 int status = -ENOMEM; 2622 2623 res.dir_attr = nfs_alloc_fattr(); 2624 if (res.dir_attr == NULL) 2625 goto out; 2626 2627 status = nfs4_call_sync(server, &msg, &args, &res, 1); 2628 if (status == 0) { 2629 update_changeattr(dir, &res.cinfo); 2630 nfs_post_op_update_inode(dir, res.dir_attr); 2631 } 2632 nfs_free_fattr(res.dir_attr); 2633out: 2634 return status; 2635} 2636 2637static int nfs4_proc_remove(struct inode *dir, struct qstr *name) 2638{ 2639 struct nfs4_exception exception = { }; 2640 int err; 2641 do { 2642 err = nfs4_handle_exception(NFS_SERVER(dir), 2643 _nfs4_proc_remove(dir, name), 2644 &exception); 2645 } while (exception.retry); 2646 return err; 2647} 2648 2649static void nfs4_proc_unlink_setup(struct rpc_message *msg, struct inode *dir) 2650{ 2651 struct nfs_server *server = NFS_SERVER(dir); 2652 struct nfs_removeargs *args = msg->rpc_argp; 2653 struct nfs_removeres *res = msg->rpc_resp; 2654 2655 args->bitmask = server->cache_consistency_bitmask; 2656 res->server = server; 2657 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE]; 2658} 2659 2660static int nfs4_proc_unlink_done(struct rpc_task *task, struct inode *dir) 2661{ 2662 struct nfs_removeres *res = task->tk_msg.rpc_resp; 2663 2664 if (!nfs4_sequence_done(task, &res->seq_res)) 2665 return 0; 2666 if (nfs4_async_handle_error(task, res->server, NULL) == -EAGAIN) 2667 return 0; 2668 update_changeattr(dir, &res->cinfo); 2669 nfs_post_op_update_inode(dir, res->dir_attr); 2670 return 1; 2671} 2672 2673static int _nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name, 2674 struct inode *new_dir, struct qstr *new_name) 2675{ 2676 struct nfs_server *server = NFS_SERVER(old_dir); 2677 struct nfs4_rename_arg arg = { 2678 .old_dir = NFS_FH(old_dir), 2679 .new_dir = NFS_FH(new_dir), 2680 .old_name = old_name, 2681 .new_name = new_name, 2682 .bitmask = server->attr_bitmask, 2683 }; 2684 struct nfs4_rename_res res = { 2685 .server = server, 2686 }; 2687 struct rpc_message msg = { 2688 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME], 2689 .rpc_argp = &arg, 2690 .rpc_resp = &res, 2691 }; 2692 int status = -ENOMEM; 2693 2694 res.old_fattr = nfs_alloc_fattr(); 2695 res.new_fattr = nfs_alloc_fattr(); 2696 if (res.old_fattr == NULL || res.new_fattr == NULL) 2697 goto out; 2698 2699 status = nfs4_call_sync(server, &msg, &arg, &res, 1); 2700 if (!status) { 2701 update_changeattr(old_dir, &res.old_cinfo); 2702 nfs_post_op_update_inode(old_dir, res.old_fattr); 2703 update_changeattr(new_dir, &res.new_cinfo); 2704 nfs_post_op_update_inode(new_dir, res.new_fattr); 2705 } 2706out: 2707 nfs_free_fattr(res.new_fattr); 2708 nfs_free_fattr(res.old_fattr); 2709 return status; 2710} 2711 2712static int nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name, 2713 struct inode *new_dir, struct qstr *new_name) 2714{ 2715 struct nfs4_exception exception = { }; 2716 int err; 2717 do { 2718 err = nfs4_handle_exception(NFS_SERVER(old_dir), 2719 _nfs4_proc_rename(old_dir, old_name, 2720 new_dir, new_name), 2721 &exception); 2722 } while (exception.retry); 2723 return err; 2724} 2725 2726static int _nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name) 2727{ 2728 struct nfs_server *server = NFS_SERVER(inode); 2729 struct nfs4_link_arg arg = { 2730 .fh = NFS_FH(inode), 2731 .dir_fh = NFS_FH(dir), 2732 .name = name, 2733 .bitmask = server->attr_bitmask, 2734 }; 2735 struct nfs4_link_res res = { 2736 .server = server, 2737 }; 2738 struct rpc_message msg = { 2739 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LINK], 2740 .rpc_argp = &arg, 2741 .rpc_resp = &res, 2742 }; 2743 int status = -ENOMEM; 2744 2745 res.fattr = nfs_alloc_fattr(); 2746 res.dir_attr = nfs_alloc_fattr(); 2747 if (res.fattr == NULL || res.dir_attr == NULL) 2748 goto out; 2749 2750 status = nfs4_call_sync(server, &msg, &arg, &res, 1); 2751 if (!status) { 2752 update_changeattr(dir, &res.cinfo); 2753 nfs_post_op_update_inode(dir, res.dir_attr); 2754 nfs_post_op_update_inode(inode, res.fattr); 2755 } 2756out: 2757 nfs_free_fattr(res.dir_attr); 2758 nfs_free_fattr(res.fattr); 2759 return status; 2760} 2761 2762static int nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name) 2763{ 2764 struct nfs4_exception exception = { }; 2765 int err; 2766 do { 2767 err = nfs4_handle_exception(NFS_SERVER(inode), 2768 _nfs4_proc_link(inode, dir, name), 2769 &exception); 2770 } while (exception.retry); 2771 return err; 2772} 2773 2774struct nfs4_createdata { 2775 struct rpc_message msg; 2776 struct nfs4_create_arg arg; 2777 struct nfs4_create_res res; 2778 struct nfs_fh fh; 2779 struct nfs_fattr fattr; 2780 struct nfs_fattr dir_fattr; 2781}; 2782 2783static struct nfs4_createdata *nfs4_alloc_createdata(struct inode *dir, 2784 struct qstr *name, struct iattr *sattr, u32 ftype) 2785{ 2786 struct nfs4_createdata *data; 2787 2788 data = kzalloc(sizeof(*data), GFP_KERNEL); 2789 if (data != NULL) { 2790 struct nfs_server *server = NFS_SERVER(dir); 2791 2792 data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE]; 2793 data->msg.rpc_argp = &data->arg; 2794 data->msg.rpc_resp = &data->res; 2795 data->arg.dir_fh = NFS_FH(dir); 2796 data->arg.server = server; 2797 data->arg.name = name; 2798 data->arg.attrs = sattr; 2799 data->arg.ftype = ftype; 2800 data->arg.bitmask = server->attr_bitmask; 2801 data->res.server = server; 2802 data->res.fh = &data->fh; 2803 data->res.fattr = &data->fattr; 2804 data->res.dir_fattr = &data->dir_fattr; 2805 nfs_fattr_init(data->res.fattr); 2806 nfs_fattr_init(data->res.dir_fattr); 2807 } 2808 return data; 2809} 2810 2811static int nfs4_do_create(struct inode *dir, struct dentry *dentry, struct nfs4_createdata *data) 2812{ 2813 int status = nfs4_call_sync(NFS_SERVER(dir), &data->msg, 2814 &data->arg, &data->res, 1); 2815 if (status == 0) { 2816 update_changeattr(dir, &data->res.dir_cinfo); 2817 nfs_post_op_update_inode(dir, data->res.dir_fattr); 2818 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr); 2819 } 2820 return status; 2821} 2822 2823static void nfs4_free_createdata(struct nfs4_createdata *data) 2824{ 2825 kfree(data); 2826} 2827 2828static int _nfs4_proc_symlink(struct inode *dir, struct dentry *dentry, 2829 struct page *page, unsigned int len, struct iattr *sattr) 2830{ 2831 struct nfs4_createdata *data; 2832 int status = -ENAMETOOLONG; 2833 2834 if (len > NFS4_MAXPATHLEN) 2835 goto out; 2836 2837 status = -ENOMEM; 2838 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4LNK); 2839 if (data == NULL) 2840 goto out; 2841 2842 data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SYMLINK]; 2843 data->arg.u.symlink.pages = &page; 2844 data->arg.u.symlink.len = len; 2845 2846 status = nfs4_do_create(dir, dentry, data); 2847 2848 nfs4_free_createdata(data); 2849out: 2850 return status; 2851} 2852 2853static int nfs4_proc_symlink(struct inode *dir, struct dentry *dentry, 2854 struct page *page, unsigned int len, struct iattr *sattr) 2855{ 2856 struct nfs4_exception exception = { }; 2857 int err; 2858 do { 2859 err = nfs4_handle_exception(NFS_SERVER(dir), 2860 _nfs4_proc_symlink(dir, dentry, page, 2861 len, sattr), 2862 &exception); 2863 } while (exception.retry); 2864 return err; 2865} 2866 2867static int _nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry, 2868 struct iattr *sattr) 2869{ 2870 struct nfs4_createdata *data; 2871 int status = -ENOMEM; 2872 2873 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4DIR); 2874 if (data == NULL) 2875 goto out; 2876 2877 status = nfs4_do_create(dir, dentry, data); 2878 2879 nfs4_free_createdata(data); 2880out: 2881 return status; 2882} 2883 2884static int nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry, 2885 struct iattr *sattr) 2886{ 2887 struct nfs4_exception exception = { }; 2888 int err; 2889 do { 2890 err = nfs4_handle_exception(NFS_SERVER(dir), 2891 _nfs4_proc_mkdir(dir, dentry, sattr), 2892 &exception); 2893 } while (exception.retry); 2894 return err; 2895} 2896 2897static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred, 2898 u64 cookie, struct page *page, unsigned int count, int plus) 2899{ 2900 struct inode *dir = dentry->d_inode; 2901 struct nfs4_readdir_arg args = { 2902 .fh = NFS_FH(dir), 2903 .pages = &page, 2904 .pgbase = 0, 2905 .count = count, 2906 .bitmask = NFS_SERVER(dentry->d_inode)->attr_bitmask, 2907 }; 2908 struct nfs4_readdir_res res; 2909 struct rpc_message msg = { 2910 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READDIR], 2911 .rpc_argp = &args, 2912 .rpc_resp = &res, 2913 .rpc_cred = cred, 2914 }; 2915 int status; 2916 2917 dprintk("%s: dentry = %s/%s, cookie = %Lu\n", __func__, 2918 dentry->d_parent->d_name.name, 2919 dentry->d_name.name, 2920 (unsigned long long)cookie); 2921 nfs4_setup_readdir(cookie, NFS_COOKIEVERF(dir), dentry, &args); 2922 res.pgbase = args.pgbase; 2923 status = nfs4_call_sync(NFS_SERVER(dir), &msg, &args, &res, 0); 2924 if (status == 0) 2925 memcpy(NFS_COOKIEVERF(dir), res.verifier.data, NFS4_VERIFIER_SIZE); 2926 2927 nfs_invalidate_atime(dir); 2928 2929 dprintk("%s: returns %d\n", __func__, status); 2930 return status; 2931} 2932 2933static int nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred, 2934 u64 cookie, struct page *page, unsigned int count, int plus) 2935{ 2936 struct nfs4_exception exception = { }; 2937 int err; 2938 do { 2939 err = nfs4_handle_exception(NFS_SERVER(dentry->d_inode), 2940 _nfs4_proc_readdir(dentry, cred, cookie, 2941 page, count, plus), 2942 &exception); 2943 } while (exception.retry); 2944 return err; 2945} 2946 2947static int _nfs4_proc_mknod(struct inode *dir, struct dentry *dentry, 2948 struct iattr *sattr, dev_t rdev) 2949{ 2950 struct nfs4_createdata *data; 2951 int mode = sattr->ia_mode; 2952 int status = -ENOMEM; 2953 2954 BUG_ON(!(sattr->ia_valid & ATTR_MODE)); 2955 BUG_ON(!S_ISFIFO(mode) && !S_ISBLK(mode) && !S_ISCHR(mode) && !S_ISSOCK(mode)); 2956 2957 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4SOCK); 2958 if (data == NULL) 2959 goto out; 2960 2961 if (S_ISFIFO(mode)) 2962 data->arg.ftype = NF4FIFO; 2963 else if (S_ISBLK(mode)) { 2964 data->arg.ftype = NF4BLK; 2965 data->arg.u.device.specdata1 = MAJOR(rdev); 2966 data->arg.u.device.specdata2 = MINOR(rdev); 2967 } 2968 else if (S_ISCHR(mode)) { 2969 data->arg.ftype = NF4CHR; 2970 data->arg.u.device.specdata1 = MAJOR(rdev); 2971 data->arg.u.device.specdata2 = MINOR(rdev); 2972 } 2973 2974 status = nfs4_do_create(dir, dentry, data); 2975 2976 nfs4_free_createdata(data); 2977out: 2978 return status; 2979} 2980 2981static int nfs4_proc_mknod(struct inode *dir, struct dentry *dentry, 2982 struct iattr *sattr, dev_t rdev) 2983{ 2984 struct nfs4_exception exception = { }; 2985 int err; 2986 do { 2987 err = nfs4_handle_exception(NFS_SERVER(dir), 2988 _nfs4_proc_mknod(dir, dentry, sattr, rdev), 2989 &exception); 2990 } while (exception.retry); 2991 return err; 2992} 2993 2994static int _nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, 2995 struct nfs_fsstat *fsstat) 2996{ 2997 struct nfs4_statfs_arg args = { 2998 .fh = fhandle, 2999 .bitmask = server->attr_bitmask, 3000 }; 3001 struct nfs4_statfs_res res = { 3002 .fsstat = fsstat, 3003 }; 3004 struct rpc_message msg = { 3005 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_STATFS], 3006 .rpc_argp = &args, 3007 .rpc_resp = &res, 3008 }; 3009 3010 nfs_fattr_init(fsstat->fattr); 3011 return nfs4_call_sync(server, &msg, &args, &res, 0); 3012} 3013 3014static int nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsstat *fsstat) 3015{ 3016 struct nfs4_exception exception = { }; 3017 int err; 3018 do { 3019 err = nfs4_handle_exception(server, 3020 _nfs4_proc_statfs(server, fhandle, fsstat), 3021 &exception); 3022 } while (exception.retry); 3023 return err; 3024} 3025 3026static int _nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, 3027 struct nfs_fsinfo *fsinfo) 3028{ 3029 struct nfs4_fsinfo_arg args = { 3030 .fh = fhandle, 3031 .bitmask = server->attr_bitmask, 3032 }; 3033 struct nfs4_fsinfo_res res = { 3034 .fsinfo = fsinfo, 3035 }; 3036 struct rpc_message msg = { 3037 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSINFO], 3038 .rpc_argp = &args, 3039 .rpc_resp = &res, 3040 }; 3041 3042 return nfs4_call_sync(server, &msg, &args, &res, 0); 3043} 3044 3045static int nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo) 3046{ 3047 struct nfs4_exception exception = { }; 3048 int err; 3049 3050 do { 3051 err = nfs4_handle_exception(server, 3052 _nfs4_do_fsinfo(server, fhandle, fsinfo), 3053 &exception); 3054 } while (exception.retry); 3055 return err; 3056} 3057 3058static int nfs4_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo) 3059{ 3060 nfs_fattr_init(fsinfo->fattr); 3061 return nfs4_do_fsinfo(server, fhandle, fsinfo); 3062} 3063 3064static int _nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle, 3065 struct nfs_pathconf *pathconf) 3066{ 3067 struct nfs4_pathconf_arg args = { 3068 .fh = fhandle, 3069 .bitmask = server->attr_bitmask, 3070 }; 3071 struct nfs4_pathconf_res res = { 3072 .pathconf = pathconf, 3073 }; 3074 struct rpc_message msg = { 3075 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_PATHCONF], 3076 .rpc_argp = &args, 3077 .rpc_resp = &res, 3078 }; 3079 3080 /* None of the pathconf attributes are mandatory to implement */ 3081 if ((args.bitmask[0] & nfs4_pathconf_bitmap[0]) == 0) { 3082 memset(pathconf, 0, sizeof(*pathconf)); 3083 return 0; 3084 } 3085 3086 nfs_fattr_init(pathconf->fattr); 3087 return nfs4_call_sync(server, &msg, &args, &res, 0); 3088} 3089 3090static int nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle, 3091 struct nfs_pathconf *pathconf) 3092{ 3093 struct nfs4_exception exception = { }; 3094 int err; 3095 3096 do { 3097 err = nfs4_handle_exception(server, 3098 _nfs4_proc_pathconf(server, fhandle, pathconf), 3099 &exception); 3100 } while (exception.retry); 3101 return err; 3102} 3103 3104static int nfs4_read_done(struct rpc_task *task, struct nfs_read_data *data) 3105{ 3106 struct nfs_server *server = NFS_SERVER(data->inode); 3107 3108 dprintk("--> %s\n", __func__); 3109 3110 if (!nfs4_sequence_done(task, &data->res.seq_res)) 3111 return -EAGAIN; 3112 3113 if (nfs4_async_handle_error(task, server, data->args.context->state) == -EAGAIN) { 3114 nfs_restart_rpc(task, server->nfs_client); 3115 return -EAGAIN; 3116 } 3117 3118 nfs_invalidate_atime(data->inode); 3119 if (task->tk_status > 0) 3120 renew_lease(server, data->timestamp); 3121 return 0; 3122} 3123 3124static void nfs4_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg) 3125{ 3126 data->timestamp = jiffies; 3127 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READ]; 3128} 3129 3130static int nfs4_write_done(struct rpc_task *task, struct nfs_write_data *data) 3131{ 3132 struct inode *inode = data->inode; 3133 3134 if (!nfs4_sequence_done(task, &data->res.seq_res)) 3135 return -EAGAIN; 3136 3137 if (nfs4_async_handle_error(task, NFS_SERVER(inode), data->args.context->state) == -EAGAIN) { 3138 nfs_restart_rpc(task, NFS_SERVER(inode)->nfs_client); 3139 return -EAGAIN; 3140 } 3141 if (task->tk_status >= 0) { 3142 renew_lease(NFS_SERVER(inode), data->timestamp); 3143 nfs_post_op_update_inode_force_wcc(inode, data->res.fattr); 3144 } 3145 return 0; 3146} 3147 3148static void nfs4_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg) 3149{ 3150 struct nfs_server *server = NFS_SERVER(data->inode); 3151 3152 data->args.bitmask = server->cache_consistency_bitmask; 3153 data->res.server = server; 3154 data->timestamp = jiffies; 3155 3156 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_WRITE]; 3157} 3158 3159static int nfs4_commit_done(struct rpc_task *task, struct nfs_write_data *data) 3160{ 3161 struct inode *inode = data->inode; 3162 3163 if (!nfs4_sequence_done(task, &data->res.seq_res)) 3164 return -EAGAIN; 3165 3166 if (nfs4_async_handle_error(task, NFS_SERVER(inode), NULL) == -EAGAIN) { 3167 nfs_restart_rpc(task, NFS_SERVER(inode)->nfs_client); 3168 return -EAGAIN; 3169 } 3170 nfs_refresh_inode(inode, data->res.fattr); 3171 return 0; 3172} 3173 3174static void nfs4_proc_commit_setup(struct nfs_write_data *data, struct rpc_message *msg) 3175{ 3176 struct nfs_server *server = NFS_SERVER(data->inode); 3177 3178 data->args.bitmask = server->cache_consistency_bitmask; 3179 data->res.server = server; 3180 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COMMIT]; 3181} 3182 3183struct nfs4_renewdata { 3184 struct nfs_client *client; 3185 unsigned long timestamp; 3186}; 3187 3188/* 3189 * nfs4_proc_async_renew(): This is not one of the nfs_rpc_ops; it is a special 3190 * standalone procedure for queueing an asynchronous RENEW. 3191 */ 3192static void nfs4_renew_release(void *calldata) 3193{ 3194 struct nfs4_renewdata *data = calldata; 3195 struct nfs_client *clp = data->client; 3196 3197 if (atomic_read(&clp->cl_count) > 1) 3198 nfs4_schedule_state_renewal(clp); 3199 nfs_put_client(clp); 3200 kfree(data); 3201} 3202 3203static void nfs4_renew_done(struct rpc_task *task, void *calldata) 3204{ 3205 struct nfs4_renewdata *data = calldata; 3206 struct nfs_client *clp = data->client; 3207 unsigned long timestamp = data->timestamp; 3208 3209 if (task->tk_status < 0) { 3210 /* Unless we're shutting down, schedule state recovery! */ 3211 if (test_bit(NFS_CS_RENEWD, &clp->cl_res_state) != 0) 3212 nfs4_schedule_state_recovery(clp); 3213 return; 3214 } 3215 do_renew_lease(clp, timestamp); 3216} 3217 3218static const struct rpc_call_ops nfs4_renew_ops = { 3219 .rpc_call_done = nfs4_renew_done, 3220 .rpc_release = nfs4_renew_release, 3221}; 3222 3223int nfs4_proc_async_renew(struct nfs_client *clp, struct rpc_cred *cred) 3224{ 3225 struct rpc_message msg = { 3226 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW], 3227 .rpc_argp = clp, 3228 .rpc_cred = cred, 3229 }; 3230 struct nfs4_renewdata *data; 3231 3232 if (!atomic_inc_not_zero(&clp->cl_count)) 3233 return -EIO; 3234 data = kmalloc(sizeof(*data), GFP_KERNEL); 3235 if (data == NULL) 3236 return -ENOMEM; 3237 data->client = clp; 3238 data->timestamp = jiffies; 3239 return rpc_call_async(clp->cl_rpcclient, &msg, RPC_TASK_SOFT, 3240 &nfs4_renew_ops, data); 3241} 3242 3243int nfs4_proc_renew(struct nfs_client *clp, struct rpc_cred *cred) 3244{ 3245 struct rpc_message msg = { 3246 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW], 3247 .rpc_argp = clp, 3248 .rpc_cred = cred, 3249 }; 3250 unsigned long now = jiffies; 3251 int status; 3252 3253 status = rpc_call_sync(clp->cl_rpcclient, &msg, 0); 3254 if (status < 0) 3255 return status; 3256 do_renew_lease(clp, now); 3257 return 0; 3258} 3259 3260static inline int nfs4_server_supports_acls(struct nfs_server *server) 3261{ 3262 return (server->caps & NFS_CAP_ACLS) 3263 && (server->acl_bitmask & ACL4_SUPPORT_ALLOW_ACL) 3264 && (server->acl_bitmask & ACL4_SUPPORT_DENY_ACL); 3265} 3266 3267/* Assuming that XATTR_SIZE_MAX is a multiple of PAGE_CACHE_SIZE, and that 3268 * it's OK to put sizeof(void) * (XATTR_SIZE_MAX/PAGE_CACHE_SIZE) bytes on 3269 * the stack. 3270 */ 3271#define NFS4ACL_MAXPAGES (XATTR_SIZE_MAX >> PAGE_CACHE_SHIFT) 3272 3273static void buf_to_pages(const void *buf, size_t buflen, 3274 struct page **pages, unsigned int *pgbase) 3275{ 3276 const void *p = buf; 3277 3278 *pgbase = offset_in_page(buf); 3279 p -= *pgbase; 3280 while (p < buf + buflen) { 3281 *(pages++) = virt_to_page(p); 3282 p += PAGE_CACHE_SIZE; 3283 } 3284} 3285 3286struct nfs4_cached_acl { 3287 int cached; 3288 size_t len; 3289 char data[0]; 3290}; 3291 3292static void nfs4_set_cached_acl(struct inode *inode, struct nfs4_cached_acl *acl) 3293{ 3294 struct nfs_inode *nfsi = NFS_I(inode); 3295 3296 spin_lock(&inode->i_lock); 3297 kfree(nfsi->nfs4_acl); 3298 nfsi->nfs4_acl = acl; 3299 spin_unlock(&inode->i_lock); 3300} 3301 3302static void nfs4_zap_acl_attr(struct inode *inode) 3303{ 3304 nfs4_set_cached_acl(inode, NULL); 3305} 3306 3307static inline ssize_t nfs4_read_cached_acl(struct inode *inode, char *buf, size_t buflen) 3308{ 3309 struct nfs_inode *nfsi = NFS_I(inode); 3310 struct nfs4_cached_acl *acl; 3311 int ret = -ENOENT; 3312 3313 spin_lock(&inode->i_lock); 3314 acl = nfsi->nfs4_acl; 3315 if (acl == NULL) 3316 goto out; 3317 if (buf == NULL) /* user is just asking for length */ 3318 goto out_len; 3319 if (acl->cached == 0) 3320 goto out; 3321 ret = -ERANGE; /* see getxattr(2) man page */ 3322 if (acl->len > buflen) 3323 goto out; 3324 memcpy(buf, acl->data, acl->len); 3325out_len: 3326 ret = acl->len; 3327out: 3328 spin_unlock(&inode->i_lock); 3329 return ret; 3330} 3331 3332static void nfs4_write_cached_acl(struct inode *inode, const char *buf, size_t acl_len) 3333{ 3334 struct nfs4_cached_acl *acl; 3335 3336 if (buf && acl_len <= PAGE_SIZE) { 3337 acl = kmalloc(sizeof(*acl) + acl_len, GFP_KERNEL); 3338 if (acl == NULL) 3339 goto out; 3340 acl->cached = 1; 3341 memcpy(acl->data, buf, acl_len); 3342 } else { 3343 acl = kmalloc(sizeof(*acl), GFP_KERNEL); 3344 if (acl == NULL) 3345 goto out; 3346 acl->cached = 0; 3347 } 3348 acl->len = acl_len; 3349out: 3350 nfs4_set_cached_acl(inode, acl); 3351} 3352 3353static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen) 3354{ 3355 struct page *pages[NFS4ACL_MAXPAGES]; 3356 struct nfs_getaclargs args = { 3357 .fh = NFS_FH(inode), 3358 .acl_pages = pages, 3359 .acl_len = buflen, 3360 }; 3361 struct nfs_getaclres res = { 3362 .acl_len = buflen, 3363 }; 3364 void *resp_buf; 3365 struct rpc_message msg = { 3366 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETACL], 3367 .rpc_argp = &args, 3368 .rpc_resp = &res, 3369 }; 3370 struct page *localpage = NULL; 3371 int ret; 3372 3373 if (buflen < PAGE_SIZE) { 3374 /* As long as we're doing a round trip to the server anyway, 3375 * let's be prepared for a page of acl data. */ 3376 localpage = alloc_page(GFP_KERNEL); 3377 resp_buf = page_address(localpage); 3378 if (localpage == NULL) 3379 return -ENOMEM; 3380 args.acl_pages[0] = localpage; 3381 args.acl_pgbase = 0; 3382 args.acl_len = PAGE_SIZE; 3383 } else { 3384 resp_buf = buf; 3385 buf_to_pages(buf, buflen, args.acl_pages, &args.acl_pgbase); 3386 } 3387 ret = nfs4_call_sync(NFS_SERVER(inode), &msg, &args, &res, 0); 3388 if (ret) 3389 goto out_free; 3390 if (res.acl_len > args.acl_len) 3391 nfs4_write_cached_acl(inode, NULL, res.acl_len); 3392 else 3393 nfs4_write_cached_acl(inode, resp_buf, res.acl_len); 3394 if (buf) { 3395 ret = -ERANGE; 3396 if (res.acl_len > buflen) 3397 goto out_free; 3398 if (localpage) 3399 memcpy(buf, resp_buf, res.acl_len); 3400 } 3401 ret = res.acl_len; 3402out_free: 3403 if (localpage) 3404 __free_page(localpage); 3405 return ret; 3406} 3407 3408static ssize_t nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen) 3409{ 3410 struct nfs4_exception exception = { }; 3411 ssize_t ret; 3412 do { 3413 ret = __nfs4_get_acl_uncached(inode, buf, buflen); 3414 if (ret >= 0) 3415 break; 3416 ret = nfs4_handle_exception(NFS_SERVER(inode), ret, &exception); 3417 } while (exception.retry); 3418 return ret; 3419} 3420 3421static ssize_t nfs4_proc_get_acl(struct inode *inode, void *buf, size_t buflen) 3422{ 3423 struct nfs_server *server = NFS_SERVER(inode); 3424 int ret; 3425 3426 if (!nfs4_server_supports_acls(server)) 3427 return -EOPNOTSUPP; 3428 ret = nfs_revalidate_inode(server, inode); 3429 if (ret < 0) 3430 return ret; 3431 ret = nfs4_read_cached_acl(inode, buf, buflen); 3432 if (ret != -ENOENT) 3433 return ret; 3434 return nfs4_get_acl_uncached(inode, buf, buflen); 3435} 3436 3437static int __nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen) 3438{ 3439 struct nfs_server *server = NFS_SERVER(inode); 3440 struct page *pages[NFS4ACL_MAXPAGES]; 3441 struct nfs_setaclargs arg = { 3442 .fh = NFS_FH(inode), 3443 .acl_pages = pages, 3444 .acl_len = buflen, 3445 }; 3446 struct nfs_setaclres res; 3447 struct rpc_message msg = { 3448 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETACL], 3449 .rpc_argp = &arg, 3450 .rpc_resp = &res, 3451 }; 3452 int ret; 3453 3454 if (!nfs4_server_supports_acls(server)) 3455 return -EOPNOTSUPP; 3456 nfs_inode_return_delegation(inode); 3457 buf_to_pages(buf, buflen, arg.acl_pages, &arg.acl_pgbase); 3458 ret = nfs4_call_sync(server, &msg, &arg, &res, 1); 3459 nfs_access_zap_cache(inode); 3460 nfs_zap_acl_cache(inode); 3461 return ret; 3462} 3463 3464static int nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen) 3465{ 3466 struct nfs4_exception exception = { }; 3467 int err; 3468 do { 3469 err = nfs4_handle_exception(NFS_SERVER(inode), 3470 __nfs4_proc_set_acl(inode, buf, buflen), 3471 &exception); 3472 } while (exception.retry); 3473 return err; 3474} 3475 3476static int 3477nfs4_async_handle_error(struct rpc_task *task, const struct nfs_server *server, struct nfs4_state *state) 3478{ 3479 struct nfs_client *clp = server->nfs_client; 3480 3481 if (task->tk_status >= 0) 3482 return 0; 3483 switch(task->tk_status) { 3484 case -NFS4ERR_ADMIN_REVOKED: 3485 case -NFS4ERR_BAD_STATEID: 3486 case -NFS4ERR_OPENMODE: 3487 if (state == NULL) 3488 break; 3489 nfs4_state_mark_reclaim_nograce(clp, state); 3490 goto do_state_recovery; 3491 case -NFS4ERR_STALE_STATEID: 3492 case -NFS4ERR_STALE_CLIENTID: 3493 case -NFS4ERR_EXPIRED: 3494 goto do_state_recovery; 3495#if defined(CONFIG_NFS_V4_1) 3496 case -NFS4ERR_BADSESSION: 3497 case -NFS4ERR_BADSLOT: 3498 case -NFS4ERR_BAD_HIGH_SLOT: 3499 case -NFS4ERR_DEADSESSION: 3500 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 3501 case -NFS4ERR_SEQ_FALSE_RETRY: 3502 case -NFS4ERR_SEQ_MISORDERED: 3503 dprintk("%s ERROR %d, Reset session\n", __func__, 3504 task->tk_status); 3505 nfs4_schedule_state_recovery(clp); 3506 task->tk_status = 0; 3507 return -EAGAIN; 3508#endif /* CONFIG_NFS_V4_1 */ 3509 case -NFS4ERR_DELAY: 3510 nfs_inc_server_stats(server, NFSIOS_DELAY); 3511 case -NFS4ERR_GRACE: 3512 case -EKEYEXPIRED: 3513 rpc_delay(task, NFS4_POLL_RETRY_MAX); 3514 task->tk_status = 0; 3515 return -EAGAIN; 3516 case -NFS4ERR_OLD_STATEID: 3517 task->tk_status = 0; 3518 return -EAGAIN; 3519 } 3520 task->tk_status = nfs4_map_errors(task->tk_status); 3521 return 0; 3522do_state_recovery: 3523 rpc_sleep_on(&clp->cl_rpcwaitq, task, NULL); 3524 nfs4_schedule_state_recovery(clp); 3525 if (test_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) == 0) 3526 rpc_wake_up_queued_task(&clp->cl_rpcwaitq, task); 3527 task->tk_status = 0; 3528 return -EAGAIN; 3529} 3530 3531int nfs4_proc_setclientid(struct nfs_client *clp, u32 program, 3532 unsigned short port, struct rpc_cred *cred, 3533 struct nfs4_setclientid_res *res) 3534{ 3535 nfs4_verifier sc_verifier; 3536 struct nfs4_setclientid setclientid = { 3537 .sc_verifier = &sc_verifier, 3538 .sc_prog = program, 3539 }; 3540 struct rpc_message msg = { 3541 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID], 3542 .rpc_argp = &setclientid, 3543 .rpc_resp = res, 3544 .rpc_cred = cred, 3545 }; 3546 __be32 *p; 3547 int loop = 0; 3548 int status; 3549 3550 p = (__be32*)sc_verifier.data; 3551 *p++ = htonl((u32)clp->cl_boot_time.tv_sec); 3552 *p = htonl((u32)clp->cl_boot_time.tv_nsec); 3553 3554 for(;;) { 3555 setclientid.sc_name_len = scnprintf(setclientid.sc_name, 3556 sizeof(setclientid.sc_name), "%s/%s %s %s %u", 3557 clp->cl_ipaddr, 3558 rpc_peeraddr2str(clp->cl_rpcclient, 3559 RPC_DISPLAY_ADDR), 3560 rpc_peeraddr2str(clp->cl_rpcclient, 3561 RPC_DISPLAY_PROTO), 3562 clp->cl_rpcclient->cl_auth->au_ops->au_name, 3563 clp->cl_id_uniquifier); 3564 setclientid.sc_netid_len = scnprintf(setclientid.sc_netid, 3565 sizeof(setclientid.sc_netid), 3566 rpc_peeraddr2str(clp->cl_rpcclient, 3567 RPC_DISPLAY_NETID)); 3568 setclientid.sc_uaddr_len = scnprintf(setclientid.sc_uaddr, 3569 sizeof(setclientid.sc_uaddr), "%s.%u.%u", 3570 clp->cl_ipaddr, port >> 8, port & 255); 3571 3572 status = rpc_call_sync(clp->cl_rpcclient, &msg, 0); 3573 if (status != -NFS4ERR_CLID_INUSE) 3574 break; 3575 if (signalled()) 3576 break; 3577 if (loop++ & 1) 3578 ssleep(clp->cl_lease_time + 1); 3579 else 3580 if (++clp->cl_id_uniquifier == 0) 3581 break; 3582 } 3583 return status; 3584} 3585 3586static int _nfs4_proc_setclientid_confirm(struct nfs_client *clp, 3587 struct nfs4_setclientid_res *arg, 3588 struct rpc_cred *cred) 3589{ 3590 struct nfs_fsinfo fsinfo; 3591 struct rpc_message msg = { 3592 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID_CONFIRM], 3593 .rpc_argp = arg, 3594 .rpc_resp = &fsinfo, 3595 .rpc_cred = cred, 3596 }; 3597 unsigned long now; 3598 int status; 3599 3600 now = jiffies; 3601 status = rpc_call_sync(clp->cl_rpcclient, &msg, 0); 3602 if (status == 0) { 3603 spin_lock(&clp->cl_lock); 3604 clp->cl_lease_time = fsinfo.lease_time * HZ; 3605 clp->cl_last_renewal = now; 3606 spin_unlock(&clp->cl_lock); 3607 } 3608 return status; 3609} 3610 3611int nfs4_proc_setclientid_confirm(struct nfs_client *clp, 3612 struct nfs4_setclientid_res *arg, 3613 struct rpc_cred *cred) 3614{ 3615 long timeout = 0; 3616 int err; 3617 do { 3618 err = _nfs4_proc_setclientid_confirm(clp, arg, cred); 3619 switch (err) { 3620 case 0: 3621 return err; 3622 case -NFS4ERR_RESOURCE: 3623 /* The IBM lawyers misread another document! */ 3624 case -NFS4ERR_DELAY: 3625 case -EKEYEXPIRED: 3626 err = nfs4_delay(clp->cl_rpcclient, &timeout); 3627 } 3628 } while (err == 0); 3629 return err; 3630} 3631 3632struct nfs4_delegreturndata { 3633 struct nfs4_delegreturnargs args; 3634 struct nfs4_delegreturnres res; 3635 struct nfs_fh fh; 3636 nfs4_stateid stateid; 3637 unsigned long timestamp; 3638 struct nfs_fattr fattr; 3639 int rpc_status; 3640}; 3641 3642static void nfs4_delegreturn_done(struct rpc_task *task, void *calldata) 3643{ 3644 struct nfs4_delegreturndata *data = calldata; 3645 3646 if (!nfs4_sequence_done(task, &data->res.seq_res)) 3647 return; 3648 3649 switch (task->tk_status) { 3650 case -NFS4ERR_STALE_STATEID: 3651 case -NFS4ERR_EXPIRED: 3652 case 0: 3653 renew_lease(data->res.server, data->timestamp); 3654 break; 3655 default: 3656 if (nfs4_async_handle_error(task, data->res.server, NULL) == 3657 -EAGAIN) { 3658 nfs_restart_rpc(task, data->res.server->nfs_client); 3659 return; 3660 } 3661 } 3662 data->rpc_status = task->tk_status; 3663} 3664 3665static void nfs4_delegreturn_release(void *calldata) 3666{ 3667 kfree(calldata); 3668} 3669 3670#if defined(CONFIG_NFS_V4_1) 3671static void nfs4_delegreturn_prepare(struct rpc_task *task, void *data) 3672{ 3673 struct nfs4_delegreturndata *d_data; 3674 3675 d_data = (struct nfs4_delegreturndata *)data; 3676 3677 if (nfs4_setup_sequence(d_data->res.server, 3678 &d_data->args.seq_args, 3679 &d_data->res.seq_res, 1, task)) 3680 return; 3681 rpc_call_start(task); 3682} 3683#endif /* CONFIG_NFS_V4_1 */ 3684 3685static const struct rpc_call_ops nfs4_delegreturn_ops = { 3686#if defined(CONFIG_NFS_V4_1) 3687 .rpc_call_prepare = nfs4_delegreturn_prepare, 3688#endif /* CONFIG_NFS_V4_1 */ 3689 .rpc_call_done = nfs4_delegreturn_done, 3690 .rpc_release = nfs4_delegreturn_release, 3691}; 3692 3693static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync) 3694{ 3695 struct nfs4_delegreturndata *data; 3696 struct nfs_server *server = NFS_SERVER(inode); 3697 struct rpc_task *task; 3698 struct rpc_message msg = { 3699 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DELEGRETURN], 3700 .rpc_cred = cred, 3701 }; 3702 struct rpc_task_setup task_setup_data = { 3703 .rpc_client = server->client, 3704 .rpc_message = &msg, 3705 .callback_ops = &nfs4_delegreturn_ops, 3706 .flags = RPC_TASK_ASYNC, 3707 }; 3708 int status = 0; 3709 3710 data = kzalloc(sizeof(*data), GFP_NOFS); 3711 if (data == NULL) 3712 return -ENOMEM; 3713 data->args.fhandle = &data->fh; 3714 data->args.stateid = &data->stateid; 3715 data->args.bitmask = server->attr_bitmask; 3716 nfs_copy_fh(&data->fh, NFS_FH(inode)); 3717 memcpy(&data->stateid, stateid, sizeof(data->stateid)); 3718 data->res.fattr = &data->fattr; 3719 data->res.server = server; 3720 data->res.seq_res.sr_slotid = NFS4_MAX_SLOT_TABLE; 3721 nfs_fattr_init(data->res.fattr); 3722 data->timestamp = jiffies; 3723 data->rpc_status = 0; 3724 3725 task_setup_data.callback_data = data; 3726 msg.rpc_argp = &data->args, 3727 msg.rpc_resp = &data->res, 3728 task = rpc_run_task(&task_setup_data); 3729 if (IS_ERR(task)) 3730 return PTR_ERR(task); 3731 if (!issync) 3732 goto out; 3733 status = nfs4_wait_for_completion_rpc_task(task); 3734 if (status != 0) 3735 goto out; 3736 status = data->rpc_status; 3737 if (status != 0) 3738 goto out; 3739 nfs_refresh_inode(inode, &data->fattr); 3740out: 3741 rpc_put_task(task); 3742 return status; 3743} 3744 3745int nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync) 3746{ 3747 struct nfs_server *server = NFS_SERVER(inode); 3748 struct nfs4_exception exception = { }; 3749 int err; 3750 do { 3751 err = _nfs4_proc_delegreturn(inode, cred, stateid, issync); 3752 switch (err) { 3753 case -NFS4ERR_STALE_STATEID: 3754 case -NFS4ERR_EXPIRED: 3755 case 0: 3756 return 0; 3757 } 3758 err = nfs4_handle_exception(server, err, &exception); 3759 } while (exception.retry); 3760 return err; 3761} 3762 3763#define NFS4_LOCK_MINTIMEOUT (1 * HZ) 3764#define NFS4_LOCK_MAXTIMEOUT (30 * HZ) 3765 3766/* 3767 * sleep, with exponential backoff, and retry the LOCK operation. 3768 */ 3769static unsigned long 3770nfs4_set_lock_task_retry(unsigned long timeout) 3771{ 3772 schedule_timeout_killable(timeout); 3773 timeout <<= 1; 3774 if (timeout > NFS4_LOCK_MAXTIMEOUT) 3775 return NFS4_LOCK_MAXTIMEOUT; 3776 return timeout; 3777} 3778 3779static int _nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request) 3780{ 3781 struct inode *inode = state->inode; 3782 struct nfs_server *server = NFS_SERVER(inode); 3783 struct nfs_client *clp = server->nfs_client; 3784 struct nfs_lockt_args arg = { 3785 .fh = NFS_FH(inode), 3786 .fl = request, 3787 }; 3788 struct nfs_lockt_res res = { 3789 .denied = request, 3790 }; 3791 struct rpc_message msg = { 3792 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKT], 3793 .rpc_argp = &arg, 3794 .rpc_resp = &res, 3795 .rpc_cred = state->owner->so_cred, 3796 }; 3797 struct nfs4_lock_state *lsp; 3798 int status; 3799 3800 arg.lock_owner.clientid = clp->cl_clientid; 3801 status = nfs4_set_lock_state(state, request); 3802 if (status != 0) 3803 goto out; 3804 lsp = request->fl_u.nfs4_fl.owner; 3805 arg.lock_owner.id = lsp->ls_id.id; 3806 status = nfs4_call_sync(server, &msg, &arg, &res, 1); 3807 switch (status) { 3808 case 0: 3809 request->fl_type = F_UNLCK; 3810 break; 3811 case -NFS4ERR_DENIED: 3812 status = 0; 3813 } 3814 request->fl_ops->fl_release_private(request); 3815out: 3816 return status; 3817} 3818 3819static int nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request) 3820{ 3821 struct nfs4_exception exception = { }; 3822 int err; 3823 3824 do { 3825 err = nfs4_handle_exception(NFS_SERVER(state->inode), 3826 _nfs4_proc_getlk(state, cmd, request), 3827 &exception); 3828 } while (exception.retry); 3829 return err; 3830} 3831 3832static int do_vfs_lock(struct file *file, struct file_lock *fl) 3833{ 3834 int res = 0; 3835 switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) { 3836 case FL_POSIX: 3837 res = posix_lock_file_wait(file, fl); 3838 break; 3839 case FL_FLOCK: 3840 res = flock_lock_file_wait(file, fl); 3841 break; 3842 default: 3843 BUG(); 3844 } 3845 return res; 3846} 3847 3848struct nfs4_unlockdata { 3849 struct nfs_locku_args arg; 3850 struct nfs_locku_res res; 3851 struct nfs4_lock_state *lsp; 3852 struct nfs_open_context *ctx; 3853 struct file_lock fl; 3854 const struct nfs_server *server; 3855 unsigned long timestamp; 3856}; 3857 3858static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl, 3859 struct nfs_open_context *ctx, 3860 struct nfs4_lock_state *lsp, 3861 struct nfs_seqid *seqid) 3862{ 3863 struct nfs4_unlockdata *p; 3864 struct inode *inode = lsp->ls_state->inode; 3865 3866 p = kzalloc(sizeof(*p), GFP_NOFS); 3867 if (p == NULL) 3868 return NULL; 3869 p->arg.fh = NFS_FH(inode); 3870 p->arg.fl = &p->fl; 3871 p->arg.seqid = seqid; 3872 p->res.seqid = seqid; 3873 p->res.seq_res.sr_slotid = NFS4_MAX_SLOT_TABLE; 3874 p->arg.stateid = &lsp->ls_stateid; 3875 p->lsp = lsp; 3876 atomic_inc(&lsp->ls_count); 3877 /* Ensure we don't close file until we're done freeing locks! */ 3878 p->ctx = get_nfs_open_context(ctx); 3879 memcpy(&p->fl, fl, sizeof(p->fl)); 3880 p->server = NFS_SERVER(inode); 3881 return p; 3882} 3883 3884static void nfs4_locku_release_calldata(void *data) 3885{ 3886 struct nfs4_unlockdata *calldata = data; 3887 nfs_free_seqid(calldata->arg.seqid); 3888 nfs4_put_lock_state(calldata->lsp); 3889 put_nfs_open_context(calldata->ctx); 3890 kfree(calldata); 3891} 3892 3893static void nfs4_locku_done(struct rpc_task *task, void *data) 3894{ 3895 struct nfs4_unlockdata *calldata = data; 3896 3897 if (!nfs4_sequence_done(task, &calldata->res.seq_res)) 3898 return; 3899 switch (task->tk_status) { 3900 case 0: 3901 memcpy(calldata->lsp->ls_stateid.data, 3902 calldata->res.stateid.data, 3903 sizeof(calldata->lsp->ls_stateid.data)); 3904 renew_lease(calldata->server, calldata->timestamp); 3905 break; 3906 case -NFS4ERR_BAD_STATEID: 3907 case -NFS4ERR_OLD_STATEID: 3908 case -NFS4ERR_STALE_STATEID: 3909 case -NFS4ERR_EXPIRED: 3910 break; 3911 default: 3912 if (nfs4_async_handle_error(task, calldata->server, NULL) == -EAGAIN) 3913 nfs_restart_rpc(task, 3914 calldata->server->nfs_client); 3915 } 3916} 3917 3918static void nfs4_locku_prepare(struct rpc_task *task, void *data) 3919{ 3920 struct nfs4_unlockdata *calldata = data; 3921 3922 if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0) 3923 return; 3924 if ((calldata->lsp->ls_flags & NFS_LOCK_INITIALIZED) == 0) { 3925 /* Note: exit _without_ running nfs4_locku_done */ 3926 task->tk_action = NULL; 3927 return; 3928 } 3929 calldata->timestamp = jiffies; 3930 if (nfs4_setup_sequence(calldata->server, 3931 &calldata->arg.seq_args, 3932 &calldata->res.seq_res, 1, task)) 3933 return; 3934 rpc_call_start(task); 3935} 3936 3937static const struct rpc_call_ops nfs4_locku_ops = { 3938 .rpc_call_prepare = nfs4_locku_prepare, 3939 .rpc_call_done = nfs4_locku_done, 3940 .rpc_release = nfs4_locku_release_calldata, 3941}; 3942 3943static struct rpc_task *nfs4_do_unlck(struct file_lock *fl, 3944 struct nfs_open_context *ctx, 3945 struct nfs4_lock_state *lsp, 3946 struct nfs_seqid *seqid) 3947{ 3948 struct nfs4_unlockdata *data; 3949 struct rpc_message msg = { 3950 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKU], 3951 .rpc_cred = ctx->cred, 3952 }; 3953 struct rpc_task_setup task_setup_data = { 3954 .rpc_client = NFS_CLIENT(lsp->ls_state->inode), 3955 .rpc_message = &msg, 3956 .callback_ops = &nfs4_locku_ops, 3957 .workqueue = nfsiod_workqueue, 3958 .flags = RPC_TASK_ASYNC, 3959 }; 3960 3961 /* Ensure this is an unlock - when canceling a lock, the 3962 * canceled lock is passed in, and it won't be an unlock. 3963 */ 3964 fl->fl_type = F_UNLCK; 3965 3966 data = nfs4_alloc_unlockdata(fl, ctx, lsp, seqid); 3967 if (data == NULL) { 3968 nfs_free_seqid(seqid); 3969 return ERR_PTR(-ENOMEM); 3970 } 3971 3972 msg.rpc_argp = &data->arg, 3973 msg.rpc_resp = &data->res, 3974 task_setup_data.callback_data = data; 3975 return rpc_run_task(&task_setup_data); 3976} 3977 3978static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock *request) 3979{ 3980 struct nfs_inode *nfsi = NFS_I(state->inode); 3981 struct nfs_seqid *seqid; 3982 struct nfs4_lock_state *lsp; 3983 struct rpc_task *task; 3984 int status = 0; 3985 unsigned char fl_flags = request->fl_flags; 3986 3987 status = nfs4_set_lock_state(state, request); 3988 /* Unlock _before_ we do the RPC call */ 3989 request->fl_flags |= FL_EXISTS; 3990 down_read(&nfsi->rwsem); 3991 if (do_vfs_lock(request->fl_file, request) == -ENOENT) { 3992 up_read(&nfsi->rwsem); 3993 goto out; 3994 } 3995 up_read(&nfsi->rwsem); 3996 if (status != 0) 3997 goto out; 3998 /* Is this a delegated lock? */ 3999 if (test_bit(NFS_DELEGATED_STATE, &state->flags)) 4000 goto out; 4001 lsp = request->fl_u.nfs4_fl.owner; 4002 seqid = nfs_alloc_seqid(&lsp->ls_seqid, GFP_KERNEL); 4003 status = -ENOMEM; 4004 if (seqid == NULL) 4005 goto out; 4006 task = nfs4_do_unlck(request, nfs_file_open_context(request->fl_file), lsp, seqid); 4007 status = PTR_ERR(task); 4008 if (IS_ERR(task)) 4009 goto out; 4010 status = nfs4_wait_for_completion_rpc_task(task); 4011 rpc_put_task(task); 4012out: 4013 request->fl_flags = fl_flags; 4014 return status; 4015} 4016 4017struct nfs4_lockdata { 4018 struct nfs_lock_args arg; 4019 struct nfs_lock_res res; 4020 struct nfs4_lock_state *lsp; 4021 struct nfs_open_context *ctx; 4022 struct file_lock fl; 4023 unsigned long timestamp; 4024 int rpc_status; 4025 int cancelled; 4026 struct nfs_server *server; 4027}; 4028 4029static struct nfs4_lockdata *nfs4_alloc_lockdata(struct file_lock *fl, 4030 struct nfs_open_context *ctx, struct nfs4_lock_state *lsp, 4031 gfp_t gfp_mask) 4032{ 4033 struct nfs4_lockdata *p; 4034 struct inode *inode = lsp->ls_state->inode; 4035 struct nfs_server *server = NFS_SERVER(inode); 4036 4037 p = kzalloc(sizeof(*p), gfp_mask); 4038 if (p == NULL) 4039 return NULL; 4040 4041 p->arg.fh = NFS_FH(inode); 4042 p->arg.fl = &p->fl; 4043 p->arg.open_seqid = nfs_alloc_seqid(&lsp->ls_state->owner->so_seqid, gfp_mask); 4044 if (p->arg.open_seqid == NULL) 4045 goto out_free; 4046 p->arg.lock_seqid = nfs_alloc_seqid(&lsp->ls_seqid, gfp_mask); 4047 if (p->arg.lock_seqid == NULL) 4048 goto out_free_seqid; 4049 p->arg.lock_stateid = &lsp->ls_stateid; 4050 p->arg.lock_owner.clientid = server->nfs_client->cl_clientid; 4051 p->arg.lock_owner.id = lsp->ls_id.id; 4052 p->res.lock_seqid = p->arg.lock_seqid; 4053 p->res.seq_res.sr_slotid = NFS4_MAX_SLOT_TABLE; 4054 p->lsp = lsp; 4055 p->server = server; 4056 atomic_inc(&lsp->ls_count); 4057 p->ctx = get_nfs_open_context(ctx); 4058 memcpy(&p->fl, fl, sizeof(p->fl)); 4059 return p; 4060out_free_seqid: 4061 nfs_free_seqid(p->arg.open_seqid); 4062out_free: 4063 kfree(p); 4064 return NULL; 4065} 4066 4067static void nfs4_lock_prepare(struct rpc_task *task, void *calldata) 4068{ 4069 struct nfs4_lockdata *data = calldata; 4070 struct nfs4_state *state = data->lsp->ls_state; 4071 4072 dprintk("%s: begin!\n", __func__); 4073 if (nfs_wait_on_sequence(data->arg.lock_seqid, task) != 0) 4074 return; 4075 /* Do we need to do an open_to_lock_owner? */ 4076 if (!(data->arg.lock_seqid->sequence->flags & NFS_SEQID_CONFIRMED)) { 4077 if (nfs_wait_on_sequence(data->arg.open_seqid, task) != 0) 4078 return; 4079 data->arg.open_stateid = &state->stateid; 4080 data->arg.new_lock_owner = 1; 4081 data->res.open_seqid = data->arg.open_seqid; 4082 } else 4083 data->arg.new_lock_owner = 0; 4084 data->timestamp = jiffies; 4085 if (nfs4_setup_sequence(data->server, 4086 &data->arg.seq_args, 4087 &data->res.seq_res, 1, task)) 4088 return; 4089 rpc_call_start(task); 4090 dprintk("%s: done!, ret = %d\n", __func__, data->rpc_status); 4091} 4092 4093static void nfs4_recover_lock_prepare(struct rpc_task *task, void *calldata) 4094{ 4095 rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED); 4096 nfs4_lock_prepare(task, calldata); 4097} 4098 4099static void nfs4_lock_done(struct rpc_task *task, void *calldata) 4100{ 4101 struct nfs4_lockdata *data = calldata; 4102 4103 dprintk("%s: begin!\n", __func__); 4104 4105 if (!nfs4_sequence_done(task, &data->res.seq_res)) 4106 return; 4107 4108 data->rpc_status = task->tk_status; 4109 if (data->arg.new_lock_owner != 0) { 4110 if (data->rpc_status == 0) 4111 nfs_confirm_seqid(&data->lsp->ls_seqid, 0); 4112 else 4113 goto out; 4114 } 4115 if (data->rpc_status == 0) { 4116 memcpy(data->lsp->ls_stateid.data, data->res.stateid.data, 4117 sizeof(data->lsp->ls_stateid.data)); 4118 data->lsp->ls_flags |= NFS_LOCK_INITIALIZED; 4119 renew_lease(NFS_SERVER(data->ctx->path.dentry->d_inode), data->timestamp); 4120 } 4121out: 4122 dprintk("%s: done, ret = %d!\n", __func__, data->rpc_status); 4123} 4124 4125static void nfs4_lock_release(void *calldata) 4126{ 4127 struct nfs4_lockdata *data = calldata; 4128 4129 dprintk("%s: begin!\n", __func__); 4130 nfs_free_seqid(data->arg.open_seqid); 4131 if (data->cancelled != 0) { 4132 struct rpc_task *task; 4133 task = nfs4_do_unlck(&data->fl, data->ctx, data->lsp, 4134 data->arg.lock_seqid); 4135 if (!IS_ERR(task)) 4136 rpc_put_task(task); 4137 dprintk("%s: cancelling lock!\n", __func__); 4138 } else 4139 nfs_free_seqid(data->arg.lock_seqid); 4140 nfs4_put_lock_state(data->lsp); 4141 put_nfs_open_context(data->ctx); 4142 kfree(data); 4143 dprintk("%s: done!\n", __func__); 4144} 4145 4146static const struct rpc_call_ops nfs4_lock_ops = { 4147 .rpc_call_prepare = nfs4_lock_prepare, 4148 .rpc_call_done = nfs4_lock_done, 4149 .rpc_release = nfs4_lock_release, 4150}; 4151 4152static const struct rpc_call_ops nfs4_recover_lock_ops = { 4153 .rpc_call_prepare = nfs4_recover_lock_prepare, 4154 .rpc_call_done = nfs4_lock_done, 4155 .rpc_release = nfs4_lock_release, 4156}; 4157 4158static void nfs4_handle_setlk_error(struct nfs_server *server, struct nfs4_lock_state *lsp, int new_lock_owner, int error) 4159{ 4160 struct nfs_client *clp = server->nfs_client; 4161 struct nfs4_state *state = lsp->ls_state; 4162 4163 switch (error) { 4164 case -NFS4ERR_ADMIN_REVOKED: 4165 case -NFS4ERR_BAD_STATEID: 4166 case -NFS4ERR_EXPIRED: 4167 if (new_lock_owner != 0 || 4168 (lsp->ls_flags & NFS_LOCK_INITIALIZED) != 0) 4169 nfs4_state_mark_reclaim_nograce(clp, state); 4170 lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED; 4171 break; 4172 case -NFS4ERR_STALE_STATEID: 4173 if (new_lock_owner != 0 || 4174 (lsp->ls_flags & NFS_LOCK_INITIALIZED) != 0) 4175 nfs4_state_mark_reclaim_reboot(clp, state); 4176 lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED; 4177 }; 4178} 4179 4180static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *fl, int recovery_type) 4181{ 4182 struct nfs4_lockdata *data; 4183 struct rpc_task *task; 4184 struct rpc_message msg = { 4185 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCK], 4186 .rpc_cred = state->owner->so_cred, 4187 }; 4188 struct rpc_task_setup task_setup_data = { 4189 .rpc_client = NFS_CLIENT(state->inode), 4190 .rpc_message = &msg, 4191 .callback_ops = &nfs4_lock_ops, 4192 .workqueue = nfsiod_workqueue, 4193 .flags = RPC_TASK_ASYNC, 4194 }; 4195 int ret; 4196 4197 dprintk("%s: begin!\n", __func__); 4198 data = nfs4_alloc_lockdata(fl, nfs_file_open_context(fl->fl_file), 4199 fl->fl_u.nfs4_fl.owner, 4200 recovery_type == NFS_LOCK_NEW ? GFP_KERNEL : GFP_NOFS); 4201 if (data == NULL) 4202 return -ENOMEM; 4203 if (IS_SETLKW(cmd)) 4204 data->arg.block = 1; 4205 if (recovery_type > NFS_LOCK_NEW) { 4206 if (recovery_type == NFS_LOCK_RECLAIM) 4207 data->arg.reclaim = NFS_LOCK_RECLAIM; 4208 task_setup_data.callback_ops = &nfs4_recover_lock_ops; 4209 } 4210 msg.rpc_argp = &data->arg, 4211 msg.rpc_resp = &data->res, 4212 task_setup_data.callback_data = data; 4213 task = rpc_run_task(&task_setup_data); 4214 if (IS_ERR(task)) 4215 return PTR_ERR(task); 4216 ret = nfs4_wait_for_completion_rpc_task(task); 4217 if (ret == 0) { 4218 ret = data->rpc_status; 4219 if (ret) 4220 nfs4_handle_setlk_error(data->server, data->lsp, 4221 data->arg.new_lock_owner, ret); 4222 } else 4223 data->cancelled = 1; 4224 rpc_put_task(task); 4225 dprintk("%s: done, ret = %d!\n", __func__, ret); 4226 return ret; 4227} 4228 4229static int nfs4_lock_reclaim(struct nfs4_state *state, struct file_lock *request) 4230{ 4231 struct nfs_server *server = NFS_SERVER(state->inode); 4232 struct nfs4_exception exception = { }; 4233 int err; 4234 4235 do { 4236 /* Cache the lock if possible... */ 4237 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0) 4238 return 0; 4239 err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_RECLAIM); 4240 if (err != -NFS4ERR_DELAY && err != -EKEYEXPIRED) 4241 break; 4242 nfs4_handle_exception(server, err, &exception); 4243 } while (exception.retry); 4244 return err; 4245} 4246 4247static int nfs4_lock_expired(struct nfs4_state *state, struct file_lock *request) 4248{ 4249 struct nfs_server *server = NFS_SERVER(state->inode); 4250 struct nfs4_exception exception = { }; 4251 int err; 4252 4253 err = nfs4_set_lock_state(state, request); 4254 if (err != 0) 4255 return err; 4256 do { 4257 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0) 4258 return 0; 4259 err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_EXPIRED); 4260 switch (err) { 4261 default: 4262 goto out; 4263 case -NFS4ERR_GRACE: 4264 case -NFS4ERR_DELAY: 4265 case -EKEYEXPIRED: 4266 nfs4_handle_exception(server, err, &exception); 4267 err = 0; 4268 } 4269 } while (exception.retry); 4270out: 4271 return err; 4272} 4273 4274static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request) 4275{ 4276 struct nfs_inode *nfsi = NFS_I(state->inode); 4277 unsigned char fl_flags = request->fl_flags; 4278 int status = -ENOLCK; 4279 4280 if ((fl_flags & FL_POSIX) && 4281 !test_bit(NFS_STATE_POSIX_LOCKS, &state->flags)) 4282 goto out; 4283 /* Is this a delegated open? */ 4284 status = nfs4_set_lock_state(state, request); 4285 if (status != 0) 4286 goto out; 4287 request->fl_flags |= FL_ACCESS; 4288 status = do_vfs_lock(request->fl_file, request); 4289 if (status < 0) 4290 goto out; 4291 down_read(&nfsi->rwsem); 4292 if (test_bit(NFS_DELEGATED_STATE, &state->flags)) { 4293 /* Yes: cache locks! */ 4294 /* ...but avoid races with delegation recall... */ 4295 request->fl_flags = fl_flags & ~FL_SLEEP; 4296 status = do_vfs_lock(request->fl_file, request); 4297 goto out_unlock; 4298 } 4299 status = _nfs4_do_setlk(state, cmd, request, NFS_LOCK_NEW); 4300 if (status != 0) 4301 goto out_unlock; 4302 /* Note: we always want to sleep here! */ 4303 request->fl_flags = fl_flags | FL_SLEEP; 4304 if (do_vfs_lock(request->fl_file, request) < 0) 4305 printk(KERN_WARNING "%s: VFS is out of sync with lock manager!\n", __func__); 4306out_unlock: 4307 up_read(&nfsi->rwsem); 4308out: 4309 request->fl_flags = fl_flags; 4310 return status; 4311} 4312 4313static int nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request) 4314{ 4315 struct nfs4_exception exception = { }; 4316 int err; 4317 4318 do { 4319 err = _nfs4_proc_setlk(state, cmd, request); 4320 if (err == -NFS4ERR_DENIED) 4321 err = -EAGAIN; 4322 err = nfs4_handle_exception(NFS_SERVER(state->inode), 4323 err, &exception); 4324 } while (exception.retry); 4325 return err; 4326} 4327 4328static int 4329nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request) 4330{ 4331 struct nfs_open_context *ctx; 4332 struct nfs4_state *state; 4333 unsigned long timeout = NFS4_LOCK_MINTIMEOUT; 4334 int status; 4335 4336 /* verify open state */ 4337 ctx = nfs_file_open_context(filp); 4338 state = ctx->state; 4339 4340 if (request->fl_start < 0 || request->fl_end < 0) 4341 return -EINVAL; 4342 4343 if (IS_GETLK(cmd)) { 4344 if (state != NULL) 4345 return nfs4_proc_getlk(state, F_GETLK, request); 4346 return 0; 4347 } 4348 4349 if (!(IS_SETLK(cmd) || IS_SETLKW(cmd))) 4350 return -EINVAL; 4351 4352 if (request->fl_type == F_UNLCK) { 4353 if (state != NULL) 4354 return nfs4_proc_unlck(state, cmd, request); 4355 return 0; 4356 } 4357 4358 if (state == NULL) 4359 return -ENOLCK; 4360 do { 4361 status = nfs4_proc_setlk(state, cmd, request); 4362 if ((status != -EAGAIN) || IS_SETLK(cmd)) 4363 break; 4364 timeout = nfs4_set_lock_task_retry(timeout); 4365 status = -ERESTARTSYS; 4366 if (signalled()) 4367 break; 4368 } while(status < 0); 4369 return status; 4370} 4371 4372int nfs4_lock_delegation_recall(struct nfs4_state *state, struct file_lock *fl) 4373{ 4374 struct nfs_server *server = NFS_SERVER(state->inode); 4375 struct nfs4_exception exception = { }; 4376 int err; 4377 4378 err = nfs4_set_lock_state(state, fl); 4379 if (err != 0) 4380 goto out; 4381 do { 4382 err = _nfs4_do_setlk(state, F_SETLK, fl, NFS_LOCK_NEW); 4383 switch (err) { 4384 default: 4385 printk(KERN_ERR "%s: unhandled error %d.\n", 4386 __func__, err); 4387 case 0: 4388 case -ESTALE: 4389 goto out; 4390 case -NFS4ERR_EXPIRED: 4391 case -NFS4ERR_STALE_CLIENTID: 4392 case -NFS4ERR_STALE_STATEID: 4393 case -NFS4ERR_BADSESSION: 4394 case -NFS4ERR_BADSLOT: 4395 case -NFS4ERR_BAD_HIGH_SLOT: 4396 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 4397 case -NFS4ERR_DEADSESSION: 4398 nfs4_schedule_state_recovery(server->nfs_client); 4399 goto out; 4400 case -ERESTARTSYS: 4401 /* 4402 * The show must go on: exit, but mark the 4403 * stateid as needing recovery. 4404 */ 4405 case -NFS4ERR_ADMIN_REVOKED: 4406 case -NFS4ERR_BAD_STATEID: 4407 case -NFS4ERR_OPENMODE: 4408 nfs4_state_mark_reclaim_nograce(server->nfs_client, state); 4409 err = 0; 4410 goto out; 4411 case -ENOMEM: 4412 case -NFS4ERR_DENIED: 4413 /* kill_proc(fl->fl_pid, SIGLOST, 1); */ 4414 err = 0; 4415 goto out; 4416 case -NFS4ERR_DELAY: 4417 case -EKEYEXPIRED: 4418 break; 4419 } 4420 err = nfs4_handle_exception(server, err, &exception); 4421 } while (exception.retry); 4422out: 4423 return err; 4424} 4425 4426static void nfs4_release_lockowner_release(void *calldata) 4427{ 4428 kfree(calldata); 4429} 4430 4431const struct rpc_call_ops nfs4_release_lockowner_ops = { 4432 .rpc_release = nfs4_release_lockowner_release, 4433}; 4434 4435void nfs4_release_lockowner(const struct nfs4_lock_state *lsp) 4436{ 4437 struct nfs_server *server = lsp->ls_state->owner->so_server; 4438 struct nfs_release_lockowner_args *args; 4439 struct rpc_message msg = { 4440 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RELEASE_LOCKOWNER], 4441 }; 4442 4443 if (server->nfs_client->cl_mvops->minor_version != 0) 4444 return; 4445 args = kmalloc(sizeof(*args), GFP_NOFS); 4446 if (!args) 4447 return; 4448 args->lock_owner.clientid = server->nfs_client->cl_clientid; 4449 args->lock_owner.id = lsp->ls_id.id; 4450 msg.rpc_argp = args; 4451 rpc_call_async(server->client, &msg, 0, &nfs4_release_lockowner_ops, args); 4452} 4453 4454#define XATTR_NAME_NFSV4_ACL "system.nfs4_acl" 4455 4456int nfs4_setxattr(struct dentry *dentry, const char *key, const void *buf, 4457 size_t buflen, int flags) 4458{ 4459 struct inode *inode = dentry->d_inode; 4460 4461 if (strcmp(key, XATTR_NAME_NFSV4_ACL) != 0) 4462 return -EOPNOTSUPP; 4463 4464 return nfs4_proc_set_acl(inode, buf, buflen); 4465} 4466 4467/* The getxattr man page suggests returning -ENODATA for unknown attributes, 4468 * and that's what we'll do for e.g. user attributes that haven't been set. 4469 * But we'll follow ext2/ext3's lead by returning -EOPNOTSUPP for unsupported 4470 * attributes in kernel-managed attribute namespaces. */ 4471ssize_t nfs4_getxattr(struct dentry *dentry, const char *key, void *buf, 4472 size_t buflen) 4473{ 4474 struct inode *inode = dentry->d_inode; 4475 4476 if (strcmp(key, XATTR_NAME_NFSV4_ACL) != 0) 4477 return -EOPNOTSUPP; 4478 4479 return nfs4_proc_get_acl(inode, buf, buflen); 4480} 4481 4482ssize_t nfs4_listxattr(struct dentry *dentry, char *buf, size_t buflen) 4483{ 4484 size_t len = strlen(XATTR_NAME_NFSV4_ACL) + 1; 4485 4486 if (!nfs4_server_supports_acls(NFS_SERVER(dentry->d_inode))) 4487 return 0; 4488 if (buf && buflen < len) 4489 return -ERANGE; 4490 if (buf) 4491 memcpy(buf, XATTR_NAME_NFSV4_ACL, len); 4492 return len; 4493} 4494 4495static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr) 4496{ 4497 if (!((fattr->valid & NFS_ATTR_FATTR_FILEID) && 4498 (fattr->valid & NFS_ATTR_FATTR_FSID) && 4499 (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL))) 4500 return; 4501 4502 fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE | 4503 NFS_ATTR_FATTR_NLINK; 4504 fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO; 4505 fattr->nlink = 2; 4506} 4507 4508int nfs4_proc_fs_locations(struct inode *dir, const struct qstr *name, 4509 struct nfs4_fs_locations *fs_locations, struct page *page) 4510{ 4511 struct nfs_server *server = NFS_SERVER(dir); 4512 u32 bitmask[2] = { 4513 [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS, 4514 [1] = FATTR4_WORD1_MOUNTED_ON_FILEID, 4515 }; 4516 struct nfs4_fs_locations_arg args = { 4517 .dir_fh = NFS_FH(dir), 4518 .name = name, 4519 .page = page, 4520 .bitmask = bitmask, 4521 }; 4522 struct nfs4_fs_locations_res res = { 4523 .fs_locations = fs_locations, 4524 }; 4525 struct rpc_message msg = { 4526 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS], 4527 .rpc_argp = &args, 4528 .rpc_resp = &res, 4529 }; 4530 int status; 4531 4532 dprintk("%s: start\n", __func__); 4533 nfs_fattr_init(&fs_locations->fattr); 4534 fs_locations->server = server; 4535 fs_locations->nlocations = 0; 4536 status = nfs4_call_sync(server, &msg, &args, &res, 0); 4537 nfs_fixup_referral_attributes(&fs_locations->fattr); 4538 dprintk("%s: returned status = %d\n", __func__, status); 4539 return status; 4540} 4541 4542#ifdef CONFIG_NFS_V4_1 4543/* 4544 * nfs4_proc_exchange_id() 4545 * 4546 * Since the clientid has expired, all compounds using sessions 4547 * associated with the stale clientid will be returning 4548 * NFS4ERR_BADSESSION in the sequence operation, and will therefore 4549 * be in some phase of session reset. 4550 */ 4551int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred) 4552{ 4553 nfs4_verifier verifier; 4554 struct nfs41_exchange_id_args args = { 4555 .client = clp, 4556 .flags = clp->cl_exchange_flags, 4557 }; 4558 struct nfs41_exchange_id_res res = { 4559 .client = clp, 4560 }; 4561 int status; 4562 struct rpc_message msg = { 4563 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_EXCHANGE_ID], 4564 .rpc_argp = &args, 4565 .rpc_resp = &res, 4566 .rpc_cred = cred, 4567 }; 4568 __be32 *p; 4569 4570 dprintk("--> %s\n", __func__); 4571 BUG_ON(clp == NULL); 4572 4573 /* Remove server-only flags */ 4574 args.flags &= ~EXCHGID4_FLAG_CONFIRMED_R; 4575 4576 p = (u32 *)verifier.data; 4577 *p++ = htonl((u32)clp->cl_boot_time.tv_sec); 4578 *p = htonl((u32)clp->cl_boot_time.tv_nsec); 4579 args.verifier = &verifier; 4580 4581 while (1) { 4582 args.id_len = scnprintf(args.id, sizeof(args.id), 4583 "%s/%s %u", 4584 clp->cl_ipaddr, 4585 rpc_peeraddr2str(clp->cl_rpcclient, 4586 RPC_DISPLAY_ADDR), 4587 clp->cl_id_uniquifier); 4588 4589 status = rpc_call_sync(clp->cl_rpcclient, &msg, 0); 4590 4591 if (status != -NFS4ERR_CLID_INUSE) 4592 break; 4593 4594 if (signalled()) 4595 break; 4596 4597 if (++clp->cl_id_uniquifier == 0) 4598 break; 4599 } 4600 4601 dprintk("<-- %s status= %d\n", __func__, status); 4602 return status; 4603} 4604 4605struct nfs4_get_lease_time_data { 4606 struct nfs4_get_lease_time_args *args; 4607 struct nfs4_get_lease_time_res *res; 4608 struct nfs_client *clp; 4609}; 4610 4611static void nfs4_get_lease_time_prepare(struct rpc_task *task, 4612 void *calldata) 4613{ 4614 int ret; 4615 struct nfs4_get_lease_time_data *data = 4616 (struct nfs4_get_lease_time_data *)calldata; 4617 4618 dprintk("--> %s\n", __func__); 4619 rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED); 4620 /* just setup sequence, do not trigger session recovery 4621 since we're invoked within one */ 4622 ret = nfs41_setup_sequence(data->clp->cl_session, 4623 &data->args->la_seq_args, 4624 &data->res->lr_seq_res, 0, task); 4625 4626 BUG_ON(ret == -EAGAIN); 4627 rpc_call_start(task); 4628 dprintk("<-- %s\n", __func__); 4629} 4630 4631/* 4632 * Called from nfs4_state_manager thread for session setup, so don't recover 4633 * from sequence operation or clientid errors. 4634 */ 4635static void nfs4_get_lease_time_done(struct rpc_task *task, void *calldata) 4636{ 4637 struct nfs4_get_lease_time_data *data = 4638 (struct nfs4_get_lease_time_data *)calldata; 4639 4640 dprintk("--> %s\n", __func__); 4641 if (!nfs41_sequence_done(task, &data->res->lr_seq_res)) 4642 return; 4643 switch (task->tk_status) { 4644 case -NFS4ERR_DELAY: 4645 case -NFS4ERR_GRACE: 4646 case -EKEYEXPIRED: 4647 dprintk("%s Retry: tk_status %d\n", __func__, task->tk_status); 4648 rpc_delay(task, NFS4_POLL_RETRY_MIN); 4649 task->tk_status = 0; 4650 nfs_restart_rpc(task, data->clp); 4651 return; 4652 } 4653 dprintk("<-- %s\n", __func__); 4654} 4655 4656struct rpc_call_ops nfs4_get_lease_time_ops = { 4657 .rpc_call_prepare = nfs4_get_lease_time_prepare, 4658 .rpc_call_done = nfs4_get_lease_time_done, 4659}; 4660 4661int nfs4_proc_get_lease_time(struct nfs_client *clp, struct nfs_fsinfo *fsinfo) 4662{ 4663 struct rpc_task *task; 4664 struct nfs4_get_lease_time_args args; 4665 struct nfs4_get_lease_time_res res = { 4666 .lr_fsinfo = fsinfo, 4667 }; 4668 struct nfs4_get_lease_time_data data = { 4669 .args = &args, 4670 .res = &res, 4671 .clp = clp, 4672 }; 4673 struct rpc_message msg = { 4674 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GET_LEASE_TIME], 4675 .rpc_argp = &args, 4676 .rpc_resp = &res, 4677 }; 4678 struct rpc_task_setup task_setup = { 4679 .rpc_client = clp->cl_rpcclient, 4680 .rpc_message = &msg, 4681 .callback_ops = &nfs4_get_lease_time_ops, 4682 .callback_data = &data 4683 }; 4684 int status; 4685 4686 res.lr_seq_res.sr_slotid = NFS4_MAX_SLOT_TABLE; 4687 dprintk("--> %s\n", __func__); 4688 task = rpc_run_task(&task_setup); 4689 4690 if (IS_ERR(task)) 4691 status = PTR_ERR(task); 4692 else { 4693 status = task->tk_status; 4694 rpc_put_task(task); 4695 } 4696 dprintk("<-- %s return %d\n", __func__, status); 4697 4698 return status; 4699} 4700 4701/* 4702 * Reset a slot table 4703 */ 4704static int nfs4_reset_slot_table(struct nfs4_slot_table *tbl, u32 max_reqs, 4705 int ivalue) 4706{ 4707 struct nfs4_slot *new = NULL; 4708 int i; 4709 int ret = 0; 4710 4711 dprintk("--> %s: max_reqs=%u, tbl->max_slots %d\n", __func__, 4712 max_reqs, tbl->max_slots); 4713 4714 /* Does the newly negotiated max_reqs match the existing slot table? */ 4715 if (max_reqs != tbl->max_slots) { 4716 ret = -ENOMEM; 4717 new = kmalloc(max_reqs * sizeof(struct nfs4_slot), 4718 GFP_NOFS); 4719 if (!new) 4720 goto out; 4721 ret = 0; 4722 kfree(tbl->slots); 4723 } 4724 spin_lock(&tbl->slot_tbl_lock); 4725 if (new) { 4726 tbl->slots = new; 4727 tbl->max_slots = max_reqs; 4728 } 4729 for (i = 0; i < tbl->max_slots; ++i) 4730 tbl->slots[i].seq_nr = ivalue; 4731 spin_unlock(&tbl->slot_tbl_lock); 4732 dprintk("%s: tbl=%p slots=%p max_slots=%d\n", __func__, 4733 tbl, tbl->slots, tbl->max_slots); 4734out: 4735 dprintk("<-- %s: return %d\n", __func__, ret); 4736 return ret; 4737} 4738 4739/* 4740 * Reset the forechannel and backchannel slot tables 4741 */ 4742static int nfs4_reset_slot_tables(struct nfs4_session *session) 4743{ 4744 int status; 4745 4746 status = nfs4_reset_slot_table(&session->fc_slot_table, 4747 session->fc_attrs.max_reqs, 1); 4748 if (status) 4749 return status; 4750 4751 status = nfs4_reset_slot_table(&session->bc_slot_table, 4752 session->bc_attrs.max_reqs, 0); 4753 return status; 4754} 4755 4756/* Destroy the slot table */ 4757static void nfs4_destroy_slot_tables(struct nfs4_session *session) 4758{ 4759 if (session->fc_slot_table.slots != NULL) { 4760 kfree(session->fc_slot_table.slots); 4761 session->fc_slot_table.slots = NULL; 4762 } 4763 if (session->bc_slot_table.slots != NULL) { 4764 kfree(session->bc_slot_table.slots); 4765 session->bc_slot_table.slots = NULL; 4766 } 4767 return; 4768} 4769 4770/* 4771 * Initialize slot table 4772 */ 4773static int nfs4_init_slot_table(struct nfs4_slot_table *tbl, 4774 int max_slots, int ivalue) 4775{ 4776 struct nfs4_slot *slot; 4777 int ret = -ENOMEM; 4778 4779 BUG_ON(max_slots > NFS4_MAX_SLOT_TABLE); 4780 4781 dprintk("--> %s: max_reqs=%u\n", __func__, max_slots); 4782 4783 slot = kcalloc(max_slots, sizeof(struct nfs4_slot), GFP_NOFS); 4784 if (!slot) 4785 goto out; 4786 ret = 0; 4787 4788 spin_lock(&tbl->slot_tbl_lock); 4789 tbl->max_slots = max_slots; 4790 tbl->slots = slot; 4791 tbl->highest_used_slotid = -1; /* no slot is currently used */ 4792 spin_unlock(&tbl->slot_tbl_lock); 4793 dprintk("%s: tbl=%p slots=%p max_slots=%d\n", __func__, 4794 tbl, tbl->slots, tbl->max_slots); 4795out: 4796 dprintk("<-- %s: return %d\n", __func__, ret); 4797 return ret; 4798} 4799 4800/* 4801 * Initialize the forechannel and backchannel tables 4802 */ 4803static int nfs4_init_slot_tables(struct nfs4_session *session) 4804{ 4805 struct nfs4_slot_table *tbl; 4806 int status = 0; 4807 4808 tbl = &session->fc_slot_table; 4809 if (tbl->slots == NULL) { 4810 status = nfs4_init_slot_table(tbl, 4811 session->fc_attrs.max_reqs, 1); 4812 if (status) 4813 return status; 4814 } 4815 4816 tbl = &session->bc_slot_table; 4817 if (tbl->slots == NULL) { 4818 status = nfs4_init_slot_table(tbl, 4819 session->bc_attrs.max_reqs, 0); 4820 if (status) 4821 nfs4_destroy_slot_tables(session); 4822 } 4823 4824 return status; 4825} 4826 4827struct nfs4_session *nfs4_alloc_session(struct nfs_client *clp) 4828{ 4829 struct nfs4_session *session; 4830 struct nfs4_slot_table *tbl; 4831 4832 session = kzalloc(sizeof(struct nfs4_session), GFP_NOFS); 4833 if (!session) 4834 return NULL; 4835 4836 init_completion(&session->complete); 4837 4838 tbl = &session->fc_slot_table; 4839 tbl->highest_used_slotid = -1; 4840 spin_lock_init(&tbl->slot_tbl_lock); 4841 rpc_init_priority_wait_queue(&tbl->slot_tbl_waitq, "ForeChannel Slot table"); 4842 4843 tbl = &session->bc_slot_table; 4844 tbl->highest_used_slotid = -1; 4845 spin_lock_init(&tbl->slot_tbl_lock); 4846 rpc_init_wait_queue(&tbl->slot_tbl_waitq, "BackChannel Slot table"); 4847 4848 session->session_state = 1<<NFS4_SESSION_INITING; 4849 4850 session->clp = clp; 4851 return session; 4852} 4853 4854void nfs4_destroy_session(struct nfs4_session *session) 4855{ 4856 nfs4_proc_destroy_session(session); 4857 dprintk("%s Destroy backchannel for xprt %p\n", 4858 __func__, session->clp->cl_rpcclient->cl_xprt); 4859 xprt_destroy_backchannel(session->clp->cl_rpcclient->cl_xprt, 4860 NFS41_BC_MIN_CALLBACKS); 4861 nfs4_destroy_slot_tables(session); 4862 kfree(session); 4863} 4864 4865/* 4866 * Initialize the values to be used by the client in CREATE_SESSION 4867 * If nfs4_init_session set the fore channel request and response sizes, 4868 * use them. 4869 * 4870 * Set the back channel max_resp_sz_cached to zero to force the client to 4871 * always set csa_cachethis to FALSE because the current implementation 4872 * of the back channel DRC only supports caching the CB_SEQUENCE operation. 4873 */ 4874static void nfs4_init_channel_attrs(struct nfs41_create_session_args *args) 4875{ 4876 struct nfs4_session *session = args->client->cl_session; 4877 unsigned int mxrqst_sz = session->fc_attrs.max_rqst_sz, 4878 mxresp_sz = session->fc_attrs.max_resp_sz; 4879 4880 if (mxrqst_sz == 0) 4881 mxrqst_sz = NFS_MAX_FILE_IO_SIZE; 4882 if (mxresp_sz == 0) 4883 mxresp_sz = NFS_MAX_FILE_IO_SIZE; 4884 /* Fore channel attributes */ 4885 args->fc_attrs.headerpadsz = 0; 4886 args->fc_attrs.max_rqst_sz = mxrqst_sz; 4887 args->fc_attrs.max_resp_sz = mxresp_sz; 4888 args->fc_attrs.max_ops = NFS4_MAX_OPS; 4889 args->fc_attrs.max_reqs = session->clp->cl_rpcclient->cl_xprt->max_reqs; 4890 4891 dprintk("%s: Fore Channel : max_rqst_sz=%u max_resp_sz=%u " 4892 "max_ops=%u max_reqs=%u\n", 4893 __func__, 4894 args->fc_attrs.max_rqst_sz, args->fc_attrs.max_resp_sz, 4895 args->fc_attrs.max_ops, args->fc_attrs.max_reqs); 4896 4897 /* Back channel attributes */ 4898 args->bc_attrs.headerpadsz = 0; 4899 args->bc_attrs.max_rqst_sz = PAGE_SIZE; 4900 args->bc_attrs.max_resp_sz = PAGE_SIZE; 4901 args->bc_attrs.max_resp_sz_cached = 0; 4902 args->bc_attrs.max_ops = NFS4_MAX_BACK_CHANNEL_OPS; 4903 args->bc_attrs.max_reqs = 1; 4904 4905 dprintk("%s: Back Channel : max_rqst_sz=%u max_resp_sz=%u " 4906 "max_resp_sz_cached=%u max_ops=%u max_reqs=%u\n", 4907 __func__, 4908 args->bc_attrs.max_rqst_sz, args->bc_attrs.max_resp_sz, 4909 args->bc_attrs.max_resp_sz_cached, args->bc_attrs.max_ops, 4910 args->bc_attrs.max_reqs); 4911} 4912 4913static int _verify_channel_attr(char *chan, char *attr_name, u32 sent, u32 rcvd) 4914{ 4915 if (rcvd <= sent) 4916 return 0; 4917 printk(KERN_WARNING "%s: Session INVALID: %s channel %s increased. " 4918 "sent=%u rcvd=%u\n", __func__, chan, attr_name, sent, rcvd); 4919 return -EINVAL; 4920} 4921 4922#define _verify_fore_channel_attr(_name_) \ 4923 _verify_channel_attr("fore", #_name_, \ 4924 args->fc_attrs._name_, \ 4925 session->fc_attrs._name_) 4926 4927#define _verify_back_channel_attr(_name_) \ 4928 _verify_channel_attr("back", #_name_, \ 4929 args->bc_attrs._name_, \ 4930 session->bc_attrs._name_) 4931 4932/* 4933 * The server is not allowed to increase the fore channel header pad size, 4934 * maximum response size, or maximum number of operations. 4935 * 4936 * The back channel attributes are only negotiatied down: We send what the 4937 * (back channel) server insists upon. 4938 */ 4939static int nfs4_verify_channel_attrs(struct nfs41_create_session_args *args, 4940 struct nfs4_session *session) 4941{ 4942 int ret = 0; 4943 4944 ret |= _verify_fore_channel_attr(headerpadsz); 4945 ret |= _verify_fore_channel_attr(max_resp_sz); 4946 ret |= _verify_fore_channel_attr(max_ops); 4947 4948 ret |= _verify_back_channel_attr(headerpadsz); 4949 ret |= _verify_back_channel_attr(max_rqst_sz); 4950 ret |= _verify_back_channel_attr(max_resp_sz); 4951 ret |= _verify_back_channel_attr(max_resp_sz_cached); 4952 ret |= _verify_back_channel_attr(max_ops); 4953 ret |= _verify_back_channel_attr(max_reqs); 4954 4955 return ret; 4956} 4957 4958static int _nfs4_proc_create_session(struct nfs_client *clp) 4959{ 4960 struct nfs4_session *session = clp->cl_session; 4961 struct nfs41_create_session_args args = { 4962 .client = clp, 4963 .cb_program = NFS4_CALLBACK, 4964 }; 4965 struct nfs41_create_session_res res = { 4966 .client = clp, 4967 }; 4968 struct rpc_message msg = { 4969 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE_SESSION], 4970 .rpc_argp = &args, 4971 .rpc_resp = &res, 4972 }; 4973 int status; 4974 4975 nfs4_init_channel_attrs(&args); 4976 args.flags = (SESSION4_PERSIST | SESSION4_BACK_CHAN); 4977 4978 status = rpc_call_sync(session->clp->cl_rpcclient, &msg, 0); 4979 4980 if (!status) 4981 /* Verify the session's negotiated channel_attrs values */ 4982 status = nfs4_verify_channel_attrs(&args, session); 4983 if (!status) { 4984 /* Increment the clientid slot sequence id */ 4985 clp->cl_seqid++; 4986 } 4987 4988 return status; 4989} 4990 4991/* 4992 * Issues a CREATE_SESSION operation to the server. 4993 * It is the responsibility of the caller to verify the session is 4994 * expired before calling this routine. 4995 */ 4996int nfs4_proc_create_session(struct nfs_client *clp) 4997{ 4998 int status; 4999 unsigned *ptr; 5000 struct nfs4_session *session = clp->cl_session; 5001 5002 dprintk("--> %s clp=%p session=%p\n", __func__, clp, session); 5003 5004 status = _nfs4_proc_create_session(clp); 5005 if (status) 5006 goto out; 5007 5008 /* Init and reset the fore channel */ 5009 status = nfs4_init_slot_tables(session); 5010 dprintk("slot table initialization returned %d\n", status); 5011 if (status) 5012 goto out; 5013 status = nfs4_reset_slot_tables(session); 5014 dprintk("slot table reset returned %d\n", status); 5015 if (status) 5016 goto out; 5017 5018 ptr = (unsigned *)&session->sess_id.data[0]; 5019 dprintk("%s client>seqid %d sessionid %u:%u:%u:%u\n", __func__, 5020 clp->cl_seqid, ptr[0], ptr[1], ptr[2], ptr[3]); 5021out: 5022 dprintk("<-- %s\n", __func__); 5023 return status; 5024} 5025 5026/* 5027 * Issue the over-the-wire RPC DESTROY_SESSION. 5028 * The caller must serialize access to this routine. 5029 */ 5030int nfs4_proc_destroy_session(struct nfs4_session *session) 5031{ 5032 int status = 0; 5033 struct rpc_message msg; 5034 5035 dprintk("--> nfs4_proc_destroy_session\n"); 5036 5037 /* session is still being setup */ 5038 if (session->clp->cl_cons_state != NFS_CS_READY) 5039 return status; 5040 5041 msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_SESSION]; 5042 msg.rpc_argp = session; 5043 msg.rpc_resp = NULL; 5044 msg.rpc_cred = NULL; 5045 status = rpc_call_sync(session->clp->cl_rpcclient, &msg, 0); 5046 5047 if (status) 5048 printk(KERN_WARNING 5049 "Got error %d from the server on DESTROY_SESSION. " 5050 "Session has been destroyed regardless...\n", status); 5051 5052 dprintk("<-- nfs4_proc_destroy_session\n"); 5053 return status; 5054} 5055 5056int nfs4_init_session(struct nfs_server *server) 5057{ 5058 struct nfs_client *clp = server->nfs_client; 5059 struct nfs4_session *session; 5060 unsigned int rsize, wsize; 5061 int ret; 5062 5063 if (!nfs4_has_session(clp)) 5064 return 0; 5065 5066 session = clp->cl_session; 5067 if (!test_and_clear_bit(NFS4_SESSION_INITING, &session->session_state)) 5068 return 0; 5069 5070 rsize = server->rsize; 5071 if (rsize == 0) 5072 rsize = NFS_MAX_FILE_IO_SIZE; 5073 wsize = server->wsize; 5074 if (wsize == 0) 5075 wsize = NFS_MAX_FILE_IO_SIZE; 5076 5077 session->fc_attrs.max_rqst_sz = wsize + nfs41_maxwrite_overhead; 5078 session->fc_attrs.max_resp_sz = rsize + nfs41_maxread_overhead; 5079 5080 ret = nfs4_recover_expired_lease(server); 5081 if (!ret) 5082 ret = nfs4_check_client_ready(clp); 5083 return ret; 5084} 5085 5086/* 5087 * Renew the cl_session lease. 5088 */ 5089struct nfs4_sequence_data { 5090 struct nfs_client *clp; 5091 struct nfs4_sequence_args args; 5092 struct nfs4_sequence_res res; 5093}; 5094 5095static void nfs41_sequence_release(void *data) 5096{ 5097 struct nfs4_sequence_data *calldata = data; 5098 struct nfs_client *clp = calldata->clp; 5099 5100 if (atomic_read(&clp->cl_count) > 1) 5101 nfs4_schedule_state_renewal(clp); 5102 nfs_put_client(clp); 5103 kfree(calldata); 5104} 5105 5106static int nfs41_sequence_handle_errors(struct rpc_task *task, struct nfs_client *clp) 5107{ 5108 switch(task->tk_status) { 5109 case -NFS4ERR_DELAY: 5110 case -EKEYEXPIRED: 5111 rpc_delay(task, NFS4_POLL_RETRY_MAX); 5112 return -EAGAIN; 5113 default: 5114 nfs4_schedule_state_recovery(clp); 5115 } 5116 return 0; 5117} 5118 5119static void nfs41_sequence_call_done(struct rpc_task *task, void *data) 5120{ 5121 struct nfs4_sequence_data *calldata = data; 5122 struct nfs_client *clp = calldata->clp; 5123 5124 if (!nfs41_sequence_done(task, task->tk_msg.rpc_resp)) 5125 return; 5126 5127 if (task->tk_status < 0) { 5128 dprintk("%s ERROR %d\n", __func__, task->tk_status); 5129 if (atomic_read(&clp->cl_count) == 1) 5130 goto out; 5131 5132 if (nfs41_sequence_handle_errors(task, clp) == -EAGAIN) { 5133 rpc_restart_call_prepare(task); 5134 return; 5135 } 5136 } 5137 dprintk("%s rpc_cred %p\n", __func__, task->tk_msg.rpc_cred); 5138out: 5139 dprintk("<-- %s\n", __func__); 5140} 5141 5142static void nfs41_sequence_prepare(struct rpc_task *task, void *data) 5143{ 5144 struct nfs4_sequence_data *calldata = data; 5145 struct nfs_client *clp = calldata->clp; 5146 struct nfs4_sequence_args *args; 5147 struct nfs4_sequence_res *res; 5148 5149 args = task->tk_msg.rpc_argp; 5150 res = task->tk_msg.rpc_resp; 5151 5152 if (nfs41_setup_sequence(clp->cl_session, args, res, 0, task)) 5153 return; 5154 rpc_call_start(task); 5155} 5156 5157static const struct rpc_call_ops nfs41_sequence_ops = { 5158 .rpc_call_done = nfs41_sequence_call_done, 5159 .rpc_call_prepare = nfs41_sequence_prepare, 5160 .rpc_release = nfs41_sequence_release, 5161}; 5162 5163static struct rpc_task *_nfs41_proc_sequence(struct nfs_client *clp, struct rpc_cred *cred) 5164{ 5165 struct nfs4_sequence_data *calldata; 5166 struct rpc_message msg = { 5167 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SEQUENCE], 5168 .rpc_cred = cred, 5169 }; 5170 struct rpc_task_setup task_setup_data = { 5171 .rpc_client = clp->cl_rpcclient, 5172 .rpc_message = &msg, 5173 .callback_ops = &nfs41_sequence_ops, 5174 .flags = RPC_TASK_ASYNC | RPC_TASK_SOFT, 5175 }; 5176 5177 if (!atomic_inc_not_zero(&clp->cl_count)) 5178 return ERR_PTR(-EIO); 5179 calldata = kmalloc(sizeof(*calldata), GFP_NOFS); 5180 if (calldata == NULL) { 5181 nfs_put_client(clp); 5182 return ERR_PTR(-ENOMEM); 5183 } 5184 calldata->res.sr_slotid = NFS4_MAX_SLOT_TABLE; 5185 msg.rpc_argp = &calldata->args; 5186 msg.rpc_resp = &calldata->res; 5187 calldata->clp = clp; 5188 task_setup_data.callback_data = calldata; 5189 5190 return rpc_run_task(&task_setup_data); 5191} 5192 5193static int nfs41_proc_async_sequence(struct nfs_client *clp, struct rpc_cred *cred) 5194{ 5195 struct rpc_task *task; 5196 int ret = 0; 5197 5198 task = _nfs41_proc_sequence(clp, cred); 5199 if (IS_ERR(task)) 5200 ret = PTR_ERR(task); 5201 else 5202 rpc_put_task(task); 5203 dprintk("<-- %s status=%d\n", __func__, ret); 5204 return ret; 5205} 5206 5207static int nfs4_proc_sequence(struct nfs_client *clp, struct rpc_cred *cred) 5208{ 5209 struct rpc_task *task; 5210 int ret; 5211 5212 task = _nfs41_proc_sequence(clp, cred); 5213 if (IS_ERR(task)) { 5214 ret = PTR_ERR(task); 5215 goto out; 5216 } 5217 ret = rpc_wait_for_completion_task(task); 5218 if (!ret) 5219 ret = task->tk_status; 5220 rpc_put_task(task); 5221out: 5222 dprintk("<-- %s status=%d\n", __func__, ret); 5223 return ret; 5224} 5225 5226struct nfs4_reclaim_complete_data { 5227 struct nfs_client *clp; 5228 struct nfs41_reclaim_complete_args arg; 5229 struct nfs41_reclaim_complete_res res; 5230}; 5231 5232static void nfs4_reclaim_complete_prepare(struct rpc_task *task, void *data) 5233{ 5234 struct nfs4_reclaim_complete_data *calldata = data; 5235 5236 rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED); 5237 if (nfs41_setup_sequence(calldata->clp->cl_session, 5238 &calldata->arg.seq_args, 5239 &calldata->res.seq_res, 0, task)) 5240 return; 5241 5242 rpc_call_start(task); 5243} 5244 5245static int nfs41_reclaim_complete_handle_errors(struct rpc_task *task, struct nfs_client *clp) 5246{ 5247 switch(task->tk_status) { 5248 case 0: 5249 case -NFS4ERR_COMPLETE_ALREADY: 5250 case -NFS4ERR_WRONG_CRED: /* What to do here? */ 5251 break; 5252 case -NFS4ERR_DELAY: 5253 case -EKEYEXPIRED: 5254 rpc_delay(task, NFS4_POLL_RETRY_MAX); 5255 return -EAGAIN; 5256 default: 5257 nfs4_schedule_state_recovery(clp); 5258 } 5259 return 0; 5260} 5261 5262static void nfs4_reclaim_complete_done(struct rpc_task *task, void *data) 5263{ 5264 struct nfs4_reclaim_complete_data *calldata = data; 5265 struct nfs_client *clp = calldata->clp; 5266 struct nfs4_sequence_res *res = &calldata->res.seq_res; 5267 5268 dprintk("--> %s\n", __func__); 5269 if (!nfs41_sequence_done(task, res)) 5270 return; 5271 5272 if (nfs41_reclaim_complete_handle_errors(task, clp) == -EAGAIN) { 5273 rpc_restart_call_prepare(task); 5274 return; 5275 } 5276 dprintk("<-- %s\n", __func__); 5277} 5278 5279static void nfs4_free_reclaim_complete_data(void *data) 5280{ 5281 struct nfs4_reclaim_complete_data *calldata = data; 5282 5283 kfree(calldata); 5284} 5285 5286static const struct rpc_call_ops nfs4_reclaim_complete_call_ops = { 5287 .rpc_call_prepare = nfs4_reclaim_complete_prepare, 5288 .rpc_call_done = nfs4_reclaim_complete_done, 5289 .rpc_release = nfs4_free_reclaim_complete_data, 5290}; 5291 5292/* 5293 * Issue a global reclaim complete. 5294 */ 5295static int nfs41_proc_reclaim_complete(struct nfs_client *clp) 5296{ 5297 struct nfs4_reclaim_complete_data *calldata; 5298 struct rpc_task *task; 5299 struct rpc_message msg = { 5300 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RECLAIM_COMPLETE], 5301 }; 5302 struct rpc_task_setup task_setup_data = { 5303 .rpc_client = clp->cl_rpcclient, 5304 .rpc_message = &msg, 5305 .callback_ops = &nfs4_reclaim_complete_call_ops, 5306 .flags = RPC_TASK_ASYNC, 5307 }; 5308 int status = -ENOMEM; 5309 5310 dprintk("--> %s\n", __func__); 5311 calldata = kzalloc(sizeof(*calldata), GFP_NOFS); 5312 if (calldata == NULL) 5313 goto out; 5314 calldata->clp = clp; 5315 calldata->arg.one_fs = 0; 5316 calldata->res.seq_res.sr_slotid = NFS4_MAX_SLOT_TABLE; 5317 5318 msg.rpc_argp = &calldata->arg; 5319 msg.rpc_resp = &calldata->res; 5320 task_setup_data.callback_data = calldata; 5321 task = rpc_run_task(&task_setup_data); 5322 if (IS_ERR(task)) { 5323 status = PTR_ERR(task); 5324 goto out; 5325 } 5326 rpc_put_task(task); 5327 return 0; 5328out: 5329 dprintk("<-- %s status=%d\n", __func__, status); 5330 return status; 5331} 5332#endif /* CONFIG_NFS_V4_1 */ 5333 5334struct nfs4_state_recovery_ops nfs40_reboot_recovery_ops = { 5335 .owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT, 5336 .state_flag_bit = NFS_STATE_RECLAIM_REBOOT, 5337 .recover_open = nfs4_open_reclaim, 5338 .recover_lock = nfs4_lock_reclaim, 5339 .establish_clid = nfs4_init_clientid, 5340 .get_clid_cred = nfs4_get_setclientid_cred, 5341}; 5342 5343#if defined(CONFIG_NFS_V4_1) 5344struct nfs4_state_recovery_ops nfs41_reboot_recovery_ops = { 5345 .owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT, 5346 .state_flag_bit = NFS_STATE_RECLAIM_REBOOT, 5347 .recover_open = nfs4_open_reclaim, 5348 .recover_lock = nfs4_lock_reclaim, 5349 .establish_clid = nfs41_init_clientid, 5350 .get_clid_cred = nfs4_get_exchange_id_cred, 5351 .reclaim_complete = nfs41_proc_reclaim_complete, 5352}; 5353#endif /* CONFIG_NFS_V4_1 */ 5354 5355struct nfs4_state_recovery_ops nfs40_nograce_recovery_ops = { 5356 .owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE, 5357 .state_flag_bit = NFS_STATE_RECLAIM_NOGRACE, 5358 .recover_open = nfs4_open_expired, 5359 .recover_lock = nfs4_lock_expired, 5360 .establish_clid = nfs4_init_clientid, 5361 .get_clid_cred = nfs4_get_setclientid_cred, 5362}; 5363 5364#if defined(CONFIG_NFS_V4_1) 5365struct nfs4_state_recovery_ops nfs41_nograce_recovery_ops = { 5366 .owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE, 5367 .state_flag_bit = NFS_STATE_RECLAIM_NOGRACE, 5368 .recover_open = nfs4_open_expired, 5369 .recover_lock = nfs4_lock_expired, 5370 .establish_clid = nfs41_init_clientid, 5371 .get_clid_cred = nfs4_get_exchange_id_cred, 5372}; 5373#endif /* CONFIG_NFS_V4_1 */ 5374 5375struct nfs4_state_maintenance_ops nfs40_state_renewal_ops = { 5376 .sched_state_renewal = nfs4_proc_async_renew, 5377 .get_state_renewal_cred_locked = nfs4_get_renew_cred_locked, 5378 .renew_lease = nfs4_proc_renew, 5379}; 5380 5381#if defined(CONFIG_NFS_V4_1) 5382struct nfs4_state_maintenance_ops nfs41_state_renewal_ops = { 5383 .sched_state_renewal = nfs41_proc_async_sequence, 5384 .get_state_renewal_cred_locked = nfs4_get_machine_cred_locked, 5385 .renew_lease = nfs4_proc_sequence, 5386}; 5387#endif 5388 5389static const struct nfs4_minor_version_ops nfs_v4_0_minor_ops = { 5390 .minor_version = 0, 5391 .call_sync = _nfs4_call_sync, 5392 .validate_stateid = nfs4_validate_delegation_stateid, 5393 .reboot_recovery_ops = &nfs40_reboot_recovery_ops, 5394 .nograce_recovery_ops = &nfs40_nograce_recovery_ops, 5395 .state_renewal_ops = &nfs40_state_renewal_ops, 5396}; 5397 5398#if defined(CONFIG_NFS_V4_1) 5399static const struct nfs4_minor_version_ops nfs_v4_1_minor_ops = { 5400 .minor_version = 1, 5401 .call_sync = _nfs4_call_sync_session, 5402 .validate_stateid = nfs41_validate_delegation_stateid, 5403 .reboot_recovery_ops = &nfs41_reboot_recovery_ops, 5404 .nograce_recovery_ops = &nfs41_nograce_recovery_ops, 5405 .state_renewal_ops = &nfs41_state_renewal_ops, 5406}; 5407#endif 5408 5409const struct nfs4_minor_version_ops *nfs_v4_minor_ops[] = { 5410 [0] = &nfs_v4_0_minor_ops, 5411#if defined(CONFIG_NFS_V4_1) 5412 [1] = &nfs_v4_1_minor_ops, 5413#endif 5414}; 5415 5416static const struct inode_operations nfs4_file_inode_operations = { 5417 .permission = nfs_permission, 5418 .getattr = nfs_getattr, 5419 .setattr = nfs_setattr, 5420 .getxattr = nfs4_getxattr, 5421 .setxattr = nfs4_setxattr, 5422 .listxattr = nfs4_listxattr, 5423}; 5424 5425const struct nfs_rpc_ops nfs_v4_clientops = { 5426 .version = 4, /* protocol version */ 5427 .dentry_ops = &nfs4_dentry_operations, 5428 .dir_inode_ops = &nfs4_dir_inode_operations, 5429 .file_inode_ops = &nfs4_file_inode_operations, 5430 .getroot = nfs4_proc_get_root, 5431 .getattr = nfs4_proc_getattr, 5432 .setattr = nfs4_proc_setattr, 5433 .lookupfh = nfs4_proc_lookupfh, 5434 .lookup = nfs4_proc_lookup, 5435 .access = nfs4_proc_access, 5436 .readlink = nfs4_proc_readlink, 5437 .create = nfs4_proc_create, 5438 .remove = nfs4_proc_remove, 5439 .unlink_setup = nfs4_proc_unlink_setup, 5440 .unlink_done = nfs4_proc_unlink_done, 5441 .rename = nfs4_proc_rename, 5442 .link = nfs4_proc_link, 5443 .symlink = nfs4_proc_symlink, 5444 .mkdir = nfs4_proc_mkdir, 5445 .rmdir = nfs4_proc_remove, 5446 .readdir = nfs4_proc_readdir, 5447 .mknod = nfs4_proc_mknod, 5448 .statfs = nfs4_proc_statfs, 5449 .fsinfo = nfs4_proc_fsinfo, 5450 .pathconf = nfs4_proc_pathconf, 5451 .set_capabilities = nfs4_server_capabilities, 5452 .decode_dirent = nfs4_decode_dirent, 5453 .read_setup = nfs4_proc_read_setup, 5454 .read_done = nfs4_read_done, 5455 .write_setup = nfs4_proc_write_setup, 5456 .write_done = nfs4_write_done, 5457 .commit_setup = nfs4_proc_commit_setup, 5458 .commit_done = nfs4_commit_done, 5459 .lock = nfs4_proc_lock, 5460 .clear_acl_cache = nfs4_zap_acl_attr, 5461 .close_context = nfs4_close_context, 5462}; 5463 5464/* 5465 * Local variables: 5466 * c-basic-offset: 8 5467 * End: 5468 */ 5469