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