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