From: Amir Goldstein <amir73il@xxxxxxxxxxxx>
Cache last COW transaction id in buffer's journal_head.
The cache suppresses COW tests until the transaction in committed.
By default, the running transaction is committed every 5 seconds
which implies an average COW cache expiry of 2.5 seconds.
Before taking a new snapshot, the journal is flushed to disk
and the current transaction in committed, so the COW cache is
invalidated (as it should be).
Signed-off-by: Amir Goldstein <amir73il@xxxxxxxxxxxx>
Signed-off-by: Yongqiang Yang <xiaoqiangnk@xxxxxxxxx>
---
fs/ext4/snapshot.c | 93 ++++++++++++++++++++++++++++++++++++++++++++++
fs/ext4/snapshot.h | 2 +
fs/ext4/snapshot_debug.c | 7 +++
3 files changed, 102 insertions(+), 0 deletions(-)
diff --git a/fs/ext4/snapshot.c b/fs/ext4/snapshot.c
index e86dc42..2724381 100644
--- a/fs/ext4/snapshot.c
+++ b/fs/ext4/snapshot.c
@@ -400,6 +400,90 @@ __ext4_snapshot_trace_cow(const char *where, handle_t *handle,
#define ext4_snapshot_trace_cow(where, handle, sb, inode, bh, blk, cnt, cmd)
#endif
/*
+ * The last transaction ID during which the buffer has been COWed is stored in
+ * the b_cow_tid field of the journal_head struct. If we know that the buffer
+ * was COWed during the current transaction, we don't need to COW it again.
+ * [jbd_lock_bh_state()]
+ */
+
+void init_ext4_snapshot_cow_cache(void)
+{
+#ifdef CONFIG_EXT4_DEBUG
+ cow_cache_enabled = 1;
+#endif
+}
+
+#ifdef CONFIG_EXT4_DEBUG
+#define cow_cache_enabled() (cow_cache_enabled)
+#else
+#define cow_cache_enabled() (1)
+#endif
+
+#define test_cow_tid(jh, handle) \
+ ((jh)->b_cow_tid == (handle)->h_transaction->t_tid)
+#define set_cow_tid(jh, handle) \
+ ((jh)->b_cow_tid = (handle)->h_transaction->t_tid)
+
+/*
+ * Journal COW cache functions.
+ * a block can only be COWed once per snapshot,
+ * so a block can only be COWed once per transaction,
+ * so a buffer that was COWed in the current transaction,
+ * doesn't need to be COWed.
+ *
+ * Return values:
+ * 1 - block was COWed in current transaction
+ * 0 - block wasn't COWed in current transaction
+ */
+static int
+ext4_snapshot_test_cowed(handle_t *handle, struct buffer_head *bh)
+{
+ struct journal_head *jh;
+
+ if (!cow_cache_enabled())
+ return 0;
+
+ /* check the COW tid in the journal head */
+ if (bh && buffer_jbd(bh)) {
+ jbd_lock_bh_state(bh);
+ jh = bh2jh(bh);
+ if (jh && !test_cow_tid(jh, handle))
+ jh = NULL;
+ jbd_unlock_bh_state(bh);
+ if (jh)
+ /*
+ * Block was already COWed in the running transaction,
+ * so we don't need to COW it again.
+ */
+ return 1;
+ }
+ return 0;
+}
+
+static void
+ext4_snapshot_mark_cowed(handle_t *handle, struct buffer_head *bh)
+{
+ struct journal_head *jh;
+
+ if (!cow_cache_enabled())
+ return;
+
+ if (bh && buffer_jbd(bh)) {
+ jbd_lock_bh_state(bh);
+ jh = bh2jh(bh);
+ if (jh && !test_cow_tid(jh, handle))
+ /*
+ * this is the first time this block was COWed
+ * in the running transaction.
+ * update the COW tid in the journal head
+ * to mark that this block doesn't need to be COWed.
+ */
+ set_cow_tid(jh, handle);
+ jbd_unlock_bh_state(bh);
+ }
+}
+
+/*
* Begin COW or move operation.
* No locks needed here, because @handle is a per-task struct.
*/
@@ -479,6 +563,13 @@ int ext4_snapshot_test_and_cow(const char *where, handle_t *handle,
snapshot_debug_hl(4, "active snapshot access denied!\n");
return -EPERM;
}
+ /* check if the buffer was COWed in the current transaction */
+ if (ext4_snapshot_test_cowed(handle, bh)) {
+ snapshot_debug_hl(4, "buffer found in COW cache - "
+ "skip block cow!\n");
+ trace_cow_inc(handle, ok_jh);
+ return 0;
+ }
/* BEGIN COWing */
ext4_snapshot_cow_begin(handle);
@@ -572,6 +663,8 @@ int ext4_snapshot_test_and_cow(const char *where, handle_t *handle,
test_pending_cow:
cowed:
+ /* mark the buffer COWed in the current transaction */
+ ext4_snapshot_mark_cowed(handle, bh);
out:
brelse(sbh);
/* END COWing */
diff --git a/fs/ext4/snapshot.h b/fs/ext4/snapshot.h
index 007fec0..44bac96 100644
--- a/fs/ext4/snapshot.h
+++ b/fs/ext4/snapshot.h
@@ -342,6 +342,7 @@ static inline int ext4_snapshot_get_delete_access(handle_t *handle,
return ext4_snapshot_move(handle, inode, block, pcount, 1);
}
+extern void init_ext4_snapshot_cow_cache(void);
/* snapshot_ctl.c */
@@ -364,6 +365,7 @@ extern void ext4_snapshot_destroy(struct super_block *sb);
static inline int init_ext4_snapshot(void)
{
+ init_ext4_snapshot_cow_cache();
return 0;
}
diff --git a/fs/ext4/snapshot_debug.c b/fs/ext4/snapshot_debug.c
index 35f552a..265ee2c 100644
--- a/fs/ext4/snapshot_debug.c
+++ b/fs/ext4/snapshot_debug.c
@@ -47,10 +47,12 @@ static const char *snapshot_test_names[SNAPSHOT_TESTS_NUM] = {
u16 snapshot_enable_test[SNAPSHOT_TESTS_NUM] __read_mostly = {0};
u8 snapshot_enable_debug __read_mostly = 1;
+u8 cow_cache_enabled __read_mostly = 1;
static struct dentry *snapshot_debug;
static struct dentry *snapshot_version;
static struct dentry *snapshot_test[SNAPSHOT_TESTS_NUM];
+static struct dentry *cow_cache;
static char snapshot_version_str[] = EXT4_SNAPSHOT_VERSION;
static struct debugfs_blob_wrapper snapshot_version_blob = {
@@ -79,6 +81,9 @@ void ext4_snapshot_create_debugfs_entry(struct dentry *debugfs_dir)
S_IRUGO|S_IWUSR,
debugfs_dir,
&snapshot_enable_test[i]);
+ cow_cache = debugfs_create_u8("cow-cache", S_IRUGO|S_IWUSR,
+ debugfs_dir,
+ &cow_cache_enabled);
}
/*
@@ -89,6 +94,8 @@ void ext4_snapshot_remove_debugfs_entry(void)
{
int i;
+ if (cow_cache)
+ debugfs_remove(cow_cache);
for (i = 0; i < SNAPSHOT_TESTS_NUM && i < SNAPSHOT_TEST_NAMES; i++)
if (snapshot_test[i])
debugfs_remove(snapshot_test[i]);
--
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
