1 /* 2 * pNFS functions to call and manage layout drivers. 3 * 4 * Copyright (c) 2002 [year of first publication] 5 * The Regents of the University of Michigan 6 * All Rights Reserved 7 * 8 * Dean Hildebrand <dhildebz@umich.edu> 9 * 10 * Permission is granted to use, copy, create derivative works, and 11 * redistribute this software and such derivative works for any purpose, 12 * so long as the name of the University of Michigan is not used in 13 * any advertising or publicity pertaining to the use or distribution 14 * of this software without specific, written prior authorization. If 15 * the above copyright notice or any other identification of the 16 * University of Michigan is included in any copy of any portion of 17 * this software, then the disclaimer below must also be included. 18 * 19 * This software is provided as is, without representation or warranty 20 * of any kind either express or implied, including without limitation 21 * the implied warranties of merchantability, fitness for a particular 22 * purpose, or noninfringement. The Regents of the University of 23 * Michigan shall not be liable for any damages, including special, 24 * indirect, incidental, or consequential damages, with respect to any 25 * claim arising out of or in connection with the use of the software, 26 * even if it has been or is hereafter advised of the possibility of 27 * such damages. 28 */ 29 30 #include <linux/nfs_fs.h> 31 #include <linux/nfs_page.h> 32 #include <linux/module.h> 33 #include <linux/sort.h> 34 #include "internal.h" 35 #include "pnfs.h" 36 #include "iostat.h" 37 #include "nfs4trace.h" 38 #include "delegation.h" 39 #include "nfs42.h" 40 #include "nfs4_fs.h" 41 42 #define NFSDBG_FACILITY NFSDBG_PNFS 43 #define PNFS_LAYOUTGET_RETRY_TIMEOUT (120*HZ) 44 45 /* Locking: 46 * 47 * pnfs_spinlock: 48 * protects pnfs_modules_tbl. 49 */ 50 static DEFINE_SPINLOCK(pnfs_spinlock); 51 52 /* 53 * pnfs_modules_tbl holds all pnfs modules 54 */ 55 static LIST_HEAD(pnfs_modules_tbl); 56 57 static void pnfs_layoutreturn_before_put_layout_hdr(struct pnfs_layout_hdr *lo); 58 static void pnfs_free_returned_lsegs(struct pnfs_layout_hdr *lo, 59 struct list_head *free_me, 60 const struct pnfs_layout_range *range, 61 u32 seq); 62 static bool pnfs_lseg_dec_and_remove_zero(struct pnfs_layout_segment *lseg, 63 struct list_head *tmp_list); 64 65 /* Return the registered pnfs layout driver module matching given id */ 66 static struct pnfs_layoutdriver_type * 67 find_pnfs_driver_locked(u32 id) 68 { 69 struct pnfs_layoutdriver_type *local; 70 71 list_for_each_entry(local, &pnfs_modules_tbl, pnfs_tblid) 72 if (local->id == id) 73 goto out; 74 local = NULL; 75 out: 76 dprintk("%s: Searching for id %u, found %p\n", __func__, id, local); 77 return local; 78 } 79 80 static struct pnfs_layoutdriver_type * 81 find_pnfs_driver(u32 id) 82 { 83 struct pnfs_layoutdriver_type *local; 84 85 spin_lock(&pnfs_spinlock); 86 local = find_pnfs_driver_locked(id); 87 if (local != NULL && !try_module_get(local->owner)) { 88 dprintk("%s: Could not grab reference on module\n", __func__); 89 local = NULL; 90 } 91 spin_unlock(&pnfs_spinlock); 92 return local; 93 } 94 95 void 96 unset_pnfs_layoutdriver(struct nfs_server *nfss) 97 { 98 if (nfss->pnfs_curr_ld) { 99 if (nfss->pnfs_curr_ld->clear_layoutdriver) 100 nfss->pnfs_curr_ld->clear_layoutdriver(nfss); 101 /* Decrement the MDS count. Purge the deviceid cache if zero */ 102 if (atomic_dec_and_test(&nfss->nfs_client->cl_mds_count)) 103 nfs4_deviceid_purge_client(nfss->nfs_client); 104 module_put(nfss->pnfs_curr_ld->owner); 105 } 106 nfss->pnfs_curr_ld = NULL; 107 } 108 109 /* 110 * When the server sends a list of layout types, we choose one in the order 111 * given in the list below. 112 * 113 * FIXME: should this list be configurable in some fashion? module param? 114 * mount option? something else? 115 */ 116 static const u32 ld_prefs[] = { 117 LAYOUT_SCSI, 118 LAYOUT_BLOCK_VOLUME, 119 LAYOUT_OSD2_OBJECTS, 120 LAYOUT_FLEX_FILES, 121 LAYOUT_NFSV4_1_FILES, 122 0 123 }; 124 125 static int 126 ld_cmp(const void *e1, const void *e2) 127 { 128 u32 ld1 = *((u32 *)e1); 129 u32 ld2 = *((u32 *)e2); 130 int i; 131 132 for (i = 0; ld_prefs[i] != 0; i++) { 133 if (ld1 == ld_prefs[i]) 134 return -1; 135 136 if (ld2 == ld_prefs[i]) 137 return 1; 138 } 139 return 0; 140 } 141 142 /* 143 * Try to set the server's pnfs module to the pnfs layout type specified by id. 144 * Currently only one pNFS layout driver per filesystem is supported. 145 * 146 * @ids array of layout types supported by MDS. 147 */ 148 void 149 set_pnfs_layoutdriver(struct nfs_server *server, const struct nfs_fh *mntfh, 150 struct nfs_fsinfo *fsinfo) 151 { 152 struct pnfs_layoutdriver_type *ld_type = NULL; 153 u32 id; 154 int i; 155 156 if (fsinfo->nlayouttypes == 0) 157 goto out_no_driver; 158 if (!(server->nfs_client->cl_exchange_flags & 159 (EXCHGID4_FLAG_USE_NON_PNFS | EXCHGID4_FLAG_USE_PNFS_MDS))) { 160 printk(KERN_ERR "NFS: %s: cl_exchange_flags 0x%x\n", 161 __func__, server->nfs_client->cl_exchange_flags); 162 goto out_no_driver; 163 } 164 165 sort(fsinfo->layouttype, fsinfo->nlayouttypes, 166 sizeof(*fsinfo->layouttype), ld_cmp, NULL); 167 168 for (i = 0; i < fsinfo->nlayouttypes; i++) { 169 id = fsinfo->layouttype[i]; 170 ld_type = find_pnfs_driver(id); 171 if (!ld_type) { 172 request_module("%s-%u", LAYOUT_NFSV4_1_MODULE_PREFIX, 173 id); 174 ld_type = find_pnfs_driver(id); 175 } 176 if (ld_type) 177 break; 178 } 179 180 if (!ld_type) { 181 dprintk("%s: No pNFS module found!\n", __func__); 182 goto out_no_driver; 183 } 184 185 server->pnfs_curr_ld = ld_type; 186 if (ld_type->set_layoutdriver 187 && ld_type->set_layoutdriver(server, mntfh)) { 188 printk(KERN_ERR "NFS: %s: Error initializing pNFS layout " 189 "driver %u.\n", __func__, id); 190 module_put(ld_type->owner); 191 goto out_no_driver; 192 } 193 /* Bump the MDS count */ 194 atomic_inc(&server->nfs_client->cl_mds_count); 195 196 dprintk("%s: pNFS module for %u set\n", __func__, id); 197 return; 198 199 out_no_driver: 200 dprintk("%s: Using NFSv4 I/O\n", __func__); 201 server->pnfs_curr_ld = NULL; 202 } 203 204 int 205 pnfs_register_layoutdriver(struct pnfs_layoutdriver_type *ld_type) 206 { 207 int status = -EINVAL; 208 struct pnfs_layoutdriver_type *tmp; 209 210 if (ld_type->id == 0) { 211 printk(KERN_ERR "NFS: %s id 0 is reserved\n", __func__); 212 return status; 213 } 214 if (!ld_type->alloc_lseg || !ld_type->free_lseg) { 215 printk(KERN_ERR "NFS: %s Layout driver must provide " 216 "alloc_lseg and free_lseg.\n", __func__); 217 return status; 218 } 219 220 spin_lock(&pnfs_spinlock); 221 tmp = find_pnfs_driver_locked(ld_type->id); 222 if (!tmp) { 223 list_add(&ld_type->pnfs_tblid, &pnfs_modules_tbl); 224 status = 0; 225 dprintk("%s Registering id:%u name:%s\n", __func__, ld_type->id, 226 ld_type->name); 227 } else { 228 printk(KERN_ERR "NFS: %s Module with id %d already loaded!\n", 229 __func__, ld_type->id); 230 } 231 spin_unlock(&pnfs_spinlock); 232 233 return status; 234 } 235 EXPORT_SYMBOL_GPL(pnfs_register_layoutdriver); 236 237 void 238 pnfs_unregister_layoutdriver(struct pnfs_layoutdriver_type *ld_type) 239 { 240 dprintk("%s Deregistering id:%u\n", __func__, ld_type->id); 241 spin_lock(&pnfs_spinlock); 242 list_del(&ld_type->pnfs_tblid); 243 spin_unlock(&pnfs_spinlock); 244 } 245 EXPORT_SYMBOL_GPL(pnfs_unregister_layoutdriver); 246 247 /* 248 * pNFS client layout cache 249 */ 250 251 /* Need to hold i_lock if caller does not already hold reference */ 252 void 253 pnfs_get_layout_hdr(struct pnfs_layout_hdr *lo) 254 { 255 refcount_inc(&lo->plh_refcount); 256 } 257 258 static struct pnfs_layout_hdr * 259 pnfs_alloc_layout_hdr(struct inode *ino, gfp_t gfp_flags) 260 { 261 struct pnfs_layoutdriver_type *ld = NFS_SERVER(ino)->pnfs_curr_ld; 262 return ld->alloc_layout_hdr(ino, gfp_flags); 263 } 264 265 static void 266 pnfs_free_layout_hdr(struct pnfs_layout_hdr *lo) 267 { 268 struct nfs_server *server = NFS_SERVER(lo->plh_inode); 269 struct pnfs_layoutdriver_type *ld = server->pnfs_curr_ld; 270 271 if (test_and_clear_bit(NFS_LAYOUT_HASHED, &lo->plh_flags)) { 272 struct nfs_client *clp = server->nfs_client; 273 274 spin_lock(&clp->cl_lock); 275 list_del_rcu(&lo->plh_layouts); 276 spin_unlock(&clp->cl_lock); 277 } 278 put_cred(lo->plh_lc_cred); 279 return ld->free_layout_hdr(lo); 280 } 281 282 static void 283 pnfs_detach_layout_hdr(struct pnfs_layout_hdr *lo) 284 { 285 struct nfs_inode *nfsi = NFS_I(lo->plh_inode); 286 dprintk("%s: freeing layout cache %p\n", __func__, lo); 287 nfsi->layout = NULL; 288 /* Reset MDS Threshold I/O counters */ 289 nfsi->write_io = 0; 290 nfsi->read_io = 0; 291 } 292 293 void 294 pnfs_put_layout_hdr(struct pnfs_layout_hdr *lo) 295 { 296 struct inode *inode; 297 unsigned long i_state; 298 299 if (!lo) 300 return; 301 inode = lo->plh_inode; 302 pnfs_layoutreturn_before_put_layout_hdr(lo); 303 304 if (refcount_dec_and_lock(&lo->plh_refcount, &inode->i_lock)) { 305 if (!list_empty(&lo->plh_segs)) 306 WARN_ONCE(1, "NFS: BUG unfreed layout segments.\n"); 307 pnfs_detach_layout_hdr(lo); 308 i_state = inode->i_state; 309 spin_unlock(&inode->i_lock); 310 pnfs_free_layout_hdr(lo); 311 /* Notify pnfs_destroy_layout_final() that we're done */ 312 if (i_state & (I_FREEING | I_CLEAR)) 313 wake_up_var(lo); 314 } 315 } 316 317 static struct inode * 318 pnfs_grab_inode_layout_hdr(struct pnfs_layout_hdr *lo) 319 { 320 struct inode *inode = igrab(lo->plh_inode); 321 if (inode) 322 return inode; 323 set_bit(NFS_LAYOUT_INODE_FREEING, &lo->plh_flags); 324 return NULL; 325 } 326 327 static void 328 pnfs_set_plh_return_info(struct pnfs_layout_hdr *lo, enum pnfs_iomode iomode, 329 u32 seq) 330 { 331 if (lo->plh_return_iomode != 0 && lo->plh_return_iomode != iomode) 332 iomode = IOMODE_ANY; 333 lo->plh_return_iomode = iomode; 334 set_bit(NFS_LAYOUT_RETURN_REQUESTED, &lo->plh_flags); 335 if (seq != 0) { 336 WARN_ON_ONCE(lo->plh_return_seq != 0 && lo->plh_return_seq != seq); 337 lo->plh_return_seq = seq; 338 } 339 } 340 341 static void 342 pnfs_clear_layoutreturn_info(struct pnfs_layout_hdr *lo) 343 { 344 struct pnfs_layout_segment *lseg; 345 lo->plh_return_iomode = 0; 346 lo->plh_return_seq = 0; 347 clear_bit(NFS_LAYOUT_RETURN_REQUESTED, &lo->plh_flags); 348 list_for_each_entry(lseg, &lo->plh_segs, pls_list) { 349 if (!test_bit(NFS_LSEG_LAYOUTRETURN, &lseg->pls_flags)) 350 continue; 351 pnfs_set_plh_return_info(lo, lseg->pls_range.iomode, 0); 352 } 353 } 354 355 static void pnfs_clear_layoutreturn_waitbit(struct pnfs_layout_hdr *lo) 356 { 357 clear_bit_unlock(NFS_LAYOUT_RETURN, &lo->plh_flags); 358 clear_bit(NFS_LAYOUT_RETURN_LOCK, &lo->plh_flags); 359 smp_mb__after_atomic(); 360 wake_up_bit(&lo->plh_flags, NFS_LAYOUT_RETURN); 361 rpc_wake_up(&NFS_SERVER(lo->plh_inode)->roc_rpcwaitq); 362 } 363 364 static void 365 pnfs_clear_lseg_state(struct pnfs_layout_segment *lseg, 366 struct list_head *free_me) 367 { 368 clear_bit(NFS_LSEG_ROC, &lseg->pls_flags); 369 clear_bit(NFS_LSEG_LAYOUTRETURN, &lseg->pls_flags); 370 if (test_and_clear_bit(NFS_LSEG_VALID, &lseg->pls_flags)) 371 pnfs_lseg_dec_and_remove_zero(lseg, free_me); 372 if (test_and_clear_bit(NFS_LSEG_LAYOUTCOMMIT, &lseg->pls_flags)) 373 pnfs_lseg_dec_and_remove_zero(lseg, free_me); 374 } 375 376 /* 377 * Update the seqid of a layout stateid after receiving 378 * NFS4ERR_OLD_STATEID 379 */ 380 bool nfs4_layout_refresh_old_stateid(nfs4_stateid *dst, 381 struct pnfs_layout_range *dst_range, 382 struct inode *inode) 383 { 384 struct pnfs_layout_hdr *lo; 385 struct pnfs_layout_range range = { 386 .iomode = IOMODE_ANY, 387 .offset = 0, 388 .length = NFS4_MAX_UINT64, 389 }; 390 bool ret = false; 391 LIST_HEAD(head); 392 int err; 393 394 spin_lock(&inode->i_lock); 395 lo = NFS_I(inode)->layout; 396 if (lo && pnfs_layout_is_valid(lo) && 397 nfs4_stateid_match_other(dst, &lo->plh_stateid)) { 398 /* Is our call using the most recent seqid? If so, bump it */ 399 if (!nfs4_stateid_is_newer(&lo->plh_stateid, dst)) { 400 nfs4_stateid_seqid_inc(dst); 401 ret = true; 402 goto out; 403 } 404 /* Try to update the seqid to the most recent */ 405 err = pnfs_mark_matching_lsegs_return(lo, &head, &range, 0); 406 if (err != -EBUSY) { 407 dst->seqid = lo->plh_stateid.seqid; 408 *dst_range = range; 409 ret = true; 410 } 411 } 412 out: 413 spin_unlock(&inode->i_lock); 414 pnfs_free_lseg_list(&head); 415 return ret; 416 } 417 418 /* 419 * Mark a pnfs_layout_hdr and all associated layout segments as invalid 420 * 421 * In order to continue using the pnfs_layout_hdr, a full recovery 422 * is required. 423 * Note that caller must hold inode->i_lock. 424 */ 425 int 426 pnfs_mark_layout_stateid_invalid(struct pnfs_layout_hdr *lo, 427 struct list_head *lseg_list) 428 { 429 struct pnfs_layout_range range = { 430 .iomode = IOMODE_ANY, 431 .offset = 0, 432 .length = NFS4_MAX_UINT64, 433 }; 434 struct pnfs_layout_segment *lseg, *next; 435 436 set_bit(NFS_LAYOUT_INVALID_STID, &lo->plh_flags); 437 list_for_each_entry_safe(lseg, next, &lo->plh_segs, pls_list) 438 pnfs_clear_lseg_state(lseg, lseg_list); 439 pnfs_clear_layoutreturn_info(lo); 440 pnfs_free_returned_lsegs(lo, lseg_list, &range, 0); 441 if (test_bit(NFS_LAYOUT_RETURN, &lo->plh_flags) && 442 !test_and_set_bit(NFS_LAYOUT_RETURN_LOCK, &lo->plh_flags)) 443 pnfs_clear_layoutreturn_waitbit(lo); 444 return !list_empty(&lo->plh_segs); 445 } 446 447 static int 448 pnfs_iomode_to_fail_bit(u32 iomode) 449 { 450 return iomode == IOMODE_RW ? 451 NFS_LAYOUT_RW_FAILED : NFS_LAYOUT_RO_FAILED; 452 } 453 454 static void 455 pnfs_layout_set_fail_bit(struct pnfs_layout_hdr *lo, int fail_bit) 456 { 457 lo->plh_retry_timestamp = jiffies; 458 if (!test_and_set_bit(fail_bit, &lo->plh_flags)) 459 refcount_inc(&lo->plh_refcount); 460 } 461 462 static void 463 pnfs_layout_clear_fail_bit(struct pnfs_layout_hdr *lo, int fail_bit) 464 { 465 if (test_and_clear_bit(fail_bit, &lo->plh_flags)) 466 refcount_dec(&lo->plh_refcount); 467 } 468 469 static void 470 pnfs_layout_io_set_failed(struct pnfs_layout_hdr *lo, u32 iomode) 471 { 472 struct inode *inode = lo->plh_inode; 473 struct pnfs_layout_range range = { 474 .iomode = iomode, 475 .offset = 0, 476 .length = NFS4_MAX_UINT64, 477 }; 478 LIST_HEAD(head); 479 480 spin_lock(&inode->i_lock); 481 pnfs_layout_set_fail_bit(lo, pnfs_iomode_to_fail_bit(iomode)); 482 pnfs_mark_matching_lsegs_invalid(lo, &head, &range, 0); 483 spin_unlock(&inode->i_lock); 484 pnfs_free_lseg_list(&head); 485 dprintk("%s Setting layout IOMODE_%s fail bit\n", __func__, 486 iomode == IOMODE_RW ? "RW" : "READ"); 487 } 488 489 static bool 490 pnfs_layout_io_test_failed(struct pnfs_layout_hdr *lo, u32 iomode) 491 { 492 unsigned long start, end; 493 int fail_bit = pnfs_iomode_to_fail_bit(iomode); 494 495 if (test_bit(fail_bit, &lo->plh_flags) == 0) 496 return false; 497 end = jiffies; 498 start = end - PNFS_LAYOUTGET_RETRY_TIMEOUT; 499 if (!time_in_range(lo->plh_retry_timestamp, start, end)) { 500 /* It is time to retry the failed layoutgets */ 501 pnfs_layout_clear_fail_bit(lo, fail_bit); 502 return false; 503 } 504 return true; 505 } 506 507 static void 508 pnfs_init_lseg(struct pnfs_layout_hdr *lo, struct pnfs_layout_segment *lseg, 509 const struct pnfs_layout_range *range, 510 const nfs4_stateid *stateid) 511 { 512 INIT_LIST_HEAD(&lseg->pls_list); 513 INIT_LIST_HEAD(&lseg->pls_lc_list); 514 INIT_LIST_HEAD(&lseg->pls_commits); 515 refcount_set(&lseg->pls_refcount, 1); 516 set_bit(NFS_LSEG_VALID, &lseg->pls_flags); 517 lseg->pls_layout = lo; 518 lseg->pls_range = *range; 519 lseg->pls_seq = be32_to_cpu(stateid->seqid); 520 } 521 522 static void pnfs_free_lseg(struct pnfs_layout_segment *lseg) 523 { 524 if (lseg != NULL) { 525 struct inode *inode = lseg->pls_layout->plh_inode; 526 NFS_SERVER(inode)->pnfs_curr_ld->free_lseg(lseg); 527 } 528 } 529 530 static void 531 pnfs_layout_remove_lseg(struct pnfs_layout_hdr *lo, 532 struct pnfs_layout_segment *lseg) 533 { 534 WARN_ON(test_bit(NFS_LSEG_VALID, &lseg->pls_flags)); 535 list_del_init(&lseg->pls_list); 536 /* Matched by pnfs_get_layout_hdr in pnfs_layout_insert_lseg */ 537 refcount_dec(&lo->plh_refcount); 538 if (test_bit(NFS_LSEG_LAYOUTRETURN, &lseg->pls_flags)) 539 return; 540 if (list_empty(&lo->plh_segs) && 541 !test_bit(NFS_LAYOUT_RETURN_REQUESTED, &lo->plh_flags) && 542 !test_bit(NFS_LAYOUT_RETURN, &lo->plh_flags)) { 543 if (atomic_read(&lo->plh_outstanding) == 0) 544 set_bit(NFS_LAYOUT_INVALID_STID, &lo->plh_flags); 545 clear_bit(NFS_LAYOUT_BULK_RECALL, &lo->plh_flags); 546 } 547 } 548 549 static bool 550 pnfs_cache_lseg_for_layoutreturn(struct pnfs_layout_hdr *lo, 551 struct pnfs_layout_segment *lseg) 552 { 553 if (test_and_clear_bit(NFS_LSEG_LAYOUTRETURN, &lseg->pls_flags) && 554 pnfs_layout_is_valid(lo)) { 555 pnfs_set_plh_return_info(lo, lseg->pls_range.iomode, 0); 556 list_move_tail(&lseg->pls_list, &lo->plh_return_segs); 557 return true; 558 } 559 return false; 560 } 561 562 void 563 pnfs_put_lseg(struct pnfs_layout_segment *lseg) 564 { 565 struct pnfs_layout_hdr *lo; 566 struct inode *inode; 567 568 if (!lseg) 569 return; 570 571 dprintk("%s: lseg %p ref %d valid %d\n", __func__, lseg, 572 refcount_read(&lseg->pls_refcount), 573 test_bit(NFS_LSEG_VALID, &lseg->pls_flags)); 574 575 lo = lseg->pls_layout; 576 inode = lo->plh_inode; 577 578 if (refcount_dec_and_lock(&lseg->pls_refcount, &inode->i_lock)) { 579 if (test_bit(NFS_LSEG_VALID, &lseg->pls_flags)) { 580 spin_unlock(&inode->i_lock); 581 return; 582 } 583 pnfs_get_layout_hdr(lo); 584 pnfs_layout_remove_lseg(lo, lseg); 585 if (pnfs_cache_lseg_for_layoutreturn(lo, lseg)) 586 lseg = NULL; 587 spin_unlock(&inode->i_lock); 588 pnfs_free_lseg(lseg); 589 pnfs_put_layout_hdr(lo); 590 } 591 } 592 EXPORT_SYMBOL_GPL(pnfs_put_lseg); 593 594 /* 595 * is l2 fully contained in l1? 596 * start1 end1 597 * [----------------------------------) 598 * start2 end2 599 * [----------------) 600 */ 601 static bool 602 pnfs_lseg_range_contained(const struct pnfs_layout_range *l1, 603 const struct pnfs_layout_range *l2) 604 { 605 u64 start1 = l1->offset; 606 u64 end1 = pnfs_end_offset(start1, l1->length); 607 u64 start2 = l2->offset; 608 u64 end2 = pnfs_end_offset(start2, l2->length); 609 610 return (start1 <= start2) && (end1 >= end2); 611 } 612 613 static bool pnfs_lseg_dec_and_remove_zero(struct pnfs_layout_segment *lseg, 614 struct list_head *tmp_list) 615 { 616 if (!refcount_dec_and_test(&lseg->pls_refcount)) 617 return false; 618 pnfs_layout_remove_lseg(lseg->pls_layout, lseg); 619 list_add(&lseg->pls_list, tmp_list); 620 return true; 621 } 622 623 /* Returns 1 if lseg is removed from list, 0 otherwise */ 624 static int mark_lseg_invalid(struct pnfs_layout_segment *lseg, 625 struct list_head *tmp_list) 626 { 627 int rv = 0; 628 629 if (test_and_clear_bit(NFS_LSEG_VALID, &lseg->pls_flags)) { 630 /* Remove the reference keeping the lseg in the 631 * list. It will now be removed when all 632 * outstanding io is finished. 633 */ 634 dprintk("%s: lseg %p ref %d\n", __func__, lseg, 635 refcount_read(&lseg->pls_refcount)); 636 if (pnfs_lseg_dec_and_remove_zero(lseg, tmp_list)) 637 rv = 1; 638 } 639 return rv; 640 } 641 642 /* 643 * Compare 2 layout stateid sequence ids, to see which is newer, 644 * taking into account wraparound issues. 645 */ 646 static bool pnfs_seqid_is_newer(u32 s1, u32 s2) 647 { 648 return (s32)(s1 - s2) > 0; 649 } 650 651 static bool 652 pnfs_should_free_range(const struct pnfs_layout_range *lseg_range, 653 const struct pnfs_layout_range *recall_range) 654 { 655 return (recall_range->iomode == IOMODE_ANY || 656 lseg_range->iomode == recall_range->iomode) && 657 pnfs_lseg_range_intersecting(lseg_range, recall_range); 658 } 659 660 static bool 661 pnfs_match_lseg_recall(const struct pnfs_layout_segment *lseg, 662 const struct pnfs_layout_range *recall_range, 663 u32 seq) 664 { 665 if (seq != 0 && pnfs_seqid_is_newer(lseg->pls_seq, seq)) 666 return false; 667 if (recall_range == NULL) 668 return true; 669 return pnfs_should_free_range(&lseg->pls_range, recall_range); 670 } 671 672 /** 673 * pnfs_mark_matching_lsegs_invalid - tear down lsegs or mark them for later 674 * @lo: layout header containing the lsegs 675 * @tmp_list: list head where doomed lsegs should go 676 * @recall_range: optional recall range argument to match (may be NULL) 677 * @seq: only invalidate lsegs obtained prior to this sequence (may be 0) 678 * 679 * Walk the list of lsegs in the layout header, and tear down any that should 680 * be destroyed. If "recall_range" is specified then the segment must match 681 * that range. If "seq" is non-zero, then only match segments that were handed 682 * out at or before that sequence. 683 * 684 * Returns number of matching invalid lsegs remaining in list after scanning 685 * it and purging them. 686 */ 687 int 688 pnfs_mark_matching_lsegs_invalid(struct pnfs_layout_hdr *lo, 689 struct list_head *tmp_list, 690 const struct pnfs_layout_range *recall_range, 691 u32 seq) 692 { 693 struct pnfs_layout_segment *lseg, *next; 694 int remaining = 0; 695 696 dprintk("%s:Begin lo %p\n", __func__, lo); 697 698 if (list_empty(&lo->plh_segs)) 699 return 0; 700 list_for_each_entry_safe(lseg, next, &lo->plh_segs, pls_list) 701 if (pnfs_match_lseg_recall(lseg, recall_range, seq)) { 702 dprintk("%s: freeing lseg %p iomode %d seq %u " 703 "offset %llu length %llu\n", __func__, 704 lseg, lseg->pls_range.iomode, lseg->pls_seq, 705 lseg->pls_range.offset, lseg->pls_range.length); 706 if (!mark_lseg_invalid(lseg, tmp_list)) 707 remaining++; 708 } 709 dprintk("%s:Return %i\n", __func__, remaining); 710 return remaining; 711 } 712 713 static void 714 pnfs_free_returned_lsegs(struct pnfs_layout_hdr *lo, 715 struct list_head *free_me, 716 const struct pnfs_layout_range *range, 717 u32 seq) 718 { 719 struct pnfs_layout_segment *lseg, *next; 720 721 list_for_each_entry_safe(lseg, next, &lo->plh_return_segs, pls_list) { 722 if (pnfs_match_lseg_recall(lseg, range, seq)) 723 list_move_tail(&lseg->pls_list, free_me); 724 } 725 } 726 727 /* note free_me must contain lsegs from a single layout_hdr */ 728 void 729 pnfs_free_lseg_list(struct list_head *free_me) 730 { 731 struct pnfs_layout_segment *lseg, *tmp; 732 733 if (list_empty(free_me)) 734 return; 735 736 list_for_each_entry_safe(lseg, tmp, free_me, pls_list) { 737 list_del(&lseg->pls_list); 738 pnfs_free_lseg(lseg); 739 } 740 } 741 742 static struct pnfs_layout_hdr *__pnfs_destroy_layout(struct nfs_inode *nfsi) 743 { 744 struct pnfs_layout_hdr *lo; 745 LIST_HEAD(tmp_list); 746 747 spin_lock(&nfsi->vfs_inode.i_lock); 748 lo = nfsi->layout; 749 if (lo) { 750 pnfs_get_layout_hdr(lo); 751 pnfs_mark_layout_stateid_invalid(lo, &tmp_list); 752 pnfs_layout_clear_fail_bit(lo, NFS_LAYOUT_RO_FAILED); 753 pnfs_layout_clear_fail_bit(lo, NFS_LAYOUT_RW_FAILED); 754 spin_unlock(&nfsi->vfs_inode.i_lock); 755 pnfs_free_lseg_list(&tmp_list); 756 nfs_commit_inode(&nfsi->vfs_inode, 0); 757 pnfs_put_layout_hdr(lo); 758 } else 759 spin_unlock(&nfsi->vfs_inode.i_lock); 760 return lo; 761 } 762 763 void pnfs_destroy_layout(struct nfs_inode *nfsi) 764 { 765 __pnfs_destroy_layout(nfsi); 766 } 767 EXPORT_SYMBOL_GPL(pnfs_destroy_layout); 768 769 static bool pnfs_layout_removed(struct nfs_inode *nfsi, 770 struct pnfs_layout_hdr *lo) 771 { 772 bool ret; 773 774 spin_lock(&nfsi->vfs_inode.i_lock); 775 ret = nfsi->layout != lo; 776 spin_unlock(&nfsi->vfs_inode.i_lock); 777 return ret; 778 } 779 780 void pnfs_destroy_layout_final(struct nfs_inode *nfsi) 781 { 782 struct pnfs_layout_hdr *lo = __pnfs_destroy_layout(nfsi); 783 784 if (lo) 785 wait_var_event(lo, pnfs_layout_removed(nfsi, lo)); 786 } 787 788 static bool 789 pnfs_layout_add_bulk_destroy_list(struct inode *inode, 790 struct list_head *layout_list) 791 { 792 struct pnfs_layout_hdr *lo; 793 bool ret = false; 794 795 spin_lock(&inode->i_lock); 796 lo = NFS_I(inode)->layout; 797 if (lo != NULL && list_empty(&lo->plh_bulk_destroy)) { 798 pnfs_get_layout_hdr(lo); 799 list_add(&lo->plh_bulk_destroy, layout_list); 800 ret = true; 801 } 802 spin_unlock(&inode->i_lock); 803 return ret; 804 } 805 806 /* Caller must hold rcu_read_lock and clp->cl_lock */ 807 static int 808 pnfs_layout_bulk_destroy_byserver_locked(struct nfs_client *clp, 809 struct nfs_server *server, 810 struct list_head *layout_list) 811 __must_hold(&clp->cl_lock) 812 __must_hold(RCU) 813 { 814 struct pnfs_layout_hdr *lo, *next; 815 struct inode *inode; 816 817 list_for_each_entry_safe(lo, next, &server->layouts, plh_layouts) { 818 if (test_bit(NFS_LAYOUT_INVALID_STID, &lo->plh_flags) || 819 test_bit(NFS_LAYOUT_INODE_FREEING, &lo->plh_flags) || 820 !list_empty(&lo->plh_bulk_destroy)) 821 continue; 822 /* If the sb is being destroyed, just bail */ 823 if (!nfs_sb_active(server->super)) 824 break; 825 inode = pnfs_grab_inode_layout_hdr(lo); 826 if (inode != NULL) { 827 if (test_and_clear_bit(NFS_LAYOUT_HASHED, &lo->plh_flags)) 828 list_del_rcu(&lo->plh_layouts); 829 if (pnfs_layout_add_bulk_destroy_list(inode, 830 layout_list)) 831 continue; 832 rcu_read_unlock(); 833 spin_unlock(&clp->cl_lock); 834 iput(inode); 835 } else { 836 rcu_read_unlock(); 837 spin_unlock(&clp->cl_lock); 838 } 839 nfs_sb_deactive(server->super); 840 spin_lock(&clp->cl_lock); 841 rcu_read_lock(); 842 return -EAGAIN; 843 } 844 return 0; 845 } 846 847 static int 848 pnfs_layout_free_bulk_destroy_list(struct list_head *layout_list, 849 bool is_bulk_recall) 850 { 851 struct pnfs_layout_hdr *lo; 852 struct inode *inode; 853 LIST_HEAD(lseg_list); 854 int ret = 0; 855 856 while (!list_empty(layout_list)) { 857 lo = list_entry(layout_list->next, struct pnfs_layout_hdr, 858 plh_bulk_destroy); 859 dprintk("%s freeing layout for inode %lu\n", __func__, 860 lo->plh_inode->i_ino); 861 inode = lo->plh_inode; 862 863 pnfs_layoutcommit_inode(inode, false); 864 865 spin_lock(&inode->i_lock); 866 list_del_init(&lo->plh_bulk_destroy); 867 if (pnfs_mark_layout_stateid_invalid(lo, &lseg_list)) { 868 if (is_bulk_recall) 869 set_bit(NFS_LAYOUT_BULK_RECALL, &lo->plh_flags); 870 ret = -EAGAIN; 871 } 872 spin_unlock(&inode->i_lock); 873 pnfs_free_lseg_list(&lseg_list); 874 /* Free all lsegs that are attached to commit buckets */ 875 nfs_commit_inode(inode, 0); 876 pnfs_put_layout_hdr(lo); 877 nfs_iput_and_deactive(inode); 878 } 879 return ret; 880 } 881 882 int 883 pnfs_destroy_layouts_byfsid(struct nfs_client *clp, 884 struct nfs_fsid *fsid, 885 bool is_recall) 886 { 887 struct nfs_server *server; 888 LIST_HEAD(layout_list); 889 890 spin_lock(&clp->cl_lock); 891 rcu_read_lock(); 892 restart: 893 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { 894 if (memcmp(&server->fsid, fsid, sizeof(*fsid)) != 0) 895 continue; 896 if (pnfs_layout_bulk_destroy_byserver_locked(clp, 897 server, 898 &layout_list) != 0) 899 goto restart; 900 } 901 rcu_read_unlock(); 902 spin_unlock(&clp->cl_lock); 903 904 if (list_empty(&layout_list)) 905 return 0; 906 return pnfs_layout_free_bulk_destroy_list(&layout_list, is_recall); 907 } 908 909 int 910 pnfs_destroy_layouts_byclid(struct nfs_client *clp, 911 bool is_recall) 912 { 913 struct nfs_server *server; 914 LIST_HEAD(layout_list); 915 916 spin_lock(&clp->cl_lock); 917 rcu_read_lock(); 918 restart: 919 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { 920 if (pnfs_layout_bulk_destroy_byserver_locked(clp, 921 server, 922 &layout_list) != 0) 923 goto restart; 924 } 925 rcu_read_unlock(); 926 spin_unlock(&clp->cl_lock); 927 928 if (list_empty(&layout_list)) 929 return 0; 930 return pnfs_layout_free_bulk_destroy_list(&layout_list, is_recall); 931 } 932 933 /* 934 * Called by the state manager to remove all layouts established under an 935 * expired lease. 936 */ 937 void 938 pnfs_destroy_all_layouts(struct nfs_client *clp) 939 { 940 nfs4_deviceid_mark_client_invalid(clp); 941 nfs4_deviceid_purge_client(clp); 942 943 pnfs_destroy_layouts_byclid(clp, false); 944 } 945 946 static void 947 pnfs_set_layout_cred(struct pnfs_layout_hdr *lo, const struct cred *cred) 948 { 949 const struct cred *old; 950 951 if (cred && cred_fscmp(lo->plh_lc_cred, cred) != 0) { 952 old = xchg(&lo->plh_lc_cred, get_cred(cred)); 953 put_cred(old); 954 } 955 } 956 957 /* update lo->plh_stateid with new if is more recent */ 958 void 959 pnfs_set_layout_stateid(struct pnfs_layout_hdr *lo, const nfs4_stateid *new, 960 const struct cred *cred, bool update_barrier) 961 { 962 u32 oldseq, newseq, new_barrier = 0; 963 964 oldseq = be32_to_cpu(lo->plh_stateid.seqid); 965 newseq = be32_to_cpu(new->seqid); 966 967 if (!pnfs_layout_is_valid(lo)) { 968 pnfs_set_layout_cred(lo, cred); 969 nfs4_stateid_copy(&lo->plh_stateid, new); 970 lo->plh_barrier = newseq; 971 pnfs_clear_layoutreturn_info(lo); 972 clear_bit(NFS_LAYOUT_INVALID_STID, &lo->plh_flags); 973 return; 974 } 975 if (pnfs_seqid_is_newer(newseq, oldseq)) { 976 nfs4_stateid_copy(&lo->plh_stateid, new); 977 /* 978 * Because of wraparound, we want to keep the barrier 979 * "close" to the current seqids. 980 */ 981 new_barrier = newseq - atomic_read(&lo->plh_outstanding); 982 } 983 if (update_barrier) 984 new_barrier = be32_to_cpu(new->seqid); 985 else if (new_barrier == 0) 986 return; 987 if (pnfs_seqid_is_newer(new_barrier, lo->plh_barrier)) 988 lo->plh_barrier = new_barrier; 989 } 990 991 static bool 992 pnfs_layout_stateid_blocked(const struct pnfs_layout_hdr *lo, 993 const nfs4_stateid *stateid) 994 { 995 u32 seqid = be32_to_cpu(stateid->seqid); 996 997 return !pnfs_seqid_is_newer(seqid, lo->plh_barrier); 998 } 999 1000 /* lget is set to 1 if called from inside send_layoutget call chain */ 1001 static bool 1002 pnfs_layoutgets_blocked(const struct pnfs_layout_hdr *lo) 1003 { 1004 return lo->plh_block_lgets || 1005 test_bit(NFS_LAYOUT_BULK_RECALL, &lo->plh_flags); 1006 } 1007 1008 static struct nfs_server * 1009 pnfs_find_server(struct inode *inode, struct nfs_open_context *ctx) 1010 { 1011 struct nfs_server *server; 1012 1013 if (inode) { 1014 server = NFS_SERVER(inode); 1015 } else { 1016 struct dentry *parent_dir = dget_parent(ctx->dentry); 1017 server = NFS_SERVER(parent_dir->d_inode); 1018 dput(parent_dir); 1019 } 1020 return server; 1021 } 1022 1023 static void nfs4_free_pages(struct page **pages, size_t size) 1024 { 1025 int i; 1026 1027 if (!pages) 1028 return; 1029 1030 for (i = 0; i < size; i++) { 1031 if (!pages[i]) 1032 break; 1033 __free_page(pages[i]); 1034 } 1035 kfree(pages); 1036 } 1037 1038 static struct page **nfs4_alloc_pages(size_t size, gfp_t gfp_flags) 1039 { 1040 struct page **pages; 1041 int i; 1042 1043 pages = kmalloc_array(size, sizeof(struct page *), gfp_flags); 1044 if (!pages) { 1045 dprintk("%s: can't alloc array of %zu pages\n", __func__, size); 1046 return NULL; 1047 } 1048 1049 for (i = 0; i < size; i++) { 1050 pages[i] = alloc_page(gfp_flags); 1051 if (!pages[i]) { 1052 dprintk("%s: failed to allocate page\n", __func__); 1053 nfs4_free_pages(pages, i); 1054 return NULL; 1055 } 1056 } 1057 1058 return pages; 1059 } 1060 1061 static struct nfs4_layoutget * 1062 pnfs_alloc_init_layoutget_args(struct inode *ino, 1063 struct nfs_open_context *ctx, 1064 const nfs4_stateid *stateid, 1065 const struct pnfs_layout_range *range, 1066 gfp_t gfp_flags) 1067 { 1068 struct nfs_server *server = pnfs_find_server(ino, ctx); 1069 size_t max_reply_sz = server->pnfs_curr_ld->max_layoutget_response; 1070 size_t max_pages = max_response_pages(server); 1071 struct nfs4_layoutget *lgp; 1072 1073 dprintk("--> %s\n", __func__); 1074 1075 lgp = kzalloc(sizeof(*lgp), gfp_flags); 1076 if (lgp == NULL) 1077 return NULL; 1078 1079 if (max_reply_sz) { 1080 size_t npages = (max_reply_sz + PAGE_SIZE - 1) >> PAGE_SHIFT; 1081 if (npages < max_pages) 1082 max_pages = npages; 1083 } 1084 1085 lgp->args.layout.pages = nfs4_alloc_pages(max_pages, gfp_flags); 1086 if (!lgp->args.layout.pages) { 1087 kfree(lgp); 1088 return NULL; 1089 } 1090 lgp->args.layout.pglen = max_pages * PAGE_SIZE; 1091 lgp->res.layoutp = &lgp->args.layout; 1092 1093 /* Don't confuse uninitialised result and success */ 1094 lgp->res.status = -NFS4ERR_DELAY; 1095 1096 lgp->args.minlength = PAGE_SIZE; 1097 if (lgp->args.minlength > range->length) 1098 lgp->args.minlength = range->length; 1099 if (ino) { 1100 loff_t i_size = i_size_read(ino); 1101 1102 if (range->iomode == IOMODE_READ) { 1103 if (range->offset >= i_size) 1104 lgp->args.minlength = 0; 1105 else if (i_size - range->offset < lgp->args.minlength) 1106 lgp->args.minlength = i_size - range->offset; 1107 } 1108 } 1109 lgp->args.maxcount = PNFS_LAYOUT_MAXSIZE; 1110 pnfs_copy_range(&lgp->args.range, range); 1111 lgp->args.type = server->pnfs_curr_ld->id; 1112 lgp->args.inode = ino; 1113 lgp->args.ctx = get_nfs_open_context(ctx); 1114 nfs4_stateid_copy(&lgp->args.stateid, stateid); 1115 lgp->gfp_flags = gfp_flags; 1116 lgp->cred = ctx->cred; 1117 return lgp; 1118 } 1119 1120 void pnfs_layoutget_free(struct nfs4_layoutget *lgp) 1121 { 1122 size_t max_pages = lgp->args.layout.pglen / PAGE_SIZE; 1123 1124 nfs4_free_pages(lgp->args.layout.pages, max_pages); 1125 if (lgp->args.inode) 1126 pnfs_put_layout_hdr(NFS_I(lgp->args.inode)->layout); 1127 put_nfs_open_context(lgp->args.ctx); 1128 kfree(lgp); 1129 } 1130 1131 static void pnfs_clear_layoutcommit(struct inode *inode, 1132 struct list_head *head) 1133 { 1134 struct nfs_inode *nfsi = NFS_I(inode); 1135 struct pnfs_layout_segment *lseg, *tmp; 1136 1137 if (!test_and_clear_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags)) 1138 return; 1139 list_for_each_entry_safe(lseg, tmp, &nfsi->layout->plh_segs, pls_list) { 1140 if (!test_and_clear_bit(NFS_LSEG_LAYOUTCOMMIT, &lseg->pls_flags)) 1141 continue; 1142 pnfs_lseg_dec_and_remove_zero(lseg, head); 1143 } 1144 } 1145 1146 void pnfs_layoutreturn_free_lsegs(struct pnfs_layout_hdr *lo, 1147 const nfs4_stateid *arg_stateid, 1148 const struct pnfs_layout_range *range, 1149 const nfs4_stateid *stateid) 1150 { 1151 struct inode *inode = lo->plh_inode; 1152 LIST_HEAD(freeme); 1153 1154 spin_lock(&inode->i_lock); 1155 if (!pnfs_layout_is_valid(lo) || 1156 !nfs4_stateid_match_other(&lo->plh_stateid, arg_stateid)) 1157 goto out_unlock; 1158 if (stateid) { 1159 u32 seq = be32_to_cpu(arg_stateid->seqid); 1160 1161 pnfs_mark_matching_lsegs_invalid(lo, &freeme, range, seq); 1162 pnfs_free_returned_lsegs(lo, &freeme, range, seq); 1163 pnfs_set_layout_stateid(lo, stateid, NULL, true); 1164 } else 1165 pnfs_mark_layout_stateid_invalid(lo, &freeme); 1166 out_unlock: 1167 pnfs_clear_layoutreturn_waitbit(lo); 1168 spin_unlock(&inode->i_lock); 1169 pnfs_free_lseg_list(&freeme); 1170 1171 } 1172 1173 static bool 1174 pnfs_prepare_layoutreturn(struct pnfs_layout_hdr *lo, 1175 nfs4_stateid *stateid, 1176 const struct cred **cred, 1177 enum pnfs_iomode *iomode) 1178 { 1179 /* Serialise LAYOUTGET/LAYOUTRETURN */ 1180 if (atomic_read(&lo->plh_outstanding) != 0) 1181 return false; 1182 if (test_and_set_bit(NFS_LAYOUT_RETURN_LOCK, &lo->plh_flags)) 1183 return false; 1184 set_bit(NFS_LAYOUT_RETURN, &lo->plh_flags); 1185 pnfs_get_layout_hdr(lo); 1186 if (test_bit(NFS_LAYOUT_RETURN_REQUESTED, &lo->plh_flags)) { 1187 nfs4_stateid_copy(stateid, &lo->plh_stateid); 1188 *cred = get_cred(lo->plh_lc_cred); 1189 if (lo->plh_return_seq != 0) 1190 stateid->seqid = cpu_to_be32(lo->plh_return_seq); 1191 if (iomode != NULL) 1192 *iomode = lo->plh_return_iomode; 1193 pnfs_clear_layoutreturn_info(lo); 1194 return true; 1195 } 1196 nfs4_stateid_copy(stateid, &lo->plh_stateid); 1197 *cred = get_cred(lo->plh_lc_cred); 1198 if (iomode != NULL) 1199 *iomode = IOMODE_ANY; 1200 return true; 1201 } 1202 1203 static void 1204 pnfs_init_layoutreturn_args(struct nfs4_layoutreturn_args *args, 1205 struct pnfs_layout_hdr *lo, 1206 const nfs4_stateid *stateid, 1207 enum pnfs_iomode iomode) 1208 { 1209 struct inode *inode = lo->plh_inode; 1210 1211 args->layout_type = NFS_SERVER(inode)->pnfs_curr_ld->id; 1212 args->inode = inode; 1213 args->range.iomode = iomode; 1214 args->range.offset = 0; 1215 args->range.length = NFS4_MAX_UINT64; 1216 args->layout = lo; 1217 nfs4_stateid_copy(&args->stateid, stateid); 1218 } 1219 1220 static int 1221 pnfs_send_layoutreturn(struct pnfs_layout_hdr *lo, 1222 const nfs4_stateid *stateid, 1223 const struct cred **pcred, 1224 enum pnfs_iomode iomode, 1225 bool sync) 1226 { 1227 struct inode *ino = lo->plh_inode; 1228 struct pnfs_layoutdriver_type *ld = NFS_SERVER(ino)->pnfs_curr_ld; 1229 struct nfs4_layoutreturn *lrp; 1230 const struct cred *cred = *pcred; 1231 int status = 0; 1232 1233 *pcred = NULL; 1234 lrp = kzalloc(sizeof(*lrp), GFP_NOFS); 1235 if (unlikely(lrp == NULL)) { 1236 status = -ENOMEM; 1237 spin_lock(&ino->i_lock); 1238 pnfs_clear_layoutreturn_waitbit(lo); 1239 spin_unlock(&ino->i_lock); 1240 put_cred(cred); 1241 pnfs_put_layout_hdr(lo); 1242 goto out; 1243 } 1244 1245 pnfs_init_layoutreturn_args(&lrp->args, lo, stateid, iomode); 1246 lrp->args.ld_private = &lrp->ld_private; 1247 lrp->clp = NFS_SERVER(ino)->nfs_client; 1248 lrp->cred = cred; 1249 if (ld->prepare_layoutreturn) 1250 ld->prepare_layoutreturn(&lrp->args); 1251 1252 status = nfs4_proc_layoutreturn(lrp, sync); 1253 out: 1254 dprintk("<-- %s status: %d\n", __func__, status); 1255 return status; 1256 } 1257 1258 static bool 1259 pnfs_layout_segments_returnable(struct pnfs_layout_hdr *lo, 1260 enum pnfs_iomode iomode, 1261 u32 seq) 1262 { 1263 struct pnfs_layout_range recall_range = { 1264 .length = NFS4_MAX_UINT64, 1265 .iomode = iomode, 1266 }; 1267 return pnfs_mark_matching_lsegs_return(lo, &lo->plh_return_segs, 1268 &recall_range, seq) != -EBUSY; 1269 } 1270 1271 /* Return true if layoutreturn is needed */ 1272 static bool 1273 pnfs_layout_need_return(struct pnfs_layout_hdr *lo) 1274 { 1275 if (!test_bit(NFS_LAYOUT_RETURN_REQUESTED, &lo->plh_flags)) 1276 return false; 1277 return pnfs_layout_segments_returnable(lo, lo->plh_return_iomode, 1278 lo->plh_return_seq); 1279 } 1280 1281 static void pnfs_layoutreturn_before_put_layout_hdr(struct pnfs_layout_hdr *lo) 1282 { 1283 struct inode *inode= lo->plh_inode; 1284 1285 if (!test_bit(NFS_LAYOUT_RETURN_REQUESTED, &lo->plh_flags)) 1286 return; 1287 spin_lock(&inode->i_lock); 1288 if (pnfs_layout_need_return(lo)) { 1289 const struct cred *cred; 1290 nfs4_stateid stateid; 1291 enum pnfs_iomode iomode; 1292 bool send; 1293 1294 send = pnfs_prepare_layoutreturn(lo, &stateid, &cred, &iomode); 1295 spin_unlock(&inode->i_lock); 1296 if (send) { 1297 /* Send an async layoutreturn so we dont deadlock */ 1298 pnfs_send_layoutreturn(lo, &stateid, &cred, iomode, false); 1299 } 1300 } else 1301 spin_unlock(&inode->i_lock); 1302 } 1303 1304 /* 1305 * Initiates a LAYOUTRETURN(FILE), and removes the pnfs_layout_hdr 1306 * when the layout segment list is empty. 1307 * 1308 * Note that a pnfs_layout_hdr can exist with an empty layout segment 1309 * list when LAYOUTGET has failed, or when LAYOUTGET succeeded, but the 1310 * deviceid is marked invalid. 1311 */ 1312 int 1313 _pnfs_return_layout(struct inode *ino) 1314 { 1315 struct pnfs_layout_hdr *lo = NULL; 1316 struct nfs_inode *nfsi = NFS_I(ino); 1317 LIST_HEAD(tmp_list); 1318 const struct cred *cred; 1319 nfs4_stateid stateid; 1320 int status = 0; 1321 bool send, valid_layout; 1322 1323 dprintk("NFS: %s for inode %lu\n", __func__, ino->i_ino); 1324 1325 spin_lock(&ino->i_lock); 1326 lo = nfsi->layout; 1327 if (!lo) { 1328 spin_unlock(&ino->i_lock); 1329 dprintk("NFS: %s no layout to return\n", __func__); 1330 goto out; 1331 } 1332 /* Reference matched in nfs4_layoutreturn_release */ 1333 pnfs_get_layout_hdr(lo); 1334 /* Is there an outstanding layoutreturn ? */ 1335 if (test_bit(NFS_LAYOUT_RETURN_LOCK, &lo->plh_flags)) { 1336 spin_unlock(&ino->i_lock); 1337 if (wait_on_bit(&lo->plh_flags, NFS_LAYOUT_RETURN, 1338 TASK_UNINTERRUPTIBLE)) 1339 goto out_put_layout_hdr; 1340 spin_lock(&ino->i_lock); 1341 } 1342 valid_layout = pnfs_layout_is_valid(lo); 1343 pnfs_clear_layoutcommit(ino, &tmp_list); 1344 pnfs_mark_matching_lsegs_invalid(lo, &tmp_list, NULL, 0); 1345 1346 if (NFS_SERVER(ino)->pnfs_curr_ld->return_range) { 1347 struct pnfs_layout_range range = { 1348 .iomode = IOMODE_ANY, 1349 .offset = 0, 1350 .length = NFS4_MAX_UINT64, 1351 }; 1352 NFS_SERVER(ino)->pnfs_curr_ld->return_range(lo, &range); 1353 } 1354 1355 /* Don't send a LAYOUTRETURN if list was initially empty */ 1356 if (!test_bit(NFS_LAYOUT_RETURN_REQUESTED, &lo->plh_flags) || 1357 !valid_layout) { 1358 spin_unlock(&ino->i_lock); 1359 dprintk("NFS: %s no layout segments to return\n", __func__); 1360 goto out_wait_layoutreturn; 1361 } 1362 1363 send = pnfs_prepare_layoutreturn(lo, &stateid, &cred, NULL); 1364 spin_unlock(&ino->i_lock); 1365 if (send) 1366 status = pnfs_send_layoutreturn(lo, &stateid, &cred, IOMODE_ANY, true); 1367 out_wait_layoutreturn: 1368 wait_on_bit(&lo->plh_flags, NFS_LAYOUT_RETURN, TASK_UNINTERRUPTIBLE); 1369 out_put_layout_hdr: 1370 pnfs_free_lseg_list(&tmp_list); 1371 pnfs_put_layout_hdr(lo); 1372 out: 1373 dprintk("<-- %s status: %d\n", __func__, status); 1374 return status; 1375 } 1376 1377 int 1378 pnfs_commit_and_return_layout(struct inode *inode) 1379 { 1380 struct pnfs_layout_hdr *lo; 1381 int ret; 1382 1383 spin_lock(&inode->i_lock); 1384 lo = NFS_I(inode)->layout; 1385 if (lo == NULL) { 1386 spin_unlock(&inode->i_lock); 1387 return 0; 1388 } 1389 pnfs_get_layout_hdr(lo); 1390 /* Block new layoutgets and read/write to ds */ 1391 lo->plh_block_lgets++; 1392 spin_unlock(&inode->i_lock); 1393 filemap_fdatawait(inode->i_mapping); 1394 ret = pnfs_layoutcommit_inode(inode, true); 1395 if (ret == 0) 1396 ret = _pnfs_return_layout(inode); 1397 spin_lock(&inode->i_lock); 1398 lo->plh_block_lgets--; 1399 spin_unlock(&inode->i_lock); 1400 pnfs_put_layout_hdr(lo); 1401 return ret; 1402 } 1403 1404 bool pnfs_roc(struct inode *ino, 1405 struct nfs4_layoutreturn_args *args, 1406 struct nfs4_layoutreturn_res *res, 1407 const struct cred *cred) 1408 { 1409 struct nfs_inode *nfsi = NFS_I(ino); 1410 struct nfs_open_context *ctx; 1411 struct nfs4_state *state; 1412 struct pnfs_layout_hdr *lo; 1413 struct pnfs_layout_segment *lseg, *next; 1414 const struct cred *lc_cred; 1415 nfs4_stateid stateid; 1416 enum pnfs_iomode iomode = 0; 1417 bool layoutreturn = false, roc = false; 1418 bool skip_read = false; 1419 1420 if (!nfs_have_layout(ino)) 1421 return false; 1422 retry: 1423 rcu_read_lock(); 1424 spin_lock(&ino->i_lock); 1425 lo = nfsi->layout; 1426 if (!lo || !pnfs_layout_is_valid(lo) || 1427 test_bit(NFS_LAYOUT_BULK_RECALL, &lo->plh_flags)) { 1428 lo = NULL; 1429 goto out_noroc; 1430 } 1431 pnfs_get_layout_hdr(lo); 1432 if (test_bit(NFS_LAYOUT_RETURN_LOCK, &lo->plh_flags)) { 1433 spin_unlock(&ino->i_lock); 1434 rcu_read_unlock(); 1435 wait_on_bit(&lo->plh_flags, NFS_LAYOUT_RETURN, 1436 TASK_UNINTERRUPTIBLE); 1437 pnfs_put_layout_hdr(lo); 1438 goto retry; 1439 } 1440 1441 /* no roc if we hold a delegation */ 1442 if (nfs4_check_delegation(ino, FMODE_READ)) { 1443 if (nfs4_check_delegation(ino, FMODE_WRITE)) 1444 goto out_noroc; 1445 skip_read = true; 1446 } 1447 1448 list_for_each_entry_rcu(ctx, &nfsi->open_files, list) { 1449 state = ctx->state; 1450 if (state == NULL) 1451 continue; 1452 /* Don't return layout if there is open file state */ 1453 if (state->state & FMODE_WRITE) 1454 goto out_noroc; 1455 if (state->state & FMODE_READ) 1456 skip_read = true; 1457 } 1458 1459 1460 list_for_each_entry_safe(lseg, next, &lo->plh_segs, pls_list) { 1461 if (skip_read && lseg->pls_range.iomode == IOMODE_READ) 1462 continue; 1463 /* If we are sending layoutreturn, invalidate all valid lsegs */ 1464 if (!test_and_clear_bit(NFS_LSEG_ROC, &lseg->pls_flags)) 1465 continue; 1466 /* 1467 * Note: mark lseg for return so pnfs_layout_remove_lseg 1468 * doesn't invalidate the layout for us. 1469 */ 1470 set_bit(NFS_LSEG_LAYOUTRETURN, &lseg->pls_flags); 1471 if (!mark_lseg_invalid(lseg, &lo->plh_return_segs)) 1472 continue; 1473 pnfs_set_plh_return_info(lo, lseg->pls_range.iomode, 0); 1474 } 1475 1476 if (!test_bit(NFS_LAYOUT_RETURN_REQUESTED, &lo->plh_flags)) 1477 goto out_noroc; 1478 1479 /* ROC in two conditions: 1480 * 1. there are ROC lsegs 1481 * 2. we don't send layoutreturn 1482 */ 1483 /* lo ref dropped in pnfs_roc_release() */ 1484 layoutreturn = pnfs_prepare_layoutreturn(lo, &stateid, &lc_cred, &iomode); 1485 /* If the creds don't match, we can't compound the layoutreturn */ 1486 if (!layoutreturn || cred_fscmp(cred, lc_cred) != 0) 1487 goto out_noroc; 1488 1489 roc = layoutreturn; 1490 pnfs_init_layoutreturn_args(args, lo, &stateid, iomode); 1491 res->lrs_present = 0; 1492 layoutreturn = false; 1493 put_cred(lc_cred); 1494 1495 out_noroc: 1496 spin_unlock(&ino->i_lock); 1497 rcu_read_unlock(); 1498 pnfs_layoutcommit_inode(ino, true); 1499 if (roc) { 1500 struct pnfs_layoutdriver_type *ld = NFS_SERVER(ino)->pnfs_curr_ld; 1501 if (ld->prepare_layoutreturn) 1502 ld->prepare_layoutreturn(args); 1503 pnfs_put_layout_hdr(lo); 1504 return true; 1505 } 1506 if (layoutreturn) 1507 pnfs_send_layoutreturn(lo, &stateid, &lc_cred, iomode, true); 1508 pnfs_put_layout_hdr(lo); 1509 return false; 1510 } 1511 1512 int pnfs_roc_done(struct rpc_task *task, struct nfs4_layoutreturn_args **argpp, 1513 struct nfs4_layoutreturn_res **respp, int *ret) 1514 { 1515 struct nfs4_layoutreturn_args *arg = *argpp; 1516 int retval = -EAGAIN; 1517 1518 if (!arg) 1519 return 0; 1520 /* Handle Layoutreturn errors */ 1521 switch (*ret) { 1522 case 0: 1523 retval = 0; 1524 break; 1525 case -NFS4ERR_NOMATCHING_LAYOUT: 1526 /* Was there an RPC level error? If not, retry */ 1527 if (task->tk_rpc_status == 0) 1528 break; 1529 /* If the call was not sent, let caller handle it */ 1530 if (!RPC_WAS_SENT(task)) 1531 return 0; 1532 /* 1533 * Otherwise, assume the call succeeded and 1534 * that we need to release the layout 1535 */ 1536 *ret = 0; 1537 (*respp)->lrs_present = 0; 1538 retval = 0; 1539 break; 1540 case -NFS4ERR_DELAY: 1541 /* Let the caller handle the retry */ 1542 *ret = -NFS4ERR_NOMATCHING_LAYOUT; 1543 return 0; 1544 case -NFS4ERR_OLD_STATEID: 1545 if (!nfs4_layout_refresh_old_stateid(&arg->stateid, 1546 &arg->range, arg->inode)) 1547 break; 1548 *ret = -NFS4ERR_NOMATCHING_LAYOUT; 1549 return -EAGAIN; 1550 } 1551 *argpp = NULL; 1552 *respp = NULL; 1553 return retval; 1554 } 1555 1556 void pnfs_roc_release(struct nfs4_layoutreturn_args *args, 1557 struct nfs4_layoutreturn_res *res, 1558 int ret) 1559 { 1560 struct pnfs_layout_hdr *lo = args->layout; 1561 struct inode *inode = args->inode; 1562 const nfs4_stateid *res_stateid = NULL; 1563 struct nfs4_xdr_opaque_data *ld_private = args->ld_private; 1564 1565 switch (ret) { 1566 case -NFS4ERR_NOMATCHING_LAYOUT: 1567 spin_lock(&inode->i_lock); 1568 if (pnfs_layout_is_valid(lo) && 1569 nfs4_stateid_match_other(&args->stateid, &lo->plh_stateid)) 1570 pnfs_set_plh_return_info(lo, args->range.iomode, 0); 1571 pnfs_clear_layoutreturn_waitbit(lo); 1572 spin_unlock(&inode->i_lock); 1573 break; 1574 case 0: 1575 if (res->lrs_present) 1576 res_stateid = &res->stateid; 1577 fallthrough; 1578 default: 1579 pnfs_layoutreturn_free_lsegs(lo, &args->stateid, &args->range, 1580 res_stateid); 1581 } 1582 trace_nfs4_layoutreturn_on_close(args->inode, &args->stateid, ret); 1583 if (ld_private && ld_private->ops && ld_private->ops->free) 1584 ld_private->ops->free(ld_private); 1585 pnfs_put_layout_hdr(lo); 1586 } 1587 1588 bool pnfs_wait_on_layoutreturn(struct inode *ino, struct rpc_task *task) 1589 { 1590 struct nfs_inode *nfsi = NFS_I(ino); 1591 struct pnfs_layout_hdr *lo; 1592 bool sleep = false; 1593 1594 /* we might not have grabbed lo reference. so need to check under 1595 * i_lock */ 1596 spin_lock(&ino->i_lock); 1597 lo = nfsi->layout; 1598 if (lo && test_bit(NFS_LAYOUT_RETURN, &lo->plh_flags)) { 1599 rpc_sleep_on(&NFS_SERVER(ino)->roc_rpcwaitq, task, NULL); 1600 sleep = true; 1601 } 1602 spin_unlock(&ino->i_lock); 1603 return sleep; 1604 } 1605 1606 /* 1607 * Compare two layout segments for sorting into layout cache. 1608 * We want to preferentially return RW over RO layouts, so ensure those 1609 * are seen first. 1610 */ 1611 static s64 1612 pnfs_lseg_range_cmp(const struct pnfs_layout_range *l1, 1613 const struct pnfs_layout_range *l2) 1614 { 1615 s64 d; 1616 1617 /* high offset > low offset */ 1618 d = l1->offset - l2->offset; 1619 if (d) 1620 return d; 1621 1622 /* short length > long length */ 1623 d = l2->length - l1->length; 1624 if (d) 1625 return d; 1626 1627 /* read > read/write */ 1628 return (int)(l1->iomode == IOMODE_READ) - (int)(l2->iomode == IOMODE_READ); 1629 } 1630 1631 static bool 1632 pnfs_lseg_range_is_after(const struct pnfs_layout_range *l1, 1633 const struct pnfs_layout_range *l2) 1634 { 1635 return pnfs_lseg_range_cmp(l1, l2) > 0; 1636 } 1637 1638 static bool 1639 pnfs_lseg_no_merge(struct pnfs_layout_segment *lseg, 1640 struct pnfs_layout_segment *old) 1641 { 1642 return false; 1643 } 1644 1645 void 1646 pnfs_generic_layout_insert_lseg(struct pnfs_layout_hdr *lo, 1647 struct pnfs_layout_segment *lseg, 1648 bool (*is_after)(const struct pnfs_layout_range *, 1649 const struct pnfs_layout_range *), 1650 bool (*do_merge)(struct pnfs_layout_segment *, 1651 struct pnfs_layout_segment *), 1652 struct list_head *free_me) 1653 { 1654 struct pnfs_layout_segment *lp, *tmp; 1655 1656 dprintk("%s:Begin\n", __func__); 1657 1658 list_for_each_entry_safe(lp, tmp, &lo->plh_segs, pls_list) { 1659 if (test_bit(NFS_LSEG_VALID, &lp->pls_flags) == 0) 1660 continue; 1661 if (do_merge(lseg, lp)) { 1662 mark_lseg_invalid(lp, free_me); 1663 continue; 1664 } 1665 if (is_after(&lseg->pls_range, &lp->pls_range)) 1666 continue; 1667 list_add_tail(&lseg->pls_list, &lp->pls_list); 1668 dprintk("%s: inserted lseg %p " 1669 "iomode %d offset %llu length %llu before " 1670 "lp %p iomode %d offset %llu length %llu\n", 1671 __func__, lseg, lseg->pls_range.iomode, 1672 lseg->pls_range.offset, lseg->pls_range.length, 1673 lp, lp->pls_range.iomode, lp->pls_range.offset, 1674 lp->pls_range.length); 1675 goto out; 1676 } 1677 list_add_tail(&lseg->pls_list, &lo->plh_segs); 1678 dprintk("%s: inserted lseg %p " 1679 "iomode %d offset %llu length %llu at tail\n", 1680 __func__, lseg, lseg->pls_range.iomode, 1681 lseg->pls_range.offset, lseg->pls_range.length); 1682 out: 1683 pnfs_get_layout_hdr(lo); 1684 1685 dprintk("%s:Return\n", __func__); 1686 } 1687 EXPORT_SYMBOL_GPL(pnfs_generic_layout_insert_lseg); 1688 1689 static void 1690 pnfs_layout_insert_lseg(struct pnfs_layout_hdr *lo, 1691 struct pnfs_layout_segment *lseg, 1692 struct list_head *free_me) 1693 { 1694 struct inode *inode = lo->plh_inode; 1695 struct pnfs_layoutdriver_type *ld = NFS_SERVER(inode)->pnfs_curr_ld; 1696 1697 if (ld->add_lseg != NULL) 1698 ld->add_lseg(lo, lseg, free_me); 1699 else 1700 pnfs_generic_layout_insert_lseg(lo, lseg, 1701 pnfs_lseg_range_is_after, 1702 pnfs_lseg_no_merge, 1703 free_me); 1704 } 1705 1706 static struct pnfs_layout_hdr * 1707 alloc_init_layout_hdr(struct inode *ino, 1708 struct nfs_open_context *ctx, 1709 gfp_t gfp_flags) 1710 { 1711 struct pnfs_layout_hdr *lo; 1712 1713 lo = pnfs_alloc_layout_hdr(ino, gfp_flags); 1714 if (!lo) 1715 return NULL; 1716 refcount_set(&lo->plh_refcount, 1); 1717 INIT_LIST_HEAD(&lo->plh_layouts); 1718 INIT_LIST_HEAD(&lo->plh_segs); 1719 INIT_LIST_HEAD(&lo->plh_return_segs); 1720 INIT_LIST_HEAD(&lo->plh_bulk_destroy); 1721 lo->plh_inode = ino; 1722 lo->plh_lc_cred = get_cred(ctx->cred); 1723 lo->plh_flags |= 1 << NFS_LAYOUT_INVALID_STID; 1724 return lo; 1725 } 1726 1727 static struct pnfs_layout_hdr * 1728 pnfs_find_alloc_layout(struct inode *ino, 1729 struct nfs_open_context *ctx, 1730 gfp_t gfp_flags) 1731 __releases(&ino->i_lock) 1732 __acquires(&ino->i_lock) 1733 { 1734 struct nfs_inode *nfsi = NFS_I(ino); 1735 struct pnfs_layout_hdr *new = NULL; 1736 1737 dprintk("%s Begin ino=%p layout=%p\n", __func__, ino, nfsi->layout); 1738 1739 if (nfsi->layout != NULL) 1740 goto out_existing; 1741 spin_unlock(&ino->i_lock); 1742 new = alloc_init_layout_hdr(ino, ctx, gfp_flags); 1743 spin_lock(&ino->i_lock); 1744 1745 if (likely(nfsi->layout == NULL)) { /* Won the race? */ 1746 nfsi->layout = new; 1747 return new; 1748 } else if (new != NULL) 1749 pnfs_free_layout_hdr(new); 1750 out_existing: 1751 pnfs_get_layout_hdr(nfsi->layout); 1752 return nfsi->layout; 1753 } 1754 1755 /* 1756 * iomode matching rules: 1757 * iomode lseg strict match 1758 * iomode 1759 * ----- ----- ------ ----- 1760 * ANY READ N/A true 1761 * ANY RW N/A true 1762 * RW READ N/A false 1763 * RW RW N/A true 1764 * READ READ N/A true 1765 * READ RW true false 1766 * READ RW false true 1767 */ 1768 static bool 1769 pnfs_lseg_range_match(const struct pnfs_layout_range *ls_range, 1770 const struct pnfs_layout_range *range, 1771 bool strict_iomode) 1772 { 1773 struct pnfs_layout_range range1; 1774 1775 if ((range->iomode == IOMODE_RW && 1776 ls_range->iomode != IOMODE_RW) || 1777 (range->iomode != ls_range->iomode && 1778 strict_iomode) || 1779 !pnfs_lseg_range_intersecting(ls_range, range)) 1780 return false; 1781 1782 /* range1 covers only the first byte in the range */ 1783 range1 = *range; 1784 range1.length = 1; 1785 return pnfs_lseg_range_contained(ls_range, &range1); 1786 } 1787 1788 /* 1789 * lookup range in layout 1790 */ 1791 static struct pnfs_layout_segment * 1792 pnfs_find_lseg(struct pnfs_layout_hdr *lo, 1793 struct pnfs_layout_range *range, 1794 bool strict_iomode) 1795 { 1796 struct pnfs_layout_segment *lseg, *ret = NULL; 1797 1798 dprintk("%s:Begin\n", __func__); 1799 1800 list_for_each_entry(lseg, &lo->plh_segs, pls_list) { 1801 if (test_bit(NFS_LSEG_VALID, &lseg->pls_flags) && 1802 pnfs_lseg_range_match(&lseg->pls_range, range, 1803 strict_iomode)) { 1804 ret = pnfs_get_lseg(lseg); 1805 break; 1806 } 1807 } 1808 1809 dprintk("%s:Return lseg %p ref %d\n", 1810 __func__, ret, ret ? refcount_read(&ret->pls_refcount) : 0); 1811 return ret; 1812 } 1813 1814 /* 1815 * Use mdsthreshold hints set at each OPEN to determine if I/O should go 1816 * to the MDS or over pNFS 1817 * 1818 * The nfs_inode read_io and write_io fields are cumulative counters reset 1819 * when there are no layout segments. Note that in pnfs_update_layout iomode 1820 * is set to IOMODE_READ for a READ request, and set to IOMODE_RW for a 1821 * WRITE request. 1822 * 1823 * A return of true means use MDS I/O. 1824 * 1825 * From rfc 5661: 1826 * If a file's size is smaller than the file size threshold, data accesses 1827 * SHOULD be sent to the metadata server. If an I/O request has a length that 1828 * is below the I/O size threshold, the I/O SHOULD be sent to the metadata 1829 * server. If both file size and I/O size are provided, the client SHOULD 1830 * reach or exceed both thresholds before sending its read or write 1831 * requests to the data server. 1832 */ 1833 static bool pnfs_within_mdsthreshold(struct nfs_open_context *ctx, 1834 struct inode *ino, int iomode) 1835 { 1836 struct nfs4_threshold *t = ctx->mdsthreshold; 1837 struct nfs_inode *nfsi = NFS_I(ino); 1838 loff_t fsize = i_size_read(ino); 1839 bool size = false, size_set = false, io = false, io_set = false, ret = false; 1840 1841 if (t == NULL) 1842 return ret; 1843 1844 dprintk("%s bm=0x%x rd_sz=%llu wr_sz=%llu rd_io=%llu wr_io=%llu\n", 1845 __func__, t->bm, t->rd_sz, t->wr_sz, t->rd_io_sz, t->wr_io_sz); 1846 1847 switch (iomode) { 1848 case IOMODE_READ: 1849 if (t->bm & THRESHOLD_RD) { 1850 dprintk("%s fsize %llu\n", __func__, fsize); 1851 size_set = true; 1852 if (fsize < t->rd_sz) 1853 size = true; 1854 } 1855 if (t->bm & THRESHOLD_RD_IO) { 1856 dprintk("%s nfsi->read_io %llu\n", __func__, 1857 nfsi->read_io); 1858 io_set = true; 1859 if (nfsi->read_io < t->rd_io_sz) 1860 io = true; 1861 } 1862 break; 1863 case IOMODE_RW: 1864 if (t->bm & THRESHOLD_WR) { 1865 dprintk("%s fsize %llu\n", __func__, fsize); 1866 size_set = true; 1867 if (fsize < t->wr_sz) 1868 size = true; 1869 } 1870 if (t->bm & THRESHOLD_WR_IO) { 1871 dprintk("%s nfsi->write_io %llu\n", __func__, 1872 nfsi->write_io); 1873 io_set = true; 1874 if (nfsi->write_io < t->wr_io_sz) 1875 io = true; 1876 } 1877 break; 1878 } 1879 if (size_set && io_set) { 1880 if (size && io) 1881 ret = true; 1882 } else if (size || io) 1883 ret = true; 1884 1885 dprintk("<-- %s size %d io %d ret %d\n", __func__, size, io, ret); 1886 return ret; 1887 } 1888 1889 static int pnfs_prepare_to_retry_layoutget(struct pnfs_layout_hdr *lo) 1890 { 1891 /* 1892 * send layoutcommit as it can hold up layoutreturn due to lseg 1893 * reference 1894 */ 1895 pnfs_layoutcommit_inode(lo->plh_inode, false); 1896 return wait_on_bit_action(&lo->plh_flags, NFS_LAYOUT_RETURN, 1897 nfs_wait_bit_killable, 1898 TASK_KILLABLE); 1899 } 1900 1901 static void nfs_layoutget_begin(struct pnfs_layout_hdr *lo) 1902 { 1903 atomic_inc(&lo->plh_outstanding); 1904 } 1905 1906 static void nfs_layoutget_end(struct pnfs_layout_hdr *lo) 1907 { 1908 if (atomic_dec_and_test(&lo->plh_outstanding)) 1909 wake_up_var(&lo->plh_outstanding); 1910 } 1911 1912 static void pnfs_clear_first_layoutget(struct pnfs_layout_hdr *lo) 1913 { 1914 unsigned long *bitlock = &lo->plh_flags; 1915 1916 clear_bit_unlock(NFS_LAYOUT_FIRST_LAYOUTGET, bitlock); 1917 smp_mb__after_atomic(); 1918 wake_up_bit(bitlock, NFS_LAYOUT_FIRST_LAYOUTGET); 1919 } 1920 1921 static void _add_to_server_list(struct pnfs_layout_hdr *lo, 1922 struct nfs_server *server) 1923 { 1924 if (!test_and_set_bit(NFS_LAYOUT_HASHED, &lo->plh_flags)) { 1925 struct nfs_client *clp = server->nfs_client; 1926 1927 /* The lo must be on the clp list if there is any 1928 * chance of a CB_LAYOUTRECALL(FILE) coming in. 1929 */ 1930 spin_lock(&clp->cl_lock); 1931 list_add_tail_rcu(&lo->plh_layouts, &server->layouts); 1932 spin_unlock(&clp->cl_lock); 1933 } 1934 } 1935 1936 /* 1937 * Layout segment is retreived from the server if not cached. 1938 * The appropriate layout segment is referenced and returned to the caller. 1939 */ 1940 struct pnfs_layout_segment * 1941 pnfs_update_layout(struct inode *ino, 1942 struct nfs_open_context *ctx, 1943 loff_t pos, 1944 u64 count, 1945 enum pnfs_iomode iomode, 1946 bool strict_iomode, 1947 gfp_t gfp_flags) 1948 { 1949 struct pnfs_layout_range arg = { 1950 .iomode = iomode, 1951 .offset = pos, 1952 .length = count, 1953 }; 1954 unsigned pg_offset; 1955 struct nfs_server *server = NFS_SERVER(ino); 1956 struct nfs_client *clp = server->nfs_client; 1957 struct pnfs_layout_hdr *lo = NULL; 1958 struct pnfs_layout_segment *lseg = NULL; 1959 struct nfs4_layoutget *lgp; 1960 nfs4_stateid stateid; 1961 long timeout = 0; 1962 unsigned long giveup = jiffies + (clp->cl_lease_time << 1); 1963 bool first; 1964 1965 if (!pnfs_enabled_sb(NFS_SERVER(ino))) { 1966 trace_pnfs_update_layout(ino, pos, count, iomode, lo, lseg, 1967 PNFS_UPDATE_LAYOUT_NO_PNFS); 1968 goto out; 1969 } 1970 1971 if (pnfs_within_mdsthreshold(ctx, ino, iomode)) { 1972 trace_pnfs_update_layout(ino, pos, count, iomode, lo, lseg, 1973 PNFS_UPDATE_LAYOUT_MDSTHRESH); 1974 goto out; 1975 } 1976 1977 lookup_again: 1978 lseg = ERR_PTR(nfs4_client_recover_expired_lease(clp)); 1979 if (IS_ERR(lseg)) 1980 goto out; 1981 first = false; 1982 spin_lock(&ino->i_lock); 1983 lo = pnfs_find_alloc_layout(ino, ctx, gfp_flags); 1984 if (lo == NULL) { 1985 spin_unlock(&ino->i_lock); 1986 trace_pnfs_update_layout(ino, pos, count, iomode, lo, lseg, 1987 PNFS_UPDATE_LAYOUT_NOMEM); 1988 goto out; 1989 } 1990 1991 /* Do we even need to bother with this? */ 1992 if (test_bit(NFS_LAYOUT_BULK_RECALL, &lo->plh_flags)) { 1993 trace_pnfs_update_layout(ino, pos, count, iomode, lo, lseg, 1994 PNFS_UPDATE_LAYOUT_BULK_RECALL); 1995 dprintk("%s matches recall, use MDS\n", __func__); 1996 goto out_unlock; 1997 } 1998 1999 /* if LAYOUTGET already failed once we don't try again */ 2000 if (pnfs_layout_io_test_failed(lo, iomode)) { 2001 trace_pnfs_update_layout(ino, pos, count, iomode, lo, lseg, 2002 PNFS_UPDATE_LAYOUT_IO_TEST_FAIL); 2003 goto out_unlock; 2004 } 2005 2006 /* 2007 * If the layout segment list is empty, but there are outstanding 2008 * layoutget calls, then they might be subject to a layoutrecall. 2009 */ 2010 if (list_empty(&lo->plh_segs) && 2011 atomic_read(&lo->plh_outstanding) != 0) { 2012 spin_unlock(&ino->i_lock); 2013 lseg = ERR_PTR(wait_var_event_killable(&lo->plh_outstanding, 2014 !atomic_read(&lo->plh_outstanding))); 2015 if (IS_ERR(lseg)) 2016 goto out_put_layout_hdr; 2017 pnfs_put_layout_hdr(lo); 2018 goto lookup_again; 2019 } 2020 2021 /* 2022 * Because we free lsegs when sending LAYOUTRETURN, we need to wait 2023 * for LAYOUTRETURN. 2024 */ 2025 if (test_bit(NFS_LAYOUT_RETURN, &lo->plh_flags)) { 2026 spin_unlock(&ino->i_lock); 2027 dprintk("%s wait for layoutreturn\n", __func__); 2028 lseg = ERR_PTR(pnfs_prepare_to_retry_layoutget(lo)); 2029 if (!IS_ERR(lseg)) { 2030 pnfs_put_layout_hdr(lo); 2031 dprintk("%s retrying\n", __func__); 2032 trace_pnfs_update_layout(ino, pos, count, iomode, lo, 2033 lseg, 2034 PNFS_UPDATE_LAYOUT_RETRY); 2035 goto lookup_again; 2036 } 2037 trace_pnfs_update_layout(ino, pos, count, iomode, lo, lseg, 2038 PNFS_UPDATE_LAYOUT_RETURN); 2039 goto out_put_layout_hdr; 2040 } 2041 2042 lseg = pnfs_find_lseg(lo, &arg, strict_iomode); 2043 if (lseg) { 2044 trace_pnfs_update_layout(ino, pos, count, iomode, lo, lseg, 2045 PNFS_UPDATE_LAYOUT_FOUND_CACHED); 2046 goto out_unlock; 2047 } 2048 2049 /* 2050 * Choose a stateid for the LAYOUTGET. If we don't have a layout 2051 * stateid, or it has been invalidated, then we must use the open 2052 * stateid. 2053 */ 2054 if (test_bit(NFS_LAYOUT_INVALID_STID, &lo->plh_flags)) { 2055 int status; 2056 2057 /* 2058 * The first layoutget for the file. Need to serialize per 2059 * RFC 5661 Errata 3208. 2060 */ 2061 if (test_and_set_bit(NFS_LAYOUT_FIRST_LAYOUTGET, 2062 &lo->plh_flags)) { 2063 spin_unlock(&ino->i_lock); 2064 lseg = ERR_PTR(wait_on_bit(&lo->plh_flags, 2065 NFS_LAYOUT_FIRST_LAYOUTGET, 2066 TASK_KILLABLE)); 2067 if (IS_ERR(lseg)) 2068 goto out_put_layout_hdr; 2069 pnfs_put_layout_hdr(lo); 2070 dprintk("%s retrying\n", __func__); 2071 goto lookup_again; 2072 } 2073 2074 spin_unlock(&ino->i_lock); 2075 first = true; 2076 status = nfs4_select_rw_stateid(ctx->state, 2077 iomode == IOMODE_RW ? FMODE_WRITE : FMODE_READ, 2078 NULL, &stateid, NULL); 2079 if (status != 0) { 2080 lseg = ERR_PTR(status); 2081 trace_pnfs_update_layout(ino, pos, count, 2082 iomode, lo, lseg, 2083 PNFS_UPDATE_LAYOUT_INVALID_OPEN); 2084 nfs4_schedule_stateid_recovery(server, ctx->state); 2085 pnfs_clear_first_layoutget(lo); 2086 pnfs_put_layout_hdr(lo); 2087 goto lookup_again; 2088 } 2089 spin_lock(&ino->i_lock); 2090 } else { 2091 nfs4_stateid_copy(&stateid, &lo->plh_stateid); 2092 } 2093 2094 if (pnfs_layoutgets_blocked(lo)) { 2095 trace_pnfs_update_layout(ino, pos, count, iomode, lo, lseg, 2096 PNFS_UPDATE_LAYOUT_BLOCKED); 2097 goto out_unlock; 2098 } 2099 nfs_layoutget_begin(lo); 2100 spin_unlock(&ino->i_lock); 2101 2102 _add_to_server_list(lo, server); 2103 2104 pg_offset = arg.offset & ~PAGE_MASK; 2105 if (pg_offset) { 2106 arg.offset -= pg_offset; 2107 arg.length += pg_offset; 2108 } 2109 if (arg.length != NFS4_MAX_UINT64) 2110 arg.length = PAGE_ALIGN(arg.length); 2111 2112 lgp = pnfs_alloc_init_layoutget_args(ino, ctx, &stateid, &arg, gfp_flags); 2113 if (!lgp) { 2114 trace_pnfs_update_layout(ino, pos, count, iomode, lo, NULL, 2115 PNFS_UPDATE_LAYOUT_NOMEM); 2116 nfs_layoutget_end(lo); 2117 goto out_put_layout_hdr; 2118 } 2119 2120 lseg = nfs4_proc_layoutget(lgp, &timeout); 2121 trace_pnfs_update_layout(ino, pos, count, iomode, lo, lseg, 2122 PNFS_UPDATE_LAYOUT_SEND_LAYOUTGET); 2123 nfs_layoutget_end(lo); 2124 if (IS_ERR(lseg)) { 2125 switch(PTR_ERR(lseg)) { 2126 case -EBUSY: 2127 if (time_after(jiffies, giveup)) 2128 lseg = NULL; 2129 break; 2130 case -ERECALLCONFLICT: 2131 case -EAGAIN: 2132 break; 2133 default: 2134 if (!nfs_error_is_fatal(PTR_ERR(lseg))) { 2135 pnfs_layout_clear_fail_bit(lo, pnfs_iomode_to_fail_bit(iomode)); 2136 lseg = NULL; 2137 } 2138 goto out_put_layout_hdr; 2139 } 2140 if (lseg) { 2141 if (first) 2142 pnfs_clear_first_layoutget(lo); 2143 trace_pnfs_update_layout(ino, pos, count, 2144 iomode, lo, lseg, PNFS_UPDATE_LAYOUT_RETRY); 2145 pnfs_put_layout_hdr(lo); 2146 goto lookup_again; 2147 } 2148 } else { 2149 pnfs_layout_clear_fail_bit(lo, pnfs_iomode_to_fail_bit(iomode)); 2150 } 2151 2152 out_put_layout_hdr: 2153 if (first) 2154 pnfs_clear_first_layoutget(lo); 2155 trace_pnfs_update_layout(ino, pos, count, iomode, lo, lseg, 2156 PNFS_UPDATE_LAYOUT_EXIT); 2157 pnfs_put_layout_hdr(lo); 2158 out: 2159 dprintk("%s: inode %s/%llu pNFS layout segment %s for " 2160 "(%s, offset: %llu, length: %llu)\n", 2161 __func__, ino->i_sb->s_id, 2162 (unsigned long long)NFS_FILEID(ino), 2163 IS_ERR_OR_NULL(lseg) ? "not found" : "found", 2164 iomode==IOMODE_RW ? "read/write" : "read-only", 2165 (unsigned long long)pos, 2166 (unsigned long long)count); 2167 return lseg; 2168 out_unlock: 2169 spin_unlock(&ino->i_lock); 2170 goto out_put_layout_hdr; 2171 } 2172 EXPORT_SYMBOL_GPL(pnfs_update_layout); 2173 2174 static bool 2175 pnfs_sanity_check_layout_range(struct pnfs_layout_range *range) 2176 { 2177 switch (range->iomode) { 2178 case IOMODE_READ: 2179 case IOMODE_RW: 2180 break; 2181 default: 2182 return false; 2183 } 2184 if (range->offset == NFS4_MAX_UINT64) 2185 return false; 2186 if (range->length == 0) 2187 return false; 2188 if (range->length != NFS4_MAX_UINT64 && 2189 range->length > NFS4_MAX_UINT64 - range->offset) 2190 return false; 2191 return true; 2192 } 2193 2194 static struct pnfs_layout_hdr * 2195 _pnfs_grab_empty_layout(struct inode *ino, struct nfs_open_context *ctx) 2196 { 2197 struct pnfs_layout_hdr *lo; 2198 2199 spin_lock(&ino->i_lock); 2200 lo = pnfs_find_alloc_layout(ino, ctx, GFP_KERNEL); 2201 if (!lo) 2202 goto out_unlock; 2203 if (!test_bit(NFS_LAYOUT_INVALID_STID, &lo->plh_flags)) 2204 goto out_unlock; 2205 if (test_bit(NFS_LAYOUT_RETURN, &lo->plh_flags)) 2206 goto out_unlock; 2207 if (pnfs_layoutgets_blocked(lo)) 2208 goto out_unlock; 2209 if (test_and_set_bit(NFS_LAYOUT_FIRST_LAYOUTGET, &lo->plh_flags)) 2210 goto out_unlock; 2211 nfs_layoutget_begin(lo); 2212 spin_unlock(&ino->i_lock); 2213 _add_to_server_list(lo, NFS_SERVER(ino)); 2214 return lo; 2215 2216 out_unlock: 2217 spin_unlock(&ino->i_lock); 2218 pnfs_put_layout_hdr(lo); 2219 return NULL; 2220 } 2221 2222 static void _lgopen_prepare_attached(struct nfs4_opendata *data, 2223 struct nfs_open_context *ctx) 2224 { 2225 struct inode *ino = data->dentry->d_inode; 2226 struct pnfs_layout_range rng = { 2227 .iomode = (data->o_arg.fmode & FMODE_WRITE) ? 2228 IOMODE_RW: IOMODE_READ, 2229 .offset = 0, 2230 .length = NFS4_MAX_UINT64, 2231 }; 2232 struct nfs4_layoutget *lgp; 2233 struct pnfs_layout_hdr *lo; 2234 2235 /* Heuristic: don't send layoutget if we have cached data */ 2236 if (rng.iomode == IOMODE_READ && 2237 (i_size_read(ino) == 0 || ino->i_mapping->nrpages != 0)) 2238 return; 2239 2240 lo = _pnfs_grab_empty_layout(ino, ctx); 2241 if (!lo) 2242 return; 2243 lgp = pnfs_alloc_init_layoutget_args(ino, ctx, ¤t_stateid, 2244 &rng, GFP_KERNEL); 2245 if (!lgp) { 2246 pnfs_clear_first_layoutget(lo); 2247 nfs_layoutget_end(lo); 2248 pnfs_put_layout_hdr(lo); 2249 return; 2250 } 2251 data->lgp = lgp; 2252 data->o_arg.lg_args = &lgp->args; 2253 data->o_res.lg_res = &lgp->res; 2254 } 2255 2256 static void _lgopen_prepare_floating(struct nfs4_opendata *data, 2257 struct nfs_open_context *ctx) 2258 { 2259 struct pnfs_layout_range rng = { 2260 .iomode = (data->o_arg.fmode & FMODE_WRITE) ? 2261 IOMODE_RW: IOMODE_READ, 2262 .offset = 0, 2263 .length = NFS4_MAX_UINT64, 2264 }; 2265 struct nfs4_layoutget *lgp; 2266 2267 lgp = pnfs_alloc_init_layoutget_args(NULL, ctx, ¤t_stateid, 2268 &rng, GFP_KERNEL); 2269 if (!lgp) 2270 return; 2271 data->lgp = lgp; 2272 data->o_arg.lg_args = &lgp->args; 2273 data->o_res.lg_res = &lgp->res; 2274 } 2275 2276 void pnfs_lgopen_prepare(struct nfs4_opendata *data, 2277 struct nfs_open_context *ctx) 2278 { 2279 struct nfs_server *server = NFS_SERVER(data->dir->d_inode); 2280 2281 if (!(pnfs_enabled_sb(server) && 2282 server->pnfs_curr_ld->flags & PNFS_LAYOUTGET_ON_OPEN)) 2283 return; 2284 /* Could check on max_ops, but currently hardcoded high enough */ 2285 if (!nfs_server_capable(data->dir->d_inode, NFS_CAP_LGOPEN)) 2286 return; 2287 if (data->state) 2288 _lgopen_prepare_attached(data, ctx); 2289 else 2290 _lgopen_prepare_floating(data, ctx); 2291 } 2292 2293 void pnfs_parse_lgopen(struct inode *ino, struct nfs4_layoutget *lgp, 2294 struct nfs_open_context *ctx) 2295 { 2296 struct pnfs_layout_hdr *lo; 2297 struct pnfs_layout_segment *lseg; 2298 struct nfs_server *srv = NFS_SERVER(ino); 2299 u32 iomode; 2300 2301 if (!lgp) 2302 return; 2303 dprintk("%s: entered with status %i\n", __func__, lgp->res.status); 2304 if (lgp->res.status) { 2305 switch (lgp->res.status) { 2306 default: 2307 break; 2308 /* 2309 * Halt lgopen attempts if the server doesn't recognise 2310 * the "current stateid" value, the layout type, or the 2311 * layoutget operation as being valid. 2312 * Also if it complains about too many ops in the compound 2313 * or of the request/reply being too big. 2314 */ 2315 case -NFS4ERR_BAD_STATEID: 2316 case -NFS4ERR_NOTSUPP: 2317 case -NFS4ERR_REP_TOO_BIG: 2318 case -NFS4ERR_REP_TOO_BIG_TO_CACHE: 2319 case -NFS4ERR_REQ_TOO_BIG: 2320 case -NFS4ERR_TOO_MANY_OPS: 2321 case -NFS4ERR_UNKNOWN_LAYOUTTYPE: 2322 srv->caps &= ~NFS_CAP_LGOPEN; 2323 } 2324 return; 2325 } 2326 if (!lgp->args.inode) { 2327 lo = _pnfs_grab_empty_layout(ino, ctx); 2328 if (!lo) 2329 return; 2330 lgp->args.inode = ino; 2331 } else 2332 lo = NFS_I(lgp->args.inode)->layout; 2333 2334 lseg = pnfs_layout_process(lgp); 2335 if (!IS_ERR(lseg)) { 2336 iomode = lgp->args.range.iomode; 2337 pnfs_layout_clear_fail_bit(lo, pnfs_iomode_to_fail_bit(iomode)); 2338 pnfs_put_lseg(lseg); 2339 } 2340 } 2341 2342 void nfs4_lgopen_release(struct nfs4_layoutget *lgp) 2343 { 2344 if (lgp != NULL) { 2345 struct inode *inode = lgp->args.inode; 2346 if (inode) { 2347 struct pnfs_layout_hdr *lo = NFS_I(inode)->layout; 2348 pnfs_clear_first_layoutget(lo); 2349 nfs_layoutget_end(lo); 2350 } 2351 pnfs_layoutget_free(lgp); 2352 } 2353 } 2354 2355 struct pnfs_layout_segment * 2356 pnfs_layout_process(struct nfs4_layoutget *lgp) 2357 { 2358 struct pnfs_layout_hdr *lo = NFS_I(lgp->args.inode)->layout; 2359 struct nfs4_layoutget_res *res = &lgp->res; 2360 struct pnfs_layout_segment *lseg; 2361 struct inode *ino = lo->plh_inode; 2362 LIST_HEAD(free_me); 2363 2364 if (!pnfs_sanity_check_layout_range(&res->range)) 2365 return ERR_PTR(-EINVAL); 2366 2367 /* Inject layout blob into I/O device driver */ 2368 lseg = NFS_SERVER(ino)->pnfs_curr_ld->alloc_lseg(lo, res, lgp->gfp_flags); 2369 if (IS_ERR_OR_NULL(lseg)) { 2370 if (!lseg) 2371 lseg = ERR_PTR(-ENOMEM); 2372 2373 dprintk("%s: Could not allocate layout: error %ld\n", 2374 __func__, PTR_ERR(lseg)); 2375 return lseg; 2376 } 2377 2378 pnfs_init_lseg(lo, lseg, &res->range, &res->stateid); 2379 2380 spin_lock(&ino->i_lock); 2381 if (pnfs_layoutgets_blocked(lo)) { 2382 dprintk("%s forget reply due to state\n", __func__); 2383 goto out_forget; 2384 } 2385 2386 if (!pnfs_layout_is_valid(lo)) { 2387 /* We have a completely new layout */ 2388 pnfs_set_layout_stateid(lo, &res->stateid, lgp->cred, true); 2389 } else if (nfs4_stateid_match_other(&lo->plh_stateid, &res->stateid)) { 2390 /* existing state ID, make sure the sequence number matches. */ 2391 if (pnfs_layout_stateid_blocked(lo, &res->stateid)) { 2392 dprintk("%s forget reply due to sequence\n", __func__); 2393 goto out_forget; 2394 } 2395 pnfs_set_layout_stateid(lo, &res->stateid, lgp->cred, false); 2396 } else { 2397 /* 2398 * We got an entirely new state ID. Mark all segments for the 2399 * inode invalid, and retry the layoutget 2400 */ 2401 pnfs_mark_layout_stateid_invalid(lo, &free_me); 2402 goto out_forget; 2403 } 2404 2405 pnfs_get_lseg(lseg); 2406 pnfs_layout_insert_lseg(lo, lseg, &free_me); 2407 2408 2409 if (res->return_on_close) 2410 set_bit(NFS_LSEG_ROC, &lseg->pls_flags); 2411 2412 spin_unlock(&ino->i_lock); 2413 pnfs_free_lseg_list(&free_me); 2414 return lseg; 2415 2416 out_forget: 2417 spin_unlock(&ino->i_lock); 2418 lseg->pls_layout = lo; 2419 NFS_SERVER(ino)->pnfs_curr_ld->free_lseg(lseg); 2420 return ERR_PTR(-EAGAIN); 2421 } 2422 2423 /** 2424 * pnfs_mark_matching_lsegs_return - Free or return matching layout segments 2425 * @lo: pointer to layout header 2426 * @tmp_list: list header to be used with pnfs_free_lseg_list() 2427 * @return_range: describe layout segment ranges to be returned 2428 * @seq: stateid seqid to match 2429 * 2430 * This function is mainly intended for use by layoutrecall. It attempts 2431 * to free the layout segment immediately, or else to mark it for return 2432 * as soon as its reference count drops to zero. 2433 * 2434 * Returns 2435 * - 0: a layoutreturn needs to be scheduled. 2436 * - EBUSY: there are layout segment that are still in use. 2437 * - ENOENT: there are no layout segments that need to be returned. 2438 */ 2439 int 2440 pnfs_mark_matching_lsegs_return(struct pnfs_layout_hdr *lo, 2441 struct list_head *tmp_list, 2442 const struct pnfs_layout_range *return_range, 2443 u32 seq) 2444 { 2445 struct pnfs_layout_segment *lseg, *next; 2446 int remaining = 0; 2447 2448 dprintk("%s:Begin lo %p\n", __func__, lo); 2449 2450 assert_spin_locked(&lo->plh_inode->i_lock); 2451 2452 list_for_each_entry_safe(lseg, next, &lo->plh_segs, pls_list) 2453 if (pnfs_match_lseg_recall(lseg, return_range, seq)) { 2454 dprintk("%s: marking lseg %p iomode %d " 2455 "offset %llu length %llu\n", __func__, 2456 lseg, lseg->pls_range.iomode, 2457 lseg->pls_range.offset, 2458 lseg->pls_range.length); 2459 if (mark_lseg_invalid(lseg, tmp_list)) 2460 continue; 2461 remaining++; 2462 set_bit(NFS_LSEG_LAYOUTRETURN, &lseg->pls_flags); 2463 } 2464 2465 if (remaining) { 2466 pnfs_set_plh_return_info(lo, return_range->iomode, seq); 2467 return -EBUSY; 2468 } 2469 2470 if (!list_empty(&lo->plh_return_segs)) { 2471 pnfs_set_plh_return_info(lo, return_range->iomode, seq); 2472 return 0; 2473 } 2474 2475 return -ENOENT; 2476 } 2477 2478 static void 2479 pnfs_mark_layout_for_return(struct inode *inode, 2480 const struct pnfs_layout_range *range) 2481 { 2482 struct pnfs_layout_hdr *lo; 2483 bool return_now = false; 2484 2485 spin_lock(&inode->i_lock); 2486 lo = NFS_I(inode)->layout; 2487 if (!pnfs_layout_is_valid(lo)) { 2488 spin_unlock(&inode->i_lock); 2489 return; 2490 } 2491 pnfs_set_plh_return_info(lo, range->iomode, 0); 2492 /* 2493 * mark all matching lsegs so that we are sure to have no live 2494 * segments at hand when sending layoutreturn. See pnfs_put_lseg() 2495 * for how it works. 2496 */ 2497 if (pnfs_mark_matching_lsegs_return(lo, &lo->plh_return_segs, range, 0) != -EBUSY) { 2498 const struct cred *cred; 2499 nfs4_stateid stateid; 2500 enum pnfs_iomode iomode; 2501 2502 return_now = pnfs_prepare_layoutreturn(lo, &stateid, &cred, &iomode); 2503 spin_unlock(&inode->i_lock); 2504 if (return_now) 2505 pnfs_send_layoutreturn(lo, &stateid, &cred, iomode, false); 2506 } else { 2507 spin_unlock(&inode->i_lock); 2508 nfs_commit_inode(inode, 0); 2509 } 2510 } 2511 2512 void pnfs_error_mark_layout_for_return(struct inode *inode, 2513 struct pnfs_layout_segment *lseg) 2514 { 2515 struct pnfs_layout_range range = { 2516 .iomode = lseg->pls_range.iomode, 2517 .offset = 0, 2518 .length = NFS4_MAX_UINT64, 2519 }; 2520 2521 pnfs_mark_layout_for_return(inode, &range); 2522 } 2523 EXPORT_SYMBOL_GPL(pnfs_error_mark_layout_for_return); 2524 2525 static bool 2526 pnfs_layout_can_be_returned(struct pnfs_layout_hdr *lo) 2527 { 2528 return pnfs_layout_is_valid(lo) && 2529 !test_bit(NFS_LAYOUT_INODE_FREEING, &lo->plh_flags) && 2530 !test_bit(NFS_LAYOUT_RETURN, &lo->plh_flags); 2531 } 2532 2533 static struct pnfs_layout_segment * 2534 pnfs_find_first_lseg(struct pnfs_layout_hdr *lo, 2535 const struct pnfs_layout_range *range, 2536 enum pnfs_iomode iomode) 2537 { 2538 struct pnfs_layout_segment *lseg; 2539 2540 list_for_each_entry(lseg, &lo->plh_segs, pls_list) { 2541 if (!test_bit(NFS_LSEG_VALID, &lseg->pls_flags)) 2542 continue; 2543 if (test_bit(NFS_LSEG_LAYOUTRETURN, &lseg->pls_flags)) 2544 continue; 2545 if (lseg->pls_range.iomode != iomode && iomode != IOMODE_ANY) 2546 continue; 2547 if (pnfs_lseg_range_intersecting(&lseg->pls_range, range)) 2548 return lseg; 2549 } 2550 return NULL; 2551 } 2552 2553 /* Find open file states whose mode matches that of the range */ 2554 static bool 2555 pnfs_should_return_unused_layout(struct pnfs_layout_hdr *lo, 2556 const struct pnfs_layout_range *range) 2557 { 2558 struct list_head *head; 2559 struct nfs_open_context *ctx; 2560 fmode_t mode = 0; 2561 2562 if (!pnfs_layout_can_be_returned(lo) || 2563 !pnfs_find_first_lseg(lo, range, range->iomode)) 2564 return false; 2565 2566 head = &NFS_I(lo->plh_inode)->open_files; 2567 list_for_each_entry_rcu(ctx, head, list) { 2568 if (ctx->state) 2569 mode |= ctx->state->state & (FMODE_READ|FMODE_WRITE); 2570 } 2571 2572 switch (range->iomode) { 2573 default: 2574 break; 2575 case IOMODE_READ: 2576 mode &= ~FMODE_WRITE; 2577 break; 2578 case IOMODE_RW: 2579 if (pnfs_find_first_lseg(lo, range, IOMODE_READ)) 2580 mode &= ~FMODE_READ; 2581 } 2582 return mode == 0; 2583 } 2584 2585 static int 2586 pnfs_layout_return_unused_byserver(struct nfs_server *server, void *data) 2587 { 2588 const struct pnfs_layout_range *range = data; 2589 struct pnfs_layout_hdr *lo; 2590 struct inode *inode; 2591 restart: 2592 rcu_read_lock(); 2593 list_for_each_entry_rcu(lo, &server->layouts, plh_layouts) { 2594 if (!pnfs_layout_can_be_returned(lo) || 2595 test_bit(NFS_LAYOUT_RETURN_REQUESTED, &lo->plh_flags)) 2596 continue; 2597 inode = lo->plh_inode; 2598 spin_lock(&inode->i_lock); 2599 if (!pnfs_should_return_unused_layout(lo, range)) { 2600 spin_unlock(&inode->i_lock); 2601 continue; 2602 } 2603 spin_unlock(&inode->i_lock); 2604 inode = pnfs_grab_inode_layout_hdr(lo); 2605 if (!inode) 2606 continue; 2607 rcu_read_unlock(); 2608 pnfs_mark_layout_for_return(inode, range); 2609 iput(inode); 2610 cond_resched(); 2611 goto restart; 2612 } 2613 rcu_read_unlock(); 2614 return 0; 2615 } 2616 2617 void 2618 pnfs_layout_return_unused_byclid(struct nfs_client *clp, 2619 enum pnfs_iomode iomode) 2620 { 2621 struct pnfs_layout_range range = { 2622 .iomode = iomode, 2623 .offset = 0, 2624 .length = NFS4_MAX_UINT64, 2625 }; 2626 2627 nfs_client_for_each_server(clp, pnfs_layout_return_unused_byserver, 2628 &range); 2629 } 2630 2631 void 2632 pnfs_generic_pg_check_layout(struct nfs_pageio_descriptor *pgio) 2633 { 2634 if (pgio->pg_lseg == NULL || 2635 test_bit(NFS_LSEG_VALID, &pgio->pg_lseg->pls_flags)) 2636 return; 2637 pnfs_put_lseg(pgio->pg_lseg); 2638 pgio->pg_lseg = NULL; 2639 } 2640 EXPORT_SYMBOL_GPL(pnfs_generic_pg_check_layout); 2641 2642 /* 2643 * Check for any intersection between the request and the pgio->pg_lseg, 2644 * and if none, put this pgio->pg_lseg away. 2645 */ 2646 void 2647 pnfs_generic_pg_check_range(struct nfs_pageio_descriptor *pgio, struct nfs_page *req) 2648 { 2649 if (pgio->pg_lseg && !pnfs_lseg_request_intersecting(pgio->pg_lseg, req)) { 2650 pnfs_put_lseg(pgio->pg_lseg); 2651 pgio->pg_lseg = NULL; 2652 } 2653 } 2654 EXPORT_SYMBOL_GPL(pnfs_generic_pg_check_range); 2655 2656 void 2657 pnfs_generic_pg_init_read(struct nfs_pageio_descriptor *pgio, struct nfs_page *req) 2658 { 2659 u64 rd_size = req->wb_bytes; 2660 2661 pnfs_generic_pg_check_layout(pgio); 2662 pnfs_generic_pg_check_range(pgio, req); 2663 if (pgio->pg_lseg == NULL) { 2664 if (pgio->pg_dreq == NULL) 2665 rd_size = i_size_read(pgio->pg_inode) - req_offset(req); 2666 else 2667 rd_size = nfs_dreq_bytes_left(pgio->pg_dreq); 2668 2669 pgio->pg_lseg = pnfs_update_layout(pgio->pg_inode, 2670 nfs_req_openctx(req), 2671 req_offset(req), 2672 rd_size, 2673 IOMODE_READ, 2674 false, 2675 GFP_KERNEL); 2676 if (IS_ERR(pgio->pg_lseg)) { 2677 pgio->pg_error = PTR_ERR(pgio->pg_lseg); 2678 pgio->pg_lseg = NULL; 2679 return; 2680 } 2681 } 2682 /* If no lseg, fall back to read through mds */ 2683 if (pgio->pg_lseg == NULL) 2684 nfs_pageio_reset_read_mds(pgio); 2685 2686 } 2687 EXPORT_SYMBOL_GPL(pnfs_generic_pg_init_read); 2688 2689 void 2690 pnfs_generic_pg_init_write(struct nfs_pageio_descriptor *pgio, 2691 struct nfs_page *req, u64 wb_size) 2692 { 2693 pnfs_generic_pg_check_layout(pgio); 2694 pnfs_generic_pg_check_range(pgio, req); 2695 if (pgio->pg_lseg == NULL) { 2696 pgio->pg_lseg = pnfs_update_layout(pgio->pg_inode, 2697 nfs_req_openctx(req), 2698 req_offset(req), 2699 wb_size, 2700 IOMODE_RW, 2701 false, 2702 GFP_KERNEL); 2703 if (IS_ERR(pgio->pg_lseg)) { 2704 pgio->pg_error = PTR_ERR(pgio->pg_lseg); 2705 pgio->pg_lseg = NULL; 2706 return; 2707 } 2708 } 2709 /* If no lseg, fall back to write through mds */ 2710 if (pgio->pg_lseg == NULL) 2711 nfs_pageio_reset_write_mds(pgio); 2712 } 2713 EXPORT_SYMBOL_GPL(pnfs_generic_pg_init_write); 2714 2715 void 2716 pnfs_generic_pg_cleanup(struct nfs_pageio_descriptor *desc) 2717 { 2718 if (desc->pg_lseg) { 2719 pnfs_put_lseg(desc->pg_lseg); 2720 desc->pg_lseg = NULL; 2721 } 2722 } 2723 EXPORT_SYMBOL_GPL(pnfs_generic_pg_cleanup); 2724 2725 /* 2726 * Return 0 if @req cannot be coalesced into @pgio, otherwise return the number 2727 * of bytes (maximum @req->wb_bytes) that can be coalesced. 2728 */ 2729 size_t 2730 pnfs_generic_pg_test(struct nfs_pageio_descriptor *pgio, 2731 struct nfs_page *prev, struct nfs_page *req) 2732 { 2733 unsigned int size; 2734 u64 seg_end, req_start, seg_left; 2735 2736 size = nfs_generic_pg_test(pgio, prev, req); 2737 if (!size) 2738 return 0; 2739 2740 /* 2741 * 'size' contains the number of bytes left in the current page (up 2742 * to the original size asked for in @req->wb_bytes). 2743 * 2744 * Calculate how many bytes are left in the layout segment 2745 * and if there are less bytes than 'size', return that instead. 2746 * 2747 * Please also note that 'end_offset' is actually the offset of the 2748 * first byte that lies outside the pnfs_layout_range. FIXME? 2749 * 2750 */ 2751 if (pgio->pg_lseg) { 2752 seg_end = pnfs_end_offset(pgio->pg_lseg->pls_range.offset, 2753 pgio->pg_lseg->pls_range.length); 2754 req_start = req_offset(req); 2755 2756 /* start of request is past the last byte of this segment */ 2757 if (req_start >= seg_end) 2758 return 0; 2759 2760 /* adjust 'size' iff there are fewer bytes left in the 2761 * segment than what nfs_generic_pg_test returned */ 2762 seg_left = seg_end - req_start; 2763 if (seg_left < size) 2764 size = (unsigned int)seg_left; 2765 } 2766 2767 return size; 2768 } 2769 EXPORT_SYMBOL_GPL(pnfs_generic_pg_test); 2770 2771 int pnfs_write_done_resend_to_mds(struct nfs_pgio_header *hdr) 2772 { 2773 struct nfs_pageio_descriptor pgio; 2774 2775 /* Resend all requests through the MDS */ 2776 nfs_pageio_init_write(&pgio, hdr->inode, FLUSH_STABLE, true, 2777 hdr->completion_ops); 2778 set_bit(NFS_CONTEXT_RESEND_WRITES, &hdr->args.context->flags); 2779 return nfs_pageio_resend(&pgio, hdr); 2780 } 2781 EXPORT_SYMBOL_GPL(pnfs_write_done_resend_to_mds); 2782 2783 static void pnfs_ld_handle_write_error(struct nfs_pgio_header *hdr) 2784 { 2785 2786 dprintk("pnfs write error = %d\n", hdr->pnfs_error); 2787 if (NFS_SERVER(hdr->inode)->pnfs_curr_ld->flags & 2788 PNFS_LAYOUTRET_ON_ERROR) { 2789 pnfs_return_layout(hdr->inode); 2790 } 2791 if (!test_and_set_bit(NFS_IOHDR_REDO, &hdr->flags)) 2792 hdr->task.tk_status = pnfs_write_done_resend_to_mds(hdr); 2793 } 2794 2795 /* 2796 * Called by non rpc-based layout drivers 2797 */ 2798 void pnfs_ld_write_done(struct nfs_pgio_header *hdr) 2799 { 2800 if (likely(!hdr->pnfs_error)) { 2801 pnfs_set_layoutcommit(hdr->inode, hdr->lseg, 2802 hdr->mds_offset + hdr->res.count); 2803 hdr->mds_ops->rpc_call_done(&hdr->task, hdr); 2804 } 2805 trace_nfs4_pnfs_write(hdr, hdr->pnfs_error); 2806 if (unlikely(hdr->pnfs_error)) 2807 pnfs_ld_handle_write_error(hdr); 2808 hdr->mds_ops->rpc_release(hdr); 2809 } 2810 EXPORT_SYMBOL_GPL(pnfs_ld_write_done); 2811 2812 static void 2813 pnfs_write_through_mds(struct nfs_pageio_descriptor *desc, 2814 struct nfs_pgio_header *hdr) 2815 { 2816 struct nfs_pgio_mirror *mirror = nfs_pgio_current_mirror(desc); 2817 2818 if (!test_and_set_bit(NFS_IOHDR_REDO, &hdr->flags)) { 2819 list_splice_tail_init(&hdr->pages, &mirror->pg_list); 2820 nfs_pageio_reset_write_mds(desc); 2821 mirror->pg_recoalesce = 1; 2822 } 2823 hdr->completion_ops->completion(hdr); 2824 } 2825 2826 static enum pnfs_try_status 2827 pnfs_try_to_write_data(struct nfs_pgio_header *hdr, 2828 const struct rpc_call_ops *call_ops, 2829 struct pnfs_layout_segment *lseg, 2830 int how) 2831 { 2832 struct inode *inode = hdr->inode; 2833 enum pnfs_try_status trypnfs; 2834 struct nfs_server *nfss = NFS_SERVER(inode); 2835 2836 hdr->mds_ops = call_ops; 2837 2838 dprintk("%s: Writing ino:%lu %u@%llu (how %d)\n", __func__, 2839 inode->i_ino, hdr->args.count, hdr->args.offset, how); 2840 trypnfs = nfss->pnfs_curr_ld->write_pagelist(hdr, how); 2841 if (trypnfs != PNFS_NOT_ATTEMPTED) 2842 nfs_inc_stats(inode, NFSIOS_PNFS_WRITE); 2843 dprintk("%s End (trypnfs:%d)\n", __func__, trypnfs); 2844 return trypnfs; 2845 } 2846 2847 static void 2848 pnfs_do_write(struct nfs_pageio_descriptor *desc, 2849 struct nfs_pgio_header *hdr, int how) 2850 { 2851 const struct rpc_call_ops *call_ops = desc->pg_rpc_callops; 2852 struct pnfs_layout_segment *lseg = desc->pg_lseg; 2853 enum pnfs_try_status trypnfs; 2854 2855 trypnfs = pnfs_try_to_write_data(hdr, call_ops, lseg, how); 2856 switch (trypnfs) { 2857 case PNFS_NOT_ATTEMPTED: 2858 pnfs_write_through_mds(desc, hdr); 2859 case PNFS_ATTEMPTED: 2860 break; 2861 case PNFS_TRY_AGAIN: 2862 /* cleanup hdr and prepare to redo pnfs */ 2863 if (!test_and_set_bit(NFS_IOHDR_REDO, &hdr->flags)) { 2864 struct nfs_pgio_mirror *mirror = nfs_pgio_current_mirror(desc); 2865 list_splice_init(&hdr->pages, &mirror->pg_list); 2866 mirror->pg_recoalesce = 1; 2867 } 2868 hdr->mds_ops->rpc_release(hdr); 2869 } 2870 } 2871 2872 static void pnfs_writehdr_free(struct nfs_pgio_header *hdr) 2873 { 2874 pnfs_put_lseg(hdr->lseg); 2875 nfs_pgio_header_free(hdr); 2876 } 2877 2878 int 2879 pnfs_generic_pg_writepages(struct nfs_pageio_descriptor *desc) 2880 { 2881 struct nfs_pgio_header *hdr; 2882 int ret; 2883 2884 hdr = nfs_pgio_header_alloc(desc->pg_rw_ops); 2885 if (!hdr) { 2886 desc->pg_error = -ENOMEM; 2887 return desc->pg_error; 2888 } 2889 nfs_pgheader_init(desc, hdr, pnfs_writehdr_free); 2890 2891 hdr->lseg = pnfs_get_lseg(desc->pg_lseg); 2892 ret = nfs_generic_pgio(desc, hdr); 2893 if (!ret) 2894 pnfs_do_write(desc, hdr, desc->pg_ioflags); 2895 2896 return ret; 2897 } 2898 EXPORT_SYMBOL_GPL(pnfs_generic_pg_writepages); 2899 2900 int pnfs_read_done_resend_to_mds(struct nfs_pgio_header *hdr) 2901 { 2902 struct nfs_pageio_descriptor pgio; 2903 2904 /* Resend all requests through the MDS */ 2905 nfs_pageio_init_read(&pgio, hdr->inode, true, hdr->completion_ops); 2906 return nfs_pageio_resend(&pgio, hdr); 2907 } 2908 EXPORT_SYMBOL_GPL(pnfs_read_done_resend_to_mds); 2909 2910 static void pnfs_ld_handle_read_error(struct nfs_pgio_header *hdr) 2911 { 2912 dprintk("pnfs read error = %d\n", hdr->pnfs_error); 2913 if (NFS_SERVER(hdr->inode)->pnfs_curr_ld->flags & 2914 PNFS_LAYOUTRET_ON_ERROR) { 2915 pnfs_return_layout(hdr->inode); 2916 } 2917 if (!test_and_set_bit(NFS_IOHDR_REDO, &hdr->flags)) 2918 hdr->task.tk_status = pnfs_read_done_resend_to_mds(hdr); 2919 } 2920 2921 /* 2922 * Called by non rpc-based layout drivers 2923 */ 2924 void pnfs_ld_read_done(struct nfs_pgio_header *hdr) 2925 { 2926 if (likely(!hdr->pnfs_error)) 2927 hdr->mds_ops->rpc_call_done(&hdr->task, hdr); 2928 trace_nfs4_pnfs_read(hdr, hdr->pnfs_error); 2929 if (unlikely(hdr->pnfs_error)) 2930 pnfs_ld_handle_read_error(hdr); 2931 hdr->mds_ops->rpc_release(hdr); 2932 } 2933 EXPORT_SYMBOL_GPL(pnfs_ld_read_done); 2934 2935 static void 2936 pnfs_read_through_mds(struct nfs_pageio_descriptor *desc, 2937 struct nfs_pgio_header *hdr) 2938 { 2939 struct nfs_pgio_mirror *mirror = nfs_pgio_current_mirror(desc); 2940 2941 if (!test_and_set_bit(NFS_IOHDR_REDO, &hdr->flags)) { 2942 list_splice_tail_init(&hdr->pages, &mirror->pg_list); 2943 nfs_pageio_reset_read_mds(desc); 2944 mirror->pg_recoalesce = 1; 2945 } 2946 hdr->completion_ops->completion(hdr); 2947 } 2948 2949 /* 2950 * Call the appropriate parallel I/O subsystem read function. 2951 */ 2952 static enum pnfs_try_status 2953 pnfs_try_to_read_data(struct nfs_pgio_header *hdr, 2954 const struct rpc_call_ops *call_ops, 2955 struct pnfs_layout_segment *lseg) 2956 { 2957 struct inode *inode = hdr->inode; 2958 struct nfs_server *nfss = NFS_SERVER(inode); 2959 enum pnfs_try_status trypnfs; 2960 2961 hdr->mds_ops = call_ops; 2962 2963 dprintk("%s: Reading ino:%lu %u@%llu\n", 2964 __func__, inode->i_ino, hdr->args.count, hdr->args.offset); 2965 2966 trypnfs = nfss->pnfs_curr_ld->read_pagelist(hdr); 2967 if (trypnfs != PNFS_NOT_ATTEMPTED) 2968 nfs_inc_stats(inode, NFSIOS_PNFS_READ); 2969 dprintk("%s End (trypnfs:%d)\n", __func__, trypnfs); 2970 return trypnfs; 2971 } 2972 2973 /* Resend all requests through pnfs. */ 2974 void pnfs_read_resend_pnfs(struct nfs_pgio_header *hdr, 2975 unsigned int mirror_idx) 2976 { 2977 struct nfs_pageio_descriptor pgio; 2978 2979 if (!test_and_set_bit(NFS_IOHDR_REDO, &hdr->flags)) { 2980 /* Prevent deadlocks with layoutreturn! */ 2981 pnfs_put_lseg(hdr->lseg); 2982 hdr->lseg = NULL; 2983 2984 nfs_pageio_init_read(&pgio, hdr->inode, false, 2985 hdr->completion_ops); 2986 pgio.pg_mirror_idx = mirror_idx; 2987 hdr->task.tk_status = nfs_pageio_resend(&pgio, hdr); 2988 } 2989 } 2990 EXPORT_SYMBOL_GPL(pnfs_read_resend_pnfs); 2991 2992 static void 2993 pnfs_do_read(struct nfs_pageio_descriptor *desc, struct nfs_pgio_header *hdr) 2994 { 2995 const struct rpc_call_ops *call_ops = desc->pg_rpc_callops; 2996 struct pnfs_layout_segment *lseg = desc->pg_lseg; 2997 enum pnfs_try_status trypnfs; 2998 2999 trypnfs = pnfs_try_to_read_data(hdr, call_ops, lseg); 3000 switch (trypnfs) { 3001 case PNFS_NOT_ATTEMPTED: 3002 pnfs_read_through_mds(desc, hdr); 3003 case PNFS_ATTEMPTED: 3004 break; 3005 case PNFS_TRY_AGAIN: 3006 /* cleanup hdr and prepare to redo pnfs */ 3007 if (!test_and_set_bit(NFS_IOHDR_REDO, &hdr->flags)) { 3008 struct nfs_pgio_mirror *mirror = nfs_pgio_current_mirror(desc); 3009 list_splice_init(&hdr->pages, &mirror->pg_list); 3010 mirror->pg_recoalesce = 1; 3011 } 3012 hdr->mds_ops->rpc_release(hdr); 3013 } 3014 } 3015 3016 static void pnfs_readhdr_free(struct nfs_pgio_header *hdr) 3017 { 3018 pnfs_put_lseg(hdr->lseg); 3019 nfs_pgio_header_free(hdr); 3020 } 3021 3022 int 3023 pnfs_generic_pg_readpages(struct nfs_pageio_descriptor *desc) 3024 { 3025 struct nfs_pgio_header *hdr; 3026 int ret; 3027 3028 hdr = nfs_pgio_header_alloc(desc->pg_rw_ops); 3029 if (!hdr) { 3030 desc->pg_error = -ENOMEM; 3031 return desc->pg_error; 3032 } 3033 nfs_pgheader_init(desc, hdr, pnfs_readhdr_free); 3034 hdr->lseg = pnfs_get_lseg(desc->pg_lseg); 3035 ret = nfs_generic_pgio(desc, hdr); 3036 if (!ret) 3037 pnfs_do_read(desc, hdr); 3038 return ret; 3039 } 3040 EXPORT_SYMBOL_GPL(pnfs_generic_pg_readpages); 3041 3042 static void pnfs_clear_layoutcommitting(struct inode *inode) 3043 { 3044 unsigned long *bitlock = &NFS_I(inode)->flags; 3045 3046 clear_bit_unlock(NFS_INO_LAYOUTCOMMITTING, bitlock); 3047 smp_mb__after_atomic(); 3048 wake_up_bit(bitlock, NFS_INO_LAYOUTCOMMITTING); 3049 } 3050 3051 /* 3052 * There can be multiple RW segments. 3053 */ 3054 static void pnfs_list_write_lseg(struct inode *inode, struct list_head *listp) 3055 { 3056 struct pnfs_layout_segment *lseg; 3057 3058 list_for_each_entry(lseg, &NFS_I(inode)->layout->plh_segs, pls_list) { 3059 if (lseg->pls_range.iomode == IOMODE_RW && 3060 test_and_clear_bit(NFS_LSEG_LAYOUTCOMMIT, &lseg->pls_flags)) 3061 list_add(&lseg->pls_lc_list, listp); 3062 } 3063 } 3064 3065 static void pnfs_list_write_lseg_done(struct inode *inode, struct list_head *listp) 3066 { 3067 struct pnfs_layout_segment *lseg, *tmp; 3068 3069 /* Matched by references in pnfs_set_layoutcommit */ 3070 list_for_each_entry_safe(lseg, tmp, listp, pls_lc_list) { 3071 list_del_init(&lseg->pls_lc_list); 3072 pnfs_put_lseg(lseg); 3073 } 3074 3075 pnfs_clear_layoutcommitting(inode); 3076 } 3077 3078 void pnfs_set_lo_fail(struct pnfs_layout_segment *lseg) 3079 { 3080 pnfs_layout_io_set_failed(lseg->pls_layout, lseg->pls_range.iomode); 3081 } 3082 EXPORT_SYMBOL_GPL(pnfs_set_lo_fail); 3083 3084 void 3085 pnfs_set_layoutcommit(struct inode *inode, struct pnfs_layout_segment *lseg, 3086 loff_t end_pos) 3087 { 3088 struct nfs_inode *nfsi = NFS_I(inode); 3089 bool mark_as_dirty = false; 3090 3091 spin_lock(&inode->i_lock); 3092 if (!test_and_set_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags)) { 3093 nfsi->layout->plh_lwb = end_pos; 3094 mark_as_dirty = true; 3095 dprintk("%s: Set layoutcommit for inode %lu ", 3096 __func__, inode->i_ino); 3097 } else if (end_pos > nfsi->layout->plh_lwb) 3098 nfsi->layout->plh_lwb = end_pos; 3099 if (!test_and_set_bit(NFS_LSEG_LAYOUTCOMMIT, &lseg->pls_flags)) { 3100 /* references matched in nfs4_layoutcommit_release */ 3101 pnfs_get_lseg(lseg); 3102 } 3103 spin_unlock(&inode->i_lock); 3104 dprintk("%s: lseg %p end_pos %llu\n", 3105 __func__, lseg, nfsi->layout->plh_lwb); 3106 3107 /* if pnfs_layoutcommit_inode() runs between inode locks, the next one 3108 * will be a noop because NFS_INO_LAYOUTCOMMIT will not be set */ 3109 if (mark_as_dirty) 3110 mark_inode_dirty_sync(inode); 3111 } 3112 EXPORT_SYMBOL_GPL(pnfs_set_layoutcommit); 3113 3114 void pnfs_cleanup_layoutcommit(struct nfs4_layoutcommit_data *data) 3115 { 3116 struct nfs_server *nfss = NFS_SERVER(data->args.inode); 3117 3118 if (nfss->pnfs_curr_ld->cleanup_layoutcommit) 3119 nfss->pnfs_curr_ld->cleanup_layoutcommit(data); 3120 pnfs_list_write_lseg_done(data->args.inode, &data->lseg_list); 3121 } 3122 3123 /* 3124 * For the LAYOUT4_NFSV4_1_FILES layout type, NFS_DATA_SYNC WRITEs and 3125 * NFS_UNSTABLE WRITEs with a COMMIT to data servers must store enough 3126 * data to disk to allow the server to recover the data if it crashes. 3127 * LAYOUTCOMMIT is only needed when the NFL4_UFLG_COMMIT_THRU_MDS flag 3128 * is off, and a COMMIT is sent to a data server, or 3129 * if WRITEs to a data server return NFS_DATA_SYNC. 3130 */ 3131 int 3132 pnfs_layoutcommit_inode(struct inode *inode, bool sync) 3133 { 3134 struct pnfs_layoutdriver_type *ld = NFS_SERVER(inode)->pnfs_curr_ld; 3135 struct nfs4_layoutcommit_data *data; 3136 struct nfs_inode *nfsi = NFS_I(inode); 3137 loff_t end_pos; 3138 int status; 3139 3140 if (!pnfs_layoutcommit_outstanding(inode)) 3141 return 0; 3142 3143 dprintk("--> %s inode %lu\n", __func__, inode->i_ino); 3144 3145 status = -EAGAIN; 3146 if (test_and_set_bit(NFS_INO_LAYOUTCOMMITTING, &nfsi->flags)) { 3147 if (!sync) 3148 goto out; 3149 status = wait_on_bit_lock_action(&nfsi->flags, 3150 NFS_INO_LAYOUTCOMMITTING, 3151 nfs_wait_bit_killable, 3152 TASK_KILLABLE); 3153 if (status) 3154 goto out; 3155 } 3156 3157 status = -ENOMEM; 3158 /* Note kzalloc ensures data->res.seq_res.sr_slot == NULL */ 3159 data = kzalloc(sizeof(*data), GFP_NOFS); 3160 if (!data) 3161 goto clear_layoutcommitting; 3162 3163 status = 0; 3164 spin_lock(&inode->i_lock); 3165 if (!test_and_clear_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags)) 3166 goto out_unlock; 3167 3168 INIT_LIST_HEAD(&data->lseg_list); 3169 pnfs_list_write_lseg(inode, &data->lseg_list); 3170 3171 end_pos = nfsi->layout->plh_lwb; 3172 3173 nfs4_stateid_copy(&data->args.stateid, &nfsi->layout->plh_stateid); 3174 data->cred = get_cred(nfsi->layout->plh_lc_cred); 3175 spin_unlock(&inode->i_lock); 3176 3177 data->args.inode = inode; 3178 nfs_fattr_init(&data->fattr); 3179 data->args.bitmask = NFS_SERVER(inode)->cache_consistency_bitmask; 3180 data->res.fattr = &data->fattr; 3181 if (end_pos != 0) 3182 data->args.lastbytewritten = end_pos - 1; 3183 else 3184 data->args.lastbytewritten = U64_MAX; 3185 data->res.server = NFS_SERVER(inode); 3186 3187 if (ld->prepare_layoutcommit) { 3188 status = ld->prepare_layoutcommit(&data->args); 3189 if (status) { 3190 put_cred(data->cred); 3191 spin_lock(&inode->i_lock); 3192 set_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags); 3193 if (end_pos > nfsi->layout->plh_lwb) 3194 nfsi->layout->plh_lwb = end_pos; 3195 goto out_unlock; 3196 } 3197 } 3198 3199 3200 status = nfs4_proc_layoutcommit(data, sync); 3201 out: 3202 if (status) 3203 mark_inode_dirty_sync(inode); 3204 dprintk("<-- %s status %d\n", __func__, status); 3205 return status; 3206 out_unlock: 3207 spin_unlock(&inode->i_lock); 3208 kfree(data); 3209 clear_layoutcommitting: 3210 pnfs_clear_layoutcommitting(inode); 3211 goto out; 3212 } 3213 EXPORT_SYMBOL_GPL(pnfs_layoutcommit_inode); 3214 3215 int 3216 pnfs_generic_sync(struct inode *inode, bool datasync) 3217 { 3218 return pnfs_layoutcommit_inode(inode, true); 3219 } 3220 EXPORT_SYMBOL_GPL(pnfs_generic_sync); 3221 3222 struct nfs4_threshold *pnfs_mdsthreshold_alloc(void) 3223 { 3224 struct nfs4_threshold *thp; 3225 3226 thp = kzalloc(sizeof(*thp), GFP_NOFS); 3227 if (!thp) { 3228 dprintk("%s mdsthreshold allocation failed\n", __func__); 3229 return NULL; 3230 } 3231 return thp; 3232 } 3233 3234 #if IS_ENABLED(CONFIG_NFS_V4_2) 3235 int 3236 pnfs_report_layoutstat(struct inode *inode, gfp_t gfp_flags) 3237 { 3238 struct pnfs_layoutdriver_type *ld = NFS_SERVER(inode)->pnfs_curr_ld; 3239 struct nfs_server *server = NFS_SERVER(inode); 3240 struct nfs_inode *nfsi = NFS_I(inode); 3241 struct nfs42_layoutstat_data *data; 3242 struct pnfs_layout_hdr *hdr; 3243 int status = 0; 3244 3245 if (!pnfs_enabled_sb(server) || !ld->prepare_layoutstats) 3246 goto out; 3247 3248 if (!nfs_server_capable(inode, NFS_CAP_LAYOUTSTATS)) 3249 goto out; 3250 3251 if (test_and_set_bit(NFS_INO_LAYOUTSTATS, &nfsi->flags)) 3252 goto out; 3253 3254 spin_lock(&inode->i_lock); 3255 if (!NFS_I(inode)->layout) { 3256 spin_unlock(&inode->i_lock); 3257 goto out_clear_layoutstats; 3258 } 3259 hdr = NFS_I(inode)->layout; 3260 pnfs_get_layout_hdr(hdr); 3261 spin_unlock(&inode->i_lock); 3262 3263 data = kzalloc(sizeof(*data), gfp_flags); 3264 if (!data) { 3265 status = -ENOMEM; 3266 goto out_put; 3267 } 3268 3269 data->args.fh = NFS_FH(inode); 3270 data->args.inode = inode; 3271 status = ld->prepare_layoutstats(&data->args); 3272 if (status) 3273 goto out_free; 3274 3275 status = nfs42_proc_layoutstats_generic(NFS_SERVER(inode), data); 3276 3277 out: 3278 dprintk("%s returns %d\n", __func__, status); 3279 return status; 3280 3281 out_free: 3282 kfree(data); 3283 out_put: 3284 pnfs_put_layout_hdr(hdr); 3285 out_clear_layoutstats: 3286 smp_mb__before_atomic(); 3287 clear_bit(NFS_INO_LAYOUTSTATS, &nfsi->flags); 3288 smp_mb__after_atomic(); 3289 goto out; 3290 } 3291 EXPORT_SYMBOL_GPL(pnfs_report_layoutstat); 3292 #endif 3293 3294 unsigned int layoutstats_timer; 3295 module_param(layoutstats_timer, uint, 0644); 3296 EXPORT_SYMBOL_GPL(layoutstats_timer); 3297