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