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/nfs.h> 47 #include <linux/nfs4.h> 48 #include <linux/nfs_fs.h> 49 #include <linux/nfs_page.h> 50 #include <linux/nfs_mount.h> 51 #include <linux/namei.h> 52 #include <linux/mount.h> 53 #include <linux/module.h> 54 #include <linux/nfs_idmap.h> 55 #include <linux/xattr.h> 56 #include <linux/utsname.h> 57 #include <linux/freezer.h> 58 59 #include "nfs4_fs.h" 60 #include "delegation.h" 61 #include "internal.h" 62 #include "iostat.h" 63 #include "callback.h" 64 #include "pnfs.h" 65 #include "netns.h" 66 #include "nfs4session.h" 67 #include "fscache.h" 68 69 #include "nfs4trace.h" 70 71 #define NFSDBG_FACILITY NFSDBG_PROC 72 73 #define NFS4_POLL_RETRY_MIN (HZ/10) 74 #define NFS4_POLL_RETRY_MAX (15*HZ) 75 76 struct nfs4_opendata; 77 static int _nfs4_proc_open(struct nfs4_opendata *data); 78 static int _nfs4_recover_proc_open(struct nfs4_opendata *data); 79 static int nfs4_do_fsinfo(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *); 80 static int nfs4_async_handle_error(struct rpc_task *, const struct nfs_server *, struct nfs4_state *, long *); 81 static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr); 82 static int nfs4_proc_getattr(struct nfs_server *, struct nfs_fh *, struct nfs_fattr *, struct nfs4_label *label); 83 static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr, struct nfs4_label *label); 84 static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred, 85 struct nfs_fattr *fattr, struct iattr *sattr, 86 struct nfs4_state *state, struct nfs4_label *ilabel, 87 struct nfs4_label *olabel); 88 #ifdef CONFIG_NFS_V4_1 89 static int nfs41_test_stateid(struct nfs_server *, nfs4_stateid *, 90 struct rpc_cred *); 91 static int nfs41_free_stateid(struct nfs_server *, nfs4_stateid *, 92 struct rpc_cred *); 93 #endif 94 95 #ifdef CONFIG_NFS_V4_SECURITY_LABEL 96 static inline struct nfs4_label * 97 nfs4_label_init_security(struct inode *dir, struct dentry *dentry, 98 struct iattr *sattr, struct nfs4_label *label) 99 { 100 int err; 101 102 if (label == NULL) 103 return NULL; 104 105 if (nfs_server_capable(dir, NFS_CAP_SECURITY_LABEL) == 0) 106 return NULL; 107 108 err = security_dentry_init_security(dentry, sattr->ia_mode, 109 &dentry->d_name, (void **)&label->label, &label->len); 110 if (err == 0) 111 return label; 112 113 return NULL; 114 } 115 static inline void 116 nfs4_label_release_security(struct nfs4_label *label) 117 { 118 if (label) 119 security_release_secctx(label->label, label->len); 120 } 121 static inline u32 *nfs4_bitmask(struct nfs_server *server, struct nfs4_label *label) 122 { 123 if (label) 124 return server->attr_bitmask; 125 126 return server->attr_bitmask_nl; 127 } 128 #else 129 static inline struct nfs4_label * 130 nfs4_label_init_security(struct inode *dir, struct dentry *dentry, 131 struct iattr *sattr, struct nfs4_label *l) 132 { return NULL; } 133 static inline void 134 nfs4_label_release_security(struct nfs4_label *label) 135 { return; } 136 static inline u32 * 137 nfs4_bitmask(struct nfs_server *server, struct nfs4_label *label) 138 { return server->attr_bitmask; } 139 #endif 140 141 /* Prevent leaks of NFSv4 errors into userland */ 142 static int nfs4_map_errors(int err) 143 { 144 if (err >= -1000) 145 return err; 146 switch (err) { 147 case -NFS4ERR_RESOURCE: 148 case -NFS4ERR_LAYOUTTRYLATER: 149 case -NFS4ERR_RECALLCONFLICT: 150 return -EREMOTEIO; 151 case -NFS4ERR_WRONGSEC: 152 case -NFS4ERR_WRONG_CRED: 153 return -EPERM; 154 case -NFS4ERR_BADOWNER: 155 case -NFS4ERR_BADNAME: 156 return -EINVAL; 157 case -NFS4ERR_SHARE_DENIED: 158 return -EACCES; 159 case -NFS4ERR_MINOR_VERS_MISMATCH: 160 return -EPROTONOSUPPORT; 161 case -NFS4ERR_FILE_OPEN: 162 return -EBUSY; 163 default: 164 dprintk("%s could not handle NFSv4 error %d\n", 165 __func__, -err); 166 break; 167 } 168 return -EIO; 169 } 170 171 /* 172 * This is our standard bitmap for GETATTR requests. 173 */ 174 const u32 nfs4_fattr_bitmap[3] = { 175 FATTR4_WORD0_TYPE 176 | FATTR4_WORD0_CHANGE 177 | FATTR4_WORD0_SIZE 178 | FATTR4_WORD0_FSID 179 | FATTR4_WORD0_FILEID, 180 FATTR4_WORD1_MODE 181 | FATTR4_WORD1_NUMLINKS 182 | FATTR4_WORD1_OWNER 183 | FATTR4_WORD1_OWNER_GROUP 184 | FATTR4_WORD1_RAWDEV 185 | FATTR4_WORD1_SPACE_USED 186 | FATTR4_WORD1_TIME_ACCESS 187 | FATTR4_WORD1_TIME_METADATA 188 | FATTR4_WORD1_TIME_MODIFY, 189 #ifdef CONFIG_NFS_V4_SECURITY_LABEL 190 FATTR4_WORD2_SECURITY_LABEL 191 #endif 192 }; 193 194 static const u32 nfs4_pnfs_open_bitmap[3] = { 195 FATTR4_WORD0_TYPE 196 | FATTR4_WORD0_CHANGE 197 | FATTR4_WORD0_SIZE 198 | FATTR4_WORD0_FSID 199 | FATTR4_WORD0_FILEID, 200 FATTR4_WORD1_MODE 201 | FATTR4_WORD1_NUMLINKS 202 | FATTR4_WORD1_OWNER 203 | FATTR4_WORD1_OWNER_GROUP 204 | FATTR4_WORD1_RAWDEV 205 | FATTR4_WORD1_SPACE_USED 206 | FATTR4_WORD1_TIME_ACCESS 207 | FATTR4_WORD1_TIME_METADATA 208 | FATTR4_WORD1_TIME_MODIFY, 209 FATTR4_WORD2_MDSTHRESHOLD 210 }; 211 212 static const u32 nfs4_open_noattr_bitmap[3] = { 213 FATTR4_WORD0_TYPE 214 | FATTR4_WORD0_CHANGE 215 | FATTR4_WORD0_FILEID, 216 }; 217 218 const u32 nfs4_statfs_bitmap[3] = { 219 FATTR4_WORD0_FILES_AVAIL 220 | FATTR4_WORD0_FILES_FREE 221 | FATTR4_WORD0_FILES_TOTAL, 222 FATTR4_WORD1_SPACE_AVAIL 223 | FATTR4_WORD1_SPACE_FREE 224 | FATTR4_WORD1_SPACE_TOTAL 225 }; 226 227 const u32 nfs4_pathconf_bitmap[3] = { 228 FATTR4_WORD0_MAXLINK 229 | FATTR4_WORD0_MAXNAME, 230 0 231 }; 232 233 const u32 nfs4_fsinfo_bitmap[3] = { FATTR4_WORD0_MAXFILESIZE 234 | FATTR4_WORD0_MAXREAD 235 | FATTR4_WORD0_MAXWRITE 236 | FATTR4_WORD0_LEASE_TIME, 237 FATTR4_WORD1_TIME_DELTA 238 | FATTR4_WORD1_FS_LAYOUT_TYPES, 239 FATTR4_WORD2_LAYOUT_BLKSIZE 240 }; 241 242 const u32 nfs4_fs_locations_bitmap[3] = { 243 FATTR4_WORD0_TYPE 244 | FATTR4_WORD0_CHANGE 245 | FATTR4_WORD0_SIZE 246 | FATTR4_WORD0_FSID 247 | FATTR4_WORD0_FILEID 248 | FATTR4_WORD0_FS_LOCATIONS, 249 FATTR4_WORD1_MODE 250 | FATTR4_WORD1_NUMLINKS 251 | FATTR4_WORD1_OWNER 252 | FATTR4_WORD1_OWNER_GROUP 253 | FATTR4_WORD1_RAWDEV 254 | FATTR4_WORD1_SPACE_USED 255 | FATTR4_WORD1_TIME_ACCESS 256 | FATTR4_WORD1_TIME_METADATA 257 | FATTR4_WORD1_TIME_MODIFY 258 | FATTR4_WORD1_MOUNTED_ON_FILEID, 259 }; 260 261 static void nfs4_setup_readdir(u64 cookie, __be32 *verifier, struct dentry *dentry, 262 struct nfs4_readdir_arg *readdir) 263 { 264 __be32 *start, *p; 265 266 if (cookie > 2) { 267 readdir->cookie = cookie; 268 memcpy(&readdir->verifier, verifier, sizeof(readdir->verifier)); 269 return; 270 } 271 272 readdir->cookie = 0; 273 memset(&readdir->verifier, 0, sizeof(readdir->verifier)); 274 if (cookie == 2) 275 return; 276 277 /* 278 * NFSv4 servers do not return entries for '.' and '..' 279 * Therefore, we fake these entries here. We let '.' 280 * have cookie 0 and '..' have cookie 1. Note that 281 * when talking to the server, we always send cookie 0 282 * instead of 1 or 2. 283 */ 284 start = p = kmap_atomic(*readdir->pages); 285 286 if (cookie == 0) { 287 *p++ = xdr_one; /* next */ 288 *p++ = xdr_zero; /* cookie, first word */ 289 *p++ = xdr_one; /* cookie, second word */ 290 *p++ = xdr_one; /* entry len */ 291 memcpy(p, ".\0\0\0", 4); /* entry */ 292 p++; 293 *p++ = xdr_one; /* bitmap length */ 294 *p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */ 295 *p++ = htonl(8); /* attribute buffer length */ 296 p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_inode)); 297 } 298 299 *p++ = xdr_one; /* next */ 300 *p++ = xdr_zero; /* cookie, first word */ 301 *p++ = xdr_two; /* cookie, second word */ 302 *p++ = xdr_two; /* entry len */ 303 memcpy(p, "..\0\0", 4); /* entry */ 304 p++; 305 *p++ = xdr_one; /* bitmap length */ 306 *p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */ 307 *p++ = htonl(8); /* attribute buffer length */ 308 p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_parent->d_inode)); 309 310 readdir->pgbase = (char *)p - (char *)start; 311 readdir->count -= readdir->pgbase; 312 kunmap_atomic(start); 313 } 314 315 static long nfs4_update_delay(long *timeout) 316 { 317 long ret; 318 if (!timeout) 319 return NFS4_POLL_RETRY_MAX; 320 if (*timeout <= 0) 321 *timeout = NFS4_POLL_RETRY_MIN; 322 if (*timeout > NFS4_POLL_RETRY_MAX) 323 *timeout = NFS4_POLL_RETRY_MAX; 324 ret = *timeout; 325 *timeout <<= 1; 326 return ret; 327 } 328 329 static int nfs4_delay(struct rpc_clnt *clnt, long *timeout) 330 { 331 int res = 0; 332 333 might_sleep(); 334 335 freezable_schedule_timeout_killable_unsafe( 336 nfs4_update_delay(timeout)); 337 if (fatal_signal_pending(current)) 338 res = -ERESTARTSYS; 339 return res; 340 } 341 342 /* This is the error handling routine for processes that are allowed 343 * to sleep. 344 */ 345 int nfs4_handle_exception(struct nfs_server *server, int errorcode, struct nfs4_exception *exception) 346 { 347 struct nfs_client *clp = server->nfs_client; 348 struct nfs4_state *state = exception->state; 349 struct inode *inode = exception->inode; 350 int ret = errorcode; 351 352 exception->retry = 0; 353 switch(errorcode) { 354 case 0: 355 return 0; 356 case -NFS4ERR_OPENMODE: 357 if (inode && nfs4_have_delegation(inode, FMODE_READ)) { 358 nfs4_inode_return_delegation(inode); 359 exception->retry = 1; 360 return 0; 361 } 362 if (state == NULL) 363 break; 364 ret = nfs4_schedule_stateid_recovery(server, state); 365 if (ret < 0) 366 break; 367 goto wait_on_recovery; 368 case -NFS4ERR_DELEG_REVOKED: 369 case -NFS4ERR_ADMIN_REVOKED: 370 case -NFS4ERR_BAD_STATEID: 371 if (state == NULL) 372 break; 373 ret = nfs4_schedule_stateid_recovery(server, state); 374 if (ret < 0) 375 break; 376 goto wait_on_recovery; 377 case -NFS4ERR_EXPIRED: 378 if (state != NULL) { 379 ret = nfs4_schedule_stateid_recovery(server, state); 380 if (ret < 0) 381 break; 382 } 383 case -NFS4ERR_STALE_STATEID: 384 case -NFS4ERR_STALE_CLIENTID: 385 nfs4_schedule_lease_recovery(clp); 386 goto wait_on_recovery; 387 case -NFS4ERR_MOVED: 388 ret = nfs4_schedule_migration_recovery(server); 389 if (ret < 0) 390 break; 391 goto wait_on_recovery; 392 case -NFS4ERR_LEASE_MOVED: 393 nfs4_schedule_lease_moved_recovery(clp); 394 goto wait_on_recovery; 395 #if defined(CONFIG_NFS_V4_1) 396 case -NFS4ERR_BADSESSION: 397 case -NFS4ERR_BADSLOT: 398 case -NFS4ERR_BAD_HIGH_SLOT: 399 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 400 case -NFS4ERR_DEADSESSION: 401 case -NFS4ERR_SEQ_FALSE_RETRY: 402 case -NFS4ERR_SEQ_MISORDERED: 403 dprintk("%s ERROR: %d Reset session\n", __func__, 404 errorcode); 405 nfs4_schedule_session_recovery(clp->cl_session, errorcode); 406 goto wait_on_recovery; 407 #endif /* defined(CONFIG_NFS_V4_1) */ 408 case -NFS4ERR_FILE_OPEN: 409 if (exception->timeout > HZ) { 410 /* We have retried a decent amount, time to 411 * fail 412 */ 413 ret = -EBUSY; 414 break; 415 } 416 case -NFS4ERR_GRACE: 417 case -NFS4ERR_DELAY: 418 ret = nfs4_delay(server->client, &exception->timeout); 419 if (ret != 0) 420 break; 421 case -NFS4ERR_RETRY_UNCACHED_REP: 422 case -NFS4ERR_OLD_STATEID: 423 exception->retry = 1; 424 break; 425 case -NFS4ERR_BADOWNER: 426 /* The following works around a Linux server bug! */ 427 case -NFS4ERR_BADNAME: 428 if (server->caps & NFS_CAP_UIDGID_NOMAP) { 429 server->caps &= ~NFS_CAP_UIDGID_NOMAP; 430 exception->retry = 1; 431 printk(KERN_WARNING "NFS: v4 server %s " 432 "does not accept raw " 433 "uid/gids. " 434 "Reenabling the idmapper.\n", 435 server->nfs_client->cl_hostname); 436 } 437 } 438 /* We failed to handle the error */ 439 return nfs4_map_errors(ret); 440 wait_on_recovery: 441 ret = nfs4_wait_clnt_recover(clp); 442 if (test_bit(NFS_MIG_FAILED, &server->mig_status)) 443 return -EIO; 444 if (ret == 0) 445 exception->retry = 1; 446 return ret; 447 } 448 449 /* 450 * Return 'true' if 'clp' is using an rpc_client that is integrity protected 451 * or 'false' otherwise. 452 */ 453 static bool _nfs4_is_integrity_protected(struct nfs_client *clp) 454 { 455 rpc_authflavor_t flavor = clp->cl_rpcclient->cl_auth->au_flavor; 456 457 if (flavor == RPC_AUTH_GSS_KRB5I || 458 flavor == RPC_AUTH_GSS_KRB5P) 459 return true; 460 461 return false; 462 } 463 464 static void do_renew_lease(struct nfs_client *clp, unsigned long timestamp) 465 { 466 spin_lock(&clp->cl_lock); 467 if (time_before(clp->cl_last_renewal,timestamp)) 468 clp->cl_last_renewal = timestamp; 469 spin_unlock(&clp->cl_lock); 470 } 471 472 static void renew_lease(const struct nfs_server *server, unsigned long timestamp) 473 { 474 do_renew_lease(server->nfs_client, timestamp); 475 } 476 477 struct nfs4_call_sync_data { 478 const struct nfs_server *seq_server; 479 struct nfs4_sequence_args *seq_args; 480 struct nfs4_sequence_res *seq_res; 481 }; 482 483 static void nfs4_init_sequence(struct nfs4_sequence_args *args, 484 struct nfs4_sequence_res *res, int cache_reply) 485 { 486 args->sa_slot = NULL; 487 args->sa_cache_this = cache_reply; 488 args->sa_privileged = 0; 489 490 res->sr_slot = NULL; 491 } 492 493 static void nfs4_set_sequence_privileged(struct nfs4_sequence_args *args) 494 { 495 args->sa_privileged = 1; 496 } 497 498 int nfs40_setup_sequence(struct nfs4_slot_table *tbl, 499 struct nfs4_sequence_args *args, 500 struct nfs4_sequence_res *res, 501 struct rpc_task *task) 502 { 503 struct nfs4_slot *slot; 504 505 /* slot already allocated? */ 506 if (res->sr_slot != NULL) 507 goto out_start; 508 509 spin_lock(&tbl->slot_tbl_lock); 510 if (nfs4_slot_tbl_draining(tbl) && !args->sa_privileged) 511 goto out_sleep; 512 513 slot = nfs4_alloc_slot(tbl); 514 if (IS_ERR(slot)) { 515 if (slot == ERR_PTR(-ENOMEM)) 516 task->tk_timeout = HZ >> 2; 517 goto out_sleep; 518 } 519 spin_unlock(&tbl->slot_tbl_lock); 520 521 args->sa_slot = slot; 522 res->sr_slot = slot; 523 524 out_start: 525 rpc_call_start(task); 526 return 0; 527 528 out_sleep: 529 if (args->sa_privileged) 530 rpc_sleep_on_priority(&tbl->slot_tbl_waitq, task, 531 NULL, RPC_PRIORITY_PRIVILEGED); 532 else 533 rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL); 534 spin_unlock(&tbl->slot_tbl_lock); 535 return -EAGAIN; 536 } 537 EXPORT_SYMBOL_GPL(nfs40_setup_sequence); 538 539 static int nfs40_sequence_done(struct rpc_task *task, 540 struct nfs4_sequence_res *res) 541 { 542 struct nfs4_slot *slot = res->sr_slot; 543 struct nfs4_slot_table *tbl; 544 545 if (slot == NULL) 546 goto out; 547 548 tbl = slot->table; 549 spin_lock(&tbl->slot_tbl_lock); 550 if (!nfs41_wake_and_assign_slot(tbl, slot)) 551 nfs4_free_slot(tbl, slot); 552 spin_unlock(&tbl->slot_tbl_lock); 553 554 res->sr_slot = NULL; 555 out: 556 return 1; 557 } 558 559 #if defined(CONFIG_NFS_V4_1) 560 561 static void nfs41_sequence_free_slot(struct nfs4_sequence_res *res) 562 { 563 struct nfs4_session *session; 564 struct nfs4_slot_table *tbl; 565 struct nfs4_slot *slot = res->sr_slot; 566 bool send_new_highest_used_slotid = false; 567 568 tbl = slot->table; 569 session = tbl->session; 570 571 spin_lock(&tbl->slot_tbl_lock); 572 /* Be nice to the server: try to ensure that the last transmitted 573 * value for highest_user_slotid <= target_highest_slotid 574 */ 575 if (tbl->highest_used_slotid > tbl->target_highest_slotid) 576 send_new_highest_used_slotid = true; 577 578 if (nfs41_wake_and_assign_slot(tbl, slot)) { 579 send_new_highest_used_slotid = false; 580 goto out_unlock; 581 } 582 nfs4_free_slot(tbl, slot); 583 584 if (tbl->highest_used_slotid != NFS4_NO_SLOT) 585 send_new_highest_used_slotid = false; 586 out_unlock: 587 spin_unlock(&tbl->slot_tbl_lock); 588 res->sr_slot = NULL; 589 if (send_new_highest_used_slotid) 590 nfs41_server_notify_highest_slotid_update(session->clp); 591 } 592 593 int nfs41_sequence_done(struct rpc_task *task, struct nfs4_sequence_res *res) 594 { 595 struct nfs4_session *session; 596 struct nfs4_slot *slot = res->sr_slot; 597 struct nfs_client *clp; 598 bool interrupted = false; 599 int ret = 1; 600 601 if (slot == NULL) 602 goto out_noaction; 603 /* don't increment the sequence number if the task wasn't sent */ 604 if (!RPC_WAS_SENT(task)) 605 goto out; 606 607 session = slot->table->session; 608 609 if (slot->interrupted) { 610 slot->interrupted = 0; 611 interrupted = true; 612 } 613 614 trace_nfs4_sequence_done(session, res); 615 /* Check the SEQUENCE operation status */ 616 switch (res->sr_status) { 617 case 0: 618 /* Update the slot's sequence and clientid lease timer */ 619 ++slot->seq_nr; 620 clp = session->clp; 621 do_renew_lease(clp, res->sr_timestamp); 622 /* Check sequence flags */ 623 if (res->sr_status_flags != 0) 624 nfs4_schedule_lease_recovery(clp); 625 nfs41_update_target_slotid(slot->table, slot, res); 626 break; 627 case 1: 628 /* 629 * sr_status remains 1 if an RPC level error occurred. 630 * The server may or may not have processed the sequence 631 * operation.. 632 * Mark the slot as having hosted an interrupted RPC call. 633 */ 634 slot->interrupted = 1; 635 goto out; 636 case -NFS4ERR_DELAY: 637 /* The server detected a resend of the RPC call and 638 * returned NFS4ERR_DELAY as per Section 2.10.6.2 639 * of RFC5661. 640 */ 641 dprintk("%s: slot=%u seq=%u: Operation in progress\n", 642 __func__, 643 slot->slot_nr, 644 slot->seq_nr); 645 goto out_retry; 646 case -NFS4ERR_BADSLOT: 647 /* 648 * The slot id we used was probably retired. Try again 649 * using a different slot id. 650 */ 651 goto retry_nowait; 652 case -NFS4ERR_SEQ_MISORDERED: 653 /* 654 * Was the last operation on this sequence interrupted? 655 * If so, retry after bumping the sequence number. 656 */ 657 if (interrupted) { 658 ++slot->seq_nr; 659 goto retry_nowait; 660 } 661 /* 662 * Could this slot have been previously retired? 663 * If so, then the server may be expecting seq_nr = 1! 664 */ 665 if (slot->seq_nr != 1) { 666 slot->seq_nr = 1; 667 goto retry_nowait; 668 } 669 break; 670 case -NFS4ERR_SEQ_FALSE_RETRY: 671 ++slot->seq_nr; 672 goto retry_nowait; 673 default: 674 /* Just update the slot sequence no. */ 675 ++slot->seq_nr; 676 } 677 out: 678 /* The session may be reset by one of the error handlers. */ 679 dprintk("%s: Error %d free the slot \n", __func__, res->sr_status); 680 nfs41_sequence_free_slot(res); 681 out_noaction: 682 return ret; 683 retry_nowait: 684 if (rpc_restart_call_prepare(task)) { 685 task->tk_status = 0; 686 ret = 0; 687 } 688 goto out; 689 out_retry: 690 if (!rpc_restart_call(task)) 691 goto out; 692 rpc_delay(task, NFS4_POLL_RETRY_MAX); 693 return 0; 694 } 695 EXPORT_SYMBOL_GPL(nfs41_sequence_done); 696 697 int nfs4_sequence_done(struct rpc_task *task, struct nfs4_sequence_res *res) 698 { 699 if (res->sr_slot == NULL) 700 return 1; 701 if (!res->sr_slot->table->session) 702 return nfs40_sequence_done(task, res); 703 return nfs41_sequence_done(task, res); 704 } 705 EXPORT_SYMBOL_GPL(nfs4_sequence_done); 706 707 int nfs41_setup_sequence(struct nfs4_session *session, 708 struct nfs4_sequence_args *args, 709 struct nfs4_sequence_res *res, 710 struct rpc_task *task) 711 { 712 struct nfs4_slot *slot; 713 struct nfs4_slot_table *tbl; 714 715 dprintk("--> %s\n", __func__); 716 /* slot already allocated? */ 717 if (res->sr_slot != NULL) 718 goto out_success; 719 720 tbl = &session->fc_slot_table; 721 722 task->tk_timeout = 0; 723 724 spin_lock(&tbl->slot_tbl_lock); 725 if (test_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state) && 726 !args->sa_privileged) { 727 /* The state manager will wait until the slot table is empty */ 728 dprintk("%s session is draining\n", __func__); 729 goto out_sleep; 730 } 731 732 slot = nfs4_alloc_slot(tbl); 733 if (IS_ERR(slot)) { 734 /* If out of memory, try again in 1/4 second */ 735 if (slot == ERR_PTR(-ENOMEM)) 736 task->tk_timeout = HZ >> 2; 737 dprintk("<-- %s: no free slots\n", __func__); 738 goto out_sleep; 739 } 740 spin_unlock(&tbl->slot_tbl_lock); 741 742 args->sa_slot = slot; 743 744 dprintk("<-- %s slotid=%u seqid=%u\n", __func__, 745 slot->slot_nr, slot->seq_nr); 746 747 res->sr_slot = slot; 748 res->sr_timestamp = jiffies; 749 res->sr_status_flags = 0; 750 /* 751 * sr_status is only set in decode_sequence, and so will remain 752 * set to 1 if an rpc level failure occurs. 753 */ 754 res->sr_status = 1; 755 trace_nfs4_setup_sequence(session, args); 756 out_success: 757 rpc_call_start(task); 758 return 0; 759 out_sleep: 760 /* Privileged tasks are queued with top priority */ 761 if (args->sa_privileged) 762 rpc_sleep_on_priority(&tbl->slot_tbl_waitq, task, 763 NULL, RPC_PRIORITY_PRIVILEGED); 764 else 765 rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL); 766 spin_unlock(&tbl->slot_tbl_lock); 767 return -EAGAIN; 768 } 769 EXPORT_SYMBOL_GPL(nfs41_setup_sequence); 770 771 static int nfs4_setup_sequence(const struct nfs_server *server, 772 struct nfs4_sequence_args *args, 773 struct nfs4_sequence_res *res, 774 struct rpc_task *task) 775 { 776 struct nfs4_session *session = nfs4_get_session(server); 777 int ret = 0; 778 779 if (!session) 780 return nfs40_setup_sequence(server->nfs_client->cl_slot_tbl, 781 args, res, task); 782 783 dprintk("--> %s clp %p session %p sr_slot %u\n", 784 __func__, session->clp, session, res->sr_slot ? 785 res->sr_slot->slot_nr : NFS4_NO_SLOT); 786 787 ret = nfs41_setup_sequence(session, args, res, task); 788 789 dprintk("<-- %s status=%d\n", __func__, ret); 790 return ret; 791 } 792 793 static void nfs41_call_sync_prepare(struct rpc_task *task, void *calldata) 794 { 795 struct nfs4_call_sync_data *data = calldata; 796 struct nfs4_session *session = nfs4_get_session(data->seq_server); 797 798 dprintk("--> %s data->seq_server %p\n", __func__, data->seq_server); 799 800 nfs41_setup_sequence(session, data->seq_args, data->seq_res, task); 801 } 802 803 static void nfs41_call_sync_done(struct rpc_task *task, void *calldata) 804 { 805 struct nfs4_call_sync_data *data = calldata; 806 807 nfs41_sequence_done(task, data->seq_res); 808 } 809 810 static const struct rpc_call_ops nfs41_call_sync_ops = { 811 .rpc_call_prepare = nfs41_call_sync_prepare, 812 .rpc_call_done = nfs41_call_sync_done, 813 }; 814 815 #else /* !CONFIG_NFS_V4_1 */ 816 817 static int nfs4_setup_sequence(const struct nfs_server *server, 818 struct nfs4_sequence_args *args, 819 struct nfs4_sequence_res *res, 820 struct rpc_task *task) 821 { 822 return nfs40_setup_sequence(server->nfs_client->cl_slot_tbl, 823 args, res, task); 824 } 825 826 int nfs4_sequence_done(struct rpc_task *task, 827 struct nfs4_sequence_res *res) 828 { 829 return nfs40_sequence_done(task, res); 830 } 831 EXPORT_SYMBOL_GPL(nfs4_sequence_done); 832 833 #endif /* !CONFIG_NFS_V4_1 */ 834 835 static void nfs40_call_sync_prepare(struct rpc_task *task, void *calldata) 836 { 837 struct nfs4_call_sync_data *data = calldata; 838 nfs4_setup_sequence(data->seq_server, 839 data->seq_args, data->seq_res, task); 840 } 841 842 static void nfs40_call_sync_done(struct rpc_task *task, void *calldata) 843 { 844 struct nfs4_call_sync_data *data = calldata; 845 nfs4_sequence_done(task, data->seq_res); 846 } 847 848 static const struct rpc_call_ops nfs40_call_sync_ops = { 849 .rpc_call_prepare = nfs40_call_sync_prepare, 850 .rpc_call_done = nfs40_call_sync_done, 851 }; 852 853 static int nfs4_call_sync_sequence(struct rpc_clnt *clnt, 854 struct nfs_server *server, 855 struct rpc_message *msg, 856 struct nfs4_sequence_args *args, 857 struct nfs4_sequence_res *res) 858 { 859 int ret; 860 struct rpc_task *task; 861 struct nfs_client *clp = server->nfs_client; 862 struct nfs4_call_sync_data data = { 863 .seq_server = server, 864 .seq_args = args, 865 .seq_res = res, 866 }; 867 struct rpc_task_setup task_setup = { 868 .rpc_client = clnt, 869 .rpc_message = msg, 870 .callback_ops = clp->cl_mvops->call_sync_ops, 871 .callback_data = &data 872 }; 873 874 task = rpc_run_task(&task_setup); 875 if (IS_ERR(task)) 876 ret = PTR_ERR(task); 877 else { 878 ret = task->tk_status; 879 rpc_put_task(task); 880 } 881 return ret; 882 } 883 884 int nfs4_call_sync(struct rpc_clnt *clnt, 885 struct nfs_server *server, 886 struct rpc_message *msg, 887 struct nfs4_sequence_args *args, 888 struct nfs4_sequence_res *res, 889 int cache_reply) 890 { 891 nfs4_init_sequence(args, res, cache_reply); 892 return nfs4_call_sync_sequence(clnt, server, msg, args, res); 893 } 894 895 static void update_changeattr(struct inode *dir, struct nfs4_change_info *cinfo) 896 { 897 struct nfs_inode *nfsi = NFS_I(dir); 898 899 spin_lock(&dir->i_lock); 900 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA; 901 if (!cinfo->atomic || cinfo->before != dir->i_version) 902 nfs_force_lookup_revalidate(dir); 903 dir->i_version = cinfo->after; 904 nfsi->attr_gencount = nfs_inc_attr_generation_counter(); 905 nfs_fscache_invalidate(dir); 906 spin_unlock(&dir->i_lock); 907 } 908 909 struct nfs4_opendata { 910 struct kref kref; 911 struct nfs_openargs o_arg; 912 struct nfs_openres o_res; 913 struct nfs_open_confirmargs c_arg; 914 struct nfs_open_confirmres c_res; 915 struct nfs4_string owner_name; 916 struct nfs4_string group_name; 917 struct nfs_fattr f_attr; 918 struct nfs4_label *f_label; 919 struct dentry *dir; 920 struct dentry *dentry; 921 struct nfs4_state_owner *owner; 922 struct nfs4_state *state; 923 struct iattr attrs; 924 unsigned long timestamp; 925 unsigned int rpc_done : 1; 926 unsigned int file_created : 1; 927 unsigned int is_recover : 1; 928 int rpc_status; 929 int cancelled; 930 }; 931 932 static bool nfs4_clear_cap_atomic_open_v1(struct nfs_server *server, 933 int err, struct nfs4_exception *exception) 934 { 935 if (err != -EINVAL) 936 return false; 937 if (!(server->caps & NFS_CAP_ATOMIC_OPEN_V1)) 938 return false; 939 server->caps &= ~NFS_CAP_ATOMIC_OPEN_V1; 940 exception->retry = 1; 941 return true; 942 } 943 944 static u32 945 nfs4_map_atomic_open_share(struct nfs_server *server, 946 fmode_t fmode, int openflags) 947 { 948 u32 res = 0; 949 950 switch (fmode & (FMODE_READ | FMODE_WRITE)) { 951 case FMODE_READ: 952 res = NFS4_SHARE_ACCESS_READ; 953 break; 954 case FMODE_WRITE: 955 res = NFS4_SHARE_ACCESS_WRITE; 956 break; 957 case FMODE_READ|FMODE_WRITE: 958 res = NFS4_SHARE_ACCESS_BOTH; 959 } 960 if (!(server->caps & NFS_CAP_ATOMIC_OPEN_V1)) 961 goto out; 962 /* Want no delegation if we're using O_DIRECT */ 963 if (openflags & O_DIRECT) 964 res |= NFS4_SHARE_WANT_NO_DELEG; 965 out: 966 return res; 967 } 968 969 static enum open_claim_type4 970 nfs4_map_atomic_open_claim(struct nfs_server *server, 971 enum open_claim_type4 claim) 972 { 973 if (server->caps & NFS_CAP_ATOMIC_OPEN_V1) 974 return claim; 975 switch (claim) { 976 default: 977 return claim; 978 case NFS4_OPEN_CLAIM_FH: 979 return NFS4_OPEN_CLAIM_NULL; 980 case NFS4_OPEN_CLAIM_DELEG_CUR_FH: 981 return NFS4_OPEN_CLAIM_DELEGATE_CUR; 982 case NFS4_OPEN_CLAIM_DELEG_PREV_FH: 983 return NFS4_OPEN_CLAIM_DELEGATE_PREV; 984 } 985 } 986 987 static void nfs4_init_opendata_res(struct nfs4_opendata *p) 988 { 989 p->o_res.f_attr = &p->f_attr; 990 p->o_res.f_label = p->f_label; 991 p->o_res.seqid = p->o_arg.seqid; 992 p->c_res.seqid = p->c_arg.seqid; 993 p->o_res.server = p->o_arg.server; 994 p->o_res.access_request = p->o_arg.access; 995 nfs_fattr_init(&p->f_attr); 996 nfs_fattr_init_names(&p->f_attr, &p->owner_name, &p->group_name); 997 } 998 999 static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry, 1000 struct nfs4_state_owner *sp, fmode_t fmode, int flags, 1001 const struct iattr *attrs, 1002 struct nfs4_label *label, 1003 enum open_claim_type4 claim, 1004 gfp_t gfp_mask) 1005 { 1006 struct dentry *parent = dget_parent(dentry); 1007 struct inode *dir = parent->d_inode; 1008 struct nfs_server *server = NFS_SERVER(dir); 1009 struct nfs_seqid *(*alloc_seqid)(struct nfs_seqid_counter *, gfp_t); 1010 struct nfs4_opendata *p; 1011 1012 p = kzalloc(sizeof(*p), gfp_mask); 1013 if (p == NULL) 1014 goto err; 1015 1016 p->f_label = nfs4_label_alloc(server, gfp_mask); 1017 if (IS_ERR(p->f_label)) 1018 goto err_free_p; 1019 1020 alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid; 1021 p->o_arg.seqid = alloc_seqid(&sp->so_seqid, gfp_mask); 1022 if (IS_ERR(p->o_arg.seqid)) 1023 goto err_free_label; 1024 nfs_sb_active(dentry->d_sb); 1025 p->dentry = dget(dentry); 1026 p->dir = parent; 1027 p->owner = sp; 1028 atomic_inc(&sp->so_count); 1029 p->o_arg.open_flags = flags; 1030 p->o_arg.fmode = fmode & (FMODE_READ|FMODE_WRITE); 1031 p->o_arg.share_access = nfs4_map_atomic_open_share(server, 1032 fmode, flags); 1033 /* don't put an ACCESS op in OPEN compound if O_EXCL, because ACCESS 1034 * will return permission denied for all bits until close */ 1035 if (!(flags & O_EXCL)) { 1036 /* ask server to check for all possible rights as results 1037 * are cached */ 1038 p->o_arg.access = NFS4_ACCESS_READ | NFS4_ACCESS_MODIFY | 1039 NFS4_ACCESS_EXTEND | NFS4_ACCESS_EXECUTE; 1040 } 1041 p->o_arg.clientid = server->nfs_client->cl_clientid; 1042 p->o_arg.id.create_time = ktime_to_ns(sp->so_seqid.create_time); 1043 p->o_arg.id.uniquifier = sp->so_seqid.owner_id; 1044 p->o_arg.name = &dentry->d_name; 1045 p->o_arg.server = server; 1046 p->o_arg.bitmask = nfs4_bitmask(server, label); 1047 p->o_arg.open_bitmap = &nfs4_fattr_bitmap[0]; 1048 p->o_arg.label = label; 1049 p->o_arg.claim = nfs4_map_atomic_open_claim(server, claim); 1050 switch (p->o_arg.claim) { 1051 case NFS4_OPEN_CLAIM_NULL: 1052 case NFS4_OPEN_CLAIM_DELEGATE_CUR: 1053 case NFS4_OPEN_CLAIM_DELEGATE_PREV: 1054 p->o_arg.fh = NFS_FH(dir); 1055 break; 1056 case NFS4_OPEN_CLAIM_PREVIOUS: 1057 case NFS4_OPEN_CLAIM_FH: 1058 case NFS4_OPEN_CLAIM_DELEG_CUR_FH: 1059 case NFS4_OPEN_CLAIM_DELEG_PREV_FH: 1060 p->o_arg.fh = NFS_FH(dentry->d_inode); 1061 } 1062 if (attrs != NULL && attrs->ia_valid != 0) { 1063 __u32 verf[2]; 1064 1065 p->o_arg.u.attrs = &p->attrs; 1066 memcpy(&p->attrs, attrs, sizeof(p->attrs)); 1067 1068 verf[0] = jiffies; 1069 verf[1] = current->pid; 1070 memcpy(p->o_arg.u.verifier.data, verf, 1071 sizeof(p->o_arg.u.verifier.data)); 1072 } 1073 p->c_arg.fh = &p->o_res.fh; 1074 p->c_arg.stateid = &p->o_res.stateid; 1075 p->c_arg.seqid = p->o_arg.seqid; 1076 nfs4_init_opendata_res(p); 1077 kref_init(&p->kref); 1078 return p; 1079 1080 err_free_label: 1081 nfs4_label_free(p->f_label); 1082 err_free_p: 1083 kfree(p); 1084 err: 1085 dput(parent); 1086 return NULL; 1087 } 1088 1089 static void nfs4_opendata_free(struct kref *kref) 1090 { 1091 struct nfs4_opendata *p = container_of(kref, 1092 struct nfs4_opendata, kref); 1093 struct super_block *sb = p->dentry->d_sb; 1094 1095 nfs_free_seqid(p->o_arg.seqid); 1096 if (p->state != NULL) 1097 nfs4_put_open_state(p->state); 1098 nfs4_put_state_owner(p->owner); 1099 1100 nfs4_label_free(p->f_label); 1101 1102 dput(p->dir); 1103 dput(p->dentry); 1104 nfs_sb_deactive(sb); 1105 nfs_fattr_free_names(&p->f_attr); 1106 kfree(p->f_attr.mdsthreshold); 1107 kfree(p); 1108 } 1109 1110 static void nfs4_opendata_put(struct nfs4_opendata *p) 1111 { 1112 if (p != NULL) 1113 kref_put(&p->kref, nfs4_opendata_free); 1114 } 1115 1116 static int nfs4_wait_for_completion_rpc_task(struct rpc_task *task) 1117 { 1118 int ret; 1119 1120 ret = rpc_wait_for_completion_task(task); 1121 return ret; 1122 } 1123 1124 static int can_open_cached(struct nfs4_state *state, fmode_t mode, int open_mode) 1125 { 1126 int ret = 0; 1127 1128 if (open_mode & (O_EXCL|O_TRUNC)) 1129 goto out; 1130 switch (mode & (FMODE_READ|FMODE_WRITE)) { 1131 case FMODE_READ: 1132 ret |= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0 1133 && state->n_rdonly != 0; 1134 break; 1135 case FMODE_WRITE: 1136 ret |= test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0 1137 && state->n_wronly != 0; 1138 break; 1139 case FMODE_READ|FMODE_WRITE: 1140 ret |= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0 1141 && state->n_rdwr != 0; 1142 } 1143 out: 1144 return ret; 1145 } 1146 1147 static int can_open_delegated(struct nfs_delegation *delegation, fmode_t fmode) 1148 { 1149 if (delegation == NULL) 1150 return 0; 1151 if ((delegation->type & fmode) != fmode) 1152 return 0; 1153 if (test_bit(NFS_DELEGATION_RETURNING, &delegation->flags)) 1154 return 0; 1155 nfs_mark_delegation_referenced(delegation); 1156 return 1; 1157 } 1158 1159 static void update_open_stateflags(struct nfs4_state *state, fmode_t fmode) 1160 { 1161 switch (fmode) { 1162 case FMODE_WRITE: 1163 state->n_wronly++; 1164 break; 1165 case FMODE_READ: 1166 state->n_rdonly++; 1167 break; 1168 case FMODE_READ|FMODE_WRITE: 1169 state->n_rdwr++; 1170 } 1171 nfs4_state_set_mode_locked(state, state->state | fmode); 1172 } 1173 1174 static void nfs_test_and_clear_all_open_stateid(struct nfs4_state *state) 1175 { 1176 struct nfs_client *clp = state->owner->so_server->nfs_client; 1177 bool need_recover = false; 1178 1179 if (test_and_clear_bit(NFS_O_RDONLY_STATE, &state->flags) && state->n_rdonly) 1180 need_recover = true; 1181 if (test_and_clear_bit(NFS_O_WRONLY_STATE, &state->flags) && state->n_wronly) 1182 need_recover = true; 1183 if (test_and_clear_bit(NFS_O_RDWR_STATE, &state->flags) && state->n_rdwr) 1184 need_recover = true; 1185 if (need_recover) 1186 nfs4_state_mark_reclaim_nograce(clp, state); 1187 } 1188 1189 static bool nfs_need_update_open_stateid(struct nfs4_state *state, 1190 nfs4_stateid *stateid) 1191 { 1192 if (test_and_set_bit(NFS_OPEN_STATE, &state->flags) == 0) 1193 return true; 1194 if (!nfs4_stateid_match_other(stateid, &state->open_stateid)) { 1195 nfs_test_and_clear_all_open_stateid(state); 1196 return true; 1197 } 1198 if (nfs4_stateid_is_newer(stateid, &state->open_stateid)) 1199 return true; 1200 return false; 1201 } 1202 1203 static void nfs_resync_open_stateid_locked(struct nfs4_state *state) 1204 { 1205 if (state->n_wronly) 1206 set_bit(NFS_O_WRONLY_STATE, &state->flags); 1207 if (state->n_rdonly) 1208 set_bit(NFS_O_RDONLY_STATE, &state->flags); 1209 if (state->n_rdwr) 1210 set_bit(NFS_O_RDWR_STATE, &state->flags); 1211 } 1212 1213 static void nfs_clear_open_stateid_locked(struct nfs4_state *state, 1214 nfs4_stateid *stateid, fmode_t fmode) 1215 { 1216 clear_bit(NFS_O_RDWR_STATE, &state->flags); 1217 switch (fmode & (FMODE_READ|FMODE_WRITE)) { 1218 case FMODE_WRITE: 1219 clear_bit(NFS_O_RDONLY_STATE, &state->flags); 1220 break; 1221 case FMODE_READ: 1222 clear_bit(NFS_O_WRONLY_STATE, &state->flags); 1223 break; 1224 case 0: 1225 clear_bit(NFS_O_RDONLY_STATE, &state->flags); 1226 clear_bit(NFS_O_WRONLY_STATE, &state->flags); 1227 clear_bit(NFS_OPEN_STATE, &state->flags); 1228 } 1229 if (stateid == NULL) 1230 return; 1231 /* Handle races with OPEN */ 1232 if (!nfs4_stateid_match_other(stateid, &state->open_stateid) || 1233 !nfs4_stateid_is_newer(stateid, &state->open_stateid)) { 1234 nfs_resync_open_stateid_locked(state); 1235 return; 1236 } 1237 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) 1238 nfs4_stateid_copy(&state->stateid, stateid); 1239 nfs4_stateid_copy(&state->open_stateid, stateid); 1240 } 1241 1242 static void nfs_clear_open_stateid(struct nfs4_state *state, nfs4_stateid *stateid, fmode_t fmode) 1243 { 1244 write_seqlock(&state->seqlock); 1245 nfs_clear_open_stateid_locked(state, stateid, fmode); 1246 write_sequnlock(&state->seqlock); 1247 if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags)) 1248 nfs4_schedule_state_manager(state->owner->so_server->nfs_client); 1249 } 1250 1251 static void nfs_set_open_stateid_locked(struct nfs4_state *state, nfs4_stateid *stateid, fmode_t fmode) 1252 { 1253 switch (fmode) { 1254 case FMODE_READ: 1255 set_bit(NFS_O_RDONLY_STATE, &state->flags); 1256 break; 1257 case FMODE_WRITE: 1258 set_bit(NFS_O_WRONLY_STATE, &state->flags); 1259 break; 1260 case FMODE_READ|FMODE_WRITE: 1261 set_bit(NFS_O_RDWR_STATE, &state->flags); 1262 } 1263 if (!nfs_need_update_open_stateid(state, stateid)) 1264 return; 1265 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) 1266 nfs4_stateid_copy(&state->stateid, stateid); 1267 nfs4_stateid_copy(&state->open_stateid, stateid); 1268 } 1269 1270 static void __update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_stateid, const nfs4_stateid *deleg_stateid, fmode_t fmode) 1271 { 1272 /* 1273 * Protect the call to nfs4_state_set_mode_locked and 1274 * serialise the stateid update 1275 */ 1276 write_seqlock(&state->seqlock); 1277 if (deleg_stateid != NULL) { 1278 nfs4_stateid_copy(&state->stateid, deleg_stateid); 1279 set_bit(NFS_DELEGATED_STATE, &state->flags); 1280 } 1281 if (open_stateid != NULL) 1282 nfs_set_open_stateid_locked(state, open_stateid, fmode); 1283 write_sequnlock(&state->seqlock); 1284 spin_lock(&state->owner->so_lock); 1285 update_open_stateflags(state, fmode); 1286 spin_unlock(&state->owner->so_lock); 1287 } 1288 1289 static int update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_stateid, nfs4_stateid *delegation, fmode_t fmode) 1290 { 1291 struct nfs_inode *nfsi = NFS_I(state->inode); 1292 struct nfs_delegation *deleg_cur; 1293 int ret = 0; 1294 1295 fmode &= (FMODE_READ|FMODE_WRITE); 1296 1297 rcu_read_lock(); 1298 deleg_cur = rcu_dereference(nfsi->delegation); 1299 if (deleg_cur == NULL) 1300 goto no_delegation; 1301 1302 spin_lock(&deleg_cur->lock); 1303 if (rcu_dereference(nfsi->delegation) != deleg_cur || 1304 test_bit(NFS_DELEGATION_RETURNING, &deleg_cur->flags) || 1305 (deleg_cur->type & fmode) != fmode) 1306 goto no_delegation_unlock; 1307 1308 if (delegation == NULL) 1309 delegation = &deleg_cur->stateid; 1310 else if (!nfs4_stateid_match(&deleg_cur->stateid, delegation)) 1311 goto no_delegation_unlock; 1312 1313 nfs_mark_delegation_referenced(deleg_cur); 1314 __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode); 1315 ret = 1; 1316 no_delegation_unlock: 1317 spin_unlock(&deleg_cur->lock); 1318 no_delegation: 1319 rcu_read_unlock(); 1320 1321 if (!ret && open_stateid != NULL) { 1322 __update_open_stateid(state, open_stateid, NULL, fmode); 1323 ret = 1; 1324 } 1325 if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags)) 1326 nfs4_schedule_state_manager(state->owner->so_server->nfs_client); 1327 1328 return ret; 1329 } 1330 1331 static bool nfs4_update_lock_stateid(struct nfs4_lock_state *lsp, 1332 const nfs4_stateid *stateid) 1333 { 1334 struct nfs4_state *state = lsp->ls_state; 1335 bool ret = false; 1336 1337 spin_lock(&state->state_lock); 1338 if (!nfs4_stateid_match_other(stateid, &lsp->ls_stateid)) 1339 goto out_noupdate; 1340 if (!nfs4_stateid_is_newer(stateid, &lsp->ls_stateid)) 1341 goto out_noupdate; 1342 nfs4_stateid_copy(&lsp->ls_stateid, stateid); 1343 ret = true; 1344 out_noupdate: 1345 spin_unlock(&state->state_lock); 1346 return ret; 1347 } 1348 1349 static void nfs4_return_incompatible_delegation(struct inode *inode, fmode_t fmode) 1350 { 1351 struct nfs_delegation *delegation; 1352 1353 rcu_read_lock(); 1354 delegation = rcu_dereference(NFS_I(inode)->delegation); 1355 if (delegation == NULL || (delegation->type & fmode) == fmode) { 1356 rcu_read_unlock(); 1357 return; 1358 } 1359 rcu_read_unlock(); 1360 nfs4_inode_return_delegation(inode); 1361 } 1362 1363 static struct nfs4_state *nfs4_try_open_cached(struct nfs4_opendata *opendata) 1364 { 1365 struct nfs4_state *state = opendata->state; 1366 struct nfs_inode *nfsi = NFS_I(state->inode); 1367 struct nfs_delegation *delegation; 1368 int open_mode = opendata->o_arg.open_flags; 1369 fmode_t fmode = opendata->o_arg.fmode; 1370 nfs4_stateid stateid; 1371 int ret = -EAGAIN; 1372 1373 for (;;) { 1374 spin_lock(&state->owner->so_lock); 1375 if (can_open_cached(state, fmode, open_mode)) { 1376 update_open_stateflags(state, fmode); 1377 spin_unlock(&state->owner->so_lock); 1378 goto out_return_state; 1379 } 1380 spin_unlock(&state->owner->so_lock); 1381 rcu_read_lock(); 1382 delegation = rcu_dereference(nfsi->delegation); 1383 if (!can_open_delegated(delegation, fmode)) { 1384 rcu_read_unlock(); 1385 break; 1386 } 1387 /* Save the delegation */ 1388 nfs4_stateid_copy(&stateid, &delegation->stateid); 1389 rcu_read_unlock(); 1390 nfs_release_seqid(opendata->o_arg.seqid); 1391 if (!opendata->is_recover) { 1392 ret = nfs_may_open(state->inode, state->owner->so_cred, open_mode); 1393 if (ret != 0) 1394 goto out; 1395 } 1396 ret = -EAGAIN; 1397 1398 /* Try to update the stateid using the delegation */ 1399 if (update_open_stateid(state, NULL, &stateid, fmode)) 1400 goto out_return_state; 1401 } 1402 out: 1403 return ERR_PTR(ret); 1404 out_return_state: 1405 atomic_inc(&state->count); 1406 return state; 1407 } 1408 1409 static void 1410 nfs4_opendata_check_deleg(struct nfs4_opendata *data, struct nfs4_state *state) 1411 { 1412 struct nfs_client *clp = NFS_SERVER(state->inode)->nfs_client; 1413 struct nfs_delegation *delegation; 1414 int delegation_flags = 0; 1415 1416 rcu_read_lock(); 1417 delegation = rcu_dereference(NFS_I(state->inode)->delegation); 1418 if (delegation) 1419 delegation_flags = delegation->flags; 1420 rcu_read_unlock(); 1421 if (data->o_arg.claim == NFS4_OPEN_CLAIM_DELEGATE_CUR) { 1422 pr_err_ratelimited("NFS: Broken NFSv4 server %s is " 1423 "returning a delegation for " 1424 "OPEN(CLAIM_DELEGATE_CUR)\n", 1425 clp->cl_hostname); 1426 } else if ((delegation_flags & 1UL<<NFS_DELEGATION_NEED_RECLAIM) == 0) 1427 nfs_inode_set_delegation(state->inode, 1428 data->owner->so_cred, 1429 &data->o_res); 1430 else 1431 nfs_inode_reclaim_delegation(state->inode, 1432 data->owner->so_cred, 1433 &data->o_res); 1434 } 1435 1436 /* 1437 * Check the inode attributes against the CLAIM_PREVIOUS returned attributes 1438 * and update the nfs4_state. 1439 */ 1440 static struct nfs4_state * 1441 _nfs4_opendata_reclaim_to_nfs4_state(struct nfs4_opendata *data) 1442 { 1443 struct inode *inode = data->state->inode; 1444 struct nfs4_state *state = data->state; 1445 int ret; 1446 1447 if (!data->rpc_done) { 1448 if (data->rpc_status) { 1449 ret = data->rpc_status; 1450 goto err; 1451 } 1452 /* cached opens have already been processed */ 1453 goto update; 1454 } 1455 1456 ret = nfs_refresh_inode(inode, &data->f_attr); 1457 if (ret) 1458 goto err; 1459 1460 if (data->o_res.delegation_type != 0) 1461 nfs4_opendata_check_deleg(data, state); 1462 update: 1463 update_open_stateid(state, &data->o_res.stateid, NULL, 1464 data->o_arg.fmode); 1465 atomic_inc(&state->count); 1466 1467 return state; 1468 err: 1469 return ERR_PTR(ret); 1470 1471 } 1472 1473 static struct nfs4_state * 1474 _nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data) 1475 { 1476 struct inode *inode; 1477 struct nfs4_state *state = NULL; 1478 int ret; 1479 1480 if (!data->rpc_done) { 1481 state = nfs4_try_open_cached(data); 1482 goto out; 1483 } 1484 1485 ret = -EAGAIN; 1486 if (!(data->f_attr.valid & NFS_ATTR_FATTR)) 1487 goto err; 1488 inode = nfs_fhget(data->dir->d_sb, &data->o_res.fh, &data->f_attr, data->f_label); 1489 ret = PTR_ERR(inode); 1490 if (IS_ERR(inode)) 1491 goto err; 1492 ret = -ENOMEM; 1493 state = nfs4_get_open_state(inode, data->owner); 1494 if (state == NULL) 1495 goto err_put_inode; 1496 if (data->o_res.delegation_type != 0) 1497 nfs4_opendata_check_deleg(data, state); 1498 update_open_stateid(state, &data->o_res.stateid, NULL, 1499 data->o_arg.fmode); 1500 iput(inode); 1501 out: 1502 nfs_release_seqid(data->o_arg.seqid); 1503 return state; 1504 err_put_inode: 1505 iput(inode); 1506 err: 1507 return ERR_PTR(ret); 1508 } 1509 1510 static struct nfs4_state * 1511 nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data) 1512 { 1513 if (data->o_arg.claim == NFS4_OPEN_CLAIM_PREVIOUS) 1514 return _nfs4_opendata_reclaim_to_nfs4_state(data); 1515 return _nfs4_opendata_to_nfs4_state(data); 1516 } 1517 1518 static struct nfs_open_context *nfs4_state_find_open_context(struct nfs4_state *state) 1519 { 1520 struct nfs_inode *nfsi = NFS_I(state->inode); 1521 struct nfs_open_context *ctx; 1522 1523 spin_lock(&state->inode->i_lock); 1524 list_for_each_entry(ctx, &nfsi->open_files, list) { 1525 if (ctx->state != state) 1526 continue; 1527 get_nfs_open_context(ctx); 1528 spin_unlock(&state->inode->i_lock); 1529 return ctx; 1530 } 1531 spin_unlock(&state->inode->i_lock); 1532 return ERR_PTR(-ENOENT); 1533 } 1534 1535 static struct nfs4_opendata *nfs4_open_recoverdata_alloc(struct nfs_open_context *ctx, 1536 struct nfs4_state *state, enum open_claim_type4 claim) 1537 { 1538 struct nfs4_opendata *opendata; 1539 1540 opendata = nfs4_opendata_alloc(ctx->dentry, state->owner, 0, 0, 1541 NULL, NULL, claim, GFP_NOFS); 1542 if (opendata == NULL) 1543 return ERR_PTR(-ENOMEM); 1544 opendata->state = state; 1545 atomic_inc(&state->count); 1546 return opendata; 1547 } 1548 1549 static int nfs4_open_recover_helper(struct nfs4_opendata *opendata, fmode_t fmode, struct nfs4_state **res) 1550 { 1551 struct nfs4_state *newstate; 1552 int ret; 1553 1554 opendata->o_arg.open_flags = 0; 1555 opendata->o_arg.fmode = fmode; 1556 opendata->o_arg.share_access = nfs4_map_atomic_open_share( 1557 NFS_SB(opendata->dentry->d_sb), 1558 fmode, 0); 1559 memset(&opendata->o_res, 0, sizeof(opendata->o_res)); 1560 memset(&opendata->c_res, 0, sizeof(opendata->c_res)); 1561 nfs4_init_opendata_res(opendata); 1562 ret = _nfs4_recover_proc_open(opendata); 1563 if (ret != 0) 1564 return ret; 1565 newstate = nfs4_opendata_to_nfs4_state(opendata); 1566 if (IS_ERR(newstate)) 1567 return PTR_ERR(newstate); 1568 nfs4_close_state(newstate, fmode); 1569 *res = newstate; 1570 return 0; 1571 } 1572 1573 static int nfs4_open_recover(struct nfs4_opendata *opendata, struct nfs4_state *state) 1574 { 1575 struct nfs4_state *newstate; 1576 int ret; 1577 1578 /* Don't trigger recovery in nfs_test_and_clear_all_open_stateid */ 1579 clear_bit(NFS_O_RDWR_STATE, &state->flags); 1580 clear_bit(NFS_O_WRONLY_STATE, &state->flags); 1581 clear_bit(NFS_O_RDONLY_STATE, &state->flags); 1582 /* memory barrier prior to reading state->n_* */ 1583 clear_bit(NFS_DELEGATED_STATE, &state->flags); 1584 clear_bit(NFS_OPEN_STATE, &state->flags); 1585 smp_rmb(); 1586 if (state->n_rdwr != 0) { 1587 ret = nfs4_open_recover_helper(opendata, FMODE_READ|FMODE_WRITE, &newstate); 1588 if (ret != 0) 1589 return ret; 1590 if (newstate != state) 1591 return -ESTALE; 1592 } 1593 if (state->n_wronly != 0) { 1594 ret = nfs4_open_recover_helper(opendata, FMODE_WRITE, &newstate); 1595 if (ret != 0) 1596 return ret; 1597 if (newstate != state) 1598 return -ESTALE; 1599 } 1600 if (state->n_rdonly != 0) { 1601 ret = nfs4_open_recover_helper(opendata, FMODE_READ, &newstate); 1602 if (ret != 0) 1603 return ret; 1604 if (newstate != state) 1605 return -ESTALE; 1606 } 1607 /* 1608 * We may have performed cached opens for all three recoveries. 1609 * Check if we need to update the current stateid. 1610 */ 1611 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0 && 1612 !nfs4_stateid_match(&state->stateid, &state->open_stateid)) { 1613 write_seqlock(&state->seqlock); 1614 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) 1615 nfs4_stateid_copy(&state->stateid, &state->open_stateid); 1616 write_sequnlock(&state->seqlock); 1617 } 1618 return 0; 1619 } 1620 1621 /* 1622 * OPEN_RECLAIM: 1623 * reclaim state on the server after a reboot. 1624 */ 1625 static int _nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state) 1626 { 1627 struct nfs_delegation *delegation; 1628 struct nfs4_opendata *opendata; 1629 fmode_t delegation_type = 0; 1630 int status; 1631 1632 opendata = nfs4_open_recoverdata_alloc(ctx, state, 1633 NFS4_OPEN_CLAIM_PREVIOUS); 1634 if (IS_ERR(opendata)) 1635 return PTR_ERR(opendata); 1636 rcu_read_lock(); 1637 delegation = rcu_dereference(NFS_I(state->inode)->delegation); 1638 if (delegation != NULL && test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags) != 0) 1639 delegation_type = delegation->type; 1640 rcu_read_unlock(); 1641 opendata->o_arg.u.delegation_type = delegation_type; 1642 status = nfs4_open_recover(opendata, state); 1643 nfs4_opendata_put(opendata); 1644 return status; 1645 } 1646 1647 static int nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state) 1648 { 1649 struct nfs_server *server = NFS_SERVER(state->inode); 1650 struct nfs4_exception exception = { }; 1651 int err; 1652 do { 1653 err = _nfs4_do_open_reclaim(ctx, state); 1654 trace_nfs4_open_reclaim(ctx, 0, err); 1655 if (nfs4_clear_cap_atomic_open_v1(server, err, &exception)) 1656 continue; 1657 if (err != -NFS4ERR_DELAY) 1658 break; 1659 nfs4_handle_exception(server, err, &exception); 1660 } while (exception.retry); 1661 return err; 1662 } 1663 1664 static int nfs4_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *state) 1665 { 1666 struct nfs_open_context *ctx; 1667 int ret; 1668 1669 ctx = nfs4_state_find_open_context(state); 1670 if (IS_ERR(ctx)) 1671 return -EAGAIN; 1672 ret = nfs4_do_open_reclaim(ctx, state); 1673 put_nfs_open_context(ctx); 1674 return ret; 1675 } 1676 1677 static int nfs4_handle_delegation_recall_error(struct nfs_server *server, struct nfs4_state *state, const nfs4_stateid *stateid, int err) 1678 { 1679 switch (err) { 1680 default: 1681 printk(KERN_ERR "NFS: %s: unhandled error " 1682 "%d.\n", __func__, err); 1683 case 0: 1684 case -ENOENT: 1685 case -ESTALE: 1686 break; 1687 case -NFS4ERR_BADSESSION: 1688 case -NFS4ERR_BADSLOT: 1689 case -NFS4ERR_BAD_HIGH_SLOT: 1690 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 1691 case -NFS4ERR_DEADSESSION: 1692 set_bit(NFS_DELEGATED_STATE, &state->flags); 1693 nfs4_schedule_session_recovery(server->nfs_client->cl_session, err); 1694 return -EAGAIN; 1695 case -NFS4ERR_STALE_CLIENTID: 1696 case -NFS4ERR_STALE_STATEID: 1697 set_bit(NFS_DELEGATED_STATE, &state->flags); 1698 case -NFS4ERR_EXPIRED: 1699 /* Don't recall a delegation if it was lost */ 1700 nfs4_schedule_lease_recovery(server->nfs_client); 1701 return -EAGAIN; 1702 case -NFS4ERR_MOVED: 1703 nfs4_schedule_migration_recovery(server); 1704 return -EAGAIN; 1705 case -NFS4ERR_LEASE_MOVED: 1706 nfs4_schedule_lease_moved_recovery(server->nfs_client); 1707 return -EAGAIN; 1708 case -NFS4ERR_DELEG_REVOKED: 1709 case -NFS4ERR_ADMIN_REVOKED: 1710 case -NFS4ERR_BAD_STATEID: 1711 case -NFS4ERR_OPENMODE: 1712 nfs_inode_find_state_and_recover(state->inode, 1713 stateid); 1714 nfs4_schedule_stateid_recovery(server, state); 1715 return -EAGAIN; 1716 case -NFS4ERR_DELAY: 1717 case -NFS4ERR_GRACE: 1718 set_bit(NFS_DELEGATED_STATE, &state->flags); 1719 ssleep(1); 1720 return -EAGAIN; 1721 case -ENOMEM: 1722 case -NFS4ERR_DENIED: 1723 /* kill_proc(fl->fl_pid, SIGLOST, 1); */ 1724 return 0; 1725 } 1726 return err; 1727 } 1728 1729 int nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid) 1730 { 1731 struct nfs_server *server = NFS_SERVER(state->inode); 1732 struct nfs4_opendata *opendata; 1733 int err; 1734 1735 opendata = nfs4_open_recoverdata_alloc(ctx, state, 1736 NFS4_OPEN_CLAIM_DELEG_CUR_FH); 1737 if (IS_ERR(opendata)) 1738 return PTR_ERR(opendata); 1739 nfs4_stateid_copy(&opendata->o_arg.u.delegation, stateid); 1740 err = nfs4_open_recover(opendata, state); 1741 nfs4_opendata_put(opendata); 1742 return nfs4_handle_delegation_recall_error(server, state, stateid, err); 1743 } 1744 1745 static void nfs4_open_confirm_prepare(struct rpc_task *task, void *calldata) 1746 { 1747 struct nfs4_opendata *data = calldata; 1748 1749 nfs40_setup_sequence(data->o_arg.server->nfs_client->cl_slot_tbl, 1750 &data->c_arg.seq_args, &data->c_res.seq_res, task); 1751 } 1752 1753 static void nfs4_open_confirm_done(struct rpc_task *task, void *calldata) 1754 { 1755 struct nfs4_opendata *data = calldata; 1756 1757 nfs40_sequence_done(task, &data->c_res.seq_res); 1758 1759 data->rpc_status = task->tk_status; 1760 if (data->rpc_status == 0) { 1761 nfs4_stateid_copy(&data->o_res.stateid, &data->c_res.stateid); 1762 nfs_confirm_seqid(&data->owner->so_seqid, 0); 1763 renew_lease(data->o_res.server, data->timestamp); 1764 data->rpc_done = 1; 1765 } 1766 } 1767 1768 static void nfs4_open_confirm_release(void *calldata) 1769 { 1770 struct nfs4_opendata *data = calldata; 1771 struct nfs4_state *state = NULL; 1772 1773 /* If this request hasn't been cancelled, do nothing */ 1774 if (data->cancelled == 0) 1775 goto out_free; 1776 /* In case of error, no cleanup! */ 1777 if (!data->rpc_done) 1778 goto out_free; 1779 state = nfs4_opendata_to_nfs4_state(data); 1780 if (!IS_ERR(state)) 1781 nfs4_close_state(state, data->o_arg.fmode); 1782 out_free: 1783 nfs4_opendata_put(data); 1784 } 1785 1786 static const struct rpc_call_ops nfs4_open_confirm_ops = { 1787 .rpc_call_prepare = nfs4_open_confirm_prepare, 1788 .rpc_call_done = nfs4_open_confirm_done, 1789 .rpc_release = nfs4_open_confirm_release, 1790 }; 1791 1792 /* 1793 * Note: On error, nfs4_proc_open_confirm will free the struct nfs4_opendata 1794 */ 1795 static int _nfs4_proc_open_confirm(struct nfs4_opendata *data) 1796 { 1797 struct nfs_server *server = NFS_SERVER(data->dir->d_inode); 1798 struct rpc_task *task; 1799 struct rpc_message msg = { 1800 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_CONFIRM], 1801 .rpc_argp = &data->c_arg, 1802 .rpc_resp = &data->c_res, 1803 .rpc_cred = data->owner->so_cred, 1804 }; 1805 struct rpc_task_setup task_setup_data = { 1806 .rpc_client = server->client, 1807 .rpc_message = &msg, 1808 .callback_ops = &nfs4_open_confirm_ops, 1809 .callback_data = data, 1810 .workqueue = nfsiod_workqueue, 1811 .flags = RPC_TASK_ASYNC, 1812 }; 1813 int status; 1814 1815 nfs4_init_sequence(&data->c_arg.seq_args, &data->c_res.seq_res, 1); 1816 kref_get(&data->kref); 1817 data->rpc_done = 0; 1818 data->rpc_status = 0; 1819 data->timestamp = jiffies; 1820 task = rpc_run_task(&task_setup_data); 1821 if (IS_ERR(task)) 1822 return PTR_ERR(task); 1823 status = nfs4_wait_for_completion_rpc_task(task); 1824 if (status != 0) { 1825 data->cancelled = 1; 1826 smp_wmb(); 1827 } else 1828 status = data->rpc_status; 1829 rpc_put_task(task); 1830 return status; 1831 } 1832 1833 static void nfs4_open_prepare(struct rpc_task *task, void *calldata) 1834 { 1835 struct nfs4_opendata *data = calldata; 1836 struct nfs4_state_owner *sp = data->owner; 1837 struct nfs_client *clp = sp->so_server->nfs_client; 1838 1839 if (nfs_wait_on_sequence(data->o_arg.seqid, task) != 0) 1840 goto out_wait; 1841 /* 1842 * Check if we still need to send an OPEN call, or if we can use 1843 * a delegation instead. 1844 */ 1845 if (data->state != NULL) { 1846 struct nfs_delegation *delegation; 1847 1848 if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags)) 1849 goto out_no_action; 1850 rcu_read_lock(); 1851 delegation = rcu_dereference(NFS_I(data->state->inode)->delegation); 1852 if (data->o_arg.claim != NFS4_OPEN_CLAIM_DELEGATE_CUR && 1853 data->o_arg.claim != NFS4_OPEN_CLAIM_DELEG_CUR_FH && 1854 can_open_delegated(delegation, data->o_arg.fmode)) 1855 goto unlock_no_action; 1856 rcu_read_unlock(); 1857 } 1858 /* Update client id. */ 1859 data->o_arg.clientid = clp->cl_clientid; 1860 switch (data->o_arg.claim) { 1861 case NFS4_OPEN_CLAIM_PREVIOUS: 1862 case NFS4_OPEN_CLAIM_DELEG_CUR_FH: 1863 case NFS4_OPEN_CLAIM_DELEG_PREV_FH: 1864 data->o_arg.open_bitmap = &nfs4_open_noattr_bitmap[0]; 1865 case NFS4_OPEN_CLAIM_FH: 1866 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_NOATTR]; 1867 nfs_copy_fh(&data->o_res.fh, data->o_arg.fh); 1868 } 1869 data->timestamp = jiffies; 1870 if (nfs4_setup_sequence(data->o_arg.server, 1871 &data->o_arg.seq_args, 1872 &data->o_res.seq_res, 1873 task) != 0) 1874 nfs_release_seqid(data->o_arg.seqid); 1875 1876 /* Set the create mode (note dependency on the session type) */ 1877 data->o_arg.createmode = NFS4_CREATE_UNCHECKED; 1878 if (data->o_arg.open_flags & O_EXCL) { 1879 data->o_arg.createmode = NFS4_CREATE_EXCLUSIVE; 1880 if (nfs4_has_persistent_session(clp)) 1881 data->o_arg.createmode = NFS4_CREATE_GUARDED; 1882 else if (clp->cl_mvops->minor_version > 0) 1883 data->o_arg.createmode = NFS4_CREATE_EXCLUSIVE4_1; 1884 } 1885 return; 1886 unlock_no_action: 1887 rcu_read_unlock(); 1888 out_no_action: 1889 task->tk_action = NULL; 1890 out_wait: 1891 nfs4_sequence_done(task, &data->o_res.seq_res); 1892 } 1893 1894 static void nfs4_open_done(struct rpc_task *task, void *calldata) 1895 { 1896 struct nfs4_opendata *data = calldata; 1897 1898 data->rpc_status = task->tk_status; 1899 1900 if (!nfs4_sequence_done(task, &data->o_res.seq_res)) 1901 return; 1902 1903 if (task->tk_status == 0) { 1904 if (data->o_res.f_attr->valid & NFS_ATTR_FATTR_TYPE) { 1905 switch (data->o_res.f_attr->mode & S_IFMT) { 1906 case S_IFREG: 1907 break; 1908 case S_IFLNK: 1909 data->rpc_status = -ELOOP; 1910 break; 1911 case S_IFDIR: 1912 data->rpc_status = -EISDIR; 1913 break; 1914 default: 1915 data->rpc_status = -ENOTDIR; 1916 } 1917 } 1918 renew_lease(data->o_res.server, data->timestamp); 1919 if (!(data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM)) 1920 nfs_confirm_seqid(&data->owner->so_seqid, 0); 1921 } 1922 data->rpc_done = 1; 1923 } 1924 1925 static void nfs4_open_release(void *calldata) 1926 { 1927 struct nfs4_opendata *data = calldata; 1928 struct nfs4_state *state = NULL; 1929 1930 /* If this request hasn't been cancelled, do nothing */ 1931 if (data->cancelled == 0) 1932 goto out_free; 1933 /* In case of error, no cleanup! */ 1934 if (data->rpc_status != 0 || !data->rpc_done) 1935 goto out_free; 1936 /* In case we need an open_confirm, no cleanup! */ 1937 if (data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM) 1938 goto out_free; 1939 state = nfs4_opendata_to_nfs4_state(data); 1940 if (!IS_ERR(state)) 1941 nfs4_close_state(state, data->o_arg.fmode); 1942 out_free: 1943 nfs4_opendata_put(data); 1944 } 1945 1946 static const struct rpc_call_ops nfs4_open_ops = { 1947 .rpc_call_prepare = nfs4_open_prepare, 1948 .rpc_call_done = nfs4_open_done, 1949 .rpc_release = nfs4_open_release, 1950 }; 1951 1952 static int nfs4_run_open_task(struct nfs4_opendata *data, int isrecover) 1953 { 1954 struct inode *dir = data->dir->d_inode; 1955 struct nfs_server *server = NFS_SERVER(dir); 1956 struct nfs_openargs *o_arg = &data->o_arg; 1957 struct nfs_openres *o_res = &data->o_res; 1958 struct rpc_task *task; 1959 struct rpc_message msg = { 1960 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN], 1961 .rpc_argp = o_arg, 1962 .rpc_resp = o_res, 1963 .rpc_cred = data->owner->so_cred, 1964 }; 1965 struct rpc_task_setup task_setup_data = { 1966 .rpc_client = server->client, 1967 .rpc_message = &msg, 1968 .callback_ops = &nfs4_open_ops, 1969 .callback_data = data, 1970 .workqueue = nfsiod_workqueue, 1971 .flags = RPC_TASK_ASYNC, 1972 }; 1973 int status; 1974 1975 nfs4_init_sequence(&o_arg->seq_args, &o_res->seq_res, 1); 1976 kref_get(&data->kref); 1977 data->rpc_done = 0; 1978 data->rpc_status = 0; 1979 data->cancelled = 0; 1980 data->is_recover = 0; 1981 if (isrecover) { 1982 nfs4_set_sequence_privileged(&o_arg->seq_args); 1983 data->is_recover = 1; 1984 } 1985 task = rpc_run_task(&task_setup_data); 1986 if (IS_ERR(task)) 1987 return PTR_ERR(task); 1988 status = nfs4_wait_for_completion_rpc_task(task); 1989 if (status != 0) { 1990 data->cancelled = 1; 1991 smp_wmb(); 1992 } else 1993 status = data->rpc_status; 1994 rpc_put_task(task); 1995 1996 return status; 1997 } 1998 1999 static int _nfs4_recover_proc_open(struct nfs4_opendata *data) 2000 { 2001 struct inode *dir = data->dir->d_inode; 2002 struct nfs_openres *o_res = &data->o_res; 2003 int status; 2004 2005 status = nfs4_run_open_task(data, 1); 2006 if (status != 0 || !data->rpc_done) 2007 return status; 2008 2009 nfs_fattr_map_and_free_names(NFS_SERVER(dir), &data->f_attr); 2010 2011 if (o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) { 2012 status = _nfs4_proc_open_confirm(data); 2013 if (status != 0) 2014 return status; 2015 } 2016 2017 return status; 2018 } 2019 2020 /* 2021 * Additional permission checks in order to distinguish between an 2022 * open for read, and an open for execute. This works around the 2023 * fact that NFSv4 OPEN treats read and execute permissions as being 2024 * the same. 2025 * Note that in the non-execute case, we want to turn off permission 2026 * checking if we just created a new file (POSIX open() semantics). 2027 */ 2028 static int nfs4_opendata_access(struct rpc_cred *cred, 2029 struct nfs4_opendata *opendata, 2030 struct nfs4_state *state, fmode_t fmode, 2031 int openflags) 2032 { 2033 struct nfs_access_entry cache; 2034 u32 mask; 2035 2036 /* access call failed or for some reason the server doesn't 2037 * support any access modes -- defer access call until later */ 2038 if (opendata->o_res.access_supported == 0) 2039 return 0; 2040 2041 mask = 0; 2042 /* 2043 * Use openflags to check for exec, because fmode won't 2044 * always have FMODE_EXEC set when file open for exec. 2045 */ 2046 if (openflags & __FMODE_EXEC) { 2047 /* ONLY check for exec rights */ 2048 mask = MAY_EXEC; 2049 } else if ((fmode & FMODE_READ) && !opendata->file_created) 2050 mask = MAY_READ; 2051 2052 cache.cred = cred; 2053 cache.jiffies = jiffies; 2054 nfs_access_set_mask(&cache, opendata->o_res.access_result); 2055 nfs_access_add_cache(state->inode, &cache); 2056 2057 if ((mask & ~cache.mask & (MAY_READ | MAY_EXEC)) == 0) 2058 return 0; 2059 2060 /* even though OPEN succeeded, access is denied. Close the file */ 2061 nfs4_close_state(state, fmode); 2062 return -EACCES; 2063 } 2064 2065 /* 2066 * Note: On error, nfs4_proc_open will free the struct nfs4_opendata 2067 */ 2068 static int _nfs4_proc_open(struct nfs4_opendata *data) 2069 { 2070 struct inode *dir = data->dir->d_inode; 2071 struct nfs_server *server = NFS_SERVER(dir); 2072 struct nfs_openargs *o_arg = &data->o_arg; 2073 struct nfs_openres *o_res = &data->o_res; 2074 int status; 2075 2076 status = nfs4_run_open_task(data, 0); 2077 if (!data->rpc_done) 2078 return status; 2079 if (status != 0) { 2080 if (status == -NFS4ERR_BADNAME && 2081 !(o_arg->open_flags & O_CREAT)) 2082 return -ENOENT; 2083 return status; 2084 } 2085 2086 nfs_fattr_map_and_free_names(server, &data->f_attr); 2087 2088 if (o_arg->open_flags & O_CREAT) { 2089 update_changeattr(dir, &o_res->cinfo); 2090 if (o_arg->open_flags & O_EXCL) 2091 data->file_created = 1; 2092 else if (o_res->cinfo.before != o_res->cinfo.after) 2093 data->file_created = 1; 2094 } 2095 if ((o_res->rflags & NFS4_OPEN_RESULT_LOCKTYPE_POSIX) == 0) 2096 server->caps &= ~NFS_CAP_POSIX_LOCK; 2097 if(o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) { 2098 status = _nfs4_proc_open_confirm(data); 2099 if (status != 0) 2100 return status; 2101 } 2102 if (!(o_res->f_attr->valid & NFS_ATTR_FATTR)) 2103 nfs4_proc_getattr(server, &o_res->fh, o_res->f_attr, o_res->f_label); 2104 return 0; 2105 } 2106 2107 static int nfs4_recover_expired_lease(struct nfs_server *server) 2108 { 2109 return nfs4_client_recover_expired_lease(server->nfs_client); 2110 } 2111 2112 /* 2113 * OPEN_EXPIRED: 2114 * reclaim state on the server after a network partition. 2115 * Assumes caller holds the appropriate lock 2116 */ 2117 static int _nfs4_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state) 2118 { 2119 struct nfs4_opendata *opendata; 2120 int ret; 2121 2122 opendata = nfs4_open_recoverdata_alloc(ctx, state, 2123 NFS4_OPEN_CLAIM_FH); 2124 if (IS_ERR(opendata)) 2125 return PTR_ERR(opendata); 2126 ret = nfs4_open_recover(opendata, state); 2127 if (ret == -ESTALE) 2128 d_drop(ctx->dentry); 2129 nfs4_opendata_put(opendata); 2130 return ret; 2131 } 2132 2133 static int nfs4_do_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state) 2134 { 2135 struct nfs_server *server = NFS_SERVER(state->inode); 2136 struct nfs4_exception exception = { }; 2137 int err; 2138 2139 do { 2140 err = _nfs4_open_expired(ctx, state); 2141 trace_nfs4_open_expired(ctx, 0, err); 2142 if (nfs4_clear_cap_atomic_open_v1(server, err, &exception)) 2143 continue; 2144 switch (err) { 2145 default: 2146 goto out; 2147 case -NFS4ERR_GRACE: 2148 case -NFS4ERR_DELAY: 2149 nfs4_handle_exception(server, err, &exception); 2150 err = 0; 2151 } 2152 } while (exception.retry); 2153 out: 2154 return err; 2155 } 2156 2157 static int nfs4_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state) 2158 { 2159 struct nfs_open_context *ctx; 2160 int ret; 2161 2162 ctx = nfs4_state_find_open_context(state); 2163 if (IS_ERR(ctx)) 2164 return -EAGAIN; 2165 ret = nfs4_do_open_expired(ctx, state); 2166 put_nfs_open_context(ctx); 2167 return ret; 2168 } 2169 2170 static void nfs_finish_clear_delegation_stateid(struct nfs4_state *state) 2171 { 2172 nfs_remove_bad_delegation(state->inode); 2173 write_seqlock(&state->seqlock); 2174 nfs4_stateid_copy(&state->stateid, &state->open_stateid); 2175 write_sequnlock(&state->seqlock); 2176 clear_bit(NFS_DELEGATED_STATE, &state->flags); 2177 } 2178 2179 static void nfs40_clear_delegation_stateid(struct nfs4_state *state) 2180 { 2181 if (rcu_access_pointer(NFS_I(state->inode)->delegation) != NULL) 2182 nfs_finish_clear_delegation_stateid(state); 2183 } 2184 2185 static int nfs40_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state) 2186 { 2187 /* NFSv4.0 doesn't allow for delegation recovery on open expire */ 2188 nfs40_clear_delegation_stateid(state); 2189 return nfs4_open_expired(sp, state); 2190 } 2191 2192 #if defined(CONFIG_NFS_V4_1) 2193 static void nfs41_check_delegation_stateid(struct nfs4_state *state) 2194 { 2195 struct nfs_server *server = NFS_SERVER(state->inode); 2196 nfs4_stateid stateid; 2197 struct nfs_delegation *delegation; 2198 struct rpc_cred *cred; 2199 int status; 2200 2201 /* Get the delegation credential for use by test/free_stateid */ 2202 rcu_read_lock(); 2203 delegation = rcu_dereference(NFS_I(state->inode)->delegation); 2204 if (delegation == NULL) { 2205 rcu_read_unlock(); 2206 return; 2207 } 2208 2209 nfs4_stateid_copy(&stateid, &delegation->stateid); 2210 cred = get_rpccred(delegation->cred); 2211 rcu_read_unlock(); 2212 status = nfs41_test_stateid(server, &stateid, cred); 2213 trace_nfs4_test_delegation_stateid(state, NULL, status); 2214 2215 if (status != NFS_OK) { 2216 /* Free the stateid unless the server explicitly 2217 * informs us the stateid is unrecognized. */ 2218 if (status != -NFS4ERR_BAD_STATEID) 2219 nfs41_free_stateid(server, &stateid, cred); 2220 nfs_finish_clear_delegation_stateid(state); 2221 } 2222 2223 put_rpccred(cred); 2224 } 2225 2226 /** 2227 * nfs41_check_open_stateid - possibly free an open stateid 2228 * 2229 * @state: NFSv4 state for an inode 2230 * 2231 * Returns NFS_OK if recovery for this stateid is now finished. 2232 * Otherwise a negative NFS4ERR value is returned. 2233 */ 2234 static int nfs41_check_open_stateid(struct nfs4_state *state) 2235 { 2236 struct nfs_server *server = NFS_SERVER(state->inode); 2237 nfs4_stateid *stateid = &state->open_stateid; 2238 struct rpc_cred *cred = state->owner->so_cred; 2239 int status; 2240 2241 /* If a state reset has been done, test_stateid is unneeded */ 2242 if ((test_bit(NFS_O_RDONLY_STATE, &state->flags) == 0) && 2243 (test_bit(NFS_O_WRONLY_STATE, &state->flags) == 0) && 2244 (test_bit(NFS_O_RDWR_STATE, &state->flags) == 0)) 2245 return -NFS4ERR_BAD_STATEID; 2246 2247 status = nfs41_test_stateid(server, stateid, cred); 2248 trace_nfs4_test_open_stateid(state, NULL, status); 2249 if (status != NFS_OK) { 2250 /* Free the stateid unless the server explicitly 2251 * informs us the stateid is unrecognized. */ 2252 if (status != -NFS4ERR_BAD_STATEID) 2253 nfs41_free_stateid(server, stateid, cred); 2254 2255 clear_bit(NFS_O_RDONLY_STATE, &state->flags); 2256 clear_bit(NFS_O_WRONLY_STATE, &state->flags); 2257 clear_bit(NFS_O_RDWR_STATE, &state->flags); 2258 clear_bit(NFS_OPEN_STATE, &state->flags); 2259 } 2260 return status; 2261 } 2262 2263 static int nfs41_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state) 2264 { 2265 int status; 2266 2267 nfs41_check_delegation_stateid(state); 2268 status = nfs41_check_open_stateid(state); 2269 if (status != NFS_OK) 2270 status = nfs4_open_expired(sp, state); 2271 return status; 2272 } 2273 #endif 2274 2275 /* 2276 * on an EXCLUSIVE create, the server should send back a bitmask with FATTR4-* 2277 * fields corresponding to attributes that were used to store the verifier. 2278 * Make sure we clobber those fields in the later setattr call 2279 */ 2280 static inline void nfs4_exclusive_attrset(struct nfs4_opendata *opendata, struct iattr *sattr) 2281 { 2282 if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_ACCESS) && 2283 !(sattr->ia_valid & ATTR_ATIME_SET)) 2284 sattr->ia_valid |= ATTR_ATIME; 2285 2286 if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_MODIFY) && 2287 !(sattr->ia_valid & ATTR_MTIME_SET)) 2288 sattr->ia_valid |= ATTR_MTIME; 2289 } 2290 2291 static int _nfs4_open_and_get_state(struct nfs4_opendata *opendata, 2292 fmode_t fmode, 2293 int flags, 2294 struct nfs_open_context *ctx) 2295 { 2296 struct nfs4_state_owner *sp = opendata->owner; 2297 struct nfs_server *server = sp->so_server; 2298 struct dentry *dentry; 2299 struct nfs4_state *state; 2300 unsigned int seq; 2301 int ret; 2302 2303 seq = raw_seqcount_begin(&sp->so_reclaim_seqcount); 2304 2305 ret = _nfs4_proc_open(opendata); 2306 if (ret != 0) 2307 goto out; 2308 2309 state = nfs4_opendata_to_nfs4_state(opendata); 2310 ret = PTR_ERR(state); 2311 if (IS_ERR(state)) 2312 goto out; 2313 if (server->caps & NFS_CAP_POSIX_LOCK) 2314 set_bit(NFS_STATE_POSIX_LOCKS, &state->flags); 2315 2316 dentry = opendata->dentry; 2317 if (dentry->d_inode == NULL) { 2318 /* FIXME: Is this d_drop() ever needed? */ 2319 d_drop(dentry); 2320 dentry = d_add_unique(dentry, igrab(state->inode)); 2321 if (dentry == NULL) { 2322 dentry = opendata->dentry; 2323 } else if (dentry != ctx->dentry) { 2324 dput(ctx->dentry); 2325 ctx->dentry = dget(dentry); 2326 } 2327 nfs_set_verifier(dentry, 2328 nfs_save_change_attribute(opendata->dir->d_inode)); 2329 } 2330 2331 ret = nfs4_opendata_access(sp->so_cred, opendata, state, fmode, flags); 2332 if (ret != 0) 2333 goto out; 2334 2335 ctx->state = state; 2336 if (dentry->d_inode == state->inode) { 2337 nfs_inode_attach_open_context(ctx); 2338 if (read_seqcount_retry(&sp->so_reclaim_seqcount, seq)) 2339 nfs4_schedule_stateid_recovery(server, state); 2340 } 2341 out: 2342 return ret; 2343 } 2344 2345 /* 2346 * Returns a referenced nfs4_state 2347 */ 2348 static int _nfs4_do_open(struct inode *dir, 2349 struct nfs_open_context *ctx, 2350 int flags, 2351 struct iattr *sattr, 2352 struct nfs4_label *label, 2353 int *opened) 2354 { 2355 struct nfs4_state_owner *sp; 2356 struct nfs4_state *state = NULL; 2357 struct nfs_server *server = NFS_SERVER(dir); 2358 struct nfs4_opendata *opendata; 2359 struct dentry *dentry = ctx->dentry; 2360 struct rpc_cred *cred = ctx->cred; 2361 struct nfs4_threshold **ctx_th = &ctx->mdsthreshold; 2362 fmode_t fmode = ctx->mode & (FMODE_READ|FMODE_WRITE|FMODE_EXEC); 2363 enum open_claim_type4 claim = NFS4_OPEN_CLAIM_NULL; 2364 struct nfs4_label *olabel = NULL; 2365 int status; 2366 2367 /* Protect against reboot recovery conflicts */ 2368 status = -ENOMEM; 2369 sp = nfs4_get_state_owner(server, cred, GFP_KERNEL); 2370 if (sp == NULL) { 2371 dprintk("nfs4_do_open: nfs4_get_state_owner failed!\n"); 2372 goto out_err; 2373 } 2374 status = nfs4_recover_expired_lease(server); 2375 if (status != 0) 2376 goto err_put_state_owner; 2377 if (dentry->d_inode != NULL) 2378 nfs4_return_incompatible_delegation(dentry->d_inode, fmode); 2379 status = -ENOMEM; 2380 if (dentry->d_inode) 2381 claim = NFS4_OPEN_CLAIM_FH; 2382 opendata = nfs4_opendata_alloc(dentry, sp, fmode, flags, sattr, 2383 label, claim, GFP_KERNEL); 2384 if (opendata == NULL) 2385 goto err_put_state_owner; 2386 2387 if (label) { 2388 olabel = nfs4_label_alloc(server, GFP_KERNEL); 2389 if (IS_ERR(olabel)) { 2390 status = PTR_ERR(olabel); 2391 goto err_opendata_put; 2392 } 2393 } 2394 2395 if (server->attr_bitmask[2] & FATTR4_WORD2_MDSTHRESHOLD) { 2396 if (!opendata->f_attr.mdsthreshold) { 2397 opendata->f_attr.mdsthreshold = pnfs_mdsthreshold_alloc(); 2398 if (!opendata->f_attr.mdsthreshold) 2399 goto err_free_label; 2400 } 2401 opendata->o_arg.open_bitmap = &nfs4_pnfs_open_bitmap[0]; 2402 } 2403 if (dentry->d_inode != NULL) 2404 opendata->state = nfs4_get_open_state(dentry->d_inode, sp); 2405 2406 status = _nfs4_open_and_get_state(opendata, fmode, flags, ctx); 2407 if (status != 0) 2408 goto err_free_label; 2409 state = ctx->state; 2410 2411 if ((opendata->o_arg.open_flags & O_EXCL) && 2412 (opendata->o_arg.createmode != NFS4_CREATE_GUARDED)) { 2413 nfs4_exclusive_attrset(opendata, sattr); 2414 2415 nfs_fattr_init(opendata->o_res.f_attr); 2416 status = nfs4_do_setattr(state->inode, cred, 2417 opendata->o_res.f_attr, sattr, 2418 state, label, olabel); 2419 if (status == 0) { 2420 nfs_setattr_update_inode(state->inode, sattr, 2421 opendata->o_res.f_attr); 2422 nfs_setsecurity(state->inode, opendata->o_res.f_attr, olabel); 2423 } 2424 } 2425 if (opendata->file_created) 2426 *opened |= FILE_CREATED; 2427 2428 if (pnfs_use_threshold(ctx_th, opendata->f_attr.mdsthreshold, server)) { 2429 *ctx_th = opendata->f_attr.mdsthreshold; 2430 opendata->f_attr.mdsthreshold = NULL; 2431 } 2432 2433 nfs4_label_free(olabel); 2434 2435 nfs4_opendata_put(opendata); 2436 nfs4_put_state_owner(sp); 2437 return 0; 2438 err_free_label: 2439 nfs4_label_free(olabel); 2440 err_opendata_put: 2441 nfs4_opendata_put(opendata); 2442 err_put_state_owner: 2443 nfs4_put_state_owner(sp); 2444 out_err: 2445 return status; 2446 } 2447 2448 2449 static struct nfs4_state *nfs4_do_open(struct inode *dir, 2450 struct nfs_open_context *ctx, 2451 int flags, 2452 struct iattr *sattr, 2453 struct nfs4_label *label, 2454 int *opened) 2455 { 2456 struct nfs_server *server = NFS_SERVER(dir); 2457 struct nfs4_exception exception = { }; 2458 struct nfs4_state *res; 2459 int status; 2460 2461 do { 2462 status = _nfs4_do_open(dir, ctx, flags, sattr, label, opened); 2463 res = ctx->state; 2464 trace_nfs4_open_file(ctx, flags, status); 2465 if (status == 0) 2466 break; 2467 /* NOTE: BAD_SEQID means the server and client disagree about the 2468 * book-keeping w.r.t. state-changing operations 2469 * (OPEN/CLOSE/LOCK/LOCKU...) 2470 * It is actually a sign of a bug on the client or on the server. 2471 * 2472 * If we receive a BAD_SEQID error in the particular case of 2473 * doing an OPEN, we assume that nfs_increment_open_seqid() will 2474 * have unhashed the old state_owner for us, and that we can 2475 * therefore safely retry using a new one. We should still warn 2476 * the user though... 2477 */ 2478 if (status == -NFS4ERR_BAD_SEQID) { 2479 pr_warn_ratelimited("NFS: v4 server %s " 2480 " returned a bad sequence-id error!\n", 2481 NFS_SERVER(dir)->nfs_client->cl_hostname); 2482 exception.retry = 1; 2483 continue; 2484 } 2485 /* 2486 * BAD_STATEID on OPEN means that the server cancelled our 2487 * state before it received the OPEN_CONFIRM. 2488 * Recover by retrying the request as per the discussion 2489 * on Page 181 of RFC3530. 2490 */ 2491 if (status == -NFS4ERR_BAD_STATEID) { 2492 exception.retry = 1; 2493 continue; 2494 } 2495 if (status == -EAGAIN) { 2496 /* We must have found a delegation */ 2497 exception.retry = 1; 2498 continue; 2499 } 2500 if (nfs4_clear_cap_atomic_open_v1(server, status, &exception)) 2501 continue; 2502 res = ERR_PTR(nfs4_handle_exception(server, 2503 status, &exception)); 2504 } while (exception.retry); 2505 return res; 2506 } 2507 2508 static int _nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred, 2509 struct nfs_fattr *fattr, struct iattr *sattr, 2510 struct nfs4_state *state, struct nfs4_label *ilabel, 2511 struct nfs4_label *olabel) 2512 { 2513 struct nfs_server *server = NFS_SERVER(inode); 2514 struct nfs_setattrargs arg = { 2515 .fh = NFS_FH(inode), 2516 .iap = sattr, 2517 .server = server, 2518 .bitmask = server->attr_bitmask, 2519 .label = ilabel, 2520 }; 2521 struct nfs_setattrres res = { 2522 .fattr = fattr, 2523 .label = olabel, 2524 .server = server, 2525 }; 2526 struct rpc_message msg = { 2527 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETATTR], 2528 .rpc_argp = &arg, 2529 .rpc_resp = &res, 2530 .rpc_cred = cred, 2531 }; 2532 unsigned long timestamp = jiffies; 2533 fmode_t fmode; 2534 bool truncate; 2535 int status; 2536 2537 arg.bitmask = nfs4_bitmask(server, ilabel); 2538 if (ilabel) 2539 arg.bitmask = nfs4_bitmask(server, olabel); 2540 2541 nfs_fattr_init(fattr); 2542 2543 /* Servers should only apply open mode checks for file size changes */ 2544 truncate = (sattr->ia_valid & ATTR_SIZE) ? true : false; 2545 fmode = truncate ? FMODE_WRITE : FMODE_READ; 2546 2547 if (nfs4_copy_delegation_stateid(&arg.stateid, inode, fmode)) { 2548 /* Use that stateid */ 2549 } else if (truncate && state != NULL) { 2550 struct nfs_lockowner lockowner = { 2551 .l_owner = current->files, 2552 .l_pid = current->tgid, 2553 }; 2554 if (!nfs4_valid_open_stateid(state)) 2555 return -EBADF; 2556 if (nfs4_select_rw_stateid(&arg.stateid, state, FMODE_WRITE, 2557 &lockowner) == -EIO) 2558 return -EBADF; 2559 } else 2560 nfs4_stateid_copy(&arg.stateid, &zero_stateid); 2561 2562 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); 2563 if (status == 0 && state != NULL) 2564 renew_lease(server, timestamp); 2565 return status; 2566 } 2567 2568 static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred, 2569 struct nfs_fattr *fattr, struct iattr *sattr, 2570 struct nfs4_state *state, struct nfs4_label *ilabel, 2571 struct nfs4_label *olabel) 2572 { 2573 struct nfs_server *server = NFS_SERVER(inode); 2574 struct nfs4_exception exception = { 2575 .state = state, 2576 .inode = inode, 2577 }; 2578 int err; 2579 do { 2580 err = _nfs4_do_setattr(inode, cred, fattr, sattr, state, ilabel, olabel); 2581 trace_nfs4_setattr(inode, err); 2582 switch (err) { 2583 case -NFS4ERR_OPENMODE: 2584 if (!(sattr->ia_valid & ATTR_SIZE)) { 2585 pr_warn_once("NFSv4: server %s is incorrectly " 2586 "applying open mode checks to " 2587 "a SETATTR that is not " 2588 "changing file size.\n", 2589 server->nfs_client->cl_hostname); 2590 } 2591 if (state && !(state->state & FMODE_WRITE)) { 2592 err = -EBADF; 2593 if (sattr->ia_valid & ATTR_OPEN) 2594 err = -EACCES; 2595 goto out; 2596 } 2597 } 2598 err = nfs4_handle_exception(server, err, &exception); 2599 } while (exception.retry); 2600 out: 2601 return err; 2602 } 2603 2604 struct nfs4_closedata { 2605 struct inode *inode; 2606 struct nfs4_state *state; 2607 struct nfs_closeargs arg; 2608 struct nfs_closeres res; 2609 struct nfs_fattr fattr; 2610 unsigned long timestamp; 2611 bool roc; 2612 u32 roc_barrier; 2613 }; 2614 2615 static void nfs4_free_closedata(void *data) 2616 { 2617 struct nfs4_closedata *calldata = data; 2618 struct nfs4_state_owner *sp = calldata->state->owner; 2619 struct super_block *sb = calldata->state->inode->i_sb; 2620 2621 if (calldata->roc) 2622 pnfs_roc_release(calldata->state->inode); 2623 nfs4_put_open_state(calldata->state); 2624 nfs_free_seqid(calldata->arg.seqid); 2625 nfs4_put_state_owner(sp); 2626 nfs_sb_deactive(sb); 2627 kfree(calldata); 2628 } 2629 2630 static void nfs4_close_done(struct rpc_task *task, void *data) 2631 { 2632 struct nfs4_closedata *calldata = data; 2633 struct nfs4_state *state = calldata->state; 2634 struct nfs_server *server = NFS_SERVER(calldata->inode); 2635 nfs4_stateid *res_stateid = NULL; 2636 2637 dprintk("%s: begin!\n", __func__); 2638 if (!nfs4_sequence_done(task, &calldata->res.seq_res)) 2639 return; 2640 trace_nfs4_close(state, &calldata->arg, &calldata->res, task->tk_status); 2641 /* hmm. we are done with the inode, and in the process of freeing 2642 * the state_owner. we keep this around to process errors 2643 */ 2644 switch (task->tk_status) { 2645 case 0: 2646 res_stateid = &calldata->res.stateid; 2647 if (calldata->arg.fmode == 0 && calldata->roc) 2648 pnfs_roc_set_barrier(state->inode, 2649 calldata->roc_barrier); 2650 renew_lease(server, calldata->timestamp); 2651 break; 2652 case -NFS4ERR_ADMIN_REVOKED: 2653 case -NFS4ERR_STALE_STATEID: 2654 case -NFS4ERR_OLD_STATEID: 2655 case -NFS4ERR_BAD_STATEID: 2656 case -NFS4ERR_EXPIRED: 2657 if (!nfs4_stateid_match(&calldata->arg.stateid, 2658 &state->open_stateid)) { 2659 rpc_restart_call_prepare(task); 2660 goto out_release; 2661 } 2662 if (calldata->arg.fmode == 0) 2663 break; 2664 default: 2665 if (nfs4_async_handle_error(task, server, state, NULL) == -EAGAIN) { 2666 rpc_restart_call_prepare(task); 2667 goto out_release; 2668 } 2669 } 2670 nfs_clear_open_stateid(state, res_stateid, calldata->arg.fmode); 2671 out_release: 2672 nfs_release_seqid(calldata->arg.seqid); 2673 nfs_refresh_inode(calldata->inode, calldata->res.fattr); 2674 dprintk("%s: done, ret = %d!\n", __func__, task->tk_status); 2675 } 2676 2677 static void nfs4_close_prepare(struct rpc_task *task, void *data) 2678 { 2679 struct nfs4_closedata *calldata = data; 2680 struct nfs4_state *state = calldata->state; 2681 struct inode *inode = calldata->inode; 2682 bool is_rdonly, is_wronly, is_rdwr; 2683 int call_close = 0; 2684 2685 dprintk("%s: begin!\n", __func__); 2686 if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0) 2687 goto out_wait; 2688 2689 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; 2690 spin_lock(&state->owner->so_lock); 2691 is_rdwr = test_bit(NFS_O_RDWR_STATE, &state->flags); 2692 is_rdonly = test_bit(NFS_O_RDONLY_STATE, &state->flags); 2693 is_wronly = test_bit(NFS_O_WRONLY_STATE, &state->flags); 2694 nfs4_stateid_copy(&calldata->arg.stateid, &state->open_stateid); 2695 /* Calculate the change in open mode */ 2696 calldata->arg.fmode = 0; 2697 if (state->n_rdwr == 0) { 2698 if (state->n_rdonly == 0) 2699 call_close |= is_rdonly; 2700 else if (is_rdonly) 2701 calldata->arg.fmode |= FMODE_READ; 2702 if (state->n_wronly == 0) 2703 call_close |= is_wronly; 2704 else if (is_wronly) 2705 calldata->arg.fmode |= FMODE_WRITE; 2706 } else if (is_rdwr) 2707 calldata->arg.fmode |= FMODE_READ|FMODE_WRITE; 2708 2709 if (calldata->arg.fmode == 0) 2710 call_close |= is_rdwr; 2711 2712 if (!nfs4_valid_open_stateid(state)) 2713 call_close = 0; 2714 spin_unlock(&state->owner->so_lock); 2715 2716 if (!call_close) { 2717 /* Note: exit _without_ calling nfs4_close_done */ 2718 goto out_no_action; 2719 } 2720 2721 if (calldata->arg.fmode == 0) { 2722 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE]; 2723 if (calldata->roc && 2724 pnfs_roc_drain(inode, &calldata->roc_barrier, task)) { 2725 nfs_release_seqid(calldata->arg.seqid); 2726 goto out_wait; 2727 } 2728 } 2729 calldata->arg.share_access = 2730 nfs4_map_atomic_open_share(NFS_SERVER(inode), 2731 calldata->arg.fmode, 0); 2732 2733 nfs_fattr_init(calldata->res.fattr); 2734 calldata->timestamp = jiffies; 2735 if (nfs4_setup_sequence(NFS_SERVER(inode), 2736 &calldata->arg.seq_args, 2737 &calldata->res.seq_res, 2738 task) != 0) 2739 nfs_release_seqid(calldata->arg.seqid); 2740 dprintk("%s: done!\n", __func__); 2741 return; 2742 out_no_action: 2743 task->tk_action = NULL; 2744 out_wait: 2745 nfs4_sequence_done(task, &calldata->res.seq_res); 2746 } 2747 2748 static const struct rpc_call_ops nfs4_close_ops = { 2749 .rpc_call_prepare = nfs4_close_prepare, 2750 .rpc_call_done = nfs4_close_done, 2751 .rpc_release = nfs4_free_closedata, 2752 }; 2753 2754 static bool nfs4_roc(struct inode *inode) 2755 { 2756 if (!nfs_have_layout(inode)) 2757 return false; 2758 return pnfs_roc(inode); 2759 } 2760 2761 /* 2762 * It is possible for data to be read/written from a mem-mapped file 2763 * after the sys_close call (which hits the vfs layer as a flush). 2764 * This means that we can't safely call nfsv4 close on a file until 2765 * the inode is cleared. This in turn means that we are not good 2766 * NFSv4 citizens - we do not indicate to the server to update the file's 2767 * share state even when we are done with one of the three share 2768 * stateid's in the inode. 2769 * 2770 * NOTE: Caller must be holding the sp->so_owner semaphore! 2771 */ 2772 int nfs4_do_close(struct nfs4_state *state, gfp_t gfp_mask, int wait) 2773 { 2774 struct nfs_server *server = NFS_SERVER(state->inode); 2775 struct nfs_seqid *(*alloc_seqid)(struct nfs_seqid_counter *, gfp_t); 2776 struct nfs4_closedata *calldata; 2777 struct nfs4_state_owner *sp = state->owner; 2778 struct rpc_task *task; 2779 struct rpc_message msg = { 2780 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE], 2781 .rpc_cred = state->owner->so_cred, 2782 }; 2783 struct rpc_task_setup task_setup_data = { 2784 .rpc_client = server->client, 2785 .rpc_message = &msg, 2786 .callback_ops = &nfs4_close_ops, 2787 .workqueue = nfsiod_workqueue, 2788 .flags = RPC_TASK_ASYNC, 2789 }; 2790 int status = -ENOMEM; 2791 2792 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_CLEANUP, 2793 &task_setup_data.rpc_client, &msg); 2794 2795 calldata = kzalloc(sizeof(*calldata), gfp_mask); 2796 if (calldata == NULL) 2797 goto out; 2798 nfs4_init_sequence(&calldata->arg.seq_args, &calldata->res.seq_res, 1); 2799 calldata->inode = state->inode; 2800 calldata->state = state; 2801 calldata->arg.fh = NFS_FH(state->inode); 2802 /* Serialization for the sequence id */ 2803 alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid; 2804 calldata->arg.seqid = alloc_seqid(&state->owner->so_seqid, gfp_mask); 2805 if (IS_ERR(calldata->arg.seqid)) 2806 goto out_free_calldata; 2807 calldata->arg.fmode = 0; 2808 calldata->arg.bitmask = server->cache_consistency_bitmask; 2809 calldata->res.fattr = &calldata->fattr; 2810 calldata->res.seqid = calldata->arg.seqid; 2811 calldata->res.server = server; 2812 calldata->roc = nfs4_roc(state->inode); 2813 nfs_sb_active(calldata->inode->i_sb); 2814 2815 msg.rpc_argp = &calldata->arg; 2816 msg.rpc_resp = &calldata->res; 2817 task_setup_data.callback_data = calldata; 2818 task = rpc_run_task(&task_setup_data); 2819 if (IS_ERR(task)) 2820 return PTR_ERR(task); 2821 status = 0; 2822 if (wait) 2823 status = rpc_wait_for_completion_task(task); 2824 rpc_put_task(task); 2825 return status; 2826 out_free_calldata: 2827 kfree(calldata); 2828 out: 2829 nfs4_put_open_state(state); 2830 nfs4_put_state_owner(sp); 2831 return status; 2832 } 2833 2834 static struct inode * 2835 nfs4_atomic_open(struct inode *dir, struct nfs_open_context *ctx, 2836 int open_flags, struct iattr *attr, int *opened) 2837 { 2838 struct nfs4_state *state; 2839 struct nfs4_label l = {0, 0, 0, NULL}, *label = NULL; 2840 2841 label = nfs4_label_init_security(dir, ctx->dentry, attr, &l); 2842 2843 /* Protect against concurrent sillydeletes */ 2844 state = nfs4_do_open(dir, ctx, open_flags, attr, label, opened); 2845 2846 nfs4_label_release_security(label); 2847 2848 if (IS_ERR(state)) 2849 return ERR_CAST(state); 2850 return state->inode; 2851 } 2852 2853 static void nfs4_close_context(struct nfs_open_context *ctx, int is_sync) 2854 { 2855 if (ctx->state == NULL) 2856 return; 2857 if (is_sync) 2858 nfs4_close_sync(ctx->state, ctx->mode); 2859 else 2860 nfs4_close_state(ctx->state, ctx->mode); 2861 } 2862 2863 #define FATTR4_WORD1_NFS40_MASK (2*FATTR4_WORD1_MOUNTED_ON_FILEID - 1UL) 2864 #define FATTR4_WORD2_NFS41_MASK (2*FATTR4_WORD2_SUPPATTR_EXCLCREAT - 1UL) 2865 #define FATTR4_WORD2_NFS42_MASK (2*FATTR4_WORD2_SECURITY_LABEL - 1UL) 2866 2867 static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle) 2868 { 2869 struct nfs4_server_caps_arg args = { 2870 .fhandle = fhandle, 2871 }; 2872 struct nfs4_server_caps_res res = {}; 2873 struct rpc_message msg = { 2874 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SERVER_CAPS], 2875 .rpc_argp = &args, 2876 .rpc_resp = &res, 2877 }; 2878 int status; 2879 2880 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); 2881 if (status == 0) { 2882 /* Sanity check the server answers */ 2883 switch (server->nfs_client->cl_minorversion) { 2884 case 0: 2885 res.attr_bitmask[1] &= FATTR4_WORD1_NFS40_MASK; 2886 res.attr_bitmask[2] = 0; 2887 break; 2888 case 1: 2889 res.attr_bitmask[2] &= FATTR4_WORD2_NFS41_MASK; 2890 break; 2891 case 2: 2892 res.attr_bitmask[2] &= FATTR4_WORD2_NFS42_MASK; 2893 } 2894 memcpy(server->attr_bitmask, res.attr_bitmask, sizeof(server->attr_bitmask)); 2895 server->caps &= ~(NFS_CAP_ACLS|NFS_CAP_HARDLINKS| 2896 NFS_CAP_SYMLINKS|NFS_CAP_FILEID| 2897 NFS_CAP_MODE|NFS_CAP_NLINK|NFS_CAP_OWNER| 2898 NFS_CAP_OWNER_GROUP|NFS_CAP_ATIME| 2899 NFS_CAP_CTIME|NFS_CAP_MTIME| 2900 NFS_CAP_SECURITY_LABEL); 2901 if (res.attr_bitmask[0] & FATTR4_WORD0_ACL && 2902 res.acl_bitmask & ACL4_SUPPORT_ALLOW_ACL) 2903 server->caps |= NFS_CAP_ACLS; 2904 if (res.has_links != 0) 2905 server->caps |= NFS_CAP_HARDLINKS; 2906 if (res.has_symlinks != 0) 2907 server->caps |= NFS_CAP_SYMLINKS; 2908 if (res.attr_bitmask[0] & FATTR4_WORD0_FILEID) 2909 server->caps |= NFS_CAP_FILEID; 2910 if (res.attr_bitmask[1] & FATTR4_WORD1_MODE) 2911 server->caps |= NFS_CAP_MODE; 2912 if (res.attr_bitmask[1] & FATTR4_WORD1_NUMLINKS) 2913 server->caps |= NFS_CAP_NLINK; 2914 if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER) 2915 server->caps |= NFS_CAP_OWNER; 2916 if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER_GROUP) 2917 server->caps |= NFS_CAP_OWNER_GROUP; 2918 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_ACCESS) 2919 server->caps |= NFS_CAP_ATIME; 2920 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_METADATA) 2921 server->caps |= NFS_CAP_CTIME; 2922 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_MODIFY) 2923 server->caps |= NFS_CAP_MTIME; 2924 #ifdef CONFIG_NFS_V4_SECURITY_LABEL 2925 if (res.attr_bitmask[2] & FATTR4_WORD2_SECURITY_LABEL) 2926 server->caps |= NFS_CAP_SECURITY_LABEL; 2927 #endif 2928 memcpy(server->attr_bitmask_nl, res.attr_bitmask, 2929 sizeof(server->attr_bitmask)); 2930 server->attr_bitmask_nl[2] &= ~FATTR4_WORD2_SECURITY_LABEL; 2931 2932 memcpy(server->cache_consistency_bitmask, res.attr_bitmask, sizeof(server->cache_consistency_bitmask)); 2933 server->cache_consistency_bitmask[0] &= FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE; 2934 server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY; 2935 server->cache_consistency_bitmask[2] = 0; 2936 server->acl_bitmask = res.acl_bitmask; 2937 server->fh_expire_type = res.fh_expire_type; 2938 } 2939 2940 return status; 2941 } 2942 2943 int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle) 2944 { 2945 struct nfs4_exception exception = { }; 2946 int err; 2947 do { 2948 err = nfs4_handle_exception(server, 2949 _nfs4_server_capabilities(server, fhandle), 2950 &exception); 2951 } while (exception.retry); 2952 return err; 2953 } 2954 2955 static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle, 2956 struct nfs_fsinfo *info) 2957 { 2958 u32 bitmask[3]; 2959 struct nfs4_lookup_root_arg args = { 2960 .bitmask = bitmask, 2961 }; 2962 struct nfs4_lookup_res res = { 2963 .server = server, 2964 .fattr = info->fattr, 2965 .fh = fhandle, 2966 }; 2967 struct rpc_message msg = { 2968 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP_ROOT], 2969 .rpc_argp = &args, 2970 .rpc_resp = &res, 2971 }; 2972 2973 bitmask[0] = nfs4_fattr_bitmap[0]; 2974 bitmask[1] = nfs4_fattr_bitmap[1]; 2975 /* 2976 * Process the label in the upcoming getfattr 2977 */ 2978 bitmask[2] = nfs4_fattr_bitmap[2] & ~FATTR4_WORD2_SECURITY_LABEL; 2979 2980 nfs_fattr_init(info->fattr); 2981 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); 2982 } 2983 2984 static int nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle, 2985 struct nfs_fsinfo *info) 2986 { 2987 struct nfs4_exception exception = { }; 2988 int err; 2989 do { 2990 err = _nfs4_lookup_root(server, fhandle, info); 2991 trace_nfs4_lookup_root(server, fhandle, info->fattr, err); 2992 switch (err) { 2993 case 0: 2994 case -NFS4ERR_WRONGSEC: 2995 goto out; 2996 default: 2997 err = nfs4_handle_exception(server, err, &exception); 2998 } 2999 } while (exception.retry); 3000 out: 3001 return err; 3002 } 3003 3004 static int nfs4_lookup_root_sec(struct nfs_server *server, struct nfs_fh *fhandle, 3005 struct nfs_fsinfo *info, rpc_authflavor_t flavor) 3006 { 3007 struct rpc_auth_create_args auth_args = { 3008 .pseudoflavor = flavor, 3009 }; 3010 struct rpc_auth *auth; 3011 int ret; 3012 3013 auth = rpcauth_create(&auth_args, server->client); 3014 if (IS_ERR(auth)) { 3015 ret = -EACCES; 3016 goto out; 3017 } 3018 ret = nfs4_lookup_root(server, fhandle, info); 3019 out: 3020 return ret; 3021 } 3022 3023 /* 3024 * Retry pseudoroot lookup with various security flavors. We do this when: 3025 * 3026 * NFSv4.0: the PUTROOTFH operation returns NFS4ERR_WRONGSEC 3027 * NFSv4.1: the server does not support the SECINFO_NO_NAME operation 3028 * 3029 * Returns zero on success, or a negative NFS4ERR value, or a 3030 * negative errno value. 3031 */ 3032 static int nfs4_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle, 3033 struct nfs_fsinfo *info) 3034 { 3035 /* Per 3530bis 15.33.5 */ 3036 static const rpc_authflavor_t flav_array[] = { 3037 RPC_AUTH_GSS_KRB5P, 3038 RPC_AUTH_GSS_KRB5I, 3039 RPC_AUTH_GSS_KRB5, 3040 RPC_AUTH_UNIX, /* courtesy */ 3041 RPC_AUTH_NULL, 3042 }; 3043 int status = -EPERM; 3044 size_t i; 3045 3046 if (server->auth_info.flavor_len > 0) { 3047 /* try each flavor specified by user */ 3048 for (i = 0; i < server->auth_info.flavor_len; i++) { 3049 status = nfs4_lookup_root_sec(server, fhandle, info, 3050 server->auth_info.flavors[i]); 3051 if (status == -NFS4ERR_WRONGSEC || status == -EACCES) 3052 continue; 3053 break; 3054 } 3055 } else { 3056 /* no flavors specified by user, try default list */ 3057 for (i = 0; i < ARRAY_SIZE(flav_array); i++) { 3058 status = nfs4_lookup_root_sec(server, fhandle, info, 3059 flav_array[i]); 3060 if (status == -NFS4ERR_WRONGSEC || status == -EACCES) 3061 continue; 3062 break; 3063 } 3064 } 3065 3066 /* 3067 * -EACCESS could mean that the user doesn't have correct permissions 3068 * to access the mount. It could also mean that we tried to mount 3069 * with a gss auth flavor, but rpc.gssd isn't running. Either way, 3070 * existing mount programs don't handle -EACCES very well so it should 3071 * be mapped to -EPERM instead. 3072 */ 3073 if (status == -EACCES) 3074 status = -EPERM; 3075 return status; 3076 } 3077 3078 static int nfs4_do_find_root_sec(struct nfs_server *server, 3079 struct nfs_fh *fhandle, struct nfs_fsinfo *info) 3080 { 3081 int mv = server->nfs_client->cl_minorversion; 3082 return nfs_v4_minor_ops[mv]->find_root_sec(server, fhandle, info); 3083 } 3084 3085 /** 3086 * nfs4_proc_get_rootfh - get file handle for server's pseudoroot 3087 * @server: initialized nfs_server handle 3088 * @fhandle: we fill in the pseudo-fs root file handle 3089 * @info: we fill in an FSINFO struct 3090 * @auth_probe: probe the auth flavours 3091 * 3092 * Returns zero on success, or a negative errno. 3093 */ 3094 int nfs4_proc_get_rootfh(struct nfs_server *server, struct nfs_fh *fhandle, 3095 struct nfs_fsinfo *info, 3096 bool auth_probe) 3097 { 3098 int status; 3099 3100 switch (auth_probe) { 3101 case false: 3102 status = nfs4_lookup_root(server, fhandle, info); 3103 if (status != -NFS4ERR_WRONGSEC) 3104 break; 3105 default: 3106 status = nfs4_do_find_root_sec(server, fhandle, info); 3107 } 3108 3109 if (status == 0) 3110 status = nfs4_server_capabilities(server, fhandle); 3111 if (status == 0) 3112 status = nfs4_do_fsinfo(server, fhandle, info); 3113 3114 return nfs4_map_errors(status); 3115 } 3116 3117 static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *mntfh, 3118 struct nfs_fsinfo *info) 3119 { 3120 int error; 3121 struct nfs_fattr *fattr = info->fattr; 3122 struct nfs4_label *label = NULL; 3123 3124 error = nfs4_server_capabilities(server, mntfh); 3125 if (error < 0) { 3126 dprintk("nfs4_get_root: getcaps error = %d\n", -error); 3127 return error; 3128 } 3129 3130 label = nfs4_label_alloc(server, GFP_KERNEL); 3131 if (IS_ERR(label)) 3132 return PTR_ERR(label); 3133 3134 error = nfs4_proc_getattr(server, mntfh, fattr, label); 3135 if (error < 0) { 3136 dprintk("nfs4_get_root: getattr error = %d\n", -error); 3137 goto err_free_label; 3138 } 3139 3140 if (fattr->valid & NFS_ATTR_FATTR_FSID && 3141 !nfs_fsid_equal(&server->fsid, &fattr->fsid)) 3142 memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid)); 3143 3144 err_free_label: 3145 nfs4_label_free(label); 3146 3147 return error; 3148 } 3149 3150 /* 3151 * Get locations and (maybe) other attributes of a referral. 3152 * Note that we'll actually follow the referral later when 3153 * we detect fsid mismatch in inode revalidation 3154 */ 3155 static int nfs4_get_referral(struct rpc_clnt *client, struct inode *dir, 3156 const struct qstr *name, struct nfs_fattr *fattr, 3157 struct nfs_fh *fhandle) 3158 { 3159 int status = -ENOMEM; 3160 struct page *page = NULL; 3161 struct nfs4_fs_locations *locations = NULL; 3162 3163 page = alloc_page(GFP_KERNEL); 3164 if (page == NULL) 3165 goto out; 3166 locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL); 3167 if (locations == NULL) 3168 goto out; 3169 3170 status = nfs4_proc_fs_locations(client, dir, name, locations, page); 3171 if (status != 0) 3172 goto out; 3173 3174 /* 3175 * If the fsid didn't change, this is a migration event, not a 3176 * referral. Cause us to drop into the exception handler, which 3177 * will kick off migration recovery. 3178 */ 3179 if (nfs_fsid_equal(&NFS_SERVER(dir)->fsid, &locations->fattr.fsid)) { 3180 dprintk("%s: server did not return a different fsid for" 3181 " a referral at %s\n", __func__, name->name); 3182 status = -NFS4ERR_MOVED; 3183 goto out; 3184 } 3185 /* Fixup attributes for the nfs_lookup() call to nfs_fhget() */ 3186 nfs_fixup_referral_attributes(&locations->fattr); 3187 3188 /* replace the lookup nfs_fattr with the locations nfs_fattr */ 3189 memcpy(fattr, &locations->fattr, sizeof(struct nfs_fattr)); 3190 memset(fhandle, 0, sizeof(struct nfs_fh)); 3191 out: 3192 if (page) 3193 __free_page(page); 3194 kfree(locations); 3195 return status; 3196 } 3197 3198 static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, 3199 struct nfs_fattr *fattr, struct nfs4_label *label) 3200 { 3201 struct nfs4_getattr_arg args = { 3202 .fh = fhandle, 3203 .bitmask = server->attr_bitmask, 3204 }; 3205 struct nfs4_getattr_res res = { 3206 .fattr = fattr, 3207 .label = label, 3208 .server = server, 3209 }; 3210 struct rpc_message msg = { 3211 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETATTR], 3212 .rpc_argp = &args, 3213 .rpc_resp = &res, 3214 }; 3215 3216 args.bitmask = nfs4_bitmask(server, label); 3217 3218 nfs_fattr_init(fattr); 3219 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); 3220 } 3221 3222 static int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, 3223 struct nfs_fattr *fattr, struct nfs4_label *label) 3224 { 3225 struct nfs4_exception exception = { }; 3226 int err; 3227 do { 3228 err = _nfs4_proc_getattr(server, fhandle, fattr, label); 3229 trace_nfs4_getattr(server, fhandle, fattr, err); 3230 err = nfs4_handle_exception(server, err, 3231 &exception); 3232 } while (exception.retry); 3233 return err; 3234 } 3235 3236 /* 3237 * The file is not closed if it is opened due to the a request to change 3238 * the size of the file. The open call will not be needed once the 3239 * VFS layer lookup-intents are implemented. 3240 * 3241 * Close is called when the inode is destroyed. 3242 * If we haven't opened the file for O_WRONLY, we 3243 * need to in the size_change case to obtain a stateid. 3244 * 3245 * Got race? 3246 * Because OPEN is always done by name in nfsv4, it is 3247 * possible that we opened a different file by the same 3248 * name. We can recognize this race condition, but we 3249 * can't do anything about it besides returning an error. 3250 * 3251 * This will be fixed with VFS changes (lookup-intent). 3252 */ 3253 static int 3254 nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr, 3255 struct iattr *sattr) 3256 { 3257 struct inode *inode = dentry->d_inode; 3258 struct rpc_cred *cred = NULL; 3259 struct nfs4_state *state = NULL; 3260 struct nfs4_label *label = NULL; 3261 int status; 3262 3263 if (pnfs_ld_layoutret_on_setattr(inode) && 3264 sattr->ia_valid & ATTR_SIZE && 3265 sattr->ia_size < i_size_read(inode)) 3266 pnfs_commit_and_return_layout(inode); 3267 3268 nfs_fattr_init(fattr); 3269 3270 /* Deal with open(O_TRUNC) */ 3271 if (sattr->ia_valid & ATTR_OPEN) 3272 sattr->ia_valid &= ~(ATTR_MTIME|ATTR_CTIME); 3273 3274 /* Optimization: if the end result is no change, don't RPC */ 3275 if ((sattr->ia_valid & ~(ATTR_FILE|ATTR_OPEN)) == 0) 3276 return 0; 3277 3278 /* Search for an existing open(O_WRITE) file */ 3279 if (sattr->ia_valid & ATTR_FILE) { 3280 struct nfs_open_context *ctx; 3281 3282 ctx = nfs_file_open_context(sattr->ia_file); 3283 if (ctx) { 3284 cred = ctx->cred; 3285 state = ctx->state; 3286 } 3287 } 3288 3289 label = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL); 3290 if (IS_ERR(label)) 3291 return PTR_ERR(label); 3292 3293 status = nfs4_do_setattr(inode, cred, fattr, sattr, state, NULL, label); 3294 if (status == 0) { 3295 nfs_setattr_update_inode(inode, sattr, fattr); 3296 nfs_setsecurity(inode, fattr, label); 3297 } 3298 nfs4_label_free(label); 3299 return status; 3300 } 3301 3302 static int _nfs4_proc_lookup(struct rpc_clnt *clnt, struct inode *dir, 3303 const struct qstr *name, struct nfs_fh *fhandle, 3304 struct nfs_fattr *fattr, struct nfs4_label *label) 3305 { 3306 struct nfs_server *server = NFS_SERVER(dir); 3307 int status; 3308 struct nfs4_lookup_arg args = { 3309 .bitmask = server->attr_bitmask, 3310 .dir_fh = NFS_FH(dir), 3311 .name = name, 3312 }; 3313 struct nfs4_lookup_res res = { 3314 .server = server, 3315 .fattr = fattr, 3316 .label = label, 3317 .fh = fhandle, 3318 }; 3319 struct rpc_message msg = { 3320 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP], 3321 .rpc_argp = &args, 3322 .rpc_resp = &res, 3323 }; 3324 3325 args.bitmask = nfs4_bitmask(server, label); 3326 3327 nfs_fattr_init(fattr); 3328 3329 dprintk("NFS call lookup %s\n", name->name); 3330 status = nfs4_call_sync(clnt, server, &msg, &args.seq_args, &res.seq_res, 0); 3331 dprintk("NFS reply lookup: %d\n", status); 3332 return status; 3333 } 3334 3335 static void nfs_fixup_secinfo_attributes(struct nfs_fattr *fattr) 3336 { 3337 fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE | 3338 NFS_ATTR_FATTR_NLINK | NFS_ATTR_FATTR_MOUNTPOINT; 3339 fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO; 3340 fattr->nlink = 2; 3341 } 3342 3343 static int nfs4_proc_lookup_common(struct rpc_clnt **clnt, struct inode *dir, 3344 struct qstr *name, struct nfs_fh *fhandle, 3345 struct nfs_fattr *fattr, struct nfs4_label *label) 3346 { 3347 struct nfs4_exception exception = { }; 3348 struct rpc_clnt *client = *clnt; 3349 int err; 3350 do { 3351 err = _nfs4_proc_lookup(client, dir, name, fhandle, fattr, label); 3352 trace_nfs4_lookup(dir, name, err); 3353 switch (err) { 3354 case -NFS4ERR_BADNAME: 3355 err = -ENOENT; 3356 goto out; 3357 case -NFS4ERR_MOVED: 3358 err = nfs4_get_referral(client, dir, name, fattr, fhandle); 3359 goto out; 3360 case -NFS4ERR_WRONGSEC: 3361 err = -EPERM; 3362 if (client != *clnt) 3363 goto out; 3364 client = nfs4_negotiate_security(client, dir, name); 3365 if (IS_ERR(client)) 3366 return PTR_ERR(client); 3367 3368 exception.retry = 1; 3369 break; 3370 default: 3371 err = nfs4_handle_exception(NFS_SERVER(dir), err, &exception); 3372 } 3373 } while (exception.retry); 3374 3375 out: 3376 if (err == 0) 3377 *clnt = client; 3378 else if (client != *clnt) 3379 rpc_shutdown_client(client); 3380 3381 return err; 3382 } 3383 3384 static int nfs4_proc_lookup(struct inode *dir, struct qstr *name, 3385 struct nfs_fh *fhandle, struct nfs_fattr *fattr, 3386 struct nfs4_label *label) 3387 { 3388 int status; 3389 struct rpc_clnt *client = NFS_CLIENT(dir); 3390 3391 status = nfs4_proc_lookup_common(&client, dir, name, fhandle, fattr, label); 3392 if (client != NFS_CLIENT(dir)) { 3393 rpc_shutdown_client(client); 3394 nfs_fixup_secinfo_attributes(fattr); 3395 } 3396 return status; 3397 } 3398 3399 struct rpc_clnt * 3400 nfs4_proc_lookup_mountpoint(struct inode *dir, struct qstr *name, 3401 struct nfs_fh *fhandle, struct nfs_fattr *fattr) 3402 { 3403 struct rpc_clnt *client = NFS_CLIENT(dir); 3404 int status; 3405 3406 status = nfs4_proc_lookup_common(&client, dir, name, fhandle, fattr, NULL); 3407 if (status < 0) 3408 return ERR_PTR(status); 3409 return (client == NFS_CLIENT(dir)) ? rpc_clone_client(client) : client; 3410 } 3411 3412 static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry) 3413 { 3414 struct nfs_server *server = NFS_SERVER(inode); 3415 struct nfs4_accessargs args = { 3416 .fh = NFS_FH(inode), 3417 .bitmask = server->cache_consistency_bitmask, 3418 }; 3419 struct nfs4_accessres res = { 3420 .server = server, 3421 }; 3422 struct rpc_message msg = { 3423 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ACCESS], 3424 .rpc_argp = &args, 3425 .rpc_resp = &res, 3426 .rpc_cred = entry->cred, 3427 }; 3428 int mode = entry->mask; 3429 int status = 0; 3430 3431 /* 3432 * Determine which access bits we want to ask for... 3433 */ 3434 if (mode & MAY_READ) 3435 args.access |= NFS4_ACCESS_READ; 3436 if (S_ISDIR(inode->i_mode)) { 3437 if (mode & MAY_WRITE) 3438 args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE; 3439 if (mode & MAY_EXEC) 3440 args.access |= NFS4_ACCESS_LOOKUP; 3441 } else { 3442 if (mode & MAY_WRITE) 3443 args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND; 3444 if (mode & MAY_EXEC) 3445 args.access |= NFS4_ACCESS_EXECUTE; 3446 } 3447 3448 res.fattr = nfs_alloc_fattr(); 3449 if (res.fattr == NULL) 3450 return -ENOMEM; 3451 3452 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); 3453 if (!status) { 3454 nfs_access_set_mask(entry, res.access); 3455 nfs_refresh_inode(inode, res.fattr); 3456 } 3457 nfs_free_fattr(res.fattr); 3458 return status; 3459 } 3460 3461 static int nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry) 3462 { 3463 struct nfs4_exception exception = { }; 3464 int err; 3465 do { 3466 err = _nfs4_proc_access(inode, entry); 3467 trace_nfs4_access(inode, err); 3468 err = nfs4_handle_exception(NFS_SERVER(inode), err, 3469 &exception); 3470 } while (exception.retry); 3471 return err; 3472 } 3473 3474 /* 3475 * TODO: For the time being, we don't try to get any attributes 3476 * along with any of the zero-copy operations READ, READDIR, 3477 * READLINK, WRITE. 3478 * 3479 * In the case of the first three, we want to put the GETATTR 3480 * after the read-type operation -- this is because it is hard 3481 * to predict the length of a GETATTR response in v4, and thus 3482 * align the READ data correctly. This means that the GETATTR 3483 * may end up partially falling into the page cache, and we should 3484 * shift it into the 'tail' of the xdr_buf before processing. 3485 * To do this efficiently, we need to know the total length 3486 * of data received, which doesn't seem to be available outside 3487 * of the RPC layer. 3488 * 3489 * In the case of WRITE, we also want to put the GETATTR after 3490 * the operation -- in this case because we want to make sure 3491 * we get the post-operation mtime and size. 3492 * 3493 * Both of these changes to the XDR layer would in fact be quite 3494 * minor, but I decided to leave them for a subsequent patch. 3495 */ 3496 static int _nfs4_proc_readlink(struct inode *inode, struct page *page, 3497 unsigned int pgbase, unsigned int pglen) 3498 { 3499 struct nfs4_readlink args = { 3500 .fh = NFS_FH(inode), 3501 .pgbase = pgbase, 3502 .pglen = pglen, 3503 .pages = &page, 3504 }; 3505 struct nfs4_readlink_res res; 3506 struct rpc_message msg = { 3507 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READLINK], 3508 .rpc_argp = &args, 3509 .rpc_resp = &res, 3510 }; 3511 3512 return nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode), &msg, &args.seq_args, &res.seq_res, 0); 3513 } 3514 3515 static int nfs4_proc_readlink(struct inode *inode, struct page *page, 3516 unsigned int pgbase, unsigned int pglen) 3517 { 3518 struct nfs4_exception exception = { }; 3519 int err; 3520 do { 3521 err = _nfs4_proc_readlink(inode, page, pgbase, pglen); 3522 trace_nfs4_readlink(inode, err); 3523 err = nfs4_handle_exception(NFS_SERVER(inode), err, 3524 &exception); 3525 } while (exception.retry); 3526 return err; 3527 } 3528 3529 /* 3530 * This is just for mknod. open(O_CREAT) will always do ->open_context(). 3531 */ 3532 static int 3533 nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr, 3534 int flags) 3535 { 3536 struct nfs4_label l, *ilabel = NULL; 3537 struct nfs_open_context *ctx; 3538 struct nfs4_state *state; 3539 int opened = 0; 3540 int status = 0; 3541 3542 ctx = alloc_nfs_open_context(dentry, FMODE_READ); 3543 if (IS_ERR(ctx)) 3544 return PTR_ERR(ctx); 3545 3546 ilabel = nfs4_label_init_security(dir, dentry, sattr, &l); 3547 3548 sattr->ia_mode &= ~current_umask(); 3549 state = nfs4_do_open(dir, ctx, flags, sattr, ilabel, &opened); 3550 if (IS_ERR(state)) { 3551 status = PTR_ERR(state); 3552 goto out; 3553 } 3554 out: 3555 nfs4_label_release_security(ilabel); 3556 put_nfs_open_context(ctx); 3557 return status; 3558 } 3559 3560 static int _nfs4_proc_remove(struct inode *dir, struct qstr *name) 3561 { 3562 struct nfs_server *server = NFS_SERVER(dir); 3563 struct nfs_removeargs args = { 3564 .fh = NFS_FH(dir), 3565 .name = *name, 3566 }; 3567 struct nfs_removeres res = { 3568 .server = server, 3569 }; 3570 struct rpc_message msg = { 3571 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE], 3572 .rpc_argp = &args, 3573 .rpc_resp = &res, 3574 }; 3575 int status; 3576 3577 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 1); 3578 if (status == 0) 3579 update_changeattr(dir, &res.cinfo); 3580 return status; 3581 } 3582 3583 static int nfs4_proc_remove(struct inode *dir, struct qstr *name) 3584 { 3585 struct nfs4_exception exception = { }; 3586 int err; 3587 do { 3588 err = _nfs4_proc_remove(dir, name); 3589 trace_nfs4_remove(dir, name, err); 3590 err = nfs4_handle_exception(NFS_SERVER(dir), err, 3591 &exception); 3592 } while (exception.retry); 3593 return err; 3594 } 3595 3596 static void nfs4_proc_unlink_setup(struct rpc_message *msg, struct inode *dir) 3597 { 3598 struct nfs_server *server = NFS_SERVER(dir); 3599 struct nfs_removeargs *args = msg->rpc_argp; 3600 struct nfs_removeres *res = msg->rpc_resp; 3601 3602 res->server = server; 3603 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE]; 3604 nfs4_init_sequence(&args->seq_args, &res->seq_res, 1); 3605 3606 nfs_fattr_init(res->dir_attr); 3607 } 3608 3609 static void nfs4_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data) 3610 { 3611 nfs4_setup_sequence(NFS_SERVER(data->dir), 3612 &data->args.seq_args, 3613 &data->res.seq_res, 3614 task); 3615 } 3616 3617 static int nfs4_proc_unlink_done(struct rpc_task *task, struct inode *dir) 3618 { 3619 struct nfs_unlinkdata *data = task->tk_calldata; 3620 struct nfs_removeres *res = &data->res; 3621 3622 if (!nfs4_sequence_done(task, &res->seq_res)) 3623 return 0; 3624 if (nfs4_async_handle_error(task, res->server, NULL, 3625 &data->timeout) == -EAGAIN) 3626 return 0; 3627 update_changeattr(dir, &res->cinfo); 3628 return 1; 3629 } 3630 3631 static void nfs4_proc_rename_setup(struct rpc_message *msg, struct inode *dir) 3632 { 3633 struct nfs_server *server = NFS_SERVER(dir); 3634 struct nfs_renameargs *arg = msg->rpc_argp; 3635 struct nfs_renameres *res = msg->rpc_resp; 3636 3637 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME]; 3638 res->server = server; 3639 nfs4_init_sequence(&arg->seq_args, &res->seq_res, 1); 3640 } 3641 3642 static void nfs4_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data) 3643 { 3644 nfs4_setup_sequence(NFS_SERVER(data->old_dir), 3645 &data->args.seq_args, 3646 &data->res.seq_res, 3647 task); 3648 } 3649 3650 static int nfs4_proc_rename_done(struct rpc_task *task, struct inode *old_dir, 3651 struct inode *new_dir) 3652 { 3653 struct nfs_renamedata *data = task->tk_calldata; 3654 struct nfs_renameres *res = &data->res; 3655 3656 if (!nfs4_sequence_done(task, &res->seq_res)) 3657 return 0; 3658 if (nfs4_async_handle_error(task, res->server, NULL, &data->timeout) == -EAGAIN) 3659 return 0; 3660 3661 update_changeattr(old_dir, &res->old_cinfo); 3662 update_changeattr(new_dir, &res->new_cinfo); 3663 return 1; 3664 } 3665 3666 static int _nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name) 3667 { 3668 struct nfs_server *server = NFS_SERVER(inode); 3669 struct nfs4_link_arg arg = { 3670 .fh = NFS_FH(inode), 3671 .dir_fh = NFS_FH(dir), 3672 .name = name, 3673 .bitmask = server->attr_bitmask, 3674 }; 3675 struct nfs4_link_res res = { 3676 .server = server, 3677 .label = NULL, 3678 }; 3679 struct rpc_message msg = { 3680 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LINK], 3681 .rpc_argp = &arg, 3682 .rpc_resp = &res, 3683 }; 3684 int status = -ENOMEM; 3685 3686 res.fattr = nfs_alloc_fattr(); 3687 if (res.fattr == NULL) 3688 goto out; 3689 3690 res.label = nfs4_label_alloc(server, GFP_KERNEL); 3691 if (IS_ERR(res.label)) { 3692 status = PTR_ERR(res.label); 3693 goto out; 3694 } 3695 arg.bitmask = nfs4_bitmask(server, res.label); 3696 3697 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); 3698 if (!status) { 3699 update_changeattr(dir, &res.cinfo); 3700 status = nfs_post_op_update_inode(inode, res.fattr); 3701 if (!status) 3702 nfs_setsecurity(inode, res.fattr, res.label); 3703 } 3704 3705 3706 nfs4_label_free(res.label); 3707 3708 out: 3709 nfs_free_fattr(res.fattr); 3710 return status; 3711 } 3712 3713 static int nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name) 3714 { 3715 struct nfs4_exception exception = { }; 3716 int err; 3717 do { 3718 err = nfs4_handle_exception(NFS_SERVER(inode), 3719 _nfs4_proc_link(inode, dir, name), 3720 &exception); 3721 } while (exception.retry); 3722 return err; 3723 } 3724 3725 struct nfs4_createdata { 3726 struct rpc_message msg; 3727 struct nfs4_create_arg arg; 3728 struct nfs4_create_res res; 3729 struct nfs_fh fh; 3730 struct nfs_fattr fattr; 3731 struct nfs4_label *label; 3732 }; 3733 3734 static struct nfs4_createdata *nfs4_alloc_createdata(struct inode *dir, 3735 struct qstr *name, struct iattr *sattr, u32 ftype) 3736 { 3737 struct nfs4_createdata *data; 3738 3739 data = kzalloc(sizeof(*data), GFP_KERNEL); 3740 if (data != NULL) { 3741 struct nfs_server *server = NFS_SERVER(dir); 3742 3743 data->label = nfs4_label_alloc(server, GFP_KERNEL); 3744 if (IS_ERR(data->label)) 3745 goto out_free; 3746 3747 data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE]; 3748 data->msg.rpc_argp = &data->arg; 3749 data->msg.rpc_resp = &data->res; 3750 data->arg.dir_fh = NFS_FH(dir); 3751 data->arg.server = server; 3752 data->arg.name = name; 3753 data->arg.attrs = sattr; 3754 data->arg.ftype = ftype; 3755 data->arg.bitmask = nfs4_bitmask(server, data->label); 3756 data->res.server = server; 3757 data->res.fh = &data->fh; 3758 data->res.fattr = &data->fattr; 3759 data->res.label = data->label; 3760 nfs_fattr_init(data->res.fattr); 3761 } 3762 return data; 3763 out_free: 3764 kfree(data); 3765 return NULL; 3766 } 3767 3768 static int nfs4_do_create(struct inode *dir, struct dentry *dentry, struct nfs4_createdata *data) 3769 { 3770 int status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &data->msg, 3771 &data->arg.seq_args, &data->res.seq_res, 1); 3772 if (status == 0) { 3773 update_changeattr(dir, &data->res.dir_cinfo); 3774 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, data->res.label); 3775 } 3776 return status; 3777 } 3778 3779 static void nfs4_free_createdata(struct nfs4_createdata *data) 3780 { 3781 nfs4_label_free(data->label); 3782 kfree(data); 3783 } 3784 3785 static int _nfs4_proc_symlink(struct inode *dir, struct dentry *dentry, 3786 struct page *page, unsigned int len, struct iattr *sattr, 3787 struct nfs4_label *label) 3788 { 3789 struct nfs4_createdata *data; 3790 int status = -ENAMETOOLONG; 3791 3792 if (len > NFS4_MAXPATHLEN) 3793 goto out; 3794 3795 status = -ENOMEM; 3796 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4LNK); 3797 if (data == NULL) 3798 goto out; 3799 3800 data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SYMLINK]; 3801 data->arg.u.symlink.pages = &page; 3802 data->arg.u.symlink.len = len; 3803 data->arg.label = label; 3804 3805 status = nfs4_do_create(dir, dentry, data); 3806 3807 nfs4_free_createdata(data); 3808 out: 3809 return status; 3810 } 3811 3812 static int nfs4_proc_symlink(struct inode *dir, struct dentry *dentry, 3813 struct page *page, unsigned int len, struct iattr *sattr) 3814 { 3815 struct nfs4_exception exception = { }; 3816 struct nfs4_label l, *label = NULL; 3817 int err; 3818 3819 label = nfs4_label_init_security(dir, dentry, sattr, &l); 3820 3821 do { 3822 err = _nfs4_proc_symlink(dir, dentry, page, len, sattr, label); 3823 trace_nfs4_symlink(dir, &dentry->d_name, err); 3824 err = nfs4_handle_exception(NFS_SERVER(dir), err, 3825 &exception); 3826 } while (exception.retry); 3827 3828 nfs4_label_release_security(label); 3829 return err; 3830 } 3831 3832 static int _nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry, 3833 struct iattr *sattr, struct nfs4_label *label) 3834 { 3835 struct nfs4_createdata *data; 3836 int status = -ENOMEM; 3837 3838 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4DIR); 3839 if (data == NULL) 3840 goto out; 3841 3842 data->arg.label = label; 3843 status = nfs4_do_create(dir, dentry, data); 3844 3845 nfs4_free_createdata(data); 3846 out: 3847 return status; 3848 } 3849 3850 static int nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry, 3851 struct iattr *sattr) 3852 { 3853 struct nfs4_exception exception = { }; 3854 struct nfs4_label l, *label = NULL; 3855 int err; 3856 3857 label = nfs4_label_init_security(dir, dentry, sattr, &l); 3858 3859 sattr->ia_mode &= ~current_umask(); 3860 do { 3861 err = _nfs4_proc_mkdir(dir, dentry, sattr, label); 3862 trace_nfs4_mkdir(dir, &dentry->d_name, err); 3863 err = nfs4_handle_exception(NFS_SERVER(dir), err, 3864 &exception); 3865 } while (exception.retry); 3866 nfs4_label_release_security(label); 3867 3868 return err; 3869 } 3870 3871 static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred, 3872 u64 cookie, struct page **pages, unsigned int count, int plus) 3873 { 3874 struct inode *dir = dentry->d_inode; 3875 struct nfs4_readdir_arg args = { 3876 .fh = NFS_FH(dir), 3877 .pages = pages, 3878 .pgbase = 0, 3879 .count = count, 3880 .bitmask = NFS_SERVER(dentry->d_inode)->attr_bitmask, 3881 .plus = plus, 3882 }; 3883 struct nfs4_readdir_res res; 3884 struct rpc_message msg = { 3885 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READDIR], 3886 .rpc_argp = &args, 3887 .rpc_resp = &res, 3888 .rpc_cred = cred, 3889 }; 3890 int status; 3891 3892 dprintk("%s: dentry = %pd2, cookie = %Lu\n", __func__, 3893 dentry, 3894 (unsigned long long)cookie); 3895 nfs4_setup_readdir(cookie, NFS_I(dir)->cookieverf, dentry, &args); 3896 res.pgbase = args.pgbase; 3897 status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &msg, &args.seq_args, &res.seq_res, 0); 3898 if (status >= 0) { 3899 memcpy(NFS_I(dir)->cookieverf, res.verifier.data, NFS4_VERIFIER_SIZE); 3900 status += args.pgbase; 3901 } 3902 3903 nfs_invalidate_atime(dir); 3904 3905 dprintk("%s: returns %d\n", __func__, status); 3906 return status; 3907 } 3908 3909 static int nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred, 3910 u64 cookie, struct page **pages, unsigned int count, int plus) 3911 { 3912 struct nfs4_exception exception = { }; 3913 int err; 3914 do { 3915 err = _nfs4_proc_readdir(dentry, cred, cookie, 3916 pages, count, plus); 3917 trace_nfs4_readdir(dentry->d_inode, err); 3918 err = nfs4_handle_exception(NFS_SERVER(dentry->d_inode), err, 3919 &exception); 3920 } while (exception.retry); 3921 return err; 3922 } 3923 3924 static int _nfs4_proc_mknod(struct inode *dir, struct dentry *dentry, 3925 struct iattr *sattr, struct nfs4_label *label, dev_t rdev) 3926 { 3927 struct nfs4_createdata *data; 3928 int mode = sattr->ia_mode; 3929 int status = -ENOMEM; 3930 3931 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4SOCK); 3932 if (data == NULL) 3933 goto out; 3934 3935 if (S_ISFIFO(mode)) 3936 data->arg.ftype = NF4FIFO; 3937 else if (S_ISBLK(mode)) { 3938 data->arg.ftype = NF4BLK; 3939 data->arg.u.device.specdata1 = MAJOR(rdev); 3940 data->arg.u.device.specdata2 = MINOR(rdev); 3941 } 3942 else if (S_ISCHR(mode)) { 3943 data->arg.ftype = NF4CHR; 3944 data->arg.u.device.specdata1 = MAJOR(rdev); 3945 data->arg.u.device.specdata2 = MINOR(rdev); 3946 } else if (!S_ISSOCK(mode)) { 3947 status = -EINVAL; 3948 goto out_free; 3949 } 3950 3951 data->arg.label = label; 3952 status = nfs4_do_create(dir, dentry, data); 3953 out_free: 3954 nfs4_free_createdata(data); 3955 out: 3956 return status; 3957 } 3958 3959 static int nfs4_proc_mknod(struct inode *dir, struct dentry *dentry, 3960 struct iattr *sattr, dev_t rdev) 3961 { 3962 struct nfs4_exception exception = { }; 3963 struct nfs4_label l, *label = NULL; 3964 int err; 3965 3966 label = nfs4_label_init_security(dir, dentry, sattr, &l); 3967 3968 sattr->ia_mode &= ~current_umask(); 3969 do { 3970 err = _nfs4_proc_mknod(dir, dentry, sattr, label, rdev); 3971 trace_nfs4_mknod(dir, &dentry->d_name, err); 3972 err = nfs4_handle_exception(NFS_SERVER(dir), err, 3973 &exception); 3974 } while (exception.retry); 3975 3976 nfs4_label_release_security(label); 3977 3978 return err; 3979 } 3980 3981 static int _nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, 3982 struct nfs_fsstat *fsstat) 3983 { 3984 struct nfs4_statfs_arg args = { 3985 .fh = fhandle, 3986 .bitmask = server->attr_bitmask, 3987 }; 3988 struct nfs4_statfs_res res = { 3989 .fsstat = fsstat, 3990 }; 3991 struct rpc_message msg = { 3992 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_STATFS], 3993 .rpc_argp = &args, 3994 .rpc_resp = &res, 3995 }; 3996 3997 nfs_fattr_init(fsstat->fattr); 3998 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); 3999 } 4000 4001 static int nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsstat *fsstat) 4002 { 4003 struct nfs4_exception exception = { }; 4004 int err; 4005 do { 4006 err = nfs4_handle_exception(server, 4007 _nfs4_proc_statfs(server, fhandle, fsstat), 4008 &exception); 4009 } while (exception.retry); 4010 return err; 4011 } 4012 4013 static int _nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, 4014 struct nfs_fsinfo *fsinfo) 4015 { 4016 struct nfs4_fsinfo_arg args = { 4017 .fh = fhandle, 4018 .bitmask = server->attr_bitmask, 4019 }; 4020 struct nfs4_fsinfo_res res = { 4021 .fsinfo = fsinfo, 4022 }; 4023 struct rpc_message msg = { 4024 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSINFO], 4025 .rpc_argp = &args, 4026 .rpc_resp = &res, 4027 }; 4028 4029 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); 4030 } 4031 4032 static int nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo) 4033 { 4034 struct nfs4_exception exception = { }; 4035 unsigned long now = jiffies; 4036 int err; 4037 4038 do { 4039 err = _nfs4_do_fsinfo(server, fhandle, fsinfo); 4040 trace_nfs4_fsinfo(server, fhandle, fsinfo->fattr, err); 4041 if (err == 0) { 4042 struct nfs_client *clp = server->nfs_client; 4043 4044 spin_lock(&clp->cl_lock); 4045 clp->cl_lease_time = fsinfo->lease_time * HZ; 4046 clp->cl_last_renewal = now; 4047 spin_unlock(&clp->cl_lock); 4048 break; 4049 } 4050 err = nfs4_handle_exception(server, err, &exception); 4051 } while (exception.retry); 4052 return err; 4053 } 4054 4055 static int nfs4_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo) 4056 { 4057 int error; 4058 4059 nfs_fattr_init(fsinfo->fattr); 4060 error = nfs4_do_fsinfo(server, fhandle, fsinfo); 4061 if (error == 0) { 4062 /* block layout checks this! */ 4063 server->pnfs_blksize = fsinfo->blksize; 4064 set_pnfs_layoutdriver(server, fhandle, fsinfo->layouttype); 4065 } 4066 4067 return error; 4068 } 4069 4070 static int _nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle, 4071 struct nfs_pathconf *pathconf) 4072 { 4073 struct nfs4_pathconf_arg args = { 4074 .fh = fhandle, 4075 .bitmask = server->attr_bitmask, 4076 }; 4077 struct nfs4_pathconf_res res = { 4078 .pathconf = pathconf, 4079 }; 4080 struct rpc_message msg = { 4081 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_PATHCONF], 4082 .rpc_argp = &args, 4083 .rpc_resp = &res, 4084 }; 4085 4086 /* None of the pathconf attributes are mandatory to implement */ 4087 if ((args.bitmask[0] & nfs4_pathconf_bitmap[0]) == 0) { 4088 memset(pathconf, 0, sizeof(*pathconf)); 4089 return 0; 4090 } 4091 4092 nfs_fattr_init(pathconf->fattr); 4093 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); 4094 } 4095 4096 static int nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle, 4097 struct nfs_pathconf *pathconf) 4098 { 4099 struct nfs4_exception exception = { }; 4100 int err; 4101 4102 do { 4103 err = nfs4_handle_exception(server, 4104 _nfs4_proc_pathconf(server, fhandle, pathconf), 4105 &exception); 4106 } while (exception.retry); 4107 return err; 4108 } 4109 4110 int nfs4_set_rw_stateid(nfs4_stateid *stateid, 4111 const struct nfs_open_context *ctx, 4112 const struct nfs_lock_context *l_ctx, 4113 fmode_t fmode) 4114 { 4115 const struct nfs_lockowner *lockowner = NULL; 4116 4117 if (l_ctx != NULL) 4118 lockowner = &l_ctx->lockowner; 4119 return nfs4_select_rw_stateid(stateid, ctx->state, fmode, lockowner); 4120 } 4121 EXPORT_SYMBOL_GPL(nfs4_set_rw_stateid); 4122 4123 static bool nfs4_stateid_is_current(nfs4_stateid *stateid, 4124 const struct nfs_open_context *ctx, 4125 const struct nfs_lock_context *l_ctx, 4126 fmode_t fmode) 4127 { 4128 nfs4_stateid current_stateid; 4129 4130 /* If the current stateid represents a lost lock, then exit */ 4131 if (nfs4_set_rw_stateid(¤t_stateid, ctx, l_ctx, fmode) == -EIO) 4132 return true; 4133 return nfs4_stateid_match(stateid, ¤t_stateid); 4134 } 4135 4136 static bool nfs4_error_stateid_expired(int err) 4137 { 4138 switch (err) { 4139 case -NFS4ERR_DELEG_REVOKED: 4140 case -NFS4ERR_ADMIN_REVOKED: 4141 case -NFS4ERR_BAD_STATEID: 4142 case -NFS4ERR_STALE_STATEID: 4143 case -NFS4ERR_OLD_STATEID: 4144 case -NFS4ERR_OPENMODE: 4145 case -NFS4ERR_EXPIRED: 4146 return true; 4147 } 4148 return false; 4149 } 4150 4151 void __nfs4_read_done_cb(struct nfs_pgio_header *hdr) 4152 { 4153 nfs_invalidate_atime(hdr->inode); 4154 } 4155 4156 static int nfs4_read_done_cb(struct rpc_task *task, struct nfs_pgio_header *hdr) 4157 { 4158 struct nfs_server *server = NFS_SERVER(hdr->inode); 4159 4160 trace_nfs4_read(hdr, task->tk_status); 4161 if (nfs4_async_handle_error(task, server, 4162 hdr->args.context->state, 4163 NULL) == -EAGAIN) { 4164 rpc_restart_call_prepare(task); 4165 return -EAGAIN; 4166 } 4167 4168 __nfs4_read_done_cb(hdr); 4169 if (task->tk_status > 0) 4170 renew_lease(server, hdr->timestamp); 4171 return 0; 4172 } 4173 4174 static bool nfs4_read_stateid_changed(struct rpc_task *task, 4175 struct nfs_pgio_args *args) 4176 { 4177 4178 if (!nfs4_error_stateid_expired(task->tk_status) || 4179 nfs4_stateid_is_current(&args->stateid, 4180 args->context, 4181 args->lock_context, 4182 FMODE_READ)) 4183 return false; 4184 rpc_restart_call_prepare(task); 4185 return true; 4186 } 4187 4188 static int nfs4_read_done(struct rpc_task *task, struct nfs_pgio_header *hdr) 4189 { 4190 4191 dprintk("--> %s\n", __func__); 4192 4193 if (!nfs4_sequence_done(task, &hdr->res.seq_res)) 4194 return -EAGAIN; 4195 if (nfs4_read_stateid_changed(task, &hdr->args)) 4196 return -EAGAIN; 4197 return hdr->pgio_done_cb ? hdr->pgio_done_cb(task, hdr) : 4198 nfs4_read_done_cb(task, hdr); 4199 } 4200 4201 static void nfs4_proc_read_setup(struct nfs_pgio_header *hdr, 4202 struct rpc_message *msg) 4203 { 4204 hdr->timestamp = jiffies; 4205 hdr->pgio_done_cb = nfs4_read_done_cb; 4206 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READ]; 4207 nfs4_init_sequence(&hdr->args.seq_args, &hdr->res.seq_res, 0); 4208 } 4209 4210 static int nfs4_proc_pgio_rpc_prepare(struct rpc_task *task, 4211 struct nfs_pgio_header *hdr) 4212 { 4213 if (nfs4_setup_sequence(NFS_SERVER(hdr->inode), 4214 &hdr->args.seq_args, 4215 &hdr->res.seq_res, 4216 task)) 4217 return 0; 4218 if (nfs4_set_rw_stateid(&hdr->args.stateid, hdr->args.context, 4219 hdr->args.lock_context, 4220 hdr->rw_ops->rw_mode) == -EIO) 4221 return -EIO; 4222 if (unlikely(test_bit(NFS_CONTEXT_BAD, &hdr->args.context->flags))) 4223 return -EIO; 4224 return 0; 4225 } 4226 4227 static int nfs4_write_done_cb(struct rpc_task *task, 4228 struct nfs_pgio_header *hdr) 4229 { 4230 struct inode *inode = hdr->inode; 4231 4232 trace_nfs4_write(hdr, task->tk_status); 4233 if (nfs4_async_handle_error(task, NFS_SERVER(inode), 4234 hdr->args.context->state, 4235 NULL) == -EAGAIN) { 4236 rpc_restart_call_prepare(task); 4237 return -EAGAIN; 4238 } 4239 if (task->tk_status >= 0) { 4240 renew_lease(NFS_SERVER(inode), hdr->timestamp); 4241 nfs_writeback_update_inode(hdr); 4242 } 4243 return 0; 4244 } 4245 4246 static bool nfs4_write_stateid_changed(struct rpc_task *task, 4247 struct nfs_pgio_args *args) 4248 { 4249 4250 if (!nfs4_error_stateid_expired(task->tk_status) || 4251 nfs4_stateid_is_current(&args->stateid, 4252 args->context, 4253 args->lock_context, 4254 FMODE_WRITE)) 4255 return false; 4256 rpc_restart_call_prepare(task); 4257 return true; 4258 } 4259 4260 static int nfs4_write_done(struct rpc_task *task, struct nfs_pgio_header *hdr) 4261 { 4262 if (!nfs4_sequence_done(task, &hdr->res.seq_res)) 4263 return -EAGAIN; 4264 if (nfs4_write_stateid_changed(task, &hdr->args)) 4265 return -EAGAIN; 4266 return hdr->pgio_done_cb ? hdr->pgio_done_cb(task, hdr) : 4267 nfs4_write_done_cb(task, hdr); 4268 } 4269 4270 static 4271 bool nfs4_write_need_cache_consistency_data(struct nfs_pgio_header *hdr) 4272 { 4273 /* Don't request attributes for pNFS or O_DIRECT writes */ 4274 if (hdr->ds_clp != NULL || hdr->dreq != NULL) 4275 return false; 4276 /* Otherwise, request attributes if and only if we don't hold 4277 * a delegation 4278 */ 4279 return nfs4_have_delegation(hdr->inode, FMODE_READ) == 0; 4280 } 4281 4282 static void nfs4_proc_write_setup(struct nfs_pgio_header *hdr, 4283 struct rpc_message *msg) 4284 { 4285 struct nfs_server *server = NFS_SERVER(hdr->inode); 4286 4287 if (!nfs4_write_need_cache_consistency_data(hdr)) { 4288 hdr->args.bitmask = NULL; 4289 hdr->res.fattr = NULL; 4290 } else 4291 hdr->args.bitmask = server->cache_consistency_bitmask; 4292 4293 if (!hdr->pgio_done_cb) 4294 hdr->pgio_done_cb = nfs4_write_done_cb; 4295 hdr->res.server = server; 4296 hdr->timestamp = jiffies; 4297 4298 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_WRITE]; 4299 nfs4_init_sequence(&hdr->args.seq_args, &hdr->res.seq_res, 1); 4300 } 4301 4302 static void nfs4_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data) 4303 { 4304 nfs4_setup_sequence(NFS_SERVER(data->inode), 4305 &data->args.seq_args, 4306 &data->res.seq_res, 4307 task); 4308 } 4309 4310 static int nfs4_commit_done_cb(struct rpc_task *task, struct nfs_commit_data *data) 4311 { 4312 struct inode *inode = data->inode; 4313 4314 trace_nfs4_commit(data, task->tk_status); 4315 if (nfs4_async_handle_error(task, NFS_SERVER(inode), 4316 NULL, NULL) == -EAGAIN) { 4317 rpc_restart_call_prepare(task); 4318 return -EAGAIN; 4319 } 4320 return 0; 4321 } 4322 4323 static int nfs4_commit_done(struct rpc_task *task, struct nfs_commit_data *data) 4324 { 4325 if (!nfs4_sequence_done(task, &data->res.seq_res)) 4326 return -EAGAIN; 4327 return data->commit_done_cb(task, data); 4328 } 4329 4330 static void nfs4_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg) 4331 { 4332 struct nfs_server *server = NFS_SERVER(data->inode); 4333 4334 if (data->commit_done_cb == NULL) 4335 data->commit_done_cb = nfs4_commit_done_cb; 4336 data->res.server = server; 4337 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COMMIT]; 4338 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1); 4339 } 4340 4341 struct nfs4_renewdata { 4342 struct nfs_client *client; 4343 unsigned long timestamp; 4344 }; 4345 4346 /* 4347 * nfs4_proc_async_renew(): This is not one of the nfs_rpc_ops; it is a special 4348 * standalone procedure for queueing an asynchronous RENEW. 4349 */ 4350 static void nfs4_renew_release(void *calldata) 4351 { 4352 struct nfs4_renewdata *data = calldata; 4353 struct nfs_client *clp = data->client; 4354 4355 if (atomic_read(&clp->cl_count) > 1) 4356 nfs4_schedule_state_renewal(clp); 4357 nfs_put_client(clp); 4358 kfree(data); 4359 } 4360 4361 static void nfs4_renew_done(struct rpc_task *task, void *calldata) 4362 { 4363 struct nfs4_renewdata *data = calldata; 4364 struct nfs_client *clp = data->client; 4365 unsigned long timestamp = data->timestamp; 4366 4367 trace_nfs4_renew_async(clp, task->tk_status); 4368 switch (task->tk_status) { 4369 case 0: 4370 break; 4371 case -NFS4ERR_LEASE_MOVED: 4372 nfs4_schedule_lease_moved_recovery(clp); 4373 break; 4374 default: 4375 /* Unless we're shutting down, schedule state recovery! */ 4376 if (test_bit(NFS_CS_RENEWD, &clp->cl_res_state) == 0) 4377 return; 4378 if (task->tk_status != NFS4ERR_CB_PATH_DOWN) { 4379 nfs4_schedule_lease_recovery(clp); 4380 return; 4381 } 4382 nfs4_schedule_path_down_recovery(clp); 4383 } 4384 do_renew_lease(clp, timestamp); 4385 } 4386 4387 static const struct rpc_call_ops nfs4_renew_ops = { 4388 .rpc_call_done = nfs4_renew_done, 4389 .rpc_release = nfs4_renew_release, 4390 }; 4391 4392 static int nfs4_proc_async_renew(struct nfs_client *clp, struct rpc_cred *cred, unsigned renew_flags) 4393 { 4394 struct rpc_message msg = { 4395 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW], 4396 .rpc_argp = clp, 4397 .rpc_cred = cred, 4398 }; 4399 struct nfs4_renewdata *data; 4400 4401 if (renew_flags == 0) 4402 return 0; 4403 if (!atomic_inc_not_zero(&clp->cl_count)) 4404 return -EIO; 4405 data = kmalloc(sizeof(*data), GFP_NOFS); 4406 if (data == NULL) 4407 return -ENOMEM; 4408 data->client = clp; 4409 data->timestamp = jiffies; 4410 return rpc_call_async(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT, 4411 &nfs4_renew_ops, data); 4412 } 4413 4414 static int nfs4_proc_renew(struct nfs_client *clp, struct rpc_cred *cred) 4415 { 4416 struct rpc_message msg = { 4417 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW], 4418 .rpc_argp = clp, 4419 .rpc_cred = cred, 4420 }; 4421 unsigned long now = jiffies; 4422 int status; 4423 4424 status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT); 4425 if (status < 0) 4426 return status; 4427 do_renew_lease(clp, now); 4428 return 0; 4429 } 4430 4431 static inline int nfs4_server_supports_acls(struct nfs_server *server) 4432 { 4433 return server->caps & NFS_CAP_ACLS; 4434 } 4435 4436 /* Assuming that XATTR_SIZE_MAX is a multiple of PAGE_SIZE, and that 4437 * it's OK to put sizeof(void) * (XATTR_SIZE_MAX/PAGE_SIZE) bytes on 4438 * the stack. 4439 */ 4440 #define NFS4ACL_MAXPAGES DIV_ROUND_UP(XATTR_SIZE_MAX, PAGE_SIZE) 4441 4442 static int buf_to_pages_noslab(const void *buf, size_t buflen, 4443 struct page **pages, unsigned int *pgbase) 4444 { 4445 struct page *newpage, **spages; 4446 int rc = 0; 4447 size_t len; 4448 spages = pages; 4449 4450 do { 4451 len = min_t(size_t, PAGE_SIZE, buflen); 4452 newpage = alloc_page(GFP_KERNEL); 4453 4454 if (newpage == NULL) 4455 goto unwind; 4456 memcpy(page_address(newpage), buf, len); 4457 buf += len; 4458 buflen -= len; 4459 *pages++ = newpage; 4460 rc++; 4461 } while (buflen != 0); 4462 4463 return rc; 4464 4465 unwind: 4466 for(; rc > 0; rc--) 4467 __free_page(spages[rc-1]); 4468 return -ENOMEM; 4469 } 4470 4471 struct nfs4_cached_acl { 4472 int cached; 4473 size_t len; 4474 char data[0]; 4475 }; 4476 4477 static void nfs4_set_cached_acl(struct inode *inode, struct nfs4_cached_acl *acl) 4478 { 4479 struct nfs_inode *nfsi = NFS_I(inode); 4480 4481 spin_lock(&inode->i_lock); 4482 kfree(nfsi->nfs4_acl); 4483 nfsi->nfs4_acl = acl; 4484 spin_unlock(&inode->i_lock); 4485 } 4486 4487 static void nfs4_zap_acl_attr(struct inode *inode) 4488 { 4489 nfs4_set_cached_acl(inode, NULL); 4490 } 4491 4492 static inline ssize_t nfs4_read_cached_acl(struct inode *inode, char *buf, size_t buflen) 4493 { 4494 struct nfs_inode *nfsi = NFS_I(inode); 4495 struct nfs4_cached_acl *acl; 4496 int ret = -ENOENT; 4497 4498 spin_lock(&inode->i_lock); 4499 acl = nfsi->nfs4_acl; 4500 if (acl == NULL) 4501 goto out; 4502 if (buf == NULL) /* user is just asking for length */ 4503 goto out_len; 4504 if (acl->cached == 0) 4505 goto out; 4506 ret = -ERANGE; /* see getxattr(2) man page */ 4507 if (acl->len > buflen) 4508 goto out; 4509 memcpy(buf, acl->data, acl->len); 4510 out_len: 4511 ret = acl->len; 4512 out: 4513 spin_unlock(&inode->i_lock); 4514 return ret; 4515 } 4516 4517 static void nfs4_write_cached_acl(struct inode *inode, struct page **pages, size_t pgbase, size_t acl_len) 4518 { 4519 struct nfs4_cached_acl *acl; 4520 size_t buflen = sizeof(*acl) + acl_len; 4521 4522 if (buflen <= PAGE_SIZE) { 4523 acl = kmalloc(buflen, GFP_KERNEL); 4524 if (acl == NULL) 4525 goto out; 4526 acl->cached = 1; 4527 _copy_from_pages(acl->data, pages, pgbase, acl_len); 4528 } else { 4529 acl = kmalloc(sizeof(*acl), GFP_KERNEL); 4530 if (acl == NULL) 4531 goto out; 4532 acl->cached = 0; 4533 } 4534 acl->len = acl_len; 4535 out: 4536 nfs4_set_cached_acl(inode, acl); 4537 } 4538 4539 /* 4540 * The getxattr API returns the required buffer length when called with a 4541 * NULL buf. The NFSv4 acl tool then calls getxattr again after allocating 4542 * the required buf. On a NULL buf, we send a page of data to the server 4543 * guessing that the ACL request can be serviced by a page. If so, we cache 4544 * up to the page of ACL data, and the 2nd call to getxattr is serviced by 4545 * the cache. If not so, we throw away the page, and cache the required 4546 * length. The next getxattr call will then produce another round trip to 4547 * the server, this time with the input buf of the required size. 4548 */ 4549 static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen) 4550 { 4551 struct page *pages[NFS4ACL_MAXPAGES] = {NULL, }; 4552 struct nfs_getaclargs args = { 4553 .fh = NFS_FH(inode), 4554 .acl_pages = pages, 4555 .acl_len = buflen, 4556 }; 4557 struct nfs_getaclres res = { 4558 .acl_len = buflen, 4559 }; 4560 struct rpc_message msg = { 4561 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETACL], 4562 .rpc_argp = &args, 4563 .rpc_resp = &res, 4564 }; 4565 unsigned int npages = DIV_ROUND_UP(buflen, PAGE_SIZE); 4566 int ret = -ENOMEM, i; 4567 4568 /* As long as we're doing a round trip to the server anyway, 4569 * let's be prepared for a page of acl data. */ 4570 if (npages == 0) 4571 npages = 1; 4572 if (npages > ARRAY_SIZE(pages)) 4573 return -ERANGE; 4574 4575 for (i = 0; i < npages; i++) { 4576 pages[i] = alloc_page(GFP_KERNEL); 4577 if (!pages[i]) 4578 goto out_free; 4579 } 4580 4581 /* for decoding across pages */ 4582 res.acl_scratch = alloc_page(GFP_KERNEL); 4583 if (!res.acl_scratch) 4584 goto out_free; 4585 4586 args.acl_len = npages * PAGE_SIZE; 4587 args.acl_pgbase = 0; 4588 4589 dprintk("%s buf %p buflen %zu npages %d args.acl_len %zu\n", 4590 __func__, buf, buflen, npages, args.acl_len); 4591 ret = nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode), 4592 &msg, &args.seq_args, &res.seq_res, 0); 4593 if (ret) 4594 goto out_free; 4595 4596 /* Handle the case where the passed-in buffer is too short */ 4597 if (res.acl_flags & NFS4_ACL_TRUNC) { 4598 /* Did the user only issue a request for the acl length? */ 4599 if (buf == NULL) 4600 goto out_ok; 4601 ret = -ERANGE; 4602 goto out_free; 4603 } 4604 nfs4_write_cached_acl(inode, pages, res.acl_data_offset, res.acl_len); 4605 if (buf) { 4606 if (res.acl_len > buflen) { 4607 ret = -ERANGE; 4608 goto out_free; 4609 } 4610 _copy_from_pages(buf, pages, res.acl_data_offset, res.acl_len); 4611 } 4612 out_ok: 4613 ret = res.acl_len; 4614 out_free: 4615 for (i = 0; i < npages; i++) 4616 if (pages[i]) 4617 __free_page(pages[i]); 4618 if (res.acl_scratch) 4619 __free_page(res.acl_scratch); 4620 return ret; 4621 } 4622 4623 static ssize_t nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen) 4624 { 4625 struct nfs4_exception exception = { }; 4626 ssize_t ret; 4627 do { 4628 ret = __nfs4_get_acl_uncached(inode, buf, buflen); 4629 trace_nfs4_get_acl(inode, ret); 4630 if (ret >= 0) 4631 break; 4632 ret = nfs4_handle_exception(NFS_SERVER(inode), ret, &exception); 4633 } while (exception.retry); 4634 return ret; 4635 } 4636 4637 static ssize_t nfs4_proc_get_acl(struct inode *inode, void *buf, size_t buflen) 4638 { 4639 struct nfs_server *server = NFS_SERVER(inode); 4640 int ret; 4641 4642 if (!nfs4_server_supports_acls(server)) 4643 return -EOPNOTSUPP; 4644 ret = nfs_revalidate_inode(server, inode); 4645 if (ret < 0) 4646 return ret; 4647 if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_ACL) 4648 nfs_zap_acl_cache(inode); 4649 ret = nfs4_read_cached_acl(inode, buf, buflen); 4650 if (ret != -ENOENT) 4651 /* -ENOENT is returned if there is no ACL or if there is an ACL 4652 * but no cached acl data, just the acl length */ 4653 return ret; 4654 return nfs4_get_acl_uncached(inode, buf, buflen); 4655 } 4656 4657 static int __nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen) 4658 { 4659 struct nfs_server *server = NFS_SERVER(inode); 4660 struct page *pages[NFS4ACL_MAXPAGES]; 4661 struct nfs_setaclargs arg = { 4662 .fh = NFS_FH(inode), 4663 .acl_pages = pages, 4664 .acl_len = buflen, 4665 }; 4666 struct nfs_setaclres res; 4667 struct rpc_message msg = { 4668 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETACL], 4669 .rpc_argp = &arg, 4670 .rpc_resp = &res, 4671 }; 4672 unsigned int npages = DIV_ROUND_UP(buflen, PAGE_SIZE); 4673 int ret, i; 4674 4675 if (!nfs4_server_supports_acls(server)) 4676 return -EOPNOTSUPP; 4677 if (npages > ARRAY_SIZE(pages)) 4678 return -ERANGE; 4679 i = buf_to_pages_noslab(buf, buflen, arg.acl_pages, &arg.acl_pgbase); 4680 if (i < 0) 4681 return i; 4682 nfs4_inode_return_delegation(inode); 4683 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); 4684 4685 /* 4686 * Free each page after tx, so the only ref left is 4687 * held by the network stack 4688 */ 4689 for (; i > 0; i--) 4690 put_page(pages[i-1]); 4691 4692 /* 4693 * Acl update can result in inode attribute update. 4694 * so mark the attribute cache invalid. 4695 */ 4696 spin_lock(&inode->i_lock); 4697 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATTR; 4698 spin_unlock(&inode->i_lock); 4699 nfs_access_zap_cache(inode); 4700 nfs_zap_acl_cache(inode); 4701 return ret; 4702 } 4703 4704 static int nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen) 4705 { 4706 struct nfs4_exception exception = { }; 4707 int err; 4708 do { 4709 err = __nfs4_proc_set_acl(inode, buf, buflen); 4710 trace_nfs4_set_acl(inode, err); 4711 err = nfs4_handle_exception(NFS_SERVER(inode), err, 4712 &exception); 4713 } while (exception.retry); 4714 return err; 4715 } 4716 4717 #ifdef CONFIG_NFS_V4_SECURITY_LABEL 4718 static int _nfs4_get_security_label(struct inode *inode, void *buf, 4719 size_t buflen) 4720 { 4721 struct nfs_server *server = NFS_SERVER(inode); 4722 struct nfs_fattr fattr; 4723 struct nfs4_label label = {0, 0, buflen, buf}; 4724 4725 u32 bitmask[3] = { 0, 0, FATTR4_WORD2_SECURITY_LABEL }; 4726 struct nfs4_getattr_arg arg = { 4727 .fh = NFS_FH(inode), 4728 .bitmask = bitmask, 4729 }; 4730 struct nfs4_getattr_res res = { 4731 .fattr = &fattr, 4732 .label = &label, 4733 .server = server, 4734 }; 4735 struct rpc_message msg = { 4736 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETATTR], 4737 .rpc_argp = &arg, 4738 .rpc_resp = &res, 4739 }; 4740 int ret; 4741 4742 nfs_fattr_init(&fattr); 4743 4744 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 0); 4745 if (ret) 4746 return ret; 4747 if (!(fattr.valid & NFS_ATTR_FATTR_V4_SECURITY_LABEL)) 4748 return -ENOENT; 4749 if (buflen < label.len) 4750 return -ERANGE; 4751 return 0; 4752 } 4753 4754 static int nfs4_get_security_label(struct inode *inode, void *buf, 4755 size_t buflen) 4756 { 4757 struct nfs4_exception exception = { }; 4758 int err; 4759 4760 if (!nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL)) 4761 return -EOPNOTSUPP; 4762 4763 do { 4764 err = _nfs4_get_security_label(inode, buf, buflen); 4765 trace_nfs4_get_security_label(inode, err); 4766 err = nfs4_handle_exception(NFS_SERVER(inode), err, 4767 &exception); 4768 } while (exception.retry); 4769 return err; 4770 } 4771 4772 static int _nfs4_do_set_security_label(struct inode *inode, 4773 struct nfs4_label *ilabel, 4774 struct nfs_fattr *fattr, 4775 struct nfs4_label *olabel) 4776 { 4777 4778 struct iattr sattr = {0}; 4779 struct nfs_server *server = NFS_SERVER(inode); 4780 const u32 bitmask[3] = { 0, 0, FATTR4_WORD2_SECURITY_LABEL }; 4781 struct nfs_setattrargs arg = { 4782 .fh = NFS_FH(inode), 4783 .iap = &sattr, 4784 .server = server, 4785 .bitmask = bitmask, 4786 .label = ilabel, 4787 }; 4788 struct nfs_setattrres res = { 4789 .fattr = fattr, 4790 .label = olabel, 4791 .server = server, 4792 }; 4793 struct rpc_message msg = { 4794 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETATTR], 4795 .rpc_argp = &arg, 4796 .rpc_resp = &res, 4797 }; 4798 int status; 4799 4800 nfs4_stateid_copy(&arg.stateid, &zero_stateid); 4801 4802 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); 4803 if (status) 4804 dprintk("%s failed: %d\n", __func__, status); 4805 4806 return status; 4807 } 4808 4809 static int nfs4_do_set_security_label(struct inode *inode, 4810 struct nfs4_label *ilabel, 4811 struct nfs_fattr *fattr, 4812 struct nfs4_label *olabel) 4813 { 4814 struct nfs4_exception exception = { }; 4815 int err; 4816 4817 do { 4818 err = _nfs4_do_set_security_label(inode, ilabel, 4819 fattr, olabel); 4820 trace_nfs4_set_security_label(inode, err); 4821 err = nfs4_handle_exception(NFS_SERVER(inode), err, 4822 &exception); 4823 } while (exception.retry); 4824 return err; 4825 } 4826 4827 static int 4828 nfs4_set_security_label(struct dentry *dentry, const void *buf, size_t buflen) 4829 { 4830 struct nfs4_label ilabel, *olabel = NULL; 4831 struct nfs_fattr fattr; 4832 struct rpc_cred *cred; 4833 struct inode *inode = dentry->d_inode; 4834 int status; 4835 4836 if (!nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL)) 4837 return -EOPNOTSUPP; 4838 4839 nfs_fattr_init(&fattr); 4840 4841 ilabel.pi = 0; 4842 ilabel.lfs = 0; 4843 ilabel.label = (char *)buf; 4844 ilabel.len = buflen; 4845 4846 cred = rpc_lookup_cred(); 4847 if (IS_ERR(cred)) 4848 return PTR_ERR(cred); 4849 4850 olabel = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL); 4851 if (IS_ERR(olabel)) { 4852 status = -PTR_ERR(olabel); 4853 goto out; 4854 } 4855 4856 status = nfs4_do_set_security_label(inode, &ilabel, &fattr, olabel); 4857 if (status == 0) 4858 nfs_setsecurity(inode, &fattr, olabel); 4859 4860 nfs4_label_free(olabel); 4861 out: 4862 put_rpccred(cred); 4863 return status; 4864 } 4865 #endif /* CONFIG_NFS_V4_SECURITY_LABEL */ 4866 4867 4868 static int 4869 nfs4_async_handle_error(struct rpc_task *task, const struct nfs_server *server, 4870 struct nfs4_state *state, long *timeout) 4871 { 4872 struct nfs_client *clp = server->nfs_client; 4873 4874 if (task->tk_status >= 0) 4875 return 0; 4876 switch(task->tk_status) { 4877 case -NFS4ERR_DELEG_REVOKED: 4878 case -NFS4ERR_ADMIN_REVOKED: 4879 case -NFS4ERR_BAD_STATEID: 4880 case -NFS4ERR_OPENMODE: 4881 if (state == NULL) 4882 break; 4883 if (nfs4_schedule_stateid_recovery(server, state) < 0) 4884 goto recovery_failed; 4885 goto wait_on_recovery; 4886 case -NFS4ERR_EXPIRED: 4887 if (state != NULL) { 4888 if (nfs4_schedule_stateid_recovery(server, state) < 0) 4889 goto recovery_failed; 4890 } 4891 case -NFS4ERR_STALE_STATEID: 4892 case -NFS4ERR_STALE_CLIENTID: 4893 nfs4_schedule_lease_recovery(clp); 4894 goto wait_on_recovery; 4895 case -NFS4ERR_MOVED: 4896 if (nfs4_schedule_migration_recovery(server) < 0) 4897 goto recovery_failed; 4898 goto wait_on_recovery; 4899 case -NFS4ERR_LEASE_MOVED: 4900 nfs4_schedule_lease_moved_recovery(clp); 4901 goto wait_on_recovery; 4902 #if defined(CONFIG_NFS_V4_1) 4903 case -NFS4ERR_BADSESSION: 4904 case -NFS4ERR_BADSLOT: 4905 case -NFS4ERR_BAD_HIGH_SLOT: 4906 case -NFS4ERR_DEADSESSION: 4907 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 4908 case -NFS4ERR_SEQ_FALSE_RETRY: 4909 case -NFS4ERR_SEQ_MISORDERED: 4910 dprintk("%s ERROR %d, Reset session\n", __func__, 4911 task->tk_status); 4912 nfs4_schedule_session_recovery(clp->cl_session, task->tk_status); 4913 goto wait_on_recovery; 4914 #endif /* CONFIG_NFS_V4_1 */ 4915 case -NFS4ERR_DELAY: 4916 nfs_inc_server_stats(server, NFSIOS_DELAY); 4917 rpc_delay(task, nfs4_update_delay(timeout)); 4918 goto restart_call; 4919 case -NFS4ERR_GRACE: 4920 rpc_delay(task, NFS4_POLL_RETRY_MAX); 4921 case -NFS4ERR_RETRY_UNCACHED_REP: 4922 case -NFS4ERR_OLD_STATEID: 4923 goto restart_call; 4924 } 4925 task->tk_status = nfs4_map_errors(task->tk_status); 4926 return 0; 4927 recovery_failed: 4928 task->tk_status = -EIO; 4929 return 0; 4930 wait_on_recovery: 4931 rpc_sleep_on(&clp->cl_rpcwaitq, task, NULL); 4932 if (test_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) == 0) 4933 rpc_wake_up_queued_task(&clp->cl_rpcwaitq, task); 4934 if (test_bit(NFS_MIG_FAILED, &server->mig_status)) 4935 goto recovery_failed; 4936 restart_call: 4937 task->tk_status = 0; 4938 return -EAGAIN; 4939 } 4940 4941 static void nfs4_init_boot_verifier(const struct nfs_client *clp, 4942 nfs4_verifier *bootverf) 4943 { 4944 __be32 verf[2]; 4945 4946 if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) { 4947 /* An impossible timestamp guarantees this value 4948 * will never match a generated boot time. */ 4949 verf[0] = 0; 4950 verf[1] = cpu_to_be32(NSEC_PER_SEC + 1); 4951 } else { 4952 struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id); 4953 verf[0] = cpu_to_be32(nn->boot_time.tv_sec); 4954 verf[1] = cpu_to_be32(nn->boot_time.tv_nsec); 4955 } 4956 memcpy(bootverf->data, verf, sizeof(bootverf->data)); 4957 } 4958 4959 static unsigned int 4960 nfs4_init_nonuniform_client_string(struct nfs_client *clp, 4961 char *buf, size_t len) 4962 { 4963 unsigned int result; 4964 4965 if (clp->cl_owner_id != NULL) 4966 return strlcpy(buf, clp->cl_owner_id, len); 4967 4968 rcu_read_lock(); 4969 result = scnprintf(buf, len, "Linux NFSv4.0 %s/%s %s", 4970 clp->cl_ipaddr, 4971 rpc_peeraddr2str(clp->cl_rpcclient, 4972 RPC_DISPLAY_ADDR), 4973 rpc_peeraddr2str(clp->cl_rpcclient, 4974 RPC_DISPLAY_PROTO)); 4975 rcu_read_unlock(); 4976 clp->cl_owner_id = kstrdup(buf, GFP_KERNEL); 4977 return result; 4978 } 4979 4980 static unsigned int 4981 nfs4_init_uniform_client_string(struct nfs_client *clp, 4982 char *buf, size_t len) 4983 { 4984 const char *nodename = clp->cl_rpcclient->cl_nodename; 4985 unsigned int result; 4986 4987 if (clp->cl_owner_id != NULL) 4988 return strlcpy(buf, clp->cl_owner_id, len); 4989 4990 if (nfs4_client_id_uniquifier[0] != '\0') 4991 result = scnprintf(buf, len, "Linux NFSv%u.%u %s/%s", 4992 clp->rpc_ops->version, 4993 clp->cl_minorversion, 4994 nfs4_client_id_uniquifier, 4995 nodename); 4996 else 4997 result = scnprintf(buf, len, "Linux NFSv%u.%u %s", 4998 clp->rpc_ops->version, clp->cl_minorversion, 4999 nodename); 5000 clp->cl_owner_id = kstrdup(buf, GFP_KERNEL); 5001 return result; 5002 } 5003 5004 /* 5005 * nfs4_callback_up_net() starts only "tcp" and "tcp6" callback 5006 * services. Advertise one based on the address family of the 5007 * clientaddr. 5008 */ 5009 static unsigned int 5010 nfs4_init_callback_netid(const struct nfs_client *clp, char *buf, size_t len) 5011 { 5012 if (strchr(clp->cl_ipaddr, ':') != NULL) 5013 return scnprintf(buf, len, "tcp6"); 5014 else 5015 return scnprintf(buf, len, "tcp"); 5016 } 5017 5018 static void nfs4_setclientid_done(struct rpc_task *task, void *calldata) 5019 { 5020 struct nfs4_setclientid *sc = calldata; 5021 5022 if (task->tk_status == 0) 5023 sc->sc_cred = get_rpccred(task->tk_rqstp->rq_cred); 5024 } 5025 5026 static const struct rpc_call_ops nfs4_setclientid_ops = { 5027 .rpc_call_done = nfs4_setclientid_done, 5028 }; 5029 5030 /** 5031 * nfs4_proc_setclientid - Negotiate client ID 5032 * @clp: state data structure 5033 * @program: RPC program for NFSv4 callback service 5034 * @port: IP port number for NFS4 callback service 5035 * @cred: RPC credential to use for this call 5036 * @res: where to place the result 5037 * 5038 * Returns zero, a negative errno, or a negative NFS4ERR status code. 5039 */ 5040 int nfs4_proc_setclientid(struct nfs_client *clp, u32 program, 5041 unsigned short port, struct rpc_cred *cred, 5042 struct nfs4_setclientid_res *res) 5043 { 5044 nfs4_verifier sc_verifier; 5045 struct nfs4_setclientid setclientid = { 5046 .sc_verifier = &sc_verifier, 5047 .sc_prog = program, 5048 .sc_cb_ident = clp->cl_cb_ident, 5049 }; 5050 struct rpc_message msg = { 5051 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID], 5052 .rpc_argp = &setclientid, 5053 .rpc_resp = res, 5054 .rpc_cred = cred, 5055 }; 5056 struct rpc_task *task; 5057 struct rpc_task_setup task_setup_data = { 5058 .rpc_client = clp->cl_rpcclient, 5059 .rpc_message = &msg, 5060 .callback_ops = &nfs4_setclientid_ops, 5061 .callback_data = &setclientid, 5062 .flags = RPC_TASK_TIMEOUT, 5063 }; 5064 int status; 5065 5066 /* nfs_client_id4 */ 5067 nfs4_init_boot_verifier(clp, &sc_verifier); 5068 if (test_bit(NFS_CS_MIGRATION, &clp->cl_flags)) 5069 setclientid.sc_name_len = 5070 nfs4_init_uniform_client_string(clp, 5071 setclientid.sc_name, 5072 sizeof(setclientid.sc_name)); 5073 else 5074 setclientid.sc_name_len = 5075 nfs4_init_nonuniform_client_string(clp, 5076 setclientid.sc_name, 5077 sizeof(setclientid.sc_name)); 5078 /* cb_client4 */ 5079 setclientid.sc_netid_len = 5080 nfs4_init_callback_netid(clp, 5081 setclientid.sc_netid, 5082 sizeof(setclientid.sc_netid)); 5083 setclientid.sc_uaddr_len = scnprintf(setclientid.sc_uaddr, 5084 sizeof(setclientid.sc_uaddr), "%s.%u.%u", 5085 clp->cl_ipaddr, port >> 8, port & 255); 5086 5087 dprintk("NFS call setclientid auth=%s, '%.*s'\n", 5088 clp->cl_rpcclient->cl_auth->au_ops->au_name, 5089 setclientid.sc_name_len, setclientid.sc_name); 5090 task = rpc_run_task(&task_setup_data); 5091 if (IS_ERR(task)) { 5092 status = PTR_ERR(task); 5093 goto out; 5094 } 5095 status = task->tk_status; 5096 if (setclientid.sc_cred) { 5097 clp->cl_acceptor = rpcauth_stringify_acceptor(setclientid.sc_cred); 5098 put_rpccred(setclientid.sc_cred); 5099 } 5100 rpc_put_task(task); 5101 out: 5102 trace_nfs4_setclientid(clp, status); 5103 dprintk("NFS reply setclientid: %d\n", status); 5104 return status; 5105 } 5106 5107 /** 5108 * nfs4_proc_setclientid_confirm - Confirm client ID 5109 * @clp: state data structure 5110 * @res: result of a previous SETCLIENTID 5111 * @cred: RPC credential to use for this call 5112 * 5113 * Returns zero, a negative errno, or a negative NFS4ERR status code. 5114 */ 5115 int nfs4_proc_setclientid_confirm(struct nfs_client *clp, 5116 struct nfs4_setclientid_res *arg, 5117 struct rpc_cred *cred) 5118 { 5119 struct rpc_message msg = { 5120 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID_CONFIRM], 5121 .rpc_argp = arg, 5122 .rpc_cred = cred, 5123 }; 5124 int status; 5125 5126 dprintk("NFS call setclientid_confirm auth=%s, (client ID %llx)\n", 5127 clp->cl_rpcclient->cl_auth->au_ops->au_name, 5128 clp->cl_clientid); 5129 status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT); 5130 trace_nfs4_setclientid_confirm(clp, status); 5131 dprintk("NFS reply setclientid_confirm: %d\n", status); 5132 return status; 5133 } 5134 5135 struct nfs4_delegreturndata { 5136 struct nfs4_delegreturnargs args; 5137 struct nfs4_delegreturnres res; 5138 struct nfs_fh fh; 5139 nfs4_stateid stateid; 5140 unsigned long timestamp; 5141 struct nfs_fattr fattr; 5142 int rpc_status; 5143 struct inode *inode; 5144 bool roc; 5145 u32 roc_barrier; 5146 }; 5147 5148 static void nfs4_delegreturn_done(struct rpc_task *task, void *calldata) 5149 { 5150 struct nfs4_delegreturndata *data = calldata; 5151 5152 if (!nfs4_sequence_done(task, &data->res.seq_res)) 5153 return; 5154 5155 trace_nfs4_delegreturn_exit(&data->args, &data->res, task->tk_status); 5156 switch (task->tk_status) { 5157 case 0: 5158 renew_lease(data->res.server, data->timestamp); 5159 case -NFS4ERR_ADMIN_REVOKED: 5160 case -NFS4ERR_DELEG_REVOKED: 5161 case -NFS4ERR_BAD_STATEID: 5162 case -NFS4ERR_OLD_STATEID: 5163 case -NFS4ERR_STALE_STATEID: 5164 case -NFS4ERR_EXPIRED: 5165 task->tk_status = 0; 5166 if (data->roc) 5167 pnfs_roc_set_barrier(data->inode, data->roc_barrier); 5168 break; 5169 default: 5170 if (nfs4_async_handle_error(task, data->res.server, 5171 NULL, NULL) == -EAGAIN) { 5172 rpc_restart_call_prepare(task); 5173 return; 5174 } 5175 } 5176 data->rpc_status = task->tk_status; 5177 } 5178 5179 static void nfs4_delegreturn_release(void *calldata) 5180 { 5181 struct nfs4_delegreturndata *data = calldata; 5182 struct inode *inode = data->inode; 5183 5184 if (inode) { 5185 if (data->roc) 5186 pnfs_roc_release(inode); 5187 nfs_iput_and_deactive(inode); 5188 } 5189 kfree(calldata); 5190 } 5191 5192 static void nfs4_delegreturn_prepare(struct rpc_task *task, void *data) 5193 { 5194 struct nfs4_delegreturndata *d_data; 5195 5196 d_data = (struct nfs4_delegreturndata *)data; 5197 5198 if (d_data->roc && 5199 pnfs_roc_drain(d_data->inode, &d_data->roc_barrier, task)) 5200 return; 5201 5202 nfs4_setup_sequence(d_data->res.server, 5203 &d_data->args.seq_args, 5204 &d_data->res.seq_res, 5205 task); 5206 } 5207 5208 static const struct rpc_call_ops nfs4_delegreturn_ops = { 5209 .rpc_call_prepare = nfs4_delegreturn_prepare, 5210 .rpc_call_done = nfs4_delegreturn_done, 5211 .rpc_release = nfs4_delegreturn_release, 5212 }; 5213 5214 static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync) 5215 { 5216 struct nfs4_delegreturndata *data; 5217 struct nfs_server *server = NFS_SERVER(inode); 5218 struct rpc_task *task; 5219 struct rpc_message msg = { 5220 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DELEGRETURN], 5221 .rpc_cred = cred, 5222 }; 5223 struct rpc_task_setup task_setup_data = { 5224 .rpc_client = server->client, 5225 .rpc_message = &msg, 5226 .callback_ops = &nfs4_delegreturn_ops, 5227 .flags = RPC_TASK_ASYNC, 5228 }; 5229 int status = 0; 5230 5231 data = kzalloc(sizeof(*data), GFP_NOFS); 5232 if (data == NULL) 5233 return -ENOMEM; 5234 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1); 5235 data->args.fhandle = &data->fh; 5236 data->args.stateid = &data->stateid; 5237 data->args.bitmask = server->cache_consistency_bitmask; 5238 nfs_copy_fh(&data->fh, NFS_FH(inode)); 5239 nfs4_stateid_copy(&data->stateid, stateid); 5240 data->res.fattr = &data->fattr; 5241 data->res.server = server; 5242 nfs_fattr_init(data->res.fattr); 5243 data->timestamp = jiffies; 5244 data->rpc_status = 0; 5245 data->inode = nfs_igrab_and_active(inode); 5246 if (data->inode) 5247 data->roc = nfs4_roc(inode); 5248 5249 task_setup_data.callback_data = data; 5250 msg.rpc_argp = &data->args; 5251 msg.rpc_resp = &data->res; 5252 task = rpc_run_task(&task_setup_data); 5253 if (IS_ERR(task)) 5254 return PTR_ERR(task); 5255 if (!issync) 5256 goto out; 5257 status = nfs4_wait_for_completion_rpc_task(task); 5258 if (status != 0) 5259 goto out; 5260 status = data->rpc_status; 5261 if (status == 0) 5262 nfs_post_op_update_inode_force_wcc(inode, &data->fattr); 5263 else 5264 nfs_refresh_inode(inode, &data->fattr); 5265 out: 5266 rpc_put_task(task); 5267 return status; 5268 } 5269 5270 int nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync) 5271 { 5272 struct nfs_server *server = NFS_SERVER(inode); 5273 struct nfs4_exception exception = { }; 5274 int err; 5275 do { 5276 err = _nfs4_proc_delegreturn(inode, cred, stateid, issync); 5277 trace_nfs4_delegreturn(inode, err); 5278 switch (err) { 5279 case -NFS4ERR_STALE_STATEID: 5280 case -NFS4ERR_EXPIRED: 5281 case 0: 5282 return 0; 5283 } 5284 err = nfs4_handle_exception(server, err, &exception); 5285 } while (exception.retry); 5286 return err; 5287 } 5288 5289 #define NFS4_LOCK_MINTIMEOUT (1 * HZ) 5290 #define NFS4_LOCK_MAXTIMEOUT (30 * HZ) 5291 5292 /* 5293 * sleep, with exponential backoff, and retry the LOCK operation. 5294 */ 5295 static unsigned long 5296 nfs4_set_lock_task_retry(unsigned long timeout) 5297 { 5298 freezable_schedule_timeout_killable_unsafe(timeout); 5299 timeout <<= 1; 5300 if (timeout > NFS4_LOCK_MAXTIMEOUT) 5301 return NFS4_LOCK_MAXTIMEOUT; 5302 return timeout; 5303 } 5304 5305 static int _nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request) 5306 { 5307 struct inode *inode = state->inode; 5308 struct nfs_server *server = NFS_SERVER(inode); 5309 struct nfs_client *clp = server->nfs_client; 5310 struct nfs_lockt_args arg = { 5311 .fh = NFS_FH(inode), 5312 .fl = request, 5313 }; 5314 struct nfs_lockt_res res = { 5315 .denied = request, 5316 }; 5317 struct rpc_message msg = { 5318 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKT], 5319 .rpc_argp = &arg, 5320 .rpc_resp = &res, 5321 .rpc_cred = state->owner->so_cred, 5322 }; 5323 struct nfs4_lock_state *lsp; 5324 int status; 5325 5326 arg.lock_owner.clientid = clp->cl_clientid; 5327 status = nfs4_set_lock_state(state, request); 5328 if (status != 0) 5329 goto out; 5330 lsp = request->fl_u.nfs4_fl.owner; 5331 arg.lock_owner.id = lsp->ls_seqid.owner_id; 5332 arg.lock_owner.s_dev = server->s_dev; 5333 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); 5334 switch (status) { 5335 case 0: 5336 request->fl_type = F_UNLCK; 5337 break; 5338 case -NFS4ERR_DENIED: 5339 status = 0; 5340 } 5341 request->fl_ops->fl_release_private(request); 5342 request->fl_ops = NULL; 5343 out: 5344 return status; 5345 } 5346 5347 static int nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request) 5348 { 5349 struct nfs4_exception exception = { }; 5350 int err; 5351 5352 do { 5353 err = _nfs4_proc_getlk(state, cmd, request); 5354 trace_nfs4_get_lock(request, state, cmd, err); 5355 err = nfs4_handle_exception(NFS_SERVER(state->inode), err, 5356 &exception); 5357 } while (exception.retry); 5358 return err; 5359 } 5360 5361 static int do_vfs_lock(struct file *file, struct file_lock *fl) 5362 { 5363 int res = 0; 5364 switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) { 5365 case FL_POSIX: 5366 res = posix_lock_file_wait(file, fl); 5367 break; 5368 case FL_FLOCK: 5369 res = flock_lock_file_wait(file, fl); 5370 break; 5371 default: 5372 BUG(); 5373 } 5374 return res; 5375 } 5376 5377 struct nfs4_unlockdata { 5378 struct nfs_locku_args arg; 5379 struct nfs_locku_res res; 5380 struct nfs4_lock_state *lsp; 5381 struct nfs_open_context *ctx; 5382 struct file_lock fl; 5383 const struct nfs_server *server; 5384 unsigned long timestamp; 5385 }; 5386 5387 static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl, 5388 struct nfs_open_context *ctx, 5389 struct nfs4_lock_state *lsp, 5390 struct nfs_seqid *seqid) 5391 { 5392 struct nfs4_unlockdata *p; 5393 struct inode *inode = lsp->ls_state->inode; 5394 5395 p = kzalloc(sizeof(*p), GFP_NOFS); 5396 if (p == NULL) 5397 return NULL; 5398 p->arg.fh = NFS_FH(inode); 5399 p->arg.fl = &p->fl; 5400 p->arg.seqid = seqid; 5401 p->res.seqid = seqid; 5402 p->lsp = lsp; 5403 atomic_inc(&lsp->ls_count); 5404 /* Ensure we don't close file until we're done freeing locks! */ 5405 p->ctx = get_nfs_open_context(ctx); 5406 memcpy(&p->fl, fl, sizeof(p->fl)); 5407 p->server = NFS_SERVER(inode); 5408 return p; 5409 } 5410 5411 static void nfs4_locku_release_calldata(void *data) 5412 { 5413 struct nfs4_unlockdata *calldata = data; 5414 nfs_free_seqid(calldata->arg.seqid); 5415 nfs4_put_lock_state(calldata->lsp); 5416 put_nfs_open_context(calldata->ctx); 5417 kfree(calldata); 5418 } 5419 5420 static void nfs4_locku_done(struct rpc_task *task, void *data) 5421 { 5422 struct nfs4_unlockdata *calldata = data; 5423 5424 if (!nfs4_sequence_done(task, &calldata->res.seq_res)) 5425 return; 5426 switch (task->tk_status) { 5427 case 0: 5428 renew_lease(calldata->server, calldata->timestamp); 5429 do_vfs_lock(calldata->fl.fl_file, &calldata->fl); 5430 if (nfs4_update_lock_stateid(calldata->lsp, 5431 &calldata->res.stateid)) 5432 break; 5433 case -NFS4ERR_BAD_STATEID: 5434 case -NFS4ERR_OLD_STATEID: 5435 case -NFS4ERR_STALE_STATEID: 5436 case -NFS4ERR_EXPIRED: 5437 if (!nfs4_stateid_match(&calldata->arg.stateid, 5438 &calldata->lsp->ls_stateid)) 5439 rpc_restart_call_prepare(task); 5440 break; 5441 default: 5442 if (nfs4_async_handle_error(task, calldata->server, 5443 NULL, NULL) == -EAGAIN) 5444 rpc_restart_call_prepare(task); 5445 } 5446 nfs_release_seqid(calldata->arg.seqid); 5447 } 5448 5449 static void nfs4_locku_prepare(struct rpc_task *task, void *data) 5450 { 5451 struct nfs4_unlockdata *calldata = data; 5452 5453 if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0) 5454 goto out_wait; 5455 nfs4_stateid_copy(&calldata->arg.stateid, &calldata->lsp->ls_stateid); 5456 if (test_bit(NFS_LOCK_INITIALIZED, &calldata->lsp->ls_flags) == 0) { 5457 /* Note: exit _without_ running nfs4_locku_done */ 5458 goto out_no_action; 5459 } 5460 calldata->timestamp = jiffies; 5461 if (nfs4_setup_sequence(calldata->server, 5462 &calldata->arg.seq_args, 5463 &calldata->res.seq_res, 5464 task) != 0) 5465 nfs_release_seqid(calldata->arg.seqid); 5466 return; 5467 out_no_action: 5468 task->tk_action = NULL; 5469 out_wait: 5470 nfs4_sequence_done(task, &calldata->res.seq_res); 5471 } 5472 5473 static const struct rpc_call_ops nfs4_locku_ops = { 5474 .rpc_call_prepare = nfs4_locku_prepare, 5475 .rpc_call_done = nfs4_locku_done, 5476 .rpc_release = nfs4_locku_release_calldata, 5477 }; 5478 5479 static struct rpc_task *nfs4_do_unlck(struct file_lock *fl, 5480 struct nfs_open_context *ctx, 5481 struct nfs4_lock_state *lsp, 5482 struct nfs_seqid *seqid) 5483 { 5484 struct nfs4_unlockdata *data; 5485 struct rpc_message msg = { 5486 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKU], 5487 .rpc_cred = ctx->cred, 5488 }; 5489 struct rpc_task_setup task_setup_data = { 5490 .rpc_client = NFS_CLIENT(lsp->ls_state->inode), 5491 .rpc_message = &msg, 5492 .callback_ops = &nfs4_locku_ops, 5493 .workqueue = nfsiod_workqueue, 5494 .flags = RPC_TASK_ASYNC, 5495 }; 5496 5497 nfs4_state_protect(NFS_SERVER(lsp->ls_state->inode)->nfs_client, 5498 NFS_SP4_MACH_CRED_CLEANUP, &task_setup_data.rpc_client, &msg); 5499 5500 /* Ensure this is an unlock - when canceling a lock, the 5501 * canceled lock is passed in, and it won't be an unlock. 5502 */ 5503 fl->fl_type = F_UNLCK; 5504 5505 data = nfs4_alloc_unlockdata(fl, ctx, lsp, seqid); 5506 if (data == NULL) { 5507 nfs_free_seqid(seqid); 5508 return ERR_PTR(-ENOMEM); 5509 } 5510 5511 nfs4_init_sequence(&data->arg.seq_args, &data->res.seq_res, 1); 5512 msg.rpc_argp = &data->arg; 5513 msg.rpc_resp = &data->res; 5514 task_setup_data.callback_data = data; 5515 return rpc_run_task(&task_setup_data); 5516 } 5517 5518 static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock *request) 5519 { 5520 struct inode *inode = state->inode; 5521 struct nfs4_state_owner *sp = state->owner; 5522 struct nfs_inode *nfsi = NFS_I(inode); 5523 struct nfs_seqid *seqid; 5524 struct nfs4_lock_state *lsp; 5525 struct rpc_task *task; 5526 struct nfs_seqid *(*alloc_seqid)(struct nfs_seqid_counter *, gfp_t); 5527 int status = 0; 5528 unsigned char fl_flags = request->fl_flags; 5529 5530 status = nfs4_set_lock_state(state, request); 5531 /* Unlock _before_ we do the RPC call */ 5532 request->fl_flags |= FL_EXISTS; 5533 /* Exclude nfs_delegation_claim_locks() */ 5534 mutex_lock(&sp->so_delegreturn_mutex); 5535 /* Exclude nfs4_reclaim_open_stateid() - note nesting! */ 5536 down_read(&nfsi->rwsem); 5537 if (do_vfs_lock(request->fl_file, request) == -ENOENT) { 5538 up_read(&nfsi->rwsem); 5539 mutex_unlock(&sp->so_delegreturn_mutex); 5540 goto out; 5541 } 5542 up_read(&nfsi->rwsem); 5543 mutex_unlock(&sp->so_delegreturn_mutex); 5544 if (status != 0) 5545 goto out; 5546 /* Is this a delegated lock? */ 5547 lsp = request->fl_u.nfs4_fl.owner; 5548 if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) == 0) 5549 goto out; 5550 alloc_seqid = NFS_SERVER(inode)->nfs_client->cl_mvops->alloc_seqid; 5551 seqid = alloc_seqid(&lsp->ls_seqid, GFP_KERNEL); 5552 status = -ENOMEM; 5553 if (IS_ERR(seqid)) 5554 goto out; 5555 task = nfs4_do_unlck(request, nfs_file_open_context(request->fl_file), lsp, seqid); 5556 status = PTR_ERR(task); 5557 if (IS_ERR(task)) 5558 goto out; 5559 status = nfs4_wait_for_completion_rpc_task(task); 5560 rpc_put_task(task); 5561 out: 5562 request->fl_flags = fl_flags; 5563 trace_nfs4_unlock(request, state, F_SETLK, status); 5564 return status; 5565 } 5566 5567 struct nfs4_lockdata { 5568 struct nfs_lock_args arg; 5569 struct nfs_lock_res res; 5570 struct nfs4_lock_state *lsp; 5571 struct nfs_open_context *ctx; 5572 struct file_lock fl; 5573 unsigned long timestamp; 5574 int rpc_status; 5575 int cancelled; 5576 struct nfs_server *server; 5577 }; 5578 5579 static struct nfs4_lockdata *nfs4_alloc_lockdata(struct file_lock *fl, 5580 struct nfs_open_context *ctx, struct nfs4_lock_state *lsp, 5581 gfp_t gfp_mask) 5582 { 5583 struct nfs4_lockdata *p; 5584 struct inode *inode = lsp->ls_state->inode; 5585 struct nfs_server *server = NFS_SERVER(inode); 5586 struct nfs_seqid *(*alloc_seqid)(struct nfs_seqid_counter *, gfp_t); 5587 5588 p = kzalloc(sizeof(*p), gfp_mask); 5589 if (p == NULL) 5590 return NULL; 5591 5592 p->arg.fh = NFS_FH(inode); 5593 p->arg.fl = &p->fl; 5594 p->arg.open_seqid = nfs_alloc_seqid(&lsp->ls_state->owner->so_seqid, gfp_mask); 5595 if (IS_ERR(p->arg.open_seqid)) 5596 goto out_free; 5597 alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid; 5598 p->arg.lock_seqid = alloc_seqid(&lsp->ls_seqid, gfp_mask); 5599 if (IS_ERR(p->arg.lock_seqid)) 5600 goto out_free_seqid; 5601 p->arg.lock_owner.clientid = server->nfs_client->cl_clientid; 5602 p->arg.lock_owner.id = lsp->ls_seqid.owner_id; 5603 p->arg.lock_owner.s_dev = server->s_dev; 5604 p->res.lock_seqid = p->arg.lock_seqid; 5605 p->lsp = lsp; 5606 p->server = server; 5607 atomic_inc(&lsp->ls_count); 5608 p->ctx = get_nfs_open_context(ctx); 5609 memcpy(&p->fl, fl, sizeof(p->fl)); 5610 return p; 5611 out_free_seqid: 5612 nfs_free_seqid(p->arg.open_seqid); 5613 out_free: 5614 kfree(p); 5615 return NULL; 5616 } 5617 5618 static void nfs4_lock_prepare(struct rpc_task *task, void *calldata) 5619 { 5620 struct nfs4_lockdata *data = calldata; 5621 struct nfs4_state *state = data->lsp->ls_state; 5622 5623 dprintk("%s: begin!\n", __func__); 5624 if (nfs_wait_on_sequence(data->arg.lock_seqid, task) != 0) 5625 goto out_wait; 5626 /* Do we need to do an open_to_lock_owner? */ 5627 if (!test_bit(NFS_LOCK_INITIALIZED, &data->lsp->ls_flags)) { 5628 if (nfs_wait_on_sequence(data->arg.open_seqid, task) != 0) { 5629 goto out_release_lock_seqid; 5630 } 5631 nfs4_stateid_copy(&data->arg.open_stateid, 5632 &state->open_stateid); 5633 data->arg.new_lock_owner = 1; 5634 data->res.open_seqid = data->arg.open_seqid; 5635 } else { 5636 data->arg.new_lock_owner = 0; 5637 nfs4_stateid_copy(&data->arg.lock_stateid, 5638 &data->lsp->ls_stateid); 5639 } 5640 if (!nfs4_valid_open_stateid(state)) { 5641 data->rpc_status = -EBADF; 5642 task->tk_action = NULL; 5643 goto out_release_open_seqid; 5644 } 5645 data->timestamp = jiffies; 5646 if (nfs4_setup_sequence(data->server, 5647 &data->arg.seq_args, 5648 &data->res.seq_res, 5649 task) == 0) 5650 return; 5651 out_release_open_seqid: 5652 nfs_release_seqid(data->arg.open_seqid); 5653 out_release_lock_seqid: 5654 nfs_release_seqid(data->arg.lock_seqid); 5655 out_wait: 5656 nfs4_sequence_done(task, &data->res.seq_res); 5657 dprintk("%s: done!, ret = %d\n", __func__, data->rpc_status); 5658 } 5659 5660 static void nfs4_lock_done(struct rpc_task *task, void *calldata) 5661 { 5662 struct nfs4_lockdata *data = calldata; 5663 struct nfs4_lock_state *lsp = data->lsp; 5664 5665 dprintk("%s: begin!\n", __func__); 5666 5667 if (!nfs4_sequence_done(task, &data->res.seq_res)) 5668 return; 5669 5670 data->rpc_status = task->tk_status; 5671 switch (task->tk_status) { 5672 case 0: 5673 renew_lease(NFS_SERVER(data->ctx->dentry->d_inode), 5674 data->timestamp); 5675 if (data->arg.new_lock) { 5676 data->fl.fl_flags &= ~(FL_SLEEP | FL_ACCESS); 5677 if (do_vfs_lock(data->fl.fl_file, &data->fl) < 0) { 5678 rpc_restart_call_prepare(task); 5679 break; 5680 } 5681 } 5682 if (data->arg.new_lock_owner != 0) { 5683 nfs_confirm_seqid(&lsp->ls_seqid, 0); 5684 nfs4_stateid_copy(&lsp->ls_stateid, &data->res.stateid); 5685 set_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags); 5686 } else if (!nfs4_update_lock_stateid(lsp, &data->res.stateid)) 5687 rpc_restart_call_prepare(task); 5688 break; 5689 case -NFS4ERR_BAD_STATEID: 5690 case -NFS4ERR_OLD_STATEID: 5691 case -NFS4ERR_STALE_STATEID: 5692 case -NFS4ERR_EXPIRED: 5693 if (data->arg.new_lock_owner != 0) { 5694 if (!nfs4_stateid_match(&data->arg.open_stateid, 5695 &lsp->ls_state->open_stateid)) 5696 rpc_restart_call_prepare(task); 5697 } else if (!nfs4_stateid_match(&data->arg.lock_stateid, 5698 &lsp->ls_stateid)) 5699 rpc_restart_call_prepare(task); 5700 } 5701 dprintk("%s: done, ret = %d!\n", __func__, data->rpc_status); 5702 } 5703 5704 static void nfs4_lock_release(void *calldata) 5705 { 5706 struct nfs4_lockdata *data = calldata; 5707 5708 dprintk("%s: begin!\n", __func__); 5709 nfs_free_seqid(data->arg.open_seqid); 5710 if (data->cancelled != 0) { 5711 struct rpc_task *task; 5712 task = nfs4_do_unlck(&data->fl, data->ctx, data->lsp, 5713 data->arg.lock_seqid); 5714 if (!IS_ERR(task)) 5715 rpc_put_task_async(task); 5716 dprintk("%s: cancelling lock!\n", __func__); 5717 } else 5718 nfs_free_seqid(data->arg.lock_seqid); 5719 nfs4_put_lock_state(data->lsp); 5720 put_nfs_open_context(data->ctx); 5721 kfree(data); 5722 dprintk("%s: done!\n", __func__); 5723 } 5724 5725 static const struct rpc_call_ops nfs4_lock_ops = { 5726 .rpc_call_prepare = nfs4_lock_prepare, 5727 .rpc_call_done = nfs4_lock_done, 5728 .rpc_release = nfs4_lock_release, 5729 }; 5730 5731 static void nfs4_handle_setlk_error(struct nfs_server *server, struct nfs4_lock_state *lsp, int new_lock_owner, int error) 5732 { 5733 switch (error) { 5734 case -NFS4ERR_ADMIN_REVOKED: 5735 case -NFS4ERR_BAD_STATEID: 5736 lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED; 5737 if (new_lock_owner != 0 || 5738 test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) != 0) 5739 nfs4_schedule_stateid_recovery(server, lsp->ls_state); 5740 break; 5741 case -NFS4ERR_STALE_STATEID: 5742 lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED; 5743 case -NFS4ERR_EXPIRED: 5744 nfs4_schedule_lease_recovery(server->nfs_client); 5745 }; 5746 } 5747 5748 static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *fl, int recovery_type) 5749 { 5750 struct nfs4_lockdata *data; 5751 struct rpc_task *task; 5752 struct rpc_message msg = { 5753 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCK], 5754 .rpc_cred = state->owner->so_cred, 5755 }; 5756 struct rpc_task_setup task_setup_data = { 5757 .rpc_client = NFS_CLIENT(state->inode), 5758 .rpc_message = &msg, 5759 .callback_ops = &nfs4_lock_ops, 5760 .workqueue = nfsiod_workqueue, 5761 .flags = RPC_TASK_ASYNC, 5762 }; 5763 int ret; 5764 5765 dprintk("%s: begin!\n", __func__); 5766 data = nfs4_alloc_lockdata(fl, nfs_file_open_context(fl->fl_file), 5767 fl->fl_u.nfs4_fl.owner, 5768 recovery_type == NFS_LOCK_NEW ? GFP_KERNEL : GFP_NOFS); 5769 if (data == NULL) 5770 return -ENOMEM; 5771 if (IS_SETLKW(cmd)) 5772 data->arg.block = 1; 5773 nfs4_init_sequence(&data->arg.seq_args, &data->res.seq_res, 1); 5774 msg.rpc_argp = &data->arg; 5775 msg.rpc_resp = &data->res; 5776 task_setup_data.callback_data = data; 5777 if (recovery_type > NFS_LOCK_NEW) { 5778 if (recovery_type == NFS_LOCK_RECLAIM) 5779 data->arg.reclaim = NFS_LOCK_RECLAIM; 5780 nfs4_set_sequence_privileged(&data->arg.seq_args); 5781 } else 5782 data->arg.new_lock = 1; 5783 task = rpc_run_task(&task_setup_data); 5784 if (IS_ERR(task)) 5785 return PTR_ERR(task); 5786 ret = nfs4_wait_for_completion_rpc_task(task); 5787 if (ret == 0) { 5788 ret = data->rpc_status; 5789 if (ret) 5790 nfs4_handle_setlk_error(data->server, data->lsp, 5791 data->arg.new_lock_owner, ret); 5792 } else 5793 data->cancelled = 1; 5794 rpc_put_task(task); 5795 dprintk("%s: done, ret = %d!\n", __func__, ret); 5796 return ret; 5797 } 5798 5799 static int nfs4_lock_reclaim(struct nfs4_state *state, struct file_lock *request) 5800 { 5801 struct nfs_server *server = NFS_SERVER(state->inode); 5802 struct nfs4_exception exception = { 5803 .inode = state->inode, 5804 }; 5805 int err; 5806 5807 do { 5808 /* Cache the lock if possible... */ 5809 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0) 5810 return 0; 5811 err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_RECLAIM); 5812 trace_nfs4_lock_reclaim(request, state, F_SETLK, err); 5813 if (err != -NFS4ERR_DELAY) 5814 break; 5815 nfs4_handle_exception(server, err, &exception); 5816 } while (exception.retry); 5817 return err; 5818 } 5819 5820 static int nfs4_lock_expired(struct nfs4_state *state, struct file_lock *request) 5821 { 5822 struct nfs_server *server = NFS_SERVER(state->inode); 5823 struct nfs4_exception exception = { 5824 .inode = state->inode, 5825 }; 5826 int err; 5827 5828 err = nfs4_set_lock_state(state, request); 5829 if (err != 0) 5830 return err; 5831 if (!recover_lost_locks) { 5832 set_bit(NFS_LOCK_LOST, &request->fl_u.nfs4_fl.owner->ls_flags); 5833 return 0; 5834 } 5835 do { 5836 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0) 5837 return 0; 5838 err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_EXPIRED); 5839 trace_nfs4_lock_expired(request, state, F_SETLK, err); 5840 switch (err) { 5841 default: 5842 goto out; 5843 case -NFS4ERR_GRACE: 5844 case -NFS4ERR_DELAY: 5845 nfs4_handle_exception(server, err, &exception); 5846 err = 0; 5847 } 5848 } while (exception.retry); 5849 out: 5850 return err; 5851 } 5852 5853 #if defined(CONFIG_NFS_V4_1) 5854 /** 5855 * nfs41_check_expired_locks - possibly free a lock stateid 5856 * 5857 * @state: NFSv4 state for an inode 5858 * 5859 * Returns NFS_OK if recovery for this stateid is now finished. 5860 * Otherwise a negative NFS4ERR value is returned. 5861 */ 5862 static int nfs41_check_expired_locks(struct nfs4_state *state) 5863 { 5864 int status, ret = -NFS4ERR_BAD_STATEID; 5865 struct nfs4_lock_state *lsp; 5866 struct nfs_server *server = NFS_SERVER(state->inode); 5867 5868 list_for_each_entry(lsp, &state->lock_states, ls_locks) { 5869 if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags)) { 5870 struct rpc_cred *cred = lsp->ls_state->owner->so_cred; 5871 5872 status = nfs41_test_stateid(server, 5873 &lsp->ls_stateid, 5874 cred); 5875 trace_nfs4_test_lock_stateid(state, lsp, status); 5876 if (status != NFS_OK) { 5877 /* Free the stateid unless the server 5878 * informs us the stateid is unrecognized. */ 5879 if (status != -NFS4ERR_BAD_STATEID) 5880 nfs41_free_stateid(server, 5881 &lsp->ls_stateid, 5882 cred); 5883 clear_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags); 5884 ret = status; 5885 } 5886 } 5887 }; 5888 5889 return ret; 5890 } 5891 5892 static int nfs41_lock_expired(struct nfs4_state *state, struct file_lock *request) 5893 { 5894 int status = NFS_OK; 5895 5896 if (test_bit(LK_STATE_IN_USE, &state->flags)) 5897 status = nfs41_check_expired_locks(state); 5898 if (status != NFS_OK) 5899 status = nfs4_lock_expired(state, request); 5900 return status; 5901 } 5902 #endif 5903 5904 static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request) 5905 { 5906 struct nfs_inode *nfsi = NFS_I(state->inode); 5907 unsigned char fl_flags = request->fl_flags; 5908 int status = -ENOLCK; 5909 5910 if ((fl_flags & FL_POSIX) && 5911 !test_bit(NFS_STATE_POSIX_LOCKS, &state->flags)) 5912 goto out; 5913 /* Is this a delegated open? */ 5914 status = nfs4_set_lock_state(state, request); 5915 if (status != 0) 5916 goto out; 5917 request->fl_flags |= FL_ACCESS; 5918 status = do_vfs_lock(request->fl_file, request); 5919 if (status < 0) 5920 goto out; 5921 down_read(&nfsi->rwsem); 5922 if (test_bit(NFS_DELEGATED_STATE, &state->flags)) { 5923 /* Yes: cache locks! */ 5924 /* ...but avoid races with delegation recall... */ 5925 request->fl_flags = fl_flags & ~FL_SLEEP; 5926 status = do_vfs_lock(request->fl_file, request); 5927 up_read(&nfsi->rwsem); 5928 goto out; 5929 } 5930 up_read(&nfsi->rwsem); 5931 status = _nfs4_do_setlk(state, cmd, request, NFS_LOCK_NEW); 5932 out: 5933 request->fl_flags = fl_flags; 5934 return status; 5935 } 5936 5937 static int nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request) 5938 { 5939 struct nfs4_exception exception = { 5940 .state = state, 5941 .inode = state->inode, 5942 }; 5943 int err; 5944 5945 do { 5946 err = _nfs4_proc_setlk(state, cmd, request); 5947 trace_nfs4_set_lock(request, state, cmd, err); 5948 if (err == -NFS4ERR_DENIED) 5949 err = -EAGAIN; 5950 err = nfs4_handle_exception(NFS_SERVER(state->inode), 5951 err, &exception); 5952 } while (exception.retry); 5953 return err; 5954 } 5955 5956 static int 5957 nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request) 5958 { 5959 struct nfs_open_context *ctx; 5960 struct nfs4_state *state; 5961 unsigned long timeout = NFS4_LOCK_MINTIMEOUT; 5962 int status; 5963 5964 /* verify open state */ 5965 ctx = nfs_file_open_context(filp); 5966 state = ctx->state; 5967 5968 if (request->fl_start < 0 || request->fl_end < 0) 5969 return -EINVAL; 5970 5971 if (IS_GETLK(cmd)) { 5972 if (state != NULL) 5973 return nfs4_proc_getlk(state, F_GETLK, request); 5974 return 0; 5975 } 5976 5977 if (!(IS_SETLK(cmd) || IS_SETLKW(cmd))) 5978 return -EINVAL; 5979 5980 if (request->fl_type == F_UNLCK) { 5981 if (state != NULL) 5982 return nfs4_proc_unlck(state, cmd, request); 5983 return 0; 5984 } 5985 5986 if (state == NULL) 5987 return -ENOLCK; 5988 /* 5989 * Don't rely on the VFS having checked the file open mode, 5990 * since it won't do this for flock() locks. 5991 */ 5992 switch (request->fl_type) { 5993 case F_RDLCK: 5994 if (!(filp->f_mode & FMODE_READ)) 5995 return -EBADF; 5996 break; 5997 case F_WRLCK: 5998 if (!(filp->f_mode & FMODE_WRITE)) 5999 return -EBADF; 6000 } 6001 6002 do { 6003 status = nfs4_proc_setlk(state, cmd, request); 6004 if ((status != -EAGAIN) || IS_SETLK(cmd)) 6005 break; 6006 timeout = nfs4_set_lock_task_retry(timeout); 6007 status = -ERESTARTSYS; 6008 if (signalled()) 6009 break; 6010 } while(status < 0); 6011 return status; 6012 } 6013 6014 int nfs4_lock_delegation_recall(struct file_lock *fl, struct nfs4_state *state, const nfs4_stateid *stateid) 6015 { 6016 struct nfs_server *server = NFS_SERVER(state->inode); 6017 int err; 6018 6019 err = nfs4_set_lock_state(state, fl); 6020 if (err != 0) 6021 return err; 6022 err = _nfs4_do_setlk(state, F_SETLK, fl, NFS_LOCK_NEW); 6023 return nfs4_handle_delegation_recall_error(server, state, stateid, err); 6024 } 6025 6026 struct nfs_release_lockowner_data { 6027 struct nfs4_lock_state *lsp; 6028 struct nfs_server *server; 6029 struct nfs_release_lockowner_args args; 6030 struct nfs_release_lockowner_res res; 6031 unsigned long timestamp; 6032 }; 6033 6034 static void nfs4_release_lockowner_prepare(struct rpc_task *task, void *calldata) 6035 { 6036 struct nfs_release_lockowner_data *data = calldata; 6037 struct nfs_server *server = data->server; 6038 nfs40_setup_sequence(server->nfs_client->cl_slot_tbl, 6039 &data->args.seq_args, &data->res.seq_res, task); 6040 data->args.lock_owner.clientid = server->nfs_client->cl_clientid; 6041 data->timestamp = jiffies; 6042 } 6043 6044 static void nfs4_release_lockowner_done(struct rpc_task *task, void *calldata) 6045 { 6046 struct nfs_release_lockowner_data *data = calldata; 6047 struct nfs_server *server = data->server; 6048 6049 nfs40_sequence_done(task, &data->res.seq_res); 6050 6051 switch (task->tk_status) { 6052 case 0: 6053 renew_lease(server, data->timestamp); 6054 break; 6055 case -NFS4ERR_STALE_CLIENTID: 6056 case -NFS4ERR_EXPIRED: 6057 nfs4_schedule_lease_recovery(server->nfs_client); 6058 break; 6059 case -NFS4ERR_LEASE_MOVED: 6060 case -NFS4ERR_DELAY: 6061 if (nfs4_async_handle_error(task, server, 6062 NULL, NULL) == -EAGAIN) 6063 rpc_restart_call_prepare(task); 6064 } 6065 } 6066 6067 static void nfs4_release_lockowner_release(void *calldata) 6068 { 6069 struct nfs_release_lockowner_data *data = calldata; 6070 nfs4_free_lock_state(data->server, data->lsp); 6071 kfree(calldata); 6072 } 6073 6074 static const struct rpc_call_ops nfs4_release_lockowner_ops = { 6075 .rpc_call_prepare = nfs4_release_lockowner_prepare, 6076 .rpc_call_done = nfs4_release_lockowner_done, 6077 .rpc_release = nfs4_release_lockowner_release, 6078 }; 6079 6080 static void 6081 nfs4_release_lockowner(struct nfs_server *server, struct nfs4_lock_state *lsp) 6082 { 6083 struct nfs_release_lockowner_data *data; 6084 struct rpc_message msg = { 6085 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RELEASE_LOCKOWNER], 6086 }; 6087 6088 if (server->nfs_client->cl_mvops->minor_version != 0) 6089 return; 6090 6091 data = kmalloc(sizeof(*data), GFP_NOFS); 6092 if (!data) 6093 return; 6094 data->lsp = lsp; 6095 data->server = server; 6096 data->args.lock_owner.clientid = server->nfs_client->cl_clientid; 6097 data->args.lock_owner.id = lsp->ls_seqid.owner_id; 6098 data->args.lock_owner.s_dev = server->s_dev; 6099 6100 msg.rpc_argp = &data->args; 6101 msg.rpc_resp = &data->res; 6102 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 0); 6103 rpc_call_async(server->client, &msg, 0, &nfs4_release_lockowner_ops, data); 6104 } 6105 6106 #define XATTR_NAME_NFSV4_ACL "system.nfs4_acl" 6107 6108 static int nfs4_xattr_set_nfs4_acl(struct dentry *dentry, const char *key, 6109 const void *buf, size_t buflen, 6110 int flags, int type) 6111 { 6112 if (strcmp(key, "") != 0) 6113 return -EINVAL; 6114 6115 return nfs4_proc_set_acl(dentry->d_inode, buf, buflen); 6116 } 6117 6118 static int nfs4_xattr_get_nfs4_acl(struct dentry *dentry, const char *key, 6119 void *buf, size_t buflen, int type) 6120 { 6121 if (strcmp(key, "") != 0) 6122 return -EINVAL; 6123 6124 return nfs4_proc_get_acl(dentry->d_inode, buf, buflen); 6125 } 6126 6127 static size_t nfs4_xattr_list_nfs4_acl(struct dentry *dentry, char *list, 6128 size_t list_len, const char *name, 6129 size_t name_len, int type) 6130 { 6131 size_t len = sizeof(XATTR_NAME_NFSV4_ACL); 6132 6133 if (!nfs4_server_supports_acls(NFS_SERVER(dentry->d_inode))) 6134 return 0; 6135 6136 if (list && len <= list_len) 6137 memcpy(list, XATTR_NAME_NFSV4_ACL, len); 6138 return len; 6139 } 6140 6141 #ifdef CONFIG_NFS_V4_SECURITY_LABEL 6142 static inline int nfs4_server_supports_labels(struct nfs_server *server) 6143 { 6144 return server->caps & NFS_CAP_SECURITY_LABEL; 6145 } 6146 6147 static int nfs4_xattr_set_nfs4_label(struct dentry *dentry, const char *key, 6148 const void *buf, size_t buflen, 6149 int flags, int type) 6150 { 6151 if (security_ismaclabel(key)) 6152 return nfs4_set_security_label(dentry, buf, buflen); 6153 6154 return -EOPNOTSUPP; 6155 } 6156 6157 static int nfs4_xattr_get_nfs4_label(struct dentry *dentry, const char *key, 6158 void *buf, size_t buflen, int type) 6159 { 6160 if (security_ismaclabel(key)) 6161 return nfs4_get_security_label(dentry->d_inode, buf, buflen); 6162 return -EOPNOTSUPP; 6163 } 6164 6165 static size_t nfs4_xattr_list_nfs4_label(struct dentry *dentry, char *list, 6166 size_t list_len, const char *name, 6167 size_t name_len, int type) 6168 { 6169 size_t len = 0; 6170 6171 if (nfs_server_capable(dentry->d_inode, NFS_CAP_SECURITY_LABEL)) { 6172 len = security_inode_listsecurity(dentry->d_inode, NULL, 0); 6173 if (list && len <= list_len) 6174 security_inode_listsecurity(dentry->d_inode, list, len); 6175 } 6176 return len; 6177 } 6178 6179 static const struct xattr_handler nfs4_xattr_nfs4_label_handler = { 6180 .prefix = XATTR_SECURITY_PREFIX, 6181 .list = nfs4_xattr_list_nfs4_label, 6182 .get = nfs4_xattr_get_nfs4_label, 6183 .set = nfs4_xattr_set_nfs4_label, 6184 }; 6185 #endif 6186 6187 6188 /* 6189 * nfs_fhget will use either the mounted_on_fileid or the fileid 6190 */ 6191 static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr) 6192 { 6193 if (!(((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) || 6194 (fattr->valid & NFS_ATTR_FATTR_FILEID)) && 6195 (fattr->valid & NFS_ATTR_FATTR_FSID) && 6196 (fattr->valid & NFS_ATTR_FATTR_V4_LOCATIONS))) 6197 return; 6198 6199 fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE | 6200 NFS_ATTR_FATTR_NLINK | NFS_ATTR_FATTR_V4_REFERRAL; 6201 fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO; 6202 fattr->nlink = 2; 6203 } 6204 6205 static int _nfs4_proc_fs_locations(struct rpc_clnt *client, struct inode *dir, 6206 const struct qstr *name, 6207 struct nfs4_fs_locations *fs_locations, 6208 struct page *page) 6209 { 6210 struct nfs_server *server = NFS_SERVER(dir); 6211 u32 bitmask[3] = { 6212 [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS, 6213 }; 6214 struct nfs4_fs_locations_arg args = { 6215 .dir_fh = NFS_FH(dir), 6216 .name = name, 6217 .page = page, 6218 .bitmask = bitmask, 6219 }; 6220 struct nfs4_fs_locations_res res = { 6221 .fs_locations = fs_locations, 6222 }; 6223 struct rpc_message msg = { 6224 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS], 6225 .rpc_argp = &args, 6226 .rpc_resp = &res, 6227 }; 6228 int status; 6229 6230 dprintk("%s: start\n", __func__); 6231 6232 /* Ask for the fileid of the absent filesystem if mounted_on_fileid 6233 * is not supported */ 6234 if (NFS_SERVER(dir)->attr_bitmask[1] & FATTR4_WORD1_MOUNTED_ON_FILEID) 6235 bitmask[1] |= FATTR4_WORD1_MOUNTED_ON_FILEID; 6236 else 6237 bitmask[0] |= FATTR4_WORD0_FILEID; 6238 6239 nfs_fattr_init(&fs_locations->fattr); 6240 fs_locations->server = server; 6241 fs_locations->nlocations = 0; 6242 status = nfs4_call_sync(client, server, &msg, &args.seq_args, &res.seq_res, 0); 6243 dprintk("%s: returned status = %d\n", __func__, status); 6244 return status; 6245 } 6246 6247 int nfs4_proc_fs_locations(struct rpc_clnt *client, struct inode *dir, 6248 const struct qstr *name, 6249 struct nfs4_fs_locations *fs_locations, 6250 struct page *page) 6251 { 6252 struct nfs4_exception exception = { }; 6253 int err; 6254 do { 6255 err = _nfs4_proc_fs_locations(client, dir, name, 6256 fs_locations, page); 6257 trace_nfs4_get_fs_locations(dir, name, err); 6258 err = nfs4_handle_exception(NFS_SERVER(dir), err, 6259 &exception); 6260 } while (exception.retry); 6261 return err; 6262 } 6263 6264 /* 6265 * This operation also signals the server that this client is 6266 * performing migration recovery. The server can stop returning 6267 * NFS4ERR_LEASE_MOVED to this client. A RENEW operation is 6268 * appended to this compound to identify the client ID which is 6269 * performing recovery. 6270 */ 6271 static int _nfs40_proc_get_locations(struct inode *inode, 6272 struct nfs4_fs_locations *locations, 6273 struct page *page, struct rpc_cred *cred) 6274 { 6275 struct nfs_server *server = NFS_SERVER(inode); 6276 struct rpc_clnt *clnt = server->client; 6277 u32 bitmask[2] = { 6278 [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS, 6279 }; 6280 struct nfs4_fs_locations_arg args = { 6281 .clientid = server->nfs_client->cl_clientid, 6282 .fh = NFS_FH(inode), 6283 .page = page, 6284 .bitmask = bitmask, 6285 .migration = 1, /* skip LOOKUP */ 6286 .renew = 1, /* append RENEW */ 6287 }; 6288 struct nfs4_fs_locations_res res = { 6289 .fs_locations = locations, 6290 .migration = 1, 6291 .renew = 1, 6292 }; 6293 struct rpc_message msg = { 6294 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS], 6295 .rpc_argp = &args, 6296 .rpc_resp = &res, 6297 .rpc_cred = cred, 6298 }; 6299 unsigned long now = jiffies; 6300 int status; 6301 6302 nfs_fattr_init(&locations->fattr); 6303 locations->server = server; 6304 locations->nlocations = 0; 6305 6306 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0); 6307 nfs4_set_sequence_privileged(&args.seq_args); 6308 status = nfs4_call_sync_sequence(clnt, server, &msg, 6309 &args.seq_args, &res.seq_res); 6310 if (status) 6311 return status; 6312 6313 renew_lease(server, now); 6314 return 0; 6315 } 6316 6317 #ifdef CONFIG_NFS_V4_1 6318 6319 /* 6320 * This operation also signals the server that this client is 6321 * performing migration recovery. The server can stop asserting 6322 * SEQ4_STATUS_LEASE_MOVED for this client. The client ID 6323 * performing this operation is identified in the SEQUENCE 6324 * operation in this compound. 6325 * 6326 * When the client supports GETATTR(fs_locations_info), it can 6327 * be plumbed in here. 6328 */ 6329 static int _nfs41_proc_get_locations(struct inode *inode, 6330 struct nfs4_fs_locations *locations, 6331 struct page *page, struct rpc_cred *cred) 6332 { 6333 struct nfs_server *server = NFS_SERVER(inode); 6334 struct rpc_clnt *clnt = server->client; 6335 u32 bitmask[2] = { 6336 [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS, 6337 }; 6338 struct nfs4_fs_locations_arg args = { 6339 .fh = NFS_FH(inode), 6340 .page = page, 6341 .bitmask = bitmask, 6342 .migration = 1, /* skip LOOKUP */ 6343 }; 6344 struct nfs4_fs_locations_res res = { 6345 .fs_locations = locations, 6346 .migration = 1, 6347 }; 6348 struct rpc_message msg = { 6349 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS], 6350 .rpc_argp = &args, 6351 .rpc_resp = &res, 6352 .rpc_cred = cred, 6353 }; 6354 int status; 6355 6356 nfs_fattr_init(&locations->fattr); 6357 locations->server = server; 6358 locations->nlocations = 0; 6359 6360 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0); 6361 nfs4_set_sequence_privileged(&args.seq_args); 6362 status = nfs4_call_sync_sequence(clnt, server, &msg, 6363 &args.seq_args, &res.seq_res); 6364 if (status == NFS4_OK && 6365 res.seq_res.sr_status_flags & SEQ4_STATUS_LEASE_MOVED) 6366 status = -NFS4ERR_LEASE_MOVED; 6367 return status; 6368 } 6369 6370 #endif /* CONFIG_NFS_V4_1 */ 6371 6372 /** 6373 * nfs4_proc_get_locations - discover locations for a migrated FSID 6374 * @inode: inode on FSID that is migrating 6375 * @locations: result of query 6376 * @page: buffer 6377 * @cred: credential to use for this operation 6378 * 6379 * Returns NFS4_OK on success, a negative NFS4ERR status code if the 6380 * operation failed, or a negative errno if a local error occurred. 6381 * 6382 * On success, "locations" is filled in, but if the server has 6383 * no locations information, NFS_ATTR_FATTR_V4_LOCATIONS is not 6384 * asserted. 6385 * 6386 * -NFS4ERR_LEASE_MOVED is returned if the server still has leases 6387 * from this client that require migration recovery. 6388 */ 6389 int nfs4_proc_get_locations(struct inode *inode, 6390 struct nfs4_fs_locations *locations, 6391 struct page *page, struct rpc_cred *cred) 6392 { 6393 struct nfs_server *server = NFS_SERVER(inode); 6394 struct nfs_client *clp = server->nfs_client; 6395 const struct nfs4_mig_recovery_ops *ops = 6396 clp->cl_mvops->mig_recovery_ops; 6397 struct nfs4_exception exception = { }; 6398 int status; 6399 6400 dprintk("%s: FSID %llx:%llx on \"%s\"\n", __func__, 6401 (unsigned long long)server->fsid.major, 6402 (unsigned long long)server->fsid.minor, 6403 clp->cl_hostname); 6404 nfs_display_fhandle(NFS_FH(inode), __func__); 6405 6406 do { 6407 status = ops->get_locations(inode, locations, page, cred); 6408 if (status != -NFS4ERR_DELAY) 6409 break; 6410 nfs4_handle_exception(server, status, &exception); 6411 } while (exception.retry); 6412 return status; 6413 } 6414 6415 /* 6416 * This operation also signals the server that this client is 6417 * performing "lease moved" recovery. The server can stop 6418 * returning NFS4ERR_LEASE_MOVED to this client. A RENEW operation 6419 * is appended to this compound to identify the client ID which is 6420 * performing recovery. 6421 */ 6422 static int _nfs40_proc_fsid_present(struct inode *inode, struct rpc_cred *cred) 6423 { 6424 struct nfs_server *server = NFS_SERVER(inode); 6425 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client; 6426 struct rpc_clnt *clnt = server->client; 6427 struct nfs4_fsid_present_arg args = { 6428 .fh = NFS_FH(inode), 6429 .clientid = clp->cl_clientid, 6430 .renew = 1, /* append RENEW */ 6431 }; 6432 struct nfs4_fsid_present_res res = { 6433 .renew = 1, 6434 }; 6435 struct rpc_message msg = { 6436 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSID_PRESENT], 6437 .rpc_argp = &args, 6438 .rpc_resp = &res, 6439 .rpc_cred = cred, 6440 }; 6441 unsigned long now = jiffies; 6442 int status; 6443 6444 res.fh = nfs_alloc_fhandle(); 6445 if (res.fh == NULL) 6446 return -ENOMEM; 6447 6448 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0); 6449 nfs4_set_sequence_privileged(&args.seq_args); 6450 status = nfs4_call_sync_sequence(clnt, server, &msg, 6451 &args.seq_args, &res.seq_res); 6452 nfs_free_fhandle(res.fh); 6453 if (status) 6454 return status; 6455 6456 do_renew_lease(clp, now); 6457 return 0; 6458 } 6459 6460 #ifdef CONFIG_NFS_V4_1 6461 6462 /* 6463 * This operation also signals the server that this client is 6464 * performing "lease moved" recovery. The server can stop asserting 6465 * SEQ4_STATUS_LEASE_MOVED for this client. The client ID performing 6466 * this operation is identified in the SEQUENCE operation in this 6467 * compound. 6468 */ 6469 static int _nfs41_proc_fsid_present(struct inode *inode, struct rpc_cred *cred) 6470 { 6471 struct nfs_server *server = NFS_SERVER(inode); 6472 struct rpc_clnt *clnt = server->client; 6473 struct nfs4_fsid_present_arg args = { 6474 .fh = NFS_FH(inode), 6475 }; 6476 struct nfs4_fsid_present_res res = { 6477 }; 6478 struct rpc_message msg = { 6479 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSID_PRESENT], 6480 .rpc_argp = &args, 6481 .rpc_resp = &res, 6482 .rpc_cred = cred, 6483 }; 6484 int status; 6485 6486 res.fh = nfs_alloc_fhandle(); 6487 if (res.fh == NULL) 6488 return -ENOMEM; 6489 6490 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0); 6491 nfs4_set_sequence_privileged(&args.seq_args); 6492 status = nfs4_call_sync_sequence(clnt, server, &msg, 6493 &args.seq_args, &res.seq_res); 6494 nfs_free_fhandle(res.fh); 6495 if (status == NFS4_OK && 6496 res.seq_res.sr_status_flags & SEQ4_STATUS_LEASE_MOVED) 6497 status = -NFS4ERR_LEASE_MOVED; 6498 return status; 6499 } 6500 6501 #endif /* CONFIG_NFS_V4_1 */ 6502 6503 /** 6504 * nfs4_proc_fsid_present - Is this FSID present or absent on server? 6505 * @inode: inode on FSID to check 6506 * @cred: credential to use for this operation 6507 * 6508 * Server indicates whether the FSID is present, moved, or not 6509 * recognized. This operation is necessary to clear a LEASE_MOVED 6510 * condition for this client ID. 6511 * 6512 * Returns NFS4_OK if the FSID is present on this server, 6513 * -NFS4ERR_MOVED if the FSID is no longer present, a negative 6514 * NFS4ERR code if some error occurred on the server, or a 6515 * negative errno if a local failure occurred. 6516 */ 6517 int nfs4_proc_fsid_present(struct inode *inode, struct rpc_cred *cred) 6518 { 6519 struct nfs_server *server = NFS_SERVER(inode); 6520 struct nfs_client *clp = server->nfs_client; 6521 const struct nfs4_mig_recovery_ops *ops = 6522 clp->cl_mvops->mig_recovery_ops; 6523 struct nfs4_exception exception = { }; 6524 int status; 6525 6526 dprintk("%s: FSID %llx:%llx on \"%s\"\n", __func__, 6527 (unsigned long long)server->fsid.major, 6528 (unsigned long long)server->fsid.minor, 6529 clp->cl_hostname); 6530 nfs_display_fhandle(NFS_FH(inode), __func__); 6531 6532 do { 6533 status = ops->fsid_present(inode, cred); 6534 if (status != -NFS4ERR_DELAY) 6535 break; 6536 nfs4_handle_exception(server, status, &exception); 6537 } while (exception.retry); 6538 return status; 6539 } 6540 6541 /** 6542 * If 'use_integrity' is true and the state managment nfs_client 6543 * cl_rpcclient is using krb5i/p, use the integrity protected cl_rpcclient 6544 * and the machine credential as per RFC3530bis and RFC5661 Security 6545 * Considerations sections. Otherwise, just use the user cred with the 6546 * filesystem's rpc_client. 6547 */ 6548 static int _nfs4_proc_secinfo(struct inode *dir, const struct qstr *name, struct nfs4_secinfo_flavors *flavors, bool use_integrity) 6549 { 6550 int status; 6551 struct nfs4_secinfo_arg args = { 6552 .dir_fh = NFS_FH(dir), 6553 .name = name, 6554 }; 6555 struct nfs4_secinfo_res res = { 6556 .flavors = flavors, 6557 }; 6558 struct rpc_message msg = { 6559 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SECINFO], 6560 .rpc_argp = &args, 6561 .rpc_resp = &res, 6562 }; 6563 struct rpc_clnt *clnt = NFS_SERVER(dir)->client; 6564 struct rpc_cred *cred = NULL; 6565 6566 if (use_integrity) { 6567 clnt = NFS_SERVER(dir)->nfs_client->cl_rpcclient; 6568 cred = nfs4_get_clid_cred(NFS_SERVER(dir)->nfs_client); 6569 msg.rpc_cred = cred; 6570 } 6571 6572 dprintk("NFS call secinfo %s\n", name->name); 6573 6574 nfs4_state_protect(NFS_SERVER(dir)->nfs_client, 6575 NFS_SP4_MACH_CRED_SECINFO, &clnt, &msg); 6576 6577 status = nfs4_call_sync(clnt, NFS_SERVER(dir), &msg, &args.seq_args, 6578 &res.seq_res, 0); 6579 dprintk("NFS reply secinfo: %d\n", status); 6580 6581 if (cred) 6582 put_rpccred(cred); 6583 6584 return status; 6585 } 6586 6587 int nfs4_proc_secinfo(struct inode *dir, const struct qstr *name, 6588 struct nfs4_secinfo_flavors *flavors) 6589 { 6590 struct nfs4_exception exception = { }; 6591 int err; 6592 do { 6593 err = -NFS4ERR_WRONGSEC; 6594 6595 /* try to use integrity protection with machine cred */ 6596 if (_nfs4_is_integrity_protected(NFS_SERVER(dir)->nfs_client)) 6597 err = _nfs4_proc_secinfo(dir, name, flavors, true); 6598 6599 /* 6600 * if unable to use integrity protection, or SECINFO with 6601 * integrity protection returns NFS4ERR_WRONGSEC (which is 6602 * disallowed by spec, but exists in deployed servers) use 6603 * the current filesystem's rpc_client and the user cred. 6604 */ 6605 if (err == -NFS4ERR_WRONGSEC) 6606 err = _nfs4_proc_secinfo(dir, name, flavors, false); 6607 6608 trace_nfs4_secinfo(dir, name, err); 6609 err = nfs4_handle_exception(NFS_SERVER(dir), err, 6610 &exception); 6611 } while (exception.retry); 6612 return err; 6613 } 6614 6615 #ifdef CONFIG_NFS_V4_1 6616 /* 6617 * Check the exchange flags returned by the server for invalid flags, having 6618 * both PNFS and NON_PNFS flags set, and not having one of NON_PNFS, PNFS, or 6619 * DS flags set. 6620 */ 6621 static int nfs4_check_cl_exchange_flags(u32 flags) 6622 { 6623 if (flags & ~EXCHGID4_FLAG_MASK_R) 6624 goto out_inval; 6625 if ((flags & EXCHGID4_FLAG_USE_PNFS_MDS) && 6626 (flags & EXCHGID4_FLAG_USE_NON_PNFS)) 6627 goto out_inval; 6628 if (!(flags & (EXCHGID4_FLAG_MASK_PNFS))) 6629 goto out_inval; 6630 return NFS_OK; 6631 out_inval: 6632 return -NFS4ERR_INVAL; 6633 } 6634 6635 static bool 6636 nfs41_same_server_scope(struct nfs41_server_scope *a, 6637 struct nfs41_server_scope *b) 6638 { 6639 if (a->server_scope_sz == b->server_scope_sz && 6640 memcmp(a->server_scope, b->server_scope, a->server_scope_sz) == 0) 6641 return true; 6642 6643 return false; 6644 } 6645 6646 /* 6647 * nfs4_proc_bind_conn_to_session() 6648 * 6649 * The 4.1 client currently uses the same TCP connection for the 6650 * fore and backchannel. 6651 */ 6652 int nfs4_proc_bind_conn_to_session(struct nfs_client *clp, struct rpc_cred *cred) 6653 { 6654 int status; 6655 struct nfs41_bind_conn_to_session_args args = { 6656 .client = clp, 6657 .dir = NFS4_CDFC4_FORE_OR_BOTH, 6658 }; 6659 struct nfs41_bind_conn_to_session_res res; 6660 struct rpc_message msg = { 6661 .rpc_proc = 6662 &nfs4_procedures[NFSPROC4_CLNT_BIND_CONN_TO_SESSION], 6663 .rpc_argp = &args, 6664 .rpc_resp = &res, 6665 .rpc_cred = cred, 6666 }; 6667 6668 dprintk("--> %s\n", __func__); 6669 6670 nfs4_copy_sessionid(&args.sessionid, &clp->cl_session->sess_id); 6671 if (!(clp->cl_session->flags & SESSION4_BACK_CHAN)) 6672 args.dir = NFS4_CDFC4_FORE; 6673 6674 status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT); 6675 trace_nfs4_bind_conn_to_session(clp, status); 6676 if (status == 0) { 6677 if (memcmp(res.sessionid.data, 6678 clp->cl_session->sess_id.data, NFS4_MAX_SESSIONID_LEN)) { 6679 dprintk("NFS: %s: Session ID mismatch\n", __func__); 6680 status = -EIO; 6681 goto out; 6682 } 6683 if ((res.dir & args.dir) != res.dir || res.dir == 0) { 6684 dprintk("NFS: %s: Unexpected direction from server\n", 6685 __func__); 6686 status = -EIO; 6687 goto out; 6688 } 6689 if (res.use_conn_in_rdma_mode != args.use_conn_in_rdma_mode) { 6690 dprintk("NFS: %s: Server returned RDMA mode = true\n", 6691 __func__); 6692 status = -EIO; 6693 goto out; 6694 } 6695 } 6696 out: 6697 dprintk("<-- %s status= %d\n", __func__, status); 6698 return status; 6699 } 6700 6701 /* 6702 * Minimum set of SP4_MACH_CRED operations from RFC 5661 in the enforce map 6703 * and operations we'd like to see to enable certain features in the allow map 6704 */ 6705 static const struct nfs41_state_protection nfs4_sp4_mach_cred_request = { 6706 .how = SP4_MACH_CRED, 6707 .enforce.u.words = { 6708 [1] = 1 << (OP_BIND_CONN_TO_SESSION - 32) | 6709 1 << (OP_EXCHANGE_ID - 32) | 6710 1 << (OP_CREATE_SESSION - 32) | 6711 1 << (OP_DESTROY_SESSION - 32) | 6712 1 << (OP_DESTROY_CLIENTID - 32) 6713 }, 6714 .allow.u.words = { 6715 [0] = 1 << (OP_CLOSE) | 6716 1 << (OP_LOCKU) | 6717 1 << (OP_COMMIT), 6718 [1] = 1 << (OP_SECINFO - 32) | 6719 1 << (OP_SECINFO_NO_NAME - 32) | 6720 1 << (OP_TEST_STATEID - 32) | 6721 1 << (OP_FREE_STATEID - 32) | 6722 1 << (OP_WRITE - 32) 6723 } 6724 }; 6725 6726 /* 6727 * Select the state protection mode for client `clp' given the server results 6728 * from exchange_id in `sp'. 6729 * 6730 * Returns 0 on success, negative errno otherwise. 6731 */ 6732 static int nfs4_sp4_select_mode(struct nfs_client *clp, 6733 struct nfs41_state_protection *sp) 6734 { 6735 static const u32 supported_enforce[NFS4_OP_MAP_NUM_WORDS] = { 6736 [1] = 1 << (OP_BIND_CONN_TO_SESSION - 32) | 6737 1 << (OP_EXCHANGE_ID - 32) | 6738 1 << (OP_CREATE_SESSION - 32) | 6739 1 << (OP_DESTROY_SESSION - 32) | 6740 1 << (OP_DESTROY_CLIENTID - 32) 6741 }; 6742 unsigned int i; 6743 6744 if (sp->how == SP4_MACH_CRED) { 6745 /* Print state protect result */ 6746 dfprintk(MOUNT, "Server SP4_MACH_CRED support:\n"); 6747 for (i = 0; i <= LAST_NFS4_OP; i++) { 6748 if (test_bit(i, sp->enforce.u.longs)) 6749 dfprintk(MOUNT, " enforce op %d\n", i); 6750 if (test_bit(i, sp->allow.u.longs)) 6751 dfprintk(MOUNT, " allow op %d\n", i); 6752 } 6753 6754 /* make sure nothing is on enforce list that isn't supported */ 6755 for (i = 0; i < NFS4_OP_MAP_NUM_WORDS; i++) { 6756 if (sp->enforce.u.words[i] & ~supported_enforce[i]) { 6757 dfprintk(MOUNT, "sp4_mach_cred: disabled\n"); 6758 return -EINVAL; 6759 } 6760 } 6761 6762 /* 6763 * Minimal mode - state operations are allowed to use machine 6764 * credential. Note this already happens by default, so the 6765 * client doesn't have to do anything more than the negotiation. 6766 * 6767 * NOTE: we don't care if EXCHANGE_ID is in the list - 6768 * we're already using the machine cred for exchange_id 6769 * and will never use a different cred. 6770 */ 6771 if (test_bit(OP_BIND_CONN_TO_SESSION, sp->enforce.u.longs) && 6772 test_bit(OP_CREATE_SESSION, sp->enforce.u.longs) && 6773 test_bit(OP_DESTROY_SESSION, sp->enforce.u.longs) && 6774 test_bit(OP_DESTROY_CLIENTID, sp->enforce.u.longs)) { 6775 dfprintk(MOUNT, "sp4_mach_cred:\n"); 6776 dfprintk(MOUNT, " minimal mode enabled\n"); 6777 set_bit(NFS_SP4_MACH_CRED_MINIMAL, &clp->cl_sp4_flags); 6778 } else { 6779 dfprintk(MOUNT, "sp4_mach_cred: disabled\n"); 6780 return -EINVAL; 6781 } 6782 6783 if (test_bit(OP_CLOSE, sp->allow.u.longs) && 6784 test_bit(OP_LOCKU, sp->allow.u.longs)) { 6785 dfprintk(MOUNT, " cleanup mode enabled\n"); 6786 set_bit(NFS_SP4_MACH_CRED_CLEANUP, &clp->cl_sp4_flags); 6787 } 6788 6789 if (test_bit(OP_SECINFO, sp->allow.u.longs) && 6790 test_bit(OP_SECINFO_NO_NAME, sp->allow.u.longs)) { 6791 dfprintk(MOUNT, " secinfo mode enabled\n"); 6792 set_bit(NFS_SP4_MACH_CRED_SECINFO, &clp->cl_sp4_flags); 6793 } 6794 6795 if (test_bit(OP_TEST_STATEID, sp->allow.u.longs) && 6796 test_bit(OP_FREE_STATEID, sp->allow.u.longs)) { 6797 dfprintk(MOUNT, " stateid mode enabled\n"); 6798 set_bit(NFS_SP4_MACH_CRED_STATEID, &clp->cl_sp4_flags); 6799 } 6800 6801 if (test_bit(OP_WRITE, sp->allow.u.longs)) { 6802 dfprintk(MOUNT, " write mode enabled\n"); 6803 set_bit(NFS_SP4_MACH_CRED_WRITE, &clp->cl_sp4_flags); 6804 } 6805 6806 if (test_bit(OP_COMMIT, sp->allow.u.longs)) { 6807 dfprintk(MOUNT, " commit mode enabled\n"); 6808 set_bit(NFS_SP4_MACH_CRED_COMMIT, &clp->cl_sp4_flags); 6809 } 6810 } 6811 6812 return 0; 6813 } 6814 6815 /* 6816 * _nfs4_proc_exchange_id() 6817 * 6818 * Wrapper for EXCHANGE_ID operation. 6819 */ 6820 static int _nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred, 6821 u32 sp4_how) 6822 { 6823 nfs4_verifier verifier; 6824 struct nfs41_exchange_id_args args = { 6825 .verifier = &verifier, 6826 .client = clp, 6827 #ifdef CONFIG_NFS_V4_1_MIGRATION 6828 .flags = EXCHGID4_FLAG_SUPP_MOVED_REFER | 6829 EXCHGID4_FLAG_BIND_PRINC_STATEID | 6830 EXCHGID4_FLAG_SUPP_MOVED_MIGR, 6831 #else 6832 .flags = EXCHGID4_FLAG_SUPP_MOVED_REFER | 6833 EXCHGID4_FLAG_BIND_PRINC_STATEID, 6834 #endif 6835 }; 6836 struct nfs41_exchange_id_res res = { 6837 0 6838 }; 6839 int status; 6840 struct rpc_message msg = { 6841 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_EXCHANGE_ID], 6842 .rpc_argp = &args, 6843 .rpc_resp = &res, 6844 .rpc_cred = cred, 6845 }; 6846 6847 nfs4_init_boot_verifier(clp, &verifier); 6848 args.id_len = nfs4_init_uniform_client_string(clp, args.id, 6849 sizeof(args.id)); 6850 dprintk("NFS call exchange_id auth=%s, '%.*s'\n", 6851 clp->cl_rpcclient->cl_auth->au_ops->au_name, 6852 args.id_len, args.id); 6853 6854 res.server_owner = kzalloc(sizeof(struct nfs41_server_owner), 6855 GFP_NOFS); 6856 if (unlikely(res.server_owner == NULL)) { 6857 status = -ENOMEM; 6858 goto out; 6859 } 6860 6861 res.server_scope = kzalloc(sizeof(struct nfs41_server_scope), 6862 GFP_NOFS); 6863 if (unlikely(res.server_scope == NULL)) { 6864 status = -ENOMEM; 6865 goto out_server_owner; 6866 } 6867 6868 res.impl_id = kzalloc(sizeof(struct nfs41_impl_id), GFP_NOFS); 6869 if (unlikely(res.impl_id == NULL)) { 6870 status = -ENOMEM; 6871 goto out_server_scope; 6872 } 6873 6874 switch (sp4_how) { 6875 case SP4_NONE: 6876 args.state_protect.how = SP4_NONE; 6877 break; 6878 6879 case SP4_MACH_CRED: 6880 args.state_protect = nfs4_sp4_mach_cred_request; 6881 break; 6882 6883 default: 6884 /* unsupported! */ 6885 WARN_ON_ONCE(1); 6886 status = -EINVAL; 6887 goto out_server_scope; 6888 } 6889 6890 status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT); 6891 trace_nfs4_exchange_id(clp, status); 6892 if (status == 0) 6893 status = nfs4_check_cl_exchange_flags(res.flags); 6894 6895 if (status == 0) 6896 status = nfs4_sp4_select_mode(clp, &res.state_protect); 6897 6898 if (status == 0) { 6899 clp->cl_clientid = res.clientid; 6900 clp->cl_exchange_flags = res.flags; 6901 /* Client ID is not confirmed */ 6902 if (!(res.flags & EXCHGID4_FLAG_CONFIRMED_R)) { 6903 clear_bit(NFS4_SESSION_ESTABLISHED, 6904 &clp->cl_session->session_state); 6905 clp->cl_seqid = res.seqid; 6906 } 6907 6908 kfree(clp->cl_serverowner); 6909 clp->cl_serverowner = res.server_owner; 6910 res.server_owner = NULL; 6911 6912 /* use the most recent implementation id */ 6913 kfree(clp->cl_implid); 6914 clp->cl_implid = res.impl_id; 6915 6916 if (clp->cl_serverscope != NULL && 6917 !nfs41_same_server_scope(clp->cl_serverscope, 6918 res.server_scope)) { 6919 dprintk("%s: server_scope mismatch detected\n", 6920 __func__); 6921 set_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state); 6922 kfree(clp->cl_serverscope); 6923 clp->cl_serverscope = NULL; 6924 } 6925 6926 if (clp->cl_serverscope == NULL) { 6927 clp->cl_serverscope = res.server_scope; 6928 goto out; 6929 } 6930 } else 6931 kfree(res.impl_id); 6932 6933 out_server_owner: 6934 kfree(res.server_owner); 6935 out_server_scope: 6936 kfree(res.server_scope); 6937 out: 6938 if (clp->cl_implid != NULL) 6939 dprintk("NFS reply exchange_id: Server Implementation ID: " 6940 "domain: %s, name: %s, date: %llu,%u\n", 6941 clp->cl_implid->domain, clp->cl_implid->name, 6942 clp->cl_implid->date.seconds, 6943 clp->cl_implid->date.nseconds); 6944 dprintk("NFS reply exchange_id: %d\n", status); 6945 return status; 6946 } 6947 6948 /* 6949 * nfs4_proc_exchange_id() 6950 * 6951 * Returns zero, a negative errno, or a negative NFS4ERR status code. 6952 * 6953 * Since the clientid has expired, all compounds using sessions 6954 * associated with the stale clientid will be returning 6955 * NFS4ERR_BADSESSION in the sequence operation, and will therefore 6956 * be in some phase of session reset. 6957 * 6958 * Will attempt to negotiate SP4_MACH_CRED if krb5i / krb5p auth is used. 6959 */ 6960 int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred) 6961 { 6962 rpc_authflavor_t authflavor = clp->cl_rpcclient->cl_auth->au_flavor; 6963 int status; 6964 6965 /* try SP4_MACH_CRED if krb5i/p */ 6966 if (authflavor == RPC_AUTH_GSS_KRB5I || 6967 authflavor == RPC_AUTH_GSS_KRB5P) { 6968 status = _nfs4_proc_exchange_id(clp, cred, SP4_MACH_CRED); 6969 if (!status) 6970 return 0; 6971 } 6972 6973 /* try SP4_NONE */ 6974 return _nfs4_proc_exchange_id(clp, cred, SP4_NONE); 6975 } 6976 6977 static int _nfs4_proc_destroy_clientid(struct nfs_client *clp, 6978 struct rpc_cred *cred) 6979 { 6980 struct rpc_message msg = { 6981 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_CLIENTID], 6982 .rpc_argp = clp, 6983 .rpc_cred = cred, 6984 }; 6985 int status; 6986 6987 status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT); 6988 trace_nfs4_destroy_clientid(clp, status); 6989 if (status) 6990 dprintk("NFS: Got error %d from the server %s on " 6991 "DESTROY_CLIENTID.", status, clp->cl_hostname); 6992 return status; 6993 } 6994 6995 static int nfs4_proc_destroy_clientid(struct nfs_client *clp, 6996 struct rpc_cred *cred) 6997 { 6998 unsigned int loop; 6999 int ret; 7000 7001 for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) { 7002 ret = _nfs4_proc_destroy_clientid(clp, cred); 7003 switch (ret) { 7004 case -NFS4ERR_DELAY: 7005 case -NFS4ERR_CLIENTID_BUSY: 7006 ssleep(1); 7007 break; 7008 default: 7009 return ret; 7010 } 7011 } 7012 return 0; 7013 } 7014 7015 int nfs4_destroy_clientid(struct nfs_client *clp) 7016 { 7017 struct rpc_cred *cred; 7018 int ret = 0; 7019 7020 if (clp->cl_mvops->minor_version < 1) 7021 goto out; 7022 if (clp->cl_exchange_flags == 0) 7023 goto out; 7024 if (clp->cl_preserve_clid) 7025 goto out; 7026 cred = nfs4_get_clid_cred(clp); 7027 ret = nfs4_proc_destroy_clientid(clp, cred); 7028 if (cred) 7029 put_rpccred(cred); 7030 switch (ret) { 7031 case 0: 7032 case -NFS4ERR_STALE_CLIENTID: 7033 clp->cl_exchange_flags = 0; 7034 } 7035 out: 7036 return ret; 7037 } 7038 7039 struct nfs4_get_lease_time_data { 7040 struct nfs4_get_lease_time_args *args; 7041 struct nfs4_get_lease_time_res *res; 7042 struct nfs_client *clp; 7043 }; 7044 7045 static void nfs4_get_lease_time_prepare(struct rpc_task *task, 7046 void *calldata) 7047 { 7048 struct nfs4_get_lease_time_data *data = 7049 (struct nfs4_get_lease_time_data *)calldata; 7050 7051 dprintk("--> %s\n", __func__); 7052 /* just setup sequence, do not trigger session recovery 7053 since we're invoked within one */ 7054 nfs41_setup_sequence(data->clp->cl_session, 7055 &data->args->la_seq_args, 7056 &data->res->lr_seq_res, 7057 task); 7058 dprintk("<-- %s\n", __func__); 7059 } 7060 7061 /* 7062 * Called from nfs4_state_manager thread for session setup, so don't recover 7063 * from sequence operation or clientid errors. 7064 */ 7065 static void nfs4_get_lease_time_done(struct rpc_task *task, void *calldata) 7066 { 7067 struct nfs4_get_lease_time_data *data = 7068 (struct nfs4_get_lease_time_data *)calldata; 7069 7070 dprintk("--> %s\n", __func__); 7071 if (!nfs41_sequence_done(task, &data->res->lr_seq_res)) 7072 return; 7073 switch (task->tk_status) { 7074 case -NFS4ERR_DELAY: 7075 case -NFS4ERR_GRACE: 7076 dprintk("%s Retry: tk_status %d\n", __func__, task->tk_status); 7077 rpc_delay(task, NFS4_POLL_RETRY_MIN); 7078 task->tk_status = 0; 7079 /* fall through */ 7080 case -NFS4ERR_RETRY_UNCACHED_REP: 7081 rpc_restart_call_prepare(task); 7082 return; 7083 } 7084 dprintk("<-- %s\n", __func__); 7085 } 7086 7087 static const struct rpc_call_ops nfs4_get_lease_time_ops = { 7088 .rpc_call_prepare = nfs4_get_lease_time_prepare, 7089 .rpc_call_done = nfs4_get_lease_time_done, 7090 }; 7091 7092 int nfs4_proc_get_lease_time(struct nfs_client *clp, struct nfs_fsinfo *fsinfo) 7093 { 7094 struct rpc_task *task; 7095 struct nfs4_get_lease_time_args args; 7096 struct nfs4_get_lease_time_res res = { 7097 .lr_fsinfo = fsinfo, 7098 }; 7099 struct nfs4_get_lease_time_data data = { 7100 .args = &args, 7101 .res = &res, 7102 .clp = clp, 7103 }; 7104 struct rpc_message msg = { 7105 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GET_LEASE_TIME], 7106 .rpc_argp = &args, 7107 .rpc_resp = &res, 7108 }; 7109 struct rpc_task_setup task_setup = { 7110 .rpc_client = clp->cl_rpcclient, 7111 .rpc_message = &msg, 7112 .callback_ops = &nfs4_get_lease_time_ops, 7113 .callback_data = &data, 7114 .flags = RPC_TASK_TIMEOUT, 7115 }; 7116 int status; 7117 7118 nfs4_init_sequence(&args.la_seq_args, &res.lr_seq_res, 0); 7119 nfs4_set_sequence_privileged(&args.la_seq_args); 7120 dprintk("--> %s\n", __func__); 7121 task = rpc_run_task(&task_setup); 7122 7123 if (IS_ERR(task)) 7124 status = PTR_ERR(task); 7125 else { 7126 status = task->tk_status; 7127 rpc_put_task(task); 7128 } 7129 dprintk("<-- %s return %d\n", __func__, status); 7130 7131 return status; 7132 } 7133 7134 /* 7135 * Initialize the values to be used by the client in CREATE_SESSION 7136 * If nfs4_init_session set the fore channel request and response sizes, 7137 * use them. 7138 * 7139 * Set the back channel max_resp_sz_cached to zero to force the client to 7140 * always set csa_cachethis to FALSE because the current implementation 7141 * of the back channel DRC only supports caching the CB_SEQUENCE operation. 7142 */ 7143 static void nfs4_init_channel_attrs(struct nfs41_create_session_args *args) 7144 { 7145 unsigned int max_rqst_sz, max_resp_sz; 7146 7147 max_rqst_sz = NFS_MAX_FILE_IO_SIZE + nfs41_maxwrite_overhead; 7148 max_resp_sz = NFS_MAX_FILE_IO_SIZE + nfs41_maxread_overhead; 7149 7150 /* Fore channel attributes */ 7151 args->fc_attrs.max_rqst_sz = max_rqst_sz; 7152 args->fc_attrs.max_resp_sz = max_resp_sz; 7153 args->fc_attrs.max_ops = NFS4_MAX_OPS; 7154 args->fc_attrs.max_reqs = max_session_slots; 7155 7156 dprintk("%s: Fore Channel : max_rqst_sz=%u max_resp_sz=%u " 7157 "max_ops=%u max_reqs=%u\n", 7158 __func__, 7159 args->fc_attrs.max_rqst_sz, args->fc_attrs.max_resp_sz, 7160 args->fc_attrs.max_ops, args->fc_attrs.max_reqs); 7161 7162 /* Back channel attributes */ 7163 args->bc_attrs.max_rqst_sz = PAGE_SIZE; 7164 args->bc_attrs.max_resp_sz = PAGE_SIZE; 7165 args->bc_attrs.max_resp_sz_cached = 0; 7166 args->bc_attrs.max_ops = NFS4_MAX_BACK_CHANNEL_OPS; 7167 args->bc_attrs.max_reqs = 1; 7168 7169 dprintk("%s: Back Channel : max_rqst_sz=%u max_resp_sz=%u " 7170 "max_resp_sz_cached=%u max_ops=%u max_reqs=%u\n", 7171 __func__, 7172 args->bc_attrs.max_rqst_sz, args->bc_attrs.max_resp_sz, 7173 args->bc_attrs.max_resp_sz_cached, args->bc_attrs.max_ops, 7174 args->bc_attrs.max_reqs); 7175 } 7176 7177 static int nfs4_verify_fore_channel_attrs(struct nfs41_create_session_args *args, 7178 struct nfs41_create_session_res *res) 7179 { 7180 struct nfs4_channel_attrs *sent = &args->fc_attrs; 7181 struct nfs4_channel_attrs *rcvd = &res->fc_attrs; 7182 7183 if (rcvd->max_resp_sz > sent->max_resp_sz) 7184 return -EINVAL; 7185 /* 7186 * Our requested max_ops is the minimum we need; we're not 7187 * prepared to break up compounds into smaller pieces than that. 7188 * So, no point even trying to continue if the server won't 7189 * cooperate: 7190 */ 7191 if (rcvd->max_ops < sent->max_ops) 7192 return -EINVAL; 7193 if (rcvd->max_reqs == 0) 7194 return -EINVAL; 7195 if (rcvd->max_reqs > NFS4_MAX_SLOT_TABLE) 7196 rcvd->max_reqs = NFS4_MAX_SLOT_TABLE; 7197 return 0; 7198 } 7199 7200 static int nfs4_verify_back_channel_attrs(struct nfs41_create_session_args *args, 7201 struct nfs41_create_session_res *res) 7202 { 7203 struct nfs4_channel_attrs *sent = &args->bc_attrs; 7204 struct nfs4_channel_attrs *rcvd = &res->bc_attrs; 7205 7206 if (!(res->flags & SESSION4_BACK_CHAN)) 7207 goto out; 7208 if (rcvd->max_rqst_sz > sent->max_rqst_sz) 7209 return -EINVAL; 7210 if (rcvd->max_resp_sz < sent->max_resp_sz) 7211 return -EINVAL; 7212 if (rcvd->max_resp_sz_cached > sent->max_resp_sz_cached) 7213 return -EINVAL; 7214 /* These would render the backchannel useless: */ 7215 if (rcvd->max_ops != sent->max_ops) 7216 return -EINVAL; 7217 if (rcvd->max_reqs != sent->max_reqs) 7218 return -EINVAL; 7219 out: 7220 return 0; 7221 } 7222 7223 static int nfs4_verify_channel_attrs(struct nfs41_create_session_args *args, 7224 struct nfs41_create_session_res *res) 7225 { 7226 int ret; 7227 7228 ret = nfs4_verify_fore_channel_attrs(args, res); 7229 if (ret) 7230 return ret; 7231 return nfs4_verify_back_channel_attrs(args, res); 7232 } 7233 7234 static void nfs4_update_session(struct nfs4_session *session, 7235 struct nfs41_create_session_res *res) 7236 { 7237 nfs4_copy_sessionid(&session->sess_id, &res->sessionid); 7238 /* Mark client id and session as being confirmed */ 7239 session->clp->cl_exchange_flags |= EXCHGID4_FLAG_CONFIRMED_R; 7240 set_bit(NFS4_SESSION_ESTABLISHED, &session->session_state); 7241 session->flags = res->flags; 7242 memcpy(&session->fc_attrs, &res->fc_attrs, sizeof(session->fc_attrs)); 7243 if (res->flags & SESSION4_BACK_CHAN) 7244 memcpy(&session->bc_attrs, &res->bc_attrs, 7245 sizeof(session->bc_attrs)); 7246 } 7247 7248 static int _nfs4_proc_create_session(struct nfs_client *clp, 7249 struct rpc_cred *cred) 7250 { 7251 struct nfs4_session *session = clp->cl_session; 7252 struct nfs41_create_session_args args = { 7253 .client = clp, 7254 .clientid = clp->cl_clientid, 7255 .seqid = clp->cl_seqid, 7256 .cb_program = NFS4_CALLBACK, 7257 }; 7258 struct nfs41_create_session_res res; 7259 7260 struct rpc_message msg = { 7261 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE_SESSION], 7262 .rpc_argp = &args, 7263 .rpc_resp = &res, 7264 .rpc_cred = cred, 7265 }; 7266 int status; 7267 7268 nfs4_init_channel_attrs(&args); 7269 args.flags = (SESSION4_PERSIST | SESSION4_BACK_CHAN); 7270 7271 status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT); 7272 trace_nfs4_create_session(clp, status); 7273 7274 if (!status) { 7275 /* Verify the session's negotiated channel_attrs values */ 7276 status = nfs4_verify_channel_attrs(&args, &res); 7277 /* Increment the clientid slot sequence id */ 7278 if (clp->cl_seqid == res.seqid) 7279 clp->cl_seqid++; 7280 if (status) 7281 goto out; 7282 nfs4_update_session(session, &res); 7283 } 7284 out: 7285 return status; 7286 } 7287 7288 /* 7289 * Issues a CREATE_SESSION operation to the server. 7290 * It is the responsibility of the caller to verify the session is 7291 * expired before calling this routine. 7292 */ 7293 int nfs4_proc_create_session(struct nfs_client *clp, struct rpc_cred *cred) 7294 { 7295 int status; 7296 unsigned *ptr; 7297 struct nfs4_session *session = clp->cl_session; 7298 7299 dprintk("--> %s clp=%p session=%p\n", __func__, clp, session); 7300 7301 status = _nfs4_proc_create_session(clp, cred); 7302 if (status) 7303 goto out; 7304 7305 /* Init or reset the session slot tables */ 7306 status = nfs4_setup_session_slot_tables(session); 7307 dprintk("slot table setup returned %d\n", status); 7308 if (status) 7309 goto out; 7310 7311 ptr = (unsigned *)&session->sess_id.data[0]; 7312 dprintk("%s client>seqid %d sessionid %u:%u:%u:%u\n", __func__, 7313 clp->cl_seqid, ptr[0], ptr[1], ptr[2], ptr[3]); 7314 out: 7315 dprintk("<-- %s\n", __func__); 7316 return status; 7317 } 7318 7319 /* 7320 * Issue the over-the-wire RPC DESTROY_SESSION. 7321 * The caller must serialize access to this routine. 7322 */ 7323 int nfs4_proc_destroy_session(struct nfs4_session *session, 7324 struct rpc_cred *cred) 7325 { 7326 struct rpc_message msg = { 7327 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_SESSION], 7328 .rpc_argp = session, 7329 .rpc_cred = cred, 7330 }; 7331 int status = 0; 7332 7333 dprintk("--> nfs4_proc_destroy_session\n"); 7334 7335 /* session is still being setup */ 7336 if (!test_and_clear_bit(NFS4_SESSION_ESTABLISHED, &session->session_state)) 7337 return 0; 7338 7339 status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT); 7340 trace_nfs4_destroy_session(session->clp, status); 7341 7342 if (status) 7343 dprintk("NFS: Got error %d from the server on DESTROY_SESSION. " 7344 "Session has been destroyed regardless...\n", status); 7345 7346 dprintk("<-- nfs4_proc_destroy_session\n"); 7347 return status; 7348 } 7349 7350 /* 7351 * Renew the cl_session lease. 7352 */ 7353 struct nfs4_sequence_data { 7354 struct nfs_client *clp; 7355 struct nfs4_sequence_args args; 7356 struct nfs4_sequence_res res; 7357 }; 7358 7359 static void nfs41_sequence_release(void *data) 7360 { 7361 struct nfs4_sequence_data *calldata = data; 7362 struct nfs_client *clp = calldata->clp; 7363 7364 if (atomic_read(&clp->cl_count) > 1) 7365 nfs4_schedule_state_renewal(clp); 7366 nfs_put_client(clp); 7367 kfree(calldata); 7368 } 7369 7370 static int nfs41_sequence_handle_errors(struct rpc_task *task, struct nfs_client *clp) 7371 { 7372 switch(task->tk_status) { 7373 case -NFS4ERR_DELAY: 7374 rpc_delay(task, NFS4_POLL_RETRY_MAX); 7375 return -EAGAIN; 7376 default: 7377 nfs4_schedule_lease_recovery(clp); 7378 } 7379 return 0; 7380 } 7381 7382 static void nfs41_sequence_call_done(struct rpc_task *task, void *data) 7383 { 7384 struct nfs4_sequence_data *calldata = data; 7385 struct nfs_client *clp = calldata->clp; 7386 7387 if (!nfs41_sequence_done(task, task->tk_msg.rpc_resp)) 7388 return; 7389 7390 trace_nfs4_sequence(clp, task->tk_status); 7391 if (task->tk_status < 0) { 7392 dprintk("%s ERROR %d\n", __func__, task->tk_status); 7393 if (atomic_read(&clp->cl_count) == 1) 7394 goto out; 7395 7396 if (nfs41_sequence_handle_errors(task, clp) == -EAGAIN) { 7397 rpc_restart_call_prepare(task); 7398 return; 7399 } 7400 } 7401 dprintk("%s rpc_cred %p\n", __func__, task->tk_msg.rpc_cred); 7402 out: 7403 dprintk("<-- %s\n", __func__); 7404 } 7405 7406 static void nfs41_sequence_prepare(struct rpc_task *task, void *data) 7407 { 7408 struct nfs4_sequence_data *calldata = data; 7409 struct nfs_client *clp = calldata->clp; 7410 struct nfs4_sequence_args *args; 7411 struct nfs4_sequence_res *res; 7412 7413 args = task->tk_msg.rpc_argp; 7414 res = task->tk_msg.rpc_resp; 7415 7416 nfs41_setup_sequence(clp->cl_session, args, res, task); 7417 } 7418 7419 static const struct rpc_call_ops nfs41_sequence_ops = { 7420 .rpc_call_done = nfs41_sequence_call_done, 7421 .rpc_call_prepare = nfs41_sequence_prepare, 7422 .rpc_release = nfs41_sequence_release, 7423 }; 7424 7425 static struct rpc_task *_nfs41_proc_sequence(struct nfs_client *clp, 7426 struct rpc_cred *cred, 7427 bool is_privileged) 7428 { 7429 struct nfs4_sequence_data *calldata; 7430 struct rpc_message msg = { 7431 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SEQUENCE], 7432 .rpc_cred = cred, 7433 }; 7434 struct rpc_task_setup task_setup_data = { 7435 .rpc_client = clp->cl_rpcclient, 7436 .rpc_message = &msg, 7437 .callback_ops = &nfs41_sequence_ops, 7438 .flags = RPC_TASK_ASYNC | RPC_TASK_TIMEOUT, 7439 }; 7440 7441 if (!atomic_inc_not_zero(&clp->cl_count)) 7442 return ERR_PTR(-EIO); 7443 calldata = kzalloc(sizeof(*calldata), GFP_NOFS); 7444 if (calldata == NULL) { 7445 nfs_put_client(clp); 7446 return ERR_PTR(-ENOMEM); 7447 } 7448 nfs4_init_sequence(&calldata->args, &calldata->res, 0); 7449 if (is_privileged) 7450 nfs4_set_sequence_privileged(&calldata->args); 7451 msg.rpc_argp = &calldata->args; 7452 msg.rpc_resp = &calldata->res; 7453 calldata->clp = clp; 7454 task_setup_data.callback_data = calldata; 7455 7456 return rpc_run_task(&task_setup_data); 7457 } 7458 7459 static int nfs41_proc_async_sequence(struct nfs_client *clp, struct rpc_cred *cred, unsigned renew_flags) 7460 { 7461 struct rpc_task *task; 7462 int ret = 0; 7463 7464 if ((renew_flags & NFS4_RENEW_TIMEOUT) == 0) 7465 return -EAGAIN; 7466 task = _nfs41_proc_sequence(clp, cred, false); 7467 if (IS_ERR(task)) 7468 ret = PTR_ERR(task); 7469 else 7470 rpc_put_task_async(task); 7471 dprintk("<-- %s status=%d\n", __func__, ret); 7472 return ret; 7473 } 7474 7475 static int nfs4_proc_sequence(struct nfs_client *clp, struct rpc_cred *cred) 7476 { 7477 struct rpc_task *task; 7478 int ret; 7479 7480 task = _nfs41_proc_sequence(clp, cred, true); 7481 if (IS_ERR(task)) { 7482 ret = PTR_ERR(task); 7483 goto out; 7484 } 7485 ret = rpc_wait_for_completion_task(task); 7486 if (!ret) { 7487 struct nfs4_sequence_res *res = task->tk_msg.rpc_resp; 7488 7489 if (task->tk_status == 0) 7490 nfs41_handle_sequence_flag_errors(clp, res->sr_status_flags); 7491 ret = task->tk_status; 7492 } 7493 rpc_put_task(task); 7494 out: 7495 dprintk("<-- %s status=%d\n", __func__, ret); 7496 return ret; 7497 } 7498 7499 struct nfs4_reclaim_complete_data { 7500 struct nfs_client *clp; 7501 struct nfs41_reclaim_complete_args arg; 7502 struct nfs41_reclaim_complete_res res; 7503 }; 7504 7505 static void nfs4_reclaim_complete_prepare(struct rpc_task *task, void *data) 7506 { 7507 struct nfs4_reclaim_complete_data *calldata = data; 7508 7509 nfs41_setup_sequence(calldata->clp->cl_session, 7510 &calldata->arg.seq_args, 7511 &calldata->res.seq_res, 7512 task); 7513 } 7514 7515 static int nfs41_reclaim_complete_handle_errors(struct rpc_task *task, struct nfs_client *clp) 7516 { 7517 switch(task->tk_status) { 7518 case 0: 7519 case -NFS4ERR_COMPLETE_ALREADY: 7520 case -NFS4ERR_WRONG_CRED: /* What to do here? */ 7521 break; 7522 case -NFS4ERR_DELAY: 7523 rpc_delay(task, NFS4_POLL_RETRY_MAX); 7524 /* fall through */ 7525 case -NFS4ERR_RETRY_UNCACHED_REP: 7526 return -EAGAIN; 7527 default: 7528 nfs4_schedule_lease_recovery(clp); 7529 } 7530 return 0; 7531 } 7532 7533 static void nfs4_reclaim_complete_done(struct rpc_task *task, void *data) 7534 { 7535 struct nfs4_reclaim_complete_data *calldata = data; 7536 struct nfs_client *clp = calldata->clp; 7537 struct nfs4_sequence_res *res = &calldata->res.seq_res; 7538 7539 dprintk("--> %s\n", __func__); 7540 if (!nfs41_sequence_done(task, res)) 7541 return; 7542 7543 trace_nfs4_reclaim_complete(clp, task->tk_status); 7544 if (nfs41_reclaim_complete_handle_errors(task, clp) == -EAGAIN) { 7545 rpc_restart_call_prepare(task); 7546 return; 7547 } 7548 dprintk("<-- %s\n", __func__); 7549 } 7550 7551 static void nfs4_free_reclaim_complete_data(void *data) 7552 { 7553 struct nfs4_reclaim_complete_data *calldata = data; 7554 7555 kfree(calldata); 7556 } 7557 7558 static const struct rpc_call_ops nfs4_reclaim_complete_call_ops = { 7559 .rpc_call_prepare = nfs4_reclaim_complete_prepare, 7560 .rpc_call_done = nfs4_reclaim_complete_done, 7561 .rpc_release = nfs4_free_reclaim_complete_data, 7562 }; 7563 7564 /* 7565 * Issue a global reclaim complete. 7566 */ 7567 static int nfs41_proc_reclaim_complete(struct nfs_client *clp, 7568 struct rpc_cred *cred) 7569 { 7570 struct nfs4_reclaim_complete_data *calldata; 7571 struct rpc_task *task; 7572 struct rpc_message msg = { 7573 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RECLAIM_COMPLETE], 7574 .rpc_cred = cred, 7575 }; 7576 struct rpc_task_setup task_setup_data = { 7577 .rpc_client = clp->cl_rpcclient, 7578 .rpc_message = &msg, 7579 .callback_ops = &nfs4_reclaim_complete_call_ops, 7580 .flags = RPC_TASK_ASYNC, 7581 }; 7582 int status = -ENOMEM; 7583 7584 dprintk("--> %s\n", __func__); 7585 calldata = kzalloc(sizeof(*calldata), GFP_NOFS); 7586 if (calldata == NULL) 7587 goto out; 7588 calldata->clp = clp; 7589 calldata->arg.one_fs = 0; 7590 7591 nfs4_init_sequence(&calldata->arg.seq_args, &calldata->res.seq_res, 0); 7592 nfs4_set_sequence_privileged(&calldata->arg.seq_args); 7593 msg.rpc_argp = &calldata->arg; 7594 msg.rpc_resp = &calldata->res; 7595 task_setup_data.callback_data = calldata; 7596 task = rpc_run_task(&task_setup_data); 7597 if (IS_ERR(task)) { 7598 status = PTR_ERR(task); 7599 goto out; 7600 } 7601 status = nfs4_wait_for_completion_rpc_task(task); 7602 if (status == 0) 7603 status = task->tk_status; 7604 rpc_put_task(task); 7605 return 0; 7606 out: 7607 dprintk("<-- %s status=%d\n", __func__, status); 7608 return status; 7609 } 7610 7611 static void 7612 nfs4_layoutget_prepare(struct rpc_task *task, void *calldata) 7613 { 7614 struct nfs4_layoutget *lgp = calldata; 7615 struct nfs_server *server = NFS_SERVER(lgp->args.inode); 7616 struct nfs4_session *session = nfs4_get_session(server); 7617 7618 dprintk("--> %s\n", __func__); 7619 /* Note the is a race here, where a CB_LAYOUTRECALL can come in 7620 * right now covering the LAYOUTGET we are about to send. 7621 * However, that is not so catastrophic, and there seems 7622 * to be no way to prevent it completely. 7623 */ 7624 if (nfs41_setup_sequence(session, &lgp->args.seq_args, 7625 &lgp->res.seq_res, task)) 7626 return; 7627 if (pnfs_choose_layoutget_stateid(&lgp->args.stateid, 7628 NFS_I(lgp->args.inode)->layout, 7629 &lgp->args.range, 7630 lgp->args.ctx->state)) { 7631 rpc_exit(task, NFS4_OK); 7632 } 7633 } 7634 7635 static void nfs4_layoutget_done(struct rpc_task *task, void *calldata) 7636 { 7637 struct nfs4_layoutget *lgp = calldata; 7638 struct inode *inode = lgp->args.inode; 7639 struct nfs_server *server = NFS_SERVER(inode); 7640 struct pnfs_layout_hdr *lo; 7641 struct nfs4_state *state = NULL; 7642 unsigned long timeo, now, giveup; 7643 7644 dprintk("--> %s tk_status => %d\n", __func__, -task->tk_status); 7645 7646 if (!nfs41_sequence_done(task, &lgp->res.seq_res)) 7647 goto out; 7648 7649 switch (task->tk_status) { 7650 case 0: 7651 goto out; 7652 /* 7653 * NFS4ERR_LAYOUTTRYLATER is a conflict with another client 7654 * (or clients) writing to the same RAID stripe 7655 */ 7656 case -NFS4ERR_LAYOUTTRYLATER: 7657 /* 7658 * NFS4ERR_RECALLCONFLICT is when conflict with self (must recall 7659 * existing layout before getting a new one). 7660 */ 7661 case -NFS4ERR_RECALLCONFLICT: 7662 timeo = rpc_get_timeout(task->tk_client); 7663 giveup = lgp->args.timestamp + timeo; 7664 now = jiffies; 7665 if (time_after(giveup, now)) { 7666 unsigned long delay; 7667 7668 /* Delay for: 7669 * - Not less then NFS4_POLL_RETRY_MIN. 7670 * - One last time a jiffie before we give up 7671 * - exponential backoff (time_now minus start_attempt) 7672 */ 7673 delay = max_t(unsigned long, NFS4_POLL_RETRY_MIN, 7674 min((giveup - now - 1), 7675 now - lgp->args.timestamp)); 7676 7677 dprintk("%s: NFS4ERR_RECALLCONFLICT waiting %lu\n", 7678 __func__, delay); 7679 rpc_delay(task, delay); 7680 task->tk_status = 0; 7681 rpc_restart_call_prepare(task); 7682 goto out; /* Do not call nfs4_async_handle_error() */ 7683 } 7684 break; 7685 case -NFS4ERR_EXPIRED: 7686 case -NFS4ERR_BAD_STATEID: 7687 spin_lock(&inode->i_lock); 7688 lo = NFS_I(inode)->layout; 7689 if (!lo || list_empty(&lo->plh_segs)) { 7690 spin_unlock(&inode->i_lock); 7691 /* If the open stateid was bad, then recover it. */ 7692 state = lgp->args.ctx->state; 7693 } else { 7694 LIST_HEAD(head); 7695 7696 /* 7697 * Mark the bad layout state as invalid, then retry 7698 * with the current stateid. 7699 */ 7700 pnfs_mark_matching_lsegs_invalid(lo, &head, NULL); 7701 spin_unlock(&inode->i_lock); 7702 pnfs_free_lseg_list(&head); 7703 7704 task->tk_status = 0; 7705 rpc_restart_call_prepare(task); 7706 } 7707 } 7708 if (nfs4_async_handle_error(task, server, state, NULL) == -EAGAIN) 7709 rpc_restart_call_prepare(task); 7710 out: 7711 dprintk("<-- %s\n", __func__); 7712 } 7713 7714 static size_t max_response_pages(struct nfs_server *server) 7715 { 7716 u32 max_resp_sz = server->nfs_client->cl_session->fc_attrs.max_resp_sz; 7717 return nfs_page_array_len(0, max_resp_sz); 7718 } 7719 7720 static void nfs4_free_pages(struct page **pages, size_t size) 7721 { 7722 int i; 7723 7724 if (!pages) 7725 return; 7726 7727 for (i = 0; i < size; i++) { 7728 if (!pages[i]) 7729 break; 7730 __free_page(pages[i]); 7731 } 7732 kfree(pages); 7733 } 7734 7735 static struct page **nfs4_alloc_pages(size_t size, gfp_t gfp_flags) 7736 { 7737 struct page **pages; 7738 int i; 7739 7740 pages = kcalloc(size, sizeof(struct page *), gfp_flags); 7741 if (!pages) { 7742 dprintk("%s: can't alloc array of %zu pages\n", __func__, size); 7743 return NULL; 7744 } 7745 7746 for (i = 0; i < size; i++) { 7747 pages[i] = alloc_page(gfp_flags); 7748 if (!pages[i]) { 7749 dprintk("%s: failed to allocate page\n", __func__); 7750 nfs4_free_pages(pages, size); 7751 return NULL; 7752 } 7753 } 7754 7755 return pages; 7756 } 7757 7758 static void nfs4_layoutget_release(void *calldata) 7759 { 7760 struct nfs4_layoutget *lgp = calldata; 7761 struct inode *inode = lgp->args.inode; 7762 struct nfs_server *server = NFS_SERVER(inode); 7763 size_t max_pages = max_response_pages(server); 7764 7765 dprintk("--> %s\n", __func__); 7766 nfs4_free_pages(lgp->args.layout.pages, max_pages); 7767 pnfs_put_layout_hdr(NFS_I(inode)->layout); 7768 put_nfs_open_context(lgp->args.ctx); 7769 kfree(calldata); 7770 dprintk("<-- %s\n", __func__); 7771 } 7772 7773 static const struct rpc_call_ops nfs4_layoutget_call_ops = { 7774 .rpc_call_prepare = nfs4_layoutget_prepare, 7775 .rpc_call_done = nfs4_layoutget_done, 7776 .rpc_release = nfs4_layoutget_release, 7777 }; 7778 7779 struct pnfs_layout_segment * 7780 nfs4_proc_layoutget(struct nfs4_layoutget *lgp, gfp_t gfp_flags) 7781 { 7782 struct inode *inode = lgp->args.inode; 7783 struct nfs_server *server = NFS_SERVER(inode); 7784 size_t max_pages = max_response_pages(server); 7785 struct rpc_task *task; 7786 struct rpc_message msg = { 7787 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTGET], 7788 .rpc_argp = &lgp->args, 7789 .rpc_resp = &lgp->res, 7790 .rpc_cred = lgp->cred, 7791 }; 7792 struct rpc_task_setup task_setup_data = { 7793 .rpc_client = server->client, 7794 .rpc_message = &msg, 7795 .callback_ops = &nfs4_layoutget_call_ops, 7796 .callback_data = lgp, 7797 .flags = RPC_TASK_ASYNC, 7798 }; 7799 struct pnfs_layout_segment *lseg = NULL; 7800 int status = 0; 7801 7802 dprintk("--> %s\n", __func__); 7803 7804 /* nfs4_layoutget_release calls pnfs_put_layout_hdr */ 7805 pnfs_get_layout_hdr(NFS_I(inode)->layout); 7806 7807 lgp->args.layout.pages = nfs4_alloc_pages(max_pages, gfp_flags); 7808 if (!lgp->args.layout.pages) { 7809 nfs4_layoutget_release(lgp); 7810 return ERR_PTR(-ENOMEM); 7811 } 7812 lgp->args.layout.pglen = max_pages * PAGE_SIZE; 7813 lgp->args.timestamp = jiffies; 7814 7815 lgp->res.layoutp = &lgp->args.layout; 7816 lgp->res.seq_res.sr_slot = NULL; 7817 nfs4_init_sequence(&lgp->args.seq_args, &lgp->res.seq_res, 0); 7818 7819 task = rpc_run_task(&task_setup_data); 7820 if (IS_ERR(task)) 7821 return ERR_CAST(task); 7822 status = nfs4_wait_for_completion_rpc_task(task); 7823 if (status == 0) 7824 status = task->tk_status; 7825 trace_nfs4_layoutget(lgp->args.ctx, 7826 &lgp->args.range, 7827 &lgp->res.range, 7828 status); 7829 /* if layoutp->len is 0, nfs4_layoutget_prepare called rpc_exit */ 7830 if (status == 0 && lgp->res.layoutp->len) 7831 lseg = pnfs_layout_process(lgp); 7832 rpc_put_task(task); 7833 dprintk("<-- %s status=%d\n", __func__, status); 7834 if (status) 7835 return ERR_PTR(status); 7836 return lseg; 7837 } 7838 7839 static void 7840 nfs4_layoutreturn_prepare(struct rpc_task *task, void *calldata) 7841 { 7842 struct nfs4_layoutreturn *lrp = calldata; 7843 7844 dprintk("--> %s\n", __func__); 7845 nfs41_setup_sequence(lrp->clp->cl_session, 7846 &lrp->args.seq_args, 7847 &lrp->res.seq_res, 7848 task); 7849 } 7850 7851 static void nfs4_layoutreturn_done(struct rpc_task *task, void *calldata) 7852 { 7853 struct nfs4_layoutreturn *lrp = calldata; 7854 struct nfs_server *server; 7855 7856 dprintk("--> %s\n", __func__); 7857 7858 if (!nfs41_sequence_done(task, &lrp->res.seq_res)) 7859 return; 7860 7861 server = NFS_SERVER(lrp->args.inode); 7862 switch (task->tk_status) { 7863 default: 7864 task->tk_status = 0; 7865 case 0: 7866 break; 7867 case -NFS4ERR_DELAY: 7868 if (nfs4_async_handle_error(task, server, NULL, NULL) != -EAGAIN) 7869 break; 7870 rpc_restart_call_prepare(task); 7871 return; 7872 } 7873 dprintk("<-- %s\n", __func__); 7874 } 7875 7876 static void nfs4_layoutreturn_release(void *calldata) 7877 { 7878 struct nfs4_layoutreturn *lrp = calldata; 7879 struct pnfs_layout_hdr *lo = lrp->args.layout; 7880 7881 dprintk("--> %s\n", __func__); 7882 spin_lock(&lo->plh_inode->i_lock); 7883 if (lrp->res.lrs_present) 7884 pnfs_set_layout_stateid(lo, &lrp->res.stateid, true); 7885 pnfs_clear_layoutreturn_waitbit(lo); 7886 clear_bit(NFS_LAYOUT_RETURN_BEFORE_CLOSE, &lo->plh_flags); 7887 rpc_wake_up(&NFS_SERVER(lo->plh_inode)->roc_rpcwaitq); 7888 lo->plh_block_lgets--; 7889 spin_unlock(&lo->plh_inode->i_lock); 7890 pnfs_put_layout_hdr(lrp->args.layout); 7891 nfs_iput_and_deactive(lrp->inode); 7892 kfree(calldata); 7893 dprintk("<-- %s\n", __func__); 7894 } 7895 7896 static const struct rpc_call_ops nfs4_layoutreturn_call_ops = { 7897 .rpc_call_prepare = nfs4_layoutreturn_prepare, 7898 .rpc_call_done = nfs4_layoutreturn_done, 7899 .rpc_release = nfs4_layoutreturn_release, 7900 }; 7901 7902 int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp, bool sync) 7903 { 7904 struct rpc_task *task; 7905 struct rpc_message msg = { 7906 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTRETURN], 7907 .rpc_argp = &lrp->args, 7908 .rpc_resp = &lrp->res, 7909 .rpc_cred = lrp->cred, 7910 }; 7911 struct rpc_task_setup task_setup_data = { 7912 .rpc_client = NFS_SERVER(lrp->args.inode)->client, 7913 .rpc_message = &msg, 7914 .callback_ops = &nfs4_layoutreturn_call_ops, 7915 .callback_data = lrp, 7916 }; 7917 int status = 0; 7918 7919 dprintk("--> %s\n", __func__); 7920 if (!sync) { 7921 lrp->inode = nfs_igrab_and_active(lrp->args.inode); 7922 if (!lrp->inode) { 7923 nfs4_layoutreturn_release(lrp); 7924 return -EAGAIN; 7925 } 7926 task_setup_data.flags |= RPC_TASK_ASYNC; 7927 } 7928 nfs4_init_sequence(&lrp->args.seq_args, &lrp->res.seq_res, 1); 7929 task = rpc_run_task(&task_setup_data); 7930 if (IS_ERR(task)) 7931 return PTR_ERR(task); 7932 if (sync) 7933 status = task->tk_status; 7934 trace_nfs4_layoutreturn(lrp->args.inode, status); 7935 dprintk("<-- %s status=%d\n", __func__, status); 7936 rpc_put_task(task); 7937 return status; 7938 } 7939 7940 static int 7941 _nfs4_proc_getdeviceinfo(struct nfs_server *server, 7942 struct pnfs_device *pdev, 7943 struct rpc_cred *cred) 7944 { 7945 struct nfs4_getdeviceinfo_args args = { 7946 .pdev = pdev, 7947 }; 7948 struct nfs4_getdeviceinfo_res res = { 7949 .pdev = pdev, 7950 }; 7951 struct rpc_message msg = { 7952 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETDEVICEINFO], 7953 .rpc_argp = &args, 7954 .rpc_resp = &res, 7955 .rpc_cred = cred, 7956 }; 7957 int status; 7958 7959 dprintk("--> %s\n", __func__); 7960 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); 7961 dprintk("<-- %s status=%d\n", __func__, status); 7962 7963 return status; 7964 } 7965 7966 int nfs4_proc_getdeviceinfo(struct nfs_server *server, 7967 struct pnfs_device *pdev, 7968 struct rpc_cred *cred) 7969 { 7970 struct nfs4_exception exception = { }; 7971 int err; 7972 7973 do { 7974 err = nfs4_handle_exception(server, 7975 _nfs4_proc_getdeviceinfo(server, pdev, cred), 7976 &exception); 7977 } while (exception.retry); 7978 return err; 7979 } 7980 EXPORT_SYMBOL_GPL(nfs4_proc_getdeviceinfo); 7981 7982 static void nfs4_layoutcommit_prepare(struct rpc_task *task, void *calldata) 7983 { 7984 struct nfs4_layoutcommit_data *data = calldata; 7985 struct nfs_server *server = NFS_SERVER(data->args.inode); 7986 struct nfs4_session *session = nfs4_get_session(server); 7987 7988 nfs41_setup_sequence(session, 7989 &data->args.seq_args, 7990 &data->res.seq_res, 7991 task); 7992 } 7993 7994 static void 7995 nfs4_layoutcommit_done(struct rpc_task *task, void *calldata) 7996 { 7997 struct nfs4_layoutcommit_data *data = calldata; 7998 struct nfs_server *server = NFS_SERVER(data->args.inode); 7999 8000 if (!nfs41_sequence_done(task, &data->res.seq_res)) 8001 return; 8002 8003 switch (task->tk_status) { /* Just ignore these failures */ 8004 case -NFS4ERR_DELEG_REVOKED: /* layout was recalled */ 8005 case -NFS4ERR_BADIOMODE: /* no IOMODE_RW layout for range */ 8006 case -NFS4ERR_BADLAYOUT: /* no layout */ 8007 case -NFS4ERR_GRACE: /* loca_recalim always false */ 8008 task->tk_status = 0; 8009 case 0: 8010 break; 8011 default: 8012 if (nfs4_async_handle_error(task, server, NULL, NULL) == -EAGAIN) { 8013 rpc_restart_call_prepare(task); 8014 return; 8015 } 8016 } 8017 } 8018 8019 static void nfs4_layoutcommit_release(void *calldata) 8020 { 8021 struct nfs4_layoutcommit_data *data = calldata; 8022 8023 pnfs_cleanup_layoutcommit(data); 8024 nfs_post_op_update_inode_force_wcc(data->args.inode, 8025 data->res.fattr); 8026 put_rpccred(data->cred); 8027 nfs_iput_and_deactive(data->inode); 8028 kfree(data); 8029 } 8030 8031 static const struct rpc_call_ops nfs4_layoutcommit_ops = { 8032 .rpc_call_prepare = nfs4_layoutcommit_prepare, 8033 .rpc_call_done = nfs4_layoutcommit_done, 8034 .rpc_release = nfs4_layoutcommit_release, 8035 }; 8036 8037 int 8038 nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data *data, bool sync) 8039 { 8040 struct rpc_message msg = { 8041 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTCOMMIT], 8042 .rpc_argp = &data->args, 8043 .rpc_resp = &data->res, 8044 .rpc_cred = data->cred, 8045 }; 8046 struct rpc_task_setup task_setup_data = { 8047 .task = &data->task, 8048 .rpc_client = NFS_CLIENT(data->args.inode), 8049 .rpc_message = &msg, 8050 .callback_ops = &nfs4_layoutcommit_ops, 8051 .callback_data = data, 8052 }; 8053 struct rpc_task *task; 8054 int status = 0; 8055 8056 dprintk("NFS: %4d initiating layoutcommit call. sync %d " 8057 "lbw: %llu inode %lu\n", 8058 data->task.tk_pid, sync, 8059 data->args.lastbytewritten, 8060 data->args.inode->i_ino); 8061 8062 if (!sync) { 8063 data->inode = nfs_igrab_and_active(data->args.inode); 8064 if (data->inode == NULL) { 8065 nfs4_layoutcommit_release(data); 8066 return -EAGAIN; 8067 } 8068 task_setup_data.flags = RPC_TASK_ASYNC; 8069 } 8070 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1); 8071 task = rpc_run_task(&task_setup_data); 8072 if (IS_ERR(task)) 8073 return PTR_ERR(task); 8074 if (sync) 8075 status = task->tk_status; 8076 trace_nfs4_layoutcommit(data->args.inode, status); 8077 dprintk("%s: status %d\n", __func__, status); 8078 rpc_put_task(task); 8079 return status; 8080 } 8081 8082 /** 8083 * Use the state managment nfs_client cl_rpcclient, which uses krb5i (if 8084 * possible) as per RFC3530bis and RFC5661 Security Considerations sections 8085 */ 8086 static int 8087 _nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle, 8088 struct nfs_fsinfo *info, 8089 struct nfs4_secinfo_flavors *flavors, bool use_integrity) 8090 { 8091 struct nfs41_secinfo_no_name_args args = { 8092 .style = SECINFO_STYLE_CURRENT_FH, 8093 }; 8094 struct nfs4_secinfo_res res = { 8095 .flavors = flavors, 8096 }; 8097 struct rpc_message msg = { 8098 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SECINFO_NO_NAME], 8099 .rpc_argp = &args, 8100 .rpc_resp = &res, 8101 }; 8102 struct rpc_clnt *clnt = server->client; 8103 struct rpc_cred *cred = NULL; 8104 int status; 8105 8106 if (use_integrity) { 8107 clnt = server->nfs_client->cl_rpcclient; 8108 cred = nfs4_get_clid_cred(server->nfs_client); 8109 msg.rpc_cred = cred; 8110 } 8111 8112 dprintk("--> %s\n", __func__); 8113 status = nfs4_call_sync(clnt, server, &msg, &args.seq_args, 8114 &res.seq_res, 0); 8115 dprintk("<-- %s status=%d\n", __func__, status); 8116 8117 if (cred) 8118 put_rpccred(cred); 8119 8120 return status; 8121 } 8122 8123 static int 8124 nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle, 8125 struct nfs_fsinfo *info, struct nfs4_secinfo_flavors *flavors) 8126 { 8127 struct nfs4_exception exception = { }; 8128 int err; 8129 do { 8130 /* first try using integrity protection */ 8131 err = -NFS4ERR_WRONGSEC; 8132 8133 /* try to use integrity protection with machine cred */ 8134 if (_nfs4_is_integrity_protected(server->nfs_client)) 8135 err = _nfs41_proc_secinfo_no_name(server, fhandle, info, 8136 flavors, true); 8137 8138 /* 8139 * if unable to use integrity protection, or SECINFO with 8140 * integrity protection returns NFS4ERR_WRONGSEC (which is 8141 * disallowed by spec, but exists in deployed servers) use 8142 * the current filesystem's rpc_client and the user cred. 8143 */ 8144 if (err == -NFS4ERR_WRONGSEC) 8145 err = _nfs41_proc_secinfo_no_name(server, fhandle, info, 8146 flavors, false); 8147 8148 switch (err) { 8149 case 0: 8150 case -NFS4ERR_WRONGSEC: 8151 case -ENOTSUPP: 8152 goto out; 8153 default: 8154 err = nfs4_handle_exception(server, err, &exception); 8155 } 8156 } while (exception.retry); 8157 out: 8158 return err; 8159 } 8160 8161 static int 8162 nfs41_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle, 8163 struct nfs_fsinfo *info) 8164 { 8165 int err; 8166 struct page *page; 8167 rpc_authflavor_t flavor = RPC_AUTH_MAXFLAVOR; 8168 struct nfs4_secinfo_flavors *flavors; 8169 struct nfs4_secinfo4 *secinfo; 8170 int i; 8171 8172 page = alloc_page(GFP_KERNEL); 8173 if (!page) { 8174 err = -ENOMEM; 8175 goto out; 8176 } 8177 8178 flavors = page_address(page); 8179 err = nfs41_proc_secinfo_no_name(server, fhandle, info, flavors); 8180 8181 /* 8182 * Fall back on "guess and check" method if 8183 * the server doesn't support SECINFO_NO_NAME 8184 */ 8185 if (err == -NFS4ERR_WRONGSEC || err == -ENOTSUPP) { 8186 err = nfs4_find_root_sec(server, fhandle, info); 8187 goto out_freepage; 8188 } 8189 if (err) 8190 goto out_freepage; 8191 8192 for (i = 0; i < flavors->num_flavors; i++) { 8193 secinfo = &flavors->flavors[i]; 8194 8195 switch (secinfo->flavor) { 8196 case RPC_AUTH_NULL: 8197 case RPC_AUTH_UNIX: 8198 case RPC_AUTH_GSS: 8199 flavor = rpcauth_get_pseudoflavor(secinfo->flavor, 8200 &secinfo->flavor_info); 8201 break; 8202 default: 8203 flavor = RPC_AUTH_MAXFLAVOR; 8204 break; 8205 } 8206 8207 if (!nfs_auth_info_match(&server->auth_info, flavor)) 8208 flavor = RPC_AUTH_MAXFLAVOR; 8209 8210 if (flavor != RPC_AUTH_MAXFLAVOR) { 8211 err = nfs4_lookup_root_sec(server, fhandle, 8212 info, flavor); 8213 if (!err) 8214 break; 8215 } 8216 } 8217 8218 if (flavor == RPC_AUTH_MAXFLAVOR) 8219 err = -EPERM; 8220 8221 out_freepage: 8222 put_page(page); 8223 if (err == -EACCES) 8224 return -EPERM; 8225 out: 8226 return err; 8227 } 8228 8229 static int _nfs41_test_stateid(struct nfs_server *server, 8230 nfs4_stateid *stateid, 8231 struct rpc_cred *cred) 8232 { 8233 int status; 8234 struct nfs41_test_stateid_args args = { 8235 .stateid = stateid, 8236 }; 8237 struct nfs41_test_stateid_res res; 8238 struct rpc_message msg = { 8239 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_TEST_STATEID], 8240 .rpc_argp = &args, 8241 .rpc_resp = &res, 8242 .rpc_cred = cred, 8243 }; 8244 struct rpc_clnt *rpc_client = server->client; 8245 8246 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_STATEID, 8247 &rpc_client, &msg); 8248 8249 dprintk("NFS call test_stateid %p\n", stateid); 8250 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0); 8251 nfs4_set_sequence_privileged(&args.seq_args); 8252 status = nfs4_call_sync_sequence(rpc_client, server, &msg, 8253 &args.seq_args, &res.seq_res); 8254 if (status != NFS_OK) { 8255 dprintk("NFS reply test_stateid: failed, %d\n", status); 8256 return status; 8257 } 8258 dprintk("NFS reply test_stateid: succeeded, %d\n", -res.status); 8259 return -res.status; 8260 } 8261 8262 /** 8263 * nfs41_test_stateid - perform a TEST_STATEID operation 8264 * 8265 * @server: server / transport on which to perform the operation 8266 * @stateid: state ID to test 8267 * @cred: credential 8268 * 8269 * Returns NFS_OK if the server recognizes that "stateid" is valid. 8270 * Otherwise a negative NFS4ERR value is returned if the operation 8271 * failed or the state ID is not currently valid. 8272 */ 8273 static int nfs41_test_stateid(struct nfs_server *server, 8274 nfs4_stateid *stateid, 8275 struct rpc_cred *cred) 8276 { 8277 struct nfs4_exception exception = { }; 8278 int err; 8279 do { 8280 err = _nfs41_test_stateid(server, stateid, cred); 8281 if (err != -NFS4ERR_DELAY) 8282 break; 8283 nfs4_handle_exception(server, err, &exception); 8284 } while (exception.retry); 8285 return err; 8286 } 8287 8288 struct nfs_free_stateid_data { 8289 struct nfs_server *server; 8290 struct nfs41_free_stateid_args args; 8291 struct nfs41_free_stateid_res res; 8292 }; 8293 8294 static void nfs41_free_stateid_prepare(struct rpc_task *task, void *calldata) 8295 { 8296 struct nfs_free_stateid_data *data = calldata; 8297 nfs41_setup_sequence(nfs4_get_session(data->server), 8298 &data->args.seq_args, 8299 &data->res.seq_res, 8300 task); 8301 } 8302 8303 static void nfs41_free_stateid_done(struct rpc_task *task, void *calldata) 8304 { 8305 struct nfs_free_stateid_data *data = calldata; 8306 8307 nfs41_sequence_done(task, &data->res.seq_res); 8308 8309 switch (task->tk_status) { 8310 case -NFS4ERR_DELAY: 8311 if (nfs4_async_handle_error(task, data->server, NULL, NULL) == -EAGAIN) 8312 rpc_restart_call_prepare(task); 8313 } 8314 } 8315 8316 static void nfs41_free_stateid_release(void *calldata) 8317 { 8318 kfree(calldata); 8319 } 8320 8321 static const struct rpc_call_ops nfs41_free_stateid_ops = { 8322 .rpc_call_prepare = nfs41_free_stateid_prepare, 8323 .rpc_call_done = nfs41_free_stateid_done, 8324 .rpc_release = nfs41_free_stateid_release, 8325 }; 8326 8327 static struct rpc_task *_nfs41_free_stateid(struct nfs_server *server, 8328 nfs4_stateid *stateid, 8329 struct rpc_cred *cred, 8330 bool privileged) 8331 { 8332 struct rpc_message msg = { 8333 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FREE_STATEID], 8334 .rpc_cred = cred, 8335 }; 8336 struct rpc_task_setup task_setup = { 8337 .rpc_client = server->client, 8338 .rpc_message = &msg, 8339 .callback_ops = &nfs41_free_stateid_ops, 8340 .flags = RPC_TASK_ASYNC, 8341 }; 8342 struct nfs_free_stateid_data *data; 8343 8344 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_STATEID, 8345 &task_setup.rpc_client, &msg); 8346 8347 dprintk("NFS call free_stateid %p\n", stateid); 8348 data = kmalloc(sizeof(*data), GFP_NOFS); 8349 if (!data) 8350 return ERR_PTR(-ENOMEM); 8351 data->server = server; 8352 nfs4_stateid_copy(&data->args.stateid, stateid); 8353 8354 task_setup.callback_data = data; 8355 8356 msg.rpc_argp = &data->args; 8357 msg.rpc_resp = &data->res; 8358 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 0); 8359 if (privileged) 8360 nfs4_set_sequence_privileged(&data->args.seq_args); 8361 8362 return rpc_run_task(&task_setup); 8363 } 8364 8365 /** 8366 * nfs41_free_stateid - perform a FREE_STATEID operation 8367 * 8368 * @server: server / transport on which to perform the operation 8369 * @stateid: state ID to release 8370 * @cred: credential 8371 * 8372 * Returns NFS_OK if the server freed "stateid". Otherwise a 8373 * negative NFS4ERR value is returned. 8374 */ 8375 static int nfs41_free_stateid(struct nfs_server *server, 8376 nfs4_stateid *stateid, 8377 struct rpc_cred *cred) 8378 { 8379 struct rpc_task *task; 8380 int ret; 8381 8382 task = _nfs41_free_stateid(server, stateid, cred, true); 8383 if (IS_ERR(task)) 8384 return PTR_ERR(task); 8385 ret = rpc_wait_for_completion_task(task); 8386 if (!ret) 8387 ret = task->tk_status; 8388 rpc_put_task(task); 8389 return ret; 8390 } 8391 8392 static void 8393 nfs41_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp) 8394 { 8395 struct rpc_task *task; 8396 struct rpc_cred *cred = lsp->ls_state->owner->so_cred; 8397 8398 task = _nfs41_free_stateid(server, &lsp->ls_stateid, cred, false); 8399 nfs4_free_lock_state(server, lsp); 8400 if (IS_ERR(task)) 8401 return; 8402 rpc_put_task(task); 8403 } 8404 8405 static bool nfs41_match_stateid(const nfs4_stateid *s1, 8406 const nfs4_stateid *s2) 8407 { 8408 if (memcmp(s1->other, s2->other, sizeof(s1->other)) != 0) 8409 return false; 8410 8411 if (s1->seqid == s2->seqid) 8412 return true; 8413 if (s1->seqid == 0 || s2->seqid == 0) 8414 return true; 8415 8416 return false; 8417 } 8418 8419 #endif /* CONFIG_NFS_V4_1 */ 8420 8421 static bool nfs4_match_stateid(const nfs4_stateid *s1, 8422 const nfs4_stateid *s2) 8423 { 8424 return nfs4_stateid_match(s1, s2); 8425 } 8426 8427 8428 static const struct nfs4_state_recovery_ops nfs40_reboot_recovery_ops = { 8429 .owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT, 8430 .state_flag_bit = NFS_STATE_RECLAIM_REBOOT, 8431 .recover_open = nfs4_open_reclaim, 8432 .recover_lock = nfs4_lock_reclaim, 8433 .establish_clid = nfs4_init_clientid, 8434 .detect_trunking = nfs40_discover_server_trunking, 8435 }; 8436 8437 #if defined(CONFIG_NFS_V4_1) 8438 static const struct nfs4_state_recovery_ops nfs41_reboot_recovery_ops = { 8439 .owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT, 8440 .state_flag_bit = NFS_STATE_RECLAIM_REBOOT, 8441 .recover_open = nfs4_open_reclaim, 8442 .recover_lock = nfs4_lock_reclaim, 8443 .establish_clid = nfs41_init_clientid, 8444 .reclaim_complete = nfs41_proc_reclaim_complete, 8445 .detect_trunking = nfs41_discover_server_trunking, 8446 }; 8447 #endif /* CONFIG_NFS_V4_1 */ 8448 8449 static const struct nfs4_state_recovery_ops nfs40_nograce_recovery_ops = { 8450 .owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE, 8451 .state_flag_bit = NFS_STATE_RECLAIM_NOGRACE, 8452 .recover_open = nfs40_open_expired, 8453 .recover_lock = nfs4_lock_expired, 8454 .establish_clid = nfs4_init_clientid, 8455 }; 8456 8457 #if defined(CONFIG_NFS_V4_1) 8458 static const struct nfs4_state_recovery_ops nfs41_nograce_recovery_ops = { 8459 .owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE, 8460 .state_flag_bit = NFS_STATE_RECLAIM_NOGRACE, 8461 .recover_open = nfs41_open_expired, 8462 .recover_lock = nfs41_lock_expired, 8463 .establish_clid = nfs41_init_clientid, 8464 }; 8465 #endif /* CONFIG_NFS_V4_1 */ 8466 8467 static const struct nfs4_state_maintenance_ops nfs40_state_renewal_ops = { 8468 .sched_state_renewal = nfs4_proc_async_renew, 8469 .get_state_renewal_cred_locked = nfs4_get_renew_cred_locked, 8470 .renew_lease = nfs4_proc_renew, 8471 }; 8472 8473 #if defined(CONFIG_NFS_V4_1) 8474 static const struct nfs4_state_maintenance_ops nfs41_state_renewal_ops = { 8475 .sched_state_renewal = nfs41_proc_async_sequence, 8476 .get_state_renewal_cred_locked = nfs4_get_machine_cred_locked, 8477 .renew_lease = nfs4_proc_sequence, 8478 }; 8479 #endif 8480 8481 static const struct nfs4_mig_recovery_ops nfs40_mig_recovery_ops = { 8482 .get_locations = _nfs40_proc_get_locations, 8483 .fsid_present = _nfs40_proc_fsid_present, 8484 }; 8485 8486 #if defined(CONFIG_NFS_V4_1) 8487 static const struct nfs4_mig_recovery_ops nfs41_mig_recovery_ops = { 8488 .get_locations = _nfs41_proc_get_locations, 8489 .fsid_present = _nfs41_proc_fsid_present, 8490 }; 8491 #endif /* CONFIG_NFS_V4_1 */ 8492 8493 static const struct nfs4_minor_version_ops nfs_v4_0_minor_ops = { 8494 .minor_version = 0, 8495 .init_caps = NFS_CAP_READDIRPLUS 8496 | NFS_CAP_ATOMIC_OPEN 8497 | NFS_CAP_CHANGE_ATTR 8498 | NFS_CAP_POSIX_LOCK, 8499 .init_client = nfs40_init_client, 8500 .shutdown_client = nfs40_shutdown_client, 8501 .match_stateid = nfs4_match_stateid, 8502 .find_root_sec = nfs4_find_root_sec, 8503 .free_lock_state = nfs4_release_lockowner, 8504 .alloc_seqid = nfs_alloc_seqid, 8505 .call_sync_ops = &nfs40_call_sync_ops, 8506 .reboot_recovery_ops = &nfs40_reboot_recovery_ops, 8507 .nograce_recovery_ops = &nfs40_nograce_recovery_ops, 8508 .state_renewal_ops = &nfs40_state_renewal_ops, 8509 .mig_recovery_ops = &nfs40_mig_recovery_ops, 8510 }; 8511 8512 #if defined(CONFIG_NFS_V4_1) 8513 static struct nfs_seqid * 8514 nfs_alloc_no_seqid(struct nfs_seqid_counter *arg1, gfp_t arg2) 8515 { 8516 return NULL; 8517 } 8518 8519 static const struct nfs4_minor_version_ops nfs_v4_1_minor_ops = { 8520 .minor_version = 1, 8521 .init_caps = NFS_CAP_READDIRPLUS 8522 | NFS_CAP_ATOMIC_OPEN 8523 | NFS_CAP_CHANGE_ATTR 8524 | NFS_CAP_POSIX_LOCK 8525 | NFS_CAP_STATEID_NFSV41 8526 | NFS_CAP_ATOMIC_OPEN_V1, 8527 .init_client = nfs41_init_client, 8528 .shutdown_client = nfs41_shutdown_client, 8529 .match_stateid = nfs41_match_stateid, 8530 .find_root_sec = nfs41_find_root_sec, 8531 .free_lock_state = nfs41_free_lock_state, 8532 .alloc_seqid = nfs_alloc_no_seqid, 8533 .call_sync_ops = &nfs41_call_sync_ops, 8534 .reboot_recovery_ops = &nfs41_reboot_recovery_ops, 8535 .nograce_recovery_ops = &nfs41_nograce_recovery_ops, 8536 .state_renewal_ops = &nfs41_state_renewal_ops, 8537 .mig_recovery_ops = &nfs41_mig_recovery_ops, 8538 }; 8539 #endif 8540 8541 #if defined(CONFIG_NFS_V4_2) 8542 static const struct nfs4_minor_version_ops nfs_v4_2_minor_ops = { 8543 .minor_version = 2, 8544 .init_caps = NFS_CAP_READDIRPLUS 8545 | NFS_CAP_ATOMIC_OPEN 8546 | NFS_CAP_CHANGE_ATTR 8547 | NFS_CAP_POSIX_LOCK 8548 | NFS_CAP_STATEID_NFSV41 8549 | NFS_CAP_ATOMIC_OPEN_V1 8550 | NFS_CAP_ALLOCATE 8551 | NFS_CAP_DEALLOCATE 8552 | NFS_CAP_SEEK, 8553 .init_client = nfs41_init_client, 8554 .shutdown_client = nfs41_shutdown_client, 8555 .match_stateid = nfs41_match_stateid, 8556 .find_root_sec = nfs41_find_root_sec, 8557 .free_lock_state = nfs41_free_lock_state, 8558 .call_sync_ops = &nfs41_call_sync_ops, 8559 .alloc_seqid = nfs_alloc_no_seqid, 8560 .reboot_recovery_ops = &nfs41_reboot_recovery_ops, 8561 .nograce_recovery_ops = &nfs41_nograce_recovery_ops, 8562 .state_renewal_ops = &nfs41_state_renewal_ops, 8563 }; 8564 #endif 8565 8566 const struct nfs4_minor_version_ops *nfs_v4_minor_ops[] = { 8567 [0] = &nfs_v4_0_minor_ops, 8568 #if defined(CONFIG_NFS_V4_1) 8569 [1] = &nfs_v4_1_minor_ops, 8570 #endif 8571 #if defined(CONFIG_NFS_V4_2) 8572 [2] = &nfs_v4_2_minor_ops, 8573 #endif 8574 }; 8575 8576 static const struct inode_operations nfs4_dir_inode_operations = { 8577 .create = nfs_create, 8578 .lookup = nfs_lookup, 8579 .atomic_open = nfs_atomic_open, 8580 .link = nfs_link, 8581 .unlink = nfs_unlink, 8582 .symlink = nfs_symlink, 8583 .mkdir = nfs_mkdir, 8584 .rmdir = nfs_rmdir, 8585 .mknod = nfs_mknod, 8586 .rename = nfs_rename, 8587 .permission = nfs_permission, 8588 .getattr = nfs_getattr, 8589 .setattr = nfs_setattr, 8590 .getxattr = generic_getxattr, 8591 .setxattr = generic_setxattr, 8592 .listxattr = generic_listxattr, 8593 .removexattr = generic_removexattr, 8594 }; 8595 8596 static const struct inode_operations nfs4_file_inode_operations = { 8597 .permission = nfs_permission, 8598 .getattr = nfs_getattr, 8599 .setattr = nfs_setattr, 8600 .getxattr = generic_getxattr, 8601 .setxattr = generic_setxattr, 8602 .listxattr = generic_listxattr, 8603 .removexattr = generic_removexattr, 8604 }; 8605 8606 const struct nfs_rpc_ops nfs_v4_clientops = { 8607 .version = 4, /* protocol version */ 8608 .dentry_ops = &nfs4_dentry_operations, 8609 .dir_inode_ops = &nfs4_dir_inode_operations, 8610 .file_inode_ops = &nfs4_file_inode_operations, 8611 .file_ops = &nfs4_file_operations, 8612 .getroot = nfs4_proc_get_root, 8613 .submount = nfs4_submount, 8614 .try_mount = nfs4_try_mount, 8615 .getattr = nfs4_proc_getattr, 8616 .setattr = nfs4_proc_setattr, 8617 .lookup = nfs4_proc_lookup, 8618 .access = nfs4_proc_access, 8619 .readlink = nfs4_proc_readlink, 8620 .create = nfs4_proc_create, 8621 .remove = nfs4_proc_remove, 8622 .unlink_setup = nfs4_proc_unlink_setup, 8623 .unlink_rpc_prepare = nfs4_proc_unlink_rpc_prepare, 8624 .unlink_done = nfs4_proc_unlink_done, 8625 .rename_setup = nfs4_proc_rename_setup, 8626 .rename_rpc_prepare = nfs4_proc_rename_rpc_prepare, 8627 .rename_done = nfs4_proc_rename_done, 8628 .link = nfs4_proc_link, 8629 .symlink = nfs4_proc_symlink, 8630 .mkdir = nfs4_proc_mkdir, 8631 .rmdir = nfs4_proc_remove, 8632 .readdir = nfs4_proc_readdir, 8633 .mknod = nfs4_proc_mknod, 8634 .statfs = nfs4_proc_statfs, 8635 .fsinfo = nfs4_proc_fsinfo, 8636 .pathconf = nfs4_proc_pathconf, 8637 .set_capabilities = nfs4_server_capabilities, 8638 .decode_dirent = nfs4_decode_dirent, 8639 .pgio_rpc_prepare = nfs4_proc_pgio_rpc_prepare, 8640 .read_setup = nfs4_proc_read_setup, 8641 .read_done = nfs4_read_done, 8642 .write_setup = nfs4_proc_write_setup, 8643 .write_done = nfs4_write_done, 8644 .commit_setup = nfs4_proc_commit_setup, 8645 .commit_rpc_prepare = nfs4_proc_commit_rpc_prepare, 8646 .commit_done = nfs4_commit_done, 8647 .lock = nfs4_proc_lock, 8648 .clear_acl_cache = nfs4_zap_acl_attr, 8649 .close_context = nfs4_close_context, 8650 .open_context = nfs4_atomic_open, 8651 .have_delegation = nfs4_have_delegation, 8652 .return_delegation = nfs4_inode_return_delegation, 8653 .alloc_client = nfs4_alloc_client, 8654 .init_client = nfs4_init_client, 8655 .free_client = nfs4_free_client, 8656 .create_server = nfs4_create_server, 8657 .clone_server = nfs_clone_server, 8658 }; 8659 8660 static const struct xattr_handler nfs4_xattr_nfs4_acl_handler = { 8661 .prefix = XATTR_NAME_NFSV4_ACL, 8662 .list = nfs4_xattr_list_nfs4_acl, 8663 .get = nfs4_xattr_get_nfs4_acl, 8664 .set = nfs4_xattr_set_nfs4_acl, 8665 }; 8666 8667 const struct xattr_handler *nfs4_xattr_handlers[] = { 8668 &nfs4_xattr_nfs4_acl_handler, 8669 #ifdef CONFIG_NFS_V4_SECURITY_LABEL 8670 &nfs4_xattr_nfs4_label_handler, 8671 #endif 8672 NULL 8673 }; 8674 8675 /* 8676 * Local variables: 8677 * c-basic-offset: 8 8678 * End: 8679 */ 8680