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