2 * Copyright (c) 2008,2009 NEC Software Tohoku, Ltd.
3 * Written by Takashi Sato <t-sato@yk.jp.nec.com>
4 * Akira Fujita <a-fujita@rs.jp.nec.com>
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of version 2.1 of the GNU Lesser General Public License
8 * as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
17 #include <linux/quotaops.h>
18 #include <linux/slab.h>
19 #include "ext4_jbd2.h"
21 #include "ext4_extents.h"
24 * get_ext_path - Find an extent path for designated logical block number.
26 * @inode: an inode which is searched
27 * @lblock: logical block number to find an extent path
28 * @path: pointer to an extent path pointer (for output)
30 * ext4_ext_find_extent wrapper. Return 0 on success, or a negative error value
34 get_ext_path(struct inode
*inode
, ext4_lblk_t lblock
,
35 struct ext4_ext_path
**orig_path
)
38 struct ext4_ext_path
*path
;
40 path
= ext4_ext_find_extent(inode
, lblock
, *orig_path
);
43 else if (path
[ext_depth(inode
)].p_ext
== NULL
)
52 * copy_extent_status - Copy the extent's initialization status
54 * @src: an extent for getting initialize status
55 * @dest: an extent to be set the status
58 copy_extent_status(struct ext4_extent
*src
, struct ext4_extent
*dest
)
60 if (ext4_ext_is_uninitialized(src
))
61 ext4_ext_mark_uninitialized(dest
);
63 dest
->ee_len
= cpu_to_le16(ext4_ext_get_actual_len(dest
));
67 * mext_next_extent - Search for the next extent and set it to "extent"
69 * @inode: inode which is searched
70 * @path: this will obtain data for the next extent
71 * @extent: pointer to the next extent we have just gotten
73 * Search the next extent in the array of ext4_ext_path structure (@path)
74 * and set it to ext4_extent structure (@extent). In addition, the member of
75 * @path (->p_ext) also points the next extent. Return 0 on success, 1 if
76 * ext4_ext_path structure refers to the last extent, or a negative error
80 mext_next_extent(struct inode
*inode
, struct ext4_ext_path
*path
,
81 struct ext4_extent
**extent
)
83 struct ext4_extent_header
*eh
;
84 int ppos
, leaf_ppos
= path
->p_depth
;
87 if (EXT_LAST_EXTENT(path
[ppos
].p_hdr
) > path
[ppos
].p_ext
) {
89 *extent
= ++path
[ppos
].p_ext
;
90 path
[ppos
].p_block
= ext4_ext_pblock(path
[ppos
].p_ext
);
95 if (EXT_LAST_INDEX(path
[ppos
].p_hdr
) >
101 path
[ppos
].p_block
= ext4_idx_pblock(path
[ppos
].p_idx
);
102 if (path
[ppos
+1].p_bh
)
103 brelse(path
[ppos
+1].p_bh
);
105 sb_bread(inode
->i_sb
, path
[ppos
].p_block
);
106 if (!path
[ppos
+1].p_bh
)
109 ext_block_hdr(path
[ppos
+1].p_bh
);
111 /* Halfway index block */
112 while (++cur_ppos
< leaf_ppos
) {
113 path
[cur_ppos
].p_idx
=
114 EXT_FIRST_INDEX(path
[cur_ppos
].p_hdr
);
115 path
[cur_ppos
].p_block
=
116 ext4_idx_pblock(path
[cur_ppos
].p_idx
);
117 if (path
[cur_ppos
+1].p_bh
)
118 brelse(path
[cur_ppos
+1].p_bh
);
119 path
[cur_ppos
+1].p_bh
= sb_bread(inode
->i_sb
,
120 path
[cur_ppos
].p_block
);
121 if (!path
[cur_ppos
+1].p_bh
)
123 path
[cur_ppos
+1].p_hdr
=
124 ext_block_hdr(path
[cur_ppos
+1].p_bh
);
127 path
[leaf_ppos
].p_ext
= *extent
= NULL
;
129 eh
= path
[leaf_ppos
].p_hdr
;
130 if (le16_to_cpu(eh
->eh_entries
) == 0)
131 /* empty leaf is found */
135 path
[leaf_ppos
].p_ext
= *extent
=
136 EXT_FIRST_EXTENT(path
[leaf_ppos
].p_hdr
);
137 path
[leaf_ppos
].p_block
=
138 ext4_ext_pblock(path
[leaf_ppos
].p_ext
);
142 /* We found the last extent */
147 * double_down_write_data_sem - Acquire two inodes' write lock of i_data_sem
149 * Acquire write lock of i_data_sem of the two inodes
152 double_down_write_data_sem(struct inode
*first
, struct inode
*second
)
154 if (first
< second
) {
155 down_write(&EXT4_I(first
)->i_data_sem
);
156 down_write_nested(&EXT4_I(second
)->i_data_sem
, SINGLE_DEPTH_NESTING
);
158 down_write(&EXT4_I(second
)->i_data_sem
);
159 down_write_nested(&EXT4_I(first
)->i_data_sem
, SINGLE_DEPTH_NESTING
);
165 * double_up_write_data_sem - Release two inodes' write lock of i_data_sem
167 * @orig_inode: original inode structure to be released its lock first
168 * @donor_inode: donor inode structure to be released its lock second
169 * Release write lock of i_data_sem of two inodes (orig and donor).
172 double_up_write_data_sem(struct inode
*orig_inode
, struct inode
*donor_inode
)
174 up_write(&EXT4_I(orig_inode
)->i_data_sem
);
175 up_write(&EXT4_I(donor_inode
)->i_data_sem
);
179 * mext_insert_across_blocks - Insert extents across leaf block
181 * @handle: journal handle
182 * @orig_inode: original inode
183 * @o_start: first original extent to be changed
184 * @o_end: last original extent to be changed
185 * @start_ext: first new extent to be inserted
186 * @new_ext: middle of new extent to be inserted
187 * @end_ext: last new extent to be inserted
189 * Allocate a new leaf block and insert extents into it. Return 0 on success,
190 * or a negative error value on failure.
193 mext_insert_across_blocks(handle_t
*handle
, struct inode
*orig_inode
,
194 struct ext4_extent
*o_start
, struct ext4_extent
*o_end
,
195 struct ext4_extent
*start_ext
, struct ext4_extent
*new_ext
,
196 struct ext4_extent
*end_ext
)
198 struct ext4_ext_path
*orig_path
= NULL
;
199 ext4_lblk_t eblock
= 0;
204 if (start_ext
->ee_len
&& new_ext
->ee_len
&& end_ext
->ee_len
) {
205 if (o_start
== o_end
) {
207 /* start_ext new_ext end_ext
208 * donor |---------|-----------|--------|
209 * orig |------------------------------|
214 /* start_ext new_ext end_ext
215 * donor |---------|----------|---------|
216 * orig |---------------|--------------|
218 o_end
->ee_block
= end_ext
->ee_block
;
219 o_end
->ee_len
= end_ext
->ee_len
;
220 ext4_ext_store_pblock(o_end
, ext4_ext_pblock(end_ext
));
223 o_start
->ee_len
= start_ext
->ee_len
;
224 eblock
= le32_to_cpu(start_ext
->ee_block
);
227 } else if (start_ext
->ee_len
&& new_ext
->ee_len
&&
228 !end_ext
->ee_len
&& o_start
== o_end
) {
231 * donor |--------------|---------------|
232 * orig |------------------------------|
234 o_start
->ee_len
= start_ext
->ee_len
;
235 eblock
= le32_to_cpu(start_ext
->ee_block
);
238 } else if (!start_ext
->ee_len
&& new_ext
->ee_len
&&
239 end_ext
->ee_len
&& o_start
== o_end
) {
242 * donor |--------------|---------------|
243 * orig |------------------------------|
245 o_end
->ee_block
= end_ext
->ee_block
;
246 o_end
->ee_len
= end_ext
->ee_len
;
247 ext4_ext_store_pblock(o_end
, ext4_ext_pblock(end_ext
));
250 * Set 0 to the extent block if new_ext was
253 if (new_ext
->ee_block
)
254 eblock
= le32_to_cpu(new_ext
->ee_block
);
258 ext4_debug("ext4 move extent: Unexpected insert case\n");
263 err
= get_ext_path(orig_inode
, eblock
, &orig_path
);
267 if (ext4_ext_insert_extent(handle
, orig_inode
,
268 orig_path
, new_ext
, 0))
273 err
= get_ext_path(orig_inode
,
274 le32_to_cpu(end_ext
->ee_block
) - 1, &orig_path
);
278 if (ext4_ext_insert_extent(handle
, orig_inode
,
279 orig_path
, end_ext
, 0))
284 ext4_ext_drop_refs(orig_path
);
293 * mext_insert_inside_block - Insert new extent to the extent block
295 * @o_start: first original extent to be moved
296 * @o_end: last original extent to be moved
297 * @start_ext: first new extent to be inserted
298 * @new_ext: middle of new extent to be inserted
299 * @end_ext: last new extent to be inserted
300 * @eh: extent header of target leaf block
301 * @range_to_move: used to decide how to insert extent
303 * Insert extents into the leaf block. The extent (@o_start) is overwritten
304 * by inserted extents.
307 mext_insert_inside_block(struct ext4_extent
*o_start
,
308 struct ext4_extent
*o_end
,
309 struct ext4_extent
*start_ext
,
310 struct ext4_extent
*new_ext
,
311 struct ext4_extent
*end_ext
,
312 struct ext4_extent_header
*eh
,
318 /* Move the existing extents */
319 if (range_to_move
&& o_end
< EXT_LAST_EXTENT(eh
)) {
320 len
= (unsigned long)(EXT_LAST_EXTENT(eh
) + 1) -
321 (unsigned long)(o_end
+ 1);
322 memmove(o_end
+ 1 + range_to_move
, o_end
+ 1, len
);
325 /* Insert start entry */
326 if (start_ext
->ee_len
)
327 o_start
[i
++].ee_len
= start_ext
->ee_len
;
329 /* Insert new entry */
330 if (new_ext
->ee_len
) {
331 o_start
[i
] = *new_ext
;
332 ext4_ext_store_pblock(&o_start
[i
++], ext4_ext_pblock(new_ext
));
335 /* Insert end entry */
337 o_start
[i
] = *end_ext
;
339 /* Increment the total entries counter on the extent block */
340 le16_add_cpu(&eh
->eh_entries
, range_to_move
);
344 * mext_insert_extents - Insert new extent
346 * @handle: journal handle
347 * @orig_inode: original inode
348 * @orig_path: path indicates first extent to be changed
349 * @o_start: first original extent to be changed
350 * @o_end: last original extent to be changed
351 * @start_ext: first new extent to be inserted
352 * @new_ext: middle of new extent to be inserted
353 * @end_ext: last new extent to be inserted
355 * Call the function to insert extents. If we cannot add more extents into
356 * the leaf block, we call mext_insert_across_blocks() to create a
357 * new leaf block. Otherwise call mext_insert_inside_block(). Return 0
358 * on success, or a negative error value on failure.
361 mext_insert_extents(handle_t
*handle
, struct inode
*orig_inode
,
362 struct ext4_ext_path
*orig_path
,
363 struct ext4_extent
*o_start
,
364 struct ext4_extent
*o_end
,
365 struct ext4_extent
*start_ext
,
366 struct ext4_extent
*new_ext
,
367 struct ext4_extent
*end_ext
)
369 struct ext4_extent_header
*eh
;
370 unsigned long need_slots
, slots_range
;
371 int range_to_move
, depth
, ret
;
374 * The extents need to be inserted
375 * start_extent + new_extent + end_extent.
377 need_slots
= (start_ext
->ee_len
? 1 : 0) + (end_ext
->ee_len
? 1 : 0) +
378 (new_ext
->ee_len
? 1 : 0);
380 /* The number of slots between start and end */
381 slots_range
= ((unsigned long)(o_end
+ 1) - (unsigned long)o_start
+ 1)
382 / sizeof(struct ext4_extent
);
384 /* Range to move the end of extent */
385 range_to_move
= need_slots
- slots_range
;
386 depth
= orig_path
->p_depth
;
388 eh
= orig_path
->p_hdr
;
391 /* Register to journal */
392 ret
= ext4_journal_get_write_access(handle
, orig_path
->p_bh
);
398 if (range_to_move
> 0 &&
399 (range_to_move
> le16_to_cpu(eh
->eh_max
)
400 - le16_to_cpu(eh
->eh_entries
))) {
402 ret
= mext_insert_across_blocks(handle
, orig_inode
, o_start
,
403 o_end
, start_ext
, new_ext
, end_ext
);
407 mext_insert_inside_block(o_start
, o_end
, start_ext
, new_ext
,
408 end_ext
, eh
, range_to_move
);
411 ret
= ext4_handle_dirty_metadata(handle
, orig_inode
,
416 ret
= ext4_mark_inode_dirty(handle
, orig_inode
);
425 * mext_leaf_block - Move one leaf extent block into the inode.
427 * @handle: journal handle
428 * @orig_inode: original inode
429 * @orig_path: path indicates first extent to be changed
430 * @dext: donor extent
431 * @from: start offset on the target file
433 * In order to insert extents into the leaf block, we must divide the extent
434 * in the leaf block into three extents. The one is located to be inserted
435 * extents, and the others are located around it.
437 * Therefore, this function creates structures to save extents of the leaf
438 * block, and inserts extents by calling mext_insert_extents() with
439 * created extents. Return 0 on success, or a negative error value on failure.
442 mext_leaf_block(handle_t
*handle
, struct inode
*orig_inode
,
443 struct ext4_ext_path
*orig_path
, struct ext4_extent
*dext
,
446 struct ext4_extent
*oext
, *o_start
, *o_end
, *prev_ext
;
447 struct ext4_extent new_ext
, start_ext
, end_ext
;
448 ext4_lblk_t new_ext_end
;
449 int oext_alen
, new_ext_alen
, end_ext_alen
;
450 int depth
= ext_depth(orig_inode
);
453 start_ext
.ee_block
= end_ext
.ee_block
= 0;
454 o_start
= o_end
= oext
= orig_path
[depth
].p_ext
;
455 oext_alen
= ext4_ext_get_actual_len(oext
);
456 start_ext
.ee_len
= end_ext
.ee_len
= 0;
458 new_ext
.ee_block
= cpu_to_le32(*from
);
459 ext4_ext_store_pblock(&new_ext
, ext4_ext_pblock(dext
));
460 new_ext
.ee_len
= dext
->ee_len
;
461 new_ext_alen
= ext4_ext_get_actual_len(&new_ext
);
462 new_ext_end
= le32_to_cpu(new_ext
.ee_block
) + new_ext_alen
- 1;
465 * Case: original extent is first
470 if (le32_to_cpu(oext
->ee_block
) < le32_to_cpu(new_ext
.ee_block
) &&
471 le32_to_cpu(new_ext
.ee_block
) <
472 le32_to_cpu(oext
->ee_block
) + oext_alen
) {
473 start_ext
.ee_len
= cpu_to_le16(le32_to_cpu(new_ext
.ee_block
) -
474 le32_to_cpu(oext
->ee_block
));
475 start_ext
.ee_block
= oext
->ee_block
;
476 copy_extent_status(oext
, &start_ext
);
477 } else if (oext
> EXT_FIRST_EXTENT(orig_path
[depth
].p_hdr
)) {
480 * We can merge new_ext into previous extent,
481 * if these are contiguous and same extent type.
483 if (ext4_can_extents_be_merged(orig_inode
, prev_ext
,
486 start_ext
.ee_len
= cpu_to_le16(
487 ext4_ext_get_actual_len(prev_ext
) +
489 start_ext
.ee_block
= oext
->ee_block
;
490 copy_extent_status(prev_ext
, &start_ext
);
496 * Case: new_ext_end must be less than oext
500 if (le32_to_cpu(oext
->ee_block
) + oext_alen
- 1 < new_ext_end
) {
501 EXT4_ERROR_INODE(orig_inode
,
502 "new_ext_end(%u) should be less than or equal to "
503 "oext->ee_block(%u) + oext_alen(%d) - 1",
504 new_ext_end
, le32_to_cpu(oext
->ee_block
),
511 * Case: new_ext is smaller than original extent
512 * oext |---------------|
513 * new_ext |-----------|
516 if (le32_to_cpu(oext
->ee_block
) <= new_ext_end
&&
517 new_ext_end
< le32_to_cpu(oext
->ee_block
) + oext_alen
- 1) {
519 cpu_to_le16(le32_to_cpu(oext
->ee_block
) +
520 oext_alen
- 1 - new_ext_end
);
521 copy_extent_status(oext
, &end_ext
);
522 end_ext_alen
= ext4_ext_get_actual_len(&end_ext
);
523 ext4_ext_store_pblock(&end_ext
,
524 (ext4_ext_pblock(o_end
) + oext_alen
- end_ext_alen
));
526 cpu_to_le32(le32_to_cpu(o_end
->ee_block
) +
527 oext_alen
- end_ext_alen
);
530 ret
= mext_insert_extents(handle
, orig_inode
, orig_path
, o_start
,
531 o_end
, &start_ext
, &new_ext
, &end_ext
);
537 * mext_calc_swap_extents - Calculate extents for extent swapping.
539 * @tmp_dext: the extent that will belong to the original inode
540 * @tmp_oext: the extent that will belong to the donor inode
541 * @orig_off: block offset of original inode
542 * @donor_off: block offset of donor inode
543 * @max_count: the maximum length of extents
545 * Return 0 on success, or a negative error value on failure.
548 mext_calc_swap_extents(struct ext4_extent
*tmp_dext
,
549 struct ext4_extent
*tmp_oext
,
550 ext4_lblk_t orig_off
, ext4_lblk_t donor_off
,
551 ext4_lblk_t max_count
)
553 ext4_lblk_t diff
, orig_diff
;
554 struct ext4_extent dext_old
, oext_old
;
556 BUG_ON(orig_off
!= donor_off
);
558 /* original and donor extents have to cover the same block offset */
559 if (orig_off
< le32_to_cpu(tmp_oext
->ee_block
) ||
560 le32_to_cpu(tmp_oext
->ee_block
) +
561 ext4_ext_get_actual_len(tmp_oext
) - 1 < orig_off
)
564 if (orig_off
< le32_to_cpu(tmp_dext
->ee_block
) ||
565 le32_to_cpu(tmp_dext
->ee_block
) +
566 ext4_ext_get_actual_len(tmp_dext
) - 1 < orig_off
)
569 dext_old
= *tmp_dext
;
570 oext_old
= *tmp_oext
;
572 /* When tmp_dext is too large, pick up the target range. */
573 diff
= donor_off
- le32_to_cpu(tmp_dext
->ee_block
);
575 ext4_ext_store_pblock(tmp_dext
, ext4_ext_pblock(tmp_dext
) + diff
);
576 le32_add_cpu(&tmp_dext
->ee_block
, diff
);
577 le16_add_cpu(&tmp_dext
->ee_len
, -diff
);
579 if (max_count
< ext4_ext_get_actual_len(tmp_dext
))
580 tmp_dext
->ee_len
= cpu_to_le16(max_count
);
582 orig_diff
= orig_off
- le32_to_cpu(tmp_oext
->ee_block
);
583 ext4_ext_store_pblock(tmp_oext
, ext4_ext_pblock(tmp_oext
) + orig_diff
);
585 /* Adjust extent length if donor extent is larger than orig */
586 if (ext4_ext_get_actual_len(tmp_dext
) >
587 ext4_ext_get_actual_len(tmp_oext
) - orig_diff
)
588 tmp_dext
->ee_len
= cpu_to_le16(le16_to_cpu(tmp_oext
->ee_len
) -
591 tmp_oext
->ee_len
= cpu_to_le16(ext4_ext_get_actual_len(tmp_dext
));
593 copy_extent_status(&oext_old
, tmp_dext
);
594 copy_extent_status(&dext_old
, tmp_oext
);
600 * mext_check_coverage - Check that all extents in range has the same type
602 * @inode: inode in question
603 * @from: block offset of inode
604 * @count: block count to be checked
605 * @uninit: extents expected to be uninitialized
606 * @err: pointer to save error value
608 * Return 1 if all extents in range has expected type, and zero otherwise.
611 mext_check_coverage(struct inode
*inode
, ext4_lblk_t from
, ext4_lblk_t count
,
612 int uninit
, int *err
)
614 struct ext4_ext_path
*path
= NULL
;
615 struct ext4_extent
*ext
;
617 ext4_lblk_t last
= from
+ count
;
618 while (from
< last
) {
619 *err
= get_ext_path(inode
, from
, &path
);
622 ext
= path
[ext_depth(inode
)].p_ext
;
623 if (uninit
!= ext4_ext_is_uninitialized(ext
))
625 from
+= ext4_ext_get_actual_len(ext
);
626 ext4_ext_drop_refs(path
);
631 ext4_ext_drop_refs(path
);
638 * mext_replace_branches - Replace original extents with new extents
640 * @handle: journal handle
641 * @orig_inode: original inode
642 * @donor_inode: donor inode
643 * @from: block offset of orig_inode
644 * @count: block count to be replaced
645 * @err: pointer to save return value
647 * Replace original inode extents and donor inode extents page by page.
648 * We implement this replacement in the following three steps:
649 * 1. Save the block information of original and donor inodes into
651 * 2. Change the block information of original inode to point at the
652 * donor inode blocks.
653 * 3. Change the block information of donor inode to point at the saved
654 * original inode blocks in the dummy extents.
656 * Return replaced block count.
659 mext_replace_branches(handle_t
*handle
, struct inode
*orig_inode
,
660 struct inode
*donor_inode
, ext4_lblk_t from
,
661 ext4_lblk_t count
, int *err
)
663 struct ext4_ext_path
*orig_path
= NULL
;
664 struct ext4_ext_path
*donor_path
= NULL
;
665 struct ext4_extent
*oext
, *dext
;
666 struct ext4_extent tmp_dext
, tmp_oext
;
667 ext4_lblk_t orig_off
= from
, donor_off
= from
;
669 int replaced_count
= 0;
672 *err
= ext4_es_remove_extent(orig_inode
, from
, count
);
676 *err
= ext4_es_remove_extent(donor_inode
, from
, count
);
680 /* Get the original extent for the block "orig_off" */
681 *err
= get_ext_path(orig_inode
, orig_off
, &orig_path
);
685 /* Get the donor extent for the head */
686 *err
= get_ext_path(donor_inode
, donor_off
, &donor_path
);
689 depth
= ext_depth(orig_inode
);
690 oext
= orig_path
[depth
].p_ext
;
693 depth
= ext_depth(donor_inode
);
694 dext
= donor_path
[depth
].p_ext
;
696 goto missing_donor_extent
;
699 *err
= mext_calc_swap_extents(&tmp_dext
, &tmp_oext
, orig_off
,
704 /* Loop for the donor extents */
706 /* The extent for donor must be found. */
707 if (unlikely(!dext
)) {
708 missing_donor_extent
:
709 EXT4_ERROR_INODE(donor_inode
,
710 "The extent for donor must be found");
713 } else if (donor_off
!= le32_to_cpu(tmp_dext
.ee_block
)) {
714 EXT4_ERROR_INODE(donor_inode
,
715 "Donor offset(%u) and the first block of donor "
716 "extent(%u) should be equal",
718 le32_to_cpu(tmp_dext
.ee_block
));
723 /* Set donor extent to orig extent */
724 *err
= mext_leaf_block(handle
, orig_inode
,
725 orig_path
, &tmp_dext
, &orig_off
);
729 /* Set orig extent to donor extent */
730 *err
= mext_leaf_block(handle
, donor_inode
,
731 donor_path
, &tmp_oext
, &donor_off
);
735 dext_alen
= ext4_ext_get_actual_len(&tmp_dext
);
736 replaced_count
+= dext_alen
;
737 donor_off
+= dext_alen
;
738 orig_off
+= dext_alen
;
740 /* Already moved the expected blocks */
741 if (replaced_count
>= count
)
745 ext4_ext_drop_refs(orig_path
);
746 *err
= get_ext_path(orig_inode
, orig_off
, &orig_path
);
749 depth
= ext_depth(orig_inode
);
750 oext
= orig_path
[depth
].p_ext
;
754 ext4_ext_drop_refs(donor_path
);
755 *err
= get_ext_path(donor_inode
, donor_off
, &donor_path
);
758 depth
= ext_depth(donor_inode
);
759 dext
= donor_path
[depth
].p_ext
;
762 *err
= mext_calc_swap_extents(&tmp_dext
, &tmp_oext
, orig_off
,
763 donor_off
, count
- replaced_count
);
770 ext4_ext_drop_refs(orig_path
);
774 ext4_ext_drop_refs(donor_path
);
778 return replaced_count
;
782 * mext_page_double_lock - Grab and lock pages on both @inode1 and @inode2
784 * @inode1: the inode structure
785 * @inode2: the inode structure
787 * @page: result page vector
789 * Grab two locked pages for inode's by inode order
792 mext_page_double_lock(struct inode
*inode1
, struct inode
*inode2
,
793 pgoff_t index
, struct page
*page
[2])
795 struct address_space
*mapping
[2];
796 unsigned fl
= AOP_FLAG_NOFS
;
798 BUG_ON(!inode1
|| !inode2
);
799 if (inode1
< inode2
) {
800 mapping
[0] = inode1
->i_mapping
;
801 mapping
[1] = inode2
->i_mapping
;
803 mapping
[0] = inode2
->i_mapping
;
804 mapping
[1] = inode1
->i_mapping
;
807 page
[0] = grab_cache_page_write_begin(mapping
[0], index
, fl
);
811 page
[1] = grab_cache_page_write_begin(mapping
[1], index
, fl
);
813 unlock_page(page
[0]);
814 page_cache_release(page
[0]);
818 if (inode1
> inode2
) {
827 /* Force page buffers uptodate w/o dropping page's lock */
829 mext_page_mkuptodate(struct page
*page
, unsigned from
, unsigned to
)
831 struct inode
*inode
= page
->mapping
->host
;
833 struct buffer_head
*bh
, *head
, *arr
[MAX_BUF_PER_PAGE
];
834 unsigned int blocksize
, block_start
, block_end
;
835 int i
, err
, nr
= 0, partial
= 0;
836 BUG_ON(!PageLocked(page
));
837 BUG_ON(PageWriteback(page
));
839 if (PageUptodate(page
))
842 blocksize
= 1 << inode
->i_blkbits
;
843 if (!page_has_buffers(page
))
844 create_empty_buffers(page
, blocksize
, 0);
846 head
= page_buffers(page
);
847 block
= (sector_t
)page
->index
<< (PAGE_CACHE_SHIFT
- inode
->i_blkbits
);
848 for (bh
= head
, block_start
= 0; bh
!= head
|| !block_start
;
849 block
++, block_start
= block_end
, bh
= bh
->b_this_page
) {
850 block_end
= block_start
+ blocksize
;
851 if (block_end
<= from
|| block_start
>= to
) {
852 if (!buffer_uptodate(bh
))
856 if (buffer_uptodate(bh
))
858 if (!buffer_mapped(bh
)) {
860 err
= ext4_get_block(inode
, block
, bh
, 0);
865 if (!buffer_mapped(bh
)) {
866 zero_user(page
, block_start
, blocksize
);
868 set_buffer_uptodate(bh
);
872 BUG_ON(nr
>= MAX_BUF_PER_PAGE
);
879 for (i
= 0; i
< nr
; i
++) {
881 if (!bh_uptodate_or_lock(bh
)) {
882 err
= bh_submit_read(bh
);
889 SetPageUptodate(page
);
894 * move_extent_per_page - Move extent data per page
896 * @o_filp: file structure of original file
897 * @donor_inode: donor inode
898 * @orig_page_offset: page index on original file
899 * @data_offset_in_page: block index where data swapping starts
900 * @block_len_in_page: the number of blocks to be swapped
901 * @uninit: orig extent is uninitialized or not
902 * @err: pointer to save return value
904 * Save the data in original inode blocks and replace original inode extents
905 * with donor inode extents by calling mext_replace_branches().
906 * Finally, write out the saved data in new original inode blocks. Return
907 * replaced block count.
910 move_extent_per_page(struct file
*o_filp
, struct inode
*donor_inode
,
911 pgoff_t orig_page_offset
, int data_offset_in_page
,
912 int block_len_in_page
, int uninit
, int *err
)
914 struct inode
*orig_inode
= file_inode(o_filp
);
915 struct page
*pagep
[2] = {NULL
, NULL
};
917 ext4_lblk_t orig_blk_offset
;
918 long long offs
= orig_page_offset
<< PAGE_CACHE_SHIFT
;
919 unsigned long blocksize
= orig_inode
->i_sb
->s_blocksize
;
920 unsigned int w_flags
= 0;
921 unsigned int tmp_data_size
, data_size
, replaced_size
;
922 int err2
, jblocks
, retries
= 0;
923 int replaced_count
= 0;
924 int from
= data_offset_in_page
<< orig_inode
->i_blkbits
;
925 int blocks_per_page
= PAGE_CACHE_SIZE
>> orig_inode
->i_blkbits
;
928 * It needs twice the amount of ordinary journal buffers because
929 * inode and donor_inode may change each different metadata blocks.
933 jblocks
= ext4_writepage_trans_blocks(orig_inode
) * 2;
934 handle
= ext4_journal_start(orig_inode
, EXT4_HT_MOVE_EXTENTS
, jblocks
);
935 if (IS_ERR(handle
)) {
936 *err
= PTR_ERR(handle
);
940 if (segment_eq(get_fs(), KERNEL_DS
))
941 w_flags
|= AOP_FLAG_UNINTERRUPTIBLE
;
943 orig_blk_offset
= orig_page_offset
* blocks_per_page
+
946 offs
= (long long)orig_blk_offset
<< orig_inode
->i_blkbits
;
948 /* Calculate data_size */
949 if ((orig_blk_offset
+ block_len_in_page
- 1) ==
950 ((orig_inode
->i_size
- 1) >> orig_inode
->i_blkbits
)) {
951 /* Replace the last block */
952 tmp_data_size
= orig_inode
->i_size
& (blocksize
- 1);
954 * If data_size equal zero, it shows data_size is multiples of
955 * blocksize. So we set appropriate value.
957 if (tmp_data_size
== 0)
958 tmp_data_size
= blocksize
;
960 data_size
= tmp_data_size
+
961 ((block_len_in_page
- 1) << orig_inode
->i_blkbits
);
963 data_size
= block_len_in_page
<< orig_inode
->i_blkbits
;
965 replaced_size
= data_size
;
967 *err
= mext_page_double_lock(orig_inode
, donor_inode
, orig_page_offset
,
969 if (unlikely(*err
< 0))
972 * If orig extent was uninitialized it can become initialized
973 * at any time after i_data_sem was dropped, in order to
974 * serialize with delalloc we have recheck extent while we
975 * hold page's lock, if it is still the case data copy is not
976 * necessary, just swap data blocks between orig and donor.
979 double_down_write_data_sem(orig_inode
, donor_inode
);
980 /* If any of extents in range became initialized we have to
981 * fallback to data copying */
982 uninit
= mext_check_coverage(orig_inode
, orig_blk_offset
,
983 block_len_in_page
, 1, err
);
987 uninit
&= mext_check_coverage(donor_inode
, orig_blk_offset
,
988 block_len_in_page
, 1, err
);
993 double_up_write_data_sem(orig_inode
, donor_inode
);
996 if ((page_has_private(pagep
[0]) &&
997 !try_to_release_page(pagep
[0], 0)) ||
998 (page_has_private(pagep
[1]) &&
999 !try_to_release_page(pagep
[1], 0))) {
1003 replaced_count
= mext_replace_branches(handle
, orig_inode
,
1004 donor_inode
, orig_blk_offset
,
1005 block_len_in_page
, err
);
1007 double_up_write_data_sem(orig_inode
, donor_inode
);
1011 *err
= mext_page_mkuptodate(pagep
[0], from
, from
+ replaced_size
);
1015 /* At this point all buffers in range are uptodate, old mapping layout
1016 * is no longer required, try to drop it now. */
1017 if ((page_has_private(pagep
[0]) && !try_to_release_page(pagep
[0], 0)) ||
1018 (page_has_private(pagep
[1]) && !try_to_release_page(pagep
[1], 0))) {
1023 replaced_count
= mext_replace_branches(handle
, orig_inode
, donor_inode
,
1025 block_len_in_page
, err
);
1027 if (replaced_count
) {
1028 block_len_in_page
= replaced_count
;
1030 block_len_in_page
<< orig_inode
->i_blkbits
;
1034 /* Perform all necessary steps similar write_begin()/write_end()
1035 * but keeping in mind that i_size will not change */
1036 *err
= __block_write_begin(pagep
[0], from
, from
+ replaced_size
,
1039 *err
= block_commit_write(pagep
[0], from
, from
+ replaced_size
);
1041 if (unlikely(*err
< 0))
1042 goto repair_branches
;
1044 /* Even in case of data=writeback it is reasonable to pin
1045 * inode to transaction, to prevent unexpected data loss */
1046 *err
= ext4_jbd2_file_inode(handle
, orig_inode
);
1049 unlock_page(pagep
[0]);
1050 page_cache_release(pagep
[0]);
1051 unlock_page(pagep
[1]);
1052 page_cache_release(pagep
[1]);
1054 ext4_journal_stop(handle
);
1055 /* Buffer was busy because probably is pinned to journal transaction,
1056 * force transaction commit may help to free it. */
1057 if (*err
== -EBUSY
&& ext4_should_retry_alloc(orig_inode
->i_sb
,
1060 return replaced_count
;
1064 * This should never ever happen!
1065 * Extents are swapped already, but we are not able to copy data.
1066 * Try to swap extents to it's original places
1068 double_down_write_data_sem(orig_inode
, donor_inode
);
1069 replaced_count
= mext_replace_branches(handle
, donor_inode
, orig_inode
,
1071 block_len_in_page
, &err2
);
1072 double_up_write_data_sem(orig_inode
, donor_inode
);
1073 if (replaced_count
!= block_len_in_page
) {
1074 EXT4_ERROR_INODE_BLOCK(orig_inode
, (sector_t
)(orig_blk_offset
),
1075 "Unable to copy data block,"
1076 " data will be lost.");
1084 * mext_check_arguments - Check whether move extent can be done
1086 * @orig_inode: original inode
1087 * @donor_inode: donor inode
1088 * @orig_start: logical start offset in block for orig
1089 * @donor_start: logical start offset in block for donor
1090 * @len: the number of blocks to be moved
1092 * Check the arguments of ext4_move_extents() whether the files can be
1093 * exchanged with each other.
1094 * Return 0 on success, or a negative error value on failure.
1097 mext_check_arguments(struct inode
*orig_inode
,
1098 struct inode
*donor_inode
, __u64 orig_start
,
1099 __u64 donor_start
, __u64
*len
)
1101 ext4_lblk_t orig_blocks
, donor_blocks
;
1102 unsigned int blkbits
= orig_inode
->i_blkbits
;
1103 unsigned int blocksize
= 1 << blkbits
;
1105 if (donor_inode
->i_mode
& (S_ISUID
|S_ISGID
)) {
1106 ext4_debug("ext4 move extent: suid or sgid is set"
1107 " to donor file [ino:orig %lu, donor %lu]\n",
1108 orig_inode
->i_ino
, donor_inode
->i_ino
);
1112 if (IS_IMMUTABLE(donor_inode
) || IS_APPEND(donor_inode
))
1115 /* Ext4 move extent does not support swapfile */
1116 if (IS_SWAPFILE(orig_inode
) || IS_SWAPFILE(donor_inode
)) {
1117 ext4_debug("ext4 move extent: The argument files should "
1118 "not be swapfile [ino:orig %lu, donor %lu]\n",
1119 orig_inode
->i_ino
, donor_inode
->i_ino
);
1123 /* Ext4 move extent supports only extent based file */
1124 if (!(ext4_test_inode_flag(orig_inode
, EXT4_INODE_EXTENTS
))) {
1125 ext4_debug("ext4 move extent: orig file is not extents "
1126 "based file [ino:orig %lu]\n", orig_inode
->i_ino
);
1128 } else if (!(ext4_test_inode_flag(donor_inode
, EXT4_INODE_EXTENTS
))) {
1129 ext4_debug("ext4 move extent: donor file is not extents "
1130 "based file [ino:donor %lu]\n", donor_inode
->i_ino
);
1134 if ((!orig_inode
->i_size
) || (!donor_inode
->i_size
)) {
1135 ext4_debug("ext4 move extent: File size is 0 byte\n");
1139 /* Start offset should be same */
1140 if (orig_start
!= donor_start
) {
1141 ext4_debug("ext4 move extent: orig and donor's start "
1142 "offset are not same [ino:orig %lu, donor %lu]\n",
1143 orig_inode
->i_ino
, donor_inode
->i_ino
);
1147 if ((orig_start
>= EXT_MAX_BLOCKS
) ||
1148 (*len
> EXT_MAX_BLOCKS
) ||
1149 (orig_start
+ *len
>= EXT_MAX_BLOCKS
)) {
1150 ext4_debug("ext4 move extent: Can't handle over [%u] blocks "
1151 "[ino:orig %lu, donor %lu]\n", EXT_MAX_BLOCKS
,
1152 orig_inode
->i_ino
, donor_inode
->i_ino
);
1156 if (orig_inode
->i_size
> donor_inode
->i_size
) {
1157 donor_blocks
= (donor_inode
->i_size
+ blocksize
- 1) >> blkbits
;
1158 /* TODO: eliminate this artificial restriction */
1159 if (orig_start
>= donor_blocks
) {
1160 ext4_debug("ext4 move extent: orig start offset "
1161 "[%llu] should be less than donor file blocks "
1162 "[%u] [ino:orig %lu, donor %lu]\n",
1163 orig_start
, donor_blocks
,
1164 orig_inode
->i_ino
, donor_inode
->i_ino
);
1168 /* TODO: eliminate this artificial restriction */
1169 if (orig_start
+ *len
> donor_blocks
) {
1170 ext4_debug("ext4 move extent: End offset [%llu] should "
1171 "be less than donor file blocks [%u]."
1172 "So adjust length from %llu to %llu "
1173 "[ino:orig %lu, donor %lu]\n",
1174 orig_start
+ *len
, donor_blocks
,
1175 *len
, donor_blocks
- orig_start
,
1176 orig_inode
->i_ino
, donor_inode
->i_ino
);
1177 *len
= donor_blocks
- orig_start
;
1180 orig_blocks
= (orig_inode
->i_size
+ blocksize
- 1) >> blkbits
;
1181 if (orig_start
>= orig_blocks
) {
1182 ext4_debug("ext4 move extent: start offset [%llu] "
1183 "should be less than original file blocks "
1184 "[%u] [ino:orig %lu, donor %lu]\n",
1185 orig_start
, orig_blocks
,
1186 orig_inode
->i_ino
, donor_inode
->i_ino
);
1190 if (orig_start
+ *len
> orig_blocks
) {
1191 ext4_debug("ext4 move extent: Adjust length "
1192 "from %llu to %llu. Because it should be "
1193 "less than original file blocks "
1194 "[ino:orig %lu, donor %lu]\n",
1195 *len
, orig_blocks
- orig_start
,
1196 orig_inode
->i_ino
, donor_inode
->i_ino
);
1197 *len
= orig_blocks
- orig_start
;
1202 ext4_debug("ext4 move extent: len should not be 0 "
1203 "[ino:orig %lu, donor %lu]\n", orig_inode
->i_ino
,
1204 donor_inode
->i_ino
);
1212 * mext_inode_double_lock - Lock i_mutex on both @inode1 and @inode2
1214 * @inode1: the inode structure
1215 * @inode2: the inode structure
1217 * Lock two inodes' i_mutex
1220 mext_inode_double_lock(struct inode
*inode1
, struct inode
*inode2
)
1222 BUG_ON(inode1
== inode2
);
1223 if (inode1
< inode2
) {
1224 mutex_lock_nested(&inode1
->i_mutex
, I_MUTEX_PARENT
);
1225 mutex_lock_nested(&inode2
->i_mutex
, I_MUTEX_CHILD
);
1227 mutex_lock_nested(&inode2
->i_mutex
, I_MUTEX_PARENT
);
1228 mutex_lock_nested(&inode1
->i_mutex
, I_MUTEX_CHILD
);
1233 * mext_inode_double_unlock - Release i_mutex on both @inode1 and @inode2
1235 * @inode1: the inode that is released first
1236 * @inode2: the inode that is released second
1241 mext_inode_double_unlock(struct inode
*inode1
, struct inode
*inode2
)
1243 mutex_unlock(&inode1
->i_mutex
);
1244 mutex_unlock(&inode2
->i_mutex
);
1248 * ext4_move_extents - Exchange the specified range of a file
1250 * @o_filp: file structure of the original file
1251 * @d_filp: file structure of the donor file
1252 * @orig_start: start offset in block for orig
1253 * @donor_start: start offset in block for donor
1254 * @len: the number of blocks to be moved
1255 * @moved_len: moved block length
1257 * This function returns 0 and moved block length is set in moved_len
1258 * if succeed, otherwise returns error value.
1260 * Note: ext4_move_extents() proceeds the following order.
1261 * 1:ext4_move_extents() calculates the last block number of moving extent
1262 * function by the start block number (orig_start) and the number of blocks
1263 * to be moved (len) specified as arguments.
1264 * If the {orig, donor}_start points a hole, the extent's start offset
1265 * pointed by ext_cur (current extent), holecheck_path, orig_path are set
1266 * after hole behind.
1267 * 2:Continue step 3 to step 5, until the holecheck_path points to last_extent
1268 * or the ext_cur exceeds the block_end which is last logical block number.
1269 * 3:To get the length of continues area, call mext_next_extent()
1270 * specified with the ext_cur (initial value is holecheck_path) re-cursive,
1271 * until find un-continuous extent, the start logical block number exceeds
1272 * the block_end or the extent points to the last extent.
1273 * 4:Exchange the original inode data with donor inode data
1274 * from orig_page_offset to seq_end_page.
1275 * The start indexes of data are specified as arguments.
1276 * That of the original inode is orig_page_offset,
1277 * and the donor inode is also orig_page_offset
1278 * (To easily handle blocksize != pagesize case, the offset for the
1279 * donor inode is block unit).
1280 * 5:Update holecheck_path and orig_path to points a next proceeding extent,
1281 * then returns to step 2.
1282 * 6:Release holecheck_path, orig_path and set the len to moved_len
1283 * which shows the number of moved blocks.
1284 * The moved_len is useful for the command to calculate the file offset
1285 * for starting next move extent ioctl.
1286 * 7:Return 0 on success, or a negative error value on failure.
1289 ext4_move_extents(struct file
*o_filp
, struct file
*d_filp
,
1290 __u64 orig_start
, __u64 donor_start
, __u64 len
,
1293 struct inode
*orig_inode
= file_inode(o_filp
);
1294 struct inode
*donor_inode
= file_inode(d_filp
);
1295 struct ext4_ext_path
*orig_path
= NULL
, *holecheck_path
= NULL
;
1296 struct ext4_extent
*ext_prev
, *ext_cur
, *ext_dummy
;
1297 ext4_lblk_t block_start
= orig_start
;
1298 ext4_lblk_t block_end
, seq_start
, add_blocks
, file_end
, seq_blocks
= 0;
1299 ext4_lblk_t rest_blocks
;
1300 pgoff_t orig_page_offset
= 0, seq_end_page
;
1301 int ret
, depth
, last_extent
= 0;
1302 int blocks_per_page
= PAGE_CACHE_SIZE
>> orig_inode
->i_blkbits
;
1303 int data_offset_in_page
;
1304 int block_len_in_page
;
1307 if (orig_inode
->i_sb
!= donor_inode
->i_sb
) {
1308 ext4_debug("ext4 move extent: The argument files "
1309 "should be in same FS [ino:orig %lu, donor %lu]\n",
1310 orig_inode
->i_ino
, donor_inode
->i_ino
);
1314 /* orig and donor should be different inodes */
1315 if (orig_inode
== donor_inode
) {
1316 ext4_debug("ext4 move extent: The argument files should not "
1317 "be same inode [ino:orig %lu, donor %lu]\n",
1318 orig_inode
->i_ino
, donor_inode
->i_ino
);
1322 /* Regular file check */
1323 if (!S_ISREG(orig_inode
->i_mode
) || !S_ISREG(donor_inode
->i_mode
)) {
1324 ext4_debug("ext4 move extent: The argument files should be "
1325 "regular file [ino:orig %lu, donor %lu]\n",
1326 orig_inode
->i_ino
, donor_inode
->i_ino
);
1329 /* TODO: This is non obvious task to swap blocks for inodes with full
1330 jornaling enabled */
1331 if (ext4_should_journal_data(orig_inode
) ||
1332 ext4_should_journal_data(donor_inode
)) {
1335 /* Protect orig and donor inodes against a truncate */
1336 mext_inode_double_lock(orig_inode
, donor_inode
);
1338 /* Wait for all existing dio workers */
1339 ext4_inode_block_unlocked_dio(orig_inode
);
1340 ext4_inode_block_unlocked_dio(donor_inode
);
1341 inode_dio_wait(orig_inode
);
1342 inode_dio_wait(donor_inode
);
1344 /* Protect extent tree against block allocations via delalloc */
1345 double_down_write_data_sem(orig_inode
, donor_inode
);
1346 /* Check the filesystem environment whether move_extent can be done */
1347 ret
= mext_check_arguments(orig_inode
, donor_inode
, orig_start
,
1352 file_end
= (i_size_read(orig_inode
) - 1) >> orig_inode
->i_blkbits
;
1353 block_end
= block_start
+ len
- 1;
1354 if (file_end
< block_end
)
1355 len
-= block_end
- file_end
;
1357 ret
= get_ext_path(orig_inode
, block_start
, &orig_path
);
1361 /* Get path structure to check the hole */
1362 ret
= get_ext_path(orig_inode
, block_start
, &holecheck_path
);
1366 depth
= ext_depth(orig_inode
);
1367 ext_cur
= holecheck_path
[depth
].p_ext
;
1370 * Get proper starting location of block replacement if block_start was
1373 if (le32_to_cpu(ext_cur
->ee_block
) +
1374 ext4_ext_get_actual_len(ext_cur
) - 1 < block_start
) {
1376 * The hole exists between extents or the tail of
1379 last_extent
= mext_next_extent(orig_inode
,
1380 holecheck_path
, &ext_cur
);
1381 if (last_extent
< 0) {
1385 last_extent
= mext_next_extent(orig_inode
, orig_path
,
1387 if (last_extent
< 0) {
1391 seq_start
= le32_to_cpu(ext_cur
->ee_block
);
1392 } else if (le32_to_cpu(ext_cur
->ee_block
) > block_start
)
1393 /* The hole exists at the beginning of original file. */
1394 seq_start
= le32_to_cpu(ext_cur
->ee_block
);
1396 seq_start
= block_start
;
1398 /* No blocks within the specified range. */
1399 if (le32_to_cpu(ext_cur
->ee_block
) > block_end
) {
1400 ext4_debug("ext4 move extent: The specified range of file "
1401 "may be the hole\n");
1406 /* Adjust start blocks */
1407 add_blocks
= min(le32_to_cpu(ext_cur
->ee_block
) +
1408 ext4_ext_get_actual_len(ext_cur
), block_end
+ 1) -
1409 max(le32_to_cpu(ext_cur
->ee_block
), block_start
);
1411 while (!last_extent
&& le32_to_cpu(ext_cur
->ee_block
) <= block_end
) {
1412 seq_blocks
+= add_blocks
;
1414 /* Adjust tail blocks */
1415 if (seq_start
+ seq_blocks
- 1 > block_end
)
1416 seq_blocks
= block_end
- seq_start
+ 1;
1419 last_extent
= mext_next_extent(orig_inode
, holecheck_path
,
1421 if (last_extent
< 0) {
1425 add_blocks
= ext4_ext_get_actual_len(ext_cur
);
1428 * Extend the length of contiguous block (seq_blocks)
1429 * if extents are contiguous.
1431 if (ext4_can_extents_be_merged(orig_inode
,
1432 ext_prev
, ext_cur
) &&
1433 block_end
>= le32_to_cpu(ext_cur
->ee_block
) &&
1437 /* Is original extent is uninitialized */
1438 uninit
= ext4_ext_is_uninitialized(ext_prev
);
1440 data_offset_in_page
= seq_start
% blocks_per_page
;
1443 * Calculate data blocks count that should be swapped
1444 * at the first page.
1446 if (data_offset_in_page
+ seq_blocks
> blocks_per_page
) {
1447 /* Swapped blocks are across pages */
1449 blocks_per_page
- data_offset_in_page
;
1451 /* Swapped blocks are in a page */
1452 block_len_in_page
= seq_blocks
;
1455 orig_page_offset
= seq_start
>>
1456 (PAGE_CACHE_SHIFT
- orig_inode
->i_blkbits
);
1457 seq_end_page
= (seq_start
+ seq_blocks
- 1) >>
1458 (PAGE_CACHE_SHIFT
- orig_inode
->i_blkbits
);
1459 seq_start
= le32_to_cpu(ext_cur
->ee_block
);
1460 rest_blocks
= seq_blocks
;
1463 * Up semaphore to avoid following problems:
1464 * a. transaction deadlock among ext4_journal_start,
1465 * ->write_begin via pagefault, and jbd2_journal_commit
1466 * b. racing with ->readpage, ->write_begin, and ext4_get_block
1467 * in move_extent_per_page
1469 double_up_write_data_sem(orig_inode
, donor_inode
);
1471 while (orig_page_offset
<= seq_end_page
) {
1473 /* Swap original branches with new branches */
1474 block_len_in_page
= move_extent_per_page(
1475 o_filp
, donor_inode
,
1477 data_offset_in_page
,
1478 block_len_in_page
, uninit
,
1481 /* Count how many blocks we have exchanged */
1482 *moved_len
+= block_len_in_page
;
1485 if (*moved_len
> len
) {
1486 EXT4_ERROR_INODE(orig_inode
,
1487 "We replaced blocks too much! "
1488 "sum of replaced: %llu requested: %llu",
1495 data_offset_in_page
= 0;
1496 rest_blocks
-= block_len_in_page
;
1497 if (rest_blocks
> blocks_per_page
)
1498 block_len_in_page
= blocks_per_page
;
1500 block_len_in_page
= rest_blocks
;
1503 double_down_write_data_sem(orig_inode
, donor_inode
);
1507 /* Decrease buffer counter */
1509 ext4_ext_drop_refs(holecheck_path
);
1510 ret
= get_ext_path(orig_inode
, seq_start
, &holecheck_path
);
1513 depth
= holecheck_path
->p_depth
;
1515 /* Decrease buffer counter */
1517 ext4_ext_drop_refs(orig_path
);
1518 ret
= get_ext_path(orig_inode
, seq_start
, &orig_path
);
1522 ext_cur
= holecheck_path
[depth
].p_ext
;
1523 add_blocks
= ext4_ext_get_actual_len(ext_cur
);
1529 ext4_discard_preallocations(orig_inode
);
1530 ext4_discard_preallocations(donor_inode
);
1534 ext4_ext_drop_refs(orig_path
);
1537 if (holecheck_path
) {
1538 ext4_ext_drop_refs(holecheck_path
);
1539 kfree(holecheck_path
);
1541 double_up_write_data_sem(orig_inode
, donor_inode
);
1542 ext4_inode_resume_unlocked_dio(orig_inode
);
1543 ext4_inode_resume_unlocked_dio(donor_inode
);
1544 mext_inode_double_unlock(orig_inode
, donor_inode
);