1
2
3
4
5
6#include <linux/bsearch.h>
7#include <linux/fs.h>
8#include <linux/file.h>
9#include <linux/sort.h>
10#include <linux/mount.h>
11#include <linux/xattr.h>
12#include <linux/posix_acl_xattr.h>
13#include <linux/radix-tree.h>
14#include <linux/vmalloc.h>
15#include <linux/string.h>
16#include <linux/compat.h>
17#include <linux/crc32c.h>
18
19#include "send.h"
20#include "backref.h"
21#include "locking.h"
22#include "disk-io.h"
23#include "btrfs_inode.h"
24#include "transaction.h"
25#include "compression.h"
26
27
28
29
30
31
32
33
34struct fs_path {
35 union {
36 struct {
37 char *start;
38 char *end;
39
40 char *buf;
41 unsigned short buf_len:15;
42 unsigned short reversed:1;
43 char inline_buf[];
44 };
45
46
47
48
49
50 char pad[256];
51 };
52};
53#define FS_PATH_INLINE_SIZE \
54 (sizeof(struct fs_path) - offsetof(struct fs_path, inline_buf))
55
56
57
58struct clone_root {
59 struct btrfs_root *root;
60 u64 ino;
61 u64 offset;
62
63 u64 found_refs;
64};
65
66#define SEND_CTX_MAX_NAME_CACHE_SIZE 128
67#define SEND_CTX_NAME_CACHE_CLEAN_SIZE (SEND_CTX_MAX_NAME_CACHE_SIZE * 2)
68
69struct send_ctx {
70 struct file *send_filp;
71 loff_t send_off;
72 char *send_buf;
73 u32 send_size;
74 u32 send_max_size;
75 u64 total_send_size;
76 u64 cmd_send_size[BTRFS_SEND_C_MAX + 1];
77 u64 flags;
78
79 struct btrfs_root *send_root;
80 struct btrfs_root *parent_root;
81 struct clone_root *clone_roots;
82 int clone_roots_cnt;
83
84
85 struct btrfs_path *left_path;
86 struct btrfs_path *right_path;
87 struct btrfs_key *cmp_key;
88
89
90
91
92
93 u64 cur_ino;
94 u64 cur_inode_gen;
95 int cur_inode_new;
96 int cur_inode_new_gen;
97 int cur_inode_deleted;
98 u64 cur_inode_size;
99 u64 cur_inode_mode;
100 u64 cur_inode_rdev;
101 u64 cur_inode_last_extent;
102 u64 cur_inode_next_write_offset;
103
104 u64 send_progress;
105
106 struct list_head new_refs;
107 struct list_head deleted_refs;
108
109 struct radix_tree_root name_cache;
110 struct list_head name_cache_list;
111 int name_cache_size;
112
113 struct file_ra_state ra;
114
115 char *read_buf;
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162 struct rb_root pending_dir_moves;
163
164
165
166
167
168
169 struct rb_root waiting_dir_moves;
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210 struct rb_root orphan_dirs;
211};
212
213struct pending_dir_move {
214 struct rb_node node;
215 struct list_head list;
216 u64 parent_ino;
217 u64 ino;
218 u64 gen;
219 struct list_head update_refs;
220};
221
222struct waiting_dir_move {
223 struct rb_node node;
224 u64 ino;
225
226
227
228
229
230 u64 rmdir_ino;
231 bool orphanized;
232};
233
234struct orphan_dir_info {
235 struct rb_node node;
236 u64 ino;
237 u64 gen;
238};
239
240struct name_cache_entry {
241 struct list_head list;
242
243
244
245
246
247
248
249
250 struct list_head radix_list;
251 u64 ino;
252 u64 gen;
253 u64 parent_ino;
254 u64 parent_gen;
255 int ret;
256 int need_later_update;
257 int name_len;
258 char name[];
259};
260
261__cold
262static void inconsistent_snapshot_error(struct send_ctx *sctx,
263 enum btrfs_compare_tree_result result,
264 const char *what)
265{
266 const char *result_string;
267
268 switch (result) {
269 case BTRFS_COMPARE_TREE_NEW:
270 result_string = "new";
271 break;
272 case BTRFS_COMPARE_TREE_DELETED:
273 result_string = "deleted";
274 break;
275 case BTRFS_COMPARE_TREE_CHANGED:
276 result_string = "updated";
277 break;
278 case BTRFS_COMPARE_TREE_SAME:
279 ASSERT(0);
280 result_string = "unchanged";
281 break;
282 default:
283 ASSERT(0);
284 result_string = "unexpected";
285 }
286
287 btrfs_err(sctx->send_root->fs_info,
288 "Send: inconsistent snapshot, found %s %s for inode %llu without updated inode item, send root is %llu, parent root is %llu",
289 result_string, what, sctx->cmp_key->objectid,
290 sctx->send_root->root_key.objectid,
291 (sctx->parent_root ?
292 sctx->parent_root->root_key.objectid : 0));
293}
294
295static int is_waiting_for_move(struct send_ctx *sctx, u64 ino);
296
297static struct waiting_dir_move *
298get_waiting_dir_move(struct send_ctx *sctx, u64 ino);
299
300static int is_waiting_for_rm(struct send_ctx *sctx, u64 dir_ino);
301
302static int need_send_hole(struct send_ctx *sctx)
303{
304 return (sctx->parent_root && !sctx->cur_inode_new &&
305 !sctx->cur_inode_new_gen && !sctx->cur_inode_deleted &&
306 S_ISREG(sctx->cur_inode_mode));
307}
308
309static void fs_path_reset(struct fs_path *p)
310{
311 if (p->reversed) {
312 p->start = p->buf + p->buf_len - 1;
313 p->end = p->start;
314 *p->start = 0;
315 } else {
316 p->start = p->buf;
317 p->end = p->start;
318 *p->start = 0;
319 }
320}
321
322static struct fs_path *fs_path_alloc(void)
323{
324 struct fs_path *p;
325
326 p = kmalloc(sizeof(*p), GFP_KERNEL);
327 if (!p)
328 return NULL;
329 p->reversed = 0;
330 p->buf = p->inline_buf;
331 p->buf_len = FS_PATH_INLINE_SIZE;
332 fs_path_reset(p);
333 return p;
334}
335
336static struct fs_path *fs_path_alloc_reversed(void)
337{
338 struct fs_path *p;
339
340 p = fs_path_alloc();
341 if (!p)
342 return NULL;
343 p->reversed = 1;
344 fs_path_reset(p);
345 return p;
346}
347
348static void fs_path_free(struct fs_path *p)
349{
350 if (!p)
351 return;
352 if (p->buf != p->inline_buf)
353 kfree(p->buf);
354 kfree(p);
355}
356
357static int fs_path_len(struct fs_path *p)
358{
359 return p->end - p->start;
360}
361
362static int fs_path_ensure_buf(struct fs_path *p, int len)
363{
364 char *tmp_buf;
365 int path_len;
366 int old_buf_len;
367
368 len++;
369
370 if (p->buf_len >= len)
371 return 0;
372
373 if (len > PATH_MAX) {
374 WARN_ON(1);
375 return -ENOMEM;
376 }
377
378 path_len = p->end - p->start;
379 old_buf_len = p->buf_len;
380
381
382
383
384 if (p->buf == p->inline_buf) {
385 tmp_buf = kmalloc(len, GFP_KERNEL);
386 if (tmp_buf)
387 memcpy(tmp_buf, p->buf, old_buf_len);
388 } else {
389 tmp_buf = krealloc(p->buf, len, GFP_KERNEL);
390 }
391 if (!tmp_buf)
392 return -ENOMEM;
393 p->buf = tmp_buf;
394
395
396
397
398 p->buf_len = ksize(p->buf);
399
400 if (p->reversed) {
401 tmp_buf = p->buf + old_buf_len - path_len - 1;
402 p->end = p->buf + p->buf_len - 1;
403 p->start = p->end - path_len;
404 memmove(p->start, tmp_buf, path_len + 1);
405 } else {
406 p->start = p->buf;
407 p->end = p->start + path_len;
408 }
409 return 0;
410}
411
412static int fs_path_prepare_for_add(struct fs_path *p, int name_len,
413 char **prepared)
414{
415 int ret;
416 int new_len;
417
418 new_len = p->end - p->start + name_len;
419 if (p->start != p->end)
420 new_len++;
421 ret = fs_path_ensure_buf(p, new_len);
422 if (ret < 0)
423 goto out;
424
425 if (p->reversed) {
426 if (p->start != p->end)
427 *--p->start = '/';
428 p->start -= name_len;
429 *prepared = p->start;
430 } else {
431 if (p->start != p->end)
432 *p->end++ = '/';
433 *prepared = p->end;
434 p->end += name_len;
435 *p->end = 0;
436 }
437
438out:
439 return ret;
440}
441
442static int fs_path_add(struct fs_path *p, const char *name, int name_len)
443{
444 int ret;
445 char *prepared;
446
447 ret = fs_path_prepare_for_add(p, name_len, &prepared);
448 if (ret < 0)
449 goto out;
450 memcpy(prepared, name, name_len);
451
452out:
453 return ret;
454}
455
456static int fs_path_add_path(struct fs_path *p, struct fs_path *p2)
457{
458 int ret;
459 char *prepared;
460
461 ret = fs_path_prepare_for_add(p, p2->end - p2->start, &prepared);
462 if (ret < 0)
463 goto out;
464 memcpy(prepared, p2->start, p2->end - p2->start);
465
466out:
467 return ret;
468}
469
470static int fs_path_add_from_extent_buffer(struct fs_path *p,
471 struct extent_buffer *eb,
472 unsigned long off, int len)
473{
474 int ret;
475 char *prepared;
476
477 ret = fs_path_prepare_for_add(p, len, &prepared);
478 if (ret < 0)
479 goto out;
480
481 read_extent_buffer(eb, prepared, off, len);
482
483out:
484 return ret;
485}
486
487static int fs_path_copy(struct fs_path *p, struct fs_path *from)
488{
489 int ret;
490
491 p->reversed = from->reversed;
492 fs_path_reset(p);
493
494 ret = fs_path_add_path(p, from);
495
496 return ret;
497}
498
499
500static void fs_path_unreverse(struct fs_path *p)
501{
502 char *tmp;
503 int len;
504
505 if (!p->reversed)
506 return;
507
508 tmp = p->start;
509 len = p->end - p->start;
510 p->start = p->buf;
511 p->end = p->start + len;
512 memmove(p->start, tmp, len + 1);
513 p->reversed = 0;
514}
515
516static struct btrfs_path *alloc_path_for_send(void)
517{
518 struct btrfs_path *path;
519
520 path = btrfs_alloc_path();
521 if (!path)
522 return NULL;
523 path->search_commit_root = 1;
524 path->skip_locking = 1;
525 path->need_commit_sem = 1;
526 return path;
527}
528
529static int write_buf(struct file *filp, const void *buf, u32 len, loff_t *off)
530{
531 int ret;
532 u32 pos = 0;
533
534 while (pos < len) {
535 ret = kernel_write(filp, buf + pos, len - pos, off);
536
537
538
539
540 if (ret < 0)
541 return ret;
542 if (ret == 0) {
543 return -EIO;
544 }
545 pos += ret;
546 }
547
548 return 0;
549}
550
551static int tlv_put(struct send_ctx *sctx, u16 attr, const void *data, int len)
552{
553 struct btrfs_tlv_header *hdr;
554 int total_len = sizeof(*hdr) + len;
555 int left = sctx->send_max_size - sctx->send_size;
556
557 if (unlikely(left < total_len))
558 return -EOVERFLOW;
559
560 hdr = (struct btrfs_tlv_header *) (sctx->send_buf + sctx->send_size);
561 hdr->tlv_type = cpu_to_le16(attr);
562 hdr->tlv_len = cpu_to_le16(len);
563 memcpy(hdr + 1, data, len);
564 sctx->send_size += total_len;
565
566 return 0;
567}
568
569#define TLV_PUT_DEFINE_INT(bits) \
570 static int tlv_put_u##bits(struct send_ctx *sctx, \
571 u##bits attr, u##bits value) \
572 { \
573 __le##bits __tmp = cpu_to_le##bits(value); \
574 return tlv_put(sctx, attr, &__tmp, sizeof(__tmp)); \
575 }
576
577TLV_PUT_DEFINE_INT(64)
578
579static int tlv_put_string(struct send_ctx *sctx, u16 attr,
580 const char *str, int len)
581{
582 if (len == -1)
583 len = strlen(str);
584 return tlv_put(sctx, attr, str, len);
585}
586
587static int tlv_put_uuid(struct send_ctx *sctx, u16 attr,
588 const u8 *uuid)
589{
590 return tlv_put(sctx, attr, uuid, BTRFS_UUID_SIZE);
591}
592
593static int tlv_put_btrfs_timespec(struct send_ctx *sctx, u16 attr,
594 struct extent_buffer *eb,
595 struct btrfs_timespec *ts)
596{
597 struct btrfs_timespec bts;
598 read_extent_buffer(eb, &bts, (unsigned long)ts, sizeof(bts));
599 return tlv_put(sctx, attr, &bts, sizeof(bts));
600}
601
602
603#define TLV_PUT(sctx, attrtype, data, attrlen) \
604 do { \
605 ret = tlv_put(sctx, attrtype, data, attrlen); \
606 if (ret < 0) \
607 goto tlv_put_failure; \
608 } while (0)
609
610#define TLV_PUT_INT(sctx, attrtype, bits, value) \
611 do { \
612 ret = tlv_put_u##bits(sctx, attrtype, value); \
613 if (ret < 0) \
614 goto tlv_put_failure; \
615 } while (0)
616
617#define TLV_PUT_U8(sctx, attrtype, data) TLV_PUT_INT(sctx, attrtype, 8, data)
618#define TLV_PUT_U16(sctx, attrtype, data) TLV_PUT_INT(sctx, attrtype, 16, data)
619#define TLV_PUT_U32(sctx, attrtype, data) TLV_PUT_INT(sctx, attrtype, 32, data)
620#define TLV_PUT_U64(sctx, attrtype, data) TLV_PUT_INT(sctx, attrtype, 64, data)
621#define TLV_PUT_STRING(sctx, attrtype, str, len) \
622 do { \
623 ret = tlv_put_string(sctx, attrtype, str, len); \
624 if (ret < 0) \
625 goto tlv_put_failure; \
626 } while (0)
627#define TLV_PUT_PATH(sctx, attrtype, p) \
628 do { \
629 ret = tlv_put_string(sctx, attrtype, p->start, \
630 p->end - p->start); \
631 if (ret < 0) \
632 goto tlv_put_failure; \
633 } while(0)
634#define TLV_PUT_UUID(sctx, attrtype, uuid) \
635 do { \
636 ret = tlv_put_uuid(sctx, attrtype, uuid); \
637 if (ret < 0) \
638 goto tlv_put_failure; \
639 } while (0)
640#define TLV_PUT_BTRFS_TIMESPEC(sctx, attrtype, eb, ts) \
641 do { \
642 ret = tlv_put_btrfs_timespec(sctx, attrtype, eb, ts); \
643 if (ret < 0) \
644 goto tlv_put_failure; \
645 } while (0)
646
647static int send_header(struct send_ctx *sctx)
648{
649 struct btrfs_stream_header hdr;
650
651 strcpy(hdr.magic, BTRFS_SEND_STREAM_MAGIC);
652 hdr.version = cpu_to_le32(BTRFS_SEND_STREAM_VERSION);
653
654 return write_buf(sctx->send_filp, &hdr, sizeof(hdr),
655 &sctx->send_off);
656}
657
658
659
660
661static int begin_cmd(struct send_ctx *sctx, int cmd)
662{
663 struct btrfs_cmd_header *hdr;
664
665 if (WARN_ON(!sctx->send_buf))
666 return -EINVAL;
667
668 BUG_ON(sctx->send_size);
669
670 sctx->send_size += sizeof(*hdr);
671 hdr = (struct btrfs_cmd_header *)sctx->send_buf;
672 hdr->cmd = cpu_to_le16(cmd);
673
674 return 0;
675}
676
677static int send_cmd(struct send_ctx *sctx)
678{
679 int ret;
680 struct btrfs_cmd_header *hdr;
681 u32 crc;
682
683 hdr = (struct btrfs_cmd_header *)sctx->send_buf;
684 hdr->len = cpu_to_le32(sctx->send_size - sizeof(*hdr));
685 hdr->crc = 0;
686
687 crc = crc32c(0, (unsigned char *)sctx->send_buf, sctx->send_size);
688 hdr->crc = cpu_to_le32(crc);
689
690 ret = write_buf(sctx->send_filp, sctx->send_buf, sctx->send_size,
691 &sctx->send_off);
692
693 sctx->total_send_size += sctx->send_size;
694 sctx->cmd_send_size[le16_to_cpu(hdr->cmd)] += sctx->send_size;
695 sctx->send_size = 0;
696
697 return ret;
698}
699
700
701
702
703static int send_rename(struct send_ctx *sctx,
704 struct fs_path *from, struct fs_path *to)
705{
706 struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;
707 int ret;
708
709 btrfs_debug(fs_info, "send_rename %s -> %s", from->start, to->start);
710
711 ret = begin_cmd(sctx, BTRFS_SEND_C_RENAME);
712 if (ret < 0)
713 goto out;
714
715 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, from);
716 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH_TO, to);
717
718 ret = send_cmd(sctx);
719
720tlv_put_failure:
721out:
722 return ret;
723}
724
725
726
727
728static int send_link(struct send_ctx *sctx,
729 struct fs_path *path, struct fs_path *lnk)
730{
731 struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;
732 int ret;
733
734 btrfs_debug(fs_info, "send_link %s -> %s", path->start, lnk->start);
735
736 ret = begin_cmd(sctx, BTRFS_SEND_C_LINK);
737 if (ret < 0)
738 goto out;
739
740 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, path);
741 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH_LINK, lnk);
742
743 ret = send_cmd(sctx);
744
745tlv_put_failure:
746out:
747 return ret;
748}
749
750
751
752
753static int send_unlink(struct send_ctx *sctx, struct fs_path *path)
754{
755 struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;
756 int ret;
757
758 btrfs_debug(fs_info, "send_unlink %s", path->start);
759
760 ret = begin_cmd(sctx, BTRFS_SEND_C_UNLINK);
761 if (ret < 0)
762 goto out;
763
764 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, path);
765
766 ret = send_cmd(sctx);
767
768tlv_put_failure:
769out:
770 return ret;
771}
772
773
774
775
776static int send_rmdir(struct send_ctx *sctx, struct fs_path *path)
777{
778 struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;
779 int ret;
780
781 btrfs_debug(fs_info, "send_rmdir %s", path->start);
782
783 ret = begin_cmd(sctx, BTRFS_SEND_C_RMDIR);
784 if (ret < 0)
785 goto out;
786
787 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, path);
788
789 ret = send_cmd(sctx);
790
791tlv_put_failure:
792out:
793 return ret;
794}
795
796
797
798
799static int __get_inode_info(struct btrfs_root *root, struct btrfs_path *path,
800 u64 ino, u64 *size, u64 *gen, u64 *mode, u64 *uid,
801 u64 *gid, u64 *rdev)
802{
803 int ret;
804 struct btrfs_inode_item *ii;
805 struct btrfs_key key;
806
807 key.objectid = ino;
808 key.type = BTRFS_INODE_ITEM_KEY;
809 key.offset = 0;
810 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
811 if (ret) {
812 if (ret > 0)
813 ret = -ENOENT;
814 return ret;
815 }
816
817 ii = btrfs_item_ptr(path->nodes[0], path->slots[0],
818 struct btrfs_inode_item);
819 if (size)
820 *size = btrfs_inode_size(path->nodes[0], ii);
821 if (gen)
822 *gen = btrfs_inode_generation(path->nodes[0], ii);
823 if (mode)
824 *mode = btrfs_inode_mode(path->nodes[0], ii);
825 if (uid)
826 *uid = btrfs_inode_uid(path->nodes[0], ii);
827 if (gid)
828 *gid = btrfs_inode_gid(path->nodes[0], ii);
829 if (rdev)
830 *rdev = btrfs_inode_rdev(path->nodes[0], ii);
831
832 return ret;
833}
834
835static int get_inode_info(struct btrfs_root *root,
836 u64 ino, u64 *size, u64 *gen,
837 u64 *mode, u64 *uid, u64 *gid,
838 u64 *rdev)
839{
840 struct btrfs_path *path;
841 int ret;
842
843 path = alloc_path_for_send();
844 if (!path)
845 return -ENOMEM;
846 ret = __get_inode_info(root, path, ino, size, gen, mode, uid, gid,
847 rdev);
848 btrfs_free_path(path);
849 return ret;
850}
851
852typedef int (*iterate_inode_ref_t)(int num, u64 dir, int index,
853 struct fs_path *p,
854 void *ctx);
855
856
857
858
859
860
861
862
863
864static int iterate_inode_ref(struct btrfs_root *root, struct btrfs_path *path,
865 struct btrfs_key *found_key, int resolve,
866 iterate_inode_ref_t iterate, void *ctx)
867{
868 struct extent_buffer *eb = path->nodes[0];
869 struct btrfs_item *item;
870 struct btrfs_inode_ref *iref;
871 struct btrfs_inode_extref *extref;
872 struct btrfs_path *tmp_path;
873 struct fs_path *p;
874 u32 cur = 0;
875 u32 total;
876 int slot = path->slots[0];
877 u32 name_len;
878 char *start;
879 int ret = 0;
880 int num = 0;
881 int index;
882 u64 dir;
883 unsigned long name_off;
884 unsigned long elem_size;
885 unsigned long ptr;
886
887 p = fs_path_alloc_reversed();
888 if (!p)
889 return -ENOMEM;
890
891 tmp_path = alloc_path_for_send();
892 if (!tmp_path) {
893 fs_path_free(p);
894 return -ENOMEM;
895 }
896
897
898 if (found_key->type == BTRFS_INODE_REF_KEY) {
899 ptr = (unsigned long)btrfs_item_ptr(eb, slot,
900 struct btrfs_inode_ref);
901 item = btrfs_item_nr(slot);
902 total = btrfs_item_size(eb, item);
903 elem_size = sizeof(*iref);
904 } else {
905 ptr = btrfs_item_ptr_offset(eb, slot);
906 total = btrfs_item_size_nr(eb, slot);
907 elem_size = sizeof(*extref);
908 }
909
910 while (cur < total) {
911 fs_path_reset(p);
912
913 if (found_key->type == BTRFS_INODE_REF_KEY) {
914 iref = (struct btrfs_inode_ref *)(ptr + cur);
915 name_len = btrfs_inode_ref_name_len(eb, iref);
916 name_off = (unsigned long)(iref + 1);
917 index = btrfs_inode_ref_index(eb, iref);
918 dir = found_key->offset;
919 } else {
920 extref = (struct btrfs_inode_extref *)(ptr + cur);
921 name_len = btrfs_inode_extref_name_len(eb, extref);
922 name_off = (unsigned long)&extref->name;
923 index = btrfs_inode_extref_index(eb, extref);
924 dir = btrfs_inode_extref_parent(eb, extref);
925 }
926
927 if (resolve) {
928 start = btrfs_ref_to_path(root, tmp_path, name_len,
929 name_off, eb, dir,
930 p->buf, p->buf_len);
931 if (IS_ERR(start)) {
932 ret = PTR_ERR(start);
933 goto out;
934 }
935 if (start < p->buf) {
936
937 ret = fs_path_ensure_buf(p,
938 p->buf_len + p->buf - start);
939 if (ret < 0)
940 goto out;
941 start = btrfs_ref_to_path(root, tmp_path,
942 name_len, name_off,
943 eb, dir,
944 p->buf, p->buf_len);
945 if (IS_ERR(start)) {
946 ret = PTR_ERR(start);
947 goto out;
948 }
949 BUG_ON(start < p->buf);
950 }
951 p->start = start;
952 } else {
953 ret = fs_path_add_from_extent_buffer(p, eb, name_off,
954 name_len);
955 if (ret < 0)
956 goto out;
957 }
958
959 cur += elem_size + name_len;
960 ret = iterate(num, dir, index, p, ctx);
961 if (ret)
962 goto out;
963 num++;
964 }
965
966out:
967 btrfs_free_path(tmp_path);
968 fs_path_free(p);
969 return ret;
970}
971
972typedef int (*iterate_dir_item_t)(int num, struct btrfs_key *di_key,
973 const char *name, int name_len,
974 const char *data, int data_len,
975 u8 type, void *ctx);
976
977
978
979
980
981
982
983
984static int iterate_dir_item(struct btrfs_root *root, struct btrfs_path *path,
985 iterate_dir_item_t iterate, void *ctx)
986{
987 int ret = 0;
988 struct extent_buffer *eb;
989 struct btrfs_item *item;
990 struct btrfs_dir_item *di;
991 struct btrfs_key di_key;
992 char *buf = NULL;
993 int buf_len;
994 u32 name_len;
995 u32 data_len;
996 u32 cur;
997 u32 len;
998 u32 total;
999 int slot;
1000 int num;
1001 u8 type;
1002
1003
1004
1005
1006
1007
1008
1009 buf_len = PATH_MAX;
1010 buf = kmalloc(buf_len, GFP_KERNEL);
1011 if (!buf) {
1012 ret = -ENOMEM;
1013 goto out;
1014 }
1015
1016 eb = path->nodes[0];
1017 slot = path->slots[0];
1018 item = btrfs_item_nr(slot);
1019 di = btrfs_item_ptr(eb, slot, struct btrfs_dir_item);
1020 cur = 0;
1021 len = 0;
1022 total = btrfs_item_size(eb, item);
1023
1024 num = 0;
1025 while (cur < total) {
1026 name_len = btrfs_dir_name_len(eb, di);
1027 data_len = btrfs_dir_data_len(eb, di);
1028 type = btrfs_dir_type(eb, di);
1029 btrfs_dir_item_key_to_cpu(eb, di, &di_key);
1030
1031 if (type == BTRFS_FT_XATTR) {
1032 if (name_len > XATTR_NAME_MAX) {
1033 ret = -ENAMETOOLONG;
1034 goto out;
1035 }
1036 if (name_len + data_len >
1037 BTRFS_MAX_XATTR_SIZE(root->fs_info)) {
1038 ret = -E2BIG;
1039 goto out;
1040 }
1041 } else {
1042
1043
1044
1045 if (name_len + data_len > PATH_MAX) {
1046 ret = -ENAMETOOLONG;
1047 goto out;
1048 }
1049 }
1050
1051 if (name_len + data_len > buf_len) {
1052 buf_len = name_len + data_len;
1053 if (is_vmalloc_addr(buf)) {
1054 vfree(buf);
1055 buf = NULL;
1056 } else {
1057 char *tmp = krealloc(buf, buf_len,
1058 GFP_KERNEL | __GFP_NOWARN);
1059
1060 if (!tmp)
1061 kfree(buf);
1062 buf = tmp;
1063 }
1064 if (!buf) {
1065 buf = kvmalloc(buf_len, GFP_KERNEL);
1066 if (!buf) {
1067 ret = -ENOMEM;
1068 goto out;
1069 }
1070 }
1071 }
1072
1073 read_extent_buffer(eb, buf, (unsigned long)(di + 1),
1074 name_len + data_len);
1075
1076 len = sizeof(*di) + name_len + data_len;
1077 di = (struct btrfs_dir_item *)((char *)di + len);
1078 cur += len;
1079
1080 ret = iterate(num, &di_key, buf, name_len, buf + name_len,
1081 data_len, type, ctx);
1082 if (ret < 0)
1083 goto out;
1084 if (ret) {
1085 ret = 0;
1086 goto out;
1087 }
1088
1089 num++;
1090 }
1091
1092out:
1093 kvfree(buf);
1094 return ret;
1095}
1096
1097static int __copy_first_ref(int num, u64 dir, int index,
1098 struct fs_path *p, void *ctx)
1099{
1100 int ret;
1101 struct fs_path *pt = ctx;
1102
1103 ret = fs_path_copy(pt, p);
1104 if (ret < 0)
1105 return ret;
1106
1107
1108 return 1;
1109}
1110
1111
1112
1113
1114
1115static int get_inode_path(struct btrfs_root *root,
1116 u64 ino, struct fs_path *path)
1117{
1118 int ret;
1119 struct btrfs_key key, found_key;
1120 struct btrfs_path *p;
1121
1122 p = alloc_path_for_send();
1123 if (!p)
1124 return -ENOMEM;
1125
1126 fs_path_reset(path);
1127
1128 key.objectid = ino;
1129 key.type = BTRFS_INODE_REF_KEY;
1130 key.offset = 0;
1131
1132 ret = btrfs_search_slot_for_read(root, &key, p, 1, 0);
1133 if (ret < 0)
1134 goto out;
1135 if (ret) {
1136 ret = 1;
1137 goto out;
1138 }
1139 btrfs_item_key_to_cpu(p->nodes[0], &found_key, p->slots[0]);
1140 if (found_key.objectid != ino ||
1141 (found_key.type != BTRFS_INODE_REF_KEY &&
1142 found_key.type != BTRFS_INODE_EXTREF_KEY)) {
1143 ret = -ENOENT;
1144 goto out;
1145 }
1146
1147 ret = iterate_inode_ref(root, p, &found_key, 1,
1148 __copy_first_ref, path);
1149 if (ret < 0)
1150 goto out;
1151 ret = 0;
1152
1153out:
1154 btrfs_free_path(p);
1155 return ret;
1156}
1157
1158struct backref_ctx {
1159 struct send_ctx *sctx;
1160
1161 struct btrfs_path *path;
1162
1163 u64 found;
1164
1165
1166
1167
1168
1169 u64 cur_objectid;
1170 u64 cur_offset;
1171
1172
1173 u64 extent_len;
1174
1175
1176 u64 data_offset;
1177
1178
1179 int found_itself;
1180};
1181
1182static int __clone_root_cmp_bsearch(const void *key, const void *elt)
1183{
1184 u64 root = (u64)(uintptr_t)key;
1185 struct clone_root *cr = (struct clone_root *)elt;
1186
1187 if (root < cr->root->objectid)
1188 return -1;
1189 if (root > cr->root->objectid)
1190 return 1;
1191 return 0;
1192}
1193
1194static int __clone_root_cmp_sort(const void *e1, const void *e2)
1195{
1196 struct clone_root *cr1 = (struct clone_root *)e1;
1197 struct clone_root *cr2 = (struct clone_root *)e2;
1198
1199 if (cr1->root->objectid < cr2->root->objectid)
1200 return -1;
1201 if (cr1->root->objectid > cr2->root->objectid)
1202 return 1;
1203 return 0;
1204}
1205
1206
1207
1208
1209
1210static int __iterate_backrefs(u64 ino, u64 offset, u64 root, void *ctx_)
1211{
1212 struct backref_ctx *bctx = ctx_;
1213 struct clone_root *found;
1214 int ret;
1215 u64 i_size;
1216
1217
1218 found = bsearch((void *)(uintptr_t)root, bctx->sctx->clone_roots,
1219 bctx->sctx->clone_roots_cnt,
1220 sizeof(struct clone_root),
1221 __clone_root_cmp_bsearch);
1222 if (!found)
1223 return 0;
1224
1225 if (found->root == bctx->sctx->send_root &&
1226 ino == bctx->cur_objectid &&
1227 offset == bctx->cur_offset) {
1228 bctx->found_itself = 1;
1229 }
1230
1231
1232
1233
1234
1235 ret = __get_inode_info(found->root, bctx->path, ino, &i_size, NULL, NULL,
1236 NULL, NULL, NULL);
1237 btrfs_release_path(bctx->path);
1238 if (ret < 0)
1239 return ret;
1240
1241 if (offset + bctx->data_offset + bctx->extent_len > i_size)
1242 return 0;
1243
1244
1245
1246
1247
1248 if (found->root == bctx->sctx->send_root) {
1249
1250
1251
1252
1253
1254
1255 if (ino >= bctx->cur_objectid)
1256 return 0;
1257 }
1258
1259 bctx->found++;
1260 found->found_refs++;
1261 if (ino < found->ino) {
1262 found->ino = ino;
1263 found->offset = offset;
1264 } else if (found->ino == ino) {
1265
1266
1267
1268 if (found->offset > offset + bctx->extent_len)
1269 found->offset = offset;
1270 }
1271
1272 return 0;
1273}
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284static int find_extent_clone(struct send_ctx *sctx,
1285 struct btrfs_path *path,
1286 u64 ino, u64 data_offset,
1287 u64 ino_size,
1288 struct clone_root **found)
1289{
1290 struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;
1291 int ret;
1292 int extent_type;
1293 u64 logical;
1294 u64 disk_byte;
1295 u64 num_bytes;
1296 u64 extent_item_pos;
1297 u64 flags = 0;
1298 struct btrfs_file_extent_item *fi;
1299 struct extent_buffer *eb = path->nodes[0];
1300 struct backref_ctx *backref_ctx = NULL;
1301 struct clone_root *cur_clone_root;
1302 struct btrfs_key found_key;
1303 struct btrfs_path *tmp_path;
1304 int compressed;
1305 u32 i;
1306
1307 tmp_path = alloc_path_for_send();
1308 if (!tmp_path)
1309 return -ENOMEM;
1310
1311
1312 tmp_path->need_commit_sem = 0;
1313
1314 backref_ctx = kmalloc(sizeof(*backref_ctx), GFP_KERNEL);
1315 if (!backref_ctx) {
1316 ret = -ENOMEM;
1317 goto out;
1318 }
1319
1320 backref_ctx->path = tmp_path;
1321
1322 if (data_offset >= ino_size) {
1323
1324
1325
1326
1327
1328 ret = 0;
1329 goto out;
1330 }
1331
1332 fi = btrfs_item_ptr(eb, path->slots[0],
1333 struct btrfs_file_extent_item);
1334 extent_type = btrfs_file_extent_type(eb, fi);
1335 if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
1336 ret = -ENOENT;
1337 goto out;
1338 }
1339 compressed = btrfs_file_extent_compression(eb, fi);
1340
1341 num_bytes = btrfs_file_extent_num_bytes(eb, fi);
1342 disk_byte = btrfs_file_extent_disk_bytenr(eb, fi);
1343 if (disk_byte == 0) {
1344 ret = -ENOENT;
1345 goto out;
1346 }
1347 logical = disk_byte + btrfs_file_extent_offset(eb, fi);
1348
1349 down_read(&fs_info->commit_root_sem);
1350 ret = extent_from_logical(fs_info, disk_byte, tmp_path,
1351 &found_key, &flags);
1352 up_read(&fs_info->commit_root_sem);
1353 btrfs_release_path(tmp_path);
1354
1355 if (ret < 0)
1356 goto out;
1357 if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
1358 ret = -EIO;
1359 goto out;
1360 }
1361
1362
1363
1364
1365 for (i = 0; i < sctx->clone_roots_cnt; i++) {
1366 cur_clone_root = sctx->clone_roots + i;
1367 cur_clone_root->ino = (u64)-1;
1368 cur_clone_root->offset = 0;
1369 cur_clone_root->found_refs = 0;
1370 }
1371
1372 backref_ctx->sctx = sctx;
1373 backref_ctx->found = 0;
1374 backref_ctx->cur_objectid = ino;
1375 backref_ctx->cur_offset = data_offset;
1376 backref_ctx->found_itself = 0;
1377 backref_ctx->extent_len = num_bytes;
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387 if (compressed == BTRFS_COMPRESS_NONE)
1388 backref_ctx->data_offset = 0;
1389 else
1390 backref_ctx->data_offset = btrfs_file_extent_offset(eb, fi);
1391
1392
1393
1394
1395
1396
1397 if (data_offset + num_bytes >= ino_size)
1398 backref_ctx->extent_len = ino_size - data_offset;
1399
1400
1401
1402
1403 if (compressed == BTRFS_COMPRESS_NONE)
1404 extent_item_pos = logical - found_key.objectid;
1405 else
1406 extent_item_pos = 0;
1407 ret = iterate_extent_inodes(fs_info, found_key.objectid,
1408 extent_item_pos, 1, __iterate_backrefs,
1409 backref_ctx, false);
1410
1411 if (ret < 0)
1412 goto out;
1413
1414 if (!backref_ctx->found_itself) {
1415
1416 ret = -EIO;
1417 btrfs_err(fs_info,
1418 "did not find backref in send_root. inode=%llu, offset=%llu, disk_byte=%llu found extent=%llu",
1419 ino, data_offset, disk_byte, found_key.objectid);
1420 goto out;
1421 }
1422
1423 btrfs_debug(fs_info,
1424 "find_extent_clone: data_offset=%llu, ino=%llu, num_bytes=%llu, logical=%llu",
1425 data_offset, ino, num_bytes, logical);
1426
1427 if (!backref_ctx->found)
1428 btrfs_debug(fs_info, "no clones found");
1429
1430 cur_clone_root = NULL;
1431 for (i = 0; i < sctx->clone_roots_cnt; i++) {
1432 if (sctx->clone_roots[i].found_refs) {
1433 if (!cur_clone_root)
1434 cur_clone_root = sctx->clone_roots + i;
1435 else if (sctx->clone_roots[i].root == sctx->send_root)
1436
1437 cur_clone_root = sctx->clone_roots + i;
1438 }
1439
1440 }
1441
1442 if (cur_clone_root) {
1443 *found = cur_clone_root;
1444 ret = 0;
1445 } else {
1446 ret = -ENOENT;
1447 }
1448
1449out:
1450 btrfs_free_path(tmp_path);
1451 kfree(backref_ctx);
1452 return ret;
1453}
1454
1455static int read_symlink(struct btrfs_root *root,
1456 u64 ino,
1457 struct fs_path *dest)
1458{
1459 int ret;
1460 struct btrfs_path *path;
1461 struct btrfs_key key;
1462 struct btrfs_file_extent_item *ei;
1463 u8 type;
1464 u8 compression;
1465 unsigned long off;
1466 int len;
1467
1468 path = alloc_path_for_send();
1469 if (!path)
1470 return -ENOMEM;
1471
1472 key.objectid = ino;
1473 key.type = BTRFS_EXTENT_DATA_KEY;
1474 key.offset = 0;
1475 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1476 if (ret < 0)
1477 goto out;
1478 if (ret) {
1479
1480
1481
1482
1483
1484
1485
1486
1487 btrfs_err(root->fs_info,
1488 "Found empty symlink inode %llu at root %llu",
1489 ino, root->root_key.objectid);
1490 ret = -EIO;
1491 goto out;
1492 }
1493
1494 ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
1495 struct btrfs_file_extent_item);
1496 type = btrfs_file_extent_type(path->nodes[0], ei);
1497 compression = btrfs_file_extent_compression(path->nodes[0], ei);
1498 BUG_ON(type != BTRFS_FILE_EXTENT_INLINE);
1499 BUG_ON(compression);
1500
1501 off = btrfs_file_extent_inline_start(ei);
1502 len = btrfs_file_extent_inline_len(path->nodes[0], path->slots[0], ei);
1503
1504 ret = fs_path_add_from_extent_buffer(dest, path->nodes[0], off, len);
1505
1506out:
1507 btrfs_free_path(path);
1508 return ret;
1509}
1510
1511
1512
1513
1514
1515static int gen_unique_name(struct send_ctx *sctx,
1516 u64 ino, u64 gen,
1517 struct fs_path *dest)
1518{
1519 int ret = 0;
1520 struct btrfs_path *path;
1521 struct btrfs_dir_item *di;
1522 char tmp[64];
1523 int len;
1524 u64 idx = 0;
1525
1526 path = alloc_path_for_send();
1527 if (!path)
1528 return -ENOMEM;
1529
1530 while (1) {
1531 len = snprintf(tmp, sizeof(tmp), "o%llu-%llu-%llu",
1532 ino, gen, idx);
1533 ASSERT(len < sizeof(tmp));
1534
1535 di = btrfs_lookup_dir_item(NULL, sctx->send_root,
1536 path, BTRFS_FIRST_FREE_OBJECTID,
1537 tmp, strlen(tmp), 0);
1538 btrfs_release_path(path);
1539 if (IS_ERR(di)) {
1540 ret = PTR_ERR(di);
1541 goto out;
1542 }
1543 if (di) {
1544
1545 idx++;
1546 continue;
1547 }
1548
1549 if (!sctx->parent_root) {
1550
1551 ret = 0;
1552 break;
1553 }
1554
1555 di = btrfs_lookup_dir_item(NULL, sctx->parent_root,
1556 path, BTRFS_FIRST_FREE_OBJECTID,
1557 tmp, strlen(tmp), 0);
1558 btrfs_release_path(path);
1559 if (IS_ERR(di)) {
1560 ret = PTR_ERR(di);
1561 goto out;
1562 }
1563 if (di) {
1564
1565 idx++;
1566 continue;
1567 }
1568
1569 break;
1570 }
1571
1572 ret = fs_path_add(dest, tmp, strlen(tmp));
1573
1574out:
1575 btrfs_free_path(path);
1576 return ret;
1577}
1578
1579enum inode_state {
1580 inode_state_no_change,
1581 inode_state_will_create,
1582 inode_state_did_create,
1583 inode_state_will_delete,
1584 inode_state_did_delete,
1585};
1586
1587static int get_cur_inode_state(struct send_ctx *sctx, u64 ino, u64 gen)
1588{
1589 int ret;
1590 int left_ret;
1591 int right_ret;
1592 u64 left_gen;
1593 u64 right_gen;
1594
1595 ret = get_inode_info(sctx->send_root, ino, NULL, &left_gen, NULL, NULL,
1596 NULL, NULL);
1597 if (ret < 0 && ret != -ENOENT)
1598 goto out;
1599 left_ret = ret;
1600
1601 if (!sctx->parent_root) {
1602 right_ret = -ENOENT;
1603 } else {
1604 ret = get_inode_info(sctx->parent_root, ino, NULL, &right_gen,
1605 NULL, NULL, NULL, NULL);
1606 if (ret < 0 && ret != -ENOENT)
1607 goto out;
1608 right_ret = ret;
1609 }
1610
1611 if (!left_ret && !right_ret) {
1612 if (left_gen == gen && right_gen == gen) {
1613 ret = inode_state_no_change;
1614 } else if (left_gen == gen) {
1615 if (ino < sctx->send_progress)
1616 ret = inode_state_did_create;
1617 else
1618 ret = inode_state_will_create;
1619 } else if (right_gen == gen) {
1620 if (ino < sctx->send_progress)
1621 ret = inode_state_did_delete;
1622 else
1623 ret = inode_state_will_delete;
1624 } else {
1625 ret = -ENOENT;
1626 }
1627 } else if (!left_ret) {
1628 if (left_gen == gen) {
1629 if (ino < sctx->send_progress)
1630 ret = inode_state_did_create;
1631 else
1632 ret = inode_state_will_create;
1633 } else {
1634 ret = -ENOENT;
1635 }
1636 } else if (!right_ret) {
1637 if (right_gen == gen) {
1638 if (ino < sctx->send_progress)
1639 ret = inode_state_did_delete;
1640 else
1641 ret = inode_state_will_delete;
1642 } else {
1643 ret = -ENOENT;
1644 }
1645 } else {
1646 ret = -ENOENT;
1647 }
1648
1649out:
1650 return ret;
1651}
1652
1653static int is_inode_existent(struct send_ctx *sctx, u64 ino, u64 gen)
1654{
1655 int ret;
1656
1657 if (ino == BTRFS_FIRST_FREE_OBJECTID)
1658 return 1;
1659
1660 ret = get_cur_inode_state(sctx, ino, gen);
1661 if (ret < 0)
1662 goto out;
1663
1664 if (ret == inode_state_no_change ||
1665 ret == inode_state_did_create ||
1666 ret == inode_state_will_delete)
1667 ret = 1;
1668 else
1669 ret = 0;
1670
1671out:
1672 return ret;
1673}
1674
1675
1676
1677
1678static int lookup_dir_item_inode(struct btrfs_root *root,
1679 u64 dir, const char *name, int name_len,
1680 u64 *found_inode,
1681 u8 *found_type)
1682{
1683 int ret = 0;
1684 struct btrfs_dir_item *di;
1685 struct btrfs_key key;
1686 struct btrfs_path *path;
1687
1688 path = alloc_path_for_send();
1689 if (!path)
1690 return -ENOMEM;
1691
1692 di = btrfs_lookup_dir_item(NULL, root, path,
1693 dir, name, name_len, 0);
1694 if (!di) {
1695 ret = -ENOENT;
1696 goto out;
1697 }
1698 if (IS_ERR(di)) {
1699 ret = PTR_ERR(di);
1700 goto out;
1701 }
1702 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &key);
1703 if (key.type == BTRFS_ROOT_ITEM_KEY) {
1704 ret = -ENOENT;
1705 goto out;
1706 }
1707 *found_inode = key.objectid;
1708 *found_type = btrfs_dir_type(path->nodes[0], di);
1709
1710out:
1711 btrfs_free_path(path);
1712 return ret;
1713}
1714
1715
1716
1717
1718
1719static int get_first_ref(struct btrfs_root *root, u64 ino,
1720 u64 *dir, u64 *dir_gen, struct fs_path *name)
1721{
1722 int ret;
1723 struct btrfs_key key;
1724 struct btrfs_key found_key;
1725 struct btrfs_path *path;
1726 int len;
1727 u64 parent_dir;
1728
1729 path = alloc_path_for_send();
1730 if (!path)
1731 return -ENOMEM;
1732
1733 key.objectid = ino;
1734 key.type = BTRFS_INODE_REF_KEY;
1735 key.offset = 0;
1736
1737 ret = btrfs_search_slot_for_read(root, &key, path, 1, 0);
1738 if (ret < 0)
1739 goto out;
1740 if (!ret)
1741 btrfs_item_key_to_cpu(path->nodes[0], &found_key,
1742 path->slots[0]);
1743 if (ret || found_key.objectid != ino ||
1744 (found_key.type != BTRFS_INODE_REF_KEY &&
1745 found_key.type != BTRFS_INODE_EXTREF_KEY)) {
1746 ret = -ENOENT;
1747 goto out;
1748 }
1749
1750 if (found_key.type == BTRFS_INODE_REF_KEY) {
1751 struct btrfs_inode_ref *iref;
1752 iref = btrfs_item_ptr(path->nodes[0], path->slots[0],
1753 struct btrfs_inode_ref);
1754 len = btrfs_inode_ref_name_len(path->nodes[0], iref);
1755 ret = fs_path_add_from_extent_buffer(name, path->nodes[0],
1756 (unsigned long)(iref + 1),
1757 len);
1758 parent_dir = found_key.offset;
1759 } else {
1760 struct btrfs_inode_extref *extref;
1761 extref = btrfs_item_ptr(path->nodes[0], path->slots[0],
1762 struct btrfs_inode_extref);
1763 len = btrfs_inode_extref_name_len(path->nodes[0], extref);
1764 ret = fs_path_add_from_extent_buffer(name, path->nodes[0],
1765 (unsigned long)&extref->name, len);
1766 parent_dir = btrfs_inode_extref_parent(path->nodes[0], extref);
1767 }
1768 if (ret < 0)
1769 goto out;
1770 btrfs_release_path(path);
1771
1772 if (dir_gen) {
1773 ret = get_inode_info(root, parent_dir, NULL, dir_gen, NULL,
1774 NULL, NULL, NULL);
1775 if (ret < 0)
1776 goto out;
1777 }
1778
1779 *dir = parent_dir;
1780
1781out:
1782 btrfs_free_path(path);
1783 return ret;
1784}
1785
1786static int is_first_ref(struct btrfs_root *root,
1787 u64 ino, u64 dir,
1788 const char *name, int name_len)
1789{
1790 int ret;
1791 struct fs_path *tmp_name;
1792 u64 tmp_dir;
1793
1794 tmp_name = fs_path_alloc();
1795 if (!tmp_name)
1796 return -ENOMEM;
1797
1798 ret = get_first_ref(root, ino, &tmp_dir, NULL, tmp_name);
1799 if (ret < 0)
1800 goto out;
1801
1802 if (dir != tmp_dir || name_len != fs_path_len(tmp_name)) {
1803 ret = 0;
1804 goto out;
1805 }
1806
1807 ret = !memcmp(tmp_name->start, name, name_len);
1808
1809out:
1810 fs_path_free(tmp_name);
1811 return ret;
1812}
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824static int will_overwrite_ref(struct send_ctx *sctx, u64 dir, u64 dir_gen,
1825 const char *name, int name_len,
1826 u64 *who_ino, u64 *who_gen, u64 *who_mode)
1827{
1828 int ret = 0;
1829 u64 gen;
1830 u64 other_inode = 0;
1831 u8 other_type = 0;
1832
1833 if (!sctx->parent_root)
1834 goto out;
1835
1836 ret = is_inode_existent(sctx, dir, dir_gen);
1837 if (ret <= 0)
1838 goto out;
1839
1840
1841
1842
1843
1844
1845 if (sctx->parent_root && dir != BTRFS_FIRST_FREE_OBJECTID) {
1846 ret = get_inode_info(sctx->parent_root, dir, NULL, &gen, NULL,
1847 NULL, NULL, NULL);
1848 if (ret < 0 && ret != -ENOENT)
1849 goto out;
1850 if (ret) {
1851 ret = 0;
1852 goto out;
1853 }
1854 if (gen != dir_gen)
1855 goto out;
1856 }
1857
1858 ret = lookup_dir_item_inode(sctx->parent_root, dir, name, name_len,
1859 &other_inode, &other_type);
1860 if (ret < 0 && ret != -ENOENT)
1861 goto out;
1862 if (ret) {
1863 ret = 0;
1864 goto out;
1865 }
1866
1867
1868
1869
1870
1871
1872 if (other_inode > sctx->send_progress ||
1873 is_waiting_for_move(sctx, other_inode)) {
1874 ret = get_inode_info(sctx->parent_root, other_inode, NULL,
1875 who_gen, who_mode, NULL, NULL, NULL);
1876 if (ret < 0)
1877 goto out;
1878
1879 ret = 1;
1880 *who_ino = other_inode;
1881 } else {
1882 ret = 0;
1883 }
1884
1885out:
1886 return ret;
1887}
1888
1889
1890
1891
1892
1893
1894
1895
1896static int did_overwrite_ref(struct send_ctx *sctx,
1897 u64 dir, u64 dir_gen,
1898 u64 ino, u64 ino_gen,
1899 const char *name, int name_len)
1900{
1901 int ret = 0;
1902 u64 gen;
1903 u64 ow_inode;
1904 u8 other_type;
1905
1906 if (!sctx->parent_root)
1907 goto out;
1908
1909 ret = is_inode_existent(sctx, dir, dir_gen);
1910 if (ret <= 0)
1911 goto out;
1912
1913 if (dir != BTRFS_FIRST_FREE_OBJECTID) {
1914 ret = get_inode_info(sctx->send_root, dir, NULL, &gen, NULL,
1915 NULL, NULL, NULL);
1916 if (ret < 0 && ret != -ENOENT)
1917 goto out;
1918 if (ret) {
1919 ret = 0;
1920 goto out;
1921 }
1922 if (gen != dir_gen)
1923 goto out;
1924 }
1925
1926
1927 ret = lookup_dir_item_inode(sctx->send_root, dir, name, name_len,
1928 &ow_inode, &other_type);
1929 if (ret < 0 && ret != -ENOENT)
1930 goto out;
1931 if (ret) {
1932
1933 ret = 0;
1934 goto out;
1935 }
1936
1937 ret = get_inode_info(sctx->send_root, ow_inode, NULL, &gen, NULL, NULL,
1938 NULL, NULL);
1939 if (ret < 0)
1940 goto out;
1941
1942 if (ow_inode == ino && gen == ino_gen) {
1943 ret = 0;
1944 goto out;
1945 }
1946
1947
1948
1949
1950
1951
1952
1953 if ((ow_inode < sctx->send_progress) ||
1954 (ino != sctx->cur_ino && ow_inode == sctx->cur_ino &&
1955 gen == sctx->cur_inode_gen))
1956 ret = 1;
1957 else
1958 ret = 0;
1959
1960out:
1961 return ret;
1962}
1963
1964
1965
1966
1967
1968
1969static int did_overwrite_first_ref(struct send_ctx *sctx, u64 ino, u64 gen)
1970{
1971 int ret = 0;
1972 struct fs_path *name = NULL;
1973 u64 dir;
1974 u64 dir_gen;
1975
1976 if (!sctx->parent_root)
1977 goto out;
1978
1979 name = fs_path_alloc();
1980 if (!name)
1981 return -ENOMEM;
1982
1983 ret = get_first_ref(sctx->parent_root, ino, &dir, &dir_gen, name);
1984 if (ret < 0)
1985 goto out;
1986
1987 ret = did_overwrite_ref(sctx, dir, dir_gen, ino, gen,
1988 name->start, fs_path_len(name));
1989
1990out:
1991 fs_path_free(name);
1992 return ret;
1993}
1994
1995
1996
1997
1998
1999
2000
2001static int name_cache_insert(struct send_ctx *sctx,
2002 struct name_cache_entry *nce)
2003{
2004 int ret = 0;
2005 struct list_head *nce_head;
2006
2007 nce_head = radix_tree_lookup(&sctx->name_cache,
2008 (unsigned long)nce->ino);
2009 if (!nce_head) {
2010 nce_head = kmalloc(sizeof(*nce_head), GFP_KERNEL);
2011 if (!nce_head) {
2012 kfree(nce);
2013 return -ENOMEM;
2014 }
2015 INIT_LIST_HEAD(nce_head);
2016
2017 ret = radix_tree_insert(&sctx->name_cache, nce->ino, nce_head);
2018 if (ret < 0) {
2019 kfree(nce_head);
2020 kfree(nce);
2021 return ret;
2022 }
2023 }
2024 list_add_tail(&nce->radix_list, nce_head);
2025 list_add_tail(&nce->list, &sctx->name_cache_list);
2026 sctx->name_cache_size++;
2027
2028 return ret;
2029}
2030
2031static void name_cache_delete(struct send_ctx *sctx,
2032 struct name_cache_entry *nce)
2033{
2034 struct list_head *nce_head;
2035
2036 nce_head = radix_tree_lookup(&sctx->name_cache,
2037 (unsigned long)nce->ino);
2038 if (!nce_head) {
2039 btrfs_err(sctx->send_root->fs_info,
2040 "name_cache_delete lookup failed ino %llu cache size %d, leaking memory",
2041 nce->ino, sctx->name_cache_size);
2042 }
2043
2044 list_del(&nce->radix_list);
2045 list_del(&nce->list);
2046 sctx->name_cache_size--;
2047
2048
2049
2050
2051 if (nce_head && list_empty(nce_head)) {
2052 radix_tree_delete(&sctx->name_cache, (unsigned long)nce->ino);
2053 kfree(nce_head);
2054 }
2055}
2056
2057static struct name_cache_entry *name_cache_search(struct send_ctx *sctx,
2058 u64 ino, u64 gen)
2059{
2060 struct list_head *nce_head;
2061 struct name_cache_entry *cur;
2062
2063 nce_head = radix_tree_lookup(&sctx->name_cache, (unsigned long)ino);
2064 if (!nce_head)
2065 return NULL;
2066
2067 list_for_each_entry(cur, nce_head, radix_list) {
2068 if (cur->ino == ino && cur->gen == gen)
2069 return cur;
2070 }
2071 return NULL;
2072}
2073
2074
2075
2076
2077
2078static void name_cache_used(struct send_ctx *sctx, struct name_cache_entry *nce)
2079{
2080 list_del(&nce->list);
2081 list_add_tail(&nce->list, &sctx->name_cache_list);
2082}
2083
2084
2085
2086
2087static void name_cache_clean_unused(struct send_ctx *sctx)
2088{
2089 struct name_cache_entry *nce;
2090
2091 if (sctx->name_cache_size < SEND_CTX_NAME_CACHE_CLEAN_SIZE)
2092 return;
2093
2094 while (sctx->name_cache_size > SEND_CTX_MAX_NAME_CACHE_SIZE) {
2095 nce = list_entry(sctx->name_cache_list.next,
2096 struct name_cache_entry, list);
2097 name_cache_delete(sctx, nce);
2098 kfree(nce);
2099 }
2100}
2101
2102static void name_cache_free(struct send_ctx *sctx)
2103{
2104 struct name_cache_entry *nce;
2105
2106 while (!list_empty(&sctx->name_cache_list)) {
2107 nce = list_entry(sctx->name_cache_list.next,
2108 struct name_cache_entry, list);
2109 name_cache_delete(sctx, nce);
2110 kfree(nce);
2111 }
2112}
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122static int __get_cur_name_and_parent(struct send_ctx *sctx,
2123 u64 ino, u64 gen,
2124 u64 *parent_ino,
2125 u64 *parent_gen,
2126 struct fs_path *dest)
2127{
2128 int ret;
2129 int nce_ret;
2130 struct name_cache_entry *nce = NULL;
2131
2132
2133
2134
2135
2136
2137 nce = name_cache_search(sctx, ino, gen);
2138 if (nce) {
2139 if (ino < sctx->send_progress && nce->need_later_update) {
2140 name_cache_delete(sctx, nce);
2141 kfree(nce);
2142 nce = NULL;
2143 } else {
2144 name_cache_used(sctx, nce);
2145 *parent_ino = nce->parent_ino;
2146 *parent_gen = nce->parent_gen;
2147 ret = fs_path_add(dest, nce->name, nce->name_len);
2148 if (ret < 0)
2149 goto out;
2150 ret = nce->ret;
2151 goto out;
2152 }
2153 }
2154
2155
2156
2157
2158
2159
2160 ret = is_inode_existent(sctx, ino, gen);
2161 if (ret < 0)
2162 goto out;
2163
2164 if (!ret) {
2165 ret = gen_unique_name(sctx, ino, gen, dest);
2166 if (ret < 0)
2167 goto out;
2168 ret = 1;
2169 goto out_cache;
2170 }
2171
2172
2173
2174
2175
2176 if (ino < sctx->send_progress)
2177 ret = get_first_ref(sctx->send_root, ino,
2178 parent_ino, parent_gen, dest);
2179 else
2180 ret = get_first_ref(sctx->parent_root, ino,
2181 parent_ino, parent_gen, dest);
2182 if (ret < 0)
2183 goto out;
2184
2185
2186
2187
2188
2189 ret = did_overwrite_ref(sctx, *parent_ino, *parent_gen, ino, gen,
2190 dest->start, dest->end - dest->start);
2191 if (ret < 0)
2192 goto out;
2193 if (ret) {
2194 fs_path_reset(dest);
2195 ret = gen_unique_name(sctx, ino, gen, dest);
2196 if (ret < 0)
2197 goto out;
2198 ret = 1;
2199 }
2200
2201out_cache:
2202
2203
2204
2205 nce = kmalloc(sizeof(*nce) + fs_path_len(dest) + 1, GFP_KERNEL);
2206 if (!nce) {
2207 ret = -ENOMEM;
2208 goto out;
2209 }
2210
2211 nce->ino = ino;
2212 nce->gen = gen;
2213 nce->parent_ino = *parent_ino;
2214 nce->parent_gen = *parent_gen;
2215 nce->name_len = fs_path_len(dest);
2216 nce->ret = ret;
2217 strcpy(nce->name, dest->start);
2218
2219 if (ino < sctx->send_progress)
2220 nce->need_later_update = 0;
2221 else
2222 nce->need_later_update = 1;
2223
2224 nce_ret = name_cache_insert(sctx, nce);
2225 if (nce_ret < 0)
2226 ret = nce_ret;
2227 name_cache_clean_unused(sctx);
2228
2229out:
2230 return ret;
2231}
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258static int get_cur_path(struct send_ctx *sctx, u64 ino, u64 gen,
2259 struct fs_path *dest)
2260{
2261 int ret = 0;
2262 struct fs_path *name = NULL;
2263 u64 parent_inode = 0;
2264 u64 parent_gen = 0;
2265 int stop = 0;
2266
2267 name = fs_path_alloc();
2268 if (!name) {
2269 ret = -ENOMEM;
2270 goto out;
2271 }
2272
2273 dest->reversed = 1;
2274 fs_path_reset(dest);
2275
2276 while (!stop && ino != BTRFS_FIRST_FREE_OBJECTID) {
2277 struct waiting_dir_move *wdm;
2278
2279 fs_path_reset(name);
2280
2281 if (is_waiting_for_rm(sctx, ino)) {
2282 ret = gen_unique_name(sctx, ino, gen, name);
2283 if (ret < 0)
2284 goto out;
2285 ret = fs_path_add_path(dest, name);
2286 break;
2287 }
2288
2289 wdm = get_waiting_dir_move(sctx, ino);
2290 if (wdm && wdm->orphanized) {
2291 ret = gen_unique_name(sctx, ino, gen, name);
2292 stop = 1;
2293 } else if (wdm) {
2294 ret = get_first_ref(sctx->parent_root, ino,
2295 &parent_inode, &parent_gen, name);
2296 } else {
2297 ret = __get_cur_name_and_parent(sctx, ino, gen,
2298 &parent_inode,
2299 &parent_gen, name);
2300 if (ret)
2301 stop = 1;
2302 }
2303
2304 if (ret < 0)
2305 goto out;
2306
2307 ret = fs_path_add_path(dest, name);
2308 if (ret < 0)
2309 goto out;
2310
2311 ino = parent_inode;
2312 gen = parent_gen;
2313 }
2314
2315out:
2316 fs_path_free(name);
2317 if (!ret)
2318 fs_path_unreverse(dest);
2319 return ret;
2320}
2321
2322
2323
2324
2325static int send_subvol_begin(struct send_ctx *sctx)
2326{
2327 int ret;
2328 struct btrfs_root *send_root = sctx->send_root;
2329 struct btrfs_root *parent_root = sctx->parent_root;
2330 struct btrfs_path *path;
2331 struct btrfs_key key;
2332 struct btrfs_root_ref *ref;
2333 struct extent_buffer *leaf;
2334 char *name = NULL;
2335 int namelen;
2336
2337 path = btrfs_alloc_path();
2338 if (!path)
2339 return -ENOMEM;
2340
2341 name = kmalloc(BTRFS_PATH_NAME_MAX, GFP_KERNEL);
2342 if (!name) {
2343 btrfs_free_path(path);
2344 return -ENOMEM;
2345 }
2346
2347 key.objectid = send_root->objectid;
2348 key.type = BTRFS_ROOT_BACKREF_KEY;
2349 key.offset = 0;
2350
2351 ret = btrfs_search_slot_for_read(send_root->fs_info->tree_root,
2352 &key, path, 1, 0);
2353 if (ret < 0)
2354 goto out;
2355 if (ret) {
2356 ret = -ENOENT;
2357 goto out;
2358 }
2359
2360 leaf = path->nodes[0];
2361 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
2362 if (key.type != BTRFS_ROOT_BACKREF_KEY ||
2363 key.objectid != send_root->objectid) {
2364 ret = -ENOENT;
2365 goto out;
2366 }
2367 ref = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_root_ref);
2368 namelen = btrfs_root_ref_name_len(leaf, ref);
2369 read_extent_buffer(leaf, name, (unsigned long)(ref + 1), namelen);
2370 btrfs_release_path(path);
2371
2372 if (parent_root) {
2373 ret = begin_cmd(sctx, BTRFS_SEND_C_SNAPSHOT);
2374 if (ret < 0)
2375 goto out;
2376 } else {
2377 ret = begin_cmd(sctx, BTRFS_SEND_C_SUBVOL);
2378 if (ret < 0)
2379 goto out;
2380 }
2381
2382 TLV_PUT_STRING(sctx, BTRFS_SEND_A_PATH, name, namelen);
2383
2384 if (!btrfs_is_empty_uuid(sctx->send_root->root_item.received_uuid))
2385 TLV_PUT_UUID(sctx, BTRFS_SEND_A_UUID,
2386 sctx->send_root->root_item.received_uuid);
2387 else
2388 TLV_PUT_UUID(sctx, BTRFS_SEND_A_UUID,
2389 sctx->send_root->root_item.uuid);
2390
2391 TLV_PUT_U64(sctx, BTRFS_SEND_A_CTRANSID,
2392 le64_to_cpu(sctx->send_root->root_item.ctransid));
2393 if (parent_root) {
2394 if (!btrfs_is_empty_uuid(parent_root->root_item.received_uuid))
2395 TLV_PUT_UUID(sctx, BTRFS_SEND_A_CLONE_UUID,
2396 parent_root->root_item.received_uuid);
2397 else
2398 TLV_PUT_UUID(sctx, BTRFS_SEND_A_CLONE_UUID,
2399 parent_root->root_item.uuid);
2400 TLV_PUT_U64(sctx, BTRFS_SEND_A_CLONE_CTRANSID,
2401 le64_to_cpu(sctx->parent_root->root_item.ctransid));
2402 }
2403
2404 ret = send_cmd(sctx);
2405
2406tlv_put_failure:
2407out:
2408 btrfs_free_path(path);
2409 kfree(name);
2410 return ret;
2411}
2412
2413static int send_truncate(struct send_ctx *sctx, u64 ino, u64 gen, u64 size)
2414{
2415 struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;
2416 int ret = 0;
2417 struct fs_path *p;
2418
2419 btrfs_debug(fs_info, "send_truncate %llu size=%llu", ino, size);
2420
2421 p = fs_path_alloc();
2422 if (!p)
2423 return -ENOMEM;
2424
2425 ret = begin_cmd(sctx, BTRFS_SEND_C_TRUNCATE);
2426 if (ret < 0)
2427 goto out;
2428
2429 ret = get_cur_path(sctx, ino, gen, p);
2430 if (ret < 0)
2431 goto out;
2432 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
2433 TLV_PUT_U64(sctx, BTRFS_SEND_A_SIZE, size);
2434
2435 ret = send_cmd(sctx);
2436
2437tlv_put_failure:
2438out:
2439 fs_path_free(p);
2440 return ret;
2441}
2442
2443static int send_chmod(struct send_ctx *sctx, u64 ino, u64 gen, u64 mode)
2444{
2445 struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;
2446 int ret = 0;
2447 struct fs_path *p;
2448
2449 btrfs_debug(fs_info, "send_chmod %llu mode=%llu", ino, mode);
2450
2451 p = fs_path_alloc();
2452 if (!p)
2453 return -ENOMEM;
2454
2455 ret = begin_cmd(sctx, BTRFS_SEND_C_CHMOD);
2456 if (ret < 0)
2457 goto out;
2458
2459 ret = get_cur_path(sctx, ino, gen, p);
2460 if (ret < 0)
2461 goto out;
2462 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
2463 TLV_PUT_U64(sctx, BTRFS_SEND_A_MODE, mode & 07777);
2464
2465 ret = send_cmd(sctx);
2466
2467tlv_put_failure:
2468out:
2469 fs_path_free(p);
2470 return ret;
2471}
2472
2473static int send_chown(struct send_ctx *sctx, u64 ino, u64 gen, u64 uid, u64 gid)
2474{
2475 struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;
2476 int ret = 0;
2477 struct fs_path *p;
2478
2479 btrfs_debug(fs_info, "send_chown %llu uid=%llu, gid=%llu",
2480 ino, uid, gid);
2481
2482 p = fs_path_alloc();
2483 if (!p)
2484 return -ENOMEM;
2485
2486 ret = begin_cmd(sctx, BTRFS_SEND_C_CHOWN);
2487 if (ret < 0)
2488 goto out;
2489
2490 ret = get_cur_path(sctx, ino, gen, p);
2491 if (ret < 0)
2492 goto out;
2493 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
2494 TLV_PUT_U64(sctx, BTRFS_SEND_A_UID, uid);
2495 TLV_PUT_U64(sctx, BTRFS_SEND_A_GID, gid);
2496
2497 ret = send_cmd(sctx);
2498
2499tlv_put_failure:
2500out:
2501 fs_path_free(p);
2502 return ret;
2503}
2504
2505static int send_utimes(struct send_ctx *sctx, u64 ino, u64 gen)
2506{
2507 struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;
2508 int ret = 0;
2509 struct fs_path *p = NULL;
2510 struct btrfs_inode_item *ii;
2511 struct btrfs_path *path = NULL;
2512 struct extent_buffer *eb;
2513 struct btrfs_key key;
2514 int slot;
2515
2516 btrfs_debug(fs_info, "send_utimes %llu", ino);
2517
2518 p = fs_path_alloc();
2519 if (!p)
2520 return -ENOMEM;
2521
2522 path = alloc_path_for_send();
2523 if (!path) {
2524 ret = -ENOMEM;
2525 goto out;
2526 }
2527
2528 key.objectid = ino;
2529 key.type = BTRFS_INODE_ITEM_KEY;
2530 key.offset = 0;
2531 ret = btrfs_search_slot(NULL, sctx->send_root, &key, path, 0, 0);
2532 if (ret > 0)
2533 ret = -ENOENT;
2534 if (ret < 0)
2535 goto out;
2536
2537 eb = path->nodes[0];
2538 slot = path->slots[0];
2539 ii = btrfs_item_ptr(eb, slot, struct btrfs_inode_item);
2540
2541 ret = begin_cmd(sctx, BTRFS_SEND_C_UTIMES);
2542 if (ret < 0)
2543 goto out;
2544
2545 ret = get_cur_path(sctx, ino, gen, p);
2546 if (ret < 0)
2547 goto out;
2548 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
2549 TLV_PUT_BTRFS_TIMESPEC(sctx, BTRFS_SEND_A_ATIME, eb, &ii->atime);
2550 TLV_PUT_BTRFS_TIMESPEC(sctx, BTRFS_SEND_A_MTIME, eb, &ii->mtime);
2551 TLV_PUT_BTRFS_TIMESPEC(sctx, BTRFS_SEND_A_CTIME, eb, &ii->ctime);
2552
2553
2554 ret = send_cmd(sctx);
2555
2556tlv_put_failure:
2557out:
2558 fs_path_free(p);
2559 btrfs_free_path(path);
2560 return ret;
2561}
2562
2563
2564
2565
2566
2567
2568static int send_create_inode(struct send_ctx *sctx, u64 ino)
2569{
2570 struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;
2571 int ret = 0;
2572 struct fs_path *p;
2573 int cmd;
2574 u64 gen;
2575 u64 mode;
2576 u64 rdev;
2577
2578 btrfs_debug(fs_info, "send_create_inode %llu", ino);
2579
2580 p = fs_path_alloc();
2581 if (!p)
2582 return -ENOMEM;
2583
2584 if (ino != sctx->cur_ino) {
2585 ret = get_inode_info(sctx->send_root, ino, NULL, &gen, &mode,
2586 NULL, NULL, &rdev);
2587 if (ret < 0)
2588 goto out;
2589 } else {
2590 gen = sctx->cur_inode_gen;
2591 mode = sctx->cur_inode_mode;
2592 rdev = sctx->cur_inode_rdev;
2593 }
2594
2595 if (S_ISREG(mode)) {
2596 cmd = BTRFS_SEND_C_MKFILE;
2597 } else if (S_ISDIR(mode)) {
2598 cmd = BTRFS_SEND_C_MKDIR;
2599 } else if (S_ISLNK(mode)) {
2600 cmd = BTRFS_SEND_C_SYMLINK;
2601 } else if (S_ISCHR(mode) || S_ISBLK(mode)) {
2602 cmd = BTRFS_SEND_C_MKNOD;
2603 } else if (S_ISFIFO(mode)) {
2604 cmd = BTRFS_SEND_C_MKFIFO;
2605 } else if (S_ISSOCK(mode)) {
2606 cmd = BTRFS_SEND_C_MKSOCK;
2607 } else {
2608 btrfs_warn(sctx->send_root->fs_info, "unexpected inode type %o",
2609 (int)(mode & S_IFMT));
2610 ret = -EOPNOTSUPP;
2611 goto out;
2612 }
2613
2614 ret = begin_cmd(sctx, cmd);
2615 if (ret < 0)
2616 goto out;
2617
2618 ret = gen_unique_name(sctx, ino, gen, p);
2619 if (ret < 0)
2620 goto out;
2621
2622 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
2623 TLV_PUT_U64(sctx, BTRFS_SEND_A_INO, ino);
2624
2625 if (S_ISLNK(mode)) {
2626 fs_path_reset(p);
2627 ret = read_symlink(sctx->send_root, ino, p);
2628 if (ret < 0)
2629 goto out;
2630 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH_LINK, p);
2631 } else if (S_ISCHR(mode) || S_ISBLK(mode) ||
2632 S_ISFIFO(mode) || S_ISSOCK(mode)) {
2633 TLV_PUT_U64(sctx, BTRFS_SEND_A_RDEV, new_encode_dev(rdev));
2634 TLV_PUT_U64(sctx, BTRFS_SEND_A_MODE, mode);
2635 }
2636
2637 ret = send_cmd(sctx);
2638 if (ret < 0)
2639 goto out;
2640
2641
2642tlv_put_failure:
2643out:
2644 fs_path_free(p);
2645 return ret;
2646}
2647
2648
2649
2650
2651
2652
2653static int did_create_dir(struct send_ctx *sctx, u64 dir)
2654{
2655 int ret = 0;
2656 struct btrfs_path *path = NULL;
2657 struct btrfs_key key;
2658 struct btrfs_key found_key;
2659 struct btrfs_key di_key;
2660 struct extent_buffer *eb;
2661 struct btrfs_dir_item *di;
2662 int slot;
2663
2664 path = alloc_path_for_send();
2665 if (!path) {
2666 ret = -ENOMEM;
2667 goto out;
2668 }
2669
2670 key.objectid = dir;
2671 key.type = BTRFS_DIR_INDEX_KEY;
2672 key.offset = 0;
2673 ret = btrfs_search_slot(NULL, sctx->send_root, &key, path, 0, 0);
2674 if (ret < 0)
2675 goto out;
2676
2677 while (1) {
2678 eb = path->nodes[0];
2679 slot = path->slots[0];
2680 if (slot >= btrfs_header_nritems(eb)) {
2681 ret = btrfs_next_leaf(sctx->send_root, path);
2682 if (ret < 0) {
2683 goto out;
2684 } else if (ret > 0) {
2685 ret = 0;
2686 break;
2687 }
2688 continue;
2689 }
2690
2691 btrfs_item_key_to_cpu(eb, &found_key, slot);
2692 if (found_key.objectid != key.objectid ||
2693 found_key.type != key.type) {
2694 ret = 0;
2695 goto out;
2696 }
2697
2698 di = btrfs_item_ptr(eb, slot, struct btrfs_dir_item);
2699 btrfs_dir_item_key_to_cpu(eb, di, &di_key);
2700
2701 if (di_key.type != BTRFS_ROOT_ITEM_KEY &&
2702 di_key.objectid < sctx->send_progress) {
2703 ret = 1;
2704 goto out;
2705 }
2706
2707 path->slots[0]++;
2708 }
2709
2710out:
2711 btrfs_free_path(path);
2712 return ret;
2713}
2714
2715
2716
2717
2718
2719
2720
2721static int send_create_inode_if_needed(struct send_ctx *sctx)
2722{
2723 int ret;
2724
2725 if (S_ISDIR(sctx->cur_inode_mode)) {
2726 ret = did_create_dir(sctx, sctx->cur_ino);
2727 if (ret < 0)
2728 goto out;
2729 if (ret) {
2730 ret = 0;
2731 goto out;
2732 }
2733 }
2734
2735 ret = send_create_inode(sctx, sctx->cur_ino);
2736 if (ret < 0)
2737 goto out;
2738
2739out:
2740 return ret;
2741}
2742
2743struct recorded_ref {
2744 struct list_head list;
2745 char *name;
2746 struct fs_path *full_path;
2747 u64 dir;
2748 u64 dir_gen;
2749 int name_len;
2750};
2751
2752static void set_ref_path(struct recorded_ref *ref, struct fs_path *path)
2753{
2754 ref->full_path = path;
2755 ref->name = (char *)kbasename(ref->full_path->start);
2756 ref->name_len = ref->full_path->end - ref->name;
2757}
2758
2759
2760
2761
2762
2763
2764static int __record_ref(struct list_head *head, u64 dir,
2765 u64 dir_gen, struct fs_path *path)
2766{
2767 struct recorded_ref *ref;
2768
2769 ref = kmalloc(sizeof(*ref), GFP_KERNEL);
2770 if (!ref)
2771 return -ENOMEM;
2772
2773 ref->dir = dir;
2774 ref->dir_gen = dir_gen;
2775 set_ref_path(ref, path);
2776 list_add_tail(&ref->list, head);
2777 return 0;
2778}
2779
2780static int dup_ref(struct recorded_ref *ref, struct list_head *list)
2781{
2782 struct recorded_ref *new;
2783
2784 new = kmalloc(sizeof(*ref), GFP_KERNEL);
2785 if (!new)
2786 return -ENOMEM;
2787
2788 new->dir = ref->dir;
2789 new->dir_gen = ref->dir_gen;
2790 new->full_path = NULL;
2791 INIT_LIST_HEAD(&new->list);
2792 list_add_tail(&new->list, list);
2793 return 0;
2794}
2795
2796static void __free_recorded_refs(struct list_head *head)
2797{
2798 struct recorded_ref *cur;
2799
2800 while (!list_empty(head)) {
2801 cur = list_entry(head->next, struct recorded_ref, list);
2802 fs_path_free(cur->full_path);
2803 list_del(&cur->list);
2804 kfree(cur);
2805 }
2806}
2807
2808static void free_recorded_refs(struct send_ctx *sctx)
2809{
2810 __free_recorded_refs(&sctx->new_refs);
2811 __free_recorded_refs(&sctx->deleted_refs);
2812}
2813
2814
2815
2816
2817
2818
2819static int orphanize_inode(struct send_ctx *sctx, u64 ino, u64 gen,
2820 struct fs_path *path)
2821{
2822 int ret;
2823 struct fs_path *orphan;
2824
2825 orphan = fs_path_alloc();
2826 if (!orphan)
2827 return -ENOMEM;
2828
2829 ret = gen_unique_name(sctx, ino, gen, orphan);
2830 if (ret < 0)
2831 goto out;
2832
2833 ret = send_rename(sctx, path, orphan);
2834
2835out:
2836 fs_path_free(orphan);
2837 return ret;
2838}
2839
2840static struct orphan_dir_info *
2841add_orphan_dir_info(struct send_ctx *sctx, u64 dir_ino)
2842{
2843 struct rb_node **p = &sctx->orphan_dirs.rb_node;
2844 struct rb_node *parent = NULL;
2845 struct orphan_dir_info *entry, *odi;
2846
2847 odi = kmalloc(sizeof(*odi), GFP_KERNEL);
2848 if (!odi)
2849 return ERR_PTR(-ENOMEM);
2850 odi->ino = dir_ino;
2851 odi->gen = 0;
2852
2853 while (*p) {
2854 parent = *p;
2855 entry = rb_entry(parent, struct orphan_dir_info, node);
2856 if (dir_ino < entry->ino) {
2857 p = &(*p)->rb_left;
2858 } else if (dir_ino > entry->ino) {
2859 p = &(*p)->rb_right;
2860 } else {
2861 kfree(odi);
2862 return entry;
2863 }
2864 }
2865
2866 rb_link_node(&odi->node, parent, p);
2867 rb_insert_color(&odi->node, &sctx->orphan_dirs);
2868 return odi;
2869}
2870
2871static struct orphan_dir_info *
2872get_orphan_dir_info(struct send_ctx *sctx, u64 dir_ino)
2873{
2874 struct rb_node *n = sctx->orphan_dirs.rb_node;
2875 struct orphan_dir_info *entry;
2876
2877 while (n) {
2878 entry = rb_entry(n, struct orphan_dir_info, node);
2879 if (dir_ino < entry->ino)
2880 n = n->rb_left;
2881 else if (dir_ino > entry->ino)
2882 n = n->rb_right;
2883 else
2884 return entry;
2885 }
2886 return NULL;
2887}
2888
2889static int is_waiting_for_rm(struct send_ctx *sctx, u64 dir_ino)
2890{
2891 struct orphan_dir_info *odi = get_orphan_dir_info(sctx, dir_ino);
2892
2893 return odi != NULL;
2894}
2895
2896static void free_orphan_dir_info(struct send_ctx *sctx,
2897 struct orphan_dir_info *odi)
2898{
2899 if (!odi)
2900 return;
2901 rb_erase(&odi->node, &sctx->orphan_dirs);
2902 kfree(odi);
2903}
2904
2905
2906
2907
2908
2909
2910static int can_rmdir(struct send_ctx *sctx, u64 dir, u64 dir_gen,
2911 u64 send_progress)
2912{
2913 int ret = 0;
2914 struct btrfs_root *root = sctx->parent_root;
2915 struct btrfs_path *path;
2916 struct btrfs_key key;
2917 struct btrfs_key found_key;
2918 struct btrfs_key loc;
2919 struct btrfs_dir_item *di;
2920
2921
2922
2923
2924 if (dir == BTRFS_FIRST_FREE_OBJECTID)
2925 return 0;
2926
2927 path = alloc_path_for_send();
2928 if (!path)
2929 return -ENOMEM;
2930
2931 key.objectid = dir;
2932 key.type = BTRFS_DIR_INDEX_KEY;
2933 key.offset = 0;
2934 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
2935 if (ret < 0)
2936 goto out;
2937
2938 while (1) {
2939 struct waiting_dir_move *dm;
2940
2941 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
2942 ret = btrfs_next_leaf(root, path);
2943 if (ret < 0)
2944 goto out;
2945 else if (ret > 0)
2946 break;
2947 continue;
2948 }
2949 btrfs_item_key_to_cpu(path->nodes[0], &found_key,
2950 path->slots[0]);
2951 if (found_key.objectid != key.objectid ||
2952 found_key.type != key.type)
2953 break;
2954
2955 di = btrfs_item_ptr(path->nodes[0], path->slots[0],
2956 struct btrfs_dir_item);
2957 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &loc);
2958
2959 dm = get_waiting_dir_move(sctx, loc.objectid);
2960 if (dm) {
2961 struct orphan_dir_info *odi;
2962
2963 odi = add_orphan_dir_info(sctx, dir);
2964 if (IS_ERR(odi)) {
2965 ret = PTR_ERR(odi);
2966 goto out;
2967 }
2968 odi->gen = dir_gen;
2969 dm->rmdir_ino = dir;
2970 ret = 0;
2971 goto out;
2972 }
2973
2974 if (loc.objectid > send_progress) {
2975 struct orphan_dir_info *odi;
2976
2977 odi = get_orphan_dir_info(sctx, dir);
2978 free_orphan_dir_info(sctx, odi);
2979 ret = 0;
2980 goto out;
2981 }
2982
2983 path->slots[0]++;
2984 }
2985
2986 ret = 1;
2987
2988out:
2989 btrfs_free_path(path);
2990 return ret;
2991}
2992
2993static int is_waiting_for_move(struct send_ctx *sctx, u64 ino)
2994{
2995 struct waiting_dir_move *entry = get_waiting_dir_move(sctx, ino);
2996
2997 return entry != NULL;
2998}
2999
3000static int add_waiting_dir_move(struct send_ctx *sctx, u64 ino, bool orphanized)
3001{
3002 struct rb_node **p = &sctx->waiting_dir_moves.rb_node;
3003 struct rb_node *parent = NULL;
3004 struct waiting_dir_move *entry, *dm;
3005
3006 dm = kmalloc(sizeof(*dm), GFP_KERNEL);
3007 if (!dm)
3008 return -ENOMEM;
3009 dm->ino = ino;
3010 dm->rmdir_ino = 0;
3011 dm->orphanized = orphanized;
3012
3013 while (*p) {
3014 parent = *p;
3015 entry = rb_entry(parent, struct waiting_dir_move, node);
3016 if (ino < entry->ino) {
3017 p = &(*p)->rb_left;
3018 } else if (ino > entry->ino) {
3019 p = &(*p)->rb_right;
3020 } else {
3021 kfree(dm);
3022 return -EEXIST;
3023 }
3024 }
3025
3026 rb_link_node(&dm->node, parent, p);
3027 rb_insert_color(&dm->node, &sctx->waiting_dir_moves);
3028 return 0;
3029}
3030
3031static struct waiting_dir_move *
3032get_waiting_dir_move(struct send_ctx *sctx, u64 ino)
3033{
3034 struct rb_node *n = sctx->waiting_dir_moves.rb_node;
3035 struct waiting_dir_move *entry;
3036
3037 while (n) {
3038 entry = rb_entry(n, struct waiting_dir_move, node);
3039 if (ino < entry->ino)
3040 n = n->rb_left;
3041 else if (ino > entry->ino)
3042 n = n->rb_right;
3043 else
3044 return entry;
3045 }
3046 return NULL;
3047}
3048
3049static void free_waiting_dir_move(struct send_ctx *sctx,
3050 struct waiting_dir_move *dm)
3051{
3052 if (!dm)
3053 return;
3054 rb_erase(&dm->node, &sctx->waiting_dir_moves);
3055 kfree(dm);
3056}
3057
3058static int add_pending_dir_move(struct send_ctx *sctx,
3059 u64 ino,
3060 u64 ino_gen,
3061 u64 parent_ino,
3062 struct list_head *new_refs,
3063 struct list_head *deleted_refs,
3064 const bool is_orphan)
3065{
3066 struct rb_node **p = &sctx->pending_dir_moves.rb_node;
3067 struct rb_node *parent = NULL;
3068 struct pending_dir_move *entry = NULL, *pm;
3069 struct recorded_ref *cur;
3070 int exists = 0;
3071 int ret;
3072
3073 pm = kmalloc(sizeof(*pm), GFP_KERNEL);
3074 if (!pm)
3075 return -ENOMEM;
3076 pm->parent_ino = parent_ino;
3077 pm->ino = ino;
3078 pm->gen = ino_gen;
3079 INIT_LIST_HEAD(&pm->list);
3080 INIT_LIST_HEAD(&pm->update_refs);
3081 RB_CLEAR_NODE(&pm->node);
3082
3083 while (*p) {
3084 parent = *p;
3085 entry = rb_entry(parent, struct pending_dir_move, node);
3086 if (parent_ino < entry->parent_ino) {
3087 p = &(*p)->rb_left;
3088 } else if (parent_ino > entry->parent_ino) {
3089 p = &(*p)->rb_right;
3090 } else {
3091 exists = 1;
3092 break;
3093 }
3094 }
3095
3096 list_for_each_entry(cur, deleted_refs, list) {
3097 ret = dup_ref(cur, &pm->update_refs);
3098 if (ret < 0)
3099 goto out;
3100 }
3101 list_for_each_entry(cur, new_refs, list) {
3102 ret = dup_ref(cur, &pm->update_refs);
3103 if (ret < 0)
3104 goto out;
3105 }
3106
3107 ret = add_waiting_dir_move(sctx, pm->ino, is_orphan);
3108 if (ret)
3109 goto out;
3110
3111 if (exists) {
3112 list_add_tail(&pm->list, &entry->list);
3113 } else {
3114 rb_link_node(&pm->node, parent, p);
3115 rb_insert_color(&pm->node, &sctx->pending_dir_moves);
3116 }
3117 ret = 0;
3118out:
3119 if (ret) {
3120 __free_recorded_refs(&pm->update_refs);
3121 kfree(pm);
3122 }
3123 return ret;
3124}
3125
3126static struct pending_dir_move *get_pending_dir_moves(struct send_ctx *sctx,
3127 u64 parent_ino)
3128{
3129 struct rb_node *n = sctx->pending_dir_moves.rb_node;
3130 struct pending_dir_move *entry;
3131
3132 while (n) {
3133 entry = rb_entry(n, struct pending_dir_move, node);
3134 if (parent_ino < entry->parent_ino)
3135 n = n->rb_left;
3136 else if (parent_ino > entry->parent_ino)
3137 n = n->rb_right;
3138 else
3139 return entry;
3140 }
3141 return NULL;
3142}
3143
3144static int path_loop(struct send_ctx *sctx, struct fs_path *name,
3145 u64 ino, u64 gen, u64 *ancestor_ino)
3146{
3147 int ret = 0;
3148 u64 parent_inode = 0;
3149 u64 parent_gen = 0;
3150 u64 start_ino = ino;
3151
3152 *ancestor_ino = 0;
3153 while (ino != BTRFS_FIRST_FREE_OBJECTID) {
3154 fs_path_reset(name);
3155
3156 if (is_waiting_for_rm(sctx, ino))
3157 break;
3158 if (is_waiting_for_move(sctx, ino)) {
3159 if (*ancestor_ino == 0)
3160 *ancestor_ino = ino;
3161 ret = get_first_ref(sctx->parent_root, ino,
3162 &parent_inode, &parent_gen, name);
3163 } else {
3164 ret = __get_cur_name_and_parent(sctx, ino, gen,
3165 &parent_inode,
3166 &parent_gen, name);
3167 if (ret > 0) {
3168 ret = 0;
3169 break;
3170 }
3171 }
3172 if (ret < 0)
3173 break;
3174 if (parent_inode == start_ino) {
3175 ret = 1;
3176 if (*ancestor_ino == 0)
3177 *ancestor_ino = ino;
3178 break;
3179 }
3180 ino = parent_inode;
3181 gen = parent_gen;
3182 }
3183 return ret;
3184}
3185
3186static int apply_dir_move(struct send_ctx *sctx, struct pending_dir_move *pm)
3187{
3188 struct fs_path *from_path = NULL;
3189 struct fs_path *to_path = NULL;
3190 struct fs_path *name = NULL;
3191 u64 orig_progress = sctx->send_progress;
3192 struct recorded_ref *cur;
3193 u64 parent_ino, parent_gen;
3194 struct waiting_dir_move *dm = NULL;
3195 u64 rmdir_ino = 0;
3196 u64 ancestor;
3197 bool is_orphan;
3198 int ret;
3199
3200 name = fs_path_alloc();
3201 from_path = fs_path_alloc();
3202 if (!name || !from_path) {
3203 ret = -ENOMEM;
3204 goto out;
3205 }
3206
3207 dm = get_waiting_dir_move(sctx, pm->ino);
3208 ASSERT(dm);
3209 rmdir_ino = dm->rmdir_ino;
3210 is_orphan = dm->orphanized;
3211 free_waiting_dir_move(sctx, dm);
3212
3213 if (is_orphan) {
3214 ret = gen_unique_name(sctx, pm->ino,
3215 pm->gen, from_path);
3216 } else {
3217 ret = get_first_ref(sctx->parent_root, pm->ino,
3218 &parent_ino, &parent_gen, name);
3219 if (ret < 0)
3220 goto out;
3221 ret = get_cur_path(sctx, parent_ino, parent_gen,
3222 from_path);
3223 if (ret < 0)
3224 goto out;
3225 ret = fs_path_add_path(from_path, name);
3226 }
3227 if (ret < 0)
3228 goto out;
3229
3230 sctx->send_progress = sctx->cur_ino + 1;
3231 ret = path_loop(sctx, name, pm->ino, pm->gen, &ancestor);
3232 if (ret < 0)
3233 goto out;
3234 if (ret) {
3235 LIST_HEAD(deleted_refs);
3236 ASSERT(ancestor > BTRFS_FIRST_FREE_OBJECTID);
3237 ret = add_pending_dir_move(sctx, pm->ino, pm->gen, ancestor,
3238 &pm->update_refs, &deleted_refs,
3239 is_orphan);
3240 if (ret < 0)
3241 goto out;
3242 if (rmdir_ino) {
3243 dm = get_waiting_dir_move(sctx, pm->ino);
3244 ASSERT(dm);
3245 dm->rmdir_ino = rmdir_ino;
3246 }
3247 goto out;
3248 }
3249 fs_path_reset(name);
3250 to_path = name;
3251 name = NULL;
3252 ret = get_cur_path(sctx, pm->ino, pm->gen, to_path);
3253 if (ret < 0)
3254 goto out;
3255
3256 ret = send_rename(sctx, from_path, to_path);
3257 if (ret < 0)
3258 goto out;
3259
3260 if (rmdir_ino) {
3261 struct orphan_dir_info *odi;
3262
3263 odi = get_orphan_dir_info(sctx, rmdir_ino);
3264 if (!odi) {
3265
3266 goto finish;
3267 }
3268 ret = can_rmdir(sctx, rmdir_ino, odi->gen, sctx->cur_ino);
3269 if (ret < 0)
3270 goto out;
3271 if (!ret)
3272 goto finish;
3273
3274 name = fs_path_alloc();
3275 if (!name) {
3276 ret = -ENOMEM;
3277 goto out;
3278 }
3279 ret = get_cur_path(sctx, rmdir_ino, odi->gen, name);
3280 if (ret < 0)
3281 goto out;
3282 ret = send_rmdir(sctx, name);
3283 if (ret < 0)
3284 goto out;
3285 free_orphan_dir_info(sctx, odi);
3286 }
3287
3288finish:
3289 ret = send_utimes(sctx, pm->ino, pm->gen);
3290 if (ret < 0)
3291 goto out;
3292
3293
3294
3295
3296
3297 list_for_each_entry(cur, &pm->update_refs, list) {
3298
3299
3300
3301 ret = get_inode_info(sctx->send_root, cur->dir, NULL,
3302 NULL, NULL, NULL, NULL, NULL);
3303 if (ret == -ENOENT) {
3304 ret = 0;
3305 continue;
3306 }
3307 if (ret < 0)
3308 goto out;
3309
3310 ret = send_utimes(sctx, cur->dir, cur->dir_gen);
3311 if (ret < 0)
3312 goto out;
3313 }
3314
3315out:
3316 fs_path_free(name);
3317 fs_path_free(from_path);
3318 fs_path_free(to_path);
3319 sctx->send_progress = orig_progress;
3320
3321 return ret;
3322}
3323
3324static void free_pending_move(struct send_ctx *sctx, struct pending_dir_move *m)
3325{
3326 if (!list_empty(&m->list))
3327 list_del(&m->list);
3328 if (!RB_EMPTY_NODE(&m->node))
3329 rb_erase(&m->node, &sctx->pending_dir_moves);
3330 __free_recorded_refs(&m->update_refs);
3331 kfree(m);
3332}
3333
3334static void tail_append_pending_moves(struct pending_dir_move *moves,
3335 struct list_head *stack)
3336{
3337 if (list_empty(&moves->list)) {
3338 list_add_tail(&moves->list, stack);
3339 } else {
3340 LIST_HEAD(list);
3341 list_splice_init(&moves->list, &list);
3342 list_add_tail(&moves->list, stack);
3343 list_splice_tail(&list, stack);
3344 }
3345}
3346
3347static int apply_children_dir_moves(struct send_ctx *sctx)
3348{
3349 struct pending_dir_move *pm;
3350 struct list_head stack;
3351 u64 parent_ino = sctx->cur_ino;
3352 int ret = 0;
3353
3354 pm = get_pending_dir_moves(sctx, parent_ino);
3355 if (!pm)
3356 return 0;
3357
3358 INIT_LIST_HEAD(&stack);
3359 tail_append_pending_moves(pm, &stack);
3360
3361 while (!list_empty(&stack)) {
3362 pm = list_first_entry(&stack, struct pending_dir_move, list);
3363 parent_ino = pm->ino;
3364 ret = apply_dir_move(sctx, pm);
3365 free_pending_move(sctx, pm);
3366 if (ret)
3367 goto out;
3368 pm = get_pending_dir_moves(sctx, parent_ino);
3369 if (pm)
3370 tail_append_pending_moves(pm, &stack);
3371 }
3372 return 0;
3373
3374out:
3375 while (!list_empty(&stack)) {
3376 pm = list_first_entry(&stack, struct pending_dir_move, list);
3377 free_pending_move(sctx, pm);
3378 }
3379 return ret;
3380}
3381
3382
3383
3384
3385
3386
3387
3388
3389
3390
3391
3392
3393
3394
3395
3396
3397
3398
3399
3400
3401
3402
3403
3404
3405
3406
3407
3408
3409
3410
3411
3412
3413
3414
3415
3416
3417
3418static int wait_for_dest_dir_move(struct send_ctx *sctx,
3419 struct recorded_ref *parent_ref,
3420 const bool is_orphan)
3421{
3422 struct btrfs_fs_info *fs_info = sctx->parent_root->fs_info;
3423 struct btrfs_path *path;
3424 struct btrfs_key key;
3425 struct btrfs_key di_key;
3426 struct btrfs_dir_item *di;
3427 u64 left_gen;
3428 u64 right_gen;
3429 int ret = 0;
3430 struct waiting_dir_move *wdm;
3431
3432 if (RB_EMPTY_ROOT(&sctx->waiting_dir_moves))
3433 return 0;
3434
3435 path = alloc_path_for_send();
3436 if (!path)
3437 return -ENOMEM;
3438
3439 key.objectid = parent_ref->dir;
3440 key.type = BTRFS_DIR_ITEM_KEY;
3441 key.offset = btrfs_name_hash(parent_ref->name, parent_ref->name_len);
3442
3443 ret = btrfs_search_slot(NULL, sctx->parent_root, &key, path, 0, 0);
3444 if (ret < 0) {
3445 goto out;
3446 } else if (ret > 0) {
3447 ret = 0;
3448 goto out;
3449 }
3450
3451 di = btrfs_match_dir_item_name(fs_info, path, parent_ref->name,
3452 parent_ref->name_len);
3453 if (!di) {
3454 ret = 0;
3455 goto out;
3456 }
3457
3458
3459
3460
3461
3462
3463
3464
3465 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &di_key);
3466 if (di_key.type != BTRFS_INODE_ITEM_KEY) {
3467 ret = 0;
3468 goto out;
3469 }
3470
3471 ret = get_inode_info(sctx->parent_root, di_key.objectid, NULL,
3472 &left_gen, NULL, NULL, NULL, NULL);
3473 if (ret < 0)
3474 goto out;
3475 ret = get_inode_info(sctx->send_root, di_key.objectid, NULL,
3476 &right_gen, NULL, NULL, NULL, NULL);
3477 if (ret < 0) {
3478 if (ret == -ENOENT)
3479 ret = 0;
3480 goto out;
3481 }
3482
3483
3484 if (right_gen != left_gen) {
3485 ret = 0;
3486 goto out;
3487 }
3488
3489 wdm = get_waiting_dir_move(sctx, di_key.objectid);
3490 if (wdm && !wdm->orphanized) {
3491 ret = add_pending_dir_move(sctx,
3492 sctx->cur_ino,
3493 sctx->cur_inode_gen,
3494 di_key.objectid,
3495 &sctx->new_refs,
3496 &sctx->deleted_refs,
3497 is_orphan);
3498 if (!ret)
3499 ret = 1;
3500 }
3501out:
3502 btrfs_free_path(path);
3503 return ret;
3504}
3505
3506
3507
3508
3509
3510static int check_ino_in_path(struct btrfs_root *root,
3511 const u64 ino1,
3512 const u64 ino1_gen,
3513 const u64 ino2,
3514 const u64 ino2_gen,
3515 struct fs_path *fs_path)
3516{
3517 u64 ino = ino2;
3518
3519 if (ino1 == ino2)
3520 return ino1_gen == ino2_gen;
3521
3522 while (ino > BTRFS_FIRST_FREE_OBJECTID) {
3523 u64 parent;
3524 u64 parent_gen;
3525 int ret;
3526
3527 fs_path_reset(fs_path);
3528 ret = get_first_ref(root, ino, &parent, &parent_gen, fs_path);
3529 if (ret < 0)
3530 return ret;
3531 if (parent == ino1)
3532 return parent_gen == ino1_gen;
3533 ino = parent;
3534 }
3535 return 0;
3536}
3537
3538
3539
3540
3541
3542
3543static int is_ancestor(struct btrfs_root *root,
3544 const u64 ino1,
3545 const u64 ino1_gen,
3546 const u64 ino2,
3547 struct fs_path *fs_path)
3548{
3549 bool free_fs_path = false;
3550 int ret = 0;
3551 struct btrfs_path *path = NULL;
3552 struct btrfs_key key;
3553
3554 if (!fs_path) {
3555 fs_path = fs_path_alloc();
3556 if (!fs_path)
3557 return -ENOMEM;
3558 free_fs_path = true;
3559 }
3560
3561 path = alloc_path_for_send();
3562 if (!path) {
3563 ret = -ENOMEM;
3564 goto out;
3565 }
3566
3567 key.objectid = ino2;
3568 key.type = BTRFS_INODE_REF_KEY;
3569 key.offset = 0;
3570
3571 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
3572 if (ret < 0)
3573 goto out;
3574
3575 while (true) {
3576 struct extent_buffer *leaf = path->nodes[0];
3577 int slot = path->slots[0];
3578 u32 cur_offset = 0;
3579 u32 item_size;
3580
3581 if (slot >= btrfs_header_nritems(leaf)) {
3582 ret = btrfs_next_leaf(root, path);
3583 if (ret < 0)
3584 goto out;
3585 if (ret > 0)
3586 break;
3587 continue;
3588 }
3589
3590 btrfs_item_key_to_cpu(leaf, &key, slot);
3591 if (key.objectid != ino2)
3592 break;
3593 if (key.type != BTRFS_INODE_REF_KEY &&
3594 key.type != BTRFS_INODE_EXTREF_KEY)
3595 break;
3596
3597 item_size = btrfs_item_size_nr(leaf, slot);
3598 while (cur_offset < item_size) {
3599 u64 parent;
3600 u64 parent_gen;
3601
3602 if (key.type == BTRFS_INODE_EXTREF_KEY) {
3603 unsigned long ptr;
3604 struct btrfs_inode_extref *extref;
3605
3606 ptr = btrfs_item_ptr_offset(leaf, slot);
3607 extref = (struct btrfs_inode_extref *)
3608 (ptr + cur_offset);
3609 parent = btrfs_inode_extref_parent(leaf,
3610 extref);
3611 cur_offset += sizeof(*extref);
3612 cur_offset += btrfs_inode_extref_name_len(leaf,
3613 extref);
3614 } else {
3615 parent = key.offset;
3616 cur_offset = item_size;
3617 }
3618
3619 ret = get_inode_info(root, parent, NULL, &parent_gen,
3620 NULL, NULL, NULL, NULL);
3621 if (ret < 0)
3622 goto out;
3623 ret = check_ino_in_path(root, ino1, ino1_gen,
3624 parent, parent_gen, fs_path);
3625 if (ret)
3626 goto out;
3627 }
3628 path->slots[0]++;
3629 }
3630 ret = 0;
3631 out:
3632 btrfs_free_path(path);
3633 if (free_fs_path)
3634 fs_path_free(fs_path);
3635 return ret;
3636}
3637
3638static int wait_for_parent_move(struct send_ctx *sctx,
3639 struct recorded_ref *parent_ref,
3640 const bool is_orphan)
3641{
3642 int ret = 0;
3643 u64 ino = parent_ref->dir;
3644 u64 ino_gen = parent_ref->dir_gen;
3645 u64 parent_ino_before, parent_ino_after;
3646 struct fs_path *path_before = NULL;
3647 struct fs_path *path_after = NULL;
3648 int len1, len2;
3649
3650 path_after = fs_path_alloc();
3651 path_before = fs_path_alloc();
3652 if (!path_after || !path_before) {
3653 ret = -ENOMEM;
3654 goto out;
3655 }
3656
3657
3658
3659
3660
3661
3662
3663
3664 while (ino > BTRFS_FIRST_FREE_OBJECTID) {
3665 u64 parent_ino_after_gen;
3666
3667 if (is_waiting_for_move(sctx, ino)) {
3668
3669
3670
3671
3672
3673
3674
3675
3676
3677
3678 ret = is_ancestor(sctx->parent_root,
3679 sctx->cur_ino, sctx->cur_inode_gen,
3680 ino, path_before);
3681 if (ret)
3682 break;
3683 }
3684
3685 fs_path_reset(path_before);
3686 fs_path_reset(path_after);
3687
3688 ret = get_first_ref(sctx->send_root, ino, &parent_ino_after,
3689 &parent_ino_after_gen, path_after);
3690 if (ret < 0)
3691 goto out;
3692 ret = get_first_ref(sctx->parent_root, ino, &parent_ino_before,
3693 NULL, path_before);
3694 if (ret < 0 && ret != -ENOENT) {
3695 goto out;
3696 } else if (ret == -ENOENT) {
3697 ret = 0;
3698 break;
3699 }
3700
3701 len1 = fs_path_len(path_before);
3702 len2 = fs_path_len(path_after);
3703 if (ino > sctx->cur_ino &&
3704 (parent_ino_before != parent_ino_after || len1 != len2 ||
3705 memcmp(path_before->start, path_after->start, len1))) {
3706 u64 parent_ino_gen;
3707
3708 ret = get_inode_info(sctx->parent_root, ino, NULL,
3709 &parent_ino_gen, NULL, NULL, NULL,
3710 NULL);
3711 if (ret < 0)
3712 goto out;
3713 if (ino_gen == parent_ino_gen) {
3714 ret = 1;
3715 break;
3716 }
3717 }
3718 ino = parent_ino_after;
3719 ino_gen = parent_ino_after_gen;
3720 }
3721
3722out:
3723 fs_path_free(path_before);
3724 fs_path_free(path_after);
3725
3726 if (ret == 1) {
3727 ret = add_pending_dir_move(sctx,
3728 sctx->cur_ino,
3729 sctx->cur_inode_gen,
3730 ino,
3731 &sctx->new_refs,
3732 &sctx->deleted_refs,
3733 is_orphan);
3734 if (!ret)
3735 ret = 1;
3736 }
3737
3738 return ret;
3739}
3740
3741static int update_ref_path(struct send_ctx *sctx, struct recorded_ref *ref)
3742{
3743 int ret;
3744 struct fs_path *new_path;
3745
3746
3747
3748
3749
3750 new_path = fs_path_alloc();
3751 if (!new_path)
3752 return -ENOMEM;
3753
3754 ret = get_cur_path(sctx, ref->dir, ref->dir_gen, new_path);
3755 if (ret < 0) {
3756 fs_path_free(new_path);
3757 return ret;
3758 }
3759 ret = fs_path_add(new_path, ref->name, ref->name_len);
3760 if (ret < 0) {
3761 fs_path_free(new_path);
3762 return ret;
3763 }
3764
3765 fs_path_free(ref->full_path);
3766 set_ref_path(ref, new_path);
3767
3768 return 0;
3769}
3770
3771
3772
3773
3774static int process_recorded_refs(struct send_ctx *sctx, int *pending_move)
3775{
3776 struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;
3777 int ret = 0;
3778 struct recorded_ref *cur;
3779 struct recorded_ref *cur2;
3780 struct list_head check_dirs;
3781 struct fs_path *valid_path = NULL;
3782 u64 ow_inode = 0;
3783 u64 ow_gen;
3784 u64 ow_mode;
3785 int did_overwrite = 0;
3786 int is_orphan = 0;
3787 u64 last_dir_ino_rm = 0;
3788 bool can_rename = true;
3789 bool orphanized_dir = false;
3790 bool orphanized_ancestor = false;
3791
3792 btrfs_debug(fs_info, "process_recorded_refs %llu", sctx->cur_ino);
3793
3794
3795
3796
3797
3798 BUG_ON(sctx->cur_ino <= BTRFS_FIRST_FREE_OBJECTID);
3799 INIT_LIST_HEAD(&check_dirs);
3800
3801 valid_path = fs_path_alloc();
3802 if (!valid_path) {
3803 ret = -ENOMEM;
3804 goto out;
3805 }
3806
3807
3808
3809
3810
3811
3812
3813
3814
3815
3816
3817
3818 if (!sctx->cur_inode_new) {
3819 ret = did_overwrite_first_ref(sctx, sctx->cur_ino,
3820 sctx->cur_inode_gen);
3821 if (ret < 0)
3822 goto out;
3823 if (ret)
3824 did_overwrite = 1;
3825 }
3826 if (sctx->cur_inode_new || did_overwrite) {
3827 ret = gen_unique_name(sctx, sctx->cur_ino,
3828 sctx->cur_inode_gen, valid_path);
3829 if (ret < 0)
3830 goto out;
3831 is_orphan = 1;
3832 } else {
3833 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen,
3834 valid_path);
3835 if (ret < 0)
3836 goto out;
3837 }
3838
3839 list_for_each_entry(cur, &sctx->new_refs, list) {
3840
3841
3842
3843
3844
3845
3846
3847 ret = get_cur_inode_state(sctx, cur->dir, cur->dir_gen);
3848 if (ret < 0)
3849 goto out;
3850 if (ret == inode_state_will_create) {
3851 ret = 0;
3852
3853
3854
3855
3856 list_for_each_entry(cur2, &sctx->new_refs, list) {
3857 if (cur == cur2)
3858 break;
3859 if (cur2->dir == cur->dir) {
3860 ret = 1;
3861 break;
3862 }
3863 }
3864
3865
3866
3867
3868
3869 if (!ret)
3870 ret = did_create_dir(sctx, cur->dir);
3871 if (ret < 0)
3872 goto out;
3873 if (!ret) {
3874 ret = send_create_inode(sctx, cur->dir);
3875 if (ret < 0)
3876 goto out;
3877 }
3878 }
3879
3880
3881
3882
3883
3884
3885
3886 ret = will_overwrite_ref(sctx, cur->dir, cur->dir_gen,
3887 cur->name, cur->name_len,
3888 &ow_inode, &ow_gen, &ow_mode);
3889 if (ret < 0)
3890 goto out;
3891 if (ret) {
3892 ret = is_first_ref(sctx->parent_root,
3893 ow_inode, cur->dir, cur->name,
3894 cur->name_len);
3895 if (ret < 0)
3896 goto out;
3897 if (ret) {
3898 struct name_cache_entry *nce;
3899 struct waiting_dir_move *wdm;
3900
3901 ret = orphanize_inode(sctx, ow_inode, ow_gen,
3902 cur->full_path);
3903 if (ret < 0)
3904 goto out;
3905 if (S_ISDIR(ow_mode))
3906 orphanized_dir = true;
3907
3908
3909
3910
3911
3912
3913
3914 if (is_waiting_for_move(sctx, ow_inode)) {
3915 wdm = get_waiting_dir_move(sctx,
3916 ow_inode);
3917 ASSERT(wdm);
3918 wdm->orphanized = true;
3919 }
3920
3921
3922
3923
3924
3925
3926
3927
3928
3929
3930
3931 nce = name_cache_search(sctx, ow_inode, ow_gen);
3932 if (nce) {
3933 name_cache_delete(sctx, nce);
3934 kfree(nce);
3935 }
3936
3937
3938
3939
3940
3941
3942
3943
3944 ret = is_ancestor(sctx->parent_root,
3945 ow_inode, ow_gen,
3946 sctx->cur_ino, NULL);
3947 if (ret > 0) {
3948 orphanized_ancestor = true;
3949 fs_path_reset(valid_path);
3950 ret = get_cur_path(sctx, sctx->cur_ino,
3951 sctx->cur_inode_gen,
3952 valid_path);
3953 }
3954 if (ret < 0)
3955 goto out;
3956 } else {
3957 ret = send_unlink(sctx, cur->full_path);
3958 if (ret < 0)
3959 goto out;
3960 }
3961 }
3962
3963 if (S_ISDIR(sctx->cur_inode_mode) && sctx->parent_root) {
3964 ret = wait_for_dest_dir_move(sctx, cur, is_orphan);
3965 if (ret < 0)
3966 goto out;
3967 if (ret == 1) {
3968 can_rename = false;
3969 *pending_move = 1;
3970 }
3971 }
3972
3973 if (S_ISDIR(sctx->cur_inode_mode) && sctx->parent_root &&
3974 can_rename) {
3975 ret = wait_for_parent_move(sctx, cur, is_orphan);
3976 if (ret < 0)
3977 goto out;
3978 if (ret == 1) {
3979 can_rename = false;
3980 *pending_move = 1;
3981 }
3982 }
3983
3984
3985
3986
3987
3988
3989 if (is_orphan && can_rename) {
3990 ret = send_rename(sctx, valid_path, cur->full_path);
3991 if (ret < 0)
3992 goto out;
3993 is_orphan = 0;
3994 ret = fs_path_copy(valid_path, cur->full_path);
3995 if (ret < 0)
3996 goto out;
3997 } else if (can_rename) {
3998 if (S_ISDIR(sctx->cur_inode_mode)) {
3999
4000
4001
4002
4003
4004 ret = send_rename(sctx, valid_path,
4005 cur->full_path);
4006 if (!ret)
4007 ret = fs_path_copy(valid_path,
4008 cur->full_path);
4009 if (ret < 0)
4010 goto out;
4011 } else {
4012
4013
4014
4015
4016
4017
4018
4019 if (orphanized_dir) {
4020 ret = update_ref_path(sctx, cur);
4021 if (ret < 0)
4022 goto out;
4023 }
4024 ret = send_link(sctx, cur->full_path,
4025 valid_path);
4026 if (ret < 0)
4027 goto out;
4028 }
4029 }
4030 ret = dup_ref(cur, &check_dirs);
4031 if (ret < 0)
4032 goto out;
4033 }
4034
4035 if (S_ISDIR(sctx->cur_inode_mode) && sctx->cur_inode_deleted) {
4036
4037
4038
4039
4040
4041
4042 ret = can_rmdir(sctx, sctx->cur_ino, sctx->cur_inode_gen,
4043 sctx->cur_ino);
4044 if (ret < 0)
4045 goto out;
4046 if (ret) {
4047 ret = send_rmdir(sctx, valid_path);
4048 if (ret < 0)
4049 goto out;
4050 } else if (!is_orphan) {
4051 ret = orphanize_inode(sctx, sctx->cur_ino,
4052 sctx->cur_inode_gen, valid_path);
4053 if (ret < 0)
4054 goto out;
4055 is_orphan = 1;
4056 }
4057
4058 list_for_each_entry(cur, &sctx->deleted_refs, list) {
4059 ret = dup_ref(cur, &check_dirs);
4060 if (ret < 0)
4061 goto out;
4062 }
4063 } else if (S_ISDIR(sctx->cur_inode_mode) &&
4064 !list_empty(&sctx->deleted_refs)) {
4065
4066
4067
4068 cur = list_entry(sctx->deleted_refs.next, struct recorded_ref,
4069 list);
4070 ret = dup_ref(cur, &check_dirs);
4071 if (ret < 0)
4072 goto out;
4073 } else if (!S_ISDIR(sctx->cur_inode_mode)) {
4074
4075
4076
4077
4078
4079 list_for_each_entry(cur, &sctx->deleted_refs, list) {
4080 ret = did_overwrite_ref(sctx, cur->dir, cur->dir_gen,
4081 sctx->cur_ino, sctx->cur_inode_gen,
4082 cur->name, cur->name_len);
4083 if (ret < 0)
4084 goto out;
4085 if (!ret) {
4086
4087
4088
4089
4090
4091
4092
4093 if (orphanized_ancestor) {
4094 ret = update_ref_path(sctx, cur);
4095 if (ret < 0)
4096 goto out;
4097 }
4098 ret = send_unlink(sctx, cur->full_path);
4099 if (ret < 0)
4100 goto out;
4101 }
4102 ret = dup_ref(cur, &check_dirs);
4103 if (ret < 0)
4104 goto out;
4105 }
4106
4107
4108
4109
4110
4111
4112
4113
4114 if (is_orphan) {
4115 ret = send_unlink(sctx, valid_path);
4116 if (ret < 0)
4117 goto out;
4118 }
4119 }
4120
4121
4122
4123
4124
4125
4126
4127 list_for_each_entry(cur, &check_dirs, list) {
4128
4129
4130
4131
4132
4133 if (cur->dir > sctx->cur_ino)
4134 continue;
4135
4136 ret = get_cur_inode_state(sctx, cur->dir, cur->dir_gen);
4137 if (ret < 0)
4138 goto out;
4139
4140 if (ret == inode_state_did_create ||
4141 ret == inode_state_no_change) {
4142
4143 ret = send_utimes(sctx, cur->dir, cur->dir_gen);
4144 if (ret < 0)
4145 goto out;
4146 } else if (ret == inode_state_did_delete &&
4147 cur->dir != last_dir_ino_rm) {
4148 ret = can_rmdir(sctx, cur->dir, cur->dir_gen,
4149 sctx->cur_ino);
4150 if (ret < 0)
4151 goto out;
4152 if (ret) {
4153 ret = get_cur_path(sctx, cur->dir,
4154 cur->dir_gen, valid_path);
4155 if (ret < 0)
4156 goto out;
4157 ret = send_rmdir(sctx, valid_path);
4158 if (ret < 0)
4159 goto out;
4160 last_dir_ino_rm = cur->dir;
4161 }
4162 }
4163 }
4164
4165 ret = 0;
4166
4167out:
4168 __free_recorded_refs(&check_dirs);
4169 free_recorded_refs(sctx);
4170 fs_path_free(valid_path);
4171 return ret;
4172}
4173
4174static int record_ref(struct btrfs_root *root, u64 dir, struct fs_path *name,
4175 void *ctx, struct list_head *refs)
4176{
4177 int ret = 0;
4178 struct send_ctx *sctx = ctx;
4179 struct fs_path *p;
4180 u64 gen;
4181
4182 p = fs_path_alloc();
4183 if (!p)
4184 return -ENOMEM;
4185
4186 ret = get_inode_info(root, dir, NULL, &gen, NULL, NULL,
4187 NULL, NULL);
4188 if (ret < 0)
4189 goto out;
4190
4191 ret = get_cur_path(sctx, dir, gen, p);
4192 if (ret < 0)
4193 goto out;
4194 ret = fs_path_add_path(p, name);
4195 if (ret < 0)
4196 goto out;
4197
4198 ret = __record_ref(refs, dir, gen, p);
4199
4200out:
4201 if (ret)
4202 fs_path_free(p);
4203 return ret;
4204}
4205
4206static int __record_new_ref(int num, u64 dir, int index,
4207 struct fs_path *name,
4208 void *ctx)
4209{
4210 struct send_ctx *sctx = ctx;
4211 return record_ref(sctx->send_root, dir, name, ctx, &sctx->new_refs);
4212}
4213
4214
4215static int __record_deleted_ref(int num, u64 dir, int index,
4216 struct fs_path *name,
4217 void *ctx)
4218{
4219 struct send_ctx *sctx = ctx;
4220 return record_ref(sctx->parent_root, dir, name, ctx,
4221 &sctx->deleted_refs);
4222}
4223
4224static int record_new_ref(struct send_ctx *sctx)
4225{
4226 int ret;
4227
4228 ret = iterate_inode_ref(sctx->send_root, sctx->left_path,
4229 sctx->cmp_key, 0, __record_new_ref, sctx);
4230 if (ret < 0)
4231 goto out;
4232 ret = 0;
4233
4234out:
4235 return ret;
4236}
4237
4238static int record_deleted_ref(struct send_ctx *sctx)
4239{
4240 int ret;
4241
4242 ret = iterate_inode_ref(sctx->parent_root, sctx->right_path,
4243 sctx->cmp_key, 0, __record_deleted_ref, sctx);
4244 if (ret < 0)
4245 goto out;
4246 ret = 0;
4247
4248out:
4249 return ret;
4250}
4251
4252struct find_ref_ctx {
4253 u64 dir;
4254 u64 dir_gen;
4255 struct btrfs_root *root;
4256 struct fs_path *name;
4257 int found_idx;
4258};
4259
4260static int __find_iref(int num, u64 dir, int index,
4261 struct fs_path *name,
4262 void *ctx_)
4263{
4264 struct find_ref_ctx *ctx = ctx_;
4265 u64 dir_gen;
4266 int ret;
4267
4268 if (dir == ctx->dir && fs_path_len(name) == fs_path_len(ctx->name) &&
4269 strncmp(name->start, ctx->name->start, fs_path_len(name)) == 0) {
4270
4271
4272
4273
4274 ret = get_inode_info(ctx->root, dir, NULL, &dir_gen, NULL,
4275 NULL, NULL, NULL);
4276 if (ret)
4277 return ret;
4278 if (dir_gen != ctx->dir_gen)
4279 return 0;
4280 ctx->found_idx = num;
4281 return 1;
4282 }
4283 return 0;
4284}
4285
4286static int find_iref(struct btrfs_root *root,
4287 struct btrfs_path *path,
4288 struct btrfs_key *key,
4289 u64 dir, u64 dir_gen, struct fs_path *name)
4290{
4291 int ret;
4292 struct find_ref_ctx ctx;
4293
4294 ctx.dir = dir;
4295 ctx.name = name;
4296 ctx.dir_gen = dir_gen;
4297 ctx.found_idx = -1;
4298 ctx.root = root;
4299
4300 ret = iterate_inode_ref(root, path, key, 0, __find_iref, &ctx);
4301 if (ret < 0)
4302 return ret;
4303
4304 if (ctx.found_idx == -1)
4305 return -ENOENT;
4306
4307 return ctx.found_idx;
4308}
4309
4310static int __record_changed_new_ref(int num, u64 dir, int index,
4311 struct fs_path *name,
4312 void *ctx)
4313{
4314 u64 dir_gen;
4315 int ret;
4316 struct send_ctx *sctx = ctx;
4317
4318 ret = get_inode_info(sctx->send_root, dir, NULL, &dir_gen, NULL,
4319 NULL, NULL, NULL);
4320 if (ret)
4321 return ret;
4322
4323 ret = find_iref(sctx->parent_root, sctx->right_path,
4324 sctx->cmp_key, dir, dir_gen, name);
4325 if (ret == -ENOENT)
4326 ret = __record_new_ref(num, dir, index, name, sctx);
4327 else if (ret > 0)
4328 ret = 0;
4329
4330 return ret;
4331}
4332
4333static int __record_changed_deleted_ref(int num, u64 dir, int index,
4334 struct fs_path *name,
4335 void *ctx)
4336{
4337 u64 dir_gen;
4338 int ret;
4339 struct send_ctx *sctx = ctx;
4340
4341 ret = get_inode_info(sctx->parent_root, dir, NULL, &dir_gen, NULL,
4342 NULL, NULL, NULL);
4343 if (ret)
4344 return ret;
4345
4346 ret = find_iref(sctx->send_root, sctx->left_path, sctx->cmp_key,
4347 dir, dir_gen, name);
4348 if (ret == -ENOENT)
4349 ret = __record_deleted_ref(num, dir, index, name, sctx);
4350 else if (ret > 0)
4351 ret = 0;
4352
4353 return ret;
4354}
4355
4356static int record_changed_ref(struct send_ctx *sctx)
4357{
4358 int ret = 0;
4359
4360 ret = iterate_inode_ref(sctx->send_root, sctx->left_path,
4361 sctx->cmp_key, 0, __record_changed_new_ref, sctx);
4362 if (ret < 0)
4363 goto out;
4364 ret = iterate_inode_ref(sctx->parent_root, sctx->right_path,
4365 sctx->cmp_key, 0, __record_changed_deleted_ref, sctx);
4366 if (ret < 0)
4367 goto out;
4368 ret = 0;
4369
4370out:
4371 return ret;
4372}
4373
4374
4375
4376
4377
4378static int process_all_refs(struct send_ctx *sctx,
4379 enum btrfs_compare_tree_result cmd)
4380{
4381 int ret;
4382 struct btrfs_root *root;
4383 struct btrfs_path *path;
4384 struct btrfs_key key;
4385 struct btrfs_key found_key;
4386 struct extent_buffer *eb;
4387 int slot;
4388 iterate_inode_ref_t cb;
4389 int pending_move = 0;
4390
4391 path = alloc_path_for_send();
4392 if (!path)
4393 return -ENOMEM;
4394
4395 if (cmd == BTRFS_COMPARE_TREE_NEW) {
4396 root = sctx->send_root;
4397 cb = __record_new_ref;
4398 } else if (cmd == BTRFS_COMPARE_TREE_DELETED) {
4399 root = sctx->parent_root;
4400 cb = __record_deleted_ref;
4401 } else {
4402 btrfs_err(sctx->send_root->fs_info,
4403 "Wrong command %d in process_all_refs", cmd);
4404 ret = -EINVAL;
4405 goto out;
4406 }
4407
4408 key.objectid = sctx->cmp_key->objectid;
4409 key.type = BTRFS_INODE_REF_KEY;
4410 key.offset = 0;
4411 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
4412 if (ret < 0)
4413 goto out;
4414
4415 while (1) {
4416 eb = path->nodes[0];
4417 slot = path->slots[0];
4418 if (slot >= btrfs_header_nritems(eb)) {
4419 ret = btrfs_next_leaf(root, path);
4420 if (ret < 0)
4421 goto out;
4422 else if (ret > 0)
4423 break;
4424 continue;
4425 }
4426
4427 btrfs_item_key_to_cpu(eb, &found_key, slot);
4428
4429 if (found_key.objectid != key.objectid ||
4430 (found_key.type != BTRFS_INODE_REF_KEY &&
4431 found_key.type != BTRFS_INODE_EXTREF_KEY))
4432 break;
4433
4434 ret = iterate_inode_ref(root, path, &found_key, 0, cb, sctx);
4435 if (ret < 0)
4436 goto out;
4437
4438 path->slots[0]++;
4439 }
4440 btrfs_release_path(path);
4441
4442
4443
4444
4445
4446
4447 ret = process_recorded_refs(sctx, &pending_move);
4448out:
4449 btrfs_free_path(path);
4450 return ret;
4451}
4452
4453static int send_set_xattr(struct send_ctx *sctx,
4454 struct fs_path *path,
4455 const char *name, int name_len,
4456 const char *data, int data_len)
4457{
4458 int ret = 0;
4459
4460 ret = begin_cmd(sctx, BTRFS_SEND_C_SET_XATTR);
4461 if (ret < 0)
4462 goto out;
4463
4464 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, path);
4465 TLV_PUT_STRING(sctx, BTRFS_SEND_A_XATTR_NAME, name, name_len);
4466 TLV_PUT(sctx, BTRFS_SEND_A_XATTR_DATA, data, data_len);
4467
4468 ret = send_cmd(sctx);
4469
4470tlv_put_failure:
4471out:
4472 return ret;
4473}
4474
4475static int send_remove_xattr(struct send_ctx *sctx,
4476 struct fs_path *path,
4477 const char *name, int name_len)
4478{
4479 int ret = 0;
4480
4481 ret = begin_cmd(sctx, BTRFS_SEND_C_REMOVE_XATTR);
4482 if (ret < 0)
4483 goto out;
4484
4485 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, path);
4486 TLV_PUT_STRING(sctx, BTRFS_SEND_A_XATTR_NAME, name, name_len);
4487
4488 ret = send_cmd(sctx);
4489
4490tlv_put_failure:
4491out:
4492 return ret;
4493}
4494
4495static int __process_new_xattr(int num, struct btrfs_key *di_key,
4496 const char *name, int name_len,
4497 const char *data, int data_len,
4498 u8 type, void *ctx)
4499{
4500 int ret;
4501 struct send_ctx *sctx = ctx;
4502 struct fs_path *p;
4503 struct posix_acl_xattr_header dummy_acl;
4504
4505 p = fs_path_alloc();
4506 if (!p)
4507 return -ENOMEM;
4508
4509
4510
4511
4512
4513
4514
4515 if (!strncmp(name, XATTR_NAME_POSIX_ACL_ACCESS, name_len) ||
4516 !strncmp(name, XATTR_NAME_POSIX_ACL_DEFAULT, name_len)) {
4517 if (data_len == 0) {
4518 dummy_acl.a_version =
4519 cpu_to_le32(POSIX_ACL_XATTR_VERSION);
4520 data = (char *)&dummy_acl;
4521 data_len = sizeof(dummy_acl);
4522 }
4523 }
4524
4525 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
4526 if (ret < 0)
4527 goto out;
4528
4529 ret = send_set_xattr(sctx, p, name, name_len, data, data_len);
4530
4531out:
4532 fs_path_free(p);
4533 return ret;
4534}
4535
4536static int __process_deleted_xattr(int num, struct btrfs_key *di_key,
4537 const char *name, int name_len,
4538 const char *data, int data_len,
4539 u8 type, void *ctx)
4540{
4541 int ret;
4542 struct send_ctx *sctx = ctx;
4543 struct fs_path *p;
4544
4545 p = fs_path_alloc();
4546 if (!p)
4547 return -ENOMEM;
4548
4549 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
4550 if (ret < 0)
4551 goto out;
4552
4553 ret = send_remove_xattr(sctx, p, name, name_len);
4554
4555out:
4556 fs_path_free(p);
4557 return ret;
4558}
4559
4560static int process_new_xattr(struct send_ctx *sctx)
4561{
4562 int ret = 0;
4563
4564 ret = iterate_dir_item(sctx->send_root, sctx->left_path,
4565 __process_new_xattr, sctx);
4566
4567 return ret;
4568}
4569
4570static int process_deleted_xattr(struct send_ctx *sctx)
4571{
4572 return iterate_dir_item(sctx->parent_root, sctx->right_path,
4573 __process_deleted_xattr, sctx);
4574}
4575
4576struct find_xattr_ctx {
4577 const char *name;
4578 int name_len;
4579 int found_idx;
4580 char *found_data;
4581 int found_data_len;
4582};
4583
4584static int __find_xattr(int num, struct btrfs_key *di_key,
4585 const char *name, int name_len,
4586 const char *data, int data_len,
4587 u8 type, void *vctx)
4588{
4589 struct find_xattr_ctx *ctx = vctx;
4590
4591 if (name_len == ctx->name_len &&
4592 strncmp(name, ctx->name, name_len) == 0) {
4593 ctx->found_idx = num;
4594 ctx->found_data_len = data_len;
4595 ctx->found_data = kmemdup(data, data_len, GFP_KERNEL);
4596 if (!ctx->found_data)
4597 return -ENOMEM;
4598 return 1;
4599 }
4600 return 0;
4601}
4602
4603static int find_xattr(struct btrfs_root *root,
4604 struct btrfs_path *path,
4605 struct btrfs_key *key,
4606 const char *name, int name_len,
4607 char **data, int *data_len)
4608{
4609 int ret;
4610 struct find_xattr_ctx ctx;
4611
4612 ctx.name = name;
4613 ctx.name_len = name_len;
4614 ctx.found_idx = -1;
4615 ctx.found_data = NULL;
4616 ctx.found_data_len = 0;
4617
4618 ret = iterate_dir_item(root, path, __find_xattr, &ctx);
4619 if (ret < 0)
4620 return ret;
4621
4622 if (ctx.found_idx == -1)
4623 return -ENOENT;
4624 if (data) {
4625 *data = ctx.found_data;
4626 *data_len = ctx.found_data_len;
4627 } else {
4628 kfree(ctx.found_data);
4629 }
4630 return ctx.found_idx;
4631}
4632
4633
4634static int __process_changed_new_xattr(int num, struct btrfs_key *di_key,
4635 const char *name, int name_len,
4636 const char *data, int data_len,
4637 u8 type, void *ctx)
4638{
4639 int ret;
4640 struct send_ctx *sctx = ctx;
4641 char *found_data = NULL;
4642 int found_data_len = 0;
4643
4644 ret = find_xattr(sctx->parent_root, sctx->right_path,
4645 sctx->cmp_key, name, name_len, &found_data,
4646 &found_data_len);
4647 if (ret == -ENOENT) {
4648 ret = __process_new_xattr(num, di_key, name, name_len, data,
4649 data_len, type, ctx);
4650 } else if (ret >= 0) {
4651 if (data_len != found_data_len ||
4652 memcmp(data, found_data, data_len)) {
4653 ret = __process_new_xattr(num, di_key, name, name_len,
4654 data, data_len, type, ctx);
4655 } else {
4656 ret = 0;
4657 }
4658 }
4659
4660 kfree(found_data);
4661 return ret;
4662}
4663
4664static int __process_changed_deleted_xattr(int num, struct btrfs_key *di_key,
4665 const char *name, int name_len,
4666 const char *data, int data_len,
4667 u8 type, void *ctx)
4668{
4669 int ret;
4670 struct send_ctx *sctx = ctx;
4671
4672 ret = find_xattr(sctx->send_root, sctx->left_path, sctx->cmp_key,
4673 name, name_len, NULL, NULL);
4674 if (ret == -ENOENT)
4675 ret = __process_deleted_xattr(num, di_key, name, name_len, data,
4676 data_len, type, ctx);
4677 else if (ret >= 0)
4678 ret = 0;
4679
4680 return ret;
4681}
4682
4683static int process_changed_xattr(struct send_ctx *sctx)
4684{
4685 int ret = 0;
4686
4687 ret = iterate_dir_item(sctx->send_root, sctx->left_path,
4688 __process_changed_new_xattr, sctx);
4689 if (ret < 0)
4690 goto out;
4691 ret = iterate_dir_item(sctx->parent_root, sctx->right_path,
4692 __process_changed_deleted_xattr, sctx);
4693
4694out:
4695 return ret;
4696}
4697
4698static int process_all_new_xattrs(struct send_ctx *sctx)
4699{
4700 int ret;
4701 struct btrfs_root *root;
4702 struct btrfs_path *path;
4703 struct btrfs_key key;
4704 struct btrfs_key found_key;
4705 struct extent_buffer *eb;
4706 int slot;
4707
4708 path = alloc_path_for_send();
4709 if (!path)
4710 return -ENOMEM;
4711
4712 root = sctx->send_root;
4713
4714 key.objectid = sctx->cmp_key->objectid;
4715 key.type = BTRFS_XATTR_ITEM_KEY;
4716 key.offset = 0;
4717 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
4718 if (ret < 0)
4719 goto out;
4720
4721 while (1) {
4722 eb = path->nodes[0];
4723 slot = path->slots[0];
4724 if (slot >= btrfs_header_nritems(eb)) {
4725 ret = btrfs_next_leaf(root, path);
4726 if (ret < 0) {
4727 goto out;
4728 } else if (ret > 0) {
4729 ret = 0;
4730 break;
4731 }
4732 continue;
4733 }
4734
4735 btrfs_item_key_to_cpu(eb, &found_key, slot);
4736 if (found_key.objectid != key.objectid ||
4737 found_key.type != key.type) {
4738 ret = 0;
4739 goto out;
4740 }
4741
4742 ret = iterate_dir_item(root, path, __process_new_xattr, sctx);
4743 if (ret < 0)
4744 goto out;
4745
4746 path->slots[0]++;
4747 }
4748
4749out:
4750 btrfs_free_path(path);
4751 return ret;
4752}
4753
4754static ssize_t fill_read_buf(struct send_ctx *sctx, u64 offset, u32 len)
4755{
4756 struct btrfs_root *root = sctx->send_root;
4757 struct btrfs_fs_info *fs_info = root->fs_info;
4758 struct inode *inode;
4759 struct page *page;
4760 char *addr;
4761 struct btrfs_key key;
4762 pgoff_t index = offset >> PAGE_SHIFT;
4763 pgoff_t last_index;
4764 unsigned pg_offset = offset & ~PAGE_MASK;
4765 ssize_t ret = 0;
4766
4767 key.objectid = sctx->cur_ino;
4768 key.type = BTRFS_INODE_ITEM_KEY;
4769 key.offset = 0;
4770
4771 inode = btrfs_iget(fs_info->sb, &key, root, NULL);
4772 if (IS_ERR(inode))
4773 return PTR_ERR(inode);
4774
4775 if (offset + len > i_size_read(inode)) {
4776 if (offset > i_size_read(inode))
4777 len = 0;
4778 else
4779 len = offset - i_size_read(inode);
4780 }
4781 if (len == 0)
4782 goto out;
4783
4784 last_index = (offset + len - 1) >> PAGE_SHIFT;
4785
4786
4787 memset(&sctx->ra, 0, sizeof(struct file_ra_state));
4788 file_ra_state_init(&sctx->ra, inode->i_mapping);
4789
4790 while (index <= last_index) {
4791 unsigned cur_len = min_t(unsigned, len,
4792 PAGE_SIZE - pg_offset);
4793
4794 page = find_lock_page(inode->i_mapping, index);
4795 if (!page) {
4796 page_cache_sync_readahead(inode->i_mapping, &sctx->ra,
4797 NULL, index, last_index + 1 - index);
4798
4799 page = find_or_create_page(inode->i_mapping, index,
4800 GFP_KERNEL);
4801 if (!page) {
4802 ret = -ENOMEM;
4803 break;
4804 }
4805 }
4806
4807 if (PageReadahead(page)) {
4808 page_cache_async_readahead(inode->i_mapping, &sctx->ra,
4809 NULL, page, index, last_index + 1 - index);
4810 }
4811
4812 if (!PageUptodate(page)) {
4813 btrfs_readpage(NULL, page);
4814 lock_page(page);
4815 if (!PageUptodate(page)) {
4816 unlock_page(page);
4817 put_page(page);
4818 ret = -EIO;
4819 break;
4820 }
4821 }
4822
4823 addr = kmap(page);
4824 memcpy(sctx->read_buf + ret, addr + pg_offset, cur_len);
4825 kunmap(page);
4826 unlock_page(page);
4827 put_page(page);
4828 index++;
4829 pg_offset = 0;
4830 len -= cur_len;
4831 ret += cur_len;
4832 }
4833out:
4834 iput(inode);
4835 return ret;
4836}
4837
4838
4839
4840
4841
4842static int send_write(struct send_ctx *sctx, u64 offset, u32 len)
4843{
4844 struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;
4845 int ret = 0;
4846 struct fs_path *p;
4847 ssize_t num_read = 0;
4848
4849 p = fs_path_alloc();
4850 if (!p)
4851 return -ENOMEM;
4852
4853 btrfs_debug(fs_info, "send_write offset=%llu, len=%d", offset, len);
4854
4855 num_read = fill_read_buf(sctx, offset, len);
4856 if (num_read <= 0) {
4857 if (num_read < 0)
4858 ret = num_read;
4859 goto out;
4860 }
4861
4862 ret = begin_cmd(sctx, BTRFS_SEND_C_WRITE);
4863 if (ret < 0)
4864 goto out;
4865
4866 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
4867 if (ret < 0)
4868 goto out;
4869
4870 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
4871 TLV_PUT_U64(sctx, BTRFS_SEND_A_FILE_OFFSET, offset);
4872 TLV_PUT(sctx, BTRFS_SEND_A_DATA, sctx->read_buf, num_read);
4873
4874 ret = send_cmd(sctx);
4875
4876tlv_put_failure:
4877out:
4878 fs_path_free(p);
4879 if (ret < 0)
4880 return ret;
4881 return num_read;
4882}
4883
4884
4885
4886
4887static int send_clone(struct send_ctx *sctx,
4888 u64 offset, u32 len,
4889 struct clone_root *clone_root)
4890{
4891 int ret = 0;
4892 struct fs_path *p;
4893 u64 gen;
4894
4895 btrfs_debug(sctx->send_root->fs_info,
4896 "send_clone offset=%llu, len=%d, clone_root=%llu, clone_inode=%llu, clone_offset=%llu",
4897 offset, len, clone_root->root->objectid, clone_root->ino,
4898 clone_root->offset);
4899
4900 p = fs_path_alloc();
4901 if (!p)
4902 return -ENOMEM;
4903
4904 ret = begin_cmd(sctx, BTRFS_SEND_C_CLONE);
4905 if (ret < 0)
4906 goto out;
4907
4908 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
4909 if (ret < 0)
4910 goto out;
4911
4912 TLV_PUT_U64(sctx, BTRFS_SEND_A_FILE_OFFSET, offset);
4913 TLV_PUT_U64(sctx, BTRFS_SEND_A_CLONE_LEN, len);
4914 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
4915
4916 if (clone_root->root == sctx->send_root) {
4917 ret = get_inode_info(sctx->send_root, clone_root->ino, NULL,
4918 &gen, NULL, NULL, NULL, NULL);
4919 if (ret < 0)
4920 goto out;
4921 ret = get_cur_path(sctx, clone_root->ino, gen, p);
4922 } else {
4923 ret = get_inode_path(clone_root->root, clone_root->ino, p);
4924 }
4925 if (ret < 0)
4926 goto out;
4927
4928
4929
4930
4931
4932
4933
4934
4935
4936
4937 if (!btrfs_is_empty_uuid(clone_root->root->root_item.received_uuid))
4938 TLV_PUT_UUID(sctx, BTRFS_SEND_A_CLONE_UUID,
4939 clone_root->root->root_item.received_uuid);
4940 else
4941 TLV_PUT_UUID(sctx, BTRFS_SEND_A_CLONE_UUID,
4942 clone_root->root->root_item.uuid);
4943 TLV_PUT_U64(sctx, BTRFS_SEND_A_CLONE_CTRANSID,
4944 le64_to_cpu(clone_root->root->root_item.ctransid));
4945 TLV_PUT_PATH(sctx, BTRFS_SEND_A_CLONE_PATH, p);
4946 TLV_PUT_U64(sctx, BTRFS_SEND_A_CLONE_OFFSET,
4947 clone_root->offset);
4948
4949 ret = send_cmd(sctx);
4950
4951tlv_put_failure:
4952out:
4953 fs_path_free(p);
4954 return ret;
4955}
4956
4957
4958
4959
4960static int send_update_extent(struct send_ctx *sctx,
4961 u64 offset, u32 len)
4962{
4963 int ret = 0;
4964 struct fs_path *p;
4965
4966 p = fs_path_alloc();
4967 if (!p)
4968 return -ENOMEM;
4969
4970 ret = begin_cmd(sctx, BTRFS_SEND_C_UPDATE_EXTENT);
4971 if (ret < 0)
4972 goto out;
4973
4974 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
4975 if (ret < 0)
4976 goto out;
4977
4978 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
4979 TLV_PUT_U64(sctx, BTRFS_SEND_A_FILE_OFFSET, offset);
4980 TLV_PUT_U64(sctx, BTRFS_SEND_A_SIZE, len);
4981
4982 ret = send_cmd(sctx);
4983
4984tlv_put_failure:
4985out:
4986 fs_path_free(p);
4987 return ret;
4988}
4989
4990static int send_hole(struct send_ctx *sctx, u64 end)
4991{
4992 struct fs_path *p = NULL;
4993 u64 offset = sctx->cur_inode_last_extent;
4994 u64 len;
4995 int ret = 0;
4996
4997 if (sctx->flags & BTRFS_SEND_FLAG_NO_FILE_DATA)
4998 return send_update_extent(sctx, offset, end - offset);
4999
5000 p = fs_path_alloc();
5001 if (!p)
5002 return -ENOMEM;
5003 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
5004 if (ret < 0)
5005 goto tlv_put_failure;
5006 memset(sctx->read_buf, 0, BTRFS_SEND_READ_SIZE);
5007 while (offset < end) {
5008 len = min_t(u64, end - offset, BTRFS_SEND_READ_SIZE);
5009
5010 ret = begin_cmd(sctx, BTRFS_SEND_C_WRITE);
5011 if (ret < 0)
5012 break;
5013 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
5014 TLV_PUT_U64(sctx, BTRFS_SEND_A_FILE_OFFSET, offset);
5015 TLV_PUT(sctx, BTRFS_SEND_A_DATA, sctx->read_buf, len);
5016 ret = send_cmd(sctx);
5017 if (ret < 0)
5018 break;
5019 offset += len;
5020 }
5021 sctx->cur_inode_next_write_offset = offset;
5022tlv_put_failure:
5023 fs_path_free(p);
5024 return ret;
5025}
5026
5027static int send_extent_data(struct send_ctx *sctx,
5028 const u64 offset,
5029 const u64 len)
5030{
5031 u64 sent = 0;
5032
5033 if (sctx->flags & BTRFS_SEND_FLAG_NO_FILE_DATA)
5034 return send_update_extent(sctx, offset, len);
5035
5036 while (sent < len) {
5037 u64 size = len - sent;
5038 int ret;
5039
5040 if (size > BTRFS_SEND_READ_SIZE)
5041 size = BTRFS_SEND_READ_SIZE;
5042 ret = send_write(sctx, offset + sent, size);
5043 if (ret < 0)
5044 return ret;
5045 if (!ret)
5046 break;
5047 sent += ret;
5048 }
5049 return 0;
5050}
5051
5052static int clone_range(struct send_ctx *sctx,
5053 struct clone_root *clone_root,
5054 const u64 disk_byte,
5055 u64 data_offset,
5056 u64 offset,
5057 u64 len)
5058{
5059 struct btrfs_path *path;
5060 struct btrfs_key key;
5061 int ret;
5062
5063
5064
5065
5066
5067
5068
5069
5070
5071
5072
5073
5074
5075
5076
5077
5078 if (clone_root->offset == 0 &&
5079 len == sctx->send_root->fs_info->sectorsize)
5080 return send_extent_data(sctx, offset, len);
5081
5082 path = alloc_path_for_send();
5083 if (!path)
5084 return -ENOMEM;
5085
5086
5087
5088
5089
5090
5091
5092
5093
5094
5095
5096
5097
5098
5099
5100
5101
5102
5103
5104
5105
5106
5107
5108 key.objectid = clone_root->ino;
5109 key.type = BTRFS_EXTENT_DATA_KEY;
5110 key.offset = clone_root->offset;
5111 ret = btrfs_search_slot(NULL, clone_root->root, &key, path, 0, 0);
5112 if (ret < 0)
5113 goto out;
5114 if (ret > 0 && path->slots[0] > 0) {
5115 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0] - 1);
5116 if (key.objectid == clone_root->ino &&
5117 key.type == BTRFS_EXTENT_DATA_KEY)
5118 path->slots[0]--;
5119 }
5120
5121 while (true) {
5122 struct extent_buffer *leaf = path->nodes[0];
5123 int slot = path->slots[0];
5124 struct btrfs_file_extent_item *ei;
5125 u8 type;
5126 u64 ext_len;
5127 u64 clone_len;
5128
5129 if (slot >= btrfs_header_nritems(leaf)) {
5130 ret = btrfs_next_leaf(clone_root->root, path);
5131 if (ret < 0)
5132 goto out;
5133 else if (ret > 0)
5134 break;
5135 continue;
5136 }
5137
5138 btrfs_item_key_to_cpu(leaf, &key, slot);
5139
5140
5141
5142
5143
5144 if (key.objectid != clone_root->ino ||
5145 key.type != BTRFS_EXTENT_DATA_KEY)
5146 break;
5147
5148 ei = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
5149 type = btrfs_file_extent_type(leaf, ei);
5150 if (type == BTRFS_FILE_EXTENT_INLINE) {
5151 ext_len = btrfs_file_extent_inline_len(leaf, slot, ei);
5152 ext_len = PAGE_ALIGN(ext_len);
5153 } else {
5154 ext_len = btrfs_file_extent_num_bytes(leaf, ei);
5155 }
5156
5157 if (key.offset + ext_len <= clone_root->offset)
5158 goto next;
5159
5160 if (key.offset > clone_root->offset) {
5161
5162 u64 hole_len = key.offset - clone_root->offset;
5163
5164 if (hole_len > len)
5165 hole_len = len;
5166 ret = send_extent_data(sctx, offset, hole_len);
5167 if (ret < 0)
5168 goto out;
5169
5170 len -= hole_len;
5171 if (len == 0)
5172 break;
5173 offset += hole_len;
5174 clone_root->offset += hole_len;
5175 data_offset += hole_len;
5176 }
5177
5178 if (key.offset >= clone_root->offset + len)
5179 break;
5180
5181 clone_len = min_t(u64, ext_len, len);
5182
5183 if (btrfs_file_extent_disk_bytenr(leaf, ei) == disk_byte &&
5184 btrfs_file_extent_offset(leaf, ei) == data_offset)
5185 ret = send_clone(sctx, offset, clone_len, clone_root);
5186 else
5187 ret = send_extent_data(sctx, offset, clone_len);
5188
5189 if (ret < 0)
5190 goto out;
5191
5192 len -= clone_len;
5193 if (len == 0)
5194 break;
5195 offset += clone_len;
5196 clone_root->offset += clone_len;
5197 data_offset += clone_len;
5198next:
5199 path->slots[0]++;
5200 }
5201
5202 if (len > 0)
5203 ret = send_extent_data(sctx, offset, len);
5204 else
5205 ret = 0;
5206out:
5207 btrfs_free_path(path);
5208 return ret;
5209}
5210
5211static int send_write_or_clone(struct send_ctx *sctx,
5212 struct btrfs_path *path,
5213 struct btrfs_key *key,
5214 struct clone_root *clone_root)
5215{
5216 int ret = 0;
5217 struct btrfs_file_extent_item *ei;
5218 u64 offset = key->offset;
5219 u64 len;
5220 u8 type;
5221 u64 bs = sctx->send_root->fs_info->sb->s_blocksize;
5222
5223 ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
5224 struct btrfs_file_extent_item);
5225 type = btrfs_file_extent_type(path->nodes[0], ei);
5226 if (type == BTRFS_FILE_EXTENT_INLINE) {
5227 len = btrfs_file_extent_inline_len(path->nodes[0],
5228 path->slots[0], ei);
5229
5230
5231
5232
5233
5234 len = PAGE_ALIGN(len);
5235 } else {
5236 len = btrfs_file_extent_num_bytes(path->nodes[0], ei);
5237 }
5238
5239 if (offset >= sctx->cur_inode_size) {
5240 ret = 0;
5241 goto out;
5242 }
5243 if (offset + len > sctx->cur_inode_size)
5244 len = sctx->cur_inode_size - offset;
5245 if (len == 0) {
5246 ret = 0;
5247 goto out;
5248 }
5249
5250 if (clone_root && IS_ALIGNED(offset + len, bs)) {
5251 u64 disk_byte;
5252 u64 data_offset;
5253
5254 disk_byte = btrfs_file_extent_disk_bytenr(path->nodes[0], ei);
5255 data_offset = btrfs_file_extent_offset(path->nodes[0], ei);
5256 ret = clone_range(sctx, clone_root, disk_byte, data_offset,
5257 offset, len);
5258 } else {
5259 ret = send_extent_data(sctx, offset, len);
5260 }
5261 sctx->cur_inode_next_write_offset = offset + len;
5262out:
5263 return ret;
5264}
5265
5266static int is_extent_unchanged(struct send_ctx *sctx,
5267 struct btrfs_path *left_path,
5268 struct btrfs_key *ekey)
5269{
5270 int ret = 0;
5271 struct btrfs_key key;
5272 struct btrfs_path *path = NULL;
5273 struct extent_buffer *eb;
5274 int slot;
5275 struct btrfs_key found_key;
5276 struct btrfs_file_extent_item *ei;
5277 u64 left_disknr;
5278 u64 right_disknr;
5279 u64 left_offset;
5280 u64 right_offset;
5281 u64 left_offset_fixed;
5282 u64 left_len;
5283 u64 right_len;
5284 u64 left_gen;
5285 u64 right_gen;
5286 u8 left_type;
5287 u8 right_type;
5288
5289 path = alloc_path_for_send();
5290 if (!path)
5291 return -ENOMEM;
5292
5293 eb = left_path->nodes[0];
5294 slot = left_path->slots[0];
5295 ei = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
5296 left_type = btrfs_file_extent_type(eb, ei);
5297
5298 if (left_type != BTRFS_FILE_EXTENT_REG) {
5299 ret = 0;
5300 goto out;
5301 }
5302 left_disknr = btrfs_file_extent_disk_bytenr(eb, ei);
5303 left_len = btrfs_file_extent_num_bytes(eb, ei);
5304 left_offset = btrfs_file_extent_offset(eb, ei);
5305 left_gen = btrfs_file_extent_generation(eb, ei);
5306
5307
5308
5309
5310
5311
5312
5313
5314
5315
5316
5317
5318
5319
5320
5321
5322
5323
5324
5325
5326
5327
5328 key.objectid = ekey->objectid;
5329 key.type = BTRFS_EXTENT_DATA_KEY;
5330 key.offset = ekey->offset;
5331 ret = btrfs_search_slot_for_read(sctx->parent_root, &key, path, 0, 0);
5332 if (ret < 0)
5333 goto out;
5334 if (ret) {
5335 ret = 0;
5336 goto out;
5337 }
5338
5339
5340
5341
5342 eb = path->nodes[0];
5343 slot = path->slots[0];
5344 btrfs_item_key_to_cpu(eb, &found_key, slot);
5345 if (found_key.objectid != key.objectid ||
5346 found_key.type != key.type) {
5347
5348 ret = (left_disknr) ? 0 : 1;
5349 goto out;
5350 }
5351
5352
5353
5354
5355 key = found_key;
5356 while (key.offset < ekey->offset + left_len) {
5357 ei = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
5358 right_type = btrfs_file_extent_type(eb, ei);
5359 if (right_type != BTRFS_FILE_EXTENT_REG &&
5360 right_type != BTRFS_FILE_EXTENT_INLINE) {
5361 ret = 0;
5362 goto out;
5363 }
5364
5365 if (right_type == BTRFS_FILE_EXTENT_INLINE) {
5366 right_len = btrfs_file_extent_inline_len(eb, slot, ei);
5367 right_len = PAGE_ALIGN(right_len);
5368 } else {
5369 right_len = btrfs_file_extent_num_bytes(eb, ei);
5370 }
5371
5372
5373
5374
5375
5376 if (found_key.offset + right_len <= ekey->offset) {
5377
5378 ret = (left_disknr) ? 0 : 1;
5379 goto out;
5380 }
5381
5382
5383
5384
5385
5386
5387
5388
5389
5390 if (right_type == BTRFS_FILE_EXTENT_INLINE) {
5391 ret = 0;
5392 goto out;
5393 }
5394
5395 right_disknr = btrfs_file_extent_disk_bytenr(eb, ei);
5396 right_offset = btrfs_file_extent_offset(eb, ei);
5397 right_gen = btrfs_file_extent_generation(eb, ei);
5398
5399 left_offset_fixed = left_offset;
5400 if (key.offset < ekey->offset) {
5401
5402 right_offset += ekey->offset - key.offset;
5403 } else {
5404
5405 left_offset_fixed += key.offset - ekey->offset;
5406 }
5407
5408
5409
5410
5411 if (left_disknr != right_disknr ||
5412 left_offset_fixed != right_offset ||
5413 left_gen != right_gen) {
5414 ret = 0;
5415 goto out;
5416 }
5417
5418
5419
5420
5421 ret = btrfs_next_item(sctx->parent_root, path);
5422 if (ret < 0)
5423 goto out;
5424 if (!ret) {
5425 eb = path->nodes[0];
5426 slot = path->slots[0];
5427 btrfs_item_key_to_cpu(eb, &found_key, slot);
5428 }
5429 if (ret || found_key.objectid != key.objectid ||
5430 found_key.type != key.type) {
5431 key.offset += right_len;
5432 break;
5433 }
5434 if (found_key.offset != key.offset + right_len) {
5435 ret = 0;
5436 goto out;
5437 }
5438 key = found_key;
5439 }
5440
5441
5442
5443
5444
5445 if (key.offset >= ekey->offset + left_len)
5446 ret = 1;
5447 else
5448 ret = 0;
5449
5450
5451out:
5452 btrfs_free_path(path);
5453 return ret;
5454}
5455
5456static int get_last_extent(struct send_ctx *sctx, u64 offset)
5457{
5458 struct btrfs_path *path;
5459 struct btrfs_root *root = sctx->send_root;
5460 struct btrfs_file_extent_item *fi;
5461 struct btrfs_key key;
5462 u64 extent_end;
5463 u8 type;
5464 int ret;
5465
5466 path = alloc_path_for_send();
5467 if (!path)
5468 return -ENOMEM;
5469
5470 sctx->cur_inode_last_extent = 0;
5471
5472 key.objectid = sctx->cur_ino;
5473 key.type = BTRFS_EXTENT_DATA_KEY;
5474 key.offset = offset;
5475 ret = btrfs_search_slot_for_read(root, &key, path, 0, 1);
5476 if (ret < 0)
5477 goto out;
5478 ret = 0;
5479 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
5480 if (key.objectid != sctx->cur_ino || key.type != BTRFS_EXTENT_DATA_KEY)
5481 goto out;
5482
5483 fi = btrfs_item_ptr(path->nodes[0], path->slots[0],
5484 struct btrfs_file_extent_item);
5485 type = btrfs_file_extent_type(path->nodes[0], fi);
5486 if (type == BTRFS_FILE_EXTENT_INLINE) {
5487 u64 size = btrfs_file_extent_inline_len(path->nodes[0],
5488 path->slots[0], fi);
5489 extent_end = ALIGN(key.offset + size,
5490 sctx->send_root->fs_info->sectorsize);
5491 } else {
5492 extent_end = key.offset +
5493 btrfs_file_extent_num_bytes(path->nodes[0], fi);
5494 }
5495 sctx->cur_inode_last_extent = extent_end;
5496out:
5497 btrfs_free_path(path);
5498 return ret;
5499}
5500
5501static int range_is_hole_in_parent(struct send_ctx *sctx,
5502 const u64 start,
5503 const u64 end)
5504{
5505 struct btrfs_path *path;
5506 struct btrfs_key key;
5507 struct btrfs_root *root = sctx->parent_root;
5508 u64 search_start = start;
5509 int ret;
5510
5511 path = alloc_path_for_send();
5512 if (!path)
5513 return -ENOMEM;
5514
5515 key.objectid = sctx->cur_ino;
5516 key.type = BTRFS_EXTENT_DATA_KEY;
5517 key.offset = search_start;
5518 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5519 if (ret < 0)
5520 goto out;
5521 if (ret > 0 && path->slots[0] > 0)
5522 path->slots[0]--;
5523
5524 while (search_start < end) {
5525 struct extent_buffer *leaf = path->nodes[0];
5526 int slot = path->slots[0];
5527 struct btrfs_file_extent_item *fi;
5528 u64 extent_end;
5529
5530 if (slot >= btrfs_header_nritems(leaf)) {
5531 ret = btrfs_next_leaf(root, path);
5532 if (ret < 0)
5533 goto out;
5534 else if (ret > 0)
5535 break;
5536 continue;
5537 }
5538
5539 btrfs_item_key_to_cpu(leaf, &key, slot);
5540 if (key.objectid < sctx->cur_ino ||
5541 key.type < BTRFS_EXTENT_DATA_KEY)
5542 goto next;
5543 if (key.objectid > sctx->cur_ino ||
5544 key.type > BTRFS_EXTENT_DATA_KEY ||
5545 key.offset >= end)
5546 break;
5547
5548 fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
5549 if (btrfs_file_extent_type(leaf, fi) ==
5550 BTRFS_FILE_EXTENT_INLINE) {
5551 u64 size = btrfs_file_extent_inline_len(leaf, slot, fi);
5552
5553 extent_end = ALIGN(key.offset + size,
5554 root->fs_info->sectorsize);
5555 } else {
5556 extent_end = key.offset +
5557 btrfs_file_extent_num_bytes(leaf, fi);
5558 }
5559 if (extent_end <= start)
5560 goto next;
5561 if (btrfs_file_extent_disk_bytenr(leaf, fi) == 0) {
5562 search_start = extent_end;
5563 goto next;
5564 }
5565 ret = 0;
5566 goto out;
5567next:
5568 path->slots[0]++;
5569 }
5570 ret = 1;
5571out:
5572 btrfs_free_path(path);
5573 return ret;
5574}
5575
5576static int maybe_send_hole(struct send_ctx *sctx, struct btrfs_path *path,
5577 struct btrfs_key *key)
5578{
5579 struct btrfs_file_extent_item *fi;
5580 u64 extent_end;
5581 u8 type;
5582 int ret = 0;
5583
5584 if (sctx->cur_ino != key->objectid || !need_send_hole(sctx))
5585 return 0;
5586
5587 if (sctx->cur_inode_last_extent == (u64)-1) {
5588 ret = get_last_extent(sctx, key->offset - 1);
5589 if (ret)
5590 return ret;
5591 }
5592
5593 fi = btrfs_item_ptr(path->nodes[0], path->slots[0],
5594 struct btrfs_file_extent_item);
5595 type = btrfs_file_extent_type(path->nodes[0], fi);
5596 if (type == BTRFS_FILE_EXTENT_INLINE) {
5597 u64 size = btrfs_file_extent_inline_len(path->nodes[0],
5598 path->slots[0], fi);
5599 extent_end = ALIGN(key->offset + size,
5600 sctx->send_root->fs_info->sectorsize);
5601 } else {
5602 extent_end = key->offset +
5603 btrfs_file_extent_num_bytes(path->nodes[0], fi);
5604 }
5605
5606 if (path->slots[0] == 0 &&
5607 sctx->cur_inode_last_extent < key->offset) {
5608
5609
5610
5611
5612
5613
5614
5615 ret = get_last_extent(sctx, key->offset - 1);
5616 if (ret)
5617 return ret;
5618 }
5619
5620 if (sctx->cur_inode_last_extent < key->offset) {
5621 ret = range_is_hole_in_parent(sctx,
5622 sctx->cur_inode_last_extent,
5623 key->offset);
5624 if (ret < 0)
5625 return ret;
5626 else if (ret == 0)
5627 ret = send_hole(sctx, key->offset);
5628 else
5629 ret = 0;
5630 }
5631 sctx->cur_inode_last_extent = extent_end;
5632 return ret;
5633}
5634
5635static int process_extent(struct send_ctx *sctx,
5636 struct btrfs_path *path,
5637 struct btrfs_key *key)
5638{
5639 struct clone_root *found_clone = NULL;
5640 int ret = 0;
5641
5642 if (S_ISLNK(sctx->cur_inode_mode))
5643 return 0;
5644
5645 if (sctx->parent_root && !sctx->cur_inode_new) {
5646 ret = is_extent_unchanged(sctx, path, key);
5647 if (ret < 0)
5648 goto out;
5649 if (ret) {
5650 ret = 0;
5651 goto out_hole;
5652 }
5653 } else {
5654 struct btrfs_file_extent_item *ei;
5655 u8 type;
5656
5657 ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
5658 struct btrfs_file_extent_item);
5659 type = btrfs_file_extent_type(path->nodes[0], ei);
5660 if (type == BTRFS_FILE_EXTENT_PREALLOC ||
5661 type == BTRFS_FILE_EXTENT_REG) {
5662
5663
5664
5665
5666
5667
5668 if (type == BTRFS_FILE_EXTENT_PREALLOC) {
5669 ret = 0;
5670 goto out;
5671 }
5672
5673
5674 if (btrfs_file_extent_disk_bytenr(path->nodes[0], ei) == 0) {
5675 ret = 0;
5676 goto out;
5677 }
5678 }
5679 }
5680
5681 ret = find_extent_clone(sctx, path, key->objectid, key->offset,
5682 sctx->cur_inode_size, &found_clone);
5683 if (ret != -ENOENT && ret < 0)
5684 goto out;
5685
5686 ret = send_write_or_clone(sctx, path, key, found_clone);
5687 if (ret)
5688 goto out;
5689out_hole:
5690 ret = maybe_send_hole(sctx, path, key);
5691out:
5692 return ret;
5693}
5694
5695static int process_all_extents(struct send_ctx *sctx)
5696{
5697 int ret;
5698 struct btrfs_root *root;
5699 struct btrfs_path *path;
5700 struct btrfs_key key;
5701 struct btrfs_key found_key;
5702 struct extent_buffer *eb;
5703 int slot;
5704
5705 root = sctx->send_root;
5706 path = alloc_path_for_send();
5707 if (!path)
5708 return -ENOMEM;
5709
5710 key.objectid = sctx->cmp_key->objectid;
5711 key.type = BTRFS_EXTENT_DATA_KEY;
5712 key.offset = 0;
5713 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5714 if (ret < 0)
5715 goto out;
5716
5717 while (1) {
5718 eb = path->nodes[0];
5719 slot = path->slots[0];
5720
5721 if (slot >= btrfs_header_nritems(eb)) {
5722 ret = btrfs_next_leaf(root, path);
5723 if (ret < 0) {
5724 goto out;
5725 } else if (ret > 0) {
5726 ret = 0;
5727 break;
5728 }
5729 continue;
5730 }
5731
5732 btrfs_item_key_to_cpu(eb, &found_key, slot);
5733
5734 if (found_key.objectid != key.objectid ||
5735 found_key.type != key.type) {
5736 ret = 0;
5737 goto out;
5738 }
5739
5740 ret = process_extent(sctx, path, &found_key);
5741 if (ret < 0)
5742 goto out;
5743
5744 path->slots[0]++;
5745 }
5746
5747out:
5748 btrfs_free_path(path);
5749 return ret;
5750}
5751
5752static int process_recorded_refs_if_needed(struct send_ctx *sctx, int at_end,
5753 int *pending_move,
5754 int *refs_processed)
5755{
5756 int ret = 0;
5757
5758 if (sctx->cur_ino == 0)
5759 goto out;
5760 if (!at_end && sctx->cur_ino == sctx->cmp_key->objectid &&
5761 sctx->cmp_key->type <= BTRFS_INODE_EXTREF_KEY)
5762 goto out;
5763 if (list_empty(&sctx->new_refs) && list_empty(&sctx->deleted_refs))
5764 goto out;
5765
5766 ret = process_recorded_refs(sctx, pending_move);
5767 if (ret < 0)
5768 goto out;
5769
5770 *refs_processed = 1;
5771out:
5772 return ret;
5773}
5774
5775static int finish_inode_if_needed(struct send_ctx *sctx, int at_end)
5776{
5777 int ret = 0;
5778 u64 left_mode;
5779 u64 left_uid;
5780 u64 left_gid;
5781 u64 right_mode;
5782 u64 right_uid;
5783 u64 right_gid;
5784 int need_chmod = 0;
5785 int need_chown = 0;
5786 int need_truncate = 1;
5787 int pending_move = 0;
5788 int refs_processed = 0;
5789
5790 ret = process_recorded_refs_if_needed(sctx, at_end, &pending_move,
5791 &refs_processed);
5792 if (ret < 0)
5793 goto out;
5794
5795
5796
5797
5798
5799
5800
5801
5802
5803
5804
5805
5806
5807 if (refs_processed && !pending_move)
5808 sctx->send_progress = sctx->cur_ino + 1;
5809
5810 if (sctx->cur_ino == 0 || sctx->cur_inode_deleted)
5811 goto out;
5812 if (!at_end && sctx->cmp_key->objectid == sctx->cur_ino)
5813 goto out;
5814
5815 ret = get_inode_info(sctx->send_root, sctx->cur_ino, NULL, NULL,
5816 &left_mode, &left_uid, &left_gid, NULL);
5817 if (ret < 0)
5818 goto out;
5819
5820 if (!sctx->parent_root || sctx->cur_inode_new) {
5821 need_chown = 1;
5822 if (!S_ISLNK(sctx->cur_inode_mode))
5823 need_chmod = 1;
5824 if (sctx->cur_inode_next_write_offset == sctx->cur_inode_size)
5825 need_truncate = 0;
5826 } else {
5827 u64 old_size;
5828
5829 ret = get_inode_info(sctx->parent_root, sctx->cur_ino,
5830 &old_size, NULL, &right_mode, &right_uid,
5831 &right_gid, NULL);
5832 if (ret < 0)
5833 goto out;
5834
5835 if (left_uid != right_uid || left_gid != right_gid)
5836 need_chown = 1;
5837 if (!S_ISLNK(sctx->cur_inode_mode) && left_mode != right_mode)
5838 need_chmod = 1;
5839 if ((old_size == sctx->cur_inode_size) ||
5840 (sctx->cur_inode_size > old_size &&
5841 sctx->cur_inode_next_write_offset == sctx->cur_inode_size))
5842 need_truncate = 0;
5843 }
5844
5845 if (S_ISREG(sctx->cur_inode_mode)) {
5846 if (need_send_hole(sctx)) {
5847 if (sctx->cur_inode_last_extent == (u64)-1 ||
5848 sctx->cur_inode_last_extent <
5849 sctx->cur_inode_size) {
5850 ret = get_last_extent(sctx, (u64)-1);
5851 if (ret)
5852 goto out;
5853 }
5854 if (sctx->cur_inode_last_extent <
5855 sctx->cur_inode_size) {
5856 ret = send_hole(sctx, sctx->cur_inode_size);
5857 if (ret)
5858 goto out;
5859 }
5860 }
5861 if (need_truncate) {
5862 ret = send_truncate(sctx, sctx->cur_ino,
5863 sctx->cur_inode_gen,
5864 sctx->cur_inode_size);
5865 if (ret < 0)
5866 goto out;
5867 }
5868 }
5869
5870 if (need_chown) {
5871 ret = send_chown(sctx, sctx->cur_ino, sctx->cur_inode_gen,
5872 left_uid, left_gid);
5873 if (ret < 0)
5874 goto out;
5875 }
5876 if (need_chmod) {
5877 ret = send_chmod(sctx, sctx->cur_ino, sctx->cur_inode_gen,
5878 left_mode);
5879 if (ret < 0)
5880 goto out;
5881 }
5882
5883
5884
5885
5886
5887 if (!is_waiting_for_move(sctx, sctx->cur_ino)) {
5888 ret = apply_children_dir_moves(sctx);
5889 if (ret)
5890 goto out;
5891
5892
5893
5894
5895
5896
5897
5898 sctx->send_progress = sctx->cur_ino + 1;
5899 ret = send_utimes(sctx, sctx->cur_ino, sctx->cur_inode_gen);
5900 if (ret < 0)
5901 goto out;
5902 }
5903
5904out:
5905 return ret;
5906}
5907
5908static int changed_inode(struct send_ctx *sctx,
5909 enum btrfs_compare_tree_result result)
5910{
5911 int ret = 0;
5912 struct btrfs_key *key = sctx->cmp_key;
5913 struct btrfs_inode_item *left_ii = NULL;
5914 struct btrfs_inode_item *right_ii = NULL;
5915 u64 left_gen = 0;
5916 u64 right_gen = 0;
5917
5918 sctx->cur_ino = key->objectid;
5919 sctx->cur_inode_new_gen = 0;
5920 sctx->cur_inode_last_extent = (u64)-1;
5921 sctx->cur_inode_next_write_offset = 0;
5922
5923
5924
5925
5926
5927
5928 sctx->send_progress = sctx->cur_ino;
5929
5930 if (result == BTRFS_COMPARE_TREE_NEW ||
5931 result == BTRFS_COMPARE_TREE_CHANGED) {
5932 left_ii = btrfs_item_ptr(sctx->left_path->nodes[0],
5933 sctx->left_path->slots[0],
5934 struct btrfs_inode_item);
5935 left_gen = btrfs_inode_generation(sctx->left_path->nodes[0],
5936 left_ii);
5937 } else {
5938 right_ii = btrfs_item_ptr(sctx->right_path->nodes[0],
5939 sctx->right_path->slots[0],
5940 struct btrfs_inode_item);
5941 right_gen = btrfs_inode_generation(sctx->right_path->nodes[0],
5942 right_ii);
5943 }
5944 if (result == BTRFS_COMPARE_TREE_CHANGED) {
5945 right_ii = btrfs_item_ptr(sctx->right_path->nodes[0],
5946 sctx->right_path->slots[0],
5947 struct btrfs_inode_item);
5948
5949 right_gen = btrfs_inode_generation(sctx->right_path->nodes[0],
5950 right_ii);
5951
5952
5953
5954
5955
5956
5957 if (left_gen != right_gen &&
5958 sctx->cur_ino != BTRFS_FIRST_FREE_OBJECTID)
5959 sctx->cur_inode_new_gen = 1;
5960 }
5961
5962 if (result == BTRFS_COMPARE_TREE_NEW) {
5963 sctx->cur_inode_gen = left_gen;
5964 sctx->cur_inode_new = 1;
5965 sctx->cur_inode_deleted = 0;
5966 sctx->cur_inode_size = btrfs_inode_size(
5967 sctx->left_path->nodes[0], left_ii);
5968 sctx->cur_inode_mode = btrfs_inode_mode(
5969 sctx->left_path->nodes[0], left_ii);
5970 sctx->cur_inode_rdev = btrfs_inode_rdev(
5971 sctx->left_path->nodes[0], left_ii);
5972 if (sctx->cur_ino != BTRFS_FIRST_FREE_OBJECTID)
5973 ret = send_create_inode_if_needed(sctx);
5974 } else if (result == BTRFS_COMPARE_TREE_DELETED) {
5975 sctx->cur_inode_gen = right_gen;
5976 sctx->cur_inode_new = 0;
5977 sctx->cur_inode_deleted = 1;
5978 sctx->cur_inode_size = btrfs_inode_size(
5979 sctx->right_path->nodes[0], right_ii);
5980 sctx->cur_inode_mode = btrfs_inode_mode(
5981 sctx->right_path->nodes[0], right_ii);
5982 } else if (result == BTRFS_COMPARE_TREE_CHANGED) {
5983
5984
5985
5986
5987
5988
5989
5990 if (sctx->cur_inode_new_gen) {
5991
5992
5993
5994 sctx->cur_inode_gen = right_gen;
5995 sctx->cur_inode_new = 0;
5996 sctx->cur_inode_deleted = 1;
5997 sctx->cur_inode_size = btrfs_inode_size(
5998 sctx->right_path->nodes[0], right_ii);
5999 sctx->cur_inode_mode = btrfs_inode_mode(
6000 sctx->right_path->nodes[0], right_ii);
6001 ret = process_all_refs(sctx,
6002 BTRFS_COMPARE_TREE_DELETED);
6003 if (ret < 0)
6004 goto out;
6005
6006
6007
6008
6009 sctx->cur_inode_gen = left_gen;
6010 sctx->cur_inode_new = 1;
6011 sctx->cur_inode_deleted = 0;
6012 sctx->cur_inode_size = btrfs_inode_size(
6013 sctx->left_path->nodes[0], left_ii);
6014 sctx->cur_inode_mode = btrfs_inode_mode(
6015 sctx->left_path->nodes[0], left_ii);
6016 sctx->cur_inode_rdev = btrfs_inode_rdev(
6017 sctx->left_path->nodes[0], left_ii);
6018 ret = send_create_inode_if_needed(sctx);
6019 if (ret < 0)
6020 goto out;
6021
6022 ret = process_all_refs(sctx, BTRFS_COMPARE_TREE_NEW);
6023 if (ret < 0)
6024 goto out;
6025
6026
6027
6028
6029 sctx->send_progress = sctx->cur_ino + 1;
6030
6031
6032
6033
6034
6035 ret = process_all_extents(sctx);
6036 if (ret < 0)
6037 goto out;
6038 ret = process_all_new_xattrs(sctx);
6039 if (ret < 0)
6040 goto out;
6041 } else {
6042 sctx->cur_inode_gen = left_gen;
6043 sctx->cur_inode_new = 0;
6044 sctx->cur_inode_new_gen = 0;
6045 sctx->cur_inode_deleted = 0;
6046 sctx->cur_inode_size = btrfs_inode_size(
6047 sctx->left_path->nodes[0], left_ii);
6048 sctx->cur_inode_mode = btrfs_inode_mode(
6049 sctx->left_path->nodes[0], left_ii);
6050 }
6051 }
6052
6053out:
6054 return ret;
6055}
6056
6057
6058
6059
6060
6061
6062
6063
6064
6065
6066
6067static int changed_ref(struct send_ctx *sctx,
6068 enum btrfs_compare_tree_result result)
6069{
6070 int ret = 0;
6071
6072 if (sctx->cur_ino != sctx->cmp_key->objectid) {
6073 inconsistent_snapshot_error(sctx, result, "reference");
6074 return -EIO;
6075 }
6076
6077 if (!sctx->cur_inode_new_gen &&
6078 sctx->cur_ino != BTRFS_FIRST_FREE_OBJECTID) {
6079 if (result == BTRFS_COMPARE_TREE_NEW)
6080 ret = record_new_ref(sctx);
6081 else if (result == BTRFS_COMPARE_TREE_DELETED)
6082 ret = record_deleted_ref(sctx);
6083 else if (result == BTRFS_COMPARE_TREE_CHANGED)
6084 ret = record_changed_ref(sctx);
6085 }
6086
6087 return ret;
6088}
6089
6090
6091
6092
6093
6094
6095static int changed_xattr(struct send_ctx *sctx,
6096 enum btrfs_compare_tree_result result)
6097{
6098 int ret = 0;
6099
6100 if (sctx->cur_ino != sctx->cmp_key->objectid) {
6101 inconsistent_snapshot_error(sctx, result, "xattr");
6102 return -EIO;
6103 }
6104
6105 if (!sctx->cur_inode_new_gen && !sctx->cur_inode_deleted) {
6106 if (result == BTRFS_COMPARE_TREE_NEW)
6107 ret = process_new_xattr(sctx);
6108 else if (result == BTRFS_COMPARE_TREE_DELETED)
6109 ret = process_deleted_xattr(sctx);
6110 else if (result == BTRFS_COMPARE_TREE_CHANGED)
6111 ret = process_changed_xattr(sctx);
6112 }
6113
6114 return ret;
6115}
6116
6117
6118
6119
6120
6121
6122static int changed_extent(struct send_ctx *sctx,
6123 enum btrfs_compare_tree_result result)
6124{
6125 int ret = 0;
6126
6127 if (sctx->cur_ino != sctx->cmp_key->objectid) {
6128
6129 if (result == BTRFS_COMPARE_TREE_CHANGED) {
6130 struct extent_buffer *leaf_l;
6131 struct extent_buffer *leaf_r;
6132 struct btrfs_file_extent_item *ei_l;
6133 struct btrfs_file_extent_item *ei_r;
6134
6135 leaf_l = sctx->left_path->nodes[0];
6136 leaf_r = sctx->right_path->nodes[0];
6137 ei_l = btrfs_item_ptr(leaf_l,
6138 sctx->left_path->slots[0],
6139 struct btrfs_file_extent_item);
6140 ei_r = btrfs_item_ptr(leaf_r,
6141 sctx->right_path->slots[0],
6142 struct btrfs_file_extent_item);
6143
6144
6145
6146
6147
6148
6149
6150
6151
6152
6153
6154
6155
6156
6157
6158
6159
6160
6161
6162
6163 if (btrfs_file_extent_generation(leaf_l, ei_l) ==
6164 btrfs_file_extent_generation(leaf_r, ei_r) &&
6165 btrfs_file_extent_ram_bytes(leaf_l, ei_l) ==
6166 btrfs_file_extent_ram_bytes(leaf_r, ei_r) &&
6167 btrfs_file_extent_compression(leaf_l, ei_l) ==
6168 btrfs_file_extent_compression(leaf_r, ei_r) &&
6169 btrfs_file_extent_encryption(leaf_l, ei_l) ==
6170 btrfs_file_extent_encryption(leaf_r, ei_r) &&
6171 btrfs_file_extent_other_encoding(leaf_l, ei_l) ==
6172 btrfs_file_extent_other_encoding(leaf_r, ei_r) &&
6173 btrfs_file_extent_type(leaf_l, ei_l) ==
6174 btrfs_file_extent_type(leaf_r, ei_r) &&
6175 btrfs_file_extent_disk_bytenr(leaf_l, ei_l) !=
6176 btrfs_file_extent_disk_bytenr(leaf_r, ei_r) &&
6177 btrfs_file_extent_disk_num_bytes(leaf_l, ei_l) ==
6178 btrfs_file_extent_disk_num_bytes(leaf_r, ei_r) &&
6179 btrfs_file_extent_offset(leaf_l, ei_l) ==
6180 btrfs_file_extent_offset(leaf_r, ei_r) &&
6181 btrfs_file_extent_num_bytes(leaf_l, ei_l) ==
6182 btrfs_file_extent_num_bytes(leaf_r, ei_r))
6183 return 0;
6184 }
6185
6186 inconsistent_snapshot_error(sctx, result, "extent");
6187 return -EIO;
6188 }
6189
6190 if (!sctx->cur_inode_new_gen && !sctx->cur_inode_deleted) {
6191 if (result != BTRFS_COMPARE_TREE_DELETED)
6192 ret = process_extent(sctx, sctx->left_path,
6193 sctx->cmp_key);
6194 }
6195
6196 return ret;
6197}
6198
6199static int dir_changed(struct send_ctx *sctx, u64 dir)
6200{
6201 u64 orig_gen, new_gen;
6202 int ret;
6203
6204 ret = get_inode_info(sctx->send_root, dir, NULL, &new_gen, NULL, NULL,
6205 NULL, NULL);
6206 if (ret)
6207 return ret;
6208
6209 ret = get_inode_info(sctx->parent_root, dir, NULL, &orig_gen, NULL,
6210 NULL, NULL, NULL);
6211 if (ret)
6212 return ret;
6213
6214 return (orig_gen != new_gen) ? 1 : 0;
6215}
6216
6217static int compare_refs(struct send_ctx *sctx, struct btrfs_path *path,
6218 struct btrfs_key *key)
6219{
6220 struct btrfs_inode_extref *extref;
6221 struct extent_buffer *leaf;
6222 u64 dirid = 0, last_dirid = 0;
6223 unsigned long ptr;
6224 u32 item_size;
6225 u32 cur_offset = 0;
6226 int ref_name_len;
6227 int ret = 0;
6228
6229
6230 if (key->type == BTRFS_INODE_REF_KEY) {
6231 dirid = key->offset;
6232
6233 ret = dir_changed(sctx, dirid);
6234 goto out;
6235 }
6236
6237 leaf = path->nodes[0];
6238 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
6239 ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
6240 while (cur_offset < item_size) {
6241 extref = (struct btrfs_inode_extref *)(ptr +
6242 cur_offset);
6243 dirid = btrfs_inode_extref_parent(leaf, extref);
6244 ref_name_len = btrfs_inode_extref_name_len(leaf, extref);
6245 cur_offset += ref_name_len + sizeof(*extref);
6246 if (dirid == last_dirid)
6247 continue;
6248 ret = dir_changed(sctx, dirid);
6249 if (ret)
6250 break;
6251 last_dirid = dirid;
6252 }
6253out:
6254 return ret;
6255}
6256
6257
6258
6259
6260
6261static int changed_cb(struct btrfs_path *left_path,
6262 struct btrfs_path *right_path,
6263 struct btrfs_key *key,
6264 enum btrfs_compare_tree_result result,
6265 void *ctx)
6266{
6267 int ret = 0;
6268 struct send_ctx *sctx = ctx;
6269
6270 if (result == BTRFS_COMPARE_TREE_SAME) {
6271 if (key->type == BTRFS_INODE_REF_KEY ||
6272 key->type == BTRFS_INODE_EXTREF_KEY) {
6273 ret = compare_refs(sctx, left_path, key);
6274 if (!ret)
6275 return 0;
6276 if (ret < 0)
6277 return ret;
6278 } else if (key->type == BTRFS_EXTENT_DATA_KEY) {
6279 return maybe_send_hole(sctx, left_path, key);
6280 } else {
6281 return 0;
6282 }
6283 result = BTRFS_COMPARE_TREE_CHANGED;
6284 ret = 0;
6285 }
6286
6287 sctx->left_path = left_path;
6288 sctx->right_path = right_path;
6289 sctx->cmp_key = key;
6290
6291 ret = finish_inode_if_needed(sctx, 0);
6292 if (ret < 0)
6293 goto out;
6294
6295
6296 if (key->objectid == BTRFS_FREE_INO_OBJECTID ||
6297 key->objectid == BTRFS_FREE_SPACE_OBJECTID)
6298 goto out;
6299
6300 if (key->type == BTRFS_INODE_ITEM_KEY)
6301 ret = changed_inode(sctx, result);
6302 else if (key->type == BTRFS_INODE_REF_KEY ||
6303 key->type == BTRFS_INODE_EXTREF_KEY)
6304 ret = changed_ref(sctx, result);
6305 else if (key->type == BTRFS_XATTR_ITEM_KEY)
6306 ret = changed_xattr(sctx, result);
6307 else if (key->type == BTRFS_EXTENT_DATA_KEY)
6308 ret = changed_extent(sctx, result);
6309
6310out:
6311 return ret;
6312}
6313
6314static int full_send_tree(struct send_ctx *sctx)
6315{
6316 int ret;
6317 struct btrfs_root *send_root = sctx->send_root;
6318 struct btrfs_key key;
6319 struct btrfs_key found_key;
6320 struct btrfs_path *path;
6321 struct extent_buffer *eb;
6322 int slot;
6323
6324 path = alloc_path_for_send();
6325 if (!path)
6326 return -ENOMEM;
6327
6328 key.objectid = BTRFS_FIRST_FREE_OBJECTID;
6329 key.type = BTRFS_INODE_ITEM_KEY;
6330 key.offset = 0;
6331
6332 ret = btrfs_search_slot_for_read(send_root, &key, path, 1, 0);
6333 if (ret < 0)
6334 goto out;
6335 if (ret)
6336 goto out_finish;
6337
6338 while (1) {
6339 eb = path->nodes[0];
6340 slot = path->slots[0];
6341 btrfs_item_key_to_cpu(eb, &found_key, slot);
6342
6343 ret = changed_cb(path, NULL, &found_key,
6344 BTRFS_COMPARE_TREE_NEW, sctx);
6345 if (ret < 0)
6346 goto out;
6347
6348 key.objectid = found_key.objectid;
6349 key.type = found_key.type;
6350 key.offset = found_key.offset + 1;
6351
6352 ret = btrfs_next_item(send_root, path);
6353 if (ret < 0)
6354 goto out;
6355 if (ret) {
6356 ret = 0;
6357 break;
6358 }
6359 }
6360
6361out_finish:
6362 ret = finish_inode_if_needed(sctx, 1);
6363
6364out:
6365 btrfs_free_path(path);
6366 return ret;
6367}
6368
6369static int send_subvol(struct send_ctx *sctx)
6370{
6371 int ret;
6372
6373 if (!(sctx->flags & BTRFS_SEND_FLAG_OMIT_STREAM_HEADER)) {
6374 ret = send_header(sctx);
6375 if (ret < 0)
6376 goto out;
6377 }
6378
6379 ret = send_subvol_begin(sctx);
6380 if (ret < 0)
6381 goto out;
6382
6383 if (sctx->parent_root) {
6384 ret = btrfs_compare_trees(sctx->send_root, sctx->parent_root,
6385 changed_cb, sctx);
6386 if (ret < 0)
6387 goto out;
6388 ret = finish_inode_if_needed(sctx, 1);
6389 if (ret < 0)
6390 goto out;
6391 } else {
6392 ret = full_send_tree(sctx);
6393 if (ret < 0)
6394 goto out;
6395 }
6396
6397out:
6398 free_recorded_refs(sctx);
6399 return ret;
6400}
6401
6402
6403
6404
6405
6406
6407
6408
6409
6410
6411
6412
6413
6414
6415static int ensure_commit_roots_uptodate(struct send_ctx *sctx)
6416{
6417 int i;
6418 struct btrfs_trans_handle *trans = NULL;
6419
6420again:
6421 if (sctx->parent_root &&
6422 sctx->parent_root->node != sctx->parent_root->commit_root)
6423 goto commit_trans;
6424
6425 for (i = 0; i < sctx->clone_roots_cnt; i++)
6426 if (sctx->clone_roots[i].root->node !=
6427 sctx->clone_roots[i].root->commit_root)
6428 goto commit_trans;
6429
6430 if (trans)
6431 return btrfs_end_transaction(trans);
6432
6433 return 0;
6434
6435commit_trans:
6436
6437 if (!trans) {
6438 trans = btrfs_join_transaction(sctx->send_root);
6439 if (IS_ERR(trans))
6440 return PTR_ERR(trans);
6441 goto again;
6442 }
6443
6444 return btrfs_commit_transaction(trans);
6445}
6446
6447static void btrfs_root_dec_send_in_progress(struct btrfs_root* root)
6448{
6449 spin_lock(&root->root_item_lock);
6450 root->send_in_progress--;
6451
6452
6453
6454
6455 if (root->send_in_progress < 0)
6456 btrfs_err(root->fs_info,
6457 "send_in_progres unbalanced %d root %llu",
6458 root->send_in_progress, root->root_key.objectid);
6459 spin_unlock(&root->root_item_lock);
6460}
6461
6462long btrfs_ioctl_send(struct file *mnt_file, struct btrfs_ioctl_send_args *arg)
6463{
6464 int ret = 0;
6465 struct btrfs_root *send_root = BTRFS_I(file_inode(mnt_file))->root;
6466 struct btrfs_fs_info *fs_info = send_root->fs_info;
6467 struct btrfs_root *clone_root;
6468 struct btrfs_key key;
6469 struct send_ctx *sctx = NULL;
6470 u32 i;
6471 u64 *clone_sources_tmp = NULL;
6472 int clone_sources_to_rollback = 0;
6473 unsigned alloc_size;
6474 int sort_clone_roots = 0;
6475 int index;
6476
6477 if (!capable(CAP_SYS_ADMIN))
6478 return -EPERM;
6479
6480
6481
6482
6483
6484 spin_lock(&send_root->root_item_lock);
6485 send_root->send_in_progress++;
6486 spin_unlock(&send_root->root_item_lock);
6487
6488
6489
6490
6491
6492 WARN_ON(send_root->orphan_cleanup_state != ORPHAN_CLEANUP_DONE);
6493
6494
6495
6496
6497
6498 if (!btrfs_root_readonly(send_root)) {
6499 ret = -EPERM;
6500 goto out;
6501 }
6502
6503
6504
6505
6506
6507
6508 if (arg->clone_sources_count >
6509 ULONG_MAX / sizeof(struct clone_root) - 1) {
6510 ret = -EINVAL;
6511 goto out;
6512 }
6513
6514 if (!access_ok(VERIFY_READ, arg->clone_sources,
6515 sizeof(*arg->clone_sources) *
6516 arg->clone_sources_count)) {
6517 ret = -EFAULT;
6518 goto out;
6519 }
6520
6521 if (arg->flags & ~BTRFS_SEND_FLAG_MASK) {
6522 ret = -EINVAL;
6523 goto out;
6524 }
6525
6526 sctx = kzalloc(sizeof(struct send_ctx), GFP_KERNEL);
6527 if (!sctx) {
6528 ret = -ENOMEM;
6529 goto out;
6530 }
6531
6532 INIT_LIST_HEAD(&sctx->new_refs);
6533 INIT_LIST_HEAD(&sctx->deleted_refs);
6534 INIT_RADIX_TREE(&sctx->name_cache, GFP_KERNEL);
6535 INIT_LIST_HEAD(&sctx->name_cache_list);
6536
6537 sctx->flags = arg->flags;
6538
6539 sctx->send_filp = fget(arg->send_fd);
6540 if (!sctx->send_filp) {
6541 ret = -EBADF;
6542 goto out;
6543 }
6544
6545 sctx->send_root = send_root;
6546
6547
6548
6549
6550 if (btrfs_root_dead(sctx->send_root)) {
6551 ret = -EPERM;
6552 goto out;
6553 }
6554
6555 sctx->clone_roots_cnt = arg->clone_sources_count;
6556
6557 sctx->send_max_size = BTRFS_SEND_BUF_SIZE;
6558 sctx->send_buf = kvmalloc(sctx->send_max_size, GFP_KERNEL);
6559 if (!sctx->send_buf) {
6560 ret = -ENOMEM;
6561 goto out;
6562 }
6563
6564 sctx->read_buf = kvmalloc(BTRFS_SEND_READ_SIZE, GFP_KERNEL);
6565 if (!sctx->read_buf) {
6566 ret = -ENOMEM;
6567 goto out;
6568 }
6569
6570 sctx->pending_dir_moves = RB_ROOT;
6571 sctx->waiting_dir_moves = RB_ROOT;
6572 sctx->orphan_dirs = RB_ROOT;
6573
6574 alloc_size = sizeof(struct clone_root) * (arg->clone_sources_count + 1);
6575
6576 sctx->clone_roots = kzalloc(alloc_size, GFP_KERNEL);
6577 if (!sctx->clone_roots) {
6578 ret = -ENOMEM;
6579 goto out;
6580 }
6581
6582 alloc_size = arg->clone_sources_count * sizeof(*arg->clone_sources);
6583
6584 if (arg->clone_sources_count) {
6585 clone_sources_tmp = kvmalloc(alloc_size, GFP_KERNEL);
6586 if (!clone_sources_tmp) {
6587 ret = -ENOMEM;
6588 goto out;
6589 }
6590
6591 ret = copy_from_user(clone_sources_tmp, arg->clone_sources,
6592 alloc_size);
6593 if (ret) {
6594 ret = -EFAULT;
6595 goto out;
6596 }
6597
6598 for (i = 0; i < arg->clone_sources_count; i++) {
6599 key.objectid = clone_sources_tmp[i];
6600 key.type = BTRFS_ROOT_ITEM_KEY;
6601 key.offset = (u64)-1;
6602
6603 index = srcu_read_lock(&fs_info->subvol_srcu);
6604
6605 clone_root = btrfs_read_fs_root_no_name(fs_info, &key);
6606 if (IS_ERR(clone_root)) {
6607 srcu_read_unlock(&fs_info->subvol_srcu, index);
6608 ret = PTR_ERR(clone_root);
6609 goto out;
6610 }
6611 spin_lock(&clone_root->root_item_lock);
6612 if (!btrfs_root_readonly(clone_root) ||
6613 btrfs_root_dead(clone_root)) {
6614 spin_unlock(&clone_root->root_item_lock);
6615 srcu_read_unlock(&fs_info->subvol_srcu, index);
6616 ret = -EPERM;
6617 goto out;
6618 }
6619 clone_root->send_in_progress++;
6620 spin_unlock(&clone_root->root_item_lock);
6621 srcu_read_unlock(&fs_info->subvol_srcu, index);
6622
6623 sctx->clone_roots[i].root = clone_root;
6624 clone_sources_to_rollback = i + 1;
6625 }
6626 kvfree(clone_sources_tmp);
6627 clone_sources_tmp = NULL;
6628 }
6629
6630 if (arg->parent_root) {
6631 key.objectid = arg->parent_root;
6632 key.type = BTRFS_ROOT_ITEM_KEY;
6633 key.offset = (u64)-1;
6634
6635 index = srcu_read_lock(&fs_info->subvol_srcu);
6636
6637 sctx->parent_root = btrfs_read_fs_root_no_name(fs_info, &key);
6638 if (IS_ERR(sctx->parent_root)) {
6639 srcu_read_unlock(&fs_info->subvol_srcu, index);
6640 ret = PTR_ERR(sctx->parent_root);
6641 goto out;
6642 }
6643
6644 spin_lock(&sctx->parent_root->root_item_lock);
6645 sctx->parent_root->send_in_progress++;
6646 if (!btrfs_root_readonly(sctx->parent_root) ||
6647 btrfs_root_dead(sctx->parent_root)) {
6648 spin_unlock(&sctx->parent_root->root_item_lock);
6649 srcu_read_unlock(&fs_info->subvol_srcu, index);
6650 ret = -EPERM;
6651 goto out;
6652 }
6653 spin_unlock(&sctx->parent_root->root_item_lock);
6654
6655 srcu_read_unlock(&fs_info->subvol_srcu, index);
6656 }
6657
6658
6659
6660
6661
6662
6663 sctx->clone_roots[sctx->clone_roots_cnt++].root = sctx->send_root;
6664
6665
6666 sort(sctx->clone_roots, sctx->clone_roots_cnt,
6667 sizeof(*sctx->clone_roots), __clone_root_cmp_sort,
6668 NULL);
6669 sort_clone_roots = 1;
6670
6671 ret = ensure_commit_roots_uptodate(sctx);
6672 if (ret)
6673 goto out;
6674
6675 current->journal_info = BTRFS_SEND_TRANS_STUB;
6676 ret = send_subvol(sctx);
6677 current->journal_info = NULL;
6678 if (ret < 0)
6679 goto out;
6680
6681 if (!(sctx->flags & BTRFS_SEND_FLAG_OMIT_END_CMD)) {
6682 ret = begin_cmd(sctx, BTRFS_SEND_C_END);
6683 if (ret < 0)
6684 goto out;
6685 ret = send_cmd(sctx);
6686 if (ret < 0)
6687 goto out;
6688 }
6689
6690out:
6691 WARN_ON(sctx && !ret && !RB_EMPTY_ROOT(&sctx->pending_dir_moves));
6692 while (sctx && !RB_EMPTY_ROOT(&sctx->pending_dir_moves)) {
6693 struct rb_node *n;
6694 struct pending_dir_move *pm;
6695
6696 n = rb_first(&sctx->pending_dir_moves);
6697 pm = rb_entry(n, struct pending_dir_move, node);
6698 while (!list_empty(&pm->list)) {
6699 struct pending_dir_move *pm2;
6700
6701 pm2 = list_first_entry(&pm->list,
6702 struct pending_dir_move, list);
6703 free_pending_move(sctx, pm2);
6704 }
6705 free_pending_move(sctx, pm);
6706 }
6707
6708 WARN_ON(sctx && !ret && !RB_EMPTY_ROOT(&sctx->waiting_dir_moves));
6709 while (sctx && !RB_EMPTY_ROOT(&sctx->waiting_dir_moves)) {
6710 struct rb_node *n;
6711 struct waiting_dir_move *dm;
6712
6713 n = rb_first(&sctx->waiting_dir_moves);
6714 dm = rb_entry(n, struct waiting_dir_move, node);
6715 rb_erase(&dm->node, &sctx->waiting_dir_moves);
6716 kfree(dm);
6717 }
6718
6719 WARN_ON(sctx && !ret && !RB_EMPTY_ROOT(&sctx->orphan_dirs));
6720 while (sctx && !RB_EMPTY_ROOT(&sctx->orphan_dirs)) {
6721 struct rb_node *n;
6722 struct orphan_dir_info *odi;
6723
6724 n = rb_first(&sctx->orphan_dirs);
6725 odi = rb_entry(n, struct orphan_dir_info, node);
6726 free_orphan_dir_info(sctx, odi);
6727 }
6728
6729 if (sort_clone_roots) {
6730 for (i = 0; i < sctx->clone_roots_cnt; i++)
6731 btrfs_root_dec_send_in_progress(
6732 sctx->clone_roots[i].root);
6733 } else {
6734 for (i = 0; sctx && i < clone_sources_to_rollback; i++)
6735 btrfs_root_dec_send_in_progress(
6736 sctx->clone_roots[i].root);
6737
6738 btrfs_root_dec_send_in_progress(send_root);
6739 }
6740 if (sctx && !IS_ERR_OR_NULL(sctx->parent_root))
6741 btrfs_root_dec_send_in_progress(sctx->parent_root);
6742
6743 kvfree(clone_sources_tmp);
6744
6745 if (sctx) {
6746 if (sctx->send_filp)
6747 fput(sctx->send_filp);
6748
6749 kvfree(sctx->clone_roots);
6750 kvfree(sctx->send_buf);
6751 kvfree(sctx->read_buf);
6752
6753 name_cache_free(sctx);
6754
6755 kfree(sctx);
6756 }
6757
6758 return ret;
6759}
6760