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