1 /* -*- mode: c; c-basic-offset: 8; -*-
2 * vim: noexpandtab sw=8 ts=8 sts=0:
6 * Copyright (C) 2011 Oracle. All rights reserved.
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public
10 * License version 2 as published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
18 #include <linux/types.h>
19 #include <linux/mount.h>
20 #include <linux/swap.h>
22 #include <cluster/masklog.h>
25 #include "ocfs2_ioctl.h"
30 #include "extent_map.h"
37 #include "buffer_head_io.h"
39 #include "refcounttree.h"
40 #include "move_extents.h"
42 struct ocfs2_move_extents_context
{
51 struct ocfs2_move_extents
*range
;
52 struct ocfs2_extent_tree et
;
53 struct ocfs2_alloc_context
*meta_ac
;
54 struct ocfs2_alloc_context
*data_ac
;
55 struct ocfs2_cached_dealloc_ctxt dealloc
;
58 static int __ocfs2_move_extent(handle_t
*handle
,
59 struct ocfs2_move_extents_context
*context
,
60 u32 cpos
, u32 len
, u32 p_cpos
, u32 new_p_cpos
,
64 struct inode
*inode
= context
->inode
;
65 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
66 struct ocfs2_extent_rec
*rec
, replace_rec
;
67 struct ocfs2_path
*path
= NULL
;
68 struct ocfs2_extent_list
*el
;
69 u64 ino
= ocfs2_metadata_cache_owner(context
->et
.et_ci
);
70 u64 old_blkno
= ocfs2_clusters_to_blocks(inode
->i_sb
, p_cpos
);
72 ret
= ocfs2_duplicate_clusters_by_page(handle
, inode
, cpos
,
73 p_cpos
, new_p_cpos
, len
);
79 memset(&replace_rec
, 0, sizeof(replace_rec
));
80 replace_rec
.e_cpos
= cpu_to_le32(cpos
);
81 replace_rec
.e_leaf_clusters
= cpu_to_le16(len
);
82 replace_rec
.e_blkno
= cpu_to_le64(ocfs2_clusters_to_blocks(inode
->i_sb
,
85 path
= ocfs2_new_path_from_et(&context
->et
);
92 ret
= ocfs2_find_path(INODE_CACHE(inode
), path
, cpos
);
98 el
= path_leaf_el(path
);
100 index
= ocfs2_search_extent_list(el
, cpos
);
102 ret
= ocfs2_error(inode
->i_sb
,
103 "Inode %llu has an extent at cpos %u which can no longer be found\n",
104 (unsigned long long)ino
, cpos
);
108 rec
= &el
->l_recs
[index
];
110 BUG_ON(ext_flags
!= rec
->e_flags
);
112 * after moving/defraging to new location, the extent is not going
113 * to be refcounted anymore.
115 replace_rec
.e_flags
= ext_flags
& ~OCFS2_EXT_REFCOUNTED
;
117 ret
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
),
118 context
->et
.et_root_bh
,
119 OCFS2_JOURNAL_ACCESS_WRITE
);
125 ret
= ocfs2_split_extent(handle
, &context
->et
, path
, index
,
126 &replace_rec
, context
->meta_ac
,
133 ocfs2_journal_dirty(handle
, context
->et
.et_root_bh
);
135 context
->new_phys_cpos
= new_p_cpos
;
138 * need I to append truncate log for old clusters?
141 if (ext_flags
& OCFS2_EXT_REFCOUNTED
)
142 ret
= ocfs2_decrease_refcount(inode
, handle
,
143 ocfs2_blocks_to_clusters(osb
->sb
,
145 len
, context
->meta_ac
,
146 &context
->dealloc
, 1);
148 ret
= ocfs2_truncate_log_append(osb
, handle
,
152 ocfs2_update_inode_fsync_trans(handle
, inode
, 0);
154 ocfs2_free_path(path
);
159 * lock allocators, and reserving appropriate number of bits for
160 * meta blocks and data clusters.
162 * in some cases, we don't need to reserve clusters, just let data_ac
165 static int ocfs2_lock_allocators_move_extents(struct inode
*inode
,
166 struct ocfs2_extent_tree
*et
,
167 u32 clusters_to_move
,
168 u32 extents_to_split
,
169 struct ocfs2_alloc_context
**meta_ac
,
170 struct ocfs2_alloc_context
**data_ac
,
174 int ret
, num_free_extents
;
175 unsigned int max_recs_needed
= 2 * extents_to_split
+ clusters_to_move
;
176 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
178 num_free_extents
= ocfs2_num_free_extents(osb
, et
);
179 if (num_free_extents
< 0) {
180 ret
= num_free_extents
;
185 if (!num_free_extents
||
186 (ocfs2_sparse_alloc(osb
) && num_free_extents
< max_recs_needed
))
187 extra_blocks
+= ocfs2_extend_meta_needed(et
->et_root_el
);
189 ret
= ocfs2_reserve_new_metadata_blocks(osb
, extra_blocks
, meta_ac
);
196 ret
= ocfs2_reserve_clusters(osb
, clusters_to_move
, data_ac
);
203 *credits
+= ocfs2_calc_extend_credits(osb
->sb
, et
->et_root_el
);
205 mlog(0, "reserve metadata_blocks: %d, data_clusters: %u, credits: %d\n",
206 extra_blocks
, clusters_to_move
, *credits
);
210 ocfs2_free_alloc_context(*meta_ac
);
219 * Using one journal handle to guarantee the data consistency in case
220 * crash happens anywhere.
222 * XXX: defrag can end up with finishing partial extent as requested,
223 * due to not enough contiguous clusters can be found in allocator.
225 static int ocfs2_defrag_extent(struct ocfs2_move_extents_context
*context
,
226 u32 cpos
, u32 phys_cpos
, u32
*len
, int ext_flags
)
228 int ret
, credits
= 0, extra_blocks
= 0, partial
= context
->partial
;
230 struct inode
*inode
= context
->inode
;
231 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
232 struct inode
*tl_inode
= osb
->osb_tl_inode
;
233 struct ocfs2_refcount_tree
*ref_tree
= NULL
;
234 u32 new_phys_cpos
, new_len
;
235 u64 phys_blkno
= ocfs2_clusters_to_blocks(inode
->i_sb
, phys_cpos
);
237 if ((ext_flags
& OCFS2_EXT_REFCOUNTED
) && *len
) {
238 BUG_ON(!ocfs2_is_refcount_inode(inode
));
239 BUG_ON(!context
->refcount_loc
);
241 ret
= ocfs2_lock_refcount_tree(osb
, context
->refcount_loc
, 1,
248 ret
= ocfs2_prepare_refcount_change_for_del(inode
,
249 context
->refcount_loc
,
260 ret
= ocfs2_lock_allocators_move_extents(inode
, &context
->et
, *len
, 1,
263 extra_blocks
, &credits
);
270 * should be using allocation reservation strategy there?
272 * if (context->data_ac)
273 * context->data_ac->ac_resv = &OCFS2_I(inode)->ip_la_data_resv;
276 inode_lock(tl_inode
);
278 if (ocfs2_truncate_log_needs_flush(osb
)) {
279 ret
= __ocfs2_flush_truncate_log(osb
);
282 goto out_unlock_mutex
;
286 handle
= ocfs2_start_trans(osb
, credits
);
287 if (IS_ERR(handle
)) {
288 ret
= PTR_ERR(handle
);
290 goto out_unlock_mutex
;
293 ret
= __ocfs2_claim_clusters(handle
, context
->data_ac
, 1, *len
,
294 &new_phys_cpos
, &new_len
);
301 * allowing partial extent moving is kind of 'pros and cons', it makes
302 * whole defragmentation less likely to fail, on the contrary, the bad
303 * thing is it may make the fs even more fragmented after moving, let
304 * userspace make a good decision here.
306 if (new_len
!= *len
) {
307 mlog(0, "len_claimed: %u, len: %u\n", new_len
, *len
);
309 context
->range
->me_flags
&= ~OCFS2_MOVE_EXT_FL_COMPLETE
;
315 mlog(0, "cpos: %u, phys_cpos: %u, new_phys_cpos: %u\n", cpos
,
316 phys_cpos
, new_phys_cpos
);
318 ret
= __ocfs2_move_extent(handle
, context
, cpos
, new_len
, phys_cpos
,
319 new_phys_cpos
, ext_flags
);
323 if (partial
&& (new_len
!= *len
))
327 * Here we should write the new page out first if we are
328 * in write-back mode.
330 ret
= ocfs2_cow_sync_writeback(inode
->i_sb
, context
->inode
, cpos
, *len
);
335 ocfs2_commit_trans(osb
, handle
);
338 inode_unlock(tl_inode
);
340 if (context
->data_ac
) {
341 ocfs2_free_alloc_context(context
->data_ac
);
342 context
->data_ac
= NULL
;
345 if (context
->meta_ac
) {
346 ocfs2_free_alloc_context(context
->meta_ac
);
347 context
->meta_ac
= NULL
;
352 ocfs2_unlock_refcount_tree(osb
, ref_tree
, 1);
358 * find the victim alloc group, where #blkno fits.
360 static int ocfs2_find_victim_alloc_group(struct inode
*inode
,
364 struct buffer_head
**ret_bh
)
366 int ret
, i
, bits_per_unit
= 0;
370 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
371 struct buffer_head
*ac_bh
= NULL
, *gd_bh
= NULL
;
372 struct ocfs2_chain_list
*cl
;
373 struct ocfs2_chain_rec
*rec
;
374 struct ocfs2_dinode
*ac_dinode
;
375 struct ocfs2_group_desc
*bg
;
377 ocfs2_sprintf_system_inode_name(namebuf
, sizeof(namebuf
), type
, slot
);
378 ret
= ocfs2_lookup_ino_from_name(osb
->sys_root_inode
, namebuf
,
379 strlen(namebuf
), &blkno
);
385 ret
= ocfs2_read_blocks_sync(osb
, blkno
, 1, &ac_bh
);
391 ac_dinode
= (struct ocfs2_dinode
*)ac_bh
->b_data
;
392 cl
= &(ac_dinode
->id2
.i_chain
);
393 rec
= &(cl
->cl_recs
[0]);
395 if (type
== GLOBAL_BITMAP_SYSTEM_INODE
)
396 bits_per_unit
= osb
->s_clustersize_bits
-
397 inode
->i_sb
->s_blocksize_bits
;
399 * 'vict_blkno' was out of the valid range.
401 if ((vict_blkno
< le64_to_cpu(rec
->c_blkno
)) ||
402 (vict_blkno
>= ((u64
)le32_to_cpu(ac_dinode
->id1
.bitmap1
.i_total
) <<
408 for (i
= 0; i
< le16_to_cpu(cl
->cl_next_free_rec
); i
++) {
410 rec
= &(cl
->cl_recs
[i
]);
418 blkno
= le64_to_cpu(rec
->c_blkno
);
420 blkno
= le64_to_cpu(bg
->bg_next_group
);
427 ret
= ocfs2_read_blocks_sync(osb
, blkno
, 1, &gd_bh
);
433 bg
= (struct ocfs2_group_desc
*)gd_bh
->b_data
;
435 if (vict_blkno
< (le64_to_cpu(bg
->bg_blkno
) +
436 le16_to_cpu(bg
->bg_bits
))) {
439 *vict_bit
= (vict_blkno
- blkno
) >>
441 mlog(0, "find the victim group: #%llu, "
442 "total_bits: %u, vict_bit: %u\n",
443 blkno
, le16_to_cpu(bg
->bg_bits
),
448 } while (le64_to_cpu(bg
->bg_next_group
));
456 * caller has to release the gd_bh properly.
462 * XXX: helper to validate and adjust moving goal.
464 static int ocfs2_validate_and_adjust_move_goal(struct inode
*inode
,
465 struct ocfs2_move_extents
*range
)
467 int ret
, goal_bit
= 0;
469 struct buffer_head
*gd_bh
= NULL
;
470 struct ocfs2_group_desc
*bg
;
471 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
472 int c_to_b
= 1 << (osb
->s_clustersize_bits
-
473 inode
->i_sb
->s_blocksize_bits
);
476 * make goal become cluster aligned.
478 range
->me_goal
= ocfs2_block_to_cluster_start(inode
->i_sb
,
481 * validate goal sits within global_bitmap, and return the victim
484 ret
= ocfs2_find_victim_alloc_group(inode
, range
->me_goal
,
485 GLOBAL_BITMAP_SYSTEM_INODE
,
491 bg
= (struct ocfs2_group_desc
*)gd_bh
->b_data
;
494 * moving goal is not allowd to start with a group desc blok(#0 blk)
495 * let's compromise to the latter cluster.
497 if (range
->me_goal
== le64_to_cpu(bg
->bg_blkno
))
498 range
->me_goal
+= c_to_b
;
501 * movement is not gonna cross two groups.
503 if ((le16_to_cpu(bg
->bg_bits
) - goal_bit
) * osb
->s_clustersize
<
509 * more exact validations/adjustments will be performed later during
510 * moving operation for each extent range.
512 mlog(0, "extents get ready to be moved to #%llu block\n",
521 static void ocfs2_probe_alloc_group(struct inode
*inode
, struct buffer_head
*bh
,
522 int *goal_bit
, u32 move_len
, u32 max_hop
,
525 int i
, used
, last_free_bits
= 0, base_bit
= *goal_bit
;
526 struct ocfs2_group_desc
*gd
= (struct ocfs2_group_desc
*)bh
->b_data
;
527 u32 base_cpos
= ocfs2_blocks_to_clusters(inode
->i_sb
,
528 le64_to_cpu(gd
->bg_blkno
));
530 for (i
= base_bit
; i
< le16_to_cpu(gd
->bg_bits
); i
++) {
532 used
= ocfs2_test_bit(i
, (unsigned long *)gd
->bg_bitmap
);
535 * we even tried searching the free chunk by jumping
536 * a 'max_hop' distance, but still failed.
538 if ((i
- base_bit
) > max_hop
) {
550 if (last_free_bits
== move_len
) {
552 *phys_cpos
= base_cpos
+ i
;
557 mlog(0, "found phys_cpos: %u to fit the wanted moving.\n", *phys_cpos
);
560 static int ocfs2_move_extent(struct ocfs2_move_extents_context
*context
,
561 u32 cpos
, u32 phys_cpos
, u32
*new_phys_cpos
,
562 u32 len
, int ext_flags
)
564 int ret
, credits
= 0, extra_blocks
= 0, goal_bit
= 0;
566 struct inode
*inode
= context
->inode
;
567 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
568 struct inode
*tl_inode
= osb
->osb_tl_inode
;
569 struct inode
*gb_inode
= NULL
;
570 struct buffer_head
*gb_bh
= NULL
;
571 struct buffer_head
*gd_bh
= NULL
;
572 struct ocfs2_group_desc
*gd
;
573 struct ocfs2_refcount_tree
*ref_tree
= NULL
;
574 u32 move_max_hop
= ocfs2_blocks_to_clusters(inode
->i_sb
,
575 context
->range
->me_threshold
);
576 u64 phys_blkno
, new_phys_blkno
;
578 phys_blkno
= ocfs2_clusters_to_blocks(inode
->i_sb
, phys_cpos
);
580 if ((ext_flags
& OCFS2_EXT_REFCOUNTED
) && len
) {
581 BUG_ON(!ocfs2_is_refcount_inode(inode
));
582 BUG_ON(!context
->refcount_loc
);
584 ret
= ocfs2_lock_refcount_tree(osb
, context
->refcount_loc
, 1,
591 ret
= ocfs2_prepare_refcount_change_for_del(inode
,
592 context
->refcount_loc
,
603 ret
= ocfs2_lock_allocators_move_extents(inode
, &context
->et
, len
, 1,
605 NULL
, extra_blocks
, &credits
);
612 * need to count 2 extra credits for global_bitmap inode and
615 credits
+= OCFS2_INODE_UPDATE_CREDITS
+ 1;
618 * ocfs2_move_extent() didn't reserve any clusters in lock_allocators()
619 * logic, while we still need to lock the global_bitmap.
621 gb_inode
= ocfs2_get_system_file_inode(osb
, GLOBAL_BITMAP_SYSTEM_INODE
,
624 mlog(ML_ERROR
, "unable to get global_bitmap inode\n");
629 inode_lock(gb_inode
);
631 ret
= ocfs2_inode_lock(gb_inode
, &gb_bh
, 1);
634 goto out_unlock_gb_mutex
;
637 inode_lock(tl_inode
);
639 handle
= ocfs2_start_trans(osb
, credits
);
640 if (IS_ERR(handle
)) {
641 ret
= PTR_ERR(handle
);
643 goto out_unlock_tl_inode
;
646 new_phys_blkno
= ocfs2_clusters_to_blocks(inode
->i_sb
, *new_phys_cpos
);
647 ret
= ocfs2_find_victim_alloc_group(inode
, new_phys_blkno
,
648 GLOBAL_BITMAP_SYSTEM_INODE
,
657 * probe the victim cluster group to find a proper
658 * region to fit wanted movement, it even will perfrom
659 * a best-effort attempt by compromising to a threshold
662 ocfs2_probe_alloc_group(inode
, gd_bh
, &goal_bit
, len
, move_max_hop
,
664 if (!*new_phys_cpos
) {
669 ret
= __ocfs2_move_extent(handle
, context
, cpos
, len
, phys_cpos
,
670 *new_phys_cpos
, ext_flags
);
676 gd
= (struct ocfs2_group_desc
*)gd_bh
->b_data
;
677 ret
= ocfs2_alloc_dinode_update_counts(gb_inode
, handle
, gb_bh
, len
,
678 le16_to_cpu(gd
->bg_chain
));
684 ret
= ocfs2_block_group_set_bits(handle
, gb_inode
, gd
, gd_bh
,
687 ocfs2_rollback_alloc_dinode_counts(gb_inode
, gb_bh
, len
,
688 le16_to_cpu(gd
->bg_chain
));
693 * Here we should write the new page out first if we are
694 * in write-back mode.
696 ret
= ocfs2_cow_sync_writeback(inode
->i_sb
, context
->inode
, cpos
, len
);
701 ocfs2_commit_trans(osb
, handle
);
705 inode_unlock(tl_inode
);
707 ocfs2_inode_unlock(gb_inode
, 1);
709 inode_unlock(gb_inode
);
714 if (context
->meta_ac
) {
715 ocfs2_free_alloc_context(context
->meta_ac
);
716 context
->meta_ac
= NULL
;
720 ocfs2_unlock_refcount_tree(osb
, ref_tree
, 1);
726 * Helper to calculate the defraging length in one run according to threshold.
728 static void ocfs2_calc_extent_defrag_len(u32
*alloc_size
, u32
*len_defraged
,
729 u32 threshold
, int *skip
)
731 if ((*alloc_size
+ *len_defraged
) < threshold
) {
733 * proceed defragmentation until we meet the thresh
735 *len_defraged
+= *alloc_size
;
736 } else if (*len_defraged
== 0) {
738 * XXX: skip a large extent.
743 * split this extent to coalesce with former pieces as
744 * to reach the threshold.
746 * we're done here with one cycle of defragmentation
747 * in a size of 'thresh', resetting 'len_defraged'
748 * forces a new defragmentation.
750 *alloc_size
= threshold
- *len_defraged
;
755 static int __ocfs2_move_extents_range(struct buffer_head
*di_bh
,
756 struct ocfs2_move_extents_context
*context
)
758 int ret
= 0, flags
, do_defrag
, skip
= 0;
759 u32 cpos
, phys_cpos
, move_start
, len_to_move
, alloc_size
;
760 u32 len_defraged
= 0, defrag_thresh
= 0, new_phys_cpos
= 0;
762 struct inode
*inode
= context
->inode
;
763 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
764 struct ocfs2_move_extents
*range
= context
->range
;
765 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
767 if ((i_size_read(inode
) == 0) || (range
->me_len
== 0))
770 if (OCFS2_I(inode
)->ip_dyn_features
& OCFS2_INLINE_DATA_FL
)
773 context
->refcount_loc
= le64_to_cpu(di
->i_refcount_loc
);
775 ocfs2_init_dinode_extent_tree(&context
->et
, INODE_CACHE(inode
), di_bh
);
776 ocfs2_init_dealloc_ctxt(&context
->dealloc
);
784 do_defrag
= context
->auto_defrag
;
787 * extents moving happens in unit of clusters, for the sake
788 * of simplicity, we may ignore two clusters where 'byte_start'
789 * and 'byte_start + len' were within.
791 move_start
= ocfs2_clusters_for_bytes(osb
->sb
, range
->me_start
);
792 len_to_move
= (range
->me_start
+ range
->me_len
) >>
793 osb
->s_clustersize_bits
;
794 if (len_to_move
>= move_start
)
795 len_to_move
-= move_start
;
800 defrag_thresh
= range
->me_threshold
>> osb
->s_clustersize_bits
;
801 if (defrag_thresh
<= 1)
804 new_phys_cpos
= ocfs2_blocks_to_clusters(inode
->i_sb
,
807 mlog(0, "Inode: %llu, start: %llu, len: %llu, cstart: %u, clen: %u, "
809 (unsigned long long)OCFS2_I(inode
)->ip_blkno
,
810 (unsigned long long)range
->me_start
,
811 (unsigned long long)range
->me_len
,
812 move_start
, len_to_move
, defrag_thresh
);
815 while (len_to_move
) {
816 ret
= ocfs2_get_clusters(inode
, cpos
, &phys_cpos
, &alloc_size
,
823 if (alloc_size
> len_to_move
)
824 alloc_size
= len_to_move
;
827 * XXX: how to deal with a hole:
829 * - skip the hole of course
830 * - force a new defragmentation
840 ocfs2_calc_extent_defrag_len(&alloc_size
, &len_defraged
,
841 defrag_thresh
, &skip
);
850 mlog(0, "#Defrag: cpos: %u, phys_cpos: %u, "
851 "alloc_size: %u, len_defraged: %u\n",
852 cpos
, phys_cpos
, alloc_size
, len_defraged
);
854 ret
= ocfs2_defrag_extent(context
, cpos
, phys_cpos
,
857 ret
= ocfs2_move_extent(context
, cpos
, phys_cpos
,
858 &new_phys_cpos
, alloc_size
,
861 new_phys_cpos
+= alloc_size
;
869 context
->clusters_moved
+= alloc_size
;
872 len_to_move
-= alloc_size
;
876 range
->me_flags
|= OCFS2_MOVE_EXT_FL_COMPLETE
;
879 range
->me_moved_len
= ocfs2_clusters_to_bytes(osb
->sb
,
880 context
->clusters_moved
);
881 range
->me_new_offset
= ocfs2_clusters_to_bytes(osb
->sb
,
882 context
->new_phys_cpos
);
884 ocfs2_schedule_truncate_log_flush(osb
, 1);
885 ocfs2_run_deallocs(osb
, &context
->dealloc
);
890 static int ocfs2_move_extents(struct ocfs2_move_extents_context
*context
)
894 struct inode
*inode
= context
->inode
;
895 struct ocfs2_dinode
*di
;
896 struct buffer_head
*di_bh
= NULL
;
897 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
899 if (ocfs2_is_hard_readonly(osb
) || ocfs2_is_soft_readonly(osb
))
905 * This prevents concurrent writes from other nodes
907 status
= ocfs2_rw_lock(inode
, 1);
913 status
= ocfs2_inode_lock(inode
, &di_bh
, 1);
920 * rememer ip_xattr_sem also needs to be held if necessary
922 down_write(&OCFS2_I(inode
)->ip_alloc_sem
);
924 status
= __ocfs2_move_extents_range(di_bh
, context
);
926 up_write(&OCFS2_I(inode
)->ip_alloc_sem
);
929 goto out_inode_unlock
;
933 * We update ctime for these changes
935 handle
= ocfs2_start_trans(osb
, OCFS2_INODE_UPDATE_CREDITS
);
936 if (IS_ERR(handle
)) {
937 status
= PTR_ERR(handle
);
939 goto out_inode_unlock
;
942 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
), di_bh
,
943 OCFS2_JOURNAL_ACCESS_WRITE
);
949 di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
950 inode
->i_ctime
= current_time(inode
);
951 di
->i_ctime
= cpu_to_le64(inode
->i_ctime
.tv_sec
);
952 di
->i_ctime_nsec
= cpu_to_le32(inode
->i_ctime
.tv_nsec
);
953 ocfs2_update_inode_fsync_trans(handle
, inode
, 0);
955 ocfs2_journal_dirty(handle
, di_bh
);
958 ocfs2_commit_trans(osb
, handle
);
962 ocfs2_inode_unlock(inode
, 1);
964 ocfs2_rw_unlock(inode
, 1);
971 int ocfs2_ioctl_move_extents(struct file
*filp
, void __user
*argp
)
975 struct inode
*inode
= file_inode(filp
);
976 struct ocfs2_move_extents range
;
977 struct ocfs2_move_extents_context
*context
;
982 status
= mnt_want_write_file(filp
);
986 if ((!S_ISREG(inode
->i_mode
)) || !(filp
->f_mode
& FMODE_WRITE
)) {
991 if (inode
->i_flags
& (S_IMMUTABLE
|S_APPEND
)) {
996 context
= kzalloc(sizeof(struct ocfs2_move_extents_context
), GFP_NOFS
);
1003 context
->inode
= inode
;
1004 context
->file
= filp
;
1006 if (copy_from_user(&range
, argp
, sizeof(range
))) {
1011 if (range
.me_start
> i_size_read(inode
)) {
1016 if (range
.me_start
+ range
.me_len
> i_size_read(inode
))
1017 range
.me_len
= i_size_read(inode
) - range
.me_start
;
1019 context
->range
= &range
;
1021 if (range
.me_flags
& OCFS2_MOVE_EXT_FL_AUTO_DEFRAG
) {
1022 context
->auto_defrag
= 1;
1024 * ok, the default theshold for the defragmentation
1025 * is 1M, since our maximum clustersize was 1M also.
1028 if (!range
.me_threshold
)
1029 range
.me_threshold
= 1024 * 1024;
1031 if (range
.me_threshold
> i_size_read(inode
))
1032 range
.me_threshold
= i_size_read(inode
);
1034 if (range
.me_flags
& OCFS2_MOVE_EXT_FL_PART_DEFRAG
)
1035 context
->partial
= 1;
1038 * first best-effort attempt to validate and adjust the goal
1039 * (physical address in block), while it can't guarantee later
1040 * operation can succeed all the time since global_bitmap may
1041 * change a bit over time.
1044 status
= ocfs2_validate_and_adjust_move_goal(inode
, &range
);
1049 status
= ocfs2_move_extents(context
);
1054 * movement/defragmentation may end up being partially completed,
1055 * that's the reason why we need to return userspace the finished
1056 * length and new_offset even if failure happens somewhere.
1058 if (copy_to_user(argp
, &range
, sizeof(range
)))
1064 mnt_drop_write_file(filp
);