1 // SPDX-License-Identifier: GPL-2.0-only
5 * Block/Cluster mapping functions
7 * Copyright (C) 2004 Oracle. All rights reserved.
11 #include <linux/init.h>
12 #include <linux/slab.h>
13 #include <linux/types.h>
14 #include <linux/fiemap.h>
16 #include <cluster/masklog.h>
22 #include "extent_map.h"
27 #include "ocfs2_trace.h"
29 #include "buffer_head_io.h"
32 * The extent caching implementation is intentionally trivial.
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
40 void ocfs2_extent_map_init(struct inode
*inode
)
42 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
44 oi
->ip_extent_map
.em_num_items
= 0;
45 INIT_LIST_HEAD(&oi
->ip_extent_map
.em_list
);
48 static void __ocfs2_extent_map_lookup(struct ocfs2_extent_map
*em
,
50 struct ocfs2_extent_map_item
**ret_emi
)
53 struct ocfs2_extent_map_item
*emi
;
57 list_for_each_entry(emi
, &em
->em_list
, ei_list
) {
58 range
= emi
->ei_cpos
+ emi
->ei_clusters
;
60 if (cpos
>= emi
->ei_cpos
&& cpos
< range
) {
61 list_move(&emi
->ei_list
, &em
->em_list
);
69 static int ocfs2_extent_map_lookup(struct inode
*inode
, unsigned int cpos
,
70 unsigned int *phys
, unsigned int *len
,
74 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
75 struct ocfs2_extent_map_item
*emi
;
77 spin_lock(&oi
->ip_lock
);
79 __ocfs2_extent_map_lookup(&oi
->ip_extent_map
, cpos
, &emi
);
81 coff
= cpos
- emi
->ei_cpos
;
82 *phys
= emi
->ei_phys
+ coff
;
84 *len
= emi
->ei_clusters
- coff
;
86 *flags
= emi
->ei_flags
;
89 spin_unlock(&oi
->ip_lock
);
98 * Forget about all clusters equal to or greater than cpos.
100 void ocfs2_extent_map_trunc(struct inode
*inode
, unsigned int cpos
)
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
;
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);
118 range
= emi
->ei_cpos
+ emi
->ei_clusters
;
120 /* Partial truncate */
121 emi
->ei_clusters
= cpos
- emi
->ei_cpos
;
124 spin_unlock(&oi
->ip_lock
);
126 list_for_each_entry_safe(emi
, n
, &tmp_list
, ei_list
) {
127 list_del(&emi
->ei_list
);
133 * Is any part of emi2 contained within emi1
135 static int ocfs2_ei_is_contained(struct ocfs2_extent_map_item
*emi1
,
136 struct ocfs2_extent_map_item
*emi2
)
138 unsigned int range1
, range2
;
141 * Check if logical start of emi2 is inside emi1
143 range1
= emi1
->ei_cpos
+ emi1
->ei_clusters
;
144 if (emi2
->ei_cpos
>= emi1
->ei_cpos
&& emi2
->ei_cpos
< range1
)
148 * Check if logical end of emi2 is inside emi1
150 range2
= emi2
->ei_cpos
+ emi2
->ei_clusters
;
151 if (range2
> emi1
->ei_cpos
&& range2
<= range1
)
157 static void ocfs2_copy_emi_fields(struct ocfs2_extent_map_item
*dest
,
158 struct ocfs2_extent_map_item
*src
)
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
;
167 * Try to merge emi with ins. Returns 1 if merge succeeds, zero
170 static int ocfs2_try_to_merge_extent_map(struct ocfs2_extent_map_item
*emi
,
171 struct ocfs2_extent_map_item
*ins
)
174 * Handle contiguousness
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
;
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
;
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.
195 if (ocfs2_ei_is_contained(emi
, ins
) ||
196 ocfs2_ei_is_contained(ins
, emi
)) {
197 ocfs2_copy_emi_fields(emi
, ins
);
201 /* No merge was possible. */
206 * In order to reduce complexity on the caller, this insert function
207 * is intentionally liberal in what it will accept.
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.
213 void ocfs2_extent_map_insert_rec(struct inode
*inode
,
214 struct ocfs2_extent_rec
*rec
)
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
;
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
;
228 spin_lock(&oi
->ip_lock
);
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
);
239 * No item could be merged.
241 * Either allocate and add a new item, or overwrite the last recently
245 if (em
->em_num_items
< OCFS2_MAX_EXTENT_MAP_ITEMS
) {
246 if (new_emi
== NULL
) {
247 spin_unlock(&oi
->ip_lock
);
249 new_emi
= kmalloc(sizeof(*new_emi
), GFP_NOFS
);
256 ocfs2_copy_emi_fields(new_emi
, &ins
);
257 list_add(&new_emi
->ei_list
, &em
->em_list
);
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
);
268 spin_unlock(&oi
->ip_lock
);
274 static int ocfs2_last_eb_is_empty(struct inode
*inode
,
275 struct ocfs2_dinode
*di
)
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
;
283 ret
= ocfs2_read_extent_block(INODE_CACHE(inode
), last_eb_blk
, &eb_bh
);
289 eb
= (struct ocfs2_extent_block
*) eb_bh
->b_data
;
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",
296 (unsigned long long)eb_bh
->b_blocknr
);
301 next_free
= le16_to_cpu(el
->l_next_free_rec
);
303 if (next_free
== 0 ||
304 (next_free
== 1 && ocfs2_is_empty_extent(&el
->l_recs
[0])))
313 * Return the 1st index within el which contains an extent start
314 * larger than v_cluster.
316 static int ocfs2_search_for_hole_index(struct ocfs2_extent_list
*el
,
320 struct ocfs2_extent_rec
*rec
;
322 for(i
= 0; i
< le16_to_cpu(el
->l_next_free_rec
); i
++) {
323 rec
= &el
->l_recs
[i
];
325 if (v_cluster
< le32_to_cpu(rec
->e_cpos
))
333 * Figure out the size of a hole which starts at v_cluster within the given
336 * If there is no more allocation past v_cluster, we return the maximum
337 * cluster size minus v_cluster.
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
343 int ocfs2_figure_hole_clusters(struct ocfs2_caching_info
*ci
,
344 struct ocfs2_extent_list
*el
,
345 struct buffer_head
*eb_bh
,
350 struct buffer_head
*next_eb_bh
= NULL
;
351 struct ocfs2_extent_block
*eb
, *next_eb
;
353 i
= ocfs2_search_for_hole_index(el
, v_cluster
);
355 if (i
== le16_to_cpu(el
->l_next_free_rec
) && eb_bh
) {
356 eb
= (struct ocfs2_extent_block
*)eb_bh
->b_data
;
359 * Check the next leaf for any extents.
362 if (le64_to_cpu(eb
->h_next_leaf_blk
) == 0ULL)
363 goto no_more_extents
;
365 ret
= ocfs2_read_extent_block(ci
,
366 le64_to_cpu(eb
->h_next_leaf_blk
),
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
);
379 if (i
== le16_to_cpu(el
->l_next_free_rec
)) {
381 * We're at the end of our existing allocation. Just
382 * return the maximum number of clusters we could
385 *num_clusters
= UINT_MAX
- v_cluster
;
387 *num_clusters
= le32_to_cpu(el
->l_recs
[i
].e_cpos
) - v_cluster
;
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
)
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
;
409 memset(ret_rec
, 0, sizeof(*ret_rec
));
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
);
417 if (tree_height
> 0) {
418 ret
= ocfs2_find_leaf(INODE_CACHE(inode
), el
, v_cluster
,
425 eb
= (struct ocfs2_extent_block
*) eb_bh
->b_data
;
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",
432 (unsigned long long)eb_bh
->b_blocknr
);
438 i
= ocfs2_search_extent_list(el
, v_cluster
);
441 * Holes can be larger than the maximum size of an
442 * extent, so we return their lengths in a separate
446 ret
= ocfs2_figure_hole_clusters(INODE_CACHE(inode
),
459 rec
= &el
->l_recs
[i
];
461 BUG_ON(v_cluster
< le32_to_cpu(rec
->e_cpos
));
464 ocfs2_error(inode
->i_sb
,
465 "Inode %lu has bad extent record (%u, %u, 0)\n",
467 le32_to_cpu(rec
->e_cpos
),
468 ocfs2_rec_clusters(el
, rec
));
476 * Checking for last extent is potentially expensive - we
477 * might have to look at the next leaf over to see if it's
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.
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
491 if (i
== (le16_to_cpu(el
->l_next_free_rec
) - 1)) {
492 if (tree_height
== 0)
494 else if (eb
->h_blkno
== di
->i_last_eb_blk
)
496 else if (eb
->h_next_leaf_blk
== di
->i_last_eb_blk
) {
497 ret
= ocfs2_last_eb_is_empty(inode
, di
);
515 static void ocfs2_relative_extent_offsets(struct super_block
*sb
,
517 struct ocfs2_extent_rec
*rec
,
518 u32
*p_cluster
, u32
*num_clusters
)
521 u32 coff
= v_cluster
- le32_to_cpu(rec
->e_cpos
);
523 *p_cluster
= ocfs2_blocks_to_clusters(sb
, le64_to_cpu(rec
->e_blkno
));
524 *p_cluster
= *p_cluster
+ coff
;
527 *num_clusters
= le16_to_cpu(rec
->e_leaf_clusters
) - coff
;
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
)
536 struct buffer_head
*eb_bh
= NULL
;
537 struct ocfs2_extent_block
*eb
;
538 struct ocfs2_extent_rec
*rec
;
541 if (el
->l_tree_depth
) {
542 ret
= ocfs2_find_leaf(INODE_CACHE(inode
), el
, v_cluster
,
549 eb
= (struct ocfs2_extent_block
*) eb_bh
->b_data
;
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",
556 (unsigned long long)eb_bh
->b_blocknr
);
562 i
= ocfs2_search_extent_list(el
, v_cluster
);
568 rec
= &el
->l_recs
[i
];
569 BUG_ON(v_cluster
< le32_to_cpu(rec
->e_cpos
));
572 ocfs2_error(inode
->i_sb
,
573 "Inode %lu has bad extent record (%u, %u, 0) in xattr\n",
575 le32_to_cpu(rec
->e_cpos
),
576 ocfs2_rec_clusters(el
, rec
));
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
;
585 *num_clusters
= ocfs2_rec_clusters(el
, rec
) - coff
;
588 *extent_flags
= rec
->e_flags
;
595 int ocfs2_get_clusters(struct inode
*inode
, u32 v_cluster
,
596 u32
*p_cluster
, u32
*num_clusters
,
597 unsigned int *extent_flags
)
600 unsigned int hole_len
, flags
= 0;
601 struct buffer_head
*di_bh
= NULL
;
602 struct ocfs2_extent_rec rec
;
604 if (OCFS2_I(inode
)->ip_dyn_features
& OCFS2_INLINE_DATA_FL
) {
610 ret
= ocfs2_extent_map_lookup(inode
, v_cluster
, p_cluster
,
611 num_clusters
, extent_flags
);
615 ret
= ocfs2_read_inode_block(inode
, &di_bh
);
621 ret
= ocfs2_get_clusters_nocache(inode
, di_bh
, v_cluster
, &hole_len
,
628 if (rec
.e_blkno
== 0ULL) {
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.
636 *num_clusters
= hole_len
;
639 ocfs2_relative_extent_offsets(inode
->i_sb
, v_cluster
, &rec
,
640 p_cluster
, num_clusters
);
643 ocfs2_extent_map_insert_rec(inode
, &rec
);
647 *extent_flags
= flags
;
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.
658 int ocfs2_extent_map_get_blocks(struct inode
*inode
, u64 v_blkno
, u64
*p_blkno
,
659 u64
*ret_count
, unsigned int *extent_flags
)
662 int bpc
= ocfs2_clusters_to_blocks(inode
->i_sb
, 1);
663 u32 cpos
, num_clusters
, p_cluster
;
666 cpos
= ocfs2_blocks_to_clusters(inode
->i_sb
, v_blkno
);
668 ret
= ocfs2_get_clusters(inode
, cpos
, &p_cluster
, &num_clusters
,
676 * p_cluster == 0 indicates a hole.
679 boff
= ocfs2_clusters_to_blocks(inode
->i_sb
, p_cluster
);
680 boff
+= (v_blkno
& (u64
)(bpc
- 1));
686 *ret_count
= ocfs2_clusters_to_blocks(inode
->i_sb
, num_clusters
);
687 *ret_count
-= v_blkno
& (u64
)(bpc
- 1);
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
700 static int ocfs2_fiemap_inline(struct inode
*inode
, struct buffer_head
*di_bh
,
701 struct fiemap_extent_info
*fieinfo
,
705 unsigned int id_count
;
706 struct ocfs2_dinode
*di
;
708 u32 flags
= FIEMAP_EXTENT_DATA_INLINE
|FIEMAP_EXTENT_LAST
;
709 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
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
);
715 id_count
= le16_to_cpu(di
->id2
.i_data
.id_count
);
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
);
722 phys
+= offsetof(struct ocfs2_dinode
,
725 ret
= fiemap_fill_next_extent(fieinfo
, 0, phys
, id_count
,
734 int ocfs2_fiemap(struct inode
*inode
, struct fiemap_extent_info
*fieinfo
,
735 u64 map_start
, u64 map_len
)
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
;
745 ret
= fiemap_prep(inode
, fieinfo
, map_start
, &map_len
, 0);
749 ret
= ocfs2_inode_lock(inode
, &di_bh
, 0);
755 down_read(&OCFS2_I(inode
)->ip_alloc_sem
);
758 * Handle inline-data and fast symlink separately.
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
);
766 cpos
= map_start
>> osb
->s_clustersize_bits
;
767 mapping_end
= ocfs2_clusters_for_bytes(inode
->i_sb
,
768 map_start
+ map_len
);
770 while (cpos
< mapping_end
&& !is_last
) {
773 ret
= ocfs2_get_clusters_nocache(inode
, di_bh
, cpos
,
774 &hole_size
, &rec
, &is_last
);
780 if (rec
.e_blkno
== 0ULL) {
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
;
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
;
796 ret
= fiemap_fill_next_extent(fieinfo
, virt_bytes
, phys_bytes
,
797 len_bytes
, fe_flags
);
801 cpos
= le32_to_cpu(rec
.e_cpos
)+ le16_to_cpu(rec
.e_leaf_clusters
);
810 up_read(&OCFS2_I(inode
)->ip_alloc_sem
);
812 ocfs2_inode_unlock(inode
, 0);
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
)
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
;
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
))
834 cpos
= map_start
>> osb
->s_clustersize_bits
;
835 mapping_end
= ocfs2_clusters_for_bytes(inode
->i_sb
,
836 map_start
+ map_len
);
838 while (cpos
< mapping_end
&& !is_last
) {
839 ret
= ocfs2_get_clusters_nocache(inode
, di_bh
, cpos
,
840 NULL
, &rec
, &is_last
);
846 if (rec
.e_blkno
== 0ULL)
849 if (rec
.e_flags
& OCFS2_EXT_REFCOUNTED
)
852 cpos
= le32_to_cpu(rec
.e_cpos
) +
853 le16_to_cpu(rec
.e_leaf_clusters
);
856 if (cpos
< mapping_end
)
862 int ocfs2_seek_data_hole_offset(struct file
*file
, loff_t
*offset
, int whence
)
864 struct inode
*inode
= file
->f_mapping
->host
;
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
;
870 struct buffer_head
*di_bh
= NULL
;
871 struct ocfs2_extent_rec rec
;
873 BUG_ON(whence
!= SEEK_DATA
&& whence
!= SEEK_HOLE
);
875 ret
= ocfs2_inode_lock(inode
, &di_bh
, 0);
881 down_read(&OCFS2_I(inode
)->ip_alloc_sem
);
883 if (*offset
>= i_size_read(inode
)) {
888 if (OCFS2_I(inode
)->ip_dyn_features
& OCFS2_INLINE_DATA_FL
) {
889 if (whence
== SEEK_HOLE
)
890 *offset
= i_size_read(inode
);
895 cpos
= *offset
>> cs_bits
;
896 cend
= ocfs2_clusters_for_bytes(inode
->i_sb
, i_size_read(inode
));
898 while (cpos
< cend
&& !is_last
) {
899 ret
= ocfs2_get_clusters_nocache(inode
, di_bh
, cpos
, &hole_size
,
909 if (rec
.e_blkno
== 0ULL) {
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;
918 if ((!is_data
&& whence
== SEEK_HOLE
) ||
919 (is_data
&& whence
== SEEK_DATA
)) {
920 if (extoff
> *offset
)
929 if (whence
== SEEK_HOLE
) {
935 if ((extoff
+ extlen
) > i_size_read(inode
))
936 extlen
= i_size_read(inode
) - extoff
;
938 if (extoff
> *offset
)
949 up_read(&OCFS2_I(inode
)->ip_alloc_sem
);
951 ocfs2_inode_unlock(inode
, 0);
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
))
962 u64 p_block
, p_count
;
963 int i
, count
, done
= 0;
965 trace_ocfs2_read_virt_blocks(
966 inode
, (unsigned long long)v_block
, nr
, bhs
, flags
,
969 if (((v_block
+ nr
- 1) << inode
->i_sb
->s_blocksize_bits
) >=
970 i_size_read(inode
)) {
971 BUG_ON(!(flags
& OCFS2_BH_READAHEAD
));
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
);
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
);
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.
1004 for (i
= 0; i
< count
; i
++) {
1007 BUG_ON(bhs
[done
+ i
]->b_blocknr
!= (p_block
+ i
));
1010 rc
= ocfs2_read_blocks(INODE_CACHE(inode
), p_block
, count
,
1011 bhs
+ done
, flags
, validate
);