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