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