From 9b5b46a0921aa86f6b7da77e5735b7386e67af05 Mon Sep 17 00:00:00 2001 From: David Disseldorp Date: Tue, 4 Sep 2012 15:29:58 +0200 Subject: [PATCH] vfs_btrfs: add snapshot create/delete calls The "btrfs: manipulate snapshots" smb.conf parameter is disabled by default, to encourage use of, and pass requests through to, the vfs_snapper module. When enabled, issue BTRFS_IOC_SNAP_CREATE_V2 and BTRFS_IOC_SNAP_DESTROY ioctls accordingly. The ioctls are issued as root, so rely on permission checks in the calling FSRVP server process. Base share paths must exist as btrfs subvolumes in order to be supported for snapshot operations. Signed-off-by: David Disseldorp Reviewed-by: Jeremy Allison --- source3/modules/vfs_btrfs.c | 320 ++++++++++++++++++++++++++++++++++++++++++++ source3/wscript | 3 +- 2 files changed, 322 insertions(+), 1 deletion(-) diff --git a/source3/modules/vfs_btrfs.c b/source3/modules/vfs_btrfs.c index 51442391ce6..bd95637c99e 100644 --- a/source3/modules/vfs_btrfs.c +++ b/source3/modules/vfs_btrfs.c @@ -22,6 +22,8 @@ #include #include #include +#include +#include #include "system/filesys.h" #include "includes.h" #include "smbd/smbd.h" @@ -43,6 +45,24 @@ static uint32_t btrfs_fs_capabilities(struct vfs_handle_struct *handle, return fs_capabilities; } +#define SHADOW_COPY_PREFIX "@GMT-" /* vfs_shadow_copy format */ +#define SHADOW_COPY_PATH_FORMAT "@GMT-%Y.%m.%d-%H.%M.%S" + +#define BTRFS_SUBVOL_RDONLY (1ULL << 1) +#define BTRFS_SUBVOL_NAME_MAX 4039 +#define BTRFS_PATH_NAME_MAX 4087 +struct btrfs_ioctl_vol_args_v2 { + int64_t fd; + uint64_t transid; + uint64_t flags; + uint64_t unused[4]; + char name[BTRFS_SUBVOL_NAME_MAX + 1]; +}; +struct btrfs_ioctl_vol_args { + int64_t fd; + char name[BTRFS_PATH_NAME_MAX + 1]; +}; + struct btrfs_ioctl_clone_range_args { int64_t src_fd; uint64_t src_offset; @@ -53,6 +73,10 @@ struct btrfs_ioctl_clone_range_args { #define BTRFS_IOCTL_MAGIC 0x94 #define BTRFS_IOC_CLONE_RANGE _IOW(BTRFS_IOCTL_MAGIC, 13, \ struct btrfs_ioctl_clone_range_args) +#define BTRFS_IOC_SNAP_DESTROY _IOW(BTRFS_IOCTL_MAGIC, 15, \ + struct btrfs_ioctl_vol_args) +#define BTRFS_IOC_SNAP_CREATE_V2 _IOW(BTRFS_IOCTL_MAGIC, 23, \ + struct btrfs_ioctl_vol_args_v2) struct btrfs_cc_state { struct vfs_handle_struct *handle; @@ -347,6 +371,299 @@ err_out: return status; } +/* + * Check whether a path can be shadow copied. Return the base volume, allowing + * the caller to determine if multiple paths lie on the same base volume. + */ +#define BTRFS_INODE_SUBVOL 256 +static NTSTATUS btrfs_snap_check_path(struct vfs_handle_struct *handle, + TALLOC_CTX *mem_ctx, + const char *service_path, + char **base_volume) +{ + struct stat st; + char *base; + + if (!lp_parm_bool(SNUM(handle->conn), + "btrfs", "manipulate snapshots", false)) { + DEBUG(2, ("Btrfs snapshot manipulation disabled, passing\n")); + return SMB_VFS_NEXT_SNAP_CHECK_PATH(handle, mem_ctx, + service_path, base_volume); + } + + /* btrfs userspace uses this logic to confirm subvolume */ + if (stat(service_path, &st) < 0) { + return NT_STATUS_NOT_SUPPORTED; + } + if ((st.st_ino != BTRFS_INODE_SUBVOL) || !S_ISDIR(st.st_mode)) { + DEBUG(0, ("%s not a btrfs subvolume, snapshots not available\n", + service_path)); + return NT_STATUS_NOT_SUPPORTED; + } + + /* we "snapshot" the service path itself */ + base = talloc_strdup(mem_ctx, service_path); + if (base == NULL) { + return NT_STATUS_NO_MEMORY; + } + *base_volume = base; + + return NT_STATUS_OK; +} + +static NTSTATUS btrfs_gen_snap_dest_path(TALLOC_CTX *mem_ctx, + const char *src_path, + time_t *tstamp, + char **dest_path, char **subvolume) +{ + struct tm t_gmt; + char time_str[50]; + size_t tlen; + + gmtime_r(tstamp, &t_gmt); + + tlen = strftime(time_str, ARRAY_SIZE(time_str), + SHADOW_COPY_PATH_FORMAT, &t_gmt); + if (tlen <= 0) { + return NT_STATUS_UNSUCCESSFUL; + } + + *dest_path = talloc_strdup(mem_ctx, src_path); + *subvolume = talloc_strdup(mem_ctx, time_str); + if ((*dest_path == NULL) || (*subvolume == NULL)) { + return NT_STATUS_NO_MEMORY; + } + + return NT_STATUS_OK; +} + +static NTSTATUS btrfs_snap_create(struct vfs_handle_struct *handle, + TALLOC_CTX *mem_ctx, + const char *base_volume, + time_t *tstamp, + bool rw, + char **_base_path, + char **_snap_path) +{ + struct btrfs_ioctl_vol_args_v2 ioctl_arg; + DIR *src_dir; + DIR *dest_dir; + int src_fd; + int dest_fd; + char *dest_path = NULL; + char *dest_subvolume = NULL; + int ret; + NTSTATUS status; + char *base_path; + char *snap_path; + TALLOC_CTX *tmp_ctx; + int saved_errno; + size_t len; + + if (!lp_parm_bool(SNUM(handle->conn), + "btrfs", "manipulate snapshots", false)) { + DEBUG(2, ("Btrfs snapshot manipulation disabled, passing\n")); + return SMB_VFS_NEXT_SNAP_CREATE(handle, mem_ctx, base_volume, + tstamp, rw, _base_path, + _snap_path); + } + + tmp_ctx = talloc_new(mem_ctx); + if (tmp_ctx == NULL) { + return NT_STATUS_NO_MEMORY; + } + + base_path = talloc_strdup(tmp_ctx, base_volume); + if (base_path == NULL) { + talloc_free(tmp_ctx); + return NT_STATUS_NO_MEMORY; + } + + status = btrfs_gen_snap_dest_path(tmp_ctx, base_volume, tstamp, + &dest_path, &dest_subvolume); + if (!NT_STATUS_IS_OK(status)) { + talloc_free(tmp_ctx); + return status; + } + + snap_path = talloc_asprintf(tmp_ctx, "%s/%s", dest_path, + dest_subvolume); + if (snap_path == NULL) { + talloc_free(tmp_ctx); + return NT_STATUS_NO_MEMORY; + } + + src_dir = opendir(base_volume); + if (src_dir == NULL) { + DEBUG(0, ("snap src %s open failed: %s\n", + base_volume, strerror(errno))); + status = map_nt_error_from_unix(errno); + talloc_free(tmp_ctx); + return status; + } + src_fd = dirfd(src_dir); + if (src_fd < 0) { + status = map_nt_error_from_unix(errno); + closedir(src_dir); + talloc_free(tmp_ctx); + return status; + } + + dest_dir = opendir(dest_path); + if (dest_dir == NULL) { + DEBUG(0, ("snap dest %s open failed: %s\n", + dest_path, strerror(errno))); + status = map_nt_error_from_unix(errno); + closedir(src_dir); + talloc_free(tmp_ctx); + return status; + } + dest_fd = dirfd(dest_dir); + if (dest_fd < 0) { + status = map_nt_error_from_unix(errno); + closedir(src_dir); + closedir(dest_dir); + talloc_free(tmp_ctx); + return status; + } + + /* avoid zeroing the entire struct here, name is 4k */ + ioctl_arg.fd = src_fd; + ioctl_arg.transid = 0; + ioctl_arg.flags = (rw == false) ? BTRFS_SUBVOL_RDONLY : 0; + memset(ioctl_arg.unused, 0, ARRAY_SIZE(ioctl_arg.unused)); + len = strlcpy(ioctl_arg.name, dest_subvolume, + ARRAY_SIZE(ioctl_arg.name)); + if (len >= ARRAY_SIZE(ioctl_arg.name)) { + DEBUG(1, ("subvolume name too long for SNAP_CREATE ioctl\n")); + closedir(src_dir); + closedir(dest_dir); + talloc_free(tmp_ctx); + return NT_STATUS_INVALID_PARAMETER; + } + + become_root(); + ret = ioctl(dest_fd, BTRFS_IOC_SNAP_CREATE_V2, &ioctl_arg); + saved_errno = errno; + unbecome_root(); + if (ret < 0) { + DEBUG(0, ("%s -> %s(%s) BTRFS_IOC_SNAP_CREATE_V2 failed: %s\n", + base_volume, dest_path, dest_subvolume, + strerror(saved_errno))); + status = map_nt_error_from_unix(saved_errno); + closedir(src_dir); + closedir(dest_dir); + talloc_free(tmp_ctx); + return status; + } + DEBUG(5, ("%s -> %s(%s) BTRFS_IOC_SNAP_CREATE_V2 done\n", + base_volume, dest_path, dest_subvolume)); + + *_base_path = talloc_steal(mem_ctx, base_path); + *_snap_path = talloc_steal(mem_ctx, snap_path); + closedir(src_dir); + closedir(dest_dir); + talloc_free(tmp_ctx); + + return NT_STATUS_OK; +} + +static NTSTATUS btrfs_snap_delete(struct vfs_handle_struct *handle, + TALLOC_CTX *mem_ctx, + char *base_path, + char *snap_path) +{ + char *tstr; + struct tm t_gmt; + DIR *dest_dir; + int dest_fd; + struct btrfs_ioctl_vol_args ioctl_arg; + int ret; + NTSTATUS status; + char *dest_path; + char *subvolume; + TALLOC_CTX *tmp_ctx; + int saved_errno; + size_t len; + + if (!lp_parm_bool(SNUM(handle->conn), + "btrfs", "manipulate snapshots", false)) { + DEBUG(2, ("Btrfs snapshot manipulation disabled, passing\n")); + return SMB_VFS_NEXT_SNAP_DELETE(handle, mem_ctx, + base_path, snap_path); + } + + tmp_ctx = talloc_new(mem_ctx); + if (tmp_ctx == NULL) { + return NT_STATUS_NO_MEMORY; + } + + dest_path = talloc_strdup(tmp_ctx, snap_path); + if (dest_path == NULL) { + talloc_free(tmp_ctx); + return NT_STATUS_NO_MEMORY; + } + subvolume = talloc_strdup(tmp_ctx, snap_path); + if (subvolume == NULL) { + talloc_free(tmp_ctx); + return NT_STATUS_NO_MEMORY; + } + dest_path = dirname(dest_path); + subvolume = basename(subvolume); + + /* confirm snap_path matches creation format */ + tstr = strptime(subvolume, SHADOW_COPY_PATH_FORMAT, &t_gmt); + if ((tstr == NULL) || (*tstr != '\0')) { + DEBUG(0, ("snapshot path %s does not match creation format\n", + snap_path)); + talloc_free(tmp_ctx); + return NT_STATUS_UNSUCCESSFUL; + } + + dest_dir = opendir(dest_path); + if (dest_dir == NULL) { + DEBUG(0, ("snap destroy dest %s open failed: %s\n", + dest_path, strerror(errno))); + status = map_nt_error_from_unix(errno); + talloc_free(tmp_ctx); + return status; + } + dest_fd = dirfd(dest_dir); + if (dest_fd < 0) { + status = map_nt_error_from_unix(errno); + closedir(dest_dir); + talloc_free(tmp_ctx); + return status; + } + + ioctl_arg.fd = -1; /* not needed */ + len = strlcpy(ioctl_arg.name, subvolume, ARRAY_SIZE(ioctl_arg.name)); + if (len >= ARRAY_SIZE(ioctl_arg.name)) { + DEBUG(1, ("subvolume name too long for SNAP_DESTROY ioctl\n")); + closedir(dest_dir); + talloc_free(tmp_ctx); + return NT_STATUS_INVALID_PARAMETER; + } + + become_root(); + ret = ioctl(dest_fd, BTRFS_IOC_SNAP_DESTROY, &ioctl_arg); + saved_errno = errno; + unbecome_root(); + if (ret < 0) { + DEBUG(0, ("%s(%s) BTRFS_IOC_SNAP_DESTROY failed: %s\n", + dest_path, subvolume, strerror(saved_errno))); + status = map_nt_error_from_unix(saved_errno); + closedir(dest_dir); + talloc_free(tmp_ctx); + return status; + } + DEBUG(5, ("%s(%s) BTRFS_IOC_SNAP_DESTROY done\n", + dest_path, subvolume)); + + closedir(dest_dir); + talloc_free(tmp_ctx); + return NT_STATUS_OK; +} static struct vfs_fn_pointers btrfs_fns = { .fs_capabilities_fn = btrfs_fs_capabilities, @@ -354,6 +671,9 @@ static struct vfs_fn_pointers btrfs_fns = { .copy_chunk_recv_fn = btrfs_copy_chunk_recv, .get_compression_fn = btrfs_get_compression, .set_compression_fn = btrfs_set_compression, + .snap_check_path_fn = btrfs_snap_check_path, + .snap_create_fn = btrfs_snap_create, + .snap_delete_fn = btrfs_snap_delete, }; NTSTATUS vfs_btrfs_init(void); diff --git a/source3/wscript b/source3/wscript index 818cdad817d..4029813beb2 100644 --- a/source3/wscript +++ b/source3/wscript @@ -1634,7 +1634,8 @@ main() { if conf.CONFIG_SET('HAVE_GPFS'): default_shared_modules.extend(TO_LIST('vfs_gpfs')) - if conf.CONFIG_SET('HAVE_LINUX_IOCTL'): + if (conf.CONFIG_SET('HAVE_LINUX_IOCTL') + and conf.CONFIG_SET('HAVE_BASENAME') and conf.CONFIG_SET('HAVE_DIRNAME')): default_shared_modules.extend(TO_LIST('vfs_btrfs')) if conf.CONFIG_SET('SAMBA_FAM_LIBS'): -- 2.11.4.GIT