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