ctdb/wscript: Remove long pending unsupported option
[Samba.git] / source3 / modules / vfs_btrfs.c
blob903125242876febad9c86042210ae5683402f336
1 /*
2 * Module to make use of awesome Btrfs features
4 * Copyright (C) David Disseldorp 2011-2013
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 3 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
20 #include "includes.h"
21 #include "system/filesys.h"
22 #include <linux/ioctl.h>
23 #include <linux/fs.h>
24 #include <sys/ioctl.h>
25 #include <unistd.h>
26 #include <fcntl.h>
27 #include <dirent.h>
28 #include <libgen.h>
29 #include "smbd/smbd.h"
30 #include "smbd/globals.h"
31 #include "librpc/gen_ndr/smbXsrv.h"
32 #include "librpc/gen_ndr/ioctl.h"
33 #include "lib/util/tevent_ntstatus.h"
34 #include "offload_token.h"
36 static uint32_t btrfs_fs_capabilities(struct vfs_handle_struct *handle,
37 enum timestamp_set_resolution *_ts_res)
39 uint32_t fs_capabilities;
40 enum timestamp_set_resolution ts_res;
42 /* inherit default capabilities, expose compression support */
43 fs_capabilities = SMB_VFS_NEXT_FS_CAPABILITIES(handle, &ts_res);
44 fs_capabilities |= (FILE_FILE_COMPRESSION
45 | FILE_SUPPORTS_BLOCK_REFCOUNTING);
46 *_ts_res = ts_res;
48 return fs_capabilities;
51 #define SHADOW_COPY_PREFIX "@GMT-" /* vfs_shadow_copy format */
52 #define SHADOW_COPY_PATH_FORMAT "@GMT-%Y.%m.%d-%H.%M.%S"
54 #define BTRFS_SUBVOL_RDONLY (1ULL << 1)
55 #define BTRFS_SUBVOL_NAME_MAX 4039
56 #define BTRFS_PATH_NAME_MAX 4087
57 struct btrfs_ioctl_vol_args_v2 {
58 int64_t fd;
59 uint64_t transid;
60 uint64_t flags;
61 uint64_t unused[4];
62 char name[BTRFS_SUBVOL_NAME_MAX + 1];
64 struct btrfs_ioctl_vol_args {
65 int64_t fd;
66 char name[BTRFS_PATH_NAME_MAX + 1];
69 struct btrfs_ioctl_clone_range_args {
70 int64_t src_fd;
71 uint64_t src_offset;
72 uint64_t src_length;
73 uint64_t dest_offset;
76 #define BTRFS_IOCTL_MAGIC 0x94
77 #define BTRFS_IOC_CLONE_RANGE _IOW(BTRFS_IOCTL_MAGIC, 13, \
78 struct btrfs_ioctl_clone_range_args)
79 #define BTRFS_IOC_SNAP_DESTROY _IOW(BTRFS_IOCTL_MAGIC, 15, \
80 struct btrfs_ioctl_vol_args)
81 #define BTRFS_IOC_SNAP_CREATE_V2 _IOW(BTRFS_IOCTL_MAGIC, 23, \
82 struct btrfs_ioctl_vol_args_v2)
84 static struct vfs_offload_ctx *btrfs_offload_ctx;
86 struct btrfs_offload_read_state {
87 struct vfs_handle_struct *handle;
88 files_struct *fsp;
89 uint32_t flags;
90 uint64_t xferlen;
91 DATA_BLOB token;
94 static void btrfs_offload_read_done(struct tevent_req *subreq);
96 static struct tevent_req *btrfs_offload_read_send(
97 TALLOC_CTX *mem_ctx,
98 struct tevent_context *ev,
99 struct vfs_handle_struct *handle,
100 files_struct *fsp,
101 uint32_t fsctl,
102 uint32_t ttl,
103 off_t offset,
104 size_t to_copy)
106 struct tevent_req *req = NULL;
107 struct tevent_req *subreq = NULL;
108 struct btrfs_offload_read_state *state = NULL;
109 NTSTATUS status;
111 req = tevent_req_create(mem_ctx, &state,
112 struct btrfs_offload_read_state);
113 if (req == NULL) {
114 return NULL;
116 *state = (struct btrfs_offload_read_state) {
117 .handle = handle,
118 .fsp = fsp,
121 status = vfs_offload_token_ctx_init(fsp->conn->sconn->client,
122 &btrfs_offload_ctx);
123 if (tevent_req_nterror(req, status)) {
124 return tevent_req_post(req, ev);
127 if (fsctl == FSCTL_DUP_EXTENTS_TO_FILE) {
128 status = vfs_offload_token_create_blob(state, fsp, fsctl,
129 &state->token);
130 if (tevent_req_nterror(req, status)) {
131 return tevent_req_post(req, ev);
134 status = vfs_offload_token_db_store_fsp(btrfs_offload_ctx, fsp,
135 &state->token);
136 if (tevent_req_nterror(req, status)) {
137 return tevent_req_post(req, ev);
139 tevent_req_done(req);
140 return tevent_req_post(req, ev);
143 subreq = SMB_VFS_NEXT_OFFLOAD_READ_SEND(mem_ctx, ev, handle, fsp,
144 fsctl, ttl, offset, to_copy);
145 if (tevent_req_nomem(subreq, req)) {
146 return tevent_req_post(req, ev);
148 tevent_req_set_callback(subreq, btrfs_offload_read_done, req);
149 return req;
152 static void btrfs_offload_read_done(struct tevent_req *subreq)
154 struct tevent_req *req = tevent_req_callback_data(
155 subreq, struct tevent_req);
156 struct btrfs_offload_read_state *state = tevent_req_data(
157 req, struct btrfs_offload_read_state);
158 NTSTATUS status;
160 status = SMB_VFS_NEXT_OFFLOAD_READ_RECV(subreq,
161 state->handle,
162 state,
163 &state->flags,
164 &state->xferlen,
165 &state->token);
166 TALLOC_FREE(subreq);
167 if (tevent_req_nterror(req, status)) {
168 return;
171 status = vfs_offload_token_db_store_fsp(btrfs_offload_ctx,
172 state->fsp,
173 &state->token);
174 if (tevent_req_nterror(req, status)) {
175 return;
178 tevent_req_done(req);
179 return;
182 static NTSTATUS btrfs_offload_read_recv(struct tevent_req *req,
183 struct vfs_handle_struct *handle,
184 TALLOC_CTX *mem_ctx,
185 uint32_t *flags,
186 uint64_t *xferlen,
187 DATA_BLOB *token)
189 struct btrfs_offload_read_state *state = tevent_req_data(
190 req, struct btrfs_offload_read_state);
191 NTSTATUS status;
193 if (tevent_req_is_nterror(req, &status)) {
194 tevent_req_received(req);
195 return status;
198 *flags = state->flags;
199 *xferlen = state->xferlen;
200 token->length = state->token.length;
201 token->data = talloc_move(mem_ctx, &state->token.data);
203 tevent_req_received(req);
204 return NT_STATUS_OK;
207 struct btrfs_offload_write_state {
208 struct vfs_handle_struct *handle;
209 off_t copied;
210 bool need_unbecome_user;
213 static void btrfs_offload_write_cleanup(struct tevent_req *req,
214 enum tevent_req_state req_state)
216 struct btrfs_offload_write_state *state =
217 tevent_req_data(req,
218 struct btrfs_offload_write_state);
219 bool ok;
221 if (!state->need_unbecome_user) {
222 return;
225 ok = unbecome_user_without_service();
226 SMB_ASSERT(ok);
227 state->need_unbecome_user = false;
230 static void btrfs_offload_write_done(struct tevent_req *subreq);
232 static struct tevent_req *btrfs_offload_write_send(struct vfs_handle_struct *handle,
233 TALLOC_CTX *mem_ctx,
234 struct tevent_context *ev,
235 uint32_t fsctl,
236 DATA_BLOB *token,
237 off_t transfer_offset,
238 struct files_struct *dest_fsp,
239 off_t dest_off,
240 off_t num)
242 struct tevent_req *req = NULL;
243 struct btrfs_offload_write_state *state = NULL;
244 struct tevent_req *subreq = NULL;
245 struct btrfs_ioctl_clone_range_args cr_args;
246 struct lock_struct src_lck;
247 struct lock_struct dest_lck;
248 off_t src_off = transfer_offset;
249 files_struct *src_fsp = NULL;
250 int ret;
251 bool handle_offload_write = true;
252 bool do_locking = false;
253 NTSTATUS status;
254 bool ok;
256 req = tevent_req_create(mem_ctx, &state,
257 struct btrfs_offload_write_state);
258 if (req == NULL) {
259 return NULL;
262 state->handle = handle;
264 tevent_req_set_cleanup_fn(req, btrfs_offload_write_cleanup);
266 status = vfs_offload_token_db_fetch_fsp(btrfs_offload_ctx,
267 token, &src_fsp);
268 if (tevent_req_nterror(req, status)) {
269 return tevent_req_post(req, ev);
272 switch (fsctl) {
273 case FSCTL_SRV_COPYCHUNK:
274 case FSCTL_SRV_COPYCHUNK_WRITE:
275 do_locking = true;
276 break;
278 case FSCTL_DUP_EXTENTS_TO_FILE:
279 /* dup extents does not use locking */
280 break;
282 default:
283 handle_offload_write = false;
284 break;
287 if (num == 0) {
289 * With a @src_length of zero, BTRFS_IOC_CLONE_RANGE clones
290 * all data from @src_offset->EOF! This is certainly not what
291 * the caller expects, and not what vfs_default does.
293 handle_offload_write = false;
296 if (!handle_offload_write) {
297 subreq = SMB_VFS_NEXT_OFFLOAD_WRITE_SEND(handle,
298 state,
300 fsctl,
301 token,
302 transfer_offset,
303 dest_fsp,
304 dest_off,
305 num);
306 if (tevent_req_nomem(subreq, req)) {
307 return tevent_req_post(req, ev);
309 tevent_req_set_callback(subreq,
310 btrfs_offload_write_done,
311 req);
312 return req;
315 status = vfs_offload_token_check_handles(
316 fsctl, src_fsp, dest_fsp);
317 if (!NT_STATUS_IS_OK(status)) {
318 tevent_req_nterror(req, status);
319 return tevent_req_post(req, ev);
322 ok = become_user_without_service_by_fsp(src_fsp);
323 if (!ok) {
324 tevent_req_nterror(req, NT_STATUS_ACCESS_DENIED);
325 return tevent_req_post(req, ev);
327 state->need_unbecome_user = true;
329 status = vfs_stat_fsp(src_fsp);
330 if (tevent_req_nterror(req, status)) {
331 return tevent_req_post(req, ev);
334 if (src_fsp->fsp_name->st.st_ex_size < src_off + num) {
335 /* [MS-SMB2] Handling a Server-Side Data Copy Request */
336 tevent_req_nterror(req, NT_STATUS_INVALID_VIEW_SIZE);
337 return tevent_req_post(req, ev);
340 if (do_locking) {
341 init_strict_lock_struct(src_fsp,
342 src_fsp->op->global->open_persistent_id,
343 src_off,
344 num,
345 READ_LOCK,
346 lp_posix_cifsu_locktype(src_fsp),
347 &src_lck);
348 if (!SMB_VFS_STRICT_LOCK_CHECK(src_fsp->conn, src_fsp, &src_lck)) {
349 tevent_req_nterror(req, NT_STATUS_FILE_LOCK_CONFLICT);
350 return tevent_req_post(req, ev);
354 ok = unbecome_user_without_service();
355 SMB_ASSERT(ok);
356 state->need_unbecome_user = false;
358 if (do_locking) {
359 init_strict_lock_struct(dest_fsp,
360 dest_fsp->op->global->open_persistent_id,
361 dest_off,
362 num,
363 WRITE_LOCK,
364 lp_posix_cifsu_locktype(dest_fsp),
365 &dest_lck);
367 if (!SMB_VFS_STRICT_LOCK_CHECK(dest_fsp->conn, dest_fsp, &dest_lck)) {
368 tevent_req_nterror(req, NT_STATUS_FILE_LOCK_CONFLICT);
369 return tevent_req_post(req, ev);
373 ZERO_STRUCT(cr_args);
374 cr_args.src_fd = fsp_get_io_fd(src_fsp);
375 cr_args.src_offset = (uint64_t)src_off;
376 cr_args.dest_offset = (uint64_t)dest_off;
377 cr_args.src_length = (uint64_t)num;
379 ret = ioctl(fsp_get_io_fd(dest_fsp), BTRFS_IOC_CLONE_RANGE, &cr_args);
380 if (ret < 0) {
382 * BTRFS_IOC_CLONE_RANGE only supports 'sectorsize' aligned
383 * cloning. Which is 4096 by default, therefore fall back to
384 * manual read/write on failure.
386 DEBUG(5, ("BTRFS_IOC_CLONE_RANGE failed: %s, length %llu, "
387 "src fd: %lld off: %llu, dest fd: %d off: %llu\n",
388 strerror(errno),
389 (unsigned long long)cr_args.src_length,
390 (long long)cr_args.src_fd,
391 (unsigned long long)cr_args.src_offset,
392 fsp_get_io_fd(dest_fsp),
393 (unsigned long long)cr_args.dest_offset));
394 subreq = SMB_VFS_NEXT_OFFLOAD_WRITE_SEND(handle,
395 state,
397 fsctl,
398 token,
399 transfer_offset,
400 dest_fsp,
401 dest_off,
402 num);
403 if (tevent_req_nomem(subreq, req)) {
404 return tevent_req_post(req, ev);
406 /* wait for subreq completion */
407 tevent_req_set_callback(subreq,
408 btrfs_offload_write_done,
409 req);
410 return req;
413 DEBUG(5, ("BTRFS_IOC_CLONE_RANGE returned %d\n", ret));
414 /* BTRFS_IOC_CLONE_RANGE is all or nothing */
415 state->copied = num;
416 tevent_req_done(req);
417 return tevent_req_post(req, ev);
420 /* only used if the request is passed through to next VFS module */
421 static void btrfs_offload_write_done(struct tevent_req *subreq)
423 struct tevent_req *req =
424 tevent_req_callback_data(subreq,
425 struct tevent_req);
426 struct btrfs_offload_write_state *state =
427 tevent_req_data(req,
428 struct btrfs_offload_write_state);
429 NTSTATUS status;
431 status = SMB_VFS_NEXT_OFFLOAD_WRITE_RECV(state->handle,
432 subreq,
433 &state->copied);
434 TALLOC_FREE(subreq);
435 if (tevent_req_nterror(req, status)) {
436 return;
438 tevent_req_done(req);
441 static NTSTATUS btrfs_offload_write_recv(struct vfs_handle_struct *handle,
442 struct tevent_req *req,
443 off_t *copied)
445 struct btrfs_offload_write_state *state =
446 tevent_req_data(req,
447 struct btrfs_offload_write_state);
448 NTSTATUS status;
450 if (tevent_req_is_nterror(req, &status)) {
451 DEBUG(4, ("server side copy chunk failed: %s\n",
452 nt_errstr(status)));
453 tevent_req_received(req);
454 return status;
457 DEBUG(10, ("server side copy chunk copied %llu\n",
458 (unsigned long long)state->copied));
459 *copied = state->copied;
460 tevent_req_received(req);
461 return NT_STATUS_OK;
464 static NTSTATUS btrfs_fget_compression(struct vfs_handle_struct *handle,
465 TALLOC_CTX *mem_ctx,
466 struct files_struct *fsp,
467 uint16_t *_compression_fmt)
469 struct sys_proc_fd_path_buf buf;
470 int ret;
471 long flags = 0;
472 int fsp_fd = fsp_get_pathref_fd(fsp);
473 int fd = -1;
474 NTSTATUS status;
476 if (!fsp->fsp_flags.is_pathref) {
477 ret = ioctl(fsp_fd, FS_IOC_GETFLAGS, &flags);
478 if (ret < 0) {
479 DBG_WARNING("FS_IOC_GETFLAGS failed: %s, fd %lld\n",
480 strerror(errno), (long long)fd);
481 return map_nt_error_from_unix(errno);
483 if (flags & FS_COMPR_FL) {
484 *_compression_fmt = COMPRESSION_FORMAT_LZNT1;
485 } else {
486 *_compression_fmt = COMPRESSION_FORMAT_NONE;
488 return NT_STATUS_OK;
491 if (!fsp->fsp_flags.have_proc_fds) {
492 return NT_STATUS_NOT_IMPLEMENTED;
495 fd = open(sys_proc_fd_path(fsp_fd, &buf), O_RDONLY);
496 if (fd == -1) {
497 DBG_DEBUG("/proc open of %s failed: %s\n",
498 buf.buf,
499 strerror(errno));
500 return map_nt_error_from_unix(errno);
503 ret = ioctl(fd, FS_IOC_GETFLAGS, &flags);
504 if (ret < 0) {
505 DEBUG(1, ("FS_IOC_GETFLAGS failed: %s, fd %lld\n",
506 strerror(errno), (long long)fd));
507 status = map_nt_error_from_unix(errno);
508 goto err_close;
510 if (flags & FS_COMPR_FL) {
511 *_compression_fmt = COMPRESSION_FORMAT_LZNT1;
512 } else {
513 *_compression_fmt = COMPRESSION_FORMAT_NONE;
515 status = NT_STATUS_OK;
517 err_close:
518 if (fd != -1) {
519 close(fd);
522 return status;
525 static NTSTATUS btrfs_set_compression(struct vfs_handle_struct *handle,
526 TALLOC_CTX *mem_ctx,
527 struct files_struct *fsp,
528 uint16_t compression_fmt)
530 int ret;
531 long flags = 0;
532 int fd;
533 NTSTATUS status;
535 if ((fsp == NULL) || (fsp_get_io_fd(fsp) == -1)) {
536 status = NT_STATUS_INVALID_PARAMETER;
537 goto err_out;
539 fd = fsp_get_io_fd(fsp);
541 ret = ioctl(fd, FS_IOC_GETFLAGS, &flags);
542 if (ret < 0) {
543 DEBUG(1, ("FS_IOC_GETFLAGS failed: %s, fd %d\n",
544 strerror(errno), fd));
545 status = map_nt_error_from_unix(errno);
546 goto err_out;
549 if (compression_fmt == COMPRESSION_FORMAT_NONE) {
550 DEBUG(5, ("setting compression\n"));
551 flags &= (~FS_COMPR_FL);
552 } else if ((compression_fmt == COMPRESSION_FORMAT_DEFAULT)
553 || (compression_fmt == COMPRESSION_FORMAT_LZNT1)) {
554 DEBUG(5, ("clearing compression\n"));
555 flags |= FS_COMPR_FL;
556 } else {
557 DEBUG(1, ("invalid compression format 0x%x\n",
558 (int)compression_fmt));
559 status = NT_STATUS_INVALID_PARAMETER;
560 goto err_out;
563 ret = ioctl(fd, FS_IOC_SETFLAGS, &flags);
564 if (ret < 0) {
565 DEBUG(1, ("FS_IOC_SETFLAGS failed: %s, fd %d\n",
566 strerror(errno), fd));
567 status = map_nt_error_from_unix(errno);
568 goto err_out;
570 status = NT_STATUS_OK;
571 err_out:
572 return status;
576 * Check whether a path can be shadow copied. Return the base volume, allowing
577 * the caller to determine if multiple paths lie on the same base volume.
579 #define BTRFS_INODE_SUBVOL 256
580 static NTSTATUS btrfs_snap_check_path(struct vfs_handle_struct *handle,
581 TALLOC_CTX *mem_ctx,
582 const char *service_path,
583 char **base_volume)
585 struct stat st;
586 char *base;
588 if (!lp_parm_bool(SNUM(handle->conn),
589 "btrfs", "manipulate snapshots", false)) {
590 DEBUG(2, ("Btrfs snapshot manipulation disabled, passing\n"));
591 return SMB_VFS_NEXT_SNAP_CHECK_PATH(handle, mem_ctx,
592 service_path, base_volume);
595 /* btrfs userspace uses this logic to confirm subvolume */
596 if (stat(service_path, &st) < 0) {
597 return NT_STATUS_NOT_SUPPORTED;
599 if ((st.st_ino != BTRFS_INODE_SUBVOL) || !S_ISDIR(st.st_mode)) {
600 DEBUG(0, ("%s not a btrfs subvolume, snapshots not available\n",
601 service_path));
602 return NT_STATUS_NOT_SUPPORTED;
605 /* we "snapshot" the service path itself */
606 base = talloc_strdup(mem_ctx, service_path);
607 if (base == NULL) {
608 return NT_STATUS_NO_MEMORY;
610 *base_volume = base;
612 return NT_STATUS_OK;
615 static NTSTATUS btrfs_gen_snap_dest_path(TALLOC_CTX *mem_ctx,
616 const char *src_path,
617 time_t *tstamp,
618 char **dest_path, char **subvolume)
620 struct tm t_gmt;
621 char time_str[50];
622 size_t tlen;
624 gmtime_r(tstamp, &t_gmt);
626 tlen = strftime(time_str, ARRAY_SIZE(time_str),
627 SHADOW_COPY_PATH_FORMAT, &t_gmt);
628 if (tlen <= 0) {
629 return NT_STATUS_UNSUCCESSFUL;
632 *dest_path = talloc_strdup(mem_ctx, src_path);
633 *subvolume = talloc_strdup(mem_ctx, time_str);
634 if ((*dest_path == NULL) || (*subvolume == NULL)) {
635 return NT_STATUS_NO_MEMORY;
638 return NT_STATUS_OK;
641 static NTSTATUS btrfs_snap_create(struct vfs_handle_struct *handle,
642 TALLOC_CTX *mem_ctx,
643 const char *base_volume,
644 time_t *tstamp,
645 bool rw,
646 char **_base_path,
647 char **_snap_path)
649 struct btrfs_ioctl_vol_args_v2 ioctl_arg;
650 DIR *src_dir;
651 DIR *dest_dir;
652 int src_fd;
653 int dest_fd;
654 char *dest_path = NULL;
655 char *dest_subvolume = NULL;
656 int ret;
657 NTSTATUS status;
658 char *base_path;
659 char *snap_path;
660 TALLOC_CTX *tmp_ctx;
661 int saved_errno;
662 size_t len;
664 if (!lp_parm_bool(SNUM(handle->conn),
665 "btrfs", "manipulate snapshots", false)) {
666 DEBUG(2, ("Btrfs snapshot manipulation disabled, passing\n"));
667 return SMB_VFS_NEXT_SNAP_CREATE(handle, mem_ctx, base_volume,
668 tstamp, rw, _base_path,
669 _snap_path);
672 tmp_ctx = talloc_new(mem_ctx);
673 if (tmp_ctx == NULL) {
674 return NT_STATUS_NO_MEMORY;
677 base_path = talloc_strdup(tmp_ctx, base_volume);
678 if (base_path == NULL) {
679 talloc_free(tmp_ctx);
680 return NT_STATUS_NO_MEMORY;
683 status = btrfs_gen_snap_dest_path(tmp_ctx, base_volume, tstamp,
684 &dest_path, &dest_subvolume);
685 if (!NT_STATUS_IS_OK(status)) {
686 talloc_free(tmp_ctx);
687 return status;
690 snap_path = talloc_asprintf(tmp_ctx, "%s/%s", dest_path,
691 dest_subvolume);
692 if (snap_path == NULL) {
693 talloc_free(tmp_ctx);
694 return NT_STATUS_NO_MEMORY;
697 src_dir = opendir(base_volume);
698 if (src_dir == NULL) {
699 DEBUG(0, ("snap src %s open failed: %s\n",
700 base_volume, strerror(errno)));
701 status = map_nt_error_from_unix(errno);
702 talloc_free(tmp_ctx);
703 return status;
705 src_fd = dirfd(src_dir);
706 if (src_fd < 0) {
707 status = map_nt_error_from_unix(errno);
708 closedir(src_dir);
709 talloc_free(tmp_ctx);
710 return status;
713 dest_dir = opendir(dest_path);
714 if (dest_dir == NULL) {
715 DEBUG(0, ("snap dest %s open failed: %s\n",
716 dest_path, strerror(errno)));
717 status = map_nt_error_from_unix(errno);
718 closedir(src_dir);
719 talloc_free(tmp_ctx);
720 return status;
722 dest_fd = dirfd(dest_dir);
723 if (dest_fd < 0) {
724 status = map_nt_error_from_unix(errno);
725 closedir(src_dir);
726 closedir(dest_dir);
727 talloc_free(tmp_ctx);
728 return status;
731 /* avoid zeroing the entire struct here, name is 4k */
732 ioctl_arg.fd = src_fd;
733 ioctl_arg.transid = 0;
734 ioctl_arg.flags = (rw == false) ? BTRFS_SUBVOL_RDONLY : 0;
735 memset(ioctl_arg.unused, 0, sizeof(ioctl_arg.unused));
736 len = strlcpy(ioctl_arg.name, dest_subvolume,
737 ARRAY_SIZE(ioctl_arg.name));
738 if (len >= ARRAY_SIZE(ioctl_arg.name)) {
739 DEBUG(1, ("subvolume name too long for SNAP_CREATE ioctl\n"));
740 closedir(src_dir);
741 closedir(dest_dir);
742 talloc_free(tmp_ctx);
743 return NT_STATUS_INVALID_PARAMETER;
746 become_root();
747 ret = ioctl(dest_fd, BTRFS_IOC_SNAP_CREATE_V2, &ioctl_arg);
748 saved_errno = errno;
749 unbecome_root();
750 if (ret < 0) {
751 DEBUG(0, ("%s -> %s(%s) BTRFS_IOC_SNAP_CREATE_V2 failed: %s\n",
752 base_volume, dest_path, dest_subvolume,
753 strerror(saved_errno)));
754 status = map_nt_error_from_unix(saved_errno);
755 closedir(src_dir);
756 closedir(dest_dir);
757 talloc_free(tmp_ctx);
758 return status;
760 DEBUG(5, ("%s -> %s(%s) BTRFS_IOC_SNAP_CREATE_V2 done\n",
761 base_volume, dest_path, dest_subvolume));
763 *_base_path = talloc_steal(mem_ctx, base_path);
764 *_snap_path = talloc_steal(mem_ctx, snap_path);
765 closedir(src_dir);
766 closedir(dest_dir);
767 talloc_free(tmp_ctx);
769 return NT_STATUS_OK;
772 static NTSTATUS btrfs_snap_delete(struct vfs_handle_struct *handle,
773 TALLOC_CTX *mem_ctx,
774 char *base_path,
775 char *snap_path)
777 char *tstr;
778 struct tm t_gmt = {};
779 DIR *dest_dir;
780 int dest_fd;
781 struct btrfs_ioctl_vol_args ioctl_arg;
782 int ret;
783 NTSTATUS status;
784 char *dest_path;
785 char *subvolume;
786 TALLOC_CTX *tmp_ctx;
787 int saved_errno;
788 size_t len;
790 if (!lp_parm_bool(SNUM(handle->conn),
791 "btrfs", "manipulate snapshots", false)) {
792 DEBUG(2, ("Btrfs snapshot manipulation disabled, passing\n"));
793 return SMB_VFS_NEXT_SNAP_DELETE(handle, mem_ctx,
794 base_path, snap_path);
797 tmp_ctx = talloc_new(mem_ctx);
798 if (tmp_ctx == NULL) {
799 return NT_STATUS_NO_MEMORY;
802 dest_path = talloc_strdup(tmp_ctx, snap_path);
803 if (dest_path == NULL) {
804 talloc_free(tmp_ctx);
805 return NT_STATUS_NO_MEMORY;
807 subvolume = talloc_strdup(tmp_ctx, snap_path);
808 if (subvolume == NULL) {
809 talloc_free(tmp_ctx);
810 return NT_STATUS_NO_MEMORY;
812 dest_path = dirname(dest_path);
813 subvolume = basename(subvolume);
815 /* confirm snap_path matches creation format */
816 tstr = strptime(subvolume, SHADOW_COPY_PATH_FORMAT, &t_gmt);
817 if ((tstr == NULL) || (*tstr != '\0')) {
818 DEBUG(0, ("snapshot path %s does not match creation format\n",
819 snap_path));
820 talloc_free(tmp_ctx);
821 return NT_STATUS_UNSUCCESSFUL;
824 dest_dir = opendir(dest_path);
825 if (dest_dir == NULL) {
826 DEBUG(0, ("snap destroy dest %s open failed: %s\n",
827 dest_path, strerror(errno)));
828 status = map_nt_error_from_unix(errno);
829 talloc_free(tmp_ctx);
830 return status;
832 dest_fd = dirfd(dest_dir);
833 if (dest_fd < 0) {
834 status = map_nt_error_from_unix(errno);
835 closedir(dest_dir);
836 talloc_free(tmp_ctx);
837 return status;
840 ioctl_arg.fd = -1; /* not needed */
841 len = strlcpy(ioctl_arg.name, subvolume, ARRAY_SIZE(ioctl_arg.name));
842 if (len >= ARRAY_SIZE(ioctl_arg.name)) {
843 DEBUG(1, ("subvolume name too long for SNAP_DESTROY ioctl\n"));
844 closedir(dest_dir);
845 talloc_free(tmp_ctx);
846 return NT_STATUS_INVALID_PARAMETER;
849 become_root();
850 ret = ioctl(dest_fd, BTRFS_IOC_SNAP_DESTROY, &ioctl_arg);
851 saved_errno = errno;
852 unbecome_root();
853 if (ret < 0) {
854 DEBUG(0, ("%s(%s) BTRFS_IOC_SNAP_DESTROY failed: %s\n",
855 dest_path, subvolume, strerror(saved_errno)));
856 status = map_nt_error_from_unix(saved_errno);
857 closedir(dest_dir);
858 talloc_free(tmp_ctx);
859 return status;
861 DEBUG(5, ("%s(%s) BTRFS_IOC_SNAP_DESTROY done\n",
862 dest_path, subvolume));
864 closedir(dest_dir);
865 talloc_free(tmp_ctx);
866 return NT_STATUS_OK;
869 static struct vfs_fn_pointers btrfs_fns = {
870 .fs_capabilities_fn = btrfs_fs_capabilities,
871 .offload_read_send_fn = btrfs_offload_read_send,
872 .offload_read_recv_fn = btrfs_offload_read_recv,
873 .offload_write_send_fn = btrfs_offload_write_send,
874 .offload_write_recv_fn = btrfs_offload_write_recv,
875 .fget_compression_fn = btrfs_fget_compression,
876 .set_compression_fn = btrfs_set_compression,
877 .snap_check_path_fn = btrfs_snap_check_path,
878 .snap_create_fn = btrfs_snap_create,
879 .snap_delete_fn = btrfs_snap_delete,
882 static_decl_vfs;
883 NTSTATUS vfs_btrfs_init(TALLOC_CTX *ctx)
885 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
886 "btrfs", &btrfs_fns);