ocfs2: fix locking for res->tracking and dlm->tracking_list
[linux/fpc-iii.git] / fs / btrfs / send.c
blob83c73738165e22ab3ef68191b55e8b54dbc76604
1 /*
2 * Copyright (C) 2012 Alexander Block. All rights reserved.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
19 #include <linux/bsearch.h>
20 #include <linux/fs.h>
21 #include <linux/file.h>
22 #include <linux/sort.h>
23 #include <linux/mount.h>
24 #include <linux/xattr.h>
25 #include <linux/posix_acl_xattr.h>
26 #include <linux/radix-tree.h>
27 #include <linux/vmalloc.h>
28 #include <linux/string.h>
30 #include "send.h"
31 #include "backref.h"
32 #include "hash.h"
33 #include "locking.h"
34 #include "disk-io.h"
35 #include "btrfs_inode.h"
36 #include "transaction.h"
38 static int g_verbose = 0;
40 #define verbose_printk(...) if (g_verbose) printk(__VA_ARGS__)
43 * A fs_path is a helper to dynamically build path names with unknown size.
44 * It reallocates the internal buffer on demand.
45 * It allows fast adding of path elements on the right side (normal path) and
46 * fast adding to the left side (reversed path). A reversed path can also be
47 * unreversed if needed.
49 struct fs_path {
50 union {
51 struct {
52 char *start;
53 char *end;
55 char *buf;
56 unsigned short buf_len:15;
57 unsigned short reversed:1;
58 char inline_buf[];
61 * Average path length does not exceed 200 bytes, we'll have
62 * better packing in the slab and higher chance to satisfy
63 * a allocation later during send.
65 char pad[256];
68 #define FS_PATH_INLINE_SIZE \
69 (sizeof(struct fs_path) - offsetof(struct fs_path, inline_buf))
72 /* reused for each extent */
73 struct clone_root {
74 struct btrfs_root *root;
75 u64 ino;
76 u64 offset;
78 u64 found_refs;
81 #define SEND_CTX_MAX_NAME_CACHE_SIZE 128
82 #define SEND_CTX_NAME_CACHE_CLEAN_SIZE (SEND_CTX_MAX_NAME_CACHE_SIZE * 2)
84 struct send_ctx {
85 struct file *send_filp;
86 loff_t send_off;
87 char *send_buf;
88 u32 send_size;
89 u32 send_max_size;
90 u64 total_send_size;
91 u64 cmd_send_size[BTRFS_SEND_C_MAX + 1];
92 u64 flags; /* 'flags' member of btrfs_ioctl_send_args is u64 */
94 struct btrfs_root *send_root;
95 struct btrfs_root *parent_root;
96 struct clone_root *clone_roots;
97 int clone_roots_cnt;
99 /* current state of the compare_tree call */
100 struct btrfs_path *left_path;
101 struct btrfs_path *right_path;
102 struct btrfs_key *cmp_key;
105 * infos of the currently processed inode. In case of deleted inodes,
106 * these are the values from the deleted inode.
108 u64 cur_ino;
109 u64 cur_inode_gen;
110 int cur_inode_new;
111 int cur_inode_new_gen;
112 int cur_inode_deleted;
113 u64 cur_inode_size;
114 u64 cur_inode_mode;
115 u64 cur_inode_rdev;
116 u64 cur_inode_last_extent;
118 u64 send_progress;
120 struct list_head new_refs;
121 struct list_head deleted_refs;
123 struct radix_tree_root name_cache;
124 struct list_head name_cache_list;
125 int name_cache_size;
127 struct file_ra_state ra;
129 char *read_buf;
132 * We process inodes by their increasing order, so if before an
133 * incremental send we reverse the parent/child relationship of
134 * directories such that a directory with a lower inode number was
135 * the parent of a directory with a higher inode number, and the one
136 * becoming the new parent got renamed too, we can't rename/move the
137 * directory with lower inode number when we finish processing it - we
138 * must process the directory with higher inode number first, then
139 * rename/move it and then rename/move the directory with lower inode
140 * number. Example follows.
142 * Tree state when the first send was performed:
145 * |-- a (ino 257)
146 * |-- b (ino 258)
149 * |-- c (ino 259)
150 * | |-- d (ino 260)
152 * |-- c2 (ino 261)
154 * Tree state when the second (incremental) send is performed:
157 * |-- a (ino 257)
158 * |-- b (ino 258)
159 * |-- c2 (ino 261)
160 * |-- d2 (ino 260)
161 * |-- cc (ino 259)
163 * The sequence of steps that lead to the second state was:
165 * mv /a/b/c/d /a/b/c2/d2
166 * mv /a/b/c /a/b/c2/d2/cc
168 * "c" has lower inode number, but we can't move it (2nd mv operation)
169 * before we move "d", which has higher inode number.
171 * So we just memorize which move/rename operations must be performed
172 * later when their respective parent is processed and moved/renamed.
175 /* Indexed by parent directory inode number. */
176 struct rb_root pending_dir_moves;
179 * Reverse index, indexed by the inode number of a directory that
180 * is waiting for the move/rename of its immediate parent before its
181 * own move/rename can be performed.
183 struct rb_root waiting_dir_moves;
186 * A directory that is going to be rm'ed might have a child directory
187 * which is in the pending directory moves index above. In this case,
188 * the directory can only be removed after the move/rename of its child
189 * is performed. Example:
191 * Parent snapshot:
193 * . (ino 256)
194 * |-- a/ (ino 257)
195 * |-- b/ (ino 258)
196 * |-- c/ (ino 259)
197 * | |-- x/ (ino 260)
199 * |-- y/ (ino 261)
201 * Send snapshot:
203 * . (ino 256)
204 * |-- a/ (ino 257)
205 * |-- b/ (ino 258)
206 * |-- YY/ (ino 261)
207 * |-- x/ (ino 260)
209 * Sequence of steps that lead to the send snapshot:
210 * rm -f /a/b/c/foo.txt
211 * mv /a/b/y /a/b/YY
212 * mv /a/b/c/x /a/b/YY
213 * rmdir /a/b/c
215 * When the child is processed, its move/rename is delayed until its
216 * parent is processed (as explained above), but all other operations
217 * like update utimes, chown, chgrp, etc, are performed and the paths
218 * that it uses for those operations must use the orphanized name of
219 * its parent (the directory we're going to rm later), so we need to
220 * memorize that name.
222 * Indexed by the inode number of the directory to be deleted.
224 struct rb_root orphan_dirs;
227 struct pending_dir_move {
228 struct rb_node node;
229 struct list_head list;
230 u64 parent_ino;
231 u64 ino;
232 u64 gen;
233 bool is_orphan;
234 struct list_head update_refs;
237 struct waiting_dir_move {
238 struct rb_node node;
239 u64 ino;
241 * There might be some directory that could not be removed because it
242 * was waiting for this directory inode to be moved first. Therefore
243 * after this directory is moved, we can try to rmdir the ino rmdir_ino.
245 u64 rmdir_ino;
246 bool orphanized;
249 struct orphan_dir_info {
250 struct rb_node node;
251 u64 ino;
252 u64 gen;
255 struct name_cache_entry {
256 struct list_head list;
258 * radix_tree has only 32bit entries but we need to handle 64bit inums.
259 * We use the lower 32bit of the 64bit inum to store it in the tree. If
260 * more then one inum would fall into the same entry, we use radix_list
261 * to store the additional entries. radix_list is also used to store
262 * entries where two entries have the same inum but different
263 * generations.
265 struct list_head radix_list;
266 u64 ino;
267 u64 gen;
268 u64 parent_ino;
269 u64 parent_gen;
270 int ret;
271 int need_later_update;
272 int name_len;
273 char name[];
276 static int is_waiting_for_move(struct send_ctx *sctx, u64 ino);
278 static struct waiting_dir_move *
279 get_waiting_dir_move(struct send_ctx *sctx, u64 ino);
281 static int is_waiting_for_rm(struct send_ctx *sctx, u64 dir_ino);
283 static int need_send_hole(struct send_ctx *sctx)
285 return (sctx->parent_root && !sctx->cur_inode_new &&
286 !sctx->cur_inode_new_gen && !sctx->cur_inode_deleted &&
287 S_ISREG(sctx->cur_inode_mode));
290 static void fs_path_reset(struct fs_path *p)
292 if (p->reversed) {
293 p->start = p->buf + p->buf_len - 1;
294 p->end = p->start;
295 *p->start = 0;
296 } else {
297 p->start = p->buf;
298 p->end = p->start;
299 *p->start = 0;
303 static struct fs_path *fs_path_alloc(void)
305 struct fs_path *p;
307 p = kmalloc(sizeof(*p), GFP_NOFS);
308 if (!p)
309 return NULL;
310 p->reversed = 0;
311 p->buf = p->inline_buf;
312 p->buf_len = FS_PATH_INLINE_SIZE;
313 fs_path_reset(p);
314 return p;
317 static struct fs_path *fs_path_alloc_reversed(void)
319 struct fs_path *p;
321 p = fs_path_alloc();
322 if (!p)
323 return NULL;
324 p->reversed = 1;
325 fs_path_reset(p);
326 return p;
329 static void fs_path_free(struct fs_path *p)
331 if (!p)
332 return;
333 if (p->buf != p->inline_buf)
334 kfree(p->buf);
335 kfree(p);
338 static int fs_path_len(struct fs_path *p)
340 return p->end - p->start;
343 static int fs_path_ensure_buf(struct fs_path *p, int len)
345 char *tmp_buf;
346 int path_len;
347 int old_buf_len;
349 len++;
351 if (p->buf_len >= len)
352 return 0;
354 if (len > PATH_MAX) {
355 WARN_ON(1);
356 return -ENOMEM;
359 path_len = p->end - p->start;
360 old_buf_len = p->buf_len;
363 * First time the inline_buf does not suffice
365 if (p->buf == p->inline_buf) {
366 tmp_buf = kmalloc(len, GFP_NOFS);
367 if (tmp_buf)
368 memcpy(tmp_buf, p->buf, old_buf_len);
369 } else {
370 tmp_buf = krealloc(p->buf, len, GFP_NOFS);
372 if (!tmp_buf)
373 return -ENOMEM;
374 p->buf = tmp_buf;
376 * The real size of the buffer is bigger, this will let the fast path
377 * happen most of the time
379 p->buf_len = ksize(p->buf);
381 if (p->reversed) {
382 tmp_buf = p->buf + old_buf_len - path_len - 1;
383 p->end = p->buf + p->buf_len - 1;
384 p->start = p->end - path_len;
385 memmove(p->start, tmp_buf, path_len + 1);
386 } else {
387 p->start = p->buf;
388 p->end = p->start + path_len;
390 return 0;
393 static int fs_path_prepare_for_add(struct fs_path *p, int name_len,
394 char **prepared)
396 int ret;
397 int new_len;
399 new_len = p->end - p->start + name_len;
400 if (p->start != p->end)
401 new_len++;
402 ret = fs_path_ensure_buf(p, new_len);
403 if (ret < 0)
404 goto out;
406 if (p->reversed) {
407 if (p->start != p->end)
408 *--p->start = '/';
409 p->start -= name_len;
410 *prepared = p->start;
411 } else {
412 if (p->start != p->end)
413 *p->end++ = '/';
414 *prepared = p->end;
415 p->end += name_len;
416 *p->end = 0;
419 out:
420 return ret;
423 static int fs_path_add(struct fs_path *p, const char *name, int name_len)
425 int ret;
426 char *prepared;
428 ret = fs_path_prepare_for_add(p, name_len, &prepared);
429 if (ret < 0)
430 goto out;
431 memcpy(prepared, name, name_len);
433 out:
434 return ret;
437 static int fs_path_add_path(struct fs_path *p, struct fs_path *p2)
439 int ret;
440 char *prepared;
442 ret = fs_path_prepare_for_add(p, p2->end - p2->start, &prepared);
443 if (ret < 0)
444 goto out;
445 memcpy(prepared, p2->start, p2->end - p2->start);
447 out:
448 return ret;
451 static int fs_path_add_from_extent_buffer(struct fs_path *p,
452 struct extent_buffer *eb,
453 unsigned long off, int len)
455 int ret;
456 char *prepared;
458 ret = fs_path_prepare_for_add(p, len, &prepared);
459 if (ret < 0)
460 goto out;
462 read_extent_buffer(eb, prepared, off, len);
464 out:
465 return ret;
468 static int fs_path_copy(struct fs_path *p, struct fs_path *from)
470 int ret;
472 p->reversed = from->reversed;
473 fs_path_reset(p);
475 ret = fs_path_add_path(p, from);
477 return ret;
481 static void fs_path_unreverse(struct fs_path *p)
483 char *tmp;
484 int len;
486 if (!p->reversed)
487 return;
489 tmp = p->start;
490 len = p->end - p->start;
491 p->start = p->buf;
492 p->end = p->start + len;
493 memmove(p->start, tmp, len + 1);
494 p->reversed = 0;
497 static struct btrfs_path *alloc_path_for_send(void)
499 struct btrfs_path *path;
501 path = btrfs_alloc_path();
502 if (!path)
503 return NULL;
504 path->search_commit_root = 1;
505 path->skip_locking = 1;
506 path->need_commit_sem = 1;
507 return path;
510 static int write_buf(struct file *filp, const void *buf, u32 len, loff_t *off)
512 int ret;
513 mm_segment_t old_fs;
514 u32 pos = 0;
516 old_fs = get_fs();
517 set_fs(KERNEL_DS);
519 while (pos < len) {
520 ret = vfs_write(filp, (__force const char __user *)buf + pos,
521 len - pos, off);
522 /* TODO handle that correctly */
523 /*if (ret == -ERESTARTSYS) {
524 continue;
526 if (ret < 0)
527 goto out;
528 if (ret == 0) {
529 ret = -EIO;
530 goto out;
532 pos += ret;
535 ret = 0;
537 out:
538 set_fs(old_fs);
539 return ret;
542 static int tlv_put(struct send_ctx *sctx, u16 attr, const void *data, int len)
544 struct btrfs_tlv_header *hdr;
545 int total_len = sizeof(*hdr) + len;
546 int left = sctx->send_max_size - sctx->send_size;
548 if (unlikely(left < total_len))
549 return -EOVERFLOW;
551 hdr = (struct btrfs_tlv_header *) (sctx->send_buf + sctx->send_size);
552 hdr->tlv_type = cpu_to_le16(attr);
553 hdr->tlv_len = cpu_to_le16(len);
554 memcpy(hdr + 1, data, len);
555 sctx->send_size += total_len;
557 return 0;
560 #define TLV_PUT_DEFINE_INT(bits) \
561 static int tlv_put_u##bits(struct send_ctx *sctx, \
562 u##bits attr, u##bits value) \
564 __le##bits __tmp = cpu_to_le##bits(value); \
565 return tlv_put(sctx, attr, &__tmp, sizeof(__tmp)); \
568 TLV_PUT_DEFINE_INT(64)
570 static int tlv_put_string(struct send_ctx *sctx, u16 attr,
571 const char *str, int len)
573 if (len == -1)
574 len = strlen(str);
575 return tlv_put(sctx, attr, str, len);
578 static int tlv_put_uuid(struct send_ctx *sctx, u16 attr,
579 const u8 *uuid)
581 return tlv_put(sctx, attr, uuid, BTRFS_UUID_SIZE);
584 static int tlv_put_btrfs_timespec(struct send_ctx *sctx, u16 attr,
585 struct extent_buffer *eb,
586 struct btrfs_timespec *ts)
588 struct btrfs_timespec bts;
589 read_extent_buffer(eb, &bts, (unsigned long)ts, sizeof(bts));
590 return tlv_put(sctx, attr, &bts, sizeof(bts));
594 #define TLV_PUT(sctx, attrtype, attrlen, data) \
595 do { \
596 ret = tlv_put(sctx, attrtype, attrlen, data); \
597 if (ret < 0) \
598 goto tlv_put_failure; \
599 } while (0)
601 #define TLV_PUT_INT(sctx, attrtype, bits, value) \
602 do { \
603 ret = tlv_put_u##bits(sctx, attrtype, value); \
604 if (ret < 0) \
605 goto tlv_put_failure; \
606 } while (0)
608 #define TLV_PUT_U8(sctx, attrtype, data) TLV_PUT_INT(sctx, attrtype, 8, data)
609 #define TLV_PUT_U16(sctx, attrtype, data) TLV_PUT_INT(sctx, attrtype, 16, data)
610 #define TLV_PUT_U32(sctx, attrtype, data) TLV_PUT_INT(sctx, attrtype, 32, data)
611 #define TLV_PUT_U64(sctx, attrtype, data) TLV_PUT_INT(sctx, attrtype, 64, data)
612 #define TLV_PUT_STRING(sctx, attrtype, str, len) \
613 do { \
614 ret = tlv_put_string(sctx, attrtype, str, len); \
615 if (ret < 0) \
616 goto tlv_put_failure; \
617 } while (0)
618 #define TLV_PUT_PATH(sctx, attrtype, p) \
619 do { \
620 ret = tlv_put_string(sctx, attrtype, p->start, \
621 p->end - p->start); \
622 if (ret < 0) \
623 goto tlv_put_failure; \
624 } while(0)
625 #define TLV_PUT_UUID(sctx, attrtype, uuid) \
626 do { \
627 ret = tlv_put_uuid(sctx, attrtype, uuid); \
628 if (ret < 0) \
629 goto tlv_put_failure; \
630 } while (0)
631 #define TLV_PUT_BTRFS_TIMESPEC(sctx, attrtype, eb, ts) \
632 do { \
633 ret = tlv_put_btrfs_timespec(sctx, attrtype, eb, ts); \
634 if (ret < 0) \
635 goto tlv_put_failure; \
636 } while (0)
638 static int send_header(struct send_ctx *sctx)
640 struct btrfs_stream_header hdr;
642 strcpy(hdr.magic, BTRFS_SEND_STREAM_MAGIC);
643 hdr.version = cpu_to_le32(BTRFS_SEND_STREAM_VERSION);
645 return write_buf(sctx->send_filp, &hdr, sizeof(hdr),
646 &sctx->send_off);
650 * For each command/item we want to send to userspace, we call this function.
652 static int begin_cmd(struct send_ctx *sctx, int cmd)
654 struct btrfs_cmd_header *hdr;
656 if (WARN_ON(!sctx->send_buf))
657 return -EINVAL;
659 BUG_ON(sctx->send_size);
661 sctx->send_size += sizeof(*hdr);
662 hdr = (struct btrfs_cmd_header *)sctx->send_buf;
663 hdr->cmd = cpu_to_le16(cmd);
665 return 0;
668 static int send_cmd(struct send_ctx *sctx)
670 int ret;
671 struct btrfs_cmd_header *hdr;
672 u32 crc;
674 hdr = (struct btrfs_cmd_header *)sctx->send_buf;
675 hdr->len = cpu_to_le32(sctx->send_size - sizeof(*hdr));
676 hdr->crc = 0;
678 crc = btrfs_crc32c(0, (unsigned char *)sctx->send_buf, sctx->send_size);
679 hdr->crc = cpu_to_le32(crc);
681 ret = write_buf(sctx->send_filp, sctx->send_buf, sctx->send_size,
682 &sctx->send_off);
684 sctx->total_send_size += sctx->send_size;
685 sctx->cmd_send_size[le16_to_cpu(hdr->cmd)] += sctx->send_size;
686 sctx->send_size = 0;
688 return ret;
692 * Sends a move instruction to user space
694 static int send_rename(struct send_ctx *sctx,
695 struct fs_path *from, struct fs_path *to)
697 int ret;
699 verbose_printk("btrfs: send_rename %s -> %s\n", from->start, to->start);
701 ret = begin_cmd(sctx, BTRFS_SEND_C_RENAME);
702 if (ret < 0)
703 goto out;
705 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, from);
706 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH_TO, to);
708 ret = send_cmd(sctx);
710 tlv_put_failure:
711 out:
712 return ret;
716 * Sends a link instruction to user space
718 static int send_link(struct send_ctx *sctx,
719 struct fs_path *path, struct fs_path *lnk)
721 int ret;
723 verbose_printk("btrfs: send_link %s -> %s\n", path->start, lnk->start);
725 ret = begin_cmd(sctx, BTRFS_SEND_C_LINK);
726 if (ret < 0)
727 goto out;
729 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, path);
730 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH_LINK, lnk);
732 ret = send_cmd(sctx);
734 tlv_put_failure:
735 out:
736 return ret;
740 * Sends an unlink instruction to user space
742 static int send_unlink(struct send_ctx *sctx, struct fs_path *path)
744 int ret;
746 verbose_printk("btrfs: send_unlink %s\n", path->start);
748 ret = begin_cmd(sctx, BTRFS_SEND_C_UNLINK);
749 if (ret < 0)
750 goto out;
752 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, path);
754 ret = send_cmd(sctx);
756 tlv_put_failure:
757 out:
758 return ret;
762 * Sends a rmdir instruction to user space
764 static int send_rmdir(struct send_ctx *sctx, struct fs_path *path)
766 int ret;
768 verbose_printk("btrfs: send_rmdir %s\n", path->start);
770 ret = begin_cmd(sctx, BTRFS_SEND_C_RMDIR);
771 if (ret < 0)
772 goto out;
774 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, path);
776 ret = send_cmd(sctx);
778 tlv_put_failure:
779 out:
780 return ret;
784 * Helper function to retrieve some fields from an inode item.
786 static int __get_inode_info(struct btrfs_root *root, struct btrfs_path *path,
787 u64 ino, u64 *size, u64 *gen, u64 *mode, u64 *uid,
788 u64 *gid, u64 *rdev)
790 int ret;
791 struct btrfs_inode_item *ii;
792 struct btrfs_key key;
794 key.objectid = ino;
795 key.type = BTRFS_INODE_ITEM_KEY;
796 key.offset = 0;
797 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
798 if (ret) {
799 if (ret > 0)
800 ret = -ENOENT;
801 return ret;
804 ii = btrfs_item_ptr(path->nodes[0], path->slots[0],
805 struct btrfs_inode_item);
806 if (size)
807 *size = btrfs_inode_size(path->nodes[0], ii);
808 if (gen)
809 *gen = btrfs_inode_generation(path->nodes[0], ii);
810 if (mode)
811 *mode = btrfs_inode_mode(path->nodes[0], ii);
812 if (uid)
813 *uid = btrfs_inode_uid(path->nodes[0], ii);
814 if (gid)
815 *gid = btrfs_inode_gid(path->nodes[0], ii);
816 if (rdev)
817 *rdev = btrfs_inode_rdev(path->nodes[0], ii);
819 return ret;
822 static int get_inode_info(struct btrfs_root *root,
823 u64 ino, u64 *size, u64 *gen,
824 u64 *mode, u64 *uid, u64 *gid,
825 u64 *rdev)
827 struct btrfs_path *path;
828 int ret;
830 path = alloc_path_for_send();
831 if (!path)
832 return -ENOMEM;
833 ret = __get_inode_info(root, path, ino, size, gen, mode, uid, gid,
834 rdev);
835 btrfs_free_path(path);
836 return ret;
839 typedef int (*iterate_inode_ref_t)(int num, u64 dir, int index,
840 struct fs_path *p,
841 void *ctx);
844 * Helper function to iterate the entries in ONE btrfs_inode_ref or
845 * btrfs_inode_extref.
846 * The iterate callback may return a non zero value to stop iteration. This can
847 * be a negative value for error codes or 1 to simply stop it.
849 * path must point to the INODE_REF or INODE_EXTREF when called.
851 static int iterate_inode_ref(struct btrfs_root *root, struct btrfs_path *path,
852 struct btrfs_key *found_key, int resolve,
853 iterate_inode_ref_t iterate, void *ctx)
855 struct extent_buffer *eb = path->nodes[0];
856 struct btrfs_item *item;
857 struct btrfs_inode_ref *iref;
858 struct btrfs_inode_extref *extref;
859 struct btrfs_path *tmp_path;
860 struct fs_path *p;
861 u32 cur = 0;
862 u32 total;
863 int slot = path->slots[0];
864 u32 name_len;
865 char *start;
866 int ret = 0;
867 int num = 0;
868 int index;
869 u64 dir;
870 unsigned long name_off;
871 unsigned long elem_size;
872 unsigned long ptr;
874 p = fs_path_alloc_reversed();
875 if (!p)
876 return -ENOMEM;
878 tmp_path = alloc_path_for_send();
879 if (!tmp_path) {
880 fs_path_free(p);
881 return -ENOMEM;
885 if (found_key->type == BTRFS_INODE_REF_KEY) {
886 ptr = (unsigned long)btrfs_item_ptr(eb, slot,
887 struct btrfs_inode_ref);
888 item = btrfs_item_nr(slot);
889 total = btrfs_item_size(eb, item);
890 elem_size = sizeof(*iref);
891 } else {
892 ptr = btrfs_item_ptr_offset(eb, slot);
893 total = btrfs_item_size_nr(eb, slot);
894 elem_size = sizeof(*extref);
897 while (cur < total) {
898 fs_path_reset(p);
900 if (found_key->type == BTRFS_INODE_REF_KEY) {
901 iref = (struct btrfs_inode_ref *)(ptr + cur);
902 name_len = btrfs_inode_ref_name_len(eb, iref);
903 name_off = (unsigned long)(iref + 1);
904 index = btrfs_inode_ref_index(eb, iref);
905 dir = found_key->offset;
906 } else {
907 extref = (struct btrfs_inode_extref *)(ptr + cur);
908 name_len = btrfs_inode_extref_name_len(eb, extref);
909 name_off = (unsigned long)&extref->name;
910 index = btrfs_inode_extref_index(eb, extref);
911 dir = btrfs_inode_extref_parent(eb, extref);
914 if (resolve) {
915 start = btrfs_ref_to_path(root, tmp_path, name_len,
916 name_off, eb, dir,
917 p->buf, p->buf_len);
918 if (IS_ERR(start)) {
919 ret = PTR_ERR(start);
920 goto out;
922 if (start < p->buf) {
923 /* overflow , try again with larger buffer */
924 ret = fs_path_ensure_buf(p,
925 p->buf_len + p->buf - start);
926 if (ret < 0)
927 goto out;
928 start = btrfs_ref_to_path(root, tmp_path,
929 name_len, name_off,
930 eb, dir,
931 p->buf, p->buf_len);
932 if (IS_ERR(start)) {
933 ret = PTR_ERR(start);
934 goto out;
936 BUG_ON(start < p->buf);
938 p->start = start;
939 } else {
940 ret = fs_path_add_from_extent_buffer(p, eb, name_off,
941 name_len);
942 if (ret < 0)
943 goto out;
946 cur += elem_size + name_len;
947 ret = iterate(num, dir, index, p, ctx);
948 if (ret)
949 goto out;
950 num++;
953 out:
954 btrfs_free_path(tmp_path);
955 fs_path_free(p);
956 return ret;
959 typedef int (*iterate_dir_item_t)(int num, struct btrfs_key *di_key,
960 const char *name, int name_len,
961 const char *data, int data_len,
962 u8 type, void *ctx);
965 * Helper function to iterate the entries in ONE btrfs_dir_item.
966 * The iterate callback may return a non zero value to stop iteration. This can
967 * be a negative value for error codes or 1 to simply stop it.
969 * path must point to the dir item when called.
971 static int iterate_dir_item(struct btrfs_root *root, struct btrfs_path *path,
972 struct btrfs_key *found_key,
973 iterate_dir_item_t iterate, void *ctx)
975 int ret = 0;
976 struct extent_buffer *eb;
977 struct btrfs_item *item;
978 struct btrfs_dir_item *di;
979 struct btrfs_key di_key;
980 char *buf = NULL;
981 int buf_len;
982 u32 name_len;
983 u32 data_len;
984 u32 cur;
985 u32 len;
986 u32 total;
987 int slot;
988 int num;
989 u8 type;
992 * Start with a small buffer (1 page). If later we end up needing more
993 * space, which can happen for xattrs on a fs with a leaf size greater
994 * then the page size, attempt to increase the buffer. Typically xattr
995 * values are small.
997 buf_len = PATH_MAX;
998 buf = kmalloc(buf_len, GFP_NOFS);
999 if (!buf) {
1000 ret = -ENOMEM;
1001 goto out;
1004 eb = path->nodes[0];
1005 slot = path->slots[0];
1006 item = btrfs_item_nr(slot);
1007 di = btrfs_item_ptr(eb, slot, struct btrfs_dir_item);
1008 cur = 0;
1009 len = 0;
1010 total = btrfs_item_size(eb, item);
1012 num = 0;
1013 while (cur < total) {
1014 name_len = btrfs_dir_name_len(eb, di);
1015 data_len = btrfs_dir_data_len(eb, di);
1016 type = btrfs_dir_type(eb, di);
1017 btrfs_dir_item_key_to_cpu(eb, di, &di_key);
1019 if (type == BTRFS_FT_XATTR) {
1020 if (name_len > XATTR_NAME_MAX) {
1021 ret = -ENAMETOOLONG;
1022 goto out;
1024 if (name_len + data_len > BTRFS_MAX_XATTR_SIZE(root)) {
1025 ret = -E2BIG;
1026 goto out;
1028 } else {
1030 * Path too long
1032 if (name_len + data_len > PATH_MAX) {
1033 ret = -ENAMETOOLONG;
1034 goto out;
1038 if (name_len + data_len > buf_len) {
1039 buf_len = name_len + data_len;
1040 if (is_vmalloc_addr(buf)) {
1041 vfree(buf);
1042 buf = NULL;
1043 } else {
1044 char *tmp = krealloc(buf, buf_len,
1045 GFP_NOFS | __GFP_NOWARN);
1047 if (!tmp)
1048 kfree(buf);
1049 buf = tmp;
1051 if (!buf) {
1052 buf = vmalloc(buf_len);
1053 if (!buf) {
1054 ret = -ENOMEM;
1055 goto out;
1060 read_extent_buffer(eb, buf, (unsigned long)(di + 1),
1061 name_len + data_len);
1063 len = sizeof(*di) + name_len + data_len;
1064 di = (struct btrfs_dir_item *)((char *)di + len);
1065 cur += len;
1067 ret = iterate(num, &di_key, buf, name_len, buf + name_len,
1068 data_len, type, ctx);
1069 if (ret < 0)
1070 goto out;
1071 if (ret) {
1072 ret = 0;
1073 goto out;
1076 num++;
1079 out:
1080 kvfree(buf);
1081 return ret;
1084 static int __copy_first_ref(int num, u64 dir, int index,
1085 struct fs_path *p, void *ctx)
1087 int ret;
1088 struct fs_path *pt = ctx;
1090 ret = fs_path_copy(pt, p);
1091 if (ret < 0)
1092 return ret;
1094 /* we want the first only */
1095 return 1;
1099 * Retrieve the first path of an inode. If an inode has more then one
1100 * ref/hardlink, this is ignored.
1102 static int get_inode_path(struct btrfs_root *root,
1103 u64 ino, struct fs_path *path)
1105 int ret;
1106 struct btrfs_key key, found_key;
1107 struct btrfs_path *p;
1109 p = alloc_path_for_send();
1110 if (!p)
1111 return -ENOMEM;
1113 fs_path_reset(path);
1115 key.objectid = ino;
1116 key.type = BTRFS_INODE_REF_KEY;
1117 key.offset = 0;
1119 ret = btrfs_search_slot_for_read(root, &key, p, 1, 0);
1120 if (ret < 0)
1121 goto out;
1122 if (ret) {
1123 ret = 1;
1124 goto out;
1126 btrfs_item_key_to_cpu(p->nodes[0], &found_key, p->slots[0]);
1127 if (found_key.objectid != ino ||
1128 (found_key.type != BTRFS_INODE_REF_KEY &&
1129 found_key.type != BTRFS_INODE_EXTREF_KEY)) {
1130 ret = -ENOENT;
1131 goto out;
1134 ret = iterate_inode_ref(root, p, &found_key, 1,
1135 __copy_first_ref, path);
1136 if (ret < 0)
1137 goto out;
1138 ret = 0;
1140 out:
1141 btrfs_free_path(p);
1142 return ret;
1145 struct backref_ctx {
1146 struct send_ctx *sctx;
1148 struct btrfs_path *path;
1149 /* number of total found references */
1150 u64 found;
1153 * used for clones found in send_root. clones found behind cur_objectid
1154 * and cur_offset are not considered as allowed clones.
1156 u64 cur_objectid;
1157 u64 cur_offset;
1159 /* may be truncated in case it's the last extent in a file */
1160 u64 extent_len;
1162 /* data offset in the file extent item */
1163 u64 data_offset;
1165 /* Just to check for bugs in backref resolving */
1166 int found_itself;
1169 static int __clone_root_cmp_bsearch(const void *key, const void *elt)
1171 u64 root = (u64)(uintptr_t)key;
1172 struct clone_root *cr = (struct clone_root *)elt;
1174 if (root < cr->root->objectid)
1175 return -1;
1176 if (root > cr->root->objectid)
1177 return 1;
1178 return 0;
1181 static int __clone_root_cmp_sort(const void *e1, const void *e2)
1183 struct clone_root *cr1 = (struct clone_root *)e1;
1184 struct clone_root *cr2 = (struct clone_root *)e2;
1186 if (cr1->root->objectid < cr2->root->objectid)
1187 return -1;
1188 if (cr1->root->objectid > cr2->root->objectid)
1189 return 1;
1190 return 0;
1194 * Called for every backref that is found for the current extent.
1195 * Results are collected in sctx->clone_roots->ino/offset/found_refs
1197 static int __iterate_backrefs(u64 ino, u64 offset, u64 root, void *ctx_)
1199 struct backref_ctx *bctx = ctx_;
1200 struct clone_root *found;
1201 int ret;
1202 u64 i_size;
1204 /* First check if the root is in the list of accepted clone sources */
1205 found = bsearch((void *)(uintptr_t)root, bctx->sctx->clone_roots,
1206 bctx->sctx->clone_roots_cnt,
1207 sizeof(struct clone_root),
1208 __clone_root_cmp_bsearch);
1209 if (!found)
1210 return 0;
1212 if (found->root == bctx->sctx->send_root &&
1213 ino == bctx->cur_objectid &&
1214 offset == bctx->cur_offset) {
1215 bctx->found_itself = 1;
1219 * There are inodes that have extents that lie behind its i_size. Don't
1220 * accept clones from these extents.
1222 ret = __get_inode_info(found->root, bctx->path, ino, &i_size, NULL, NULL,
1223 NULL, NULL, NULL);
1224 btrfs_release_path(bctx->path);
1225 if (ret < 0)
1226 return ret;
1228 if (offset + bctx->data_offset + bctx->extent_len > i_size)
1229 return 0;
1232 * Make sure we don't consider clones from send_root that are
1233 * behind the current inode/offset.
1235 if (found->root == bctx->sctx->send_root) {
1237 * TODO for the moment we don't accept clones from the inode
1238 * that is currently send. We may change this when
1239 * BTRFS_IOC_CLONE_RANGE supports cloning from and to the same
1240 * file.
1242 if (ino >= bctx->cur_objectid)
1243 return 0;
1244 #if 0
1245 if (ino > bctx->cur_objectid)
1246 return 0;
1247 if (offset + bctx->extent_len > bctx->cur_offset)
1248 return 0;
1249 #endif
1252 bctx->found++;
1253 found->found_refs++;
1254 if (ino < found->ino) {
1255 found->ino = ino;
1256 found->offset = offset;
1257 } else if (found->ino == ino) {
1259 * same extent found more then once in the same file.
1261 if (found->offset > offset + bctx->extent_len)
1262 found->offset = offset;
1265 return 0;
1269 * Given an inode, offset and extent item, it finds a good clone for a clone
1270 * instruction. Returns -ENOENT when none could be found. The function makes
1271 * sure that the returned clone is usable at the point where sending is at the
1272 * moment. This means, that no clones are accepted which lie behind the current
1273 * inode+offset.
1275 * path must point to the extent item when called.
1277 static int find_extent_clone(struct send_ctx *sctx,
1278 struct btrfs_path *path,
1279 u64 ino, u64 data_offset,
1280 u64 ino_size,
1281 struct clone_root **found)
1283 int ret;
1284 int extent_type;
1285 u64 logical;
1286 u64 disk_byte;
1287 u64 num_bytes;
1288 u64 extent_item_pos;
1289 u64 flags = 0;
1290 struct btrfs_file_extent_item *fi;
1291 struct extent_buffer *eb = path->nodes[0];
1292 struct backref_ctx *backref_ctx = NULL;
1293 struct clone_root *cur_clone_root;
1294 struct btrfs_key found_key;
1295 struct btrfs_path *tmp_path;
1296 int compressed;
1297 u32 i;
1299 tmp_path = alloc_path_for_send();
1300 if (!tmp_path)
1301 return -ENOMEM;
1303 /* We only use this path under the commit sem */
1304 tmp_path->need_commit_sem = 0;
1306 backref_ctx = kmalloc(sizeof(*backref_ctx), GFP_NOFS);
1307 if (!backref_ctx) {
1308 ret = -ENOMEM;
1309 goto out;
1312 backref_ctx->path = tmp_path;
1314 if (data_offset >= ino_size) {
1316 * There may be extents that lie behind the file's size.
1317 * I at least had this in combination with snapshotting while
1318 * writing large files.
1320 ret = 0;
1321 goto out;
1324 fi = btrfs_item_ptr(eb, path->slots[0],
1325 struct btrfs_file_extent_item);
1326 extent_type = btrfs_file_extent_type(eb, fi);
1327 if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
1328 ret = -ENOENT;
1329 goto out;
1331 compressed = btrfs_file_extent_compression(eb, fi);
1333 num_bytes = btrfs_file_extent_num_bytes(eb, fi);
1334 disk_byte = btrfs_file_extent_disk_bytenr(eb, fi);
1335 if (disk_byte == 0) {
1336 ret = -ENOENT;
1337 goto out;
1339 logical = disk_byte + btrfs_file_extent_offset(eb, fi);
1341 down_read(&sctx->send_root->fs_info->commit_root_sem);
1342 ret = extent_from_logical(sctx->send_root->fs_info, disk_byte, tmp_path,
1343 &found_key, &flags);
1344 up_read(&sctx->send_root->fs_info->commit_root_sem);
1345 btrfs_release_path(tmp_path);
1347 if (ret < 0)
1348 goto out;
1349 if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
1350 ret = -EIO;
1351 goto out;
1355 * Setup the clone roots.
1357 for (i = 0; i < sctx->clone_roots_cnt; i++) {
1358 cur_clone_root = sctx->clone_roots + i;
1359 cur_clone_root->ino = (u64)-1;
1360 cur_clone_root->offset = 0;
1361 cur_clone_root->found_refs = 0;
1364 backref_ctx->sctx = sctx;
1365 backref_ctx->found = 0;
1366 backref_ctx->cur_objectid = ino;
1367 backref_ctx->cur_offset = data_offset;
1368 backref_ctx->found_itself = 0;
1369 backref_ctx->extent_len = num_bytes;
1371 * For non-compressed extents iterate_extent_inodes() gives us extent
1372 * offsets that already take into account the data offset, but not for
1373 * compressed extents, since the offset is logical and not relative to
1374 * the physical extent locations. We must take this into account to
1375 * avoid sending clone offsets that go beyond the source file's size,
1376 * which would result in the clone ioctl failing with -EINVAL on the
1377 * receiving end.
1379 if (compressed == BTRFS_COMPRESS_NONE)
1380 backref_ctx->data_offset = 0;
1381 else
1382 backref_ctx->data_offset = btrfs_file_extent_offset(eb, fi);
1385 * The last extent of a file may be too large due to page alignment.
1386 * We need to adjust extent_len in this case so that the checks in
1387 * __iterate_backrefs work.
1389 if (data_offset + num_bytes >= ino_size)
1390 backref_ctx->extent_len = ino_size - data_offset;
1393 * Now collect all backrefs.
1395 if (compressed == BTRFS_COMPRESS_NONE)
1396 extent_item_pos = logical - found_key.objectid;
1397 else
1398 extent_item_pos = 0;
1399 ret = iterate_extent_inodes(sctx->send_root->fs_info,
1400 found_key.objectid, extent_item_pos, 1,
1401 __iterate_backrefs, backref_ctx);
1403 if (ret < 0)
1404 goto out;
1406 if (!backref_ctx->found_itself) {
1407 /* found a bug in backref code? */
1408 ret = -EIO;
1409 btrfs_err(sctx->send_root->fs_info, "did not find backref in "
1410 "send_root. inode=%llu, offset=%llu, "
1411 "disk_byte=%llu found extent=%llu",
1412 ino, data_offset, disk_byte, found_key.objectid);
1413 goto out;
1416 verbose_printk(KERN_DEBUG "btrfs: find_extent_clone: data_offset=%llu, "
1417 "ino=%llu, "
1418 "num_bytes=%llu, logical=%llu\n",
1419 data_offset, ino, num_bytes, logical);
1421 if (!backref_ctx->found)
1422 verbose_printk("btrfs: no clones found\n");
1424 cur_clone_root = NULL;
1425 for (i = 0; i < sctx->clone_roots_cnt; i++) {
1426 if (sctx->clone_roots[i].found_refs) {
1427 if (!cur_clone_root)
1428 cur_clone_root = sctx->clone_roots + i;
1429 else if (sctx->clone_roots[i].root == sctx->send_root)
1430 /* prefer clones from send_root over others */
1431 cur_clone_root = sctx->clone_roots + i;
1436 if (cur_clone_root) {
1437 *found = cur_clone_root;
1438 ret = 0;
1439 } else {
1440 ret = -ENOENT;
1443 out:
1444 btrfs_free_path(tmp_path);
1445 kfree(backref_ctx);
1446 return ret;
1449 static int read_symlink(struct btrfs_root *root,
1450 u64 ino,
1451 struct fs_path *dest)
1453 int ret;
1454 struct btrfs_path *path;
1455 struct btrfs_key key;
1456 struct btrfs_file_extent_item *ei;
1457 u8 type;
1458 u8 compression;
1459 unsigned long off;
1460 int len;
1462 path = alloc_path_for_send();
1463 if (!path)
1464 return -ENOMEM;
1466 key.objectid = ino;
1467 key.type = BTRFS_EXTENT_DATA_KEY;
1468 key.offset = 0;
1469 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1470 if (ret < 0)
1471 goto out;
1472 if (ret) {
1474 * An empty symlink inode. Can happen in rare error paths when
1475 * creating a symlink (transaction committed before the inode
1476 * eviction handler removed the symlink inode items and a crash
1477 * happened in between or the subvol was snapshoted in between).
1478 * Print an informative message to dmesg/syslog so that the user
1479 * can delete the symlink.
1481 btrfs_err(root->fs_info,
1482 "Found empty symlink inode %llu at root %llu",
1483 ino, root->root_key.objectid);
1484 ret = -EIO;
1485 goto out;
1488 ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
1489 struct btrfs_file_extent_item);
1490 type = btrfs_file_extent_type(path->nodes[0], ei);
1491 compression = btrfs_file_extent_compression(path->nodes[0], ei);
1492 BUG_ON(type != BTRFS_FILE_EXTENT_INLINE);
1493 BUG_ON(compression);
1495 off = btrfs_file_extent_inline_start(ei);
1496 len = btrfs_file_extent_inline_len(path->nodes[0], path->slots[0], ei);
1498 ret = fs_path_add_from_extent_buffer(dest, path->nodes[0], off, len);
1500 out:
1501 btrfs_free_path(path);
1502 return ret;
1506 * Helper function to generate a file name that is unique in the root of
1507 * send_root and parent_root. This is used to generate names for orphan inodes.
1509 static int gen_unique_name(struct send_ctx *sctx,
1510 u64 ino, u64 gen,
1511 struct fs_path *dest)
1513 int ret = 0;
1514 struct btrfs_path *path;
1515 struct btrfs_dir_item *di;
1516 char tmp[64];
1517 int len;
1518 u64 idx = 0;
1520 path = alloc_path_for_send();
1521 if (!path)
1522 return -ENOMEM;
1524 while (1) {
1525 len = snprintf(tmp, sizeof(tmp), "o%llu-%llu-%llu",
1526 ino, gen, idx);
1527 ASSERT(len < sizeof(tmp));
1529 di = btrfs_lookup_dir_item(NULL, sctx->send_root,
1530 path, BTRFS_FIRST_FREE_OBJECTID,
1531 tmp, strlen(tmp), 0);
1532 btrfs_release_path(path);
1533 if (IS_ERR(di)) {
1534 ret = PTR_ERR(di);
1535 goto out;
1537 if (di) {
1538 /* not unique, try again */
1539 idx++;
1540 continue;
1543 if (!sctx->parent_root) {
1544 /* unique */
1545 ret = 0;
1546 break;
1549 di = btrfs_lookup_dir_item(NULL, sctx->parent_root,
1550 path, BTRFS_FIRST_FREE_OBJECTID,
1551 tmp, strlen(tmp), 0);
1552 btrfs_release_path(path);
1553 if (IS_ERR(di)) {
1554 ret = PTR_ERR(di);
1555 goto out;
1557 if (di) {
1558 /* not unique, try again */
1559 idx++;
1560 continue;
1562 /* unique */
1563 break;
1566 ret = fs_path_add(dest, tmp, strlen(tmp));
1568 out:
1569 btrfs_free_path(path);
1570 return ret;
1573 enum inode_state {
1574 inode_state_no_change,
1575 inode_state_will_create,
1576 inode_state_did_create,
1577 inode_state_will_delete,
1578 inode_state_did_delete,
1581 static int get_cur_inode_state(struct send_ctx *sctx, u64 ino, u64 gen)
1583 int ret;
1584 int left_ret;
1585 int right_ret;
1586 u64 left_gen;
1587 u64 right_gen;
1589 ret = get_inode_info(sctx->send_root, ino, NULL, &left_gen, NULL, NULL,
1590 NULL, NULL);
1591 if (ret < 0 && ret != -ENOENT)
1592 goto out;
1593 left_ret = ret;
1595 if (!sctx->parent_root) {
1596 right_ret = -ENOENT;
1597 } else {
1598 ret = get_inode_info(sctx->parent_root, ino, NULL, &right_gen,
1599 NULL, NULL, NULL, NULL);
1600 if (ret < 0 && ret != -ENOENT)
1601 goto out;
1602 right_ret = ret;
1605 if (!left_ret && !right_ret) {
1606 if (left_gen == gen && right_gen == gen) {
1607 ret = inode_state_no_change;
1608 } else if (left_gen == gen) {
1609 if (ino < sctx->send_progress)
1610 ret = inode_state_did_create;
1611 else
1612 ret = inode_state_will_create;
1613 } else if (right_gen == gen) {
1614 if (ino < sctx->send_progress)
1615 ret = inode_state_did_delete;
1616 else
1617 ret = inode_state_will_delete;
1618 } else {
1619 ret = -ENOENT;
1621 } else if (!left_ret) {
1622 if (left_gen == gen) {
1623 if (ino < sctx->send_progress)
1624 ret = inode_state_did_create;
1625 else
1626 ret = inode_state_will_create;
1627 } else {
1628 ret = -ENOENT;
1630 } else if (!right_ret) {
1631 if (right_gen == gen) {
1632 if (ino < sctx->send_progress)
1633 ret = inode_state_did_delete;
1634 else
1635 ret = inode_state_will_delete;
1636 } else {
1637 ret = -ENOENT;
1639 } else {
1640 ret = -ENOENT;
1643 out:
1644 return ret;
1647 static int is_inode_existent(struct send_ctx *sctx, u64 ino, u64 gen)
1649 int ret;
1651 if (ino == BTRFS_FIRST_FREE_OBJECTID)
1652 return 1;
1654 ret = get_cur_inode_state(sctx, ino, gen);
1655 if (ret < 0)
1656 goto out;
1658 if (ret == inode_state_no_change ||
1659 ret == inode_state_did_create ||
1660 ret == inode_state_will_delete)
1661 ret = 1;
1662 else
1663 ret = 0;
1665 out:
1666 return ret;
1670 * Helper function to lookup a dir item in a dir.
1672 static int lookup_dir_item_inode(struct btrfs_root *root,
1673 u64 dir, const char *name, int name_len,
1674 u64 *found_inode,
1675 u8 *found_type)
1677 int ret = 0;
1678 struct btrfs_dir_item *di;
1679 struct btrfs_key key;
1680 struct btrfs_path *path;
1682 path = alloc_path_for_send();
1683 if (!path)
1684 return -ENOMEM;
1686 di = btrfs_lookup_dir_item(NULL, root, path,
1687 dir, name, name_len, 0);
1688 if (!di) {
1689 ret = -ENOENT;
1690 goto out;
1692 if (IS_ERR(di)) {
1693 ret = PTR_ERR(di);
1694 goto out;
1696 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &key);
1697 if (key.type == BTRFS_ROOT_ITEM_KEY) {
1698 ret = -ENOENT;
1699 goto out;
1701 *found_inode = key.objectid;
1702 *found_type = btrfs_dir_type(path->nodes[0], di);
1704 out:
1705 btrfs_free_path(path);
1706 return ret;
1710 * Looks up the first btrfs_inode_ref of a given ino. It returns the parent dir,
1711 * generation of the parent dir and the name of the dir entry.
1713 static int get_first_ref(struct btrfs_root *root, u64 ino,
1714 u64 *dir, u64 *dir_gen, struct fs_path *name)
1716 int ret;
1717 struct btrfs_key key;
1718 struct btrfs_key found_key;
1719 struct btrfs_path *path;
1720 int len;
1721 u64 parent_dir;
1723 path = alloc_path_for_send();
1724 if (!path)
1725 return -ENOMEM;
1727 key.objectid = ino;
1728 key.type = BTRFS_INODE_REF_KEY;
1729 key.offset = 0;
1731 ret = btrfs_search_slot_for_read(root, &key, path, 1, 0);
1732 if (ret < 0)
1733 goto out;
1734 if (!ret)
1735 btrfs_item_key_to_cpu(path->nodes[0], &found_key,
1736 path->slots[0]);
1737 if (ret || found_key.objectid != ino ||
1738 (found_key.type != BTRFS_INODE_REF_KEY &&
1739 found_key.type != BTRFS_INODE_EXTREF_KEY)) {
1740 ret = -ENOENT;
1741 goto out;
1744 if (found_key.type == BTRFS_INODE_REF_KEY) {
1745 struct btrfs_inode_ref *iref;
1746 iref = btrfs_item_ptr(path->nodes[0], path->slots[0],
1747 struct btrfs_inode_ref);
1748 len = btrfs_inode_ref_name_len(path->nodes[0], iref);
1749 ret = fs_path_add_from_extent_buffer(name, path->nodes[0],
1750 (unsigned long)(iref + 1),
1751 len);
1752 parent_dir = found_key.offset;
1753 } else {
1754 struct btrfs_inode_extref *extref;
1755 extref = btrfs_item_ptr(path->nodes[0], path->slots[0],
1756 struct btrfs_inode_extref);
1757 len = btrfs_inode_extref_name_len(path->nodes[0], extref);
1758 ret = fs_path_add_from_extent_buffer(name, path->nodes[0],
1759 (unsigned long)&extref->name, len);
1760 parent_dir = btrfs_inode_extref_parent(path->nodes[0], extref);
1762 if (ret < 0)
1763 goto out;
1764 btrfs_release_path(path);
1766 if (dir_gen) {
1767 ret = get_inode_info(root, parent_dir, NULL, dir_gen, NULL,
1768 NULL, NULL, NULL);
1769 if (ret < 0)
1770 goto out;
1773 *dir = parent_dir;
1775 out:
1776 btrfs_free_path(path);
1777 return ret;
1780 static int is_first_ref(struct btrfs_root *root,
1781 u64 ino, u64 dir,
1782 const char *name, int name_len)
1784 int ret;
1785 struct fs_path *tmp_name;
1786 u64 tmp_dir;
1788 tmp_name = fs_path_alloc();
1789 if (!tmp_name)
1790 return -ENOMEM;
1792 ret = get_first_ref(root, ino, &tmp_dir, NULL, tmp_name);
1793 if (ret < 0)
1794 goto out;
1796 if (dir != tmp_dir || name_len != fs_path_len(tmp_name)) {
1797 ret = 0;
1798 goto out;
1801 ret = !memcmp(tmp_name->start, name, name_len);
1803 out:
1804 fs_path_free(tmp_name);
1805 return ret;
1809 * Used by process_recorded_refs to determine if a new ref would overwrite an
1810 * already existing ref. In case it detects an overwrite, it returns the
1811 * inode/gen in who_ino/who_gen.
1812 * When an overwrite is detected, process_recorded_refs does proper orphanizing
1813 * to make sure later references to the overwritten inode are possible.
1814 * Orphanizing is however only required for the first ref of an inode.
1815 * process_recorded_refs does an additional is_first_ref check to see if
1816 * orphanizing is really required.
1818 static int will_overwrite_ref(struct send_ctx *sctx, u64 dir, u64 dir_gen,
1819 const char *name, int name_len,
1820 u64 *who_ino, u64 *who_gen)
1822 int ret = 0;
1823 u64 gen;
1824 u64 other_inode = 0;
1825 u8 other_type = 0;
1827 if (!sctx->parent_root)
1828 goto out;
1830 ret = is_inode_existent(sctx, dir, dir_gen);
1831 if (ret <= 0)
1832 goto out;
1835 * If we have a parent root we need to verify that the parent dir was
1836 * not delted and then re-created, if it was then we have no overwrite
1837 * and we can just unlink this entry.
1839 if (sctx->parent_root && dir != BTRFS_FIRST_FREE_OBJECTID) {
1840 ret = get_inode_info(sctx->parent_root, dir, NULL, &gen, NULL,
1841 NULL, NULL, NULL);
1842 if (ret < 0 && ret != -ENOENT)
1843 goto out;
1844 if (ret) {
1845 ret = 0;
1846 goto out;
1848 if (gen != dir_gen)
1849 goto out;
1852 ret = lookup_dir_item_inode(sctx->parent_root, dir, name, name_len,
1853 &other_inode, &other_type);
1854 if (ret < 0 && ret != -ENOENT)
1855 goto out;
1856 if (ret) {
1857 ret = 0;
1858 goto out;
1862 * Check if the overwritten ref was already processed. If yes, the ref
1863 * was already unlinked/moved, so we can safely assume that we will not
1864 * overwrite anything at this point in time.
1866 if (other_inode > sctx->send_progress) {
1867 ret = get_inode_info(sctx->parent_root, other_inode, NULL,
1868 who_gen, NULL, NULL, NULL, NULL);
1869 if (ret < 0)
1870 goto out;
1872 ret = 1;
1873 *who_ino = other_inode;
1874 } else {
1875 ret = 0;
1878 out:
1879 return ret;
1883 * Checks if the ref was overwritten by an already processed inode. This is
1884 * used by __get_cur_name_and_parent to find out if the ref was orphanized and
1885 * thus the orphan name needs be used.
1886 * process_recorded_refs also uses it to avoid unlinking of refs that were
1887 * overwritten.
1889 static int did_overwrite_ref(struct send_ctx *sctx,
1890 u64 dir, u64 dir_gen,
1891 u64 ino, u64 ino_gen,
1892 const char *name, int name_len)
1894 int ret = 0;
1895 u64 gen;
1896 u64 ow_inode;
1897 u8 other_type;
1899 if (!sctx->parent_root)
1900 goto out;
1902 ret = is_inode_existent(sctx, dir, dir_gen);
1903 if (ret <= 0)
1904 goto out;
1906 /* check if the ref was overwritten by another ref */
1907 ret = lookup_dir_item_inode(sctx->send_root, dir, name, name_len,
1908 &ow_inode, &other_type);
1909 if (ret < 0 && ret != -ENOENT)
1910 goto out;
1911 if (ret) {
1912 /* was never and will never be overwritten */
1913 ret = 0;
1914 goto out;
1917 ret = get_inode_info(sctx->send_root, ow_inode, NULL, &gen, NULL, NULL,
1918 NULL, NULL);
1919 if (ret < 0)
1920 goto out;
1922 if (ow_inode == ino && gen == ino_gen) {
1923 ret = 0;
1924 goto out;
1928 * We know that it is or will be overwritten. Check this now.
1929 * The current inode being processed might have been the one that caused
1930 * inode 'ino' to be orphanized, therefore check if ow_inode matches
1931 * the current inode being processed.
1933 if ((ow_inode < sctx->send_progress) ||
1934 (ino != sctx->cur_ino && ow_inode == sctx->cur_ino &&
1935 gen == sctx->cur_inode_gen))
1936 ret = 1;
1937 else
1938 ret = 0;
1940 out:
1941 return ret;
1945 * Same as did_overwrite_ref, but also checks if it is the first ref of an inode
1946 * that got overwritten. This is used by process_recorded_refs to determine
1947 * if it has to use the path as returned by get_cur_path or the orphan name.
1949 static int did_overwrite_first_ref(struct send_ctx *sctx, u64 ino, u64 gen)
1951 int ret = 0;
1952 struct fs_path *name = NULL;
1953 u64 dir;
1954 u64 dir_gen;
1956 if (!sctx->parent_root)
1957 goto out;
1959 name = fs_path_alloc();
1960 if (!name)
1961 return -ENOMEM;
1963 ret = get_first_ref(sctx->parent_root, ino, &dir, &dir_gen, name);
1964 if (ret < 0)
1965 goto out;
1967 ret = did_overwrite_ref(sctx, dir, dir_gen, ino, gen,
1968 name->start, fs_path_len(name));
1970 out:
1971 fs_path_free(name);
1972 return ret;
1976 * Insert a name cache entry. On 32bit kernels the radix tree index is 32bit,
1977 * so we need to do some special handling in case we have clashes. This function
1978 * takes care of this with the help of name_cache_entry::radix_list.
1979 * In case of error, nce is kfreed.
1981 static int name_cache_insert(struct send_ctx *sctx,
1982 struct name_cache_entry *nce)
1984 int ret = 0;
1985 struct list_head *nce_head;
1987 nce_head = radix_tree_lookup(&sctx->name_cache,
1988 (unsigned long)nce->ino);
1989 if (!nce_head) {
1990 nce_head = kmalloc(sizeof(*nce_head), GFP_NOFS);
1991 if (!nce_head) {
1992 kfree(nce);
1993 return -ENOMEM;
1995 INIT_LIST_HEAD(nce_head);
1997 ret = radix_tree_insert(&sctx->name_cache, nce->ino, nce_head);
1998 if (ret < 0) {
1999 kfree(nce_head);
2000 kfree(nce);
2001 return ret;
2004 list_add_tail(&nce->radix_list, nce_head);
2005 list_add_tail(&nce->list, &sctx->name_cache_list);
2006 sctx->name_cache_size++;
2008 return ret;
2011 static void name_cache_delete(struct send_ctx *sctx,
2012 struct name_cache_entry *nce)
2014 struct list_head *nce_head;
2016 nce_head = radix_tree_lookup(&sctx->name_cache,
2017 (unsigned long)nce->ino);
2018 if (!nce_head) {
2019 btrfs_err(sctx->send_root->fs_info,
2020 "name_cache_delete lookup failed ino %llu cache size %d, leaking memory",
2021 nce->ino, sctx->name_cache_size);
2024 list_del(&nce->radix_list);
2025 list_del(&nce->list);
2026 sctx->name_cache_size--;
2029 * We may not get to the final release of nce_head if the lookup fails
2031 if (nce_head && list_empty(nce_head)) {
2032 radix_tree_delete(&sctx->name_cache, (unsigned long)nce->ino);
2033 kfree(nce_head);
2037 static struct name_cache_entry *name_cache_search(struct send_ctx *sctx,
2038 u64 ino, u64 gen)
2040 struct list_head *nce_head;
2041 struct name_cache_entry *cur;
2043 nce_head = radix_tree_lookup(&sctx->name_cache, (unsigned long)ino);
2044 if (!nce_head)
2045 return NULL;
2047 list_for_each_entry(cur, nce_head, radix_list) {
2048 if (cur->ino == ino && cur->gen == gen)
2049 return cur;
2051 return NULL;
2055 * Removes the entry from the list and adds it back to the end. This marks the
2056 * entry as recently used so that name_cache_clean_unused does not remove it.
2058 static void name_cache_used(struct send_ctx *sctx, struct name_cache_entry *nce)
2060 list_del(&nce->list);
2061 list_add_tail(&nce->list, &sctx->name_cache_list);
2065 * Remove some entries from the beginning of name_cache_list.
2067 static void name_cache_clean_unused(struct send_ctx *sctx)
2069 struct name_cache_entry *nce;
2071 if (sctx->name_cache_size < SEND_CTX_NAME_CACHE_CLEAN_SIZE)
2072 return;
2074 while (sctx->name_cache_size > SEND_CTX_MAX_NAME_CACHE_SIZE) {
2075 nce = list_entry(sctx->name_cache_list.next,
2076 struct name_cache_entry, list);
2077 name_cache_delete(sctx, nce);
2078 kfree(nce);
2082 static void name_cache_free(struct send_ctx *sctx)
2084 struct name_cache_entry *nce;
2086 while (!list_empty(&sctx->name_cache_list)) {
2087 nce = list_entry(sctx->name_cache_list.next,
2088 struct name_cache_entry, list);
2089 name_cache_delete(sctx, nce);
2090 kfree(nce);
2095 * Used by get_cur_path for each ref up to the root.
2096 * Returns 0 if it succeeded.
2097 * Returns 1 if the inode is not existent or got overwritten. In that case, the
2098 * name is an orphan name. This instructs get_cur_path to stop iterating. If 1
2099 * is returned, parent_ino/parent_gen are not guaranteed to be valid.
2100 * Returns <0 in case of error.
2102 static int __get_cur_name_and_parent(struct send_ctx *sctx,
2103 u64 ino, u64 gen,
2104 u64 *parent_ino,
2105 u64 *parent_gen,
2106 struct fs_path *dest)
2108 int ret;
2109 int nce_ret;
2110 struct name_cache_entry *nce = NULL;
2113 * First check if we already did a call to this function with the same
2114 * ino/gen. If yes, check if the cache entry is still up-to-date. If yes
2115 * return the cached result.
2117 nce = name_cache_search(sctx, ino, gen);
2118 if (nce) {
2119 if (ino < sctx->send_progress && nce->need_later_update) {
2120 name_cache_delete(sctx, nce);
2121 kfree(nce);
2122 nce = NULL;
2123 } else {
2124 name_cache_used(sctx, nce);
2125 *parent_ino = nce->parent_ino;
2126 *parent_gen = nce->parent_gen;
2127 ret = fs_path_add(dest, nce->name, nce->name_len);
2128 if (ret < 0)
2129 goto out;
2130 ret = nce->ret;
2131 goto out;
2136 * If the inode is not existent yet, add the orphan name and return 1.
2137 * This should only happen for the parent dir that we determine in
2138 * __record_new_ref
2140 ret = is_inode_existent(sctx, ino, gen);
2141 if (ret < 0)
2142 goto out;
2144 if (!ret) {
2145 ret = gen_unique_name(sctx, ino, gen, dest);
2146 if (ret < 0)
2147 goto out;
2148 ret = 1;
2149 goto out_cache;
2153 * Depending on whether the inode was already processed or not, use
2154 * send_root or parent_root for ref lookup.
2156 if (ino < sctx->send_progress)
2157 ret = get_first_ref(sctx->send_root, ino,
2158 parent_ino, parent_gen, dest);
2159 else
2160 ret = get_first_ref(sctx->parent_root, ino,
2161 parent_ino, parent_gen, dest);
2162 if (ret < 0)
2163 goto out;
2166 * Check if the ref was overwritten by an inode's ref that was processed
2167 * earlier. If yes, treat as orphan and return 1.
2169 ret = did_overwrite_ref(sctx, *parent_ino, *parent_gen, ino, gen,
2170 dest->start, dest->end - dest->start);
2171 if (ret < 0)
2172 goto out;
2173 if (ret) {
2174 fs_path_reset(dest);
2175 ret = gen_unique_name(sctx, ino, gen, dest);
2176 if (ret < 0)
2177 goto out;
2178 ret = 1;
2181 out_cache:
2183 * Store the result of the lookup in the name cache.
2185 nce = kmalloc(sizeof(*nce) + fs_path_len(dest) + 1, GFP_NOFS);
2186 if (!nce) {
2187 ret = -ENOMEM;
2188 goto out;
2191 nce->ino = ino;
2192 nce->gen = gen;
2193 nce->parent_ino = *parent_ino;
2194 nce->parent_gen = *parent_gen;
2195 nce->name_len = fs_path_len(dest);
2196 nce->ret = ret;
2197 strcpy(nce->name, dest->start);
2199 if (ino < sctx->send_progress)
2200 nce->need_later_update = 0;
2201 else
2202 nce->need_later_update = 1;
2204 nce_ret = name_cache_insert(sctx, nce);
2205 if (nce_ret < 0)
2206 ret = nce_ret;
2207 name_cache_clean_unused(sctx);
2209 out:
2210 return ret;
2214 * Magic happens here. This function returns the first ref to an inode as it
2215 * would look like while receiving the stream at this point in time.
2216 * We walk the path up to the root. For every inode in between, we check if it
2217 * was already processed/sent. If yes, we continue with the parent as found
2218 * in send_root. If not, we continue with the parent as found in parent_root.
2219 * If we encounter an inode that was deleted at this point in time, we use the
2220 * inodes "orphan" name instead of the real name and stop. Same with new inodes
2221 * that were not created yet and overwritten inodes/refs.
2223 * When do we have have orphan inodes:
2224 * 1. When an inode is freshly created and thus no valid refs are available yet
2225 * 2. When a directory lost all it's refs (deleted) but still has dir items
2226 * inside which were not processed yet (pending for move/delete). If anyone
2227 * tried to get the path to the dir items, it would get a path inside that
2228 * orphan directory.
2229 * 3. When an inode is moved around or gets new links, it may overwrite the ref
2230 * of an unprocessed inode. If in that case the first ref would be
2231 * overwritten, the overwritten inode gets "orphanized". Later when we
2232 * process this overwritten inode, it is restored at a new place by moving
2233 * the orphan inode.
2235 * sctx->send_progress tells this function at which point in time receiving
2236 * would be.
2238 static int get_cur_path(struct send_ctx *sctx, u64 ino, u64 gen,
2239 struct fs_path *dest)
2241 int ret = 0;
2242 struct fs_path *name = NULL;
2243 u64 parent_inode = 0;
2244 u64 parent_gen = 0;
2245 int stop = 0;
2247 name = fs_path_alloc();
2248 if (!name) {
2249 ret = -ENOMEM;
2250 goto out;
2253 dest->reversed = 1;
2254 fs_path_reset(dest);
2256 while (!stop && ino != BTRFS_FIRST_FREE_OBJECTID) {
2257 struct waiting_dir_move *wdm;
2259 fs_path_reset(name);
2261 if (is_waiting_for_rm(sctx, ino)) {
2262 ret = gen_unique_name(sctx, ino, gen, name);
2263 if (ret < 0)
2264 goto out;
2265 ret = fs_path_add_path(dest, name);
2266 break;
2269 wdm = get_waiting_dir_move(sctx, ino);
2270 if (wdm && wdm->orphanized) {
2271 ret = gen_unique_name(sctx, ino, gen, name);
2272 stop = 1;
2273 } else if (wdm) {
2274 ret = get_first_ref(sctx->parent_root, ino,
2275 &parent_inode, &parent_gen, name);
2276 } else {
2277 ret = __get_cur_name_and_parent(sctx, ino, gen,
2278 &parent_inode,
2279 &parent_gen, name);
2280 if (ret)
2281 stop = 1;
2284 if (ret < 0)
2285 goto out;
2287 ret = fs_path_add_path(dest, name);
2288 if (ret < 0)
2289 goto out;
2291 ino = parent_inode;
2292 gen = parent_gen;
2295 out:
2296 fs_path_free(name);
2297 if (!ret)
2298 fs_path_unreverse(dest);
2299 return ret;
2303 * Sends a BTRFS_SEND_C_SUBVOL command/item to userspace
2305 static int send_subvol_begin(struct send_ctx *sctx)
2307 int ret;
2308 struct btrfs_root *send_root = sctx->send_root;
2309 struct btrfs_root *parent_root = sctx->parent_root;
2310 struct btrfs_path *path;
2311 struct btrfs_key key;
2312 struct btrfs_root_ref *ref;
2313 struct extent_buffer *leaf;
2314 char *name = NULL;
2315 int namelen;
2317 path = btrfs_alloc_path();
2318 if (!path)
2319 return -ENOMEM;
2321 name = kmalloc(BTRFS_PATH_NAME_MAX, GFP_NOFS);
2322 if (!name) {
2323 btrfs_free_path(path);
2324 return -ENOMEM;
2327 key.objectid = send_root->objectid;
2328 key.type = BTRFS_ROOT_BACKREF_KEY;
2329 key.offset = 0;
2331 ret = btrfs_search_slot_for_read(send_root->fs_info->tree_root,
2332 &key, path, 1, 0);
2333 if (ret < 0)
2334 goto out;
2335 if (ret) {
2336 ret = -ENOENT;
2337 goto out;
2340 leaf = path->nodes[0];
2341 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
2342 if (key.type != BTRFS_ROOT_BACKREF_KEY ||
2343 key.objectid != send_root->objectid) {
2344 ret = -ENOENT;
2345 goto out;
2347 ref = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_root_ref);
2348 namelen = btrfs_root_ref_name_len(leaf, ref);
2349 read_extent_buffer(leaf, name, (unsigned long)(ref + 1), namelen);
2350 btrfs_release_path(path);
2352 if (parent_root) {
2353 ret = begin_cmd(sctx, BTRFS_SEND_C_SNAPSHOT);
2354 if (ret < 0)
2355 goto out;
2356 } else {
2357 ret = begin_cmd(sctx, BTRFS_SEND_C_SUBVOL);
2358 if (ret < 0)
2359 goto out;
2362 TLV_PUT_STRING(sctx, BTRFS_SEND_A_PATH, name, namelen);
2364 if (!btrfs_is_empty_uuid(sctx->send_root->root_item.received_uuid))
2365 TLV_PUT_UUID(sctx, BTRFS_SEND_A_UUID,
2366 sctx->send_root->root_item.received_uuid);
2367 else
2368 TLV_PUT_UUID(sctx, BTRFS_SEND_A_UUID,
2369 sctx->send_root->root_item.uuid);
2371 TLV_PUT_U64(sctx, BTRFS_SEND_A_CTRANSID,
2372 le64_to_cpu(sctx->send_root->root_item.ctransid));
2373 if (parent_root) {
2374 if (!btrfs_is_empty_uuid(parent_root->root_item.received_uuid))
2375 TLV_PUT_UUID(sctx, BTRFS_SEND_A_CLONE_UUID,
2376 parent_root->root_item.received_uuid);
2377 else
2378 TLV_PUT_UUID(sctx, BTRFS_SEND_A_CLONE_UUID,
2379 parent_root->root_item.uuid);
2380 TLV_PUT_U64(sctx, BTRFS_SEND_A_CLONE_CTRANSID,
2381 le64_to_cpu(sctx->parent_root->root_item.ctransid));
2384 ret = send_cmd(sctx);
2386 tlv_put_failure:
2387 out:
2388 btrfs_free_path(path);
2389 kfree(name);
2390 return ret;
2393 static int send_truncate(struct send_ctx *sctx, u64 ino, u64 gen, u64 size)
2395 int ret = 0;
2396 struct fs_path *p;
2398 verbose_printk("btrfs: send_truncate %llu size=%llu\n", ino, size);
2400 p = fs_path_alloc();
2401 if (!p)
2402 return -ENOMEM;
2404 ret = begin_cmd(sctx, BTRFS_SEND_C_TRUNCATE);
2405 if (ret < 0)
2406 goto out;
2408 ret = get_cur_path(sctx, ino, gen, p);
2409 if (ret < 0)
2410 goto out;
2411 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
2412 TLV_PUT_U64(sctx, BTRFS_SEND_A_SIZE, size);
2414 ret = send_cmd(sctx);
2416 tlv_put_failure:
2417 out:
2418 fs_path_free(p);
2419 return ret;
2422 static int send_chmod(struct send_ctx *sctx, u64 ino, u64 gen, u64 mode)
2424 int ret = 0;
2425 struct fs_path *p;
2427 verbose_printk("btrfs: send_chmod %llu mode=%llu\n", ino, mode);
2429 p = fs_path_alloc();
2430 if (!p)
2431 return -ENOMEM;
2433 ret = begin_cmd(sctx, BTRFS_SEND_C_CHMOD);
2434 if (ret < 0)
2435 goto out;
2437 ret = get_cur_path(sctx, ino, gen, p);
2438 if (ret < 0)
2439 goto out;
2440 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
2441 TLV_PUT_U64(sctx, BTRFS_SEND_A_MODE, mode & 07777);
2443 ret = send_cmd(sctx);
2445 tlv_put_failure:
2446 out:
2447 fs_path_free(p);
2448 return ret;
2451 static int send_chown(struct send_ctx *sctx, u64 ino, u64 gen, u64 uid, u64 gid)
2453 int ret = 0;
2454 struct fs_path *p;
2456 verbose_printk("btrfs: send_chown %llu uid=%llu, gid=%llu\n", ino, uid, gid);
2458 p = fs_path_alloc();
2459 if (!p)
2460 return -ENOMEM;
2462 ret = begin_cmd(sctx, BTRFS_SEND_C_CHOWN);
2463 if (ret < 0)
2464 goto out;
2466 ret = get_cur_path(sctx, ino, gen, p);
2467 if (ret < 0)
2468 goto out;
2469 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
2470 TLV_PUT_U64(sctx, BTRFS_SEND_A_UID, uid);
2471 TLV_PUT_U64(sctx, BTRFS_SEND_A_GID, gid);
2473 ret = send_cmd(sctx);
2475 tlv_put_failure:
2476 out:
2477 fs_path_free(p);
2478 return ret;
2481 static int send_utimes(struct send_ctx *sctx, u64 ino, u64 gen)
2483 int ret = 0;
2484 struct fs_path *p = NULL;
2485 struct btrfs_inode_item *ii;
2486 struct btrfs_path *path = NULL;
2487 struct extent_buffer *eb;
2488 struct btrfs_key key;
2489 int slot;
2491 verbose_printk("btrfs: send_utimes %llu\n", ino);
2493 p = fs_path_alloc();
2494 if (!p)
2495 return -ENOMEM;
2497 path = alloc_path_for_send();
2498 if (!path) {
2499 ret = -ENOMEM;
2500 goto out;
2503 key.objectid = ino;
2504 key.type = BTRFS_INODE_ITEM_KEY;
2505 key.offset = 0;
2506 ret = btrfs_search_slot(NULL, sctx->send_root, &key, path, 0, 0);
2507 if (ret < 0)
2508 goto out;
2510 eb = path->nodes[0];
2511 slot = path->slots[0];
2512 ii = btrfs_item_ptr(eb, slot, struct btrfs_inode_item);
2514 ret = begin_cmd(sctx, BTRFS_SEND_C_UTIMES);
2515 if (ret < 0)
2516 goto out;
2518 ret = get_cur_path(sctx, ino, gen, p);
2519 if (ret < 0)
2520 goto out;
2521 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
2522 TLV_PUT_BTRFS_TIMESPEC(sctx, BTRFS_SEND_A_ATIME, eb, &ii->atime);
2523 TLV_PUT_BTRFS_TIMESPEC(sctx, BTRFS_SEND_A_MTIME, eb, &ii->mtime);
2524 TLV_PUT_BTRFS_TIMESPEC(sctx, BTRFS_SEND_A_CTIME, eb, &ii->ctime);
2525 /* TODO Add otime support when the otime patches get into upstream */
2527 ret = send_cmd(sctx);
2529 tlv_put_failure:
2530 out:
2531 fs_path_free(p);
2532 btrfs_free_path(path);
2533 return ret;
2537 * Sends a BTRFS_SEND_C_MKXXX or SYMLINK command to user space. We don't have
2538 * a valid path yet because we did not process the refs yet. So, the inode
2539 * is created as orphan.
2541 static int send_create_inode(struct send_ctx *sctx, u64 ino)
2543 int ret = 0;
2544 struct fs_path *p;
2545 int cmd;
2546 u64 gen;
2547 u64 mode;
2548 u64 rdev;
2550 verbose_printk("btrfs: send_create_inode %llu\n", ino);
2552 p = fs_path_alloc();
2553 if (!p)
2554 return -ENOMEM;
2556 if (ino != sctx->cur_ino) {
2557 ret = get_inode_info(sctx->send_root, ino, NULL, &gen, &mode,
2558 NULL, NULL, &rdev);
2559 if (ret < 0)
2560 goto out;
2561 } else {
2562 gen = sctx->cur_inode_gen;
2563 mode = sctx->cur_inode_mode;
2564 rdev = sctx->cur_inode_rdev;
2567 if (S_ISREG(mode)) {
2568 cmd = BTRFS_SEND_C_MKFILE;
2569 } else if (S_ISDIR(mode)) {
2570 cmd = BTRFS_SEND_C_MKDIR;
2571 } else if (S_ISLNK(mode)) {
2572 cmd = BTRFS_SEND_C_SYMLINK;
2573 } else if (S_ISCHR(mode) || S_ISBLK(mode)) {
2574 cmd = BTRFS_SEND_C_MKNOD;
2575 } else if (S_ISFIFO(mode)) {
2576 cmd = BTRFS_SEND_C_MKFIFO;
2577 } else if (S_ISSOCK(mode)) {
2578 cmd = BTRFS_SEND_C_MKSOCK;
2579 } else {
2580 btrfs_warn(sctx->send_root->fs_info, "unexpected inode type %o",
2581 (int)(mode & S_IFMT));
2582 ret = -ENOTSUPP;
2583 goto out;
2586 ret = begin_cmd(sctx, cmd);
2587 if (ret < 0)
2588 goto out;
2590 ret = gen_unique_name(sctx, ino, gen, p);
2591 if (ret < 0)
2592 goto out;
2594 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
2595 TLV_PUT_U64(sctx, BTRFS_SEND_A_INO, ino);
2597 if (S_ISLNK(mode)) {
2598 fs_path_reset(p);
2599 ret = read_symlink(sctx->send_root, ino, p);
2600 if (ret < 0)
2601 goto out;
2602 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH_LINK, p);
2603 } else if (S_ISCHR(mode) || S_ISBLK(mode) ||
2604 S_ISFIFO(mode) || S_ISSOCK(mode)) {
2605 TLV_PUT_U64(sctx, BTRFS_SEND_A_RDEV, new_encode_dev(rdev));
2606 TLV_PUT_U64(sctx, BTRFS_SEND_A_MODE, mode);
2609 ret = send_cmd(sctx);
2610 if (ret < 0)
2611 goto out;
2614 tlv_put_failure:
2615 out:
2616 fs_path_free(p);
2617 return ret;
2621 * We need some special handling for inodes that get processed before the parent
2622 * directory got created. See process_recorded_refs for details.
2623 * This function does the check if we already created the dir out of order.
2625 static int did_create_dir(struct send_ctx *sctx, u64 dir)
2627 int ret = 0;
2628 struct btrfs_path *path = NULL;
2629 struct btrfs_key key;
2630 struct btrfs_key found_key;
2631 struct btrfs_key di_key;
2632 struct extent_buffer *eb;
2633 struct btrfs_dir_item *di;
2634 int slot;
2636 path = alloc_path_for_send();
2637 if (!path) {
2638 ret = -ENOMEM;
2639 goto out;
2642 key.objectid = dir;
2643 key.type = BTRFS_DIR_INDEX_KEY;
2644 key.offset = 0;
2645 ret = btrfs_search_slot(NULL, sctx->send_root, &key, path, 0, 0);
2646 if (ret < 0)
2647 goto out;
2649 while (1) {
2650 eb = path->nodes[0];
2651 slot = path->slots[0];
2652 if (slot >= btrfs_header_nritems(eb)) {
2653 ret = btrfs_next_leaf(sctx->send_root, path);
2654 if (ret < 0) {
2655 goto out;
2656 } else if (ret > 0) {
2657 ret = 0;
2658 break;
2660 continue;
2663 btrfs_item_key_to_cpu(eb, &found_key, slot);
2664 if (found_key.objectid != key.objectid ||
2665 found_key.type != key.type) {
2666 ret = 0;
2667 goto out;
2670 di = btrfs_item_ptr(eb, slot, struct btrfs_dir_item);
2671 btrfs_dir_item_key_to_cpu(eb, di, &di_key);
2673 if (di_key.type != BTRFS_ROOT_ITEM_KEY &&
2674 di_key.objectid < sctx->send_progress) {
2675 ret = 1;
2676 goto out;
2679 path->slots[0]++;
2682 out:
2683 btrfs_free_path(path);
2684 return ret;
2688 * Only creates the inode if it is:
2689 * 1. Not a directory
2690 * 2. Or a directory which was not created already due to out of order
2691 * directories. See did_create_dir and process_recorded_refs for details.
2693 static int send_create_inode_if_needed(struct send_ctx *sctx)
2695 int ret;
2697 if (S_ISDIR(sctx->cur_inode_mode)) {
2698 ret = did_create_dir(sctx, sctx->cur_ino);
2699 if (ret < 0)
2700 goto out;
2701 if (ret) {
2702 ret = 0;
2703 goto out;
2707 ret = send_create_inode(sctx, sctx->cur_ino);
2708 if (ret < 0)
2709 goto out;
2711 out:
2712 return ret;
2715 struct recorded_ref {
2716 struct list_head list;
2717 char *dir_path;
2718 char *name;
2719 struct fs_path *full_path;
2720 u64 dir;
2721 u64 dir_gen;
2722 int dir_path_len;
2723 int name_len;
2727 * We need to process new refs before deleted refs, but compare_tree gives us
2728 * everything mixed. So we first record all refs and later process them.
2729 * This function is a helper to record one ref.
2731 static int __record_ref(struct list_head *head, u64 dir,
2732 u64 dir_gen, struct fs_path *path)
2734 struct recorded_ref *ref;
2736 ref = kmalloc(sizeof(*ref), GFP_NOFS);
2737 if (!ref)
2738 return -ENOMEM;
2740 ref->dir = dir;
2741 ref->dir_gen = dir_gen;
2742 ref->full_path = path;
2744 ref->name = (char *)kbasename(ref->full_path->start);
2745 ref->name_len = ref->full_path->end - ref->name;
2746 ref->dir_path = ref->full_path->start;
2747 if (ref->name == ref->full_path->start)
2748 ref->dir_path_len = 0;
2749 else
2750 ref->dir_path_len = ref->full_path->end -
2751 ref->full_path->start - 1 - ref->name_len;
2753 list_add_tail(&ref->list, head);
2754 return 0;
2757 static int dup_ref(struct recorded_ref *ref, struct list_head *list)
2759 struct recorded_ref *new;
2761 new = kmalloc(sizeof(*ref), GFP_NOFS);
2762 if (!new)
2763 return -ENOMEM;
2765 new->dir = ref->dir;
2766 new->dir_gen = ref->dir_gen;
2767 new->full_path = NULL;
2768 INIT_LIST_HEAD(&new->list);
2769 list_add_tail(&new->list, list);
2770 return 0;
2773 static void __free_recorded_refs(struct list_head *head)
2775 struct recorded_ref *cur;
2777 while (!list_empty(head)) {
2778 cur = list_entry(head->next, struct recorded_ref, list);
2779 fs_path_free(cur->full_path);
2780 list_del(&cur->list);
2781 kfree(cur);
2785 static void free_recorded_refs(struct send_ctx *sctx)
2787 __free_recorded_refs(&sctx->new_refs);
2788 __free_recorded_refs(&sctx->deleted_refs);
2792 * Renames/moves a file/dir to its orphan name. Used when the first
2793 * ref of an unprocessed inode gets overwritten and for all non empty
2794 * directories.
2796 static int orphanize_inode(struct send_ctx *sctx, u64 ino, u64 gen,
2797 struct fs_path *path)
2799 int ret;
2800 struct fs_path *orphan;
2802 orphan = fs_path_alloc();
2803 if (!orphan)
2804 return -ENOMEM;
2806 ret = gen_unique_name(sctx, ino, gen, orphan);
2807 if (ret < 0)
2808 goto out;
2810 ret = send_rename(sctx, path, orphan);
2812 out:
2813 fs_path_free(orphan);
2814 return ret;
2817 static struct orphan_dir_info *
2818 add_orphan_dir_info(struct send_ctx *sctx, u64 dir_ino)
2820 struct rb_node **p = &sctx->orphan_dirs.rb_node;
2821 struct rb_node *parent = NULL;
2822 struct orphan_dir_info *entry, *odi;
2824 odi = kmalloc(sizeof(*odi), GFP_NOFS);
2825 if (!odi)
2826 return ERR_PTR(-ENOMEM);
2827 odi->ino = dir_ino;
2828 odi->gen = 0;
2830 while (*p) {
2831 parent = *p;
2832 entry = rb_entry(parent, struct orphan_dir_info, node);
2833 if (dir_ino < entry->ino) {
2834 p = &(*p)->rb_left;
2835 } else if (dir_ino > entry->ino) {
2836 p = &(*p)->rb_right;
2837 } else {
2838 kfree(odi);
2839 return entry;
2843 rb_link_node(&odi->node, parent, p);
2844 rb_insert_color(&odi->node, &sctx->orphan_dirs);
2845 return odi;
2848 static struct orphan_dir_info *
2849 get_orphan_dir_info(struct send_ctx *sctx, u64 dir_ino)
2851 struct rb_node *n = sctx->orphan_dirs.rb_node;
2852 struct orphan_dir_info *entry;
2854 while (n) {
2855 entry = rb_entry(n, struct orphan_dir_info, node);
2856 if (dir_ino < entry->ino)
2857 n = n->rb_left;
2858 else if (dir_ino > entry->ino)
2859 n = n->rb_right;
2860 else
2861 return entry;
2863 return NULL;
2866 static int is_waiting_for_rm(struct send_ctx *sctx, u64 dir_ino)
2868 struct orphan_dir_info *odi = get_orphan_dir_info(sctx, dir_ino);
2870 return odi != NULL;
2873 static void free_orphan_dir_info(struct send_ctx *sctx,
2874 struct orphan_dir_info *odi)
2876 if (!odi)
2877 return;
2878 rb_erase(&odi->node, &sctx->orphan_dirs);
2879 kfree(odi);
2883 * Returns 1 if a directory can be removed at this point in time.
2884 * We check this by iterating all dir items and checking if the inode behind
2885 * the dir item was already processed.
2887 static int can_rmdir(struct send_ctx *sctx, u64 dir, u64 dir_gen,
2888 u64 send_progress)
2890 int ret = 0;
2891 struct btrfs_root *root = sctx->parent_root;
2892 struct btrfs_path *path;
2893 struct btrfs_key key;
2894 struct btrfs_key found_key;
2895 struct btrfs_key loc;
2896 struct btrfs_dir_item *di;
2899 * Don't try to rmdir the top/root subvolume dir.
2901 if (dir == BTRFS_FIRST_FREE_OBJECTID)
2902 return 0;
2904 path = alloc_path_for_send();
2905 if (!path)
2906 return -ENOMEM;
2908 key.objectid = dir;
2909 key.type = BTRFS_DIR_INDEX_KEY;
2910 key.offset = 0;
2911 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
2912 if (ret < 0)
2913 goto out;
2915 while (1) {
2916 struct waiting_dir_move *dm;
2918 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
2919 ret = btrfs_next_leaf(root, path);
2920 if (ret < 0)
2921 goto out;
2922 else if (ret > 0)
2923 break;
2924 continue;
2926 btrfs_item_key_to_cpu(path->nodes[0], &found_key,
2927 path->slots[0]);
2928 if (found_key.objectid != key.objectid ||
2929 found_key.type != key.type)
2930 break;
2932 di = btrfs_item_ptr(path->nodes[0], path->slots[0],
2933 struct btrfs_dir_item);
2934 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &loc);
2936 dm = get_waiting_dir_move(sctx, loc.objectid);
2937 if (dm) {
2938 struct orphan_dir_info *odi;
2940 odi = add_orphan_dir_info(sctx, dir);
2941 if (IS_ERR(odi)) {
2942 ret = PTR_ERR(odi);
2943 goto out;
2945 odi->gen = dir_gen;
2946 dm->rmdir_ino = dir;
2947 ret = 0;
2948 goto out;
2951 if (loc.objectid > send_progress) {
2952 ret = 0;
2953 goto out;
2956 path->slots[0]++;
2959 ret = 1;
2961 out:
2962 btrfs_free_path(path);
2963 return ret;
2966 static int is_waiting_for_move(struct send_ctx *sctx, u64 ino)
2968 struct waiting_dir_move *entry = get_waiting_dir_move(sctx, ino);
2970 return entry != NULL;
2973 static int add_waiting_dir_move(struct send_ctx *sctx, u64 ino, bool orphanized)
2975 struct rb_node **p = &sctx->waiting_dir_moves.rb_node;
2976 struct rb_node *parent = NULL;
2977 struct waiting_dir_move *entry, *dm;
2979 dm = kmalloc(sizeof(*dm), GFP_NOFS);
2980 if (!dm)
2981 return -ENOMEM;
2982 dm->ino = ino;
2983 dm->rmdir_ino = 0;
2984 dm->orphanized = orphanized;
2986 while (*p) {
2987 parent = *p;
2988 entry = rb_entry(parent, struct waiting_dir_move, node);
2989 if (ino < entry->ino) {
2990 p = &(*p)->rb_left;
2991 } else if (ino > entry->ino) {
2992 p = &(*p)->rb_right;
2993 } else {
2994 kfree(dm);
2995 return -EEXIST;
2999 rb_link_node(&dm->node, parent, p);
3000 rb_insert_color(&dm->node, &sctx->waiting_dir_moves);
3001 return 0;
3004 static struct waiting_dir_move *
3005 get_waiting_dir_move(struct send_ctx *sctx, u64 ino)
3007 struct rb_node *n = sctx->waiting_dir_moves.rb_node;
3008 struct waiting_dir_move *entry;
3010 while (n) {
3011 entry = rb_entry(n, struct waiting_dir_move, node);
3012 if (ino < entry->ino)
3013 n = n->rb_left;
3014 else if (ino > entry->ino)
3015 n = n->rb_right;
3016 else
3017 return entry;
3019 return NULL;
3022 static void free_waiting_dir_move(struct send_ctx *sctx,
3023 struct waiting_dir_move *dm)
3025 if (!dm)
3026 return;
3027 rb_erase(&dm->node, &sctx->waiting_dir_moves);
3028 kfree(dm);
3031 static int add_pending_dir_move(struct send_ctx *sctx,
3032 u64 ino,
3033 u64 ino_gen,
3034 u64 parent_ino,
3035 struct list_head *new_refs,
3036 struct list_head *deleted_refs,
3037 const bool is_orphan)
3039 struct rb_node **p = &sctx->pending_dir_moves.rb_node;
3040 struct rb_node *parent = NULL;
3041 struct pending_dir_move *entry = NULL, *pm;
3042 struct recorded_ref *cur;
3043 int exists = 0;
3044 int ret;
3046 pm = kmalloc(sizeof(*pm), GFP_NOFS);
3047 if (!pm)
3048 return -ENOMEM;
3049 pm->parent_ino = parent_ino;
3050 pm->ino = ino;
3051 pm->gen = ino_gen;
3052 pm->is_orphan = is_orphan;
3053 INIT_LIST_HEAD(&pm->list);
3054 INIT_LIST_HEAD(&pm->update_refs);
3055 RB_CLEAR_NODE(&pm->node);
3057 while (*p) {
3058 parent = *p;
3059 entry = rb_entry(parent, struct pending_dir_move, node);
3060 if (parent_ino < entry->parent_ino) {
3061 p = &(*p)->rb_left;
3062 } else if (parent_ino > entry->parent_ino) {
3063 p = &(*p)->rb_right;
3064 } else {
3065 exists = 1;
3066 break;
3070 list_for_each_entry(cur, deleted_refs, list) {
3071 ret = dup_ref(cur, &pm->update_refs);
3072 if (ret < 0)
3073 goto out;
3075 list_for_each_entry(cur, new_refs, list) {
3076 ret = dup_ref(cur, &pm->update_refs);
3077 if (ret < 0)
3078 goto out;
3081 ret = add_waiting_dir_move(sctx, pm->ino, is_orphan);
3082 if (ret)
3083 goto out;
3085 if (exists) {
3086 list_add_tail(&pm->list, &entry->list);
3087 } else {
3088 rb_link_node(&pm->node, parent, p);
3089 rb_insert_color(&pm->node, &sctx->pending_dir_moves);
3091 ret = 0;
3092 out:
3093 if (ret) {
3094 __free_recorded_refs(&pm->update_refs);
3095 kfree(pm);
3097 return ret;
3100 static struct pending_dir_move *get_pending_dir_moves(struct send_ctx *sctx,
3101 u64 parent_ino)
3103 struct rb_node *n = sctx->pending_dir_moves.rb_node;
3104 struct pending_dir_move *entry;
3106 while (n) {
3107 entry = rb_entry(n, struct pending_dir_move, node);
3108 if (parent_ino < entry->parent_ino)
3109 n = n->rb_left;
3110 else if (parent_ino > entry->parent_ino)
3111 n = n->rb_right;
3112 else
3113 return entry;
3115 return NULL;
3118 static int apply_dir_move(struct send_ctx *sctx, struct pending_dir_move *pm)
3120 struct fs_path *from_path = NULL;
3121 struct fs_path *to_path = NULL;
3122 struct fs_path *name = NULL;
3123 u64 orig_progress = sctx->send_progress;
3124 struct recorded_ref *cur;
3125 u64 parent_ino, parent_gen;
3126 struct waiting_dir_move *dm = NULL;
3127 u64 rmdir_ino = 0;
3128 int ret;
3130 name = fs_path_alloc();
3131 from_path = fs_path_alloc();
3132 if (!name || !from_path) {
3133 ret = -ENOMEM;
3134 goto out;
3137 dm = get_waiting_dir_move(sctx, pm->ino);
3138 ASSERT(dm);
3139 rmdir_ino = dm->rmdir_ino;
3140 free_waiting_dir_move(sctx, dm);
3142 if (pm->is_orphan) {
3143 ret = gen_unique_name(sctx, pm->ino,
3144 pm->gen, from_path);
3145 } else {
3146 ret = get_first_ref(sctx->parent_root, pm->ino,
3147 &parent_ino, &parent_gen, name);
3148 if (ret < 0)
3149 goto out;
3150 ret = get_cur_path(sctx, parent_ino, parent_gen,
3151 from_path);
3152 if (ret < 0)
3153 goto out;
3154 ret = fs_path_add_path(from_path, name);
3156 if (ret < 0)
3157 goto out;
3159 sctx->send_progress = sctx->cur_ino + 1;
3160 fs_path_reset(name);
3161 to_path = name;
3162 name = NULL;
3163 ret = get_cur_path(sctx, pm->ino, pm->gen, to_path);
3164 if (ret < 0)
3165 goto out;
3167 ret = send_rename(sctx, from_path, to_path);
3168 if (ret < 0)
3169 goto out;
3171 if (rmdir_ino) {
3172 struct orphan_dir_info *odi;
3174 odi = get_orphan_dir_info(sctx, rmdir_ino);
3175 if (!odi) {
3176 /* already deleted */
3177 goto finish;
3179 ret = can_rmdir(sctx, rmdir_ino, odi->gen, sctx->cur_ino + 1);
3180 if (ret < 0)
3181 goto out;
3182 if (!ret)
3183 goto finish;
3185 name = fs_path_alloc();
3186 if (!name) {
3187 ret = -ENOMEM;
3188 goto out;
3190 ret = get_cur_path(sctx, rmdir_ino, odi->gen, name);
3191 if (ret < 0)
3192 goto out;
3193 ret = send_rmdir(sctx, name);
3194 if (ret < 0)
3195 goto out;
3196 free_orphan_dir_info(sctx, odi);
3199 finish:
3200 ret = send_utimes(sctx, pm->ino, pm->gen);
3201 if (ret < 0)
3202 goto out;
3205 * After rename/move, need to update the utimes of both new parent(s)
3206 * and old parent(s).
3208 list_for_each_entry(cur, &pm->update_refs, list) {
3209 if (cur->dir == rmdir_ino)
3210 continue;
3211 ret = send_utimes(sctx, cur->dir, cur->dir_gen);
3212 if (ret < 0)
3213 goto out;
3216 out:
3217 fs_path_free(name);
3218 fs_path_free(from_path);
3219 fs_path_free(to_path);
3220 sctx->send_progress = orig_progress;
3222 return ret;
3225 static void free_pending_move(struct send_ctx *sctx, struct pending_dir_move *m)
3227 if (!list_empty(&m->list))
3228 list_del(&m->list);
3229 if (!RB_EMPTY_NODE(&m->node))
3230 rb_erase(&m->node, &sctx->pending_dir_moves);
3231 __free_recorded_refs(&m->update_refs);
3232 kfree(m);
3235 static void tail_append_pending_moves(struct pending_dir_move *moves,
3236 struct list_head *stack)
3238 if (list_empty(&moves->list)) {
3239 list_add_tail(&moves->list, stack);
3240 } else {
3241 LIST_HEAD(list);
3242 list_splice_init(&moves->list, &list);
3243 list_add_tail(&moves->list, stack);
3244 list_splice_tail(&list, stack);
3248 static int apply_children_dir_moves(struct send_ctx *sctx)
3250 struct pending_dir_move *pm;
3251 struct list_head stack;
3252 u64 parent_ino = sctx->cur_ino;
3253 int ret = 0;
3255 pm = get_pending_dir_moves(sctx, parent_ino);
3256 if (!pm)
3257 return 0;
3259 INIT_LIST_HEAD(&stack);
3260 tail_append_pending_moves(pm, &stack);
3262 while (!list_empty(&stack)) {
3263 pm = list_first_entry(&stack, struct pending_dir_move, list);
3264 parent_ino = pm->ino;
3265 ret = apply_dir_move(sctx, pm);
3266 free_pending_move(sctx, pm);
3267 if (ret)
3268 goto out;
3269 pm = get_pending_dir_moves(sctx, parent_ino);
3270 if (pm)
3271 tail_append_pending_moves(pm, &stack);
3273 return 0;
3275 out:
3276 while (!list_empty(&stack)) {
3277 pm = list_first_entry(&stack, struct pending_dir_move, list);
3278 free_pending_move(sctx, pm);
3280 return ret;
3284 * We might need to delay a directory rename even when no ancestor directory
3285 * (in the send root) with a higher inode number than ours (sctx->cur_ino) was
3286 * renamed. This happens when we rename a directory to the old name (the name
3287 * in the parent root) of some other unrelated directory that got its rename
3288 * delayed due to some ancestor with higher number that got renamed.
3290 * Example:
3292 * Parent snapshot:
3293 * . (ino 256)
3294 * |---- a/ (ino 257)
3295 * | |---- file (ino 260)
3297 * |---- b/ (ino 258)
3298 * |---- c/ (ino 259)
3300 * Send snapshot:
3301 * . (ino 256)
3302 * |---- a/ (ino 258)
3303 * |---- x/ (ino 259)
3304 * |---- y/ (ino 257)
3305 * |----- file (ino 260)
3307 * Here we can not rename 258 from 'b' to 'a' without the rename of inode 257
3308 * from 'a' to 'x/y' happening first, which in turn depends on the rename of
3309 * inode 259 from 'c' to 'x'. So the order of rename commands the send stream
3310 * must issue is:
3312 * 1 - rename 259 from 'c' to 'x'
3313 * 2 - rename 257 from 'a' to 'x/y'
3314 * 3 - rename 258 from 'b' to 'a'
3316 * Returns 1 if the rename of sctx->cur_ino needs to be delayed, 0 if it can
3317 * be done right away and < 0 on error.
3319 static int wait_for_dest_dir_move(struct send_ctx *sctx,
3320 struct recorded_ref *parent_ref,
3321 const bool is_orphan)
3323 struct btrfs_path *path;
3324 struct btrfs_key key;
3325 struct btrfs_key di_key;
3326 struct btrfs_dir_item *di;
3327 u64 left_gen;
3328 u64 right_gen;
3329 int ret = 0;
3331 if (RB_EMPTY_ROOT(&sctx->waiting_dir_moves))
3332 return 0;
3334 path = alloc_path_for_send();
3335 if (!path)
3336 return -ENOMEM;
3338 key.objectid = parent_ref->dir;
3339 key.type = BTRFS_DIR_ITEM_KEY;
3340 key.offset = btrfs_name_hash(parent_ref->name, parent_ref->name_len);
3342 ret = btrfs_search_slot(NULL, sctx->parent_root, &key, path, 0, 0);
3343 if (ret < 0) {
3344 goto out;
3345 } else if (ret > 0) {
3346 ret = 0;
3347 goto out;
3350 di = btrfs_match_dir_item_name(sctx->parent_root, path,
3351 parent_ref->name, parent_ref->name_len);
3352 if (!di) {
3353 ret = 0;
3354 goto out;
3357 * di_key.objectid has the number of the inode that has a dentry in the
3358 * parent directory with the same name that sctx->cur_ino is being
3359 * renamed to. We need to check if that inode is in the send root as
3360 * well and if it is currently marked as an inode with a pending rename,
3361 * if it is, we need to delay the rename of sctx->cur_ino as well, so
3362 * that it happens after that other inode is renamed.
3364 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &di_key);
3365 if (di_key.type != BTRFS_INODE_ITEM_KEY) {
3366 ret = 0;
3367 goto out;
3370 ret = get_inode_info(sctx->parent_root, di_key.objectid, NULL,
3371 &left_gen, NULL, NULL, NULL, NULL);
3372 if (ret < 0)
3373 goto out;
3374 ret = get_inode_info(sctx->send_root, di_key.objectid, NULL,
3375 &right_gen, NULL, NULL, NULL, NULL);
3376 if (ret < 0) {
3377 if (ret == -ENOENT)
3378 ret = 0;
3379 goto out;
3382 /* Different inode, no need to delay the rename of sctx->cur_ino */
3383 if (right_gen != left_gen) {
3384 ret = 0;
3385 goto out;
3388 if (is_waiting_for_move(sctx, di_key.objectid)) {
3389 ret = add_pending_dir_move(sctx,
3390 sctx->cur_ino,
3391 sctx->cur_inode_gen,
3392 di_key.objectid,
3393 &sctx->new_refs,
3394 &sctx->deleted_refs,
3395 is_orphan);
3396 if (!ret)
3397 ret = 1;
3399 out:
3400 btrfs_free_path(path);
3401 return ret;
3405 * Check if ino ino1 is an ancestor of inode ino2 in the given root.
3406 * Return 1 if true, 0 if false and < 0 on error.
3408 static int is_ancestor(struct btrfs_root *root,
3409 const u64 ino1,
3410 const u64 ino1_gen,
3411 const u64 ino2,
3412 struct fs_path *fs_path)
3414 u64 ino = ino2;
3416 while (ino > BTRFS_FIRST_FREE_OBJECTID) {
3417 int ret;
3418 u64 parent;
3419 u64 parent_gen;
3421 fs_path_reset(fs_path);
3422 ret = get_first_ref(root, ino, &parent, &parent_gen, fs_path);
3423 if (ret < 0) {
3424 if (ret == -ENOENT && ino == ino2)
3425 ret = 0;
3426 return ret;
3428 if (parent == ino1)
3429 return parent_gen == ino1_gen ? 1 : 0;
3430 ino = parent;
3432 return 0;
3435 static int wait_for_parent_move(struct send_ctx *sctx,
3436 struct recorded_ref *parent_ref,
3437 const bool is_orphan)
3439 int ret = 0;
3440 u64 ino = parent_ref->dir;
3441 u64 parent_ino_before, parent_ino_after;
3442 struct fs_path *path_before = NULL;
3443 struct fs_path *path_after = NULL;
3444 int len1, len2;
3446 path_after = fs_path_alloc();
3447 path_before = fs_path_alloc();
3448 if (!path_after || !path_before) {
3449 ret = -ENOMEM;
3450 goto out;
3454 * Our current directory inode may not yet be renamed/moved because some
3455 * ancestor (immediate or not) has to be renamed/moved first. So find if
3456 * such ancestor exists and make sure our own rename/move happens after
3457 * that ancestor is processed to avoid path build infinite loops (done
3458 * at get_cur_path()).
3460 while (ino > BTRFS_FIRST_FREE_OBJECTID) {
3461 if (is_waiting_for_move(sctx, ino)) {
3463 * If the current inode is an ancestor of ino in the
3464 * parent root, we need to delay the rename of the
3465 * current inode, otherwise don't delayed the rename
3466 * because we can end up with a circular dependency
3467 * of renames, resulting in some directories never
3468 * getting the respective rename operations issued in
3469 * the send stream or getting into infinite path build
3470 * loops.
3472 ret = is_ancestor(sctx->parent_root,
3473 sctx->cur_ino, sctx->cur_inode_gen,
3474 ino, path_before);
3475 break;
3478 fs_path_reset(path_before);
3479 fs_path_reset(path_after);
3481 ret = get_first_ref(sctx->send_root, ino, &parent_ino_after,
3482 NULL, path_after);
3483 if (ret < 0)
3484 goto out;
3485 ret = get_first_ref(sctx->parent_root, ino, &parent_ino_before,
3486 NULL, path_before);
3487 if (ret < 0 && ret != -ENOENT) {
3488 goto out;
3489 } else if (ret == -ENOENT) {
3490 ret = 0;
3491 break;
3494 len1 = fs_path_len(path_before);
3495 len2 = fs_path_len(path_after);
3496 if (ino > sctx->cur_ino &&
3497 (parent_ino_before != parent_ino_after || len1 != len2 ||
3498 memcmp(path_before->start, path_after->start, len1))) {
3499 ret = 1;
3500 break;
3502 ino = parent_ino_after;
3505 out:
3506 fs_path_free(path_before);
3507 fs_path_free(path_after);
3509 if (ret == 1) {
3510 ret = add_pending_dir_move(sctx,
3511 sctx->cur_ino,
3512 sctx->cur_inode_gen,
3513 ino,
3514 &sctx->new_refs,
3515 &sctx->deleted_refs,
3516 is_orphan);
3517 if (!ret)
3518 ret = 1;
3521 return ret;
3525 * This does all the move/link/unlink/rmdir magic.
3527 static int process_recorded_refs(struct send_ctx *sctx, int *pending_move)
3529 int ret = 0;
3530 struct recorded_ref *cur;
3531 struct recorded_ref *cur2;
3532 struct list_head check_dirs;
3533 struct fs_path *valid_path = NULL;
3534 u64 ow_inode = 0;
3535 u64 ow_gen;
3536 int did_overwrite = 0;
3537 int is_orphan = 0;
3538 u64 last_dir_ino_rm = 0;
3539 bool can_rename = true;
3541 verbose_printk("btrfs: process_recorded_refs %llu\n", sctx->cur_ino);
3544 * This should never happen as the root dir always has the same ref
3545 * which is always '..'
3547 BUG_ON(sctx->cur_ino <= BTRFS_FIRST_FREE_OBJECTID);
3548 INIT_LIST_HEAD(&check_dirs);
3550 valid_path = fs_path_alloc();
3551 if (!valid_path) {
3552 ret = -ENOMEM;
3553 goto out;
3557 * First, check if the first ref of the current inode was overwritten
3558 * before. If yes, we know that the current inode was already orphanized
3559 * and thus use the orphan name. If not, we can use get_cur_path to
3560 * get the path of the first ref as it would like while receiving at
3561 * this point in time.
3562 * New inodes are always orphan at the beginning, so force to use the
3563 * orphan name in this case.
3564 * The first ref is stored in valid_path and will be updated if it
3565 * gets moved around.
3567 if (!sctx->cur_inode_new) {
3568 ret = did_overwrite_first_ref(sctx, sctx->cur_ino,
3569 sctx->cur_inode_gen);
3570 if (ret < 0)
3571 goto out;
3572 if (ret)
3573 did_overwrite = 1;
3575 if (sctx->cur_inode_new || did_overwrite) {
3576 ret = gen_unique_name(sctx, sctx->cur_ino,
3577 sctx->cur_inode_gen, valid_path);
3578 if (ret < 0)
3579 goto out;
3580 is_orphan = 1;
3581 } else {
3582 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen,
3583 valid_path);
3584 if (ret < 0)
3585 goto out;
3588 list_for_each_entry(cur, &sctx->new_refs, list) {
3590 * We may have refs where the parent directory does not exist
3591 * yet. This happens if the parent directories inum is higher
3592 * the the current inum. To handle this case, we create the
3593 * parent directory out of order. But we need to check if this
3594 * did already happen before due to other refs in the same dir.
3596 ret = get_cur_inode_state(sctx, cur->dir, cur->dir_gen);
3597 if (ret < 0)
3598 goto out;
3599 if (ret == inode_state_will_create) {
3600 ret = 0;
3602 * First check if any of the current inodes refs did
3603 * already create the dir.
3605 list_for_each_entry(cur2, &sctx->new_refs, list) {
3606 if (cur == cur2)
3607 break;
3608 if (cur2->dir == cur->dir) {
3609 ret = 1;
3610 break;
3615 * If that did not happen, check if a previous inode
3616 * did already create the dir.
3618 if (!ret)
3619 ret = did_create_dir(sctx, cur->dir);
3620 if (ret < 0)
3621 goto out;
3622 if (!ret) {
3623 ret = send_create_inode(sctx, cur->dir);
3624 if (ret < 0)
3625 goto out;
3630 * Check if this new ref would overwrite the first ref of
3631 * another unprocessed inode. If yes, orphanize the
3632 * overwritten inode. If we find an overwritten ref that is
3633 * not the first ref, simply unlink it.
3635 ret = will_overwrite_ref(sctx, cur->dir, cur->dir_gen,
3636 cur->name, cur->name_len,
3637 &ow_inode, &ow_gen);
3638 if (ret < 0)
3639 goto out;
3640 if (ret) {
3641 ret = is_first_ref(sctx->parent_root,
3642 ow_inode, cur->dir, cur->name,
3643 cur->name_len);
3644 if (ret < 0)
3645 goto out;
3646 if (ret) {
3647 struct name_cache_entry *nce;
3649 ret = orphanize_inode(sctx, ow_inode, ow_gen,
3650 cur->full_path);
3651 if (ret < 0)
3652 goto out;
3654 * Make sure we clear our orphanized inode's
3655 * name from the name cache. This is because the
3656 * inode ow_inode might be an ancestor of some
3657 * other inode that will be orphanized as well
3658 * later and has an inode number greater than
3659 * sctx->send_progress. We need to prevent
3660 * future name lookups from using the old name
3661 * and get instead the orphan name.
3663 nce = name_cache_search(sctx, ow_inode, ow_gen);
3664 if (nce) {
3665 name_cache_delete(sctx, nce);
3666 kfree(nce);
3668 } else {
3669 ret = send_unlink(sctx, cur->full_path);
3670 if (ret < 0)
3671 goto out;
3675 if (S_ISDIR(sctx->cur_inode_mode) && sctx->parent_root) {
3676 ret = wait_for_dest_dir_move(sctx, cur, is_orphan);
3677 if (ret < 0)
3678 goto out;
3679 if (ret == 1) {
3680 can_rename = false;
3681 *pending_move = 1;
3685 if (S_ISDIR(sctx->cur_inode_mode) && sctx->parent_root &&
3686 can_rename) {
3687 ret = wait_for_parent_move(sctx, cur, is_orphan);
3688 if (ret < 0)
3689 goto out;
3690 if (ret == 1) {
3691 can_rename = false;
3692 *pending_move = 1;
3697 * link/move the ref to the new place. If we have an orphan
3698 * inode, move it and update valid_path. If not, link or move
3699 * it depending on the inode mode.
3701 if (is_orphan && can_rename) {
3702 ret = send_rename(sctx, valid_path, cur->full_path);
3703 if (ret < 0)
3704 goto out;
3705 is_orphan = 0;
3706 ret = fs_path_copy(valid_path, cur->full_path);
3707 if (ret < 0)
3708 goto out;
3709 } else if (can_rename) {
3710 if (S_ISDIR(sctx->cur_inode_mode)) {
3712 * Dirs can't be linked, so move it. For moved
3713 * dirs, we always have one new and one deleted
3714 * ref. The deleted ref is ignored later.
3716 ret = send_rename(sctx, valid_path,
3717 cur->full_path);
3718 if (!ret)
3719 ret = fs_path_copy(valid_path,
3720 cur->full_path);
3721 if (ret < 0)
3722 goto out;
3723 } else {
3724 ret = send_link(sctx, cur->full_path,
3725 valid_path);
3726 if (ret < 0)
3727 goto out;
3730 ret = dup_ref(cur, &check_dirs);
3731 if (ret < 0)
3732 goto out;
3735 if (S_ISDIR(sctx->cur_inode_mode) && sctx->cur_inode_deleted) {
3737 * Check if we can already rmdir the directory. If not,
3738 * orphanize it. For every dir item inside that gets deleted
3739 * later, we do this check again and rmdir it then if possible.
3740 * See the use of check_dirs for more details.
3742 ret = can_rmdir(sctx, sctx->cur_ino, sctx->cur_inode_gen,
3743 sctx->cur_ino);
3744 if (ret < 0)
3745 goto out;
3746 if (ret) {
3747 ret = send_rmdir(sctx, valid_path);
3748 if (ret < 0)
3749 goto out;
3750 } else if (!is_orphan) {
3751 ret = orphanize_inode(sctx, sctx->cur_ino,
3752 sctx->cur_inode_gen, valid_path);
3753 if (ret < 0)
3754 goto out;
3755 is_orphan = 1;
3758 list_for_each_entry(cur, &sctx->deleted_refs, list) {
3759 ret = dup_ref(cur, &check_dirs);
3760 if (ret < 0)
3761 goto out;
3763 } else if (S_ISDIR(sctx->cur_inode_mode) &&
3764 !list_empty(&sctx->deleted_refs)) {
3766 * We have a moved dir. Add the old parent to check_dirs
3768 cur = list_entry(sctx->deleted_refs.next, struct recorded_ref,
3769 list);
3770 ret = dup_ref(cur, &check_dirs);
3771 if (ret < 0)
3772 goto out;
3773 } else if (!S_ISDIR(sctx->cur_inode_mode)) {
3775 * We have a non dir inode. Go through all deleted refs and
3776 * unlink them if they were not already overwritten by other
3777 * inodes.
3779 list_for_each_entry(cur, &sctx->deleted_refs, list) {
3780 ret = did_overwrite_ref(sctx, cur->dir, cur->dir_gen,
3781 sctx->cur_ino, sctx->cur_inode_gen,
3782 cur->name, cur->name_len);
3783 if (ret < 0)
3784 goto out;
3785 if (!ret) {
3786 ret = send_unlink(sctx, cur->full_path);
3787 if (ret < 0)
3788 goto out;
3790 ret = dup_ref(cur, &check_dirs);
3791 if (ret < 0)
3792 goto out;
3795 * If the inode is still orphan, unlink the orphan. This may
3796 * happen when a previous inode did overwrite the first ref
3797 * of this inode and no new refs were added for the current
3798 * inode. Unlinking does not mean that the inode is deleted in
3799 * all cases. There may still be links to this inode in other
3800 * places.
3802 if (is_orphan) {
3803 ret = send_unlink(sctx, valid_path);
3804 if (ret < 0)
3805 goto out;
3810 * We did collect all parent dirs where cur_inode was once located. We
3811 * now go through all these dirs and check if they are pending for
3812 * deletion and if it's finally possible to perform the rmdir now.
3813 * We also update the inode stats of the parent dirs here.
3815 list_for_each_entry(cur, &check_dirs, list) {
3817 * In case we had refs into dirs that were not processed yet,
3818 * we don't need to do the utime and rmdir logic for these dirs.
3819 * The dir will be processed later.
3821 if (cur->dir > sctx->cur_ino)
3822 continue;
3824 ret = get_cur_inode_state(sctx, cur->dir, cur->dir_gen);
3825 if (ret < 0)
3826 goto out;
3828 if (ret == inode_state_did_create ||
3829 ret == inode_state_no_change) {
3830 /* TODO delayed utimes */
3831 ret = send_utimes(sctx, cur->dir, cur->dir_gen);
3832 if (ret < 0)
3833 goto out;
3834 } else if (ret == inode_state_did_delete &&
3835 cur->dir != last_dir_ino_rm) {
3836 ret = can_rmdir(sctx, cur->dir, cur->dir_gen,
3837 sctx->cur_ino);
3838 if (ret < 0)
3839 goto out;
3840 if (ret) {
3841 ret = get_cur_path(sctx, cur->dir,
3842 cur->dir_gen, valid_path);
3843 if (ret < 0)
3844 goto out;
3845 ret = send_rmdir(sctx, valid_path);
3846 if (ret < 0)
3847 goto out;
3848 last_dir_ino_rm = cur->dir;
3853 ret = 0;
3855 out:
3856 __free_recorded_refs(&check_dirs);
3857 free_recorded_refs(sctx);
3858 fs_path_free(valid_path);
3859 return ret;
3862 static int record_ref(struct btrfs_root *root, int num, u64 dir, int index,
3863 struct fs_path *name, void *ctx, struct list_head *refs)
3865 int ret = 0;
3866 struct send_ctx *sctx = ctx;
3867 struct fs_path *p;
3868 u64 gen;
3870 p = fs_path_alloc();
3871 if (!p)
3872 return -ENOMEM;
3874 ret = get_inode_info(root, dir, NULL, &gen, NULL, NULL,
3875 NULL, NULL);
3876 if (ret < 0)
3877 goto out;
3879 ret = get_cur_path(sctx, dir, gen, p);
3880 if (ret < 0)
3881 goto out;
3882 ret = fs_path_add_path(p, name);
3883 if (ret < 0)
3884 goto out;
3886 ret = __record_ref(refs, dir, gen, p);
3888 out:
3889 if (ret)
3890 fs_path_free(p);
3891 return ret;
3894 static int __record_new_ref(int num, u64 dir, int index,
3895 struct fs_path *name,
3896 void *ctx)
3898 struct send_ctx *sctx = ctx;
3899 return record_ref(sctx->send_root, num, dir, index, name,
3900 ctx, &sctx->new_refs);
3904 static int __record_deleted_ref(int num, u64 dir, int index,
3905 struct fs_path *name,
3906 void *ctx)
3908 struct send_ctx *sctx = ctx;
3909 return record_ref(sctx->parent_root, num, dir, index, name,
3910 ctx, &sctx->deleted_refs);
3913 static int record_new_ref(struct send_ctx *sctx)
3915 int ret;
3917 ret = iterate_inode_ref(sctx->send_root, sctx->left_path,
3918 sctx->cmp_key, 0, __record_new_ref, sctx);
3919 if (ret < 0)
3920 goto out;
3921 ret = 0;
3923 out:
3924 return ret;
3927 static int record_deleted_ref(struct send_ctx *sctx)
3929 int ret;
3931 ret = iterate_inode_ref(sctx->parent_root, sctx->right_path,
3932 sctx->cmp_key, 0, __record_deleted_ref, sctx);
3933 if (ret < 0)
3934 goto out;
3935 ret = 0;
3937 out:
3938 return ret;
3941 struct find_ref_ctx {
3942 u64 dir;
3943 u64 dir_gen;
3944 struct btrfs_root *root;
3945 struct fs_path *name;
3946 int found_idx;
3949 static int __find_iref(int num, u64 dir, int index,
3950 struct fs_path *name,
3951 void *ctx_)
3953 struct find_ref_ctx *ctx = ctx_;
3954 u64 dir_gen;
3955 int ret;
3957 if (dir == ctx->dir && fs_path_len(name) == fs_path_len(ctx->name) &&
3958 strncmp(name->start, ctx->name->start, fs_path_len(name)) == 0) {
3960 * To avoid doing extra lookups we'll only do this if everything
3961 * else matches.
3963 ret = get_inode_info(ctx->root, dir, NULL, &dir_gen, NULL,
3964 NULL, NULL, NULL);
3965 if (ret)
3966 return ret;
3967 if (dir_gen != ctx->dir_gen)
3968 return 0;
3969 ctx->found_idx = num;
3970 return 1;
3972 return 0;
3975 static int find_iref(struct btrfs_root *root,
3976 struct btrfs_path *path,
3977 struct btrfs_key *key,
3978 u64 dir, u64 dir_gen, struct fs_path *name)
3980 int ret;
3981 struct find_ref_ctx ctx;
3983 ctx.dir = dir;
3984 ctx.name = name;
3985 ctx.dir_gen = dir_gen;
3986 ctx.found_idx = -1;
3987 ctx.root = root;
3989 ret = iterate_inode_ref(root, path, key, 0, __find_iref, &ctx);
3990 if (ret < 0)
3991 return ret;
3993 if (ctx.found_idx == -1)
3994 return -ENOENT;
3996 return ctx.found_idx;
3999 static int __record_changed_new_ref(int num, u64 dir, int index,
4000 struct fs_path *name,
4001 void *ctx)
4003 u64 dir_gen;
4004 int ret;
4005 struct send_ctx *sctx = ctx;
4007 ret = get_inode_info(sctx->send_root, dir, NULL, &dir_gen, NULL,
4008 NULL, NULL, NULL);
4009 if (ret)
4010 return ret;
4012 ret = find_iref(sctx->parent_root, sctx->right_path,
4013 sctx->cmp_key, dir, dir_gen, name);
4014 if (ret == -ENOENT)
4015 ret = __record_new_ref(num, dir, index, name, sctx);
4016 else if (ret > 0)
4017 ret = 0;
4019 return ret;
4022 static int __record_changed_deleted_ref(int num, u64 dir, int index,
4023 struct fs_path *name,
4024 void *ctx)
4026 u64 dir_gen;
4027 int ret;
4028 struct send_ctx *sctx = ctx;
4030 ret = get_inode_info(sctx->parent_root, dir, NULL, &dir_gen, NULL,
4031 NULL, NULL, NULL);
4032 if (ret)
4033 return ret;
4035 ret = find_iref(sctx->send_root, sctx->left_path, sctx->cmp_key,
4036 dir, dir_gen, name);
4037 if (ret == -ENOENT)
4038 ret = __record_deleted_ref(num, dir, index, name, sctx);
4039 else if (ret > 0)
4040 ret = 0;
4042 return ret;
4045 static int record_changed_ref(struct send_ctx *sctx)
4047 int ret = 0;
4049 ret = iterate_inode_ref(sctx->send_root, sctx->left_path,
4050 sctx->cmp_key, 0, __record_changed_new_ref, sctx);
4051 if (ret < 0)
4052 goto out;
4053 ret = iterate_inode_ref(sctx->parent_root, sctx->right_path,
4054 sctx->cmp_key, 0, __record_changed_deleted_ref, sctx);
4055 if (ret < 0)
4056 goto out;
4057 ret = 0;
4059 out:
4060 return ret;
4064 * Record and process all refs at once. Needed when an inode changes the
4065 * generation number, which means that it was deleted and recreated.
4067 static int process_all_refs(struct send_ctx *sctx,
4068 enum btrfs_compare_tree_result cmd)
4070 int ret;
4071 struct btrfs_root *root;
4072 struct btrfs_path *path;
4073 struct btrfs_key key;
4074 struct btrfs_key found_key;
4075 struct extent_buffer *eb;
4076 int slot;
4077 iterate_inode_ref_t cb;
4078 int pending_move = 0;
4080 path = alloc_path_for_send();
4081 if (!path)
4082 return -ENOMEM;
4084 if (cmd == BTRFS_COMPARE_TREE_NEW) {
4085 root = sctx->send_root;
4086 cb = __record_new_ref;
4087 } else if (cmd == BTRFS_COMPARE_TREE_DELETED) {
4088 root = sctx->parent_root;
4089 cb = __record_deleted_ref;
4090 } else {
4091 btrfs_err(sctx->send_root->fs_info,
4092 "Wrong command %d in process_all_refs", cmd);
4093 ret = -EINVAL;
4094 goto out;
4097 key.objectid = sctx->cmp_key->objectid;
4098 key.type = BTRFS_INODE_REF_KEY;
4099 key.offset = 0;
4100 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
4101 if (ret < 0)
4102 goto out;
4104 while (1) {
4105 eb = path->nodes[0];
4106 slot = path->slots[0];
4107 if (slot >= btrfs_header_nritems(eb)) {
4108 ret = btrfs_next_leaf(root, path);
4109 if (ret < 0)
4110 goto out;
4111 else if (ret > 0)
4112 break;
4113 continue;
4116 btrfs_item_key_to_cpu(eb, &found_key, slot);
4118 if (found_key.objectid != key.objectid ||
4119 (found_key.type != BTRFS_INODE_REF_KEY &&
4120 found_key.type != BTRFS_INODE_EXTREF_KEY))
4121 break;
4123 ret = iterate_inode_ref(root, path, &found_key, 0, cb, sctx);
4124 if (ret < 0)
4125 goto out;
4127 path->slots[0]++;
4129 btrfs_release_path(path);
4131 ret = process_recorded_refs(sctx, &pending_move);
4132 /* Only applicable to an incremental send. */
4133 ASSERT(pending_move == 0);
4135 out:
4136 btrfs_free_path(path);
4137 return ret;
4140 static int send_set_xattr(struct send_ctx *sctx,
4141 struct fs_path *path,
4142 const char *name, int name_len,
4143 const char *data, int data_len)
4145 int ret = 0;
4147 ret = begin_cmd(sctx, BTRFS_SEND_C_SET_XATTR);
4148 if (ret < 0)
4149 goto out;
4151 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, path);
4152 TLV_PUT_STRING(sctx, BTRFS_SEND_A_XATTR_NAME, name, name_len);
4153 TLV_PUT(sctx, BTRFS_SEND_A_XATTR_DATA, data, data_len);
4155 ret = send_cmd(sctx);
4157 tlv_put_failure:
4158 out:
4159 return ret;
4162 static int send_remove_xattr(struct send_ctx *sctx,
4163 struct fs_path *path,
4164 const char *name, int name_len)
4166 int ret = 0;
4168 ret = begin_cmd(sctx, BTRFS_SEND_C_REMOVE_XATTR);
4169 if (ret < 0)
4170 goto out;
4172 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, path);
4173 TLV_PUT_STRING(sctx, BTRFS_SEND_A_XATTR_NAME, name, name_len);
4175 ret = send_cmd(sctx);
4177 tlv_put_failure:
4178 out:
4179 return ret;
4182 static int __process_new_xattr(int num, struct btrfs_key *di_key,
4183 const char *name, int name_len,
4184 const char *data, int data_len,
4185 u8 type, void *ctx)
4187 int ret;
4188 struct send_ctx *sctx = ctx;
4189 struct fs_path *p;
4190 posix_acl_xattr_header dummy_acl;
4192 p = fs_path_alloc();
4193 if (!p)
4194 return -ENOMEM;
4197 * This hack is needed because empty acl's are stored as zero byte
4198 * data in xattrs. Problem with that is, that receiving these zero byte
4199 * acl's will fail later. To fix this, we send a dummy acl list that
4200 * only contains the version number and no entries.
4202 if (!strncmp(name, XATTR_NAME_POSIX_ACL_ACCESS, name_len) ||
4203 !strncmp(name, XATTR_NAME_POSIX_ACL_DEFAULT, name_len)) {
4204 if (data_len == 0) {
4205 dummy_acl.a_version =
4206 cpu_to_le32(POSIX_ACL_XATTR_VERSION);
4207 data = (char *)&dummy_acl;
4208 data_len = sizeof(dummy_acl);
4212 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
4213 if (ret < 0)
4214 goto out;
4216 ret = send_set_xattr(sctx, p, name, name_len, data, data_len);
4218 out:
4219 fs_path_free(p);
4220 return ret;
4223 static int __process_deleted_xattr(int num, struct btrfs_key *di_key,
4224 const char *name, int name_len,
4225 const char *data, int data_len,
4226 u8 type, void *ctx)
4228 int ret;
4229 struct send_ctx *sctx = ctx;
4230 struct fs_path *p;
4232 p = fs_path_alloc();
4233 if (!p)
4234 return -ENOMEM;
4236 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
4237 if (ret < 0)
4238 goto out;
4240 ret = send_remove_xattr(sctx, p, name, name_len);
4242 out:
4243 fs_path_free(p);
4244 return ret;
4247 static int process_new_xattr(struct send_ctx *sctx)
4249 int ret = 0;
4251 ret = iterate_dir_item(sctx->send_root, sctx->left_path,
4252 sctx->cmp_key, __process_new_xattr, sctx);
4254 return ret;
4257 static int process_deleted_xattr(struct send_ctx *sctx)
4259 int ret;
4261 ret = iterate_dir_item(sctx->parent_root, sctx->right_path,
4262 sctx->cmp_key, __process_deleted_xattr, sctx);
4264 return ret;
4267 struct find_xattr_ctx {
4268 const char *name;
4269 int name_len;
4270 int found_idx;
4271 char *found_data;
4272 int found_data_len;
4275 static int __find_xattr(int num, struct btrfs_key *di_key,
4276 const char *name, int name_len,
4277 const char *data, int data_len,
4278 u8 type, void *vctx)
4280 struct find_xattr_ctx *ctx = vctx;
4282 if (name_len == ctx->name_len &&
4283 strncmp(name, ctx->name, name_len) == 0) {
4284 ctx->found_idx = num;
4285 ctx->found_data_len = data_len;
4286 ctx->found_data = kmemdup(data, data_len, GFP_NOFS);
4287 if (!ctx->found_data)
4288 return -ENOMEM;
4289 return 1;
4291 return 0;
4294 static int find_xattr(struct btrfs_root *root,
4295 struct btrfs_path *path,
4296 struct btrfs_key *key,
4297 const char *name, int name_len,
4298 char **data, int *data_len)
4300 int ret;
4301 struct find_xattr_ctx ctx;
4303 ctx.name = name;
4304 ctx.name_len = name_len;
4305 ctx.found_idx = -1;
4306 ctx.found_data = NULL;
4307 ctx.found_data_len = 0;
4309 ret = iterate_dir_item(root, path, key, __find_xattr, &ctx);
4310 if (ret < 0)
4311 return ret;
4313 if (ctx.found_idx == -1)
4314 return -ENOENT;
4315 if (data) {
4316 *data = ctx.found_data;
4317 *data_len = ctx.found_data_len;
4318 } else {
4319 kfree(ctx.found_data);
4321 return ctx.found_idx;
4325 static int __process_changed_new_xattr(int num, struct btrfs_key *di_key,
4326 const char *name, int name_len,
4327 const char *data, int data_len,
4328 u8 type, void *ctx)
4330 int ret;
4331 struct send_ctx *sctx = ctx;
4332 char *found_data = NULL;
4333 int found_data_len = 0;
4335 ret = find_xattr(sctx->parent_root, sctx->right_path,
4336 sctx->cmp_key, name, name_len, &found_data,
4337 &found_data_len);
4338 if (ret == -ENOENT) {
4339 ret = __process_new_xattr(num, di_key, name, name_len, data,
4340 data_len, type, ctx);
4341 } else if (ret >= 0) {
4342 if (data_len != found_data_len ||
4343 memcmp(data, found_data, data_len)) {
4344 ret = __process_new_xattr(num, di_key, name, name_len,
4345 data, data_len, type, ctx);
4346 } else {
4347 ret = 0;
4351 kfree(found_data);
4352 return ret;
4355 static int __process_changed_deleted_xattr(int num, struct btrfs_key *di_key,
4356 const char *name, int name_len,
4357 const char *data, int data_len,
4358 u8 type, void *ctx)
4360 int ret;
4361 struct send_ctx *sctx = ctx;
4363 ret = find_xattr(sctx->send_root, sctx->left_path, sctx->cmp_key,
4364 name, name_len, NULL, NULL);
4365 if (ret == -ENOENT)
4366 ret = __process_deleted_xattr(num, di_key, name, name_len, data,
4367 data_len, type, ctx);
4368 else if (ret >= 0)
4369 ret = 0;
4371 return ret;
4374 static int process_changed_xattr(struct send_ctx *sctx)
4376 int ret = 0;
4378 ret = iterate_dir_item(sctx->send_root, sctx->left_path,
4379 sctx->cmp_key, __process_changed_new_xattr, sctx);
4380 if (ret < 0)
4381 goto out;
4382 ret = iterate_dir_item(sctx->parent_root, sctx->right_path,
4383 sctx->cmp_key, __process_changed_deleted_xattr, sctx);
4385 out:
4386 return ret;
4389 static int process_all_new_xattrs(struct send_ctx *sctx)
4391 int ret;
4392 struct btrfs_root *root;
4393 struct btrfs_path *path;
4394 struct btrfs_key key;
4395 struct btrfs_key found_key;
4396 struct extent_buffer *eb;
4397 int slot;
4399 path = alloc_path_for_send();
4400 if (!path)
4401 return -ENOMEM;
4403 root = sctx->send_root;
4405 key.objectid = sctx->cmp_key->objectid;
4406 key.type = BTRFS_XATTR_ITEM_KEY;
4407 key.offset = 0;
4408 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
4409 if (ret < 0)
4410 goto out;
4412 while (1) {
4413 eb = path->nodes[0];
4414 slot = path->slots[0];
4415 if (slot >= btrfs_header_nritems(eb)) {
4416 ret = btrfs_next_leaf(root, path);
4417 if (ret < 0) {
4418 goto out;
4419 } else if (ret > 0) {
4420 ret = 0;
4421 break;
4423 continue;
4426 btrfs_item_key_to_cpu(eb, &found_key, slot);
4427 if (found_key.objectid != key.objectid ||
4428 found_key.type != key.type) {
4429 ret = 0;
4430 goto out;
4433 ret = iterate_dir_item(root, path, &found_key,
4434 __process_new_xattr, sctx);
4435 if (ret < 0)
4436 goto out;
4438 path->slots[0]++;
4441 out:
4442 btrfs_free_path(path);
4443 return ret;
4446 static ssize_t fill_read_buf(struct send_ctx *sctx, u64 offset, u32 len)
4448 struct btrfs_root *root = sctx->send_root;
4449 struct btrfs_fs_info *fs_info = root->fs_info;
4450 struct inode *inode;
4451 struct page *page;
4452 char *addr;
4453 struct btrfs_key key;
4454 pgoff_t index = offset >> PAGE_CACHE_SHIFT;
4455 pgoff_t last_index;
4456 unsigned pg_offset = offset & ~PAGE_CACHE_MASK;
4457 ssize_t ret = 0;
4459 key.objectid = sctx->cur_ino;
4460 key.type = BTRFS_INODE_ITEM_KEY;
4461 key.offset = 0;
4463 inode = btrfs_iget(fs_info->sb, &key, root, NULL);
4464 if (IS_ERR(inode))
4465 return PTR_ERR(inode);
4467 if (offset + len > i_size_read(inode)) {
4468 if (offset > i_size_read(inode))
4469 len = 0;
4470 else
4471 len = offset - i_size_read(inode);
4473 if (len == 0)
4474 goto out;
4476 last_index = (offset + len - 1) >> PAGE_CACHE_SHIFT;
4478 /* initial readahead */
4479 memset(&sctx->ra, 0, sizeof(struct file_ra_state));
4480 file_ra_state_init(&sctx->ra, inode->i_mapping);
4481 btrfs_force_ra(inode->i_mapping, &sctx->ra, NULL, index,
4482 last_index - index + 1);
4484 while (index <= last_index) {
4485 unsigned cur_len = min_t(unsigned, len,
4486 PAGE_CACHE_SIZE - pg_offset);
4487 page = find_or_create_page(inode->i_mapping, index, GFP_NOFS);
4488 if (!page) {
4489 ret = -ENOMEM;
4490 break;
4493 if (!PageUptodate(page)) {
4494 btrfs_readpage(NULL, page);
4495 lock_page(page);
4496 if (!PageUptodate(page)) {
4497 unlock_page(page);
4498 page_cache_release(page);
4499 ret = -EIO;
4500 break;
4504 addr = kmap(page);
4505 memcpy(sctx->read_buf + ret, addr + pg_offset, cur_len);
4506 kunmap(page);
4507 unlock_page(page);
4508 page_cache_release(page);
4509 index++;
4510 pg_offset = 0;
4511 len -= cur_len;
4512 ret += cur_len;
4514 out:
4515 iput(inode);
4516 return ret;
4520 * Read some bytes from the current inode/file and send a write command to
4521 * user space.
4523 static int send_write(struct send_ctx *sctx, u64 offset, u32 len)
4525 int ret = 0;
4526 struct fs_path *p;
4527 ssize_t num_read = 0;
4529 p = fs_path_alloc();
4530 if (!p)
4531 return -ENOMEM;
4533 verbose_printk("btrfs: send_write offset=%llu, len=%d\n", offset, len);
4535 num_read = fill_read_buf(sctx, offset, len);
4536 if (num_read <= 0) {
4537 if (num_read < 0)
4538 ret = num_read;
4539 goto out;
4542 ret = begin_cmd(sctx, BTRFS_SEND_C_WRITE);
4543 if (ret < 0)
4544 goto out;
4546 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
4547 if (ret < 0)
4548 goto out;
4550 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
4551 TLV_PUT_U64(sctx, BTRFS_SEND_A_FILE_OFFSET, offset);
4552 TLV_PUT(sctx, BTRFS_SEND_A_DATA, sctx->read_buf, num_read);
4554 ret = send_cmd(sctx);
4556 tlv_put_failure:
4557 out:
4558 fs_path_free(p);
4559 if (ret < 0)
4560 return ret;
4561 return num_read;
4565 * Send a clone command to user space.
4567 static int send_clone(struct send_ctx *sctx,
4568 u64 offset, u32 len,
4569 struct clone_root *clone_root)
4571 int ret = 0;
4572 struct fs_path *p;
4573 u64 gen;
4575 verbose_printk("btrfs: send_clone offset=%llu, len=%d, clone_root=%llu, "
4576 "clone_inode=%llu, clone_offset=%llu\n", offset, len,
4577 clone_root->root->objectid, clone_root->ino,
4578 clone_root->offset);
4580 p = fs_path_alloc();
4581 if (!p)
4582 return -ENOMEM;
4584 ret = begin_cmd(sctx, BTRFS_SEND_C_CLONE);
4585 if (ret < 0)
4586 goto out;
4588 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
4589 if (ret < 0)
4590 goto out;
4592 TLV_PUT_U64(sctx, BTRFS_SEND_A_FILE_OFFSET, offset);
4593 TLV_PUT_U64(sctx, BTRFS_SEND_A_CLONE_LEN, len);
4594 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
4596 if (clone_root->root == sctx->send_root) {
4597 ret = get_inode_info(sctx->send_root, clone_root->ino, NULL,
4598 &gen, NULL, NULL, NULL, NULL);
4599 if (ret < 0)
4600 goto out;
4601 ret = get_cur_path(sctx, clone_root->ino, gen, p);
4602 } else {
4603 ret = get_inode_path(clone_root->root, clone_root->ino, p);
4605 if (ret < 0)
4606 goto out;
4609 * If the parent we're using has a received_uuid set then use that as
4610 * our clone source as that is what we will look for when doing a
4611 * receive.
4613 * This covers the case that we create a snapshot off of a received
4614 * subvolume and then use that as the parent and try to receive on a
4615 * different host.
4617 if (!btrfs_is_empty_uuid(clone_root->root->root_item.received_uuid))
4618 TLV_PUT_UUID(sctx, BTRFS_SEND_A_CLONE_UUID,
4619 clone_root->root->root_item.received_uuid);
4620 else
4621 TLV_PUT_UUID(sctx, BTRFS_SEND_A_CLONE_UUID,
4622 clone_root->root->root_item.uuid);
4623 TLV_PUT_U64(sctx, BTRFS_SEND_A_CLONE_CTRANSID,
4624 le64_to_cpu(clone_root->root->root_item.ctransid));
4625 TLV_PUT_PATH(sctx, BTRFS_SEND_A_CLONE_PATH, p);
4626 TLV_PUT_U64(sctx, BTRFS_SEND_A_CLONE_OFFSET,
4627 clone_root->offset);
4629 ret = send_cmd(sctx);
4631 tlv_put_failure:
4632 out:
4633 fs_path_free(p);
4634 return ret;
4638 * Send an update extent command to user space.
4640 static int send_update_extent(struct send_ctx *sctx,
4641 u64 offset, u32 len)
4643 int ret = 0;
4644 struct fs_path *p;
4646 p = fs_path_alloc();
4647 if (!p)
4648 return -ENOMEM;
4650 ret = begin_cmd(sctx, BTRFS_SEND_C_UPDATE_EXTENT);
4651 if (ret < 0)
4652 goto out;
4654 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
4655 if (ret < 0)
4656 goto out;
4658 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
4659 TLV_PUT_U64(sctx, BTRFS_SEND_A_FILE_OFFSET, offset);
4660 TLV_PUT_U64(sctx, BTRFS_SEND_A_SIZE, len);
4662 ret = send_cmd(sctx);
4664 tlv_put_failure:
4665 out:
4666 fs_path_free(p);
4667 return ret;
4670 static int send_hole(struct send_ctx *sctx, u64 end)
4672 struct fs_path *p = NULL;
4673 u64 offset = sctx->cur_inode_last_extent;
4674 u64 len;
4675 int ret = 0;
4677 if (sctx->flags & BTRFS_SEND_FLAG_NO_FILE_DATA)
4678 return send_update_extent(sctx, offset, end - offset);
4680 p = fs_path_alloc();
4681 if (!p)
4682 return -ENOMEM;
4683 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
4684 if (ret < 0)
4685 goto tlv_put_failure;
4686 memset(sctx->read_buf, 0, BTRFS_SEND_READ_SIZE);
4687 while (offset < end) {
4688 len = min_t(u64, end - offset, BTRFS_SEND_READ_SIZE);
4690 ret = begin_cmd(sctx, BTRFS_SEND_C_WRITE);
4691 if (ret < 0)
4692 break;
4693 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
4694 TLV_PUT_U64(sctx, BTRFS_SEND_A_FILE_OFFSET, offset);
4695 TLV_PUT(sctx, BTRFS_SEND_A_DATA, sctx->read_buf, len);
4696 ret = send_cmd(sctx);
4697 if (ret < 0)
4698 break;
4699 offset += len;
4701 tlv_put_failure:
4702 fs_path_free(p);
4703 return ret;
4706 static int send_extent_data(struct send_ctx *sctx,
4707 const u64 offset,
4708 const u64 len)
4710 u64 sent = 0;
4712 if (sctx->flags & BTRFS_SEND_FLAG_NO_FILE_DATA)
4713 return send_update_extent(sctx, offset, len);
4715 while (sent < len) {
4716 u64 size = len - sent;
4717 int ret;
4719 if (size > BTRFS_SEND_READ_SIZE)
4720 size = BTRFS_SEND_READ_SIZE;
4721 ret = send_write(sctx, offset + sent, size);
4722 if (ret < 0)
4723 return ret;
4724 if (!ret)
4725 break;
4726 sent += ret;
4728 return 0;
4731 static int clone_range(struct send_ctx *sctx,
4732 struct clone_root *clone_root,
4733 const u64 disk_byte,
4734 u64 data_offset,
4735 u64 offset,
4736 u64 len)
4738 struct btrfs_path *path;
4739 struct btrfs_key key;
4740 int ret;
4742 path = alloc_path_for_send();
4743 if (!path)
4744 return -ENOMEM;
4747 * We can't send a clone operation for the entire range if we find
4748 * extent items in the respective range in the source file that
4749 * refer to different extents or if we find holes.
4750 * So check for that and do a mix of clone and regular write/copy
4751 * operations if needed.
4753 * Example:
4755 * mkfs.btrfs -f /dev/sda
4756 * mount /dev/sda /mnt
4757 * xfs_io -f -c "pwrite -S 0xaa 0K 100K" /mnt/foo
4758 * cp --reflink=always /mnt/foo /mnt/bar
4759 * xfs_io -c "pwrite -S 0xbb 50K 50K" /mnt/foo
4760 * btrfs subvolume snapshot -r /mnt /mnt/snap
4762 * If when we send the snapshot and we are processing file bar (which
4763 * has a higher inode number than foo) we blindly send a clone operation
4764 * for the [0, 100K[ range from foo to bar, the receiver ends up getting
4765 * a file bar that matches the content of file foo - iow, doesn't match
4766 * the content from bar in the original filesystem.
4768 key.objectid = clone_root->ino;
4769 key.type = BTRFS_EXTENT_DATA_KEY;
4770 key.offset = clone_root->offset;
4771 ret = btrfs_search_slot(NULL, clone_root->root, &key, path, 0, 0);
4772 if (ret < 0)
4773 goto out;
4774 if (ret > 0 && path->slots[0] > 0) {
4775 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0] - 1);
4776 if (key.objectid == clone_root->ino &&
4777 key.type == BTRFS_EXTENT_DATA_KEY)
4778 path->slots[0]--;
4781 while (true) {
4782 struct extent_buffer *leaf = path->nodes[0];
4783 int slot = path->slots[0];
4784 struct btrfs_file_extent_item *ei;
4785 u8 type;
4786 u64 ext_len;
4787 u64 clone_len;
4789 if (slot >= btrfs_header_nritems(leaf)) {
4790 ret = btrfs_next_leaf(clone_root->root, path);
4791 if (ret < 0)
4792 goto out;
4793 else if (ret > 0)
4794 break;
4795 continue;
4798 btrfs_item_key_to_cpu(leaf, &key, slot);
4801 * We might have an implicit trailing hole (NO_HOLES feature
4802 * enabled). We deal with it after leaving this loop.
4804 if (key.objectid != clone_root->ino ||
4805 key.type != BTRFS_EXTENT_DATA_KEY)
4806 break;
4808 ei = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
4809 type = btrfs_file_extent_type(leaf, ei);
4810 if (type == BTRFS_FILE_EXTENT_INLINE) {
4811 ext_len = btrfs_file_extent_inline_len(leaf, slot, ei);
4812 ext_len = PAGE_CACHE_ALIGN(ext_len);
4813 } else {
4814 ext_len = btrfs_file_extent_num_bytes(leaf, ei);
4817 if (key.offset + ext_len <= clone_root->offset)
4818 goto next;
4820 if (key.offset > clone_root->offset) {
4821 /* Implicit hole, NO_HOLES feature enabled. */
4822 u64 hole_len = key.offset - clone_root->offset;
4824 if (hole_len > len)
4825 hole_len = len;
4826 ret = send_extent_data(sctx, offset, hole_len);
4827 if (ret < 0)
4828 goto out;
4830 len -= hole_len;
4831 if (len == 0)
4832 break;
4833 offset += hole_len;
4834 clone_root->offset += hole_len;
4835 data_offset += hole_len;
4838 if (key.offset >= clone_root->offset + len)
4839 break;
4841 clone_len = min_t(u64, ext_len, len);
4843 if (btrfs_file_extent_disk_bytenr(leaf, ei) == disk_byte &&
4844 btrfs_file_extent_offset(leaf, ei) == data_offset)
4845 ret = send_clone(sctx, offset, clone_len, clone_root);
4846 else
4847 ret = send_extent_data(sctx, offset, clone_len);
4849 if (ret < 0)
4850 goto out;
4852 len -= clone_len;
4853 if (len == 0)
4854 break;
4855 offset += clone_len;
4856 clone_root->offset += clone_len;
4857 data_offset += clone_len;
4858 next:
4859 path->slots[0]++;
4862 if (len > 0)
4863 ret = send_extent_data(sctx, offset, len);
4864 else
4865 ret = 0;
4866 out:
4867 btrfs_free_path(path);
4868 return ret;
4871 static int send_write_or_clone(struct send_ctx *sctx,
4872 struct btrfs_path *path,
4873 struct btrfs_key *key,
4874 struct clone_root *clone_root)
4876 int ret = 0;
4877 struct btrfs_file_extent_item *ei;
4878 u64 offset = key->offset;
4879 u64 len;
4880 u8 type;
4881 u64 bs = sctx->send_root->fs_info->sb->s_blocksize;
4883 ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
4884 struct btrfs_file_extent_item);
4885 type = btrfs_file_extent_type(path->nodes[0], ei);
4886 if (type == BTRFS_FILE_EXTENT_INLINE) {
4887 len = btrfs_file_extent_inline_len(path->nodes[0],
4888 path->slots[0], ei);
4890 * it is possible the inline item won't cover the whole page,
4891 * but there may be items after this page. Make
4892 * sure to send the whole thing
4894 len = PAGE_CACHE_ALIGN(len);
4895 } else {
4896 len = btrfs_file_extent_num_bytes(path->nodes[0], ei);
4899 if (offset + len > sctx->cur_inode_size)
4900 len = sctx->cur_inode_size - offset;
4901 if (len == 0) {
4902 ret = 0;
4903 goto out;
4906 if (clone_root && IS_ALIGNED(offset + len, bs)) {
4907 u64 disk_byte;
4908 u64 data_offset;
4910 disk_byte = btrfs_file_extent_disk_bytenr(path->nodes[0], ei);
4911 data_offset = btrfs_file_extent_offset(path->nodes[0], ei);
4912 ret = clone_range(sctx, clone_root, disk_byte, data_offset,
4913 offset, len);
4914 } else {
4915 ret = send_extent_data(sctx, offset, len);
4917 out:
4918 return ret;
4921 static int is_extent_unchanged(struct send_ctx *sctx,
4922 struct btrfs_path *left_path,
4923 struct btrfs_key *ekey)
4925 int ret = 0;
4926 struct btrfs_key key;
4927 struct btrfs_path *path = NULL;
4928 struct extent_buffer *eb;
4929 int slot;
4930 struct btrfs_key found_key;
4931 struct btrfs_file_extent_item *ei;
4932 u64 left_disknr;
4933 u64 right_disknr;
4934 u64 left_offset;
4935 u64 right_offset;
4936 u64 left_offset_fixed;
4937 u64 left_len;
4938 u64 right_len;
4939 u64 left_gen;
4940 u64 right_gen;
4941 u8 left_type;
4942 u8 right_type;
4944 path = alloc_path_for_send();
4945 if (!path)
4946 return -ENOMEM;
4948 eb = left_path->nodes[0];
4949 slot = left_path->slots[0];
4950 ei = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
4951 left_type = btrfs_file_extent_type(eb, ei);
4953 if (left_type != BTRFS_FILE_EXTENT_REG) {
4954 ret = 0;
4955 goto out;
4957 left_disknr = btrfs_file_extent_disk_bytenr(eb, ei);
4958 left_len = btrfs_file_extent_num_bytes(eb, ei);
4959 left_offset = btrfs_file_extent_offset(eb, ei);
4960 left_gen = btrfs_file_extent_generation(eb, ei);
4963 * Following comments will refer to these graphics. L is the left
4964 * extents which we are checking at the moment. 1-8 are the right
4965 * extents that we iterate.
4967 * |-----L-----|
4968 * |-1-|-2a-|-3-|-4-|-5-|-6-|
4970 * |-----L-----|
4971 * |--1--|-2b-|...(same as above)
4973 * Alternative situation. Happens on files where extents got split.
4974 * |-----L-----|
4975 * |-----------7-----------|-6-|
4977 * Alternative situation. Happens on files which got larger.
4978 * |-----L-----|
4979 * |-8-|
4980 * Nothing follows after 8.
4983 key.objectid = ekey->objectid;
4984 key.type = BTRFS_EXTENT_DATA_KEY;
4985 key.offset = ekey->offset;
4986 ret = btrfs_search_slot_for_read(sctx->parent_root, &key, path, 0, 0);
4987 if (ret < 0)
4988 goto out;
4989 if (ret) {
4990 ret = 0;
4991 goto out;
4995 * Handle special case where the right side has no extents at all.
4997 eb = path->nodes[0];
4998 slot = path->slots[0];
4999 btrfs_item_key_to_cpu(eb, &found_key, slot);
5000 if (found_key.objectid != key.objectid ||
5001 found_key.type != key.type) {
5002 /* If we're a hole then just pretend nothing changed */
5003 ret = (left_disknr) ? 0 : 1;
5004 goto out;
5008 * We're now on 2a, 2b or 7.
5010 key = found_key;
5011 while (key.offset < ekey->offset + left_len) {
5012 ei = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
5013 right_type = btrfs_file_extent_type(eb, ei);
5014 if (right_type != BTRFS_FILE_EXTENT_REG &&
5015 right_type != BTRFS_FILE_EXTENT_INLINE) {
5016 ret = 0;
5017 goto out;
5020 right_disknr = btrfs_file_extent_disk_bytenr(eb, ei);
5021 if (right_type == BTRFS_FILE_EXTENT_INLINE) {
5022 right_len = btrfs_file_extent_inline_len(eb, slot, ei);
5023 right_len = PAGE_ALIGN(right_len);
5024 } else {
5025 right_len = btrfs_file_extent_num_bytes(eb, ei);
5027 right_offset = btrfs_file_extent_offset(eb, ei);
5028 right_gen = btrfs_file_extent_generation(eb, ei);
5031 * Are we at extent 8? If yes, we know the extent is changed.
5032 * This may only happen on the first iteration.
5034 if (found_key.offset + right_len <= ekey->offset) {
5035 /* If we're a hole just pretend nothing changed */
5036 ret = (left_disknr) ? 0 : 1;
5037 goto out;
5041 * We just wanted to see if when we have an inline extent, what
5042 * follows it is a regular extent (wanted to check the above
5043 * condition for inline extents too). This should normally not
5044 * happen but it's possible for example when we have an inline
5045 * compressed extent representing data with a size matching
5046 * the page size (currently the same as sector size).
5048 if (right_type == BTRFS_FILE_EXTENT_INLINE) {
5049 ret = 0;
5050 goto out;
5053 left_offset_fixed = left_offset;
5054 if (key.offset < ekey->offset) {
5055 /* Fix the right offset for 2a and 7. */
5056 right_offset += ekey->offset - key.offset;
5057 } else {
5058 /* Fix the left offset for all behind 2a and 2b */
5059 left_offset_fixed += key.offset - ekey->offset;
5063 * Check if we have the same extent.
5065 if (left_disknr != right_disknr ||
5066 left_offset_fixed != right_offset ||
5067 left_gen != right_gen) {
5068 ret = 0;
5069 goto out;
5073 * Go to the next extent.
5075 ret = btrfs_next_item(sctx->parent_root, path);
5076 if (ret < 0)
5077 goto out;
5078 if (!ret) {
5079 eb = path->nodes[0];
5080 slot = path->slots[0];
5081 btrfs_item_key_to_cpu(eb, &found_key, slot);
5083 if (ret || found_key.objectid != key.objectid ||
5084 found_key.type != key.type) {
5085 key.offset += right_len;
5086 break;
5088 if (found_key.offset != key.offset + right_len) {
5089 ret = 0;
5090 goto out;
5092 key = found_key;
5096 * We're now behind the left extent (treat as unchanged) or at the end
5097 * of the right side (treat as changed).
5099 if (key.offset >= ekey->offset + left_len)
5100 ret = 1;
5101 else
5102 ret = 0;
5105 out:
5106 btrfs_free_path(path);
5107 return ret;
5110 static int get_last_extent(struct send_ctx *sctx, u64 offset)
5112 struct btrfs_path *path;
5113 struct btrfs_root *root = sctx->send_root;
5114 struct btrfs_file_extent_item *fi;
5115 struct btrfs_key key;
5116 u64 extent_end;
5117 u8 type;
5118 int ret;
5120 path = alloc_path_for_send();
5121 if (!path)
5122 return -ENOMEM;
5124 sctx->cur_inode_last_extent = 0;
5126 key.objectid = sctx->cur_ino;
5127 key.type = BTRFS_EXTENT_DATA_KEY;
5128 key.offset = offset;
5129 ret = btrfs_search_slot_for_read(root, &key, path, 0, 1);
5130 if (ret < 0)
5131 goto out;
5132 ret = 0;
5133 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
5134 if (key.objectid != sctx->cur_ino || key.type != BTRFS_EXTENT_DATA_KEY)
5135 goto out;
5137 fi = btrfs_item_ptr(path->nodes[0], path->slots[0],
5138 struct btrfs_file_extent_item);
5139 type = btrfs_file_extent_type(path->nodes[0], fi);
5140 if (type == BTRFS_FILE_EXTENT_INLINE) {
5141 u64 size = btrfs_file_extent_inline_len(path->nodes[0],
5142 path->slots[0], fi);
5143 extent_end = ALIGN(key.offset + size,
5144 sctx->send_root->sectorsize);
5145 } else {
5146 extent_end = key.offset +
5147 btrfs_file_extent_num_bytes(path->nodes[0], fi);
5149 sctx->cur_inode_last_extent = extent_end;
5150 out:
5151 btrfs_free_path(path);
5152 return ret;
5155 static int maybe_send_hole(struct send_ctx *sctx, struct btrfs_path *path,
5156 struct btrfs_key *key)
5158 struct btrfs_file_extent_item *fi;
5159 u64 extent_end;
5160 u8 type;
5161 int ret = 0;
5163 if (sctx->cur_ino != key->objectid || !need_send_hole(sctx))
5164 return 0;
5166 if (sctx->cur_inode_last_extent == (u64)-1) {
5167 ret = get_last_extent(sctx, key->offset - 1);
5168 if (ret)
5169 return ret;
5172 fi = btrfs_item_ptr(path->nodes[0], path->slots[0],
5173 struct btrfs_file_extent_item);
5174 type = btrfs_file_extent_type(path->nodes[0], fi);
5175 if (type == BTRFS_FILE_EXTENT_INLINE) {
5176 u64 size = btrfs_file_extent_inline_len(path->nodes[0],
5177 path->slots[0], fi);
5178 extent_end = ALIGN(key->offset + size,
5179 sctx->send_root->sectorsize);
5180 } else {
5181 extent_end = key->offset +
5182 btrfs_file_extent_num_bytes(path->nodes[0], fi);
5185 if (path->slots[0] == 0 &&
5186 sctx->cur_inode_last_extent < key->offset) {
5188 * We might have skipped entire leafs that contained only
5189 * file extent items for our current inode. These leafs have
5190 * a generation number smaller (older) than the one in the
5191 * current leaf and the leaf our last extent came from, and
5192 * are located between these 2 leafs.
5194 ret = get_last_extent(sctx, key->offset - 1);
5195 if (ret)
5196 return ret;
5199 if (sctx->cur_inode_last_extent < key->offset)
5200 ret = send_hole(sctx, key->offset);
5201 sctx->cur_inode_last_extent = extent_end;
5202 return ret;
5205 static int process_extent(struct send_ctx *sctx,
5206 struct btrfs_path *path,
5207 struct btrfs_key *key)
5209 struct clone_root *found_clone = NULL;
5210 int ret = 0;
5212 if (S_ISLNK(sctx->cur_inode_mode))
5213 return 0;
5215 if (sctx->parent_root && !sctx->cur_inode_new) {
5216 ret = is_extent_unchanged(sctx, path, key);
5217 if (ret < 0)
5218 goto out;
5219 if (ret) {
5220 ret = 0;
5221 goto out_hole;
5223 } else {
5224 struct btrfs_file_extent_item *ei;
5225 u8 type;
5227 ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
5228 struct btrfs_file_extent_item);
5229 type = btrfs_file_extent_type(path->nodes[0], ei);
5230 if (type == BTRFS_FILE_EXTENT_PREALLOC ||
5231 type == BTRFS_FILE_EXTENT_REG) {
5233 * The send spec does not have a prealloc command yet,
5234 * so just leave a hole for prealloc'ed extents until
5235 * we have enough commands queued up to justify rev'ing
5236 * the send spec.
5238 if (type == BTRFS_FILE_EXTENT_PREALLOC) {
5239 ret = 0;
5240 goto out;
5243 /* Have a hole, just skip it. */
5244 if (btrfs_file_extent_disk_bytenr(path->nodes[0], ei) == 0) {
5245 ret = 0;
5246 goto out;
5251 ret = find_extent_clone(sctx, path, key->objectid, key->offset,
5252 sctx->cur_inode_size, &found_clone);
5253 if (ret != -ENOENT && ret < 0)
5254 goto out;
5256 ret = send_write_or_clone(sctx, path, key, found_clone);
5257 if (ret)
5258 goto out;
5259 out_hole:
5260 ret = maybe_send_hole(sctx, path, key);
5261 out:
5262 return ret;
5265 static int process_all_extents(struct send_ctx *sctx)
5267 int ret;
5268 struct btrfs_root *root;
5269 struct btrfs_path *path;
5270 struct btrfs_key key;
5271 struct btrfs_key found_key;
5272 struct extent_buffer *eb;
5273 int slot;
5275 root = sctx->send_root;
5276 path = alloc_path_for_send();
5277 if (!path)
5278 return -ENOMEM;
5280 key.objectid = sctx->cmp_key->objectid;
5281 key.type = BTRFS_EXTENT_DATA_KEY;
5282 key.offset = 0;
5283 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5284 if (ret < 0)
5285 goto out;
5287 while (1) {
5288 eb = path->nodes[0];
5289 slot = path->slots[0];
5291 if (slot >= btrfs_header_nritems(eb)) {
5292 ret = btrfs_next_leaf(root, path);
5293 if (ret < 0) {
5294 goto out;
5295 } else if (ret > 0) {
5296 ret = 0;
5297 break;
5299 continue;
5302 btrfs_item_key_to_cpu(eb, &found_key, slot);
5304 if (found_key.objectid != key.objectid ||
5305 found_key.type != key.type) {
5306 ret = 0;
5307 goto out;
5310 ret = process_extent(sctx, path, &found_key);
5311 if (ret < 0)
5312 goto out;
5314 path->slots[0]++;
5317 out:
5318 btrfs_free_path(path);
5319 return ret;
5322 static int process_recorded_refs_if_needed(struct send_ctx *sctx, int at_end,
5323 int *pending_move,
5324 int *refs_processed)
5326 int ret = 0;
5328 if (sctx->cur_ino == 0)
5329 goto out;
5330 if (!at_end && sctx->cur_ino == sctx->cmp_key->objectid &&
5331 sctx->cmp_key->type <= BTRFS_INODE_EXTREF_KEY)
5332 goto out;
5333 if (list_empty(&sctx->new_refs) && list_empty(&sctx->deleted_refs))
5334 goto out;
5336 ret = process_recorded_refs(sctx, pending_move);
5337 if (ret < 0)
5338 goto out;
5340 *refs_processed = 1;
5341 out:
5342 return ret;
5345 static int finish_inode_if_needed(struct send_ctx *sctx, int at_end)
5347 int ret = 0;
5348 u64 left_mode;
5349 u64 left_uid;
5350 u64 left_gid;
5351 u64 right_mode;
5352 u64 right_uid;
5353 u64 right_gid;
5354 int need_chmod = 0;
5355 int need_chown = 0;
5356 int pending_move = 0;
5357 int refs_processed = 0;
5359 ret = process_recorded_refs_if_needed(sctx, at_end, &pending_move,
5360 &refs_processed);
5361 if (ret < 0)
5362 goto out;
5365 * We have processed the refs and thus need to advance send_progress.
5366 * Now, calls to get_cur_xxx will take the updated refs of the current
5367 * inode into account.
5369 * On the other hand, if our current inode is a directory and couldn't
5370 * be moved/renamed because its parent was renamed/moved too and it has
5371 * a higher inode number, we can only move/rename our current inode
5372 * after we moved/renamed its parent. Therefore in this case operate on
5373 * the old path (pre move/rename) of our current inode, and the
5374 * move/rename will be performed later.
5376 if (refs_processed && !pending_move)
5377 sctx->send_progress = sctx->cur_ino + 1;
5379 if (sctx->cur_ino == 0 || sctx->cur_inode_deleted)
5380 goto out;
5381 if (!at_end && sctx->cmp_key->objectid == sctx->cur_ino)
5382 goto out;
5384 ret = get_inode_info(sctx->send_root, sctx->cur_ino, NULL, NULL,
5385 &left_mode, &left_uid, &left_gid, NULL);
5386 if (ret < 0)
5387 goto out;
5389 if (!sctx->parent_root || sctx->cur_inode_new) {
5390 need_chown = 1;
5391 if (!S_ISLNK(sctx->cur_inode_mode))
5392 need_chmod = 1;
5393 } else {
5394 ret = get_inode_info(sctx->parent_root, sctx->cur_ino,
5395 NULL, NULL, &right_mode, &right_uid,
5396 &right_gid, NULL);
5397 if (ret < 0)
5398 goto out;
5400 if (left_uid != right_uid || left_gid != right_gid)
5401 need_chown = 1;
5402 if (!S_ISLNK(sctx->cur_inode_mode) && left_mode != right_mode)
5403 need_chmod = 1;
5406 if (S_ISREG(sctx->cur_inode_mode)) {
5407 if (need_send_hole(sctx)) {
5408 if (sctx->cur_inode_last_extent == (u64)-1 ||
5409 sctx->cur_inode_last_extent <
5410 sctx->cur_inode_size) {
5411 ret = get_last_extent(sctx, (u64)-1);
5412 if (ret)
5413 goto out;
5415 if (sctx->cur_inode_last_extent <
5416 sctx->cur_inode_size) {
5417 ret = send_hole(sctx, sctx->cur_inode_size);
5418 if (ret)
5419 goto out;
5422 ret = send_truncate(sctx, sctx->cur_ino, sctx->cur_inode_gen,
5423 sctx->cur_inode_size);
5424 if (ret < 0)
5425 goto out;
5428 if (need_chown) {
5429 ret = send_chown(sctx, sctx->cur_ino, sctx->cur_inode_gen,
5430 left_uid, left_gid);
5431 if (ret < 0)
5432 goto out;
5434 if (need_chmod) {
5435 ret = send_chmod(sctx, sctx->cur_ino, sctx->cur_inode_gen,
5436 left_mode);
5437 if (ret < 0)
5438 goto out;
5442 * If other directory inodes depended on our current directory
5443 * inode's move/rename, now do their move/rename operations.
5445 if (!is_waiting_for_move(sctx, sctx->cur_ino)) {
5446 ret = apply_children_dir_moves(sctx);
5447 if (ret)
5448 goto out;
5450 * Need to send that every time, no matter if it actually
5451 * changed between the two trees as we have done changes to
5452 * the inode before. If our inode is a directory and it's
5453 * waiting to be moved/renamed, we will send its utimes when
5454 * it's moved/renamed, therefore we don't need to do it here.
5456 sctx->send_progress = sctx->cur_ino + 1;
5457 ret = send_utimes(sctx, sctx->cur_ino, sctx->cur_inode_gen);
5458 if (ret < 0)
5459 goto out;
5462 out:
5463 return ret;
5466 static int changed_inode(struct send_ctx *sctx,
5467 enum btrfs_compare_tree_result result)
5469 int ret = 0;
5470 struct btrfs_key *key = sctx->cmp_key;
5471 struct btrfs_inode_item *left_ii = NULL;
5472 struct btrfs_inode_item *right_ii = NULL;
5473 u64 left_gen = 0;
5474 u64 right_gen = 0;
5476 sctx->cur_ino = key->objectid;
5477 sctx->cur_inode_new_gen = 0;
5478 sctx->cur_inode_last_extent = (u64)-1;
5481 * Set send_progress to current inode. This will tell all get_cur_xxx
5482 * functions that the current inode's refs are not updated yet. Later,
5483 * when process_recorded_refs is finished, it is set to cur_ino + 1.
5485 sctx->send_progress = sctx->cur_ino;
5487 if (result == BTRFS_COMPARE_TREE_NEW ||
5488 result == BTRFS_COMPARE_TREE_CHANGED) {
5489 left_ii = btrfs_item_ptr(sctx->left_path->nodes[0],
5490 sctx->left_path->slots[0],
5491 struct btrfs_inode_item);
5492 left_gen = btrfs_inode_generation(sctx->left_path->nodes[0],
5493 left_ii);
5494 } else {
5495 right_ii = btrfs_item_ptr(sctx->right_path->nodes[0],
5496 sctx->right_path->slots[0],
5497 struct btrfs_inode_item);
5498 right_gen = btrfs_inode_generation(sctx->right_path->nodes[0],
5499 right_ii);
5501 if (result == BTRFS_COMPARE_TREE_CHANGED) {
5502 right_ii = btrfs_item_ptr(sctx->right_path->nodes[0],
5503 sctx->right_path->slots[0],
5504 struct btrfs_inode_item);
5506 right_gen = btrfs_inode_generation(sctx->right_path->nodes[0],
5507 right_ii);
5510 * The cur_ino = root dir case is special here. We can't treat
5511 * the inode as deleted+reused because it would generate a
5512 * stream that tries to delete/mkdir the root dir.
5514 if (left_gen != right_gen &&
5515 sctx->cur_ino != BTRFS_FIRST_FREE_OBJECTID)
5516 sctx->cur_inode_new_gen = 1;
5519 if (result == BTRFS_COMPARE_TREE_NEW) {
5520 sctx->cur_inode_gen = left_gen;
5521 sctx->cur_inode_new = 1;
5522 sctx->cur_inode_deleted = 0;
5523 sctx->cur_inode_size = btrfs_inode_size(
5524 sctx->left_path->nodes[0], left_ii);
5525 sctx->cur_inode_mode = btrfs_inode_mode(
5526 sctx->left_path->nodes[0], left_ii);
5527 sctx->cur_inode_rdev = btrfs_inode_rdev(
5528 sctx->left_path->nodes[0], left_ii);
5529 if (sctx->cur_ino != BTRFS_FIRST_FREE_OBJECTID)
5530 ret = send_create_inode_if_needed(sctx);
5531 } else if (result == BTRFS_COMPARE_TREE_DELETED) {
5532 sctx->cur_inode_gen = right_gen;
5533 sctx->cur_inode_new = 0;
5534 sctx->cur_inode_deleted = 1;
5535 sctx->cur_inode_size = btrfs_inode_size(
5536 sctx->right_path->nodes[0], right_ii);
5537 sctx->cur_inode_mode = btrfs_inode_mode(
5538 sctx->right_path->nodes[0], right_ii);
5539 } else if (result == BTRFS_COMPARE_TREE_CHANGED) {
5541 * We need to do some special handling in case the inode was
5542 * reported as changed with a changed generation number. This
5543 * means that the original inode was deleted and new inode
5544 * reused the same inum. So we have to treat the old inode as
5545 * deleted and the new one as new.
5547 if (sctx->cur_inode_new_gen) {
5549 * First, process the inode as if it was deleted.
5551 sctx->cur_inode_gen = right_gen;
5552 sctx->cur_inode_new = 0;
5553 sctx->cur_inode_deleted = 1;
5554 sctx->cur_inode_size = btrfs_inode_size(
5555 sctx->right_path->nodes[0], right_ii);
5556 sctx->cur_inode_mode = btrfs_inode_mode(
5557 sctx->right_path->nodes[0], right_ii);
5558 ret = process_all_refs(sctx,
5559 BTRFS_COMPARE_TREE_DELETED);
5560 if (ret < 0)
5561 goto out;
5564 * Now process the inode as if it was new.
5566 sctx->cur_inode_gen = left_gen;
5567 sctx->cur_inode_new = 1;
5568 sctx->cur_inode_deleted = 0;
5569 sctx->cur_inode_size = btrfs_inode_size(
5570 sctx->left_path->nodes[0], left_ii);
5571 sctx->cur_inode_mode = btrfs_inode_mode(
5572 sctx->left_path->nodes[0], left_ii);
5573 sctx->cur_inode_rdev = btrfs_inode_rdev(
5574 sctx->left_path->nodes[0], left_ii);
5575 ret = send_create_inode_if_needed(sctx);
5576 if (ret < 0)
5577 goto out;
5579 ret = process_all_refs(sctx, BTRFS_COMPARE_TREE_NEW);
5580 if (ret < 0)
5581 goto out;
5583 * Advance send_progress now as we did not get into
5584 * process_recorded_refs_if_needed in the new_gen case.
5586 sctx->send_progress = sctx->cur_ino + 1;
5589 * Now process all extents and xattrs of the inode as if
5590 * they were all new.
5592 ret = process_all_extents(sctx);
5593 if (ret < 0)
5594 goto out;
5595 ret = process_all_new_xattrs(sctx);
5596 if (ret < 0)
5597 goto out;
5598 } else {
5599 sctx->cur_inode_gen = left_gen;
5600 sctx->cur_inode_new = 0;
5601 sctx->cur_inode_new_gen = 0;
5602 sctx->cur_inode_deleted = 0;
5603 sctx->cur_inode_size = btrfs_inode_size(
5604 sctx->left_path->nodes[0], left_ii);
5605 sctx->cur_inode_mode = btrfs_inode_mode(
5606 sctx->left_path->nodes[0], left_ii);
5610 out:
5611 return ret;
5615 * We have to process new refs before deleted refs, but compare_trees gives us
5616 * the new and deleted refs mixed. To fix this, we record the new/deleted refs
5617 * first and later process them in process_recorded_refs.
5618 * For the cur_inode_new_gen case, we skip recording completely because
5619 * changed_inode did already initiate processing of refs. The reason for this is
5620 * that in this case, compare_tree actually compares the refs of 2 different
5621 * inodes. To fix this, process_all_refs is used in changed_inode to handle all
5622 * refs of the right tree as deleted and all refs of the left tree as new.
5624 static int changed_ref(struct send_ctx *sctx,
5625 enum btrfs_compare_tree_result result)
5627 int ret = 0;
5629 BUG_ON(sctx->cur_ino != sctx->cmp_key->objectid);
5631 if (!sctx->cur_inode_new_gen &&
5632 sctx->cur_ino != BTRFS_FIRST_FREE_OBJECTID) {
5633 if (result == BTRFS_COMPARE_TREE_NEW)
5634 ret = record_new_ref(sctx);
5635 else if (result == BTRFS_COMPARE_TREE_DELETED)
5636 ret = record_deleted_ref(sctx);
5637 else if (result == BTRFS_COMPARE_TREE_CHANGED)
5638 ret = record_changed_ref(sctx);
5641 return ret;
5645 * Process new/deleted/changed xattrs. We skip processing in the
5646 * cur_inode_new_gen case because changed_inode did already initiate processing
5647 * of xattrs. The reason is the same as in changed_ref
5649 static int changed_xattr(struct send_ctx *sctx,
5650 enum btrfs_compare_tree_result result)
5652 int ret = 0;
5654 BUG_ON(sctx->cur_ino != sctx->cmp_key->objectid);
5656 if (!sctx->cur_inode_new_gen && !sctx->cur_inode_deleted) {
5657 if (result == BTRFS_COMPARE_TREE_NEW)
5658 ret = process_new_xattr(sctx);
5659 else if (result == BTRFS_COMPARE_TREE_DELETED)
5660 ret = process_deleted_xattr(sctx);
5661 else if (result == BTRFS_COMPARE_TREE_CHANGED)
5662 ret = process_changed_xattr(sctx);
5665 return ret;
5669 * Process new/deleted/changed extents. We skip processing in the
5670 * cur_inode_new_gen case because changed_inode did already initiate processing
5671 * of extents. The reason is the same as in changed_ref
5673 static int changed_extent(struct send_ctx *sctx,
5674 enum btrfs_compare_tree_result result)
5676 int ret = 0;
5678 BUG_ON(sctx->cur_ino != sctx->cmp_key->objectid);
5680 if (!sctx->cur_inode_new_gen && !sctx->cur_inode_deleted) {
5681 if (result != BTRFS_COMPARE_TREE_DELETED)
5682 ret = process_extent(sctx, sctx->left_path,
5683 sctx->cmp_key);
5686 return ret;
5689 static int dir_changed(struct send_ctx *sctx, u64 dir)
5691 u64 orig_gen, new_gen;
5692 int ret;
5694 ret = get_inode_info(sctx->send_root, dir, NULL, &new_gen, NULL, NULL,
5695 NULL, NULL);
5696 if (ret)
5697 return ret;
5699 ret = get_inode_info(sctx->parent_root, dir, NULL, &orig_gen, NULL,
5700 NULL, NULL, NULL);
5701 if (ret)
5702 return ret;
5704 return (orig_gen != new_gen) ? 1 : 0;
5707 static int compare_refs(struct send_ctx *sctx, struct btrfs_path *path,
5708 struct btrfs_key *key)
5710 struct btrfs_inode_extref *extref;
5711 struct extent_buffer *leaf;
5712 u64 dirid = 0, last_dirid = 0;
5713 unsigned long ptr;
5714 u32 item_size;
5715 u32 cur_offset = 0;
5716 int ref_name_len;
5717 int ret = 0;
5719 /* Easy case, just check this one dirid */
5720 if (key->type == BTRFS_INODE_REF_KEY) {
5721 dirid = key->offset;
5723 ret = dir_changed(sctx, dirid);
5724 goto out;
5727 leaf = path->nodes[0];
5728 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
5729 ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
5730 while (cur_offset < item_size) {
5731 extref = (struct btrfs_inode_extref *)(ptr +
5732 cur_offset);
5733 dirid = btrfs_inode_extref_parent(leaf, extref);
5734 ref_name_len = btrfs_inode_extref_name_len(leaf, extref);
5735 cur_offset += ref_name_len + sizeof(*extref);
5736 if (dirid == last_dirid)
5737 continue;
5738 ret = dir_changed(sctx, dirid);
5739 if (ret)
5740 break;
5741 last_dirid = dirid;
5743 out:
5744 return ret;
5748 * Updates compare related fields in sctx and simply forwards to the actual
5749 * changed_xxx functions.
5751 static int changed_cb(struct btrfs_root *left_root,
5752 struct btrfs_root *right_root,
5753 struct btrfs_path *left_path,
5754 struct btrfs_path *right_path,
5755 struct btrfs_key *key,
5756 enum btrfs_compare_tree_result result,
5757 void *ctx)
5759 int ret = 0;
5760 struct send_ctx *sctx = ctx;
5762 if (result == BTRFS_COMPARE_TREE_SAME) {
5763 if (key->type == BTRFS_INODE_REF_KEY ||
5764 key->type == BTRFS_INODE_EXTREF_KEY) {
5765 ret = compare_refs(sctx, left_path, key);
5766 if (!ret)
5767 return 0;
5768 if (ret < 0)
5769 return ret;
5770 } else if (key->type == BTRFS_EXTENT_DATA_KEY) {
5771 return maybe_send_hole(sctx, left_path, key);
5772 } else {
5773 return 0;
5775 result = BTRFS_COMPARE_TREE_CHANGED;
5776 ret = 0;
5779 sctx->left_path = left_path;
5780 sctx->right_path = right_path;
5781 sctx->cmp_key = key;
5783 ret = finish_inode_if_needed(sctx, 0);
5784 if (ret < 0)
5785 goto out;
5787 /* Ignore non-FS objects */
5788 if (key->objectid == BTRFS_FREE_INO_OBJECTID ||
5789 key->objectid == BTRFS_FREE_SPACE_OBJECTID)
5790 goto out;
5792 if (key->type == BTRFS_INODE_ITEM_KEY)
5793 ret = changed_inode(sctx, result);
5794 else if (key->type == BTRFS_INODE_REF_KEY ||
5795 key->type == BTRFS_INODE_EXTREF_KEY)
5796 ret = changed_ref(sctx, result);
5797 else if (key->type == BTRFS_XATTR_ITEM_KEY)
5798 ret = changed_xattr(sctx, result);
5799 else if (key->type == BTRFS_EXTENT_DATA_KEY)
5800 ret = changed_extent(sctx, result);
5802 out:
5803 return ret;
5806 static int full_send_tree(struct send_ctx *sctx)
5808 int ret;
5809 struct btrfs_root *send_root = sctx->send_root;
5810 struct btrfs_key key;
5811 struct btrfs_key found_key;
5812 struct btrfs_path *path;
5813 struct extent_buffer *eb;
5814 int slot;
5816 path = alloc_path_for_send();
5817 if (!path)
5818 return -ENOMEM;
5820 key.objectid = BTRFS_FIRST_FREE_OBJECTID;
5821 key.type = BTRFS_INODE_ITEM_KEY;
5822 key.offset = 0;
5824 ret = btrfs_search_slot_for_read(send_root, &key, path, 1, 0);
5825 if (ret < 0)
5826 goto out;
5827 if (ret)
5828 goto out_finish;
5830 while (1) {
5831 eb = path->nodes[0];
5832 slot = path->slots[0];
5833 btrfs_item_key_to_cpu(eb, &found_key, slot);
5835 ret = changed_cb(send_root, NULL, path, NULL,
5836 &found_key, BTRFS_COMPARE_TREE_NEW, sctx);
5837 if (ret < 0)
5838 goto out;
5840 key.objectid = found_key.objectid;
5841 key.type = found_key.type;
5842 key.offset = found_key.offset + 1;
5844 ret = btrfs_next_item(send_root, path);
5845 if (ret < 0)
5846 goto out;
5847 if (ret) {
5848 ret = 0;
5849 break;
5853 out_finish:
5854 ret = finish_inode_if_needed(sctx, 1);
5856 out:
5857 btrfs_free_path(path);
5858 return ret;
5861 static int send_subvol(struct send_ctx *sctx)
5863 int ret;
5865 if (!(sctx->flags & BTRFS_SEND_FLAG_OMIT_STREAM_HEADER)) {
5866 ret = send_header(sctx);
5867 if (ret < 0)
5868 goto out;
5871 ret = send_subvol_begin(sctx);
5872 if (ret < 0)
5873 goto out;
5875 if (sctx->parent_root) {
5876 ret = btrfs_compare_trees(sctx->send_root, sctx->parent_root,
5877 changed_cb, sctx);
5878 if (ret < 0)
5879 goto out;
5880 ret = finish_inode_if_needed(sctx, 1);
5881 if (ret < 0)
5882 goto out;
5883 } else {
5884 ret = full_send_tree(sctx);
5885 if (ret < 0)
5886 goto out;
5889 out:
5890 free_recorded_refs(sctx);
5891 return ret;
5895 * If orphan cleanup did remove any orphans from a root, it means the tree
5896 * was modified and therefore the commit root is not the same as the current
5897 * root anymore. This is a problem, because send uses the commit root and
5898 * therefore can see inode items that don't exist in the current root anymore,
5899 * and for example make calls to btrfs_iget, which will do tree lookups based
5900 * on the current root and not on the commit root. Those lookups will fail,
5901 * returning a -ESTALE error, and making send fail with that error. So make
5902 * sure a send does not see any orphans we have just removed, and that it will
5903 * see the same inodes regardless of whether a transaction commit happened
5904 * before it started (meaning that the commit root will be the same as the
5905 * current root) or not.
5907 static int ensure_commit_roots_uptodate(struct send_ctx *sctx)
5909 int i;
5910 struct btrfs_trans_handle *trans = NULL;
5912 again:
5913 if (sctx->parent_root &&
5914 sctx->parent_root->node != sctx->parent_root->commit_root)
5915 goto commit_trans;
5917 for (i = 0; i < sctx->clone_roots_cnt; i++)
5918 if (sctx->clone_roots[i].root->node !=
5919 sctx->clone_roots[i].root->commit_root)
5920 goto commit_trans;
5922 if (trans)
5923 return btrfs_end_transaction(trans, sctx->send_root);
5925 return 0;
5927 commit_trans:
5928 /* Use any root, all fs roots will get their commit roots updated. */
5929 if (!trans) {
5930 trans = btrfs_join_transaction(sctx->send_root);
5931 if (IS_ERR(trans))
5932 return PTR_ERR(trans);
5933 goto again;
5936 return btrfs_commit_transaction(trans, sctx->send_root);
5939 static void btrfs_root_dec_send_in_progress(struct btrfs_root* root)
5941 spin_lock(&root->root_item_lock);
5942 root->send_in_progress--;
5944 * Not much left to do, we don't know why it's unbalanced and
5945 * can't blindly reset it to 0.
5947 if (root->send_in_progress < 0)
5948 btrfs_err(root->fs_info,
5949 "send_in_progres unbalanced %d root %llu",
5950 root->send_in_progress, root->root_key.objectid);
5951 spin_unlock(&root->root_item_lock);
5954 long btrfs_ioctl_send(struct file *mnt_file, void __user *arg_)
5956 int ret = 0;
5957 struct btrfs_root *send_root;
5958 struct btrfs_root *clone_root;
5959 struct btrfs_fs_info *fs_info;
5960 struct btrfs_ioctl_send_args *arg = NULL;
5961 struct btrfs_key key;
5962 struct send_ctx *sctx = NULL;
5963 u32 i;
5964 u64 *clone_sources_tmp = NULL;
5965 int clone_sources_to_rollback = 0;
5966 int sort_clone_roots = 0;
5967 int index;
5969 if (!capable(CAP_SYS_ADMIN))
5970 return -EPERM;
5972 send_root = BTRFS_I(file_inode(mnt_file))->root;
5973 fs_info = send_root->fs_info;
5976 * The subvolume must remain read-only during send, protect against
5977 * making it RW. This also protects against deletion.
5979 spin_lock(&send_root->root_item_lock);
5980 send_root->send_in_progress++;
5981 spin_unlock(&send_root->root_item_lock);
5984 * This is done when we lookup the root, it should already be complete
5985 * by the time we get here.
5987 WARN_ON(send_root->orphan_cleanup_state != ORPHAN_CLEANUP_DONE);
5990 * Userspace tools do the checks and warn the user if it's
5991 * not RO.
5993 if (!btrfs_root_readonly(send_root)) {
5994 ret = -EPERM;
5995 goto out;
5998 arg = memdup_user(arg_, sizeof(*arg));
5999 if (IS_ERR(arg)) {
6000 ret = PTR_ERR(arg);
6001 arg = NULL;
6002 goto out;
6005 if (!access_ok(VERIFY_READ, arg->clone_sources,
6006 sizeof(*arg->clone_sources) *
6007 arg->clone_sources_count)) {
6008 ret = -EFAULT;
6009 goto out;
6012 if (arg->flags & ~BTRFS_SEND_FLAG_MASK) {
6013 ret = -EINVAL;
6014 goto out;
6017 sctx = kzalloc(sizeof(struct send_ctx), GFP_NOFS);
6018 if (!sctx) {
6019 ret = -ENOMEM;
6020 goto out;
6023 INIT_LIST_HEAD(&sctx->new_refs);
6024 INIT_LIST_HEAD(&sctx->deleted_refs);
6025 INIT_RADIX_TREE(&sctx->name_cache, GFP_NOFS);
6026 INIT_LIST_HEAD(&sctx->name_cache_list);
6028 sctx->flags = arg->flags;
6030 sctx->send_filp = fget(arg->send_fd);
6031 if (!sctx->send_filp) {
6032 ret = -EBADF;
6033 goto out;
6036 sctx->send_root = send_root;
6038 * Unlikely but possible, if the subvolume is marked for deletion but
6039 * is slow to remove the directory entry, send can still be started
6041 if (btrfs_root_dead(sctx->send_root)) {
6042 ret = -EPERM;
6043 goto out;
6046 sctx->clone_roots_cnt = arg->clone_sources_count;
6048 sctx->send_max_size = BTRFS_SEND_BUF_SIZE;
6049 sctx->send_buf = vmalloc(sctx->send_max_size);
6050 if (!sctx->send_buf) {
6051 ret = -ENOMEM;
6052 goto out;
6055 sctx->read_buf = vmalloc(BTRFS_SEND_READ_SIZE);
6056 if (!sctx->read_buf) {
6057 ret = -ENOMEM;
6058 goto out;
6061 sctx->pending_dir_moves = RB_ROOT;
6062 sctx->waiting_dir_moves = RB_ROOT;
6063 sctx->orphan_dirs = RB_ROOT;
6065 sctx->clone_roots = vzalloc(sizeof(struct clone_root) *
6066 (arg->clone_sources_count + 1));
6067 if (!sctx->clone_roots) {
6068 ret = -ENOMEM;
6069 goto out;
6072 if (arg->clone_sources_count) {
6073 clone_sources_tmp = vmalloc(arg->clone_sources_count *
6074 sizeof(*arg->clone_sources));
6075 if (!clone_sources_tmp) {
6076 ret = -ENOMEM;
6077 goto out;
6080 ret = copy_from_user(clone_sources_tmp, arg->clone_sources,
6081 arg->clone_sources_count *
6082 sizeof(*arg->clone_sources));
6083 if (ret) {
6084 ret = -EFAULT;
6085 goto out;
6088 for (i = 0; i < arg->clone_sources_count; i++) {
6089 key.objectid = clone_sources_tmp[i];
6090 key.type = BTRFS_ROOT_ITEM_KEY;
6091 key.offset = (u64)-1;
6093 index = srcu_read_lock(&fs_info->subvol_srcu);
6095 clone_root = btrfs_read_fs_root_no_name(fs_info, &key);
6096 if (IS_ERR(clone_root)) {
6097 srcu_read_unlock(&fs_info->subvol_srcu, index);
6098 ret = PTR_ERR(clone_root);
6099 goto out;
6101 spin_lock(&clone_root->root_item_lock);
6102 if (!btrfs_root_readonly(clone_root) ||
6103 btrfs_root_dead(clone_root)) {
6104 spin_unlock(&clone_root->root_item_lock);
6105 srcu_read_unlock(&fs_info->subvol_srcu, index);
6106 ret = -EPERM;
6107 goto out;
6109 clone_root->send_in_progress++;
6110 spin_unlock(&clone_root->root_item_lock);
6111 srcu_read_unlock(&fs_info->subvol_srcu, index);
6113 sctx->clone_roots[i].root = clone_root;
6114 clone_sources_to_rollback = i + 1;
6116 vfree(clone_sources_tmp);
6117 clone_sources_tmp = NULL;
6120 if (arg->parent_root) {
6121 key.objectid = arg->parent_root;
6122 key.type = BTRFS_ROOT_ITEM_KEY;
6123 key.offset = (u64)-1;
6125 index = srcu_read_lock(&fs_info->subvol_srcu);
6127 sctx->parent_root = btrfs_read_fs_root_no_name(fs_info, &key);
6128 if (IS_ERR(sctx->parent_root)) {
6129 srcu_read_unlock(&fs_info->subvol_srcu, index);
6130 ret = PTR_ERR(sctx->parent_root);
6131 goto out;
6134 spin_lock(&sctx->parent_root->root_item_lock);
6135 sctx->parent_root->send_in_progress++;
6136 if (!btrfs_root_readonly(sctx->parent_root) ||
6137 btrfs_root_dead(sctx->parent_root)) {
6138 spin_unlock(&sctx->parent_root->root_item_lock);
6139 srcu_read_unlock(&fs_info->subvol_srcu, index);
6140 ret = -EPERM;
6141 goto out;
6143 spin_unlock(&sctx->parent_root->root_item_lock);
6145 srcu_read_unlock(&fs_info->subvol_srcu, index);
6149 * Clones from send_root are allowed, but only if the clone source
6150 * is behind the current send position. This is checked while searching
6151 * for possible clone sources.
6153 sctx->clone_roots[sctx->clone_roots_cnt++].root = sctx->send_root;
6155 /* We do a bsearch later */
6156 sort(sctx->clone_roots, sctx->clone_roots_cnt,
6157 sizeof(*sctx->clone_roots), __clone_root_cmp_sort,
6158 NULL);
6159 sort_clone_roots = 1;
6161 ret = ensure_commit_roots_uptodate(sctx);
6162 if (ret)
6163 goto out;
6165 current->journal_info = BTRFS_SEND_TRANS_STUB;
6166 ret = send_subvol(sctx);
6167 current->journal_info = NULL;
6168 if (ret < 0)
6169 goto out;
6171 if (!(sctx->flags & BTRFS_SEND_FLAG_OMIT_END_CMD)) {
6172 ret = begin_cmd(sctx, BTRFS_SEND_C_END);
6173 if (ret < 0)
6174 goto out;
6175 ret = send_cmd(sctx);
6176 if (ret < 0)
6177 goto out;
6180 out:
6181 WARN_ON(sctx && !ret && !RB_EMPTY_ROOT(&sctx->pending_dir_moves));
6182 while (sctx && !RB_EMPTY_ROOT(&sctx->pending_dir_moves)) {
6183 struct rb_node *n;
6184 struct pending_dir_move *pm;
6186 n = rb_first(&sctx->pending_dir_moves);
6187 pm = rb_entry(n, struct pending_dir_move, node);
6188 while (!list_empty(&pm->list)) {
6189 struct pending_dir_move *pm2;
6191 pm2 = list_first_entry(&pm->list,
6192 struct pending_dir_move, list);
6193 free_pending_move(sctx, pm2);
6195 free_pending_move(sctx, pm);
6198 WARN_ON(sctx && !ret && !RB_EMPTY_ROOT(&sctx->waiting_dir_moves));
6199 while (sctx && !RB_EMPTY_ROOT(&sctx->waiting_dir_moves)) {
6200 struct rb_node *n;
6201 struct waiting_dir_move *dm;
6203 n = rb_first(&sctx->waiting_dir_moves);
6204 dm = rb_entry(n, struct waiting_dir_move, node);
6205 rb_erase(&dm->node, &sctx->waiting_dir_moves);
6206 kfree(dm);
6209 WARN_ON(sctx && !ret && !RB_EMPTY_ROOT(&sctx->orphan_dirs));
6210 while (sctx && !RB_EMPTY_ROOT(&sctx->orphan_dirs)) {
6211 struct rb_node *n;
6212 struct orphan_dir_info *odi;
6214 n = rb_first(&sctx->orphan_dirs);
6215 odi = rb_entry(n, struct orphan_dir_info, node);
6216 free_orphan_dir_info(sctx, odi);
6219 if (sort_clone_roots) {
6220 for (i = 0; i < sctx->clone_roots_cnt; i++)
6221 btrfs_root_dec_send_in_progress(
6222 sctx->clone_roots[i].root);
6223 } else {
6224 for (i = 0; sctx && i < clone_sources_to_rollback; i++)
6225 btrfs_root_dec_send_in_progress(
6226 sctx->clone_roots[i].root);
6228 btrfs_root_dec_send_in_progress(send_root);
6230 if (sctx && !IS_ERR_OR_NULL(sctx->parent_root))
6231 btrfs_root_dec_send_in_progress(sctx->parent_root);
6233 kfree(arg);
6234 vfree(clone_sources_tmp);
6236 if (sctx) {
6237 if (sctx->send_filp)
6238 fput(sctx->send_filp);
6240 vfree(sctx->clone_roots);
6241 vfree(sctx->send_buf);
6242 vfree(sctx->read_buf);
6244 name_cache_free(sctx);
6246 kfree(sctx);
6249 return ret;