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