* [PATCH 1/7] btrfs-progs: Basic framework for dedup command group
2015-12-29 8:01 [PATCH 0/7] btrfs-progs: Support for in-band deduplication Qu Wenruo
@ 2015-12-29 8:01 ` Qu Wenruo
2015-12-29 8:01 ` [PATCH 2/7] btrfs-progs: dedup: Add enable command " Qu Wenruo
` (5 subsequent siblings)
6 siblings, 0 replies; 8+ messages in thread
From: Qu Wenruo @ 2015-12-29 8:01 UTC (permalink / raw)
To: linux-btrfs
Add basic ioctl header and command group framework for later use.
Alone with basic man page doc.
Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
---
Documentation/btrfs-dedup.asciidoc | 37 +++++++++++++++++++++++++++++
Makefile.in | 2 +-
btrfs.c | 1 +
cmds-dedup.c | 48 ++++++++++++++++++++++++++++++++++++++
commands.h | 2 ++
ctree.h | 34 ++++++++++++++++++++++++++-
dedup.h | 39 +++++++++++++++++++++++++++++++
ioctl.h | 21 +++++++++++++++++
8 files changed, 182 insertions(+), 2 deletions(-)
create mode 100644 Documentation/btrfs-dedup.asciidoc
create mode 100644 cmds-dedup.c
create mode 100644 dedup.h
diff --git a/Documentation/btrfs-dedup.asciidoc b/Documentation/btrfs-dedup.asciidoc
new file mode 100644
index 0000000..354313f
--- /dev/null
+++ b/Documentation/btrfs-dedup.asciidoc
@@ -0,0 +1,37 @@
+btrfs-dedup(8)
+==============
+
+NAME
+----
+btrfs-dedup - manage in-band (write time) de-duplication of a btrfs filesystem
+
+SYNOPSIS
+--------
+*btrfs dedup* <subcommand> <args>
+
+DESCRIPTION
+-----------
+*btrfs dedup* is used to enable/disable or show current in-band de-duplication
+status of a btrfs filesystem.
+
+WARNING: In-band de-duplication is still a experimental feautre of btrfs,
+use with caution.
+
+SUBCOMMAND
+----------
+Nothing yet
+
+EXIT STATUS
+-----------
+*btrfs dedup* returns a zero exit status if it succeeds. Non zero is
+returned in case of failure.
+
+AVAILABILITY
+------------
+*btrfs* is part of btrfs-progs.
+Please refer to the btrfs wiki http://btrfs.wiki.kernel.org for
+further details.
+
+SEE ALSO
+--------
+`mkfs.btrfs`(8),
diff --git a/Makefile.in b/Makefile.in
index 8e24808..f1fb54c 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -74,7 +74,7 @@ cmds_objects = cmds-subvolume.o cmds-filesystem.o cmds-device.o cmds-scrub.o \
cmds-inspect.o cmds-balance.o cmds-send.o cmds-receive.o \
cmds-quota.o cmds-qgroup.o cmds-replace.o cmds-check.o \
cmds-restore.o cmds-rescue.o chunk-recover.o super-recover.o \
- cmds-property.o cmds-fi-usage.o
+ cmds-property.o cmds-fi-usage.o cmds-dedup.o
libbtrfs_objects = send-stream.o send-utils.o rbtree.o btrfs-list.o crc32c.o \
uuid-tree.o utils-lib.o rbtree-utils.o
libbtrfs_headers = send-stream.h send-utils.h send.h rbtree.h btrfs-list.h \
diff --git a/btrfs.c b/btrfs.c
index 14b556b..0774ebb 100644
--- a/btrfs.c
+++ b/btrfs.c
@@ -208,6 +208,7 @@ static const struct cmd_group btrfs_cmd_group = {
{ "receive", cmd_receive, cmd_receive_usage, NULL, 0 },
{ "quota", cmd_quota, NULL, "a_cmd_group, 0 },
{ "qgroup", cmd_qgroup, NULL, &qgroup_cmd_group, 0 },
+ { "dedup", cmd_dedup, NULL, &dedup_cmd_group, 0 },
{ "replace", cmd_replace, NULL, &replace_cmd_group, 0 },
{ "help", cmd_help, cmd_help_usage, NULL, 0 },
{ "version", cmd_version, cmd_version_usage, NULL, 0 },
diff --git a/cmds-dedup.c b/cmds-dedup.c
new file mode 100644
index 0000000..800df34
--- /dev/null
+++ b/cmds-dedup.c
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2015 Fujitsu. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License v2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 021110-1307, USA.
+ */
+
+#include <getopt.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+
+#include "ctree.h"
+#include "ioctl.h"
+
+#include "commands.h"
+#include "utils.h"
+#include "kerncompat.h"
+#include "dedup.h"
+
+static const char * const dedup_cmd_group_usage[] = {
+ "btrfs dedup <command> [options] <path>",
+ NULL
+};
+
+static const char dedup_cmd_group_info[] =
+"manage inband(write time) de-duplication";
+
+const struct cmd_group dedup_cmd_group = {
+ dedup_cmd_group_usage, dedup_cmd_group_info, {
+ NULL_CMD_STRUCT
+ }
+};
+
+int cmd_dedup(int argc, char **argv)
+{
+ return handle_command_group(&dedup_cmd_group, argc, argv);
+}
diff --git a/commands.h b/commands.h
index d2bb093..26d1af3 100644
--- a/commands.h
+++ b/commands.h
@@ -93,6 +93,7 @@ extern const struct cmd_group inspect_cmd_group;
extern const struct cmd_group property_cmd_group;
extern const struct cmd_group quota_cmd_group;
extern const struct cmd_group qgroup_cmd_group;
+extern const struct cmd_group dedup_cmd_group;
extern const struct cmd_group replace_cmd_group;
extern const struct cmd_group rescue_cmd_group;
@@ -118,6 +119,7 @@ int cmd_send(int argc, char **argv);
int cmd_receive(int argc, char **argv);
int cmd_quota(int argc, char **argv);
int cmd_qgroup(int argc, char **argv);
+int cmd_dedup(int argc, char **argv);
int cmd_replace(int argc, char **argv);
int cmd_restore(int argc, char **argv);
int cmd_select_super(int argc, char **argv);
diff --git a/ctree.h b/ctree.h
index c57f9ca..20305de 100644
--- a/ctree.h
+++ b/ctree.h
@@ -476,9 +476,11 @@ struct btrfs_super_block {
#define BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA (1ULL << 8)
#define BTRFS_FEATURE_INCOMPAT_NO_HOLES (1ULL << 9)
+#define BTRFS_FEATURE_COMPAT_RO_DEDUP (1ULL << 0)
#define BTRFS_FEATURE_COMPAT_SUPP 0ULL
-#define BTRFS_FEATURE_COMPAT_RO_SUPP 0ULL
+#define BTRFS_FEATURE_COMPAT_RO_SUPP \
+ (BTRFS_FEATURE_COMPAT_RO_DEDUP)
#define BTRFS_FEATURE_INCOMPAT_SUPP \
(BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF | \
BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL | \
@@ -828,6 +830,23 @@ struct btrfs_csum_item {
u8 csum;
} __attribute__ ((__packed__));
+struct btrfs_dedup_status_item {
+ __le64 blocksize;
+ __le64 limit_nr;
+ __le16 hash_type;
+ __le16 backend;
+} __attribute__ ((__packed__));
+
+struct btrfs_dedup_hash_item {
+ /* on disk length of dedup range */
+ __le64 len;
+
+ /* Spare space */
+ u8 __unused[16];
+
+ /* Hash follows */
+} __attribute__ ((__packed__));
+
/*
* We don't want to overwrite 1M at the beginning of device, even though
* there is our 1st superblock at 64k. Some possible reasons:
@@ -2032,6 +2051,19 @@ static inline unsigned long btrfs_leaf_data(struct extent_buffer *l)
return offsetof(struct btrfs_leaf, items);
}
+/* btrfs_dedup_status */
+BTRFS_SETGET_FUNCS(dedup_status_blocksize, struct btrfs_dedup_status_item,
+ blocksize, 64);
+BTRFS_SETGET_FUNCS(dedup_status_limit, struct btrfs_dedup_status_item,
+ limit_nr, 64);
+BTRFS_SETGET_FUNCS(dedup_status_hash_type, struct btrfs_dedup_status_item,
+ hash_type, 16);
+BTRFS_SETGET_FUNCS(dedup_status_backend, struct btrfs_dedup_status_item,
+ backend, 16);
+
+/* btrfs_dedup_hash_item */
+BTRFS_SETGET_FUNCS(dedup_hash_len, struct btrfs_dedup_hash_item, len, 64);
+
/* struct btrfs_file_extent_item */
BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8);
BTRFS_SETGET_STACK_FUNCS(stack_file_extent_type, struct btrfs_file_extent_item, type, 8);
diff --git a/dedup.h b/dedup.h
new file mode 100644
index 0000000..d9efc9c
--- /dev/null
+++ b/dedup.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2015 Fujitsu. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License v2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 021110-1307, USA.
+ */
+
+#ifndef __BTRFS_DEDUP__
+#define __BTRFS_DEDUP__
+
+/*
+ * Dedup storage backend
+ * On disk is persist storage but overhead is large
+ * In memory is fast but will lose all its hash on umount
+ */
+#define BTRFS_DEDUP_BACKEND_INMEMORY 0
+#define BTRFS_DEDUP_BACKEND_ONDISK 1
+#define BTRFS_DEDUP_BACKEND_LAST 2
+
+/* Dedup block size limit and default value */
+#define BTRFS_DEDUP_BLOCKSIZE_MAX (128 * 1024)
+#define BTRFS_DEDUP_BLOCKSIZE_MIN (16 * 1024)
+#define BTRFS_DEDUP_BLOCKSIZE_DEFAULT (32 * 1024)
+
+/* Hash algorithm, only support SHA256 yet */
+#define BTRFS_DEDUP_HASH_SHA256 0
+
+#endif
diff --git a/ioctl.h b/ioctl.h
index dff015a..7c9221d 100644
--- a/ioctl.h
+++ b/ioctl.h
@@ -466,6 +466,27 @@ struct btrfs_ioctl_get_dev_stats {
__u64 unused[128 - 2 - BTRFS_DEV_STAT_VALUES_MAX]; /* pad to 1k */
};
+/*
+ * de-duplication control modes
+ * For re-config, re-enable will handle it
+ * TODO: Add support to disable per-file/dir dedup operation
+ */
+#define BTRFS_DEDUP_CTL_ENABLE 1
+#define BTRFS_DEDUP_CTL_DISABLE 2
+#define BTRFS_DEDUP_CTL_STATUS 3
+#define BTRFS_DEDUP_CTL_LAST 4
+struct btrfs_ioctl_dedup_args {
+ __u16 cmd; /* In: command(see above macro) */
+ __u64 blocksize; /* In/Out: For enable/status */
+ __u64 limit_nr; /* In/Out: For enable/status */
+ __u64 current_nr; /* Out: For status output */
+ __u16 backend; /* In/Out: For enable/status */
+ __u16 hash_type; /* In/Out: For enable/status */
+ u8 status; /* Out: For status output */
+ /* pad to 512 bytes */
+ u8 __unused[489];
+};
+
/* BTRFS_IOC_SNAP_CREATE is no longer used by the btrfs command */
#define BTRFS_QUOTA_CTL_ENABLE 1
#define BTRFS_QUOTA_CTL_DISABLE 2
--
2.6.4
^ permalink raw reply related [flat|nested] 8+ messages in thread* [PATCH 2/7] btrfs-progs: dedup: Add enable command for dedup command group
2015-12-29 8:01 [PATCH 0/7] btrfs-progs: Support for in-band deduplication Qu Wenruo
2015-12-29 8:01 ` [PATCH 1/7] btrfs-progs: Basic framework for dedup command group Qu Wenruo
@ 2015-12-29 8:01 ` Qu Wenruo
2015-12-29 8:01 ` [PATCH 3/7] btrfs-progs: dedup: Add disable support for inban deduplication Qu Wenruo
` (4 subsequent siblings)
6 siblings, 0 replies; 8+ messages in thread
From: Qu Wenruo @ 2015-12-29 8:01 UTC (permalink / raw)
To: linux-btrfs
Add enable subcommand for dedup commmand group.
Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
---
Documentation/btrfs-dedup.asciidoc | 62 ++++++++++++++++++-
cmds-dedup.c | 120 +++++++++++++++++++++++++++++++++++++
ioctl.h | 2 +
kerncompat.h | 5 ++
4 files changed, 188 insertions(+), 1 deletion(-)
diff --git a/Documentation/btrfs-dedup.asciidoc b/Documentation/btrfs-dedup.asciidoc
index 354313f..652f22d 100644
--- a/Documentation/btrfs-dedup.asciidoc
+++ b/Documentation/btrfs-dedup.asciidoc
@@ -19,7 +19,67 @@ use with caution.
SUBCOMMAND
----------
-Nothing yet
+*enable* [options] <path>::
+Enable in-band de-duplication for a filesystem.
++
+`Options`
++
+-s|--storage-backend <BACKEND>::::
+Specify de-duplication hash storage backend.
+Supported backends are 'ondisk' and 'inmemory'
+If not specified, default value is 'inmemory'.
++
+Refer to *BACKENDS* sector for more information.
+
+-b|--blocksize <BLOCKSIZE>::::
+Specify dedup block size.
+Supported values are power of 2 from '16K' to '128K'.
+Default value is the larger of page size and '32K'.
++
+Refer to *BLOCKSIZE* sector for more information.
+
+-a|--hash-algorithm <HASH>::::
+Specify hash algorithm.
+Only 'sha256' is supported yet.
+
+-l|--limit <LIMIT>::::
+Specify limit of hash number.
+Only works for 'inmemory' backend.
+If *LIMIT* is zero, there will be no limit at all. Use with caution as it can
+use up all the memory for dedup hash.
+Default value is 4096 if using 'inmemory' backend.
+
+BACKENDS
+--------
+Btrfs in-band de-duplication support two different backends with their own
+features.
+
+In-memory backend::
+Designed for speed, in-memory backend will keep all dedup hash into memory.
+And it has a limit of number of hash kept in-memory.
+Hashes over the limit will be dropped following last recent use behavior.
+So this backend has a consistent overhead for given limit but can't ensure
+any all duplicated data will be de-duplicated.
++
+After umount and mount, in-memory backend need to refill its hash table.
+
+On-disk backend::
+Designed for de-duplication rate, on-disk backend will keep dedup hash on disk.
+This behavior may cause extra disk IO for de-duplication, but will have a much
+higher dedup rate.
++
+After umount and mount, on-disk backend still has its hash on disk, no need to
+refill its dedup hash table.
+
+BLOCKSIZE
+---------
+Block in-band de-duplication is done at block size unit.
+Any data smaller than dedup block size won't go through the dedup backends.
+
+Smaller block size will cause more fragments and lower performance, but a
+higher dedup rate.
+Larger block size will cause less fragments and higher performance, but a
+lower dedup rate.
EXIT STATUS
-----------
diff --git a/cmds-dedup.c b/cmds-dedup.c
index 800df34..e116f4c 100644
--- a/cmds-dedup.c
+++ b/cmds-dedup.c
@@ -36,8 +36,128 @@ static const char * const dedup_cmd_group_usage[] = {
static const char dedup_cmd_group_info[] =
"manage inband(write time) de-duplication";
+static const char * const cmd_dedup_enable_usage[] = {
+ "btrfs dedup enable [options] <path>",
+ "Enable in-band(write time) de-duplication of a btrfs.",
+ "",
+ "-s|--storage-backend <BACKEND>",
+ " specify dedup hash storage backend",
+ " supported backend: 'ondisk', 'inmemory'",
+ " inmemory is the default backend",
+ "-b|--blocksize <BLOCKSIZE>",
+ " specify dedup block size",
+ " default value is the larger of page size and 16K",
+ "-a|--hash-algorithm <HASH>",
+ " specify hash algorithm",
+ " only 'sha256' is supported yet",
+ "-l|--limit <LIMIT>",
+ " specify limit of hash number",
+ " only for 'inmemory' backend",
+ " default value is 4096 if using 'inmemory' backend",
+ NULL
+};
+
+static int cmd_dedup_enable(int argc, char **argv)
+{
+ int ret;
+ int fd;
+ char *path;
+ int pagesize = sysconf(_SC_PAGESIZE);
+ u64 blocksize = max(pagesize, BTRFS_DEDUP_BLOCKSIZE_DEFAULT);
+ u16 hash_type = BTRFS_DEDUP_HASH_SHA256;
+ u16 backend = BTRFS_DEDUP_BACKEND_INMEMORY;
+ u64 limit = 0;
+ struct btrfs_ioctl_dedup_args dargs;
+ DIR *dirstream;
+
+ while (1) {
+ int c;
+ static const struct option long_options[] = {
+ { "storage-backend", required_argument, NULL, 's'},
+ { "blocksize", required_argument, NULL, 'b'},
+ { "hash-algorithm", required_argument, NULL, 'a'},
+ { "limit", required_argument, NULL, 'l'},
+ { NULL, 0, NULL, 0}
+ };
+
+ c = getopt_long(argc, argv, "s:b:a:l:", long_options, NULL);
+ if (c < 0)
+ break;
+ switch (c) {
+ case 's':
+ if (!strcmp("ondisk", optarg))
+ backend = BTRFS_DEDUP_BACKEND_ONDISK;
+ else if (!strcmp("inmemory", optarg))
+ backend = BTRFS_DEDUP_BACKEND_INMEMORY;
+ else {
+ error("unsupported dedup backend: %s", optarg);
+ exit(1);
+ }
+ break;
+ case 'b':
+ blocksize = parse_size(optarg);
+ break;
+ case 'a':
+ if (strcmp("sha256", optarg)) {
+ error("unsupported dedup hash algorithm: %s",
+ optarg);
+ return 1;
+ }
+ break;
+ case 'l':
+ limit = parse_size(optarg);
+ break;
+ }
+ }
+
+ path = argv[optind];
+ if (check_argc_exact(argc - optind, 1))
+ usage(cmd_dedup_enable_usage);
+
+ /* Validation check */
+ if (!is_power_of_2(blocksize) ||
+ blocksize > BTRFS_DEDUP_BLOCKSIZE_MAX ||
+ blocksize < BTRFS_DEDUP_BLOCKSIZE_MIN ||
+ blocksize < pagesize) {
+ error("invalid dedup blocksize: %llu, not in range [%llu,%llu] nor power of 2",
+ blocksize, max(pagesize, BTRFS_DEDUP_BLOCKSIZE_MIN),
+ BTRFS_DEDUP_BLOCKSIZE_MAX);
+ return 1;
+ }
+ if (limit && backend == BTRFS_DEDUP_BACKEND_ONDISK) {
+ error("limit is only valid for 'inmemory' backend");
+ return 1;
+ }
+
+ fd = open_file_or_dir(path, &dirstream);
+ if (fd < 0) {
+ error("failed to open file or directory: %s", path);
+ return 1;
+ }
+ memset(&dargs, 0, sizeof(dargs));
+ dargs.cmd = BTRFS_DEDUP_CTL_ENABLE;
+ dargs.blocksize = blocksize;
+ dargs.hash_type = hash_type;
+ dargs.limit_nr = limit;
+ dargs.backend = backend;
+
+ ret = ioctl(fd, BTRFS_IOC_DEDUP_CTL, &dargs);
+ if (ret < 0) {
+ error("failed to enable inband deduplication: %s",
+ strerror(errno));
+ ret = 1;
+ goto out;
+ }
+ ret = 0;
+
+out:
+ close_file_or_dir(fd, dirstream);
+ return ret;
+}
+
const struct cmd_group dedup_cmd_group = {
dedup_cmd_group_usage, dedup_cmd_group_info, {
+ { "enable", cmd_dedup_enable, cmd_dedup_enable_usage, NULL, 0},
NULL_CMD_STRUCT
}
};
diff --git a/ioctl.h b/ioctl.h
index 7c9221d..6bff671 100644
--- a/ioctl.h
+++ b/ioctl.h
@@ -698,6 +698,8 @@ static inline char *btrfs_err_str(enum btrfs_err_code err_code)
struct btrfs_ioctl_dev_replace_args)
#define BTRFS_IOC_FILE_EXTENT_SAME _IOWR(BTRFS_IOCTL_MAGIC, 54, \
struct btrfs_ioctl_same_args)
+#define BTRFS_IOC_DEDUP_CTL _IOWR(BTRFS_IOCTL_MAGIC, 55, \
+ struct btrfs_ioctl_dedup_args)
#define BTRFS_IOC_GET_FEATURES _IOR(BTRFS_IOCTL_MAGIC, 57, \
struct btrfs_ioctl_feature_flags)
#define BTRFS_IOC_SET_FEATURES _IOW(BTRFS_IOCTL_MAGIC, 57, \
diff --git a/kerncompat.h b/kerncompat.h
index 7c627ba..db1d77b 100644
--- a/kerncompat.h
+++ b/kerncompat.h
@@ -310,6 +310,11 @@ static inline long IS_ERR(const void *ptr)
#define __bitwise
#endif
+static inline int is_power_of_2(unsigned long n)
+{
+ return (n != 0 && ((n & (n - 1)) == 0));
+}
+
typedef u16 __bitwise __le16;
typedef u16 __bitwise __be16;
typedef u32 __bitwise __le32;
--
2.6.4
^ permalink raw reply related [flat|nested] 8+ messages in thread* [PATCH 3/7] btrfs-progs: dedup: Add disable support for inban deduplication
2015-12-29 8:01 [PATCH 0/7] btrfs-progs: Support for in-band deduplication Qu Wenruo
2015-12-29 8:01 ` [PATCH 1/7] btrfs-progs: Basic framework for dedup command group Qu Wenruo
2015-12-29 8:01 ` [PATCH 2/7] btrfs-progs: dedup: Add enable command " Qu Wenruo
@ 2015-12-29 8:01 ` Qu Wenruo
2015-12-29 8:01 ` [PATCH 4/7] btrfs-progs: dedup: Add status subcommand Qu Wenruo
` (3 subsequent siblings)
6 siblings, 0 replies; 8+ messages in thread
From: Qu Wenruo @ 2015-12-29 8:01 UTC (permalink / raw)
To: linux-btrfs
Add disable subcommand for dedup command group.
Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
---
Documentation/btrfs-dedup.asciidoc | 5 +++++
cmds-dedup.c | 42 ++++++++++++++++++++++++++++++++++++++
2 files changed, 47 insertions(+)
diff --git a/Documentation/btrfs-dedup.asciidoc b/Documentation/btrfs-dedup.asciidoc
index 652f22d..08d1050 100644
--- a/Documentation/btrfs-dedup.asciidoc
+++ b/Documentation/btrfs-dedup.asciidoc
@@ -19,6 +19,11 @@ use with caution.
SUBCOMMAND
----------
+*disable* <path>::
+Disable in-band de-duplication for a filesystem.
++
+This will trash all stored dedup hash.
++
*enable* [options] <path>::
Enable in-band de-duplication for a filesystem.
+
diff --git a/cmds-dedup.c b/cmds-dedup.c
index e116f4c..f15c2c2 100644
--- a/cmds-dedup.c
+++ b/cmds-dedup.c
@@ -155,9 +155,51 @@ out:
return ret;
}
+static const char * const cmd_dedup_disable_usage[] = {
+ "btrfs dedup disable <path>",
+ "Disable in-band(write time) de-duplication of a btrfs.",
+ NULL
+};
+
+static int cmd_dedup_disable(int argc, char **argv)
+{
+ struct btrfs_ioctl_dedup_args dargs;
+ DIR *dirstream;
+ char *path;
+ int fd;
+ int ret;
+
+ if (check_argc_exact(argc, 2))
+ usage(cmd_dedup_disable_usage);
+
+ path = argv[1];
+ fd = open_file_or_dir(path, &dirstream);
+ if (fd < 0) {
+ error("failed to open file or directory: %s", path);
+ return 1;
+ }
+ memset(&dargs, 0, sizeof(dargs));
+ dargs.cmd = BTRFS_DEDUP_CTL_DISABLE;
+
+ ret = ioctl(fd, BTRFS_IOC_DEDUP_CTL, &dargs);
+ if (ret < 0) {
+ error("failed to disable inband deduplication: %s",
+ strerror(errno));
+ ret = 1;
+ goto out;
+ }
+ ret = 0;
+
+out:
+ close_file_or_dir(fd, dirstream);
+ return 0;
+}
+
const struct cmd_group dedup_cmd_group = {
dedup_cmd_group_usage, dedup_cmd_group_info, {
{ "enable", cmd_dedup_enable, cmd_dedup_enable_usage, NULL, 0},
+ { "disable", cmd_dedup_disable, cmd_dedup_disable_usage,
+ NULL, 0},
NULL_CMD_STRUCT
}
};
--
2.6.4
^ permalink raw reply related [flat|nested] 8+ messages in thread* [PATCH 4/7] btrfs-progs: dedup: Add status subcommand
2015-12-29 8:01 [PATCH 0/7] btrfs-progs: Support for in-band deduplication Qu Wenruo
` (2 preceding siblings ...)
2015-12-29 8:01 ` [PATCH 3/7] btrfs-progs: dedup: Add disable support for inban deduplication Qu Wenruo
@ 2015-12-29 8:01 ` Qu Wenruo
2015-12-29 8:01 ` [PATCH 5/7] btrfs-progs: Add dedup feature for mkfs and convert Qu Wenruo
` (2 subsequent siblings)
6 siblings, 0 replies; 8+ messages in thread
From: Qu Wenruo @ 2015-12-29 8:01 UTC (permalink / raw)
To: linux-btrfs
Add status subcommand for dedup command group.
Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
---
Documentation/btrfs-dedup.asciidoc | 3 ++
cmds-dedup.c | 72 ++++++++++++++++++++++++++++++++++++++
2 files changed, 75 insertions(+)
diff --git a/Documentation/btrfs-dedup.asciidoc b/Documentation/btrfs-dedup.asciidoc
index 08d1050..8b605fb 100644
--- a/Documentation/btrfs-dedup.asciidoc
+++ b/Documentation/btrfs-dedup.asciidoc
@@ -54,6 +54,9 @@ If *LIMIT* is zero, there will be no limit at all. Use with caution as it can
use up all the memory for dedup hash.
Default value is 4096 if using 'inmemory' backend.
+*status* <path>::
+Show current in-band de-duplication status of a filesystem.
+
BACKENDS
--------
Btrfs in-band de-duplication support two different backends with their own
diff --git a/cmds-dedup.c b/cmds-dedup.c
index f15c2c2..5792420 100644
--- a/cmds-dedup.c
+++ b/cmds-dedup.c
@@ -195,11 +195,83 @@ out:
return 0;
}
+static const char * const cmd_dedup_status_usage[] = {
+ "btrfs dedup status <path>",
+ "Show current in-band(write time) de-duplication status of a btrfs.",
+ NULL
+};
+
+static int cmd_dedup_status(int argc, char **argv)
+{
+ struct btrfs_ioctl_dedup_args dargs;
+ DIR *dirstream;
+ char *path;
+ int fd;
+ int ret;
+ int print_limit = 1;
+
+ if (check_argc_exact(argc, 2))
+ usage(cmd_dedup_status_usage);
+
+ path = argv[1];
+ fd = open_file_or_dir(path, &dirstream);
+ if (fd < 0) {
+ error("failed to open file or directory: %s", path);
+ ret = 1;
+ goto out;
+ }
+ memset(&dargs, 0, sizeof(dargs));
+ dargs.cmd = BTRFS_DEDUP_CTL_STATUS;
+
+ ret = ioctl(fd, BTRFS_IOC_DEDUP_CTL, &dargs);
+ if (ret < 0) {
+ error("failed to get inband deduplication status: %s",
+ strerror(errno));
+ ret = 1;
+ goto out;
+ }
+ ret = 0;
+ if (dargs.status == 0) {
+ printf("Status: Disabled\n");
+ goto out;
+ }
+ printf("Status: Enabled\n");
+
+ if (dargs.hash_type == BTRFS_DEDUP_HASH_SHA256)
+ printf("Hash algorithm: SHA-256\n");
+ else
+ printf("Hash algorithm: Unrecognized(%x)\n",
+ dargs.hash_type);
+
+ if (dargs.backend == BTRFS_DEDUP_BACKEND_INMEMORY) {
+ printf("Backend: In-memory\n");
+ print_limit = 1;
+ } else if (dargs.backend == BTRFS_DEDUP_BACKEND_ONDISK) {
+ printf("Backend: On-disk\n");
+ print_limit = 0;
+ } else {
+ printf("Backend: Unrecognized(%x)\n",
+ dargs.backend);
+ }
+
+ printf("Dedup Blocksize: %llu\n", dargs.blocksize);
+
+ if (print_limit) {
+ printf("Current number of hash: %llu\n", dargs.current_nr);
+ printf("Max number of hash: %llu\n", dargs.limit_nr);
+ }
+out:
+ close_file_or_dir(fd, dirstream);
+ return ret;
+}
+
const struct cmd_group dedup_cmd_group = {
dedup_cmd_group_usage, dedup_cmd_group_info, {
{ "enable", cmd_dedup_enable, cmd_dedup_enable_usage, NULL, 0},
{ "disable", cmd_dedup_disable, cmd_dedup_disable_usage,
NULL, 0},
+ { "status", cmd_dedup_status, cmd_dedup_status_usage,
+ NULL, 0},
NULL_CMD_STRUCT
}
};
--
2.6.4
^ permalink raw reply related [flat|nested] 8+ messages in thread* [PATCH 5/7] btrfs-progs: Add dedup feature for mkfs and convert
2015-12-29 8:01 [PATCH 0/7] btrfs-progs: Support for in-band deduplication Qu Wenruo
` (3 preceding siblings ...)
2015-12-29 8:01 ` [PATCH 4/7] btrfs-progs: dedup: Add status subcommand Qu Wenruo
@ 2015-12-29 8:01 ` Qu Wenruo
2015-12-29 8:01 ` [PATCH 6/7] btrfs: dedup: Add show-super support for new DEDUP flag Qu Wenruo
2015-12-29 8:01 ` [PATCH 7/7] btrfs-progs: dedup-tree: Add dedup tree support Qu Wenruo
6 siblings, 0 replies; 8+ messages in thread
From: Qu Wenruo @ 2015-12-29 8:01 UTC (permalink / raw)
To: linux-btrfs
Add new DEDUP ro compat flag and corresponding mkfs/convert flag
'dedup'.
Since dedup tree is completely isolated from fs tree, so even old kernel
could do read mount.
So add it to RO compat flag instead of common incompat flags
Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
---
Documentation/mkfs.btrfs.asciidoc | 9 +++++++++
btrfs-convert.c | 19 +++++++++++++------
mkfs.c | 8 ++++++--
utils.c | 38 +++++++++++++++++++++++++++-----------
utils.h | 7 ++++---
5 files changed, 59 insertions(+), 22 deletions(-)
diff --git a/Documentation/mkfs.btrfs.asciidoc b/Documentation/mkfs.btrfs.asciidoc
index 12d8840..5c5b41d 100644
--- a/Documentation/mkfs.btrfs.asciidoc
+++ b/Documentation/mkfs.btrfs.asciidoc
@@ -207,6 +207,15 @@ reduced-size metadata for extent references, saves a few percent of metadata
improved representation of file extents where holes are not explicitly
stored as an extent, saves a few percent of metadata if sparse files are used
+*dedup*::
+allow btrfs to use new on-disk format designed for in-band(write time)
+de-duplication.
++
+on-disk storage backend and persist de-duplication status needs this feature.
++
+unlike other features, this is an RO compat flag, means old kernel can still
+mount fs read-only.
+
BLOCK GROUPS, CHUNKS, RAID
--------------------------
diff --git a/btrfs-convert.c b/btrfs-convert.c
index 02e5cdb..bf1df48 100644
--- a/btrfs-convert.c
+++ b/btrfs-convert.c
@@ -2288,7 +2288,7 @@ err:
static int do_convert(const char *devname, int datacsum, int packing, int noxattr,
u32 nodesize, int copylabel, const char *fslabel, int progress,
- u64 features)
+ u64 features, u64 ro_features)
{
int i, ret, blocks_per_node;
int fd = -1;
@@ -2343,8 +2343,9 @@ static int do_convert(const char *devname, int datacsum, int packing, int noxatt
fprintf(stderr, "unable to open %s\n", devname);
goto fail;
}
- btrfs_parse_features_to_string(features_buf, features);
- if (features == BTRFS_MKFS_DEFAULT_FEATURES)
+ btrfs_parse_features_to_string(features_buf, features, ro_features);
+ if (features == BTRFS_MKFS_DEFAULT_FEATURES &&
+ ro_features == 0)
strcat(features_buf, " (default)");
printf("create btrfs filesystem:\n");
@@ -2360,6 +2361,7 @@ static int do_convert(const char *devname, int datacsum, int packing, int noxatt
mkfs_cfg.sectorsize = blocksize;
mkfs_cfg.stripesize = blocksize;
mkfs_cfg.features = features;
+ mkfs_cfg.ro_features = ro_features;
ret = make_btrfs(fd, &mkfs_cfg);
if (ret) {
@@ -2898,6 +2900,7 @@ int main(int argc, char *argv[])
char *file;
char fslabel[BTRFS_LABEL_SIZE];
u64 features = BTRFS_MKFS_DEFAULT_FEATURES;
+ u64 ro_features = 0;
while(1) {
enum { GETOPT_VAL_NO_PROGRESS = 256 };
@@ -2956,7 +2959,8 @@ int main(int argc, char *argv[])
char *orig = strdup(optarg);
char *tmp = orig;
- tmp = btrfs_parse_fs_features(tmp, &features);
+ tmp = btrfs_parse_fs_features(tmp, &features,
+ &ro_features);
if (tmp) {
fprintf(stderr,
"Unrecognized filesystem feature '%s'\n",
@@ -2974,7 +2978,9 @@ int main(int argc, char *argv[])
char buf[64];
btrfs_parse_features_to_string(buf,
- features & ~BTRFS_CONVERT_ALLOWED_FEATURES);
+ features &
+ ~BTRFS_CONVERT_ALLOWED_FEATURES,
+ ro_features);
fprintf(stderr,
"ERROR: features not allowed for convert: %s\n",
buf);
@@ -3025,7 +3031,8 @@ int main(int argc, char *argv[])
ret = do_rollback(file);
} else {
ret = do_convert(file, datacsum, packing, noxattr, nodesize,
- copylabel, fslabel, progress, features);
+ copylabel, fslabel, progress, features,
+ ro_features);
}
if (ret)
return 1;
diff --git a/mkfs.c b/mkfs.c
index 5f1411f..9c7acc2 100644
--- a/mkfs.c
+++ b/mkfs.c
@@ -1372,6 +1372,7 @@ int main(int ac, char **av)
int saved_optind;
char fs_uuid[BTRFS_UUID_UNPARSED_SIZE] = { 0 };
u64 features = BTRFS_MKFS_DEFAULT_FEATURES;
+ u64 ro_features = 0;
struct mkfs_allocation allocation = { 0 };
struct btrfs_mkfs_config mkfs_cfg;
@@ -1434,7 +1435,8 @@ int main(int ac, char **av)
char *orig = strdup(optarg);
char *tmp = orig;
- tmp = btrfs_parse_fs_features(tmp, &features);
+ tmp = btrfs_parse_fs_features(tmp, &features,
+ &ro_features);
if (tmp) {
fprintf(stderr,
"Unrecognized filesystem feature '%s'\n",
@@ -1677,6 +1679,7 @@ int main(int ac, char **av)
mkfs_cfg.sectorsize = sectorsize;
mkfs_cfg.stripesize = stripesize;
mkfs_cfg.features = features;
+ mkfs_cfg.ro_features = ro_features;
ret = make_btrfs(fd, &mkfs_cfg);
if (ret) {
@@ -1831,7 +1834,8 @@ raid_groups:
btrfs_group_profile_str(metadata_profile),
pretty_size(allocation.system));
printf("SSD detected: %s\n", ssd ? "yes" : "no");
- btrfs_parse_features_to_string(features_buf, features);
+ btrfs_parse_features_to_string(features_buf, features,
+ ro_features);
printf("Incompat features: %s", features_buf);
printf("\n");
diff --git a/utils.c b/utils.c
index 60235d8..6b0c67a 100644
--- a/utils.c
+++ b/utils.c
@@ -250,6 +250,7 @@ int make_btrfs(int fd, struct btrfs_mkfs_config *cfg)
btrfs_set_super_chunk_root_generation(&super, 1);
btrfs_set_super_cache_generation(&super, -1);
btrfs_set_super_incompat_flags(&super, cfg->features);
+ btrfs_set_super_compat_ro_flags(&super, cfg->ro_features);
if (cfg->label)
strncpy(super.label, cfg->label, BTRFS_LABEL_SIZE - 1);
@@ -572,23 +573,26 @@ out:
static const struct btrfs_fs_feature {
const char *name;
u64 flag;
+ u64 ro_flag;
const char *desc;
} mkfs_features[] = {
- { "mixed-bg", BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS,
+ { "mixed-bg", BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS, 0,
"mixed data and metadata block groups" },
- { "extref", BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF,
+ { "extref", BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF, 0,
"increased hardlink limit per file to 65536" },
- { "raid56", BTRFS_FEATURE_INCOMPAT_RAID56,
+ { "raid56", BTRFS_FEATURE_INCOMPAT_RAID56, 0,
"raid56 extended format" },
- { "skinny-metadata", BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA,
+ { "skinny-metadata", BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA, 0,
"reduced-size metadata extent refs" },
- { "no-holes", BTRFS_FEATURE_INCOMPAT_NO_HOLES,
+ { "no-holes", BTRFS_FEATURE_INCOMPAT_NO_HOLES, 0,
"no explicit hole extents for files" },
+ { "dedup", 0, BTRFS_FEATURE_COMPAT_RO_DEDUP,
+ "support on-disk dedup backend and persist dedup status" },
/* Keep this one last */
- { "list-all", BTRFS_FEATURE_LIST_ALL, NULL }
+ { "list-all", BTRFS_FEATURE_LIST_ALL, 0, NULL }
};
-static int parse_one_fs_feature(const char *name, u64 *flags)
+static int parse_one_fs_feature(const char *name, u64 *flags, u64 *ro_flags)
{
int i;
int found = 0;
@@ -597,9 +601,11 @@ static int parse_one_fs_feature(const char *name, u64 *flags)
if (name[0] == '^' &&
!strcmp(mkfs_features[i].name, name + 1)) {
*flags &= ~ mkfs_features[i].flag;
+ *ro_flags &= ~mkfs_features[i].ro_flag;
found = 1;
} else if (!strcmp(mkfs_features[i].name, name)) {
*flags |= mkfs_features[i].flag;
+ *ro_flags |= mkfs_features[i].ro_flag;
found = 1;
}
}
@@ -607,7 +613,7 @@ static int parse_one_fs_feature(const char *name, u64 *flags)
return !found;
}
-void btrfs_parse_features_to_string(char *buf, u64 flags)
+void btrfs_parse_features_to_string(char *buf, u64 flags, u64 ro_flags)
{
int i;
@@ -619,10 +625,15 @@ void btrfs_parse_features_to_string(char *buf, u64 flags)
strcat(buf, ", ");
strcat(buf, mkfs_features[i].name);
}
+ if (ro_flags & mkfs_features[i].ro_flag) {
+ if (*buf)
+ strcat(buf, ", ");
+ strcat(buf, mkfs_features[i].name);
+ }
}
}
-void btrfs_process_fs_features(u64 flags)
+void btrfs_process_fs_features(u64 flags, u64 ro_flags)
{
int i;
@@ -632,6 +643,11 @@ void btrfs_process_fs_features(u64 flags)
mkfs_features[i].name,
mkfs_features[i].desc);
}
+ if (ro_flags & mkfs_features[i].ro_flag) {
+ printf("Turning ON RO compat features '%s': %s\n",
+ mkfs_features[i].name,
+ mkfs_features[i].desc);
+ }
}
}
@@ -659,7 +675,7 @@ void btrfs_list_all_fs_features(u64 mask_disallowed)
* Return NULL if all features were parsed fine, otherwise return the name of
* the first unparsed.
*/
-char* btrfs_parse_fs_features(char *namelist, u64 *flags)
+char *btrfs_parse_fs_features(char *namelist, u64 *flags, u64 *ro_flags)
{
char *this_char;
char *save_ptr = NULL; /* Satisfy static checkers */
@@ -667,7 +683,7 @@ char* btrfs_parse_fs_features(char *namelist, u64 *flags)
for (this_char = strtok_r(namelist, ",", &save_ptr);
this_char != NULL;
this_char = strtok_r(NULL, ",", &save_ptr)) {
- if (parse_one_fs_feature(this_char, flags))
+ if (parse_one_fs_feature(this_char, flags, ro_flags))
return this_char;
}
diff --git a/utils.h b/utils.h
index b625330..835fd22 100644
--- a/utils.h
+++ b/utils.h
@@ -102,9 +102,9 @@ void units_set_mode(unsigned *units, unsigned mode);
void units_set_base(unsigned *units, unsigned base);
void btrfs_list_all_fs_features(u64 mask_disallowed);
-char* btrfs_parse_fs_features(char *namelist, u64 *flags);
-void btrfs_process_fs_features(u64 flags);
-void btrfs_parse_features_to_string(char *buf, u64 flags);
+char *btrfs_parse_fs_features(char *namelist, u64 *flags, u64 *ro_flags);
+void btrfs_process_fs_features(u64 flags, u64 ro_flags);
+void btrfs_parse_features_to_string(char *buf, u64 flags, u64 ro_flags);
struct btrfs_mkfs_config {
char *label;
@@ -115,6 +115,7 @@ struct btrfs_mkfs_config {
u32 sectorsize;
u32 stripesize;
u64 features;
+ u64 ro_features;
};
int make_btrfs(int fd, struct btrfs_mkfs_config *cfg);
--
2.6.4
^ permalink raw reply related [flat|nested] 8+ messages in thread* [PATCH 6/7] btrfs: dedup: Add show-super support for new DEDUP flag
2015-12-29 8:01 [PATCH 0/7] btrfs-progs: Support for in-band deduplication Qu Wenruo
` (4 preceding siblings ...)
2015-12-29 8:01 ` [PATCH 5/7] btrfs-progs: Add dedup feature for mkfs and convert Qu Wenruo
@ 2015-12-29 8:01 ` Qu Wenruo
2015-12-29 8:01 ` [PATCH 7/7] btrfs-progs: dedup-tree: Add dedup tree support Qu Wenruo
6 siblings, 0 replies; 8+ messages in thread
From: Qu Wenruo @ 2015-12-29 8:01 UTC (permalink / raw)
To: linux-btrfs
Now btrfs-show-super can handle DEDUP ro compat flag.
Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
---
btrfs-show-super.c | 17 +++++++++++++++++
1 file changed, 17 insertions(+)
diff --git a/btrfs-show-super.c b/btrfs-show-super.c
index d8ad69e..7c0dfa9 100644
--- a/btrfs-show-super.c
+++ b/btrfs-show-super.c
@@ -291,6 +291,15 @@ struct readable_flag_entry {
u64 bit;
char *output;
};
+#define DEF_RO_COMPAT_FLAG_ENTRY(bit_name) \
+ {BTRFS_FEATURE_COMPAT_RO_##bit_name, #bit_name}
+
+struct readable_flag_entry ro_compat_flags_array[] = {
+ DEF_RO_COMPAT_FLAG_ENTRY(DEDUP)
+};
+
+static const int ro_compat_flags_num = sizeof(ro_compat_flags_array) /
+ sizeof(struct readable_flag_entry);
#define DEF_INCOMPAT_FLAG_ENTRY(bit_name) \
{BTRFS_FEATURE_INCOMPAT_##bit_name, #bit_name}
@@ -363,6 +372,13 @@ static void __print_readable_flag(u64 flag, struct readable_flag_entry *array,
printf(")\n");
}
+static void print_readable_ro_compat_flag(u64 ro_flag)
+{
+ return __print_readable_flag(ro_flag, ro_compat_flags_array,
+ ro_compat_flags_num,
+ BTRFS_FEATURE_COMPAT_RO_SUPP);
+}
+
static void print_readable_incompat_flag(u64 flag)
{
return __print_readable_flag(flag, incompat_flags_array,
@@ -454,6 +470,7 @@ static void dump_superblock(struct btrfs_super_block *sb, int full)
(unsigned long long)btrfs_super_compat_flags(sb));
printf("compat_ro_flags\t\t0x%llx\n",
(unsigned long long)btrfs_super_compat_ro_flags(sb));
+ print_readable_ro_compat_flag(btrfs_super_compat_ro_flags(sb));
printf("incompat_flags\t\t0x%llx\n",
(unsigned long long)btrfs_super_incompat_flags(sb));
print_readable_incompat_flag(btrfs_super_incompat_flags(sb));
--
2.6.4
^ permalink raw reply related [flat|nested] 8+ messages in thread* [PATCH 7/7] btrfs-progs: dedup-tree: Add dedup tree support
2015-12-29 8:01 [PATCH 0/7] btrfs-progs: Support for in-band deduplication Qu Wenruo
` (5 preceding siblings ...)
2015-12-29 8:01 ` [PATCH 6/7] btrfs: dedup: Add show-super support for new DEDUP flag Qu Wenruo
@ 2015-12-29 8:01 ` Qu Wenruo
6 siblings, 0 replies; 8+ messages in thread
From: Qu Wenruo @ 2015-12-29 8:01 UTC (permalink / raw)
To: linux-btrfs
Add dedup tree support for btrfs-debug-tree.
Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
---
btrfs-debug-tree.c | 4 ++++
ctree.h | 7 +++++++
print-tree.c | 52 ++++++++++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 63 insertions(+)
diff --git a/btrfs-debug-tree.c b/btrfs-debug-tree.c
index 8adc39f..8b04df1 100644
--- a/btrfs-debug-tree.c
+++ b/btrfs-debug-tree.c
@@ -381,6 +381,10 @@ again:
printf("multiple");
}
break;
+ case BTRFS_DEDUP_TREE_OBJECTID:
+ if (!skip)
+ printf("dedup");
+ break;
default:
if (!skip) {
printf("file");
diff --git a/ctree.h b/ctree.h
index 20305de..eacad7d 100644
--- a/ctree.h
+++ b/ctree.h
@@ -76,6 +76,9 @@ struct btrfs_free_space_ctl;
/* for storing items that use the BTRFS_UUID_KEY* */
#define BTRFS_UUID_TREE_OBJECTID 9ULL
+/* on-disk dedup tree (EXPERIMENTAL) */
+#define BTRFS_DEDUP_TREE_OBJECTID 10ULL
+
/* for storing balance parameters in the root tree */
#define BTRFS_BALANCE_OBJECTID -4ULL
@@ -1180,6 +1183,10 @@ struct btrfs_root {
#define BTRFS_DEV_ITEM_KEY 216
#define BTRFS_CHUNK_ITEM_KEY 228
+#define BTRFS_DEDUP_STATUS_ITEM_KEY 230
+#define BTRFS_DEDUP_HASH_ITEM_KEY 231
+#define BTRFS_DEDUP_BYTENR_ITEM_KEY 232
+
#define BTRFS_BALANCE_ITEM_KEY 248
/*
diff --git a/print-tree.c b/print-tree.c
index 4d4c3a2..b88beef 100644
--- a/print-tree.c
+++ b/print-tree.c
@@ -25,6 +25,7 @@
#include "disk-io.h"
#include "print-tree.h"
#include "utils.h"
+#include "dedup.h"
static void print_dir_item_type(struct extent_buffer *eb,
@@ -658,6 +659,15 @@ static void print_key_type(u64 objectid, u8 type)
case BTRFS_UUID_KEY_RECEIVED_SUBVOL:
printf("UUID_KEY_RECEIVED_SUBVOL");
break;
+ case BTRFS_DEDUP_STATUS_ITEM_KEY:
+ printf("DEDUP_STATUS_ITEM");
+ break;
+ case BTRFS_DEDUP_HASH_ITEM_KEY:
+ printf("DEDUP_HASH_ITEM");
+ break;
+ case BTRFS_DEDUP_BYTENR_ITEM_KEY:
+ printf("DEDUP_BYTENR_ITEM");
+ break;
default:
printf("UNKNOWN.%d", type);
};
@@ -803,6 +813,37 @@ static void print_uuid_item(struct extent_buffer *l, unsigned long offset,
}
}
+static void print_dedup_status(struct extent_buffer *node, int slot)
+{
+ struct btrfs_dedup_status_item *status_item;
+ u64 blocksize;
+ u64 limit;
+ u16 hash_type;
+ u16 backend;
+
+ status_item = btrfs_item_ptr(node, slot,
+ struct btrfs_dedup_status_item);
+ blocksize = btrfs_dedup_status_blocksize(node, status_item);
+ limit = btrfs_dedup_status_limit(node, status_item);
+ hash_type = btrfs_dedup_status_hash_type(node, status_item);
+ backend = btrfs_dedup_status_backend(node, status_item);
+
+ printf("\t\tdedup status item ");
+ if (backend == BTRFS_DEDUP_BACKEND_INMEMORY)
+ printf("backend: inmemory\n");
+ else if (backend == BTRFS_DEDUP_BACKEND_ONDISK)
+ printf("backend: ondisk\n");
+ else
+ printf("backend: Unrecognized(%u)\n", backend);
+
+ if (hash_type == BTRFS_DEDUP_HASH_SHA256)
+ printf("\t\thash algorithm: SHA-256 ");
+ else
+ printf("\t\thash algorithm: Unrecognized(%u) ", hash_type);
+
+ printf("blocksize: %llu limit: %llu\n", blocksize, limit);
+}
+
void btrfs_print_leaf(struct btrfs_root *root, struct extent_buffer *l)
{
int i;
@@ -823,6 +864,8 @@ void btrfs_print_leaf(struct btrfs_root *root, struct extent_buffer *l)
struct btrfs_qgroup_info_item *qg_info;
struct btrfs_qgroup_limit_item *qg_limit;
struct btrfs_qgroup_status_item *qg_status;
+ struct btrfs_dedup_hash_item *hash_item;
+
u32 nr = btrfs_header_nritems(l);
u64 objectid;
u32 type;
@@ -1045,6 +1088,15 @@ void btrfs_print_leaf(struct btrfs_root *root, struct extent_buffer *l)
case BTRFS_DEV_STATS_KEY:
printf("\t\tdevice stats\n");
break;
+ case BTRFS_DEDUP_STATUS_ITEM_KEY:
+ print_dedup_status(l, i);
+ break;
+ case BTRFS_DEDUP_HASH_ITEM_KEY:
+ hash_item = btrfs_item_ptr(l, i,
+ struct btrfs_dedup_hash_item);
+
+ printf("\t\tdedup hash item num_bytes: %llu\n",
+ btrfs_dedup_hash_len(l, hash_item));
};
fflush(stdout);
}
--
2.6.4
^ permalink raw reply related [flat|nested] 8+ messages in thread