btrfs-progs: offline filesystem resize feature

Add support for resizing btrfs filesystems while unmounted using a new
--offline flag. This enables filesystem resizing without requiring mount
privileges or dealing with mounted filesystem constraints.

The offline resize functionality currently only supports increasing the
size of single-device filesystem. It works on both block devices and
regular files. For regular files it also truncates the file to the new
size.

This provides a safer alternative for users who need to resize
filesystems in environments where mounting may not be possible
or desirable, such as in containers or during system recovery.

Signed-off-by: Leo Martins <[email protected]>

Author: loemraw

cmds/filesystem.c

@@ -15,6 +15,7 @@
  */
 
 #include "kerncompat.h"
+#include "kernel-shared/transaction.h"
 #include <sys/ioctl.h>
 #include <sys/stat.h>
 #include <linux/version.h>
@@ -1287,14 +1288,15 @@ static const char * const cmd_filesystem_resize_usage[] = {
 	"[kK] means KiB, which denotes 1KiB = 1024B, 1MiB = 1024KiB, etc.",
 	"",
 	OPTLINE("--enqueue", "wait if there's another exclusive operation running, otherwise continue"),
+	OPTLINE("--offline", "resize an offline filesystem, shrinking and multi-device not supported"),
 	NULL
 };
 
 struct resize_args {
 	bool is_cancel;
 	bool specified_dev_id;
-	u64 devid;
 	bool is_max;
+	u64 devid;
 	int mod;
 	u64 size;
 };
@@ -1356,6 +1358,154 @@ static bool parse_resize_args(const char *amount, struct resize_args *ret) {
 	return true;
 }
 
