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