?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Btrfs progs v4.5-rc1
[btrfs-progs-unstable/devel.git] / cmds-receive.c
blobcbb16421b14963e9edd98f3c27ffa1d6214bb969
1 /*
2 * Copyright (C) 2012 Alexander Block. All rights reserved.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
17 */
18
19 #include "kerncompat.h"
20 #include "androidcompat.h"
21
22 #include <unistd.h>
23 #include <stdint.h>
24 #include <dirent.h>
25 #include <fcntl.h>
26 #include <pthread.h>
27 #include <math.h>
28 #include <ftw.h>
29 #include <sys/wait.h>
30 #include <assert.h>
31 #include <getopt.h>
32 #include <limits.h>
33
34 #include <sys/stat.h>
35 #include <sys/types.h>
36 #include <sys/ioctl.h>
37 #include <sys/time.h>
38 #include <sys/types.h>
39 #include <sys/xattr.h>
40 #include <uuid/uuid.h>
41
42 #include "ctree.h"
43 #include "ioctl.h"
44 #include "commands.h"
45 #include "utils.h"
46 #include "list.h"
47 #include "btrfs-list.h"
48
49 #include "send.h"
50 #include "send-stream.h"
51 #include "send-utils.h"
52
53 static int g_verbose = 0;
54
55 struct btrfs_receive
56 {
57 int mnt_fd;
58 int dest_dir_fd;
59
60 int write_fd;
61 char write_path[PATH_MAX];
62
63 char *root_path;
64 char *dest_dir_path; /* relative to root_path */
65 char full_subvol_path[PATH_MAX];
66 char *full_root_path;
67 int dest_dir_chroot;
68
69 struct subvol_info cur_subvol;
70 /*
71 * Substitute for cur_subvol::path which is a pointer and we cannot
72 * change it to an array as it's a public API.
73 */
74 char cur_subvol_path[PATH_MAX];
75
76 struct subvol_uuid_search sus;
77
78 int honor_end_cmd;
79
80 /*
81 * Buffer to store capabilities from security.capabilities xattr,
82 * usually 20 bytes, but make same room for potentially larger
83 * encodings. Must be set only once per file, denoted by length > 0.
84 */
85 char cached_capabilities[64];
86 int cached_capabilities_len;
87 };
88
89 static int finish_subvol(struct btrfs_receive *r)
90 {
91 int ret;
92 int subvol_fd = -1;
93 struct btrfs_ioctl_received_subvol_args rs_args;
94 char uuid_str[BTRFS_UUID_UNPARSED_SIZE];
95 u64 flags;
96
97 if (r->cur_subvol_path[0] == 0)
98 return 0;
99
100 subvol_fd = openat(r->mnt_fd, r->cur_subvol_path,
101 O_RDONLY | O_NOATIME);
102 if (subvol_fd < 0) {
103 ret = -errno;
104 error("cannot open %s: %s\n",
105 r->cur_subvol_path, strerror(-ret));
106 goto out;
107 }
108
109 memset(&rs_args, 0, sizeof(rs_args));
110 memcpy(rs_args.uuid, r->cur_subvol.received_uuid, BTRFS_UUID_SIZE);
111 rs_args.stransid = r->cur_subvol.stransid;
112
113 if (g_verbose >= 1) {
114 uuid_unparse((u8*)rs_args.uuid, uuid_str);
115 fprintf(stderr, "BTRFS_IOC_SET_RECEIVED_SUBVOL uuid=%s, "
116 "stransid=%llu\n", uuid_str, rs_args.stransid);
117 }
118
119 ret = ioctl(subvol_fd, BTRFS_IOC_SET_RECEIVED_SUBVOL, &rs_args);
120 if (ret < 0) {
121 ret = -errno;
122 error("ioctl BTRFS_IOC_SET_RECEIVED_SUBVOL failed: %s",
123 strerror(-ret));
124 goto out;
125 }
126 r->cur_subvol.rtransid = rs_args.rtransid;
127
128 ret = ioctl(subvol_fd, BTRFS_IOC_SUBVOL_GETFLAGS, &flags);
129 if (ret < 0) {
130 ret = -errno;
131 error("ioctl BTRFS_IOC_SUBVOL_GETFLAGS failed: %s",
132 strerror(-ret));
133 goto out;
134 }
135
136 flags |= BTRFS_SUBVOL_RDONLY;
137
138 ret = ioctl(subvol_fd, BTRFS_IOC_SUBVOL_SETFLAGS, &flags);
139 if (ret < 0) {
140 ret = -errno;
141 error("failed to make subvolume read only: %s",
142 strerror(-ret));
143 goto out;
144 }
145
146 ret = 0;
147
148 out:
149 if (r->cur_subvol_path[0]) {
150 r->cur_subvol_path[0] = 0;
151 }
152 if (subvol_fd != -1)
153 close(subvol_fd);
154 return ret;
155 }
156
157 static int process_subvol(const char *path, const u8 *uuid, u64 ctransid,
158 void *user)
159 {
160 int ret;
161 struct btrfs_receive *r = user;
162 struct btrfs_ioctl_vol_args args_v1;
163 char uuid_str[BTRFS_UUID_UNPARSED_SIZE];
164
165 ret = finish_subvol(r);
166 if (ret < 0)
167 goto out;
168
169 BUG_ON(r->cur_subvol.path);
170 BUG_ON(r->cur_subvol_path[0]);
171
172 if (*r->dest_dir_path == 0) {
173 strncpy_null(r->cur_subvol_path, path);
174 } else {
175 ret = path_cat_out(r->cur_subvol_path, r->dest_dir_path, path);
176 if (ret < 0) {
177 error("subvol: path invalid: %s\n", path);
178 goto out;
179 }
180 }
181 ret = path_cat3_out(r->full_subvol_path, r->root_path,
182 r->dest_dir_path, path);
183 if (ret < 0) {
184 error("subvol: path invalid: %s", path);
185 goto out;
186 }
187
188 fprintf(stderr, "At subvol %s\n", path);
189
190 memcpy(r->cur_subvol.received_uuid, uuid, BTRFS_UUID_SIZE);
191 r->cur_subvol.stransid = ctransid;
192
193 if (g_verbose) {
194 uuid_unparse((u8*)r->cur_subvol.received_uuid, uuid_str);
195 fprintf(stderr, "receiving subvol %s uuid=%s, stransid=%llu\n",
196 path, uuid_str,
197 r->cur_subvol.stransid);
198 }
199
200 memset(&args_v1, 0, sizeof(args_v1));
201 strncpy_null(args_v1.name, path);
202 ret = ioctl(r->dest_dir_fd, BTRFS_IOC_SUBVOL_CREATE, &args_v1);
203 if (ret < 0) {
204 ret = -errno;
205 error("creating subvolume %s failed: %s", path, strerror(-ret));
206 goto out;
207 }
208
209 out:
210 return ret;
211 }
212
213 static int process_snapshot(const char *path, const u8 *uuid, u64 ctransid,
214 const u8 *parent_uuid, u64 parent_ctransid,
215 void *user)
216 {
217 int ret;
218 struct btrfs_receive *r = user;
219 char uuid_str[BTRFS_UUID_UNPARSED_SIZE];
220 struct btrfs_ioctl_vol_args_v2 args_v2;
221 struct subvol_info *parent_subvol = NULL;
222
223 ret = finish_subvol(r);
224 if (ret < 0)
225 goto out;
226
227 BUG_ON(r->cur_subvol.path);
228 BUG_ON(r->cur_subvol_path[0]);
229
230 if (*r->dest_dir_path == 0) {
231 strncpy_null(r->cur_subvol_path, path);
232 } else {
233 ret = path_cat_out(r->cur_subvol_path, r->dest_dir_path, path);
234 if (ret < 0) {
235 error("snapshot: path invalid: %s", path);
236 goto out;
237 }
238 }
239 ret = path_cat3_out(r->full_subvol_path, r->root_path,
240 r->dest_dir_path, path);
241 if (ret < 0) {
242 error("snapshot: path invalid: %s", path);
243 goto out;
244 }
245
246 fprintf(stdout, "At snapshot %s\n", path);
247
248 memcpy(r->cur_subvol.received_uuid, uuid, BTRFS_UUID_SIZE);
249 r->cur_subvol.stransid = ctransid;
250
251 if (g_verbose) {
252 uuid_unparse((u8*)r->cur_subvol.received_uuid, uuid_str);
253 fprintf(stderr, "receiving snapshot %s uuid=%s, "
254 "ctransid=%llu ", path, uuid_str,
255 r->cur_subvol.stransid);
256 uuid_unparse(parent_uuid, uuid_str);
257 fprintf(stderr, "parent_uuid=%s, parent_ctransid=%llu\n",
258 uuid_str, parent_ctransid);
259 }
260
261 memset(&args_v2, 0, sizeof(args_v2));
262 strncpy_null(args_v2.name, path);
263
264 parent_subvol = subvol_uuid_search(&r->sus, 0, parent_uuid,
265 parent_ctransid, NULL, subvol_search_by_received_uuid);
266 if (!parent_subvol) {
267 parent_subvol = subvol_uuid_search(&r->sus, 0, parent_uuid,
268 parent_ctransid, NULL, subvol_search_by_uuid);
269 }
270 if (!parent_subvol) {
271 ret = -ENOENT;
272 error("cannot find parent subvolume");
273 goto out;
274 }
275
276 /*
277 * The path is resolved from the root subvol, but we could be in some
278 * subvolume under the root subvolume, so try and adjust the path to be
279 * relative to our root path.
280 */
281 if (r->full_root_path) {
282 size_t root_len;
283 size_t sub_len;
284
285 root_len = strlen(r->full_root_path);
286 sub_len = strlen(parent_subvol->path);
287
288 /* First make sure the parent subvol is actually in our path */
289 if (sub_len < root_len ||
290 strstr(parent_subvol->path, r->full_root_path) == NULL) {
291 error(
292 "parent subvol is not reachable from inside the root subvol");
293 ret = -ENOENT;
294 goto out;
295 }
296
297 if (sub_len == root_len) {
298 parent_subvol->path[0] = '/';
299 parent_subvol->path[1] = '\0';
300 } else {
301 /*
302 * root path is foo/bar
303 * subvol path is foo/bar/baz
304 *
305 * we need to have baz be the path, so we need to move
306 * the bit after foo/bar/, so path + root_len + 1, and
307 * move the part we care about, so sub_len - root_len -
308 * 1.
309 */
310 memmove(parent_subvol->path,
311 parent_subvol->path + root_len + 1,
312 sub_len - root_len - 1);
313 parent_subvol->path[sub_len - root_len - 1] = '\0';
314 }
315 }
316 /*if (rs_args.ctransid > rs_args.rtransid) {
317 if (!r->force) {
318 ret = -EINVAL;
319 fprintf(stderr, "ERROR: subvolume %s was modified after it was received.\n", r->subvol_parent_name);
320 goto out;
321 } else {
322 fprintf(stderr, "WARNING: subvolume %s was modified after it was received.\n", r->subvol_parent_name);
323 }
324 }*/
325
326 if (*parent_subvol->path == 0)
327 args_v2.fd = dup(r->mnt_fd);
328 else
329 args_v2.fd = openat(r->mnt_fd, parent_subvol->path,
330 O_RDONLY | O_NOATIME);
331 if (args_v2.fd < 0) {
332 ret = -errno;
333 if (errno != ENOENT)
334 error("cannot open %s: %s",
335 parent_subvol->path, strerror(-ret));
336 else
337 fprintf(stderr,
338 "It seems that you have changed your default "
339 "subvolume or you specify other subvolume to\n"
340 "mount btrfs, try to remount this btrfs filesystem "
341 "with fs tree, and run btrfs receive again!\n");
342 goto out;
343 }
344
345 ret = ioctl(r->dest_dir_fd, BTRFS_IOC_SNAP_CREATE_V2, &args_v2);
346 close(args_v2.fd);
347 if (ret < 0) {
348 ret = -errno;
349 error("creating snapshot %s -> %s failed: %s",
350 parent_subvol->path, path, strerror(-ret));
351 goto out;
352 }
353
354 out:
355 if (parent_subvol) {
356 free(parent_subvol->path);
357 free(parent_subvol);
358 }
359 return ret;
360 }
361
362 static int process_mkfile(const char *path, void *user)
363 {
364 int ret;
365 struct btrfs_receive *r = user;
366 char full_path[PATH_MAX];
367
368 ret = path_cat_out(full_path, r->full_subvol_path, path);
369 if (ret < 0) {
370 error("mkfile: path invalid: %s", path);
371 goto out;
372 }
373
374 if (g_verbose >= 2)
375 fprintf(stderr, "mkfile %s\n", path);
376
377 ret = creat(full_path, 0600);
378 if (ret < 0) {
379 ret = -errno;
380 error("mkfile %s failed: %s", path, strerror(-ret));
381 goto out;
382 }
383 close(ret);
384 ret = 0;
385
386 out:
387 return ret;
388 }
389
390 static int process_mkdir(const char *path, void *user)
391 {
392 int ret;
393 struct btrfs_receive *r = user;
394 char full_path[PATH_MAX];
395
396 ret = path_cat_out(full_path, r->full_subvol_path, path);
397 if (ret < 0) {
398 error("mkdir: path invalid: %s", path);
399 goto out;
400 }
401
402 if (g_verbose >= 2)
403 fprintf(stderr, "mkdir %s\n", path);
404
405 ret = mkdir(full_path, 0700);
406 if (ret < 0) {
407 ret = -errno;
408 error("mkdir %s failed: %s", path, strerror(-ret));
409 }
410
411 out:
412 return ret;
413 }
414
415 static int process_mknod(const char *path, u64 mode, u64 dev, void *user)
416 {
417 int ret;
418 struct btrfs_receive *r = user;
419 char full_path[PATH_MAX];
420
421 ret = path_cat_out(full_path, r->full_subvol_path, path);
422 if (ret < 0) {
423 error("mknod: path invalid: %s", path);
424 goto out;
425 }
426
427 if (g_verbose >= 2)
428 fprintf(stderr, "mknod %s mode=%llu, dev=%llu\n",
429 path, mode, dev);
430
431 ret = mknod(full_path, mode & S_IFMT, dev);
432 if (ret < 0) {
433 ret = -errno;
434 error("mknod %s failed: %s", path, strerror(-ret));
435 }
436
437 out:
438 return ret;
439 }
440
441 static int process_mkfifo(const char *path, void *user)
442 {
443 int ret;
444 struct btrfs_receive *r = user;
445 char full_path[PATH_MAX];
446
447 ret = path_cat_out(full_path, r->full_subvol_path, path);
448 if (ret < 0) {
449 error("mkfifo: path invalid: %s", path);
450 goto out;
451 }
452
453 if (g_verbose >= 2)
454 fprintf(stderr, "mkfifo %s\n", path);
455
456 ret = mkfifo(full_path, 0600);
457 if (ret < 0) {
458 ret = -errno;
459 error("mkfifo %s failed: %s", path, strerror(-ret));
460 }
461
462 out:
463 return ret;
464 }
465
466 static int process_mksock(const char *path, void *user)
467 {
468 int ret;
469 struct btrfs_receive *r = user;
470 char full_path[PATH_MAX];
471
472 ret = path_cat_out(full_path, r->full_subvol_path, path);
473 if (ret < 0) {
474 error("mksock: path invalid: %s", path);
475 goto out;
476 }
477
478 if (g_verbose >= 2)
479 fprintf(stderr, "mksock %s\n", path);
480
481 ret = mknod(full_path, 0600 | S_IFSOCK, 0);
482 if (ret < 0) {
483 ret = -errno;
484 error("mknod %s failed: %s", path, strerror(-ret));
485 }
486
487 out:
488 return ret;
489 }
490
491 static int process_symlink(const char *path, const char *lnk, void *user)
492 {
493 int ret;
494 struct btrfs_receive *r = user;
495 char full_path[PATH_MAX];
496
497 ret = path_cat_out(full_path, r->full_subvol_path, path);
498 if (ret < 0) {
499 error("symlink: path invalid: %s", path);
500 goto out;
501 }
502
503 if (g_verbose >= 2)
504 fprintf(stderr, "symlink %s -> %s\n", path, lnk);
505
506 ret = symlink(lnk, full_path);
507 if (ret < 0) {
508 ret = -errno;
509 error("symlink %s -> %s failed: %s", path,
510 lnk, strerror(-ret));
511 }
512
513 out:
514 return ret;
515 }
516
517 static int process_rename(const char *from, const char *to, void *user)
518 {
519 int ret;
520 struct btrfs_receive *r = user;
521 char full_from[PATH_MAX];
522 char full_to[PATH_MAX];
523
524 ret = path_cat_out(full_from, r->full_subvol_path, from);
525 if (ret < 0) {
526 error("rename: source path invalid: %s", from);
527 goto out;
528 }
529
530 ret = path_cat_out(full_to, r->full_subvol_path, to);
531 if (ret < 0) {
532 error("rename: target path invalid: %s", to);
533 goto out;
534 }
535
536 if (g_verbose >= 2)
537 fprintf(stderr, "rename %s -> %s\n", from, to);
538
539 ret = rename(full_from, full_to);
540 if (ret < 0) {
541 ret = -errno;
542 error("rename %s -> %s failed: %s", from,
543 to, strerror(-ret));
544 }
545
546 out:
547 return ret;
548 }
549
550 static int process_link(const char *path, const char *lnk, void *user)
551 {
552 int ret;
553 struct btrfs_receive *r = user;
554 char full_path[PATH_MAX];
555 char full_link_path[PATH_MAX];
556
557 ret = path_cat_out(full_path, r->full_subvol_path, path);
558 if (ret < 0) {
559 error("link: source path invalid: %s", full_path);
560 goto out;
561 }
562
563 ret = path_cat_out(full_link_path, r->full_subvol_path, lnk);
564 if (ret < 0) {
565 error("link: target path invalid: %s", full_link_path);
566 goto out;
567 }
568
569 if (g_verbose >= 2)
570 fprintf(stderr, "link %s -> %s\n", path, lnk);
571
572 ret = link(full_link_path, full_path);
573 if (ret < 0) {
574 ret = -errno;
575 error("link %s -> %s failed: %s", path, lnk, strerror(-ret));
576 }
577
578 out:
579 return ret;
580 }
581
582
583 static int process_unlink(const char *path, void *user)
584 {
585 int ret;
586 struct btrfs_receive *r = user;
587 char full_path[PATH_MAX];
588
589 ret = path_cat_out(full_path, r->full_subvol_path, path);
590 if (ret < 0) {
591 error("unlink: path invalid: %s", path);
592 goto out;
593 }
594
595 if (g_verbose >= 2)
596 fprintf(stderr, "unlink %s\n", path);
597
598 ret = unlink(full_path);
599 if (ret < 0) {
600 ret = -errno;
601 error("unlink %s failed. %s", path, strerror(-ret));
602 }
603
604 out:
605 return ret;
606 }
607
608 static int process_rmdir(const char *path, void *user)
609 {
610 int ret;
611 struct btrfs_receive *r = user;
612 char full_path[PATH_MAX];
613
614 ret = path_cat_out(full_path, r->full_subvol_path, path);
615 if (ret < 0) {
616 error("rmdir: path invalid: %s", path);
617 goto out;
618 }
619
620 if (g_verbose >= 2)
621 fprintf(stderr, "rmdir %s\n", path);
622
623 ret = rmdir(full_path);
624 if (ret < 0) {
625 ret = -errno;
626 error("rmdir %s failed: %s", path, strerror(-ret));
627 }
628
629 out:
630 return ret;
631 }
632
633 static int open_inode_for_write(struct btrfs_receive *r, const char *path)
634 {
635 int ret = 0;
636
637 if (r->write_fd != -1) {
638 if (strcmp(r->write_path, path) == 0)
639 goto out;
640 close(r->write_fd);
641 r->write_fd = -1;
642 }
643
644 r->write_fd = open(path, O_RDWR);
645 if (r->write_fd < 0) {
646 ret = -errno;
647 error("cannont open %s: %s", path, strerror(-ret));
648 goto out;
649 }
650 strncpy_null(r->write_path, path);
651
652 out:
653 return ret;
654 }
655
656 static void close_inode_for_write(struct btrfs_receive *r)
657 {
658 if(r->write_fd == -1)
659 return;
660
661 close(r->write_fd);
662 r->write_fd = -1;
663 r->write_path[0] = 0;
664 }
665
666 static int process_write(const char *path, const void *data, u64 offset,
667 u64 len, void *user)
668 {
669 int ret = 0;
670 struct btrfs_receive *r = user;
671 char full_path[PATH_MAX];
672 u64 pos = 0;
673 int w;
674
675 ret = path_cat_out(full_path, r->full_subvol_path, path);
676 if (ret < 0) {
677 error("write: path invalid: %s", path);
678 goto out;
679 }
680
681 ret = open_inode_for_write(r, full_path);
682 if (ret < 0)
683 goto out;
684
685 while (pos < len) {
686 w = pwrite(r->write_fd, (char*)data + pos, len - pos,
687 offset + pos);
688 if (w < 0) {
689 ret = -errno;
690 error("writing to %s failed: %s\n",
691 path, strerror(-ret));
692 goto out;
693 }
694 pos += w;
695 }
696
697 out:
698 return ret;
699 }
700
701 static int process_clone(const char *path, u64 offset, u64 len,
702 const u8 *clone_uuid, u64 clone_ctransid,
703 const char *clone_path, u64 clone_offset,
704 void *user)
705 {
706 int ret;
707 struct btrfs_receive *r = user;
708 struct btrfs_ioctl_clone_range_args clone_args;
709 struct subvol_info *si = NULL;
710 char full_path[PATH_MAX];
711 char *subvol_path = NULL;
712 char full_clone_path[PATH_MAX];
713 int clone_fd = -1;
714
715 ret = path_cat_out(full_path, r->full_subvol_path, path);
716 if (ret < 0) {
717 error("clone: source path invalid: %s", path);
718 goto out;
719 }
720
721 ret = open_inode_for_write(r, full_path);
722 if (ret < 0)
723 goto out;
724
725 si = subvol_uuid_search(&r->sus, 0, clone_uuid, clone_ctransid, NULL,
726 subvol_search_by_received_uuid);
727 if (!si) {
728 if (memcmp(clone_uuid, r->cur_subvol.received_uuid,
729 BTRFS_UUID_SIZE) == 0) {
730 /* TODO check generation of extent */
731 subvol_path = strdup(r->cur_subvol_path);
732 } else {
733 ret = -ENOENT;
734 error("clone: did not find source subvol");
735 goto out;
736 }
737 } else {
738 /*if (rs_args.ctransid > rs_args.rtransid) {
739 if (!r->force) {
740 ret = -EINVAL;
741 fprintf(stderr, "ERROR: subvolume %s was "
742 "modified after it was "
743 "received.\n",
744 r->subvol_parent_name);
745 goto out;
746 } else {
747 fprintf(stderr, "WARNING: subvolume %s was "
748 "modified after it was "
749 "received.\n",
750 r->subvol_parent_name);
751 }
752 }*/
753 subvol_path = strdup(si->path);
754 }
755
756 ret = path_cat_out(full_clone_path, subvol_path, clone_path);
757 if (ret < 0) {
758 error("clone: target path invalid: %s", clone_path);
759 goto out;
760 }
761
762 clone_fd = openat(r->mnt_fd, full_clone_path, O_RDONLY | O_NOATIME);
763 if (clone_fd < 0) {
764 ret = -errno;
765 error("cannot open %s: %s", full_clone_path, strerror(-ret));
766 goto out;
767 }
768
769 clone_args.src_fd = clone_fd;
770 clone_args.src_offset = clone_offset;
771 clone_args.src_length = len;
772 clone_args.dest_offset = offset;
773 ret = ioctl(r->write_fd, BTRFS_IOC_CLONE_RANGE, &clone_args);
774 if (ret < 0) {
775 ret = -errno;
776 error("failed to clone extents to %s\n%s\n",
777 path, strerror(-ret));
778 goto out;
779 }
780
781 out:
782 if (si) {
783 free(si->path);
784 free(si);
785 }
786 free(subvol_path);
787 if (clone_fd != -1)
788 close(clone_fd);
789 return ret;
790 }
791
792
793 static int process_set_xattr(const char *path, const char *name,
794 const void *data, int len, void *user)
795 {
796 int ret = 0;
797 struct btrfs_receive *r = user;
798 char full_path[PATH_MAX];
799
800 ret = path_cat_out(full_path, r->full_subvol_path, path);
801 if (ret < 0) {
802 error("set_xattr: path invalid: %s", path);
803 goto out;
804 }
805
806 if (strcmp("security.capability", name) == 0) {
807 if (g_verbose >= 3)
808 fprintf(stderr, "set_xattr: cache capabilities\n");
809 if (r->cached_capabilities_len)
810 warning("capabilities set multiple times per file: %s",
811 full_path);
812 if (len > sizeof(r->cached_capabilities)) {
813 error("capabilities encoded to %d bytes, buffer too small",
814 len);
815 ret = -E2BIG;
816 goto out;
817 }
818 r->cached_capabilities_len = len;
819 memcpy(r->cached_capabilities, data, len);
820 }
821
822 if (g_verbose >= 2) {
823 fprintf(stderr, "set_xattr %s - name=%s data_len=%d "
824 "data=%.*s\n", path, name, len,
825 len, (char*)data);
826 }
827
828 ret = lsetxattr(full_path, name, data, len, 0);
829 if (ret < 0) {
830 ret = -errno;
831 error("lsetxattr %s %s=%.*s failed: %s",
832 path, name, len, (char*)data, strerror(-ret));
833 goto out;
834 }
835
836 out:
837 return ret;
838 }
839
840 static int process_remove_xattr(const char *path, const char *name, void *user)
841 {
842 int ret = 0;
843 struct btrfs_receive *r = user;
844 char full_path[PATH_MAX];
845
846 ret = path_cat_out(full_path, r->full_subvol_path, path);
847 if (ret < 0) {
848 error("remove_xattr: path invalid: %s", path);
849 goto out;
850 }
851
852 if (g_verbose >= 2) {
853 fprintf(stderr, "remove_xattr %s - name=%s\n",
854 path, name);
855 }
856
857 ret = lremovexattr(full_path, name);
858 if (ret < 0) {
859 ret = -errno;
860 error("lremovexattr %s %s failed: %s",
861 path, name, strerror(-ret));
862 goto out;
863 }
864
865 out:
866 return ret;
867 }
868
869 static int process_truncate(const char *path, u64 size, void *user)
870 {
871 int ret = 0;
872 struct btrfs_receive *r = user;
873 char full_path[PATH_MAX];
874
875 ret = path_cat_out(full_path, r->full_subvol_path, path);
876 if (ret < 0) {
877 error("truncate: path invalid: %s", path);
878 goto out;
879 }
880
881 if (g_verbose >= 2)
882 fprintf(stderr, "truncate %s size=%llu\n", path, size);
883
884 ret = truncate(full_path, size);
885 if (ret < 0) {
886 ret = -errno;
887 error("truncate %s failed: %s", path, strerror(-ret));
888 goto out;
889 }
890
891 out:
892 return ret;
893 }
894
895 static int process_chmod(const char *path, u64 mode, void *user)
896 {
897 int ret = 0;
898 struct btrfs_receive *r = user;
899 char full_path[PATH_MAX];
900
901 ret = path_cat_out(full_path, r->full_subvol_path, path);
902 if (ret < 0) {
903 error("chmod: path invalid: %s", path);
904 goto out;
905 }
906
907 if (g_verbose >= 2)
908 fprintf(stderr, "chmod %s - mode=0%o\n", path, (int)mode);
909
910 ret = chmod(full_path, mode);
911 if (ret < 0) {
912 ret = -errno;
913 error("chmod %s failed: %s", path, strerror(-ret));
914 goto out;
915 }
916
917 out:
918 return ret;
919 }
920
921 static int process_chown(const char *path, u64 uid, u64 gid, void *user)
922 {
923 int ret = 0;
924 struct btrfs_receive *r = user;
925 char full_path[PATH_MAX];
926
927 ret = path_cat_out(full_path, r->full_subvol_path, path);
928 if (ret < 0) {
929 error("chown: path invalid: %s", path);
930 goto out;
931 }
932
933 if (g_verbose >= 2)
934 fprintf(stderr, "chown %s - uid=%llu, gid=%llu\n", path,
935 uid, gid);
936
937 ret = lchown(full_path, uid, gid);
938 if (ret < 0) {
939 ret = -errno;
940 error("chown %s failed: %s", path, strerror(-ret));
941 goto out;
942 }
943
944 if (r->cached_capabilities_len) {
945 if (g_verbose >= 2)
946 fprintf(stderr, "chown: restore capabilities\n");
947 ret = lsetxattr(full_path, "security.capability",
948 r->cached_capabilities,
949 r->cached_capabilities_len, 0);
950 memset(r->cached_capabilities, 0,
951 sizeof(r->cached_capabilities));
952 r->cached_capabilities_len = 0;
953 if (ret < 0) {
954 ret = -errno;
955 error("restoring capabilities %s: %s",
956 path, strerror(-ret));
957 goto out;
958 }
959 }
960
961 out:
962 return ret;
963 }
964
965 static int process_utimes(const char *path, struct timespec *at,
966 struct timespec *mt, struct timespec *ct,
967 void *user)
968 {
969 int ret = 0;
970 struct btrfs_receive *r = user;
971 char full_path[PATH_MAX];
972 struct timespec tv[2];
973
974 ret = path_cat_out(full_path, r->full_subvol_path, path);
975 if (ret < 0) {
976 error("utimes: path invalid: %s", path);
977 goto out;
978 }
979
980 if (g_verbose >= 2)
981 fprintf(stderr, "utimes %s\n", path);
982
983 tv[0] = *at;
984 tv[1] = *mt;
985 ret = utimensat(AT_FDCWD, full_path, tv, AT_SYMLINK_NOFOLLOW);
986 if (ret < 0) {
987 ret = -errno;
988 error("utimes %s failed: %s",
989 path, strerror(-ret));
990 goto out;
991 }
992
993 out:
994 return ret;
995 }
996
997 static int process_update_extent(const char *path, u64 offset, u64 len,
998 void *user)
999 {
1000 if (g_verbose >= 2)
1001 fprintf(stderr, "update_extent %s: offset=%llu, len=%llu\n",
1002 path, (unsigned long long)offset,
1003 (unsigned long long)len);
1004
1005 /*
1006 * Sent with BTRFS_SEND_FLAG_NO_FILE_DATA, nothing to do.
1007 */
1008
1009 return 0;
1010 }
1011
1012 static struct btrfs_send_ops send_ops = {
1013 .subvol = process_subvol,
1014 .snapshot = process_snapshot,
1015 .mkfile = process_mkfile,
1016 .mkdir = process_mkdir,
1017 .mknod = process_mknod,
1018 .mkfifo = process_mkfifo,
1019 .mksock = process_mksock,
1020 .symlink = process_symlink,
1021 .rename = process_rename,
1022 .link = process_link,
1023 .unlink = process_unlink,
1024 .rmdir = process_rmdir,
1025 .write = process_write,
1026 .clone = process_clone,
1027 .set_xattr = process_set_xattr,
1028 .remove_xattr = process_remove_xattr,
1029 .truncate = process_truncate,
1030 .chmod = process_chmod,
1031 .chown = process_chown,
1032 .utimes = process_utimes,
1033 .update_extent = process_update_extent,
1034 };
1035
1036 static int do_receive(struct btrfs_receive *r, const char *tomnt,
1037 char *realmnt, int r_fd, u64 max_errors)
1038 {
1039 u64 subvol_id;
1040 int ret;
1041 char *dest_dir_full_path;
1042 char root_subvol_path[PATH_MAX];
1043 int end = 0;
1044
1045 dest_dir_full_path = realpath(tomnt, NULL);
1046 if (!dest_dir_full_path) {
1047 ret = -errno;
1048 error("realpath(%s) failed: %s", tomnt, strerror(-ret));
1049 goto out;
1050 }
1051 r->dest_dir_fd = open(dest_dir_full_path, O_RDONLY | O_NOATIME);
1052 if (r->dest_dir_fd < 0) {
1053 ret = -errno;
1054 error("cannot open destination directory %s: %s",
1055 dest_dir_full_path, strerror(-ret));
1056 goto out;
1057 }
1058
1059 if (realmnt[0]) {
1060 r->root_path = realmnt;
1061 } else {
1062 ret = find_mount_root(dest_dir_full_path, &r->root_path);
1063 if (ret < 0) {
1064 error("failed to determine mount point for %s: %s",
1065 dest_dir_full_path, strerror(-ret));
1066 ret = -EINVAL;
1067 goto out;
1068 }
1069 if (ret > 0) {
1070 error("%s doesn't belong to btrfs mount point",
1071 dest_dir_full_path);
1072 ret = -EINVAL;
1073 goto out;
1074 }
1075 }
1076 r->mnt_fd = open(r->root_path, O_RDONLY | O_NOATIME);
1077 if (r->mnt_fd < 0) {
1078 ret = -errno;
1079 error("cannot open %s: %s", r->root_path, strerror(-ret));
1080 goto out;
1081 }
1082
1083 /*
1084 * If we use -m or a default subvol we want to resolve the path to the
1085 * subvolume we're sitting in so that we can adjust the paths of any
1086 * subvols we want to receive in.
1087 */
1088 ret = btrfs_list_get_path_rootid(r->mnt_fd, &subvol_id);
1089 if (ret) {
1090 error("cannot resolve our subvolid: %d",
1091 ret);
1092 goto out;
1093 }
1094
1095 root_subvol_path[0] = 0;
1096 ret = btrfs_subvolid_resolve(r->mnt_fd, root_subvol_path,
1097 PATH_MAX, subvol_id);
1098 if (ret) {
1099 error("cannot resolve our subvol path");
1100 goto out;
1101 }
1102
1103 /*
1104 * Ok we're inside of a subvol off of the root subvol, we need to
1105 * actually set full_root_path.
1106 */
1107 if (*root_subvol_path)
1108 r->full_root_path = root_subvol_path;
1109
1110 if (r->dest_dir_chroot) {
1111 if (chroot(dest_dir_full_path)) {
1112 ret = -errno;
1113 error("failed to chroot to %s: %s",
1114 dest_dir_full_path, strerror(-ret));
1115 goto out;
1116 }
1117 if (chdir("/")) {
1118 ret = -errno;
1119 error("failed to chdir to / after chroot: %s",
1120 strerror(-ret));
1121 goto out;
1122 }
1123 fprintf(stderr, "Chroot to %s\n", dest_dir_full_path);
1124 r->root_path = strdup("/");
1125 r->dest_dir_path = r->root_path;
1126 } else {
1127 /*
1128 * find_mount_root returns a root_path that is a subpath of
1129 * dest_dir_full_path. Now get the other part of root_path,
1130 * which is the destination dir relative to root_path.
1131 */
1132 r->dest_dir_path = dest_dir_full_path + strlen(r->root_path);
1133 while (r->dest_dir_path[0] == '/')
1134 r->dest_dir_path++;
1135 }
1136
1137 ret = subvol_uuid_search_init(r->mnt_fd, &r->sus);
1138 if (ret < 0)
1139 goto out;
1140
1141 while (!end) {
1142 if (r->cached_capabilities_len) {
1143 if (g_verbose >= 3)
1144 fprintf(stderr, "clear cached capabilities\n");
1145 memset(r->cached_capabilities, 0,
1146 sizeof(r->cached_capabilities));
1147 r->cached_capabilities_len = 0;
1148 }
1149
1150 ret = btrfs_read_and_process_send_stream(r_fd, &send_ops, r,
1151 r->honor_end_cmd,
1152 max_errors);
1153 if (ret < 0)
1154 goto out;
1155 if (ret)
1156 end = 1;
1157
1158 close_inode_for_write(r);
1159 ret = finish_subvol(r);
1160 if (ret < 0)
1161 goto out;
1162 }
1163 ret = 0;
1164
1165 out:
1166 if (r->write_fd != -1) {
1167 close(r->write_fd);
1168 r->write_fd = -1;
1169 }
1170
1171 if (r->root_path != realmnt)
1172 free(r->root_path);
1173 r->root_path = NULL;
1174 r->dest_dir_path = NULL;
1175 free(dest_dir_full_path);
1176 subvol_uuid_search_finit(&r->sus);
1177 if (r->mnt_fd != -1) {
1178 close(r->mnt_fd);
1179 r->mnt_fd = -1;
1180 }
1181 if (r->dest_dir_fd != -1) {
1182 close(r->dest_dir_fd);
1183 r->dest_dir_fd = -1;
1184 }
1185
1186 return ret;
1187 }
1188
1189 int cmd_receive(int argc, char **argv)
1190 {
1191 char *tomnt = NULL;
1192 char fromfile[PATH_MAX];
1193 char realmnt[PATH_MAX];
1194 struct btrfs_receive r;
1195 int receive_fd = fileno(stdin);
1196 u64 max_errors = 1;
1197 int ret = 0;
1198
1199 memset(&r, 0, sizeof(r));
1200 r.mnt_fd = -1;
1201 r.write_fd = -1;
1202 r.dest_dir_fd = -1;
1203 r.dest_dir_chroot = 0;
1204 realmnt[0] = 0;
1205 fromfile[0] = 0;
1206
1207 while (1) {
1208 int c;
1209 static const struct option long_opts[] = {
1210 { "max-errors", required_argument, NULL, 'E' },
1211 { "chroot", no_argument, NULL, 'C' },
1212 { NULL, 0, NULL, 0 }
1213 };
1214
1215 c = getopt_long(argc, argv, "Cevf:m:", long_opts, NULL);
1216 if (c < 0)
1217 break;
1218
1219 switch (c) {
1220 case 'v':
1221 g_verbose++;
1222 break;
1223 case 'f':
1224 if (arg_copy_path(fromfile, optarg, sizeof(fromfile))) {
1225 error("input file path too long (%zu)",
1226 strlen(optarg));
1227 ret = 1;
1228 goto out;
1229 }
1230 break;
1231 case 'e':
1232 r.honor_end_cmd = 1;
1233 break;
1234 case 'C':
1235 r.dest_dir_chroot = 1;
1236 break;
1237 case 'E':
1238 max_errors = arg_strtou64(optarg);
1239 break;
1240 case 'm':
1241 if (arg_copy_path(realmnt, optarg, sizeof(realmnt))) {
1242 error("mount point path too long (%zu)",
1243 strlen(optarg));
1244 ret = 1;
1245 goto out;
1246 }
1247 break;
1248 case '?':
1249 default:
1250 error("receive args invalid");
1251 return 1;
1252 }
1253 }
1254
1255 if (check_argc_exact(argc - optind, 1))
1256 usage(cmd_receive_usage);
1257
1258 tomnt = argv[optind];
1259
1260 if (fromfile[0]) {
1261 receive_fd = open(fromfile, O_RDONLY | O_NOATIME);
1262 if (receive_fd < 0) {
1263 error("cannot open %s: %s", fromfile, strerror(errno));
1264 goto out;
1265 }
1266 }
1267
1268 ret = do_receive(&r, tomnt, realmnt, receive_fd, max_errors);
1269 if (receive_fd != fileno(stdin))
1270 close(receive_fd);
1271
1272 out:
1273
1274 return !!ret;
1275 }
1276
1277 const char * const cmd_receive_usage[] = {
1278 "btrfs receive [-ve] [-f <infile>] [--max-errors <N>] <mount>",
1279 "Receive subvolumes from stdin.",
1280 "Receives one or more subvolumes that were previously",
1281 "sent with btrfs send. The received subvolumes are stored",
1282 "into <mount>.",
1283 "btrfs receive will fail in case a receiving subvolume",
1284 "already exists. It will also fail in case a previously",
1285 "received subvolume was changed after it was received.",
1286 "After receiving a subvolume, it is immediately set to",
1287 "read only.\n",
1288 "-v Enable verbose debug output. Each",
1289 " occurrence of this option increases the",
1290 " verbose level more.",
1291 "-f <infile> By default, btrfs receive uses stdin",
1292 " to receive the subvolumes. Use this",
1293 " option to specify a file to use instead.",
1294 "-e Terminate after receiving an <end cmd>",
1295 " in the data stream. Without this option,",
1296 " the receiver terminates only if an error",
1297 " is recognized or on EOF.",
1298 "-C|--chroot confine the process to <mount> using chroot",
1299 "--max-errors <N> Terminate as soon as N errors happened while",
1300 " processing commands from the send stream.",
1301 " Default value is 1. A value of 0 means no limit.",
1302 "-m <mountpoint> The root mount point of the destination fs.",
1303 " If you do not have /proc use this to tell us where ",
1304 " this file system is mounted.",
1305 NULL
1306 };
(deprecated) Btrfs progs developments and patch integration