+static bool check_offline_resize_args(const char *path, const char *amount,
+				     const struct btrfs_fs_info *fs_info,
+				     struct btrfs_device **device_ret,
+				     u64 *new_size_ret)
+{
+	struct btrfs_device *device = NULL;
+	struct resize_args args;
+	struct stat stat_buf;
+	u64 new_size = 0, old_size = 0, device_size = 0;
+
+	if (check_mounted(path)) {
+		error("%s must not be mounted to use --offline", path);
+		return false;
+	}
+
+	if (fs_info->fs_devices->num_devices > 1) {
+		error("multi-device not supported with --offline");
+		return false;
+	}
+	device = list_first_entry_or_null(&fs_info->fs_devices->devices, struct btrfs_device, dev_list);
+	if (!device) {
+		error("no device found");
+		return false;
+	}
+	*device_ret = device;
+	old_size = device->total_bytes;
+
+	fstat(device->fd, &stat_buf);
+	if (device_get_partition_size_fd_stat(device->fd, &stat_buf, &device_size))
+		device_size = 0;
+	if (!device_size) {
+		error("unable to get size at path %s", device->name);
+		return false;
+	}
+
+	if (!parse_resize_args(amount, &args))
+		return false;
+
+	if (args.is_cancel) {
+		error("can not cancel --offline resize");
+		return false;
+	}
+	if (args.specified_dev_id && args.devid != device->devid) {
+		error("invalid device id %llu", args.devid);
+		return false;
+	}
+	if (args.is_max) {
+		new_size = device_size;
+	} else {
+		if (args.mod == 0) {
+			new_size = args.size;
+		} else if (args.mod < 0) {
+			error("offline resize does not support shrinking");
+			return false;
+		} else {
+			if (args.size > ULLONG_MAX - old_size) {
+				error("increasing %s is out of range",
+				      pretty_size_mode(args.size, UNITS_DEFAULT));
+				return false;
+			}
+			new_size = old_size + args.size;
+		}
+	}
+	new_size = round_down(new_size, fs_info->sectorsize);
+	if (new_size < old_size) {
+		error("offline resize does not support shrinking");
+		return false;
+	}
+	*new_size_ret = new_size;
+
+	if (path_is_block_device(device->name) && new_size > device_size) {
+		error("unable to resize '%s': not enough free space", device->name);
+		return false;
+	}
+
+	if (new_size < 256 * SZ_1M)
+		warning("the new size %lld (%s) is < 256MiB, this may be rejected by kernel",
+			new_size, pretty_size_mode(new_size, UNITS_DEFAULT));
+
+	pr_verbose(LOG_DEFAULT, "Resize from %s to %s\n",
+		   pretty_size_mode(old_size, UNITS_DEFAULT),
+		   pretty_size_mode(new_size, UNITS_DEFAULT));
+	return true;
+}
+
+static bool offline_resize(const char *path, const char *amount)
+{
+	int ret = false;
+	struct btrfs_root *root;
+	struct btrfs_fs_info *fs_info;
+	struct btrfs_device *device;
+	struct btrfs_super_block *super;
+	struct btrfs_trans_handle *trans;
+	u64 new_size;
+	u64 old_total;
+	u64 diff;
+
+	root = open_ctree(path, 0, OPEN_CTREE_WRITES | OPEN_CTREE_CHUNK_ROOT_ONLY);
+	if (!root)
+		return false;
+	fs_info = root->fs_info;
+	super = fs_info->super_copy;
+
+	if (!check_offline_resize_args(path, amount, fs_info, &device, &new_size)) {
+		ret = false;
+		goto close;
+	}
+
+	trans = btrfs_start_transaction(root, 1);
+	if (IS_ERR(trans)) {
+		errno = -PTR_ERR(trans);
+		error_msg(ERROR_MSG_START_TRANS, "%m");
+		ret = false;
+		goto close;
+	}
+
+	old_total = btrfs_super_total_bytes(super);
+	diff = round_down(new_size - device->total_bytes, fs_info->sectorsize);
+	btrfs_set_super_total_bytes(super, round_down(old_total + diff,
+						      fs_info->sectorsize));
+	device->total_bytes = new_size;
+	ret = btrfs_update_device(trans, device);
+	if (ret) {
+		btrfs_abort_transaction(trans, ret);
+		ret = false;
+		goto close;
+	}
+
+	if (path_is_reg_file(device->name)) {
+		if (truncate(device->name, new_size)) {
+			error("unable to truncate %s to new size %llu", device->name, new_size);
+			btrfs_abort_transaction(trans, ret);
+			ret = false;
+			goto close;
+		}
+	}
+
+	if (btrfs_commit_transaction(trans, root)) {
+		ret = false;
+		goto close;
+	}
+
+	ret = true;
+close:
+	close_ctree(root);
+	return ret;
+}
+
 static int check_resize_args(const char *amount, const char *path, u64 *devid_ret)
 {
 	struct btrfs_ioctl_fs_info_args fi_args;
@@ -1482,6 +1632,7 @@ static int cmd_filesystem_resize(const struct cmd_struct *cmd,
 	u64 devid;
 	int ret;
 	bool enqueue = false;
+	bool offline = false;
 	bool cancel = false;
 
 	/*
@@ -1491,6 +1642,8 @@ static int cmd_filesystem_resize(const struct cmd_struct *cmd,
 	for (optind = 1; optind < argc; optind++) {
 		if (strcmp(argv[optind], "--enqueue") == 0) {
 			enqueue = true;
+		} else if (strcmp(argv[optind], "--offline") == 0) {
+			offline = true;
 		} else if (strcmp(argv[optind], "--") == 0) {
 			/* Separator: options -- non-options */
 		} else if (strncmp(argv[optind], "--", 2) == 0) {
@@ -1505,6 +1658,12 @@ static int cmd_filesystem_resize(const struct cmd_struct *cmd,
 	if (check_argc_exact(argc - optind, 2))
 		return 1;
 
+	if (offline && enqueue) {
+		error("--enqueue is not compatible with --offline\n"
+		      "since offline resizing is synchronous");
+		return 1;
+	}
+
 	amount = argv[optind];
 	path = argv[optind + 1];
 
@@ -1514,17 +1673,16 @@ static int cmd_filesystem_resize(const struct cmd_struct *cmd,
 		return 1;
 	}
 
+	if (offline)
+		return !offline_resize(path, amount);
+
 	cancel = (strcmp("cancel", amount) == 0);
 
 	fd = btrfs_open_dir(path);
 	if (fd < 0) {
-		/* The path is a directory */
-		if (fd == -ENOTDIR) {
-			error(
-		"resize works on mounted filesystems and accepts only\n"
-		"directories as argument. Passing file containing a btrfs image\n"
-		"would resize the underlying filesystem instead of the image.\n");
-		}
+		/* The path is not a directory */
+		if (fd == -ENOTDIR)
+			error("to resize a file containing a BTRFS image use the --offline flag");
 		return 1;
 	}
 

tests/cli-tests/003-fi-resize-args/test.sh

@@ -58,7 +58,7 @@ done
 run_mustfail_stdout "should fail for image" \
 	"$TOP/btrfs" filesystem resize 1:-128M "$TEST_DEV" |
 	_log_stdout |
-	grep -q "ERROR: resize works on mounted filesystems and accepts only" ||
+	grep -q "ERROR: to resize a file containing a BTRFS image use the --offline flag" ||
 	_fail "no expected error message in the output 2"
 
 run_check_umount_test_dev