From: Amir Goldstein <amir73il@xxxxxxxxxxxx>
Implementation of moving blocks into a snapshot file.
The move block command maps an allocated blocks to the snapshot file,
allocating only the indirect blocks when needed.
This mechanism is used to move-on-write data blocks to snapshot.
Signed-off-by: Amir Goldstein <amir73il@xxxxxxxxxxxx>
Signed-off-by: Yongqiang Yang <xiaoqiangnk@xxxxxxxxx>
---
fs/ext4/inode.c | 62 +++++++++++++++++++-------
fs/ext4/snapshot.c | 120 ++++++++++++++++++++++++++++++++++++++++++++++++++++
fs/ext4/snapshot.h | 12 +++++-
3 files changed, 176 insertions(+), 18 deletions(-)
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index cdc1752..1558a7b 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -676,6 +676,11 @@ static int ext4_alloc_blocks(handle_t *handle, struct inode *inode,
new_blocks[index++] = current_block++;
count--;
}
+ if (blks == 0 && target == 0) {
+ /* mapping data blocks */
+ *err = 0;
+ return 0;
+ }
if (count > 0) {
/*
* save the new block number
@@ -777,10 +782,10 @@ failed_out:
* ext4_alloc_block() (normally -ENOSPC). Otherwise we set the chain
* as described above and return 0.
*/
-static int ext4_alloc_branch(handle_t *handle, struct inode *inode,
- ext4_lblk_t iblock, int indirect_blks,
- int *blks, ext4_fsblk_t goal,
- ext4_lblk_t *offsets, Indirect *branch)
+static int ext4_alloc_branch_cow(handle_t *handle, struct inode *inode,
+ ext4_fsblk_t iblock, int indirect_blks,
+ int *blks, ext4_fsblk_t goal,
+ int *offsets, Indirect *branch, int flags)
{
int blocksize = inode->i_sb->s_blocksize;
int i, n = 0;
@@ -790,6 +795,22 @@ static int ext4_alloc_branch(handle_t *handle, struct inode *inode,
ext4_fsblk_t new_blocks[4];
ext4_fsblk_t current_block;
+ if (SNAPMAP_ISMOVE(flags)) {
+ /* mapping snapshot block to block device block */
+ current_block = SNAPSHOT_BLOCK(iblock);
+ num = 0;
+ if (indirect_blks > 0) {
+ /* allocating only indirect blocks */
+ ext4_alloc_blocks(handle, inode, iblock, goal,
+ indirect_blks, 0, new_blocks, &err);
+ if (err)
+ return err;
+ }
+ /* charge snapshot file owner for moved blocks */
+ dquot_alloc_block_nofail(inode, *blks);
+ num = *blks;
+ new_blocks[indirect_blks] = current_block;
+ } else
num = ext4_alloc_blocks(handle, inode, iblock, goal, indirect_blks,
*blks, new_blocks, &err);
if (err)
@@ -861,8 +882,11 @@ failed:
}
for (i = n+1; i < indirect_blks; i++)
ext4_free_blocks(handle, inode, NULL, new_blocks[i], 1, 0);
-
- ext4_free_blocks(handle, inode, NULL, new_blocks[i], num, 0);
+ if (SNAPMAP_ISMOVE(flags) && num > 0)
+ /* don't charge snapshot file owner if move failed */
+ dquot_free_block(inode, num);
+ else if (num > 0)
+ ext4_free_blocks(handle, inode, NULL, new_blocks[i], num, 0);
return err;
}
@@ -882,9 +906,8 @@ failed:
* inode (->i_blocks, etc.). In case of success we end up with the full
* chain to new block and return 0.
*/
-static int ext4_splice_branch(handle_t *handle, struct inode *inode,
- ext4_lblk_t block, Indirect *where, int num,
- int blks)
+static int ext4_splice_branch_cow(handle_t *handle, struct inode *inode,
+ long block, Indirect *where, int num, int blks, int flags)
{
int i;
int err = 0;
@@ -951,8 +974,12 @@ err_out:
ext4_free_blocks(handle, inode, where[i].bh, 0, 1,
EXT4_FREE_BLOCKS_FORGET);
}
- ext4_free_blocks(handle, inode, NULL, le32_to_cpu(where[num].key),
- blks, 0);
+ if (SNAPMAP_ISMOVE(flags))
+ /* don't charge snapshot file owner if move failed */
+ dquot_free_block(inode, blks);
+ else
+ ext4_free_blocks(handle, inode, NULL,
+ le32_to_cpu(where[num].key), blks, 0);
return err;
}
@@ -1099,9 +1126,11 @@ static int ext4_ind_map_blocks(handle_t *handle, struct inode *inode,
/*
* Block out ext4_truncate while we alter the tree
*/
- err = ext4_alloc_branch(handle, inode, map->m_lblk, indirect_blks,
- &count, goal,
- offsets + (partial - chain), partial);
+ err = ext4_alloc_branch_cow(handle, inode, map->m_lblk, indirect_blks,
+ &count, goal, offsets + (partial - chain),
+ partial, flags);
+ if (err)
+ goto cleanup;
if (map->m_flags & EXT4_MAP_REMAP) {
map->m_len = count;
@@ -1127,9 +1156,8 @@ static int ext4_ind_map_blocks(handle_t *handle, struct inode *inode,
* credits cannot be returned. Can we handle this somehow? We
* may need to return -EAGAIN upwards in the worst case. --sct
*/
- if (!err)
- err = ext4_splice_branch(handle, inode, map->m_lblk,
- partial, indirect_blks, count);
+ err = ext4_splice_branch_cow(handle, inode, map->m_lblk, partial,
+ indirect_blks, count, flags);
if (err)
goto cleanup;
diff --git a/fs/ext4/snapshot.c b/fs/ext4/snapshot.c
index fc91ca4..adeb0b6 100644
--- a/fs/ext4/snapshot.c
+++ b/fs/ext4/snapshot.c
@@ -328,3 +328,123 @@ out:
return err;
}
+/*
+ * ext4_snapshot_test_and_move - move blocks to active snapshot
+ * @where: name of caller function
+ * @handle: JBD handle
+ * @inode: owner of blocks (NULL for global metadata blocks)
+ * @block: address of first block to move
+ * @maxblocks: max. blocks to move
+ * @move: if false, only test if @block needs to be moved
+ *
+ * Return values:
+ * > 0 - blocks a) were moved to snapshot for @move = 1;
+ * b) needs to be moved for @move = 0
+ * = 0 - blocks dont need to be moved
+ * < 0 - error
+ */
+int ext4_snapshot_test_and_move(const char *where, handle_t *handle,
+ struct inode *inode, ext4_fsblk_t block, int *maxblocks, int move)
+{
+ struct super_block *sb = handle->h_transaction->t_journal->j_private;
+ struct inode *active_snapshot = ext4_snapshot_has_active(sb);
+ ext4_fsblk_t blk = 0;
+ int err = 0, count = *maxblocks;
+ int moved_blks = 0;
+ int excluded = 0;
+
+ if (!active_snapshot)
+ /* no active snapshot - no need to move */
+ return 0;
+
+ ext4_snapshot_trace_cow(where, handle, sb, inode, NULL, block, count,
+ move);
+
+ BUG_ON(IS_COWING(handle) || inode == active_snapshot);
+
+ /* BEGIN moving */
+ ext4_snapshot_cow_begin(handle);
+
+ if (inode)
+ excluded = ext4_snapshot_excluded(inode);
+ if (excluded) {
+ /* don't move excluded file block to snapshot */
+ snapshot_debug_hl(4, "file (%lu) excluded from snapshot\n",
+ inode->i_ino);
+ move = 0;
+ }
+
+ if (excluded)
+ goto out;
+ if (!err) {
+ /* block not in COW bitmap - no need to move */
+ trace_cow_add(handle, ok_bitmap, count);
+ goto out;
+ }
+
+#ifdef CONFIG_EXT4_DEBUG
+ if (inode == NULL &&
+ !(EXT4_I(active_snapshot)->i_flags & EXT4_UNRM_FL)) {
+ /*
+ * This is ext4_group_extend() "freeing" the blocks that
+ * were added to the block group. These block should not be
+ * moved to snapshot, unless the snapshot is marked with the
+ * UNRM flag for large snapshot creation test.
+ */
+ trace_cow_add(handle, ok_bitmap, count);
+ err = 0;
+ goto out;
+ }
+#endif
+
+ /* count blocks are in use by snapshot - check if @block is mapped */
+ err = ext4_snapshot_map_blocks(handle, active_snapshot, block, count,
+ &blk, SNAPMAP_READ);
+ if (err < 0)
+ goto out;
+ if (err > 0) {
+ /* blocks already mapped in snapshot - no need to move */
+ count = err;
+ trace_cow_add(handle, ok_mapped, count);
+ err = 0;
+ goto out;
+ }
+
+ /* @count blocks need to be moved */
+ err = count;
+ if (!move)
+ /* don't move - we were just checking */
+ goto out;
+
+ /* try to move @count blocks from inode to snapshot.
+ * @count blocks may cross block boundry.
+ * TODO: if moving fails after some blocks has been moved,
+ * maybe we need a blockbitmap fsck.
+ */
+ blk = block;
+ while (count) {
+ err = ext4_snapshot_map_blocks(handle, active_snapshot, blk,
+ count, NULL, SNAPMAP_MOVE);
+ if (err <= 0)
+ goto out;
+ moved_blks += err;
+ blk += err;
+ count -= err;
+ }
+ count = moved_blks;
+ err = moved_blks;
+ /*
+ * User should no longer be charged for these blocks.
+ * Snapshot file owner was charged for these blocks
+ * when they were mapped to snapshot file.
+ */
+ if (inode)
+ dquot_free_block(inode, count);
+ trace_cow_add(handle, moved, count);
+out:
+ /* END moving */
+ ext4_snapshot_cow_end(where, handle, block, err);
+ *maxblocks = count;
+ return err;
+}
+
diff --git a/fs/ext4/snapshot.h b/fs/ext4/snapshot.h
index 90cb33e..fc5dbec 100644
--- a/fs/ext4/snapshot.h
+++ b/fs/ext4/snapshot.h
@@ -186,7 +186,17 @@ extern int ext4_snapshot_test_and_cow(const char *where,
ext4_snapshot_test_and_cow(__func__, handle, inode, \
block, bh, cow)
-#define ext4_snapshot_move(handle, inode, block, pcount, move) (0)
+extern int ext4_snapshot_test_and_move(const char *where,
+ handle_t *handle, struct inode *inode,
+ ext4_fsblk_t block, int *pcount, int move);
+
+/*
+ * test if blocks should be moved to snapshot
+ * and if they should, try to move them to the active snapshot
+ */
+#define ext4_snapshot_move(handle, inode, block, pcount, move) \
+ ext4_snapshot_test_and_move(__func__, handle, inode, \
+ block, pcount, move)
/*
* Block access functions
--
1.7.4.1
--
To unsubscribe from this list: send the line "unsubscribe linux-ext4" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
