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