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