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