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