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