1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * extent_map.c 4 * 5 * Block/Cluster mapping functions 6 * 7 * Copyright (C) 2004 Oracle. All rights reserved. 8 */ 9 10 #include <linux/fs.h> 11 #include <linux/init.h> 12 #include <linux/slab.h> 13 #include <linux/types.h> 14 #include <linux/fiemap.h> 15 16 #include <cluster/masklog.h> 17 18 #include "ocfs2.h" 19 20 #include "alloc.h" 21 #include "dlmglue.h" 22 #include "extent_map.h" 23 #include "inode.h" 24 #include "super.h" 25 #include "symlink.h" 26 #include "aops.h" 27 #include "ocfs2_trace.h" 28 29 #include "buffer_head_io.h" 30 31 /* 32 * The extent caching implementation is intentionally trivial. 33 * 34 * We only cache a small number of extents stored directly on the 35 * inode, so linear order operations are acceptable. If we ever want 36 * to increase the size of the extent map, then these algorithms must 37 * get smarter. 38 */ 39 40 void ocfs2_extent_map_init(struct inode *inode) 41 { 42 struct ocfs2_inode_info *oi = OCFS2_I(inode); 43 44 oi->ip_extent_map.em_num_items = 0; 45 INIT_LIST_HEAD(&oi->ip_extent_map.em_list); 46 } 47 48 static void __ocfs2_extent_map_lookup(struct ocfs2_extent_map *em, 49 unsigned int cpos, 50 struct ocfs2_extent_map_item **ret_emi) 51 { 52 unsigned int range; 53 struct ocfs2_extent_map_item *emi; 54 55 *ret_emi = NULL; 56 57 list_for_each_entry(emi, &em->em_list, ei_list) { 58 range = emi->ei_cpos + emi->ei_clusters; 59 60 if (cpos >= emi->ei_cpos && cpos < range) { 61 list_move(&emi->ei_list, &em->em_list); 62 63 *ret_emi = emi; 64 break; 65 } 66 } 67 } 68 69 static int ocfs2_extent_map_lookup(struct inode *inode, unsigned int cpos, 70 unsigned int *phys, unsigned int *len, 71 unsigned int *flags) 72 { 73 unsigned int coff; 74 struct ocfs2_inode_info *oi = OCFS2_I(inode); 75 struct ocfs2_extent_map_item *emi; 76 77 spin_lock(&oi->ip_lock); 78 79 __ocfs2_extent_map_lookup(&oi->ip_extent_map, cpos, &emi); 80 if (emi) { 81 coff = cpos - emi->ei_cpos; 82 *phys = emi->ei_phys + coff; 83 if (len) 84 *len = emi->ei_clusters - coff; 85 if (flags) 86 *flags = emi->ei_flags; 87 } 88 89 spin_unlock(&oi->ip_lock); 90 91 if (emi == NULL) 92 return -ENOENT; 93 94 return 0; 95 } 96 97 /* 98 * Forget about all clusters equal to or greater than cpos. 99 */ 100 void ocfs2_extent_map_trunc(struct inode *inode, unsigned int cpos) 101 { 102 struct ocfs2_extent_map_item *emi, *n; 103 struct ocfs2_inode_info *oi = OCFS2_I(inode); 104 struct ocfs2_extent_map *em = &oi->ip_extent_map; 105 LIST_HEAD(tmp_list); 106 unsigned int range; 107 108 spin_lock(&oi->ip_lock); 109 list_for_each_entry_safe(emi, n, &em->em_list, ei_list) { 110 if (emi->ei_cpos >= cpos) { 111 /* Full truncate of this record. */ 112 list_move(&emi->ei_list, &tmp_list); 113 BUG_ON(em->em_num_items == 0); 114 em->em_num_items--; 115 continue; 116 } 117 118 range = emi->ei_cpos + emi->ei_clusters; 119 if (range > cpos) { 120 /* Partial truncate */ 121 emi->ei_clusters = cpos - emi->ei_cpos; 122 } 123 } 124 spin_unlock(&oi->ip_lock); 125 126 list_for_each_entry_safe(emi, n, &tmp_list, ei_list) { 127 list_del(&emi->ei_list); 128 kfree(emi); 129 } 130 } 131 132 /* 133 * Is any part of emi2 contained within emi1 134 */ 135 static int ocfs2_ei_is_contained(struct ocfs2_extent_map_item *emi1, 136 struct ocfs2_extent_map_item *emi2) 137 { 138 unsigned int range1, range2; 139 140 /* 141 * Check if logical start of emi2 is inside emi1 142 */ 143 range1 = emi1->ei_cpos + emi1->ei_clusters; 144 if (emi2->ei_cpos >= emi1->ei_cpos && emi2->ei_cpos < range1) 145 return 1; 146 147 /* 148 * Check if logical end of emi2 is inside emi1 149 */ 150 range2 = emi2->ei_cpos + emi2->ei_clusters; 151 if (range2 > emi1->ei_cpos && range2 <= range1) 152 return 1; 153 154 return 0; 155 } 156 157 static void ocfs2_copy_emi_fields(struct ocfs2_extent_map_item *dest, 158 struct ocfs2_extent_map_item *src) 159 { 160 dest->ei_cpos = src->ei_cpos; 161 dest->ei_phys = src->ei_phys; 162 dest->ei_clusters = src->ei_clusters; 163 dest->ei_flags = src->ei_flags; 164 } 165 166 /* 167 * Try to merge emi with ins. Returns 1 if merge succeeds, zero 168 * otherwise. 169 */ 170 static int ocfs2_try_to_merge_extent_map(struct ocfs2_extent_map_item *emi, 171 struct ocfs2_extent_map_item *ins) 172 { 173 /* 174 * Handle contiguousness 175 */ 176 if (ins->ei_phys == (emi->ei_phys + emi->ei_clusters) && 177 ins->ei_cpos == (emi->ei_cpos + emi->ei_clusters) && 178 ins->ei_flags == emi->ei_flags) { 179 emi->ei_clusters += ins->ei_clusters; 180 return 1; 181 } else if ((ins->ei_phys + ins->ei_clusters) == emi->ei_phys && 182 (ins->ei_cpos + ins->ei_clusters) == emi->ei_cpos && 183 ins->ei_flags == emi->ei_flags) { 184 emi->ei_phys = ins->ei_phys; 185 emi->ei_cpos = ins->ei_cpos; 186 emi->ei_clusters += ins->ei_clusters; 187 return 1; 188 } 189 190 /* 191 * Overlapping extents - this shouldn't happen unless we've 192 * split an extent to change it's flags. That is exceedingly 193 * rare, so there's no sense in trying to optimize it yet. 194 */ 195 if (ocfs2_ei_is_contained(emi, ins) || 196 ocfs2_ei_is_contained(ins, emi)) { 197 ocfs2_copy_emi_fields(emi, ins); 198 return 1; 199 } 200 201 /* No merge was possible. */ 202 return 0; 203 } 204 205 /* 206 * In order to reduce complexity on the caller, this insert function 207 * is intentionally liberal in what it will accept. 208 * 209 * The only rule is that the truncate call *must* be used whenever 210 * records have been deleted. This avoids inserting overlapping 211 * records with different physical mappings. 212 */ 213 void ocfs2_extent_map_insert_rec(struct inode *inode, 214 struct ocfs2_extent_rec *rec) 215 { 216 struct ocfs2_inode_info *oi = OCFS2_I(inode); 217 struct ocfs2_extent_map *em = &oi->ip_extent_map; 218 struct ocfs2_extent_map_item *emi, *new_emi = NULL; 219 struct ocfs2_extent_map_item ins; 220 221 ins.ei_cpos = le32_to_cpu(rec->e_cpos); 222 ins.ei_phys = ocfs2_blocks_to_clusters(inode->i_sb, 223 le64_to_cpu(rec->e_blkno)); 224 ins.ei_clusters = le16_to_cpu(rec->e_leaf_clusters); 225 ins.ei_flags = rec->e_flags; 226 227 search: 228 spin_lock(&oi->ip_lock); 229 230 list_for_each_entry(emi, &em->em_list, ei_list) { 231 if (ocfs2_try_to_merge_extent_map(emi, &ins)) { 232 list_move(&emi->ei_list, &em->em_list); 233 spin_unlock(&oi->ip_lock); 234 goto out; 235 } 236 } 237 238 /* 239 * No item could be merged. 240 * 241 * Either allocate and add a new item, or overwrite the last recently 242 * inserted. 243 */ 244 245 if (em->em_num_items < OCFS2_MAX_EXTENT_MAP_ITEMS) { 246 if (new_emi == NULL) { 247 spin_unlock(&oi->ip_lock); 248 249 new_emi = kmalloc(sizeof(*new_emi), GFP_NOFS); 250 if (new_emi == NULL) 251 goto out; 252 253 goto search; 254 } 255 256 ocfs2_copy_emi_fields(new_emi, &ins); 257 list_add(&new_emi->ei_list, &em->em_list); 258 em->em_num_items++; 259 new_emi = NULL; 260 } else { 261 BUG_ON(list_empty(&em->em_list) || em->em_num_items == 0); 262 emi = list_entry(em->em_list.prev, 263 struct ocfs2_extent_map_item, ei_list); 264 list_move(&emi->ei_list, &em->em_list); 265 ocfs2_copy_emi_fields(emi, &ins); 266 } 267 268 spin_unlock(&oi->ip_lock); 269 270 out: 271 kfree(new_emi); 272 } 273 274 static int ocfs2_last_eb_is_empty(struct inode *inode, 275 struct ocfs2_dinode *di) 276 { 277 int ret, next_free; 278 u64 last_eb_blk = le64_to_cpu(di->i_last_eb_blk); 279 struct buffer_head *eb_bh = NULL; 280 struct ocfs2_extent_block *eb; 281 struct ocfs2_extent_list *el; 282 283 ret = ocfs2_read_extent_block(INODE_CACHE(inode), last_eb_blk, &eb_bh); 284 if (ret) { 285 mlog_errno(ret); 286 goto out; 287 } 288 289 eb = (struct ocfs2_extent_block *) eb_bh->b_data; 290 el = &eb->h_list; 291 292 if (el->l_tree_depth) { 293 ocfs2_error(inode->i_sb, 294 "Inode %lu has non zero tree depth in leaf block %llu\n", 295 inode->i_ino, 296 (unsigned long long)eb_bh->b_blocknr); 297 ret = -EROFS; 298 goto out; 299 } 300 301 next_free = le16_to_cpu(el->l_next_free_rec); 302 303 if (next_free == 0 || 304 (next_free == 1 && ocfs2_is_empty_extent(&el->l_recs[0]))) 305 ret = 1; 306 307 out: 308 brelse(eb_bh); 309 return ret; 310 } 311 312 /* 313 * Return the 1st index within el which contains an extent start 314 * larger than v_cluster. 315 */ 316 static int ocfs2_search_for_hole_index(struct ocfs2_extent_list *el, 317 u32 v_cluster) 318 { 319 int i; 320 struct ocfs2_extent_rec *rec; 321 322 for(i = 0; i < le16_to_cpu(el->l_next_free_rec); i++) { 323 rec = &el->l_recs[i]; 324 325 if (v_cluster < le32_to_cpu(rec->e_cpos)) 326 break; 327 } 328 329 return i; 330 } 331 332 /* 333 * Figure out the size of a hole which starts at v_cluster within the given 334 * extent list. 335 * 336 * If there is no more allocation past v_cluster, we return the maximum 337 * cluster size minus v_cluster. 338 * 339 * If we have in-inode extents, then el points to the dinode list and 340 * eb_bh is NULL. Otherwise, eb_bh should point to the extent block 341 * containing el. 342 */ 343 int ocfs2_figure_hole_clusters(struct ocfs2_caching_info *ci, 344 struct ocfs2_extent_list *el, 345 struct buffer_head *eb_bh, 346 u32 v_cluster, 347 u32 *num_clusters) 348 { 349 int ret, i; 350 struct buffer_head *next_eb_bh = NULL; 351 struct ocfs2_extent_block *eb, *next_eb; 352 353 i = ocfs2_search_for_hole_index(el, v_cluster); 354 355 if (i == le16_to_cpu(el->l_next_free_rec) && eb_bh) { 356 eb = (struct ocfs2_extent_block *)eb_bh->b_data; 357 358 /* 359 * Check the next leaf for any extents. 360 */ 361 362 if (le64_to_cpu(eb->h_next_leaf_blk) == 0ULL) 363 goto no_more_extents; 364 365 ret = ocfs2_read_extent_block(ci, 366 le64_to_cpu(eb->h_next_leaf_blk), 367 &next_eb_bh); 368 if (ret) { 369 mlog_errno(ret); 370 goto out; 371 } 372 373 next_eb = (struct ocfs2_extent_block *)next_eb_bh->b_data; 374 el = &next_eb->h_list; 375 i = ocfs2_search_for_hole_index(el, v_cluster); 376 } 377 378 no_more_extents: 379 if (i == le16_to_cpu(el->l_next_free_rec)) { 380 /* 381 * We're at the end of our existing allocation. Just 382 * return the maximum number of clusters we could 383 * possibly allocate. 384 */ 385 *num_clusters = UINT_MAX - v_cluster; 386 } else { 387 *num_clusters = le32_to_cpu(el->l_recs[i].e_cpos) - v_cluster; 388 } 389 390 ret = 0; 391 out: 392 brelse(next_eb_bh); 393 return ret; 394 } 395 396 static int ocfs2_get_clusters_nocache(struct inode *inode, 397 struct buffer_head *di_bh, 398 u32 v_cluster, unsigned int *hole_len, 399 struct ocfs2_extent_rec *ret_rec, 400 unsigned int *is_last) 401 { 402 int i, ret, tree_height, len; 403 struct ocfs2_dinode *di; 404 struct ocfs2_extent_block *eb; 405 struct ocfs2_extent_list *el; 406 struct ocfs2_extent_rec *rec; 407 struct buffer_head *eb_bh = NULL; 408 409 memset(ret_rec, 0, sizeof(*ret_rec)); 410 if (is_last) 411 *is_last = 0; 412 413 di = (struct ocfs2_dinode *) di_bh->b_data; 414 el = &di->id2.i_list; 415 tree_height = le16_to_cpu(el->l_tree_depth); 416 417 if (tree_height > 0) { 418 ret = ocfs2_find_leaf(INODE_CACHE(inode), el, v_cluster, 419 &eb_bh); 420 if (ret) { 421 mlog_errno(ret); 422 goto out; 423 } 424 425 eb = (struct ocfs2_extent_block *) eb_bh->b_data; 426 el = &eb->h_list; 427 428 if (el->l_tree_depth) { 429 ocfs2_error(inode->i_sb, 430 "Inode %lu has non zero tree depth in leaf block %llu\n", 431 inode->i_ino, 432 (unsigned long long)eb_bh->b_blocknr); 433 ret = -EROFS; 434 goto out; 435 } 436 } 437 438 i = ocfs2_search_extent_list(el, v_cluster); 439 if (i == -1) { 440 /* 441 * Holes can be larger than the maximum size of an 442 * extent, so we return their lengths in a separate 443 * field. 444 */ 445 if (hole_len) { 446 ret = ocfs2_figure_hole_clusters(INODE_CACHE(inode), 447 el, eb_bh, 448 v_cluster, &len); 449 if (ret) { 450 mlog_errno(ret); 451 goto out; 452 } 453 454 *hole_len = len; 455 } 456 goto out_hole; 457 } 458 459 rec = &el->l_recs[i]; 460 461 BUG_ON(v_cluster < le32_to_cpu(rec->e_cpos)); 462 463 if (!rec->e_blkno) { 464 ocfs2_error(inode->i_sb, 465 "Inode %lu has bad extent record (%u, %u, 0)\n", 466 inode->i_ino, 467 le32_to_cpu(rec->e_cpos), 468 ocfs2_rec_clusters(el, rec)); 469 ret = -EROFS; 470 goto out; 471 } 472 473 *ret_rec = *rec; 474 475 /* 476 * Checking for last extent is potentially expensive - we 477 * might have to look at the next leaf over to see if it's 478 * empty. 479 * 480 * The first two checks are to see whether the caller even 481 * cares for this information, and if the extent is at least 482 * the last in it's list. 483 * 484 * If those hold true, then the extent is last if any of the 485 * additional conditions hold true: 486 * - Extent list is in-inode 487 * - Extent list is right-most 488 * - Extent list is 2nd to rightmost, with empty right-most 489 */ 490 if (is_last) { 491 if (i == (le16_to_cpu(el->l_next_free_rec) - 1)) { 492 if (tree_height == 0) 493 *is_last = 1; 494 else if (eb->h_blkno == di->i_last_eb_blk) 495 *is_last = 1; 496 else if (eb->h_next_leaf_blk == di->i_last_eb_blk) { 497 ret = ocfs2_last_eb_is_empty(inode, di); 498 if (ret < 0) { 499 mlog_errno(ret); 500 goto out; 501 } 502 if (ret == 1) 503 *is_last = 1; 504 } 505 } 506 } 507 508 out_hole: 509 ret = 0; 510 out: 511 brelse(eb_bh); 512 return ret; 513 } 514 515 static void ocfs2_relative_extent_offsets(struct super_block *sb, 516 u32 v_cluster, 517 struct ocfs2_extent_rec *rec, 518 u32 *p_cluster, u32 *num_clusters) 519 520 { 521 u32 coff = v_cluster - le32_to_cpu(rec->e_cpos); 522 523 *p_cluster = ocfs2_blocks_to_clusters(sb, le64_to_cpu(rec->e_blkno)); 524 *p_cluster = *p_cluster + coff; 525 526 if (num_clusters) 527 *num_clusters = le16_to_cpu(rec->e_leaf_clusters) - coff; 528 } 529 530 int ocfs2_xattr_get_clusters(struct inode *inode, u32 v_cluster, 531 u32 *p_cluster, u32 *num_clusters, 532 struct ocfs2_extent_list *el, 533 unsigned int *extent_flags) 534 { 535 int ret = 0, i; 536 struct buffer_head *eb_bh = NULL; 537 struct ocfs2_extent_block *eb; 538 struct ocfs2_extent_rec *rec; 539 u32 coff; 540 541 if (el->l_tree_depth) { 542 ret = ocfs2_find_leaf(INODE_CACHE(inode), el, v_cluster, 543 &eb_bh); 544 if (ret) { 545 mlog_errno(ret); 546 goto out; 547 } 548 549 eb = (struct ocfs2_extent_block *) eb_bh->b_data; 550 el = &eb->h_list; 551 552 if (el->l_tree_depth) { 553 ocfs2_error(inode->i_sb, 554 "Inode %lu has non zero tree depth in xattr leaf block %llu\n", 555 inode->i_ino, 556 (unsigned long long)eb_bh->b_blocknr); 557 ret = -EROFS; 558 goto out; 559 } 560 } 561 562 i = ocfs2_search_extent_list(el, v_cluster); 563 if (i == -1) { 564 ret = -EROFS; 565 mlog_errno(ret); 566 goto out; 567 } else { 568 rec = &el->l_recs[i]; 569 BUG_ON(v_cluster < le32_to_cpu(rec->e_cpos)); 570 571 if (!rec->e_blkno) { 572 ocfs2_error(inode->i_sb, 573 "Inode %lu has bad extent record (%u, %u, 0) in xattr\n", 574 inode->i_ino, 575 le32_to_cpu(rec->e_cpos), 576 ocfs2_rec_clusters(el, rec)); 577 ret = -EROFS; 578 goto out; 579 } 580 coff = v_cluster - le32_to_cpu(rec->e_cpos); 581 *p_cluster = ocfs2_blocks_to_clusters(inode->i_sb, 582 le64_to_cpu(rec->e_blkno)); 583 *p_cluster = *p_cluster + coff; 584 if (num_clusters) 585 *num_clusters = ocfs2_rec_clusters(el, rec) - coff; 586 587 if (extent_flags) 588 *extent_flags = rec->e_flags; 589 } 590 out: 591 brelse(eb_bh); 592 return ret; 593 } 594 595 int ocfs2_get_clusters(struct inode *inode, u32 v_cluster, 596 u32 *p_cluster, u32 *num_clusters, 597 unsigned int *extent_flags) 598 { 599 int ret; 600 unsigned int hole_len, flags = 0; 601 struct buffer_head *di_bh = NULL; 602 struct ocfs2_extent_rec rec; 603 604 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) { 605 ret = -ERANGE; 606 mlog_errno(ret); 607 goto out; 608 } 609 610 ret = ocfs2_extent_map_lookup(inode, v_cluster, p_cluster, 611 num_clusters, extent_flags); 612 if (ret == 0) 613 goto out; 614 615 ret = ocfs2_read_inode_block(inode, &di_bh); 616 if (ret) { 617 mlog_errno(ret); 618 goto out; 619 } 620 621 ret = ocfs2_get_clusters_nocache(inode, di_bh, v_cluster, &hole_len, 622 &rec, NULL); 623 if (ret) { 624 mlog_errno(ret); 625 goto out; 626 } 627 628 if (rec.e_blkno == 0ULL) { 629 /* 630 * A hole was found. Return some canned values that 631 * callers can key on. If asked for, num_clusters will 632 * be populated with the size of the hole. 633 */ 634 *p_cluster = 0; 635 if (num_clusters) { 636 *num_clusters = hole_len; 637 } 638 } else { 639 ocfs2_relative_extent_offsets(inode->i_sb, v_cluster, &rec, 640 p_cluster, num_clusters); 641 flags = rec.e_flags; 642 643 ocfs2_extent_map_insert_rec(inode, &rec); 644 } 645 646 if (extent_flags) 647 *extent_flags = flags; 648 649 out: 650 brelse(di_bh); 651 return ret; 652 } 653 654 /* 655 * This expects alloc_sem to be held. The allocation cannot change at 656 * all while the map is in the process of being updated. 657 */ 658 int ocfs2_extent_map_get_blocks(struct inode *inode, u64 v_blkno, u64 *p_blkno, 659 u64 *ret_count, unsigned int *extent_flags) 660 { 661 int ret; 662 int bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1); 663 u32 cpos, num_clusters, p_cluster; 664 u64 boff = 0; 665 666 cpos = ocfs2_blocks_to_clusters(inode->i_sb, v_blkno); 667 668 ret = ocfs2_get_clusters(inode, cpos, &p_cluster, &num_clusters, 669 extent_flags); 670 if (ret) { 671 mlog_errno(ret); 672 goto out; 673 } 674 675 /* 676 * p_cluster == 0 indicates a hole. 677 */ 678 if (p_cluster) { 679 boff = ocfs2_clusters_to_blocks(inode->i_sb, p_cluster); 680 boff += (v_blkno & (u64)(bpc - 1)); 681 } 682 683 *p_blkno = boff; 684 685 if (ret_count) { 686 *ret_count = ocfs2_clusters_to_blocks(inode->i_sb, num_clusters); 687 *ret_count -= v_blkno & (u64)(bpc - 1); 688 } 689 690 out: 691 return ret; 692 } 693 694 /* 695 * The ocfs2_fiemap_inline() may be a little bit misleading, since 696 * it not only handles the fiemap for inlined files, but also deals 697 * with the fast symlink, cause they have no difference for extent 698 * mapping per se. 699 */ 700 static int ocfs2_fiemap_inline(struct inode *inode, struct buffer_head *di_bh, 701 struct fiemap_extent_info *fieinfo, 702 u64 map_start) 703 { 704 int ret; 705 unsigned int id_count; 706 struct ocfs2_dinode *di; 707 u64 phys; 708 u32 flags = FIEMAP_EXTENT_DATA_INLINE|FIEMAP_EXTENT_LAST; 709 struct ocfs2_inode_info *oi = OCFS2_I(inode); 710 711 di = (struct ocfs2_dinode *)di_bh->b_data; 712 if (ocfs2_inode_is_fast_symlink(inode)) 713 id_count = ocfs2_fast_symlink_chars(inode->i_sb); 714 else 715 id_count = le16_to_cpu(di->id2.i_data.id_count); 716 717 if (map_start < id_count) { 718 phys = oi->ip_blkno << inode->i_sb->s_blocksize_bits; 719 if (ocfs2_inode_is_fast_symlink(inode)) 720 phys += offsetof(struct ocfs2_dinode, id2.i_symlink); 721 else 722 phys += offsetof(struct ocfs2_dinode, 723 id2.i_data.id_data); 724 725 ret = fiemap_fill_next_extent(fieinfo, 0, phys, id_count, 726 flags); 727 if (ret < 0) 728 return ret; 729 } 730 731 return 0; 732 } 733 734 int ocfs2_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, 735 u64 map_start, u64 map_len) 736 { 737 int ret, is_last; 738 u32 mapping_end, cpos; 739 unsigned int hole_size; 740 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 741 u64 len_bytes, phys_bytes, virt_bytes; 742 struct buffer_head *di_bh = NULL; 743 struct ocfs2_extent_rec rec; 744 745 ret = fiemap_prep(inode, fieinfo, map_start, &map_len, 0); 746 if (ret) 747 return ret; 748 749 ret = ocfs2_inode_lock(inode, &di_bh, 0); 750 if (ret) { 751 mlog_errno(ret); 752 goto out; 753 } 754 755 down_read(&OCFS2_I(inode)->ip_alloc_sem); 756 757 /* 758 * Handle inline-data and fast symlink separately. 759 */ 760 if ((OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) || 761 ocfs2_inode_is_fast_symlink(inode)) { 762 ret = ocfs2_fiemap_inline(inode, di_bh, fieinfo, map_start); 763 goto out_unlock; 764 } 765 766 cpos = map_start >> osb->s_clustersize_bits; 767 mapping_end = ocfs2_clusters_for_bytes(inode->i_sb, 768 map_start + map_len); 769 is_last = 0; 770 while (cpos < mapping_end && !is_last) { 771 u32 fe_flags; 772 773 ret = ocfs2_get_clusters_nocache(inode, di_bh, cpos, 774 &hole_size, &rec, &is_last); 775 if (ret) { 776 mlog_errno(ret); 777 goto out_unlock; 778 } 779 780 if (rec.e_blkno == 0ULL) { 781 cpos += hole_size; 782 continue; 783 } 784 785 fe_flags = 0; 786 if (rec.e_flags & OCFS2_EXT_UNWRITTEN) 787 fe_flags |= FIEMAP_EXTENT_UNWRITTEN; 788 if (rec.e_flags & OCFS2_EXT_REFCOUNTED) 789 fe_flags |= FIEMAP_EXTENT_SHARED; 790 if (is_last) 791 fe_flags |= FIEMAP_EXTENT_LAST; 792 len_bytes = (u64)le16_to_cpu(rec.e_leaf_clusters) << osb->s_clustersize_bits; 793 phys_bytes = le64_to_cpu(rec.e_blkno) << osb->sb->s_blocksize_bits; 794 virt_bytes = (u64)le32_to_cpu(rec.e_cpos) << osb->s_clustersize_bits; 795 796 ret = fiemap_fill_next_extent(fieinfo, virt_bytes, phys_bytes, 797 len_bytes, fe_flags); 798 if (ret) 799 break; 800 801 cpos = le32_to_cpu(rec.e_cpos)+ le16_to_cpu(rec.e_leaf_clusters); 802 } 803 804 if (ret > 0) 805 ret = 0; 806 807 out_unlock: 808 brelse(di_bh); 809 810 up_read(&OCFS2_I(inode)->ip_alloc_sem); 811 812 ocfs2_inode_unlock(inode, 0); 813 out: 814 815 return ret; 816 } 817 818 /* Is IO overwriting allocated blocks? */ 819 int ocfs2_overwrite_io(struct inode *inode, struct buffer_head *di_bh, 820 u64 map_start, u64 map_len) 821 { 822 int ret = 0, is_last; 823 u32 mapping_end, cpos; 824 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 825 struct ocfs2_extent_rec rec; 826 827 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) { 828 if (ocfs2_size_fits_inline_data(di_bh, map_start + map_len)) 829 return ret; 830 else 831 return -EAGAIN; 832 } 833 834 cpos = map_start >> osb->s_clustersize_bits; 835 mapping_end = ocfs2_clusters_for_bytes(inode->i_sb, 836 map_start + map_len); 837 is_last = 0; 838 while (cpos < mapping_end && !is_last) { 839 ret = ocfs2_get_clusters_nocache(inode, di_bh, cpos, 840 NULL, &rec, &is_last); 841 if (ret) { 842 mlog_errno(ret); 843 goto out; 844 } 845 846 if (rec.e_blkno == 0ULL) 847 break; 848 849 if (rec.e_flags & OCFS2_EXT_REFCOUNTED) 850 break; 851 852 cpos = le32_to_cpu(rec.e_cpos) + 853 le16_to_cpu(rec.e_leaf_clusters); 854 } 855 856 if (cpos < mapping_end) 857 ret = -EAGAIN; 858 out: 859 return ret; 860 } 861 862 int ocfs2_seek_data_hole_offset(struct file *file, loff_t *offset, int whence) 863 { 864 struct inode *inode = file->f_mapping->host; 865 int ret; 866 unsigned int is_last = 0, is_data = 0; 867 u16 cs_bits = OCFS2_SB(inode->i_sb)->s_clustersize_bits; 868 u32 cpos, cend, clen, hole_size; 869 u64 extoff, extlen; 870 struct buffer_head *di_bh = NULL; 871 struct ocfs2_extent_rec rec; 872 873 BUG_ON(whence != SEEK_DATA && whence != SEEK_HOLE); 874 875 ret = ocfs2_inode_lock(inode, &di_bh, 0); 876 if (ret) { 877 mlog_errno(ret); 878 goto out; 879 } 880 881 down_read(&OCFS2_I(inode)->ip_alloc_sem); 882 883 if (*offset >= i_size_read(inode)) { 884 ret = -ENXIO; 885 goto out_unlock; 886 } 887 888 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) { 889 if (whence == SEEK_HOLE) 890 *offset = i_size_read(inode); 891 goto out_unlock; 892 } 893 894 clen = 0; 895 cpos = *offset >> cs_bits; 896 cend = ocfs2_clusters_for_bytes(inode->i_sb, i_size_read(inode)); 897 898 while (cpos < cend && !is_last) { 899 ret = ocfs2_get_clusters_nocache(inode, di_bh, cpos, &hole_size, 900 &rec, &is_last); 901 if (ret) { 902 mlog_errno(ret); 903 goto out_unlock; 904 } 905 906 extoff = cpos; 907 extoff <<= cs_bits; 908 909 if (rec.e_blkno == 0ULL) { 910 clen = hole_size; 911 is_data = 0; 912 } else { 913 clen = le16_to_cpu(rec.e_leaf_clusters) - 914 (cpos - le32_to_cpu(rec.e_cpos)); 915 is_data = (rec.e_flags & OCFS2_EXT_UNWRITTEN) ? 0 : 1; 916 } 917 918 if ((!is_data && whence == SEEK_HOLE) || 919 (is_data && whence == SEEK_DATA)) { 920 if (extoff > *offset) 921 *offset = extoff; 922 goto out_unlock; 923 } 924 925 if (!is_last) 926 cpos += clen; 927 } 928 929 if (whence == SEEK_HOLE) { 930 extoff = cpos; 931 extoff <<= cs_bits; 932 extlen = clen; 933 extlen <<= cs_bits; 934 935 if ((extoff + extlen) > i_size_read(inode)) 936 extlen = i_size_read(inode) - extoff; 937 extoff += extlen; 938 if (extoff > *offset) 939 *offset = extoff; 940 goto out_unlock; 941 } 942 943 ret = -ENXIO; 944 945 out_unlock: 946 947 brelse(di_bh); 948 949 up_read(&OCFS2_I(inode)->ip_alloc_sem); 950 951 ocfs2_inode_unlock(inode, 0); 952 out: 953 return ret; 954 } 955 956 int ocfs2_read_virt_blocks(struct inode *inode, u64 v_block, int nr, 957 struct buffer_head *bhs[], int flags, 958 int (*validate)(struct super_block *sb, 959 struct buffer_head *bh)) 960 { 961 int rc = 0; 962 u64 p_block, p_count; 963 int i, count, done = 0; 964 965 trace_ocfs2_read_virt_blocks( 966 inode, (unsigned long long)v_block, nr, bhs, flags, 967 validate); 968 969 if (((v_block + nr - 1) << inode->i_sb->s_blocksize_bits) >= 970 i_size_read(inode)) { 971 BUG_ON(!(flags & OCFS2_BH_READAHEAD)); 972 goto out; 973 } 974 975 while (done < nr) { 976 down_read(&OCFS2_I(inode)->ip_alloc_sem); 977 rc = ocfs2_extent_map_get_blocks(inode, v_block + done, 978 &p_block, &p_count, NULL); 979 up_read(&OCFS2_I(inode)->ip_alloc_sem); 980 if (rc) { 981 mlog_errno(rc); 982 break; 983 } 984 985 if (!p_block) { 986 rc = -EIO; 987 mlog(ML_ERROR, 988 "Inode #%llu contains a hole at offset %llu\n", 989 (unsigned long long)OCFS2_I(inode)->ip_blkno, 990 (unsigned long long)(v_block + done) << 991 inode->i_sb->s_blocksize_bits); 992 break; 993 } 994 995 count = nr - done; 996 if (p_count < count) 997 count = p_count; 998 999 /* 1000 * If the caller passed us bhs, they should have come 1001 * from a previous readahead call to this function. Thus, 1002 * they should have the right b_blocknr. 1003 */ 1004 for (i = 0; i < count; i++) { 1005 if (!bhs[done + i]) 1006 continue; 1007 BUG_ON(bhs[done + i]->b_blocknr != (p_block + i)); 1008 } 1009 1010 rc = ocfs2_read_blocks(INODE_CACHE(inode), p_block, count, 1011 bhs + done, flags, validate); 1012 if (rc) { 1013 mlog_errno(rc); 1014 break; 1015 } 1016 done += count; 1017 } 1018 1019 out: 1020 return rc; 1021 } 1022 1023 1024