blob: ddd2b786f4d540699a9c82c7d76274228d9072fe [file] [log] [blame]
Alexander Block31db9f72012-07-25 23:19:24 +02001/*
2 * Copyright (C) 2012 Alexander Block. All rights reserved.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
17 */
18
19#include <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>
Stephen Rothwella1857eb2012-07-27 10:11:13 +100027#include <linux/vmalloc.h>
Andy Shevchenkoed848852013-08-21 10:32:13 +030028#include <linux/string.h>
Alexander Block31db9f72012-07-25 23:19:24 +020029
30#include "send.h"
31#include "backref.h"
Filipe David Borba Manana0b947af2014-01-29 21:06:04 +000032#include "hash.h"
Alexander Block31db9f72012-07-25 23:19:24 +020033#include "locking.h"
34#include "disk-io.h"
35#include "btrfs_inode.h"
36#include "transaction.h"
Anand Jainebb87652016-03-10 17:26:59 +080037#include "compression.h"
Alexander Block31db9f72012-07-25 23:19:24 +020038
Alexander Block31db9f72012-07-25 23:19:24 +020039/*
40 * A fs_path is a helper to dynamically build path names with unknown size.
41 * It reallocates the internal buffer on demand.
42 * It allows fast adding of path elements on the right side (normal path) and
43 * fast adding to the left side (reversed path). A reversed path can also be
44 * unreversed if needed.
45 */
46struct fs_path {
47 union {
48 struct {
49 char *start;
50 char *end;
Alexander Block31db9f72012-07-25 23:19:24 +020051
52 char *buf;
David Sterba1f5a7ff2014-02-03 19:23:47 +010053 unsigned short buf_len:15;
54 unsigned short reversed:1;
Alexander Block31db9f72012-07-25 23:19:24 +020055 char inline_buf[];
56 };
David Sterbaace01052014-02-05 16:17:34 +010057 /*
58 * Average path length does not exceed 200 bytes, we'll have
59 * better packing in the slab and higher chance to satisfy
60 * a allocation later during send.
61 */
62 char pad[256];
Alexander Block31db9f72012-07-25 23:19:24 +020063 };
64};
65#define FS_PATH_INLINE_SIZE \
66 (sizeof(struct fs_path) - offsetof(struct fs_path, inline_buf))
67
68
69/* reused for each extent */
70struct clone_root {
71 struct btrfs_root *root;
72 u64 ino;
73 u64 offset;
74
75 u64 found_refs;
76};
77
78#define SEND_CTX_MAX_NAME_CACHE_SIZE 128
79#define SEND_CTX_NAME_CACHE_CLEAN_SIZE (SEND_CTX_MAX_NAME_CACHE_SIZE * 2)
80
81struct send_ctx {
82 struct file *send_filp;
83 loff_t send_off;
84 char *send_buf;
85 u32 send_size;
86 u32 send_max_size;
87 u64 total_send_size;
88 u64 cmd_send_size[BTRFS_SEND_C_MAX + 1];
Mark Fashehcb95e7b2013-02-04 20:54:57 +000089 u64 flags; /* 'flags' member of btrfs_ioctl_send_args is u64 */
Alexander Block31db9f72012-07-25 23:19:24 +020090
Alexander Block31db9f72012-07-25 23:19:24 +020091 struct btrfs_root *send_root;
92 struct btrfs_root *parent_root;
93 struct clone_root *clone_roots;
94 int clone_roots_cnt;
95
96 /* current state of the compare_tree call */
97 struct btrfs_path *left_path;
98 struct btrfs_path *right_path;
99 struct btrfs_key *cmp_key;
100
101 /*
102 * infos of the currently processed inode. In case of deleted inodes,
103 * these are the values from the deleted inode.
104 */
105 u64 cur_ino;
106 u64 cur_inode_gen;
107 int cur_inode_new;
108 int cur_inode_new_gen;
109 int cur_inode_deleted;
Alexander Block31db9f72012-07-25 23:19:24 +0200110 u64 cur_inode_size;
111 u64 cur_inode_mode;
Liu Bo644d1942014-02-27 17:29:01 +0800112 u64 cur_inode_rdev;
Josef Bacik16e75492013-10-22 12:18:51 -0400113 u64 cur_inode_last_extent;
Alexander Block31db9f72012-07-25 23:19:24 +0200114
115 u64 send_progress;
116
117 struct list_head new_refs;
118 struct list_head deleted_refs;
119
120 struct radix_tree_root name_cache;
121 struct list_head name_cache_list;
122 int name_cache_size;
123
Liu Bo2131bcd2014-03-05 10:07:35 +0800124 struct file_ra_state ra;
125
Alexander Block31db9f72012-07-25 23:19:24 +0200126 char *read_buf;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +0000127
128 /*
129 * We process inodes by their increasing order, so if before an
130 * incremental send we reverse the parent/child relationship of
131 * directories such that a directory with a lower inode number was
132 * the parent of a directory with a higher inode number, and the one
133 * becoming the new parent got renamed too, we can't rename/move the
134 * directory with lower inode number when we finish processing it - we
135 * must process the directory with higher inode number first, then
136 * rename/move it and then rename/move the directory with lower inode
137 * number. Example follows.
138 *
139 * Tree state when the first send was performed:
140 *
141 * .
142 * |-- a (ino 257)
143 * |-- b (ino 258)
144 * |
145 * |
146 * |-- c (ino 259)
147 * | |-- d (ino 260)
148 * |
149 * |-- c2 (ino 261)
150 *
151 * Tree state when the second (incremental) send is performed:
152 *
153 * .
154 * |-- a (ino 257)
155 * |-- b (ino 258)
156 * |-- c2 (ino 261)
157 * |-- d2 (ino 260)
158 * |-- cc (ino 259)
159 *
160 * The sequence of steps that lead to the second state was:
161 *
162 * mv /a/b/c/d /a/b/c2/d2
163 * mv /a/b/c /a/b/c2/d2/cc
164 *
165 * "c" has lower inode number, but we can't move it (2nd mv operation)
166 * before we move "d", which has higher inode number.
167 *
168 * So we just memorize which move/rename operations must be performed
169 * later when their respective parent is processed and moved/renamed.
170 */
171
172 /* Indexed by parent directory inode number. */
173 struct rb_root pending_dir_moves;
174
175 /*
176 * Reverse index, indexed by the inode number of a directory that
177 * is waiting for the move/rename of its immediate parent before its
178 * own move/rename can be performed.
179 */
180 struct rb_root waiting_dir_moves;
Filipe Manana9dc44212014-02-19 14:31:44 +0000181
182 /*
183 * A directory that is going to be rm'ed might have a child directory
184 * which is in the pending directory moves index above. In this case,
185 * the directory can only be removed after the move/rename of its child
186 * is performed. Example:
187 *
188 * Parent snapshot:
189 *
190 * . (ino 256)
191 * |-- a/ (ino 257)
192 * |-- b/ (ino 258)
193 * |-- c/ (ino 259)
194 * | |-- x/ (ino 260)
195 * |
196 * |-- y/ (ino 261)
197 *
198 * Send snapshot:
199 *
200 * . (ino 256)
201 * |-- a/ (ino 257)
202 * |-- b/ (ino 258)
203 * |-- YY/ (ino 261)
204 * |-- x/ (ino 260)
205 *
206 * Sequence of steps that lead to the send snapshot:
207 * rm -f /a/b/c/foo.txt
208 * mv /a/b/y /a/b/YY
209 * mv /a/b/c/x /a/b/YY
210 * rmdir /a/b/c
211 *
212 * When the child is processed, its move/rename is delayed until its
213 * parent is processed (as explained above), but all other operations
214 * like update utimes, chown, chgrp, etc, are performed and the paths
215 * that it uses for those operations must use the orphanized name of
216 * its parent (the directory we're going to rm later), so we need to
217 * memorize that name.
218 *
219 * Indexed by the inode number of the directory to be deleted.
220 */
221 struct rb_root orphan_dirs;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +0000222};
223
224struct pending_dir_move {
225 struct rb_node node;
226 struct list_head list;
227 u64 parent_ino;
228 u64 ino;
229 u64 gen;
230 struct list_head update_refs;
231};
232
233struct waiting_dir_move {
234 struct rb_node node;
235 u64 ino;
Filipe Manana9dc44212014-02-19 14:31:44 +0000236 /*
237 * There might be some directory that could not be removed because it
238 * was waiting for this directory inode to be moved first. Therefore
239 * after this directory is moved, we can try to rmdir the ino rmdir_ino.
240 */
241 u64 rmdir_ino;
Filipe Manana8b191a62015-04-09 14:09:14 +0100242 bool orphanized;
Filipe Manana9dc44212014-02-19 14:31:44 +0000243};
244
245struct orphan_dir_info {
246 struct rb_node node;
247 u64 ino;
248 u64 gen;
Alexander Block31db9f72012-07-25 23:19:24 +0200249};
250
251struct name_cache_entry {
252 struct list_head list;
Alexander Block7e0926f2012-07-28 14:20:58 +0200253 /*
254 * radix_tree has only 32bit entries but we need to handle 64bit inums.
255 * We use the lower 32bit of the 64bit inum to store it in the tree. If
256 * more then one inum would fall into the same entry, we use radix_list
257 * to store the additional entries. radix_list is also used to store
258 * entries where two entries have the same inum but different
259 * generations.
260 */
261 struct list_head radix_list;
Alexander Block31db9f72012-07-25 23:19:24 +0200262 u64 ino;
263 u64 gen;
264 u64 parent_ino;
265 u64 parent_gen;
266 int ret;
267 int need_later_update;
268 int name_len;
269 char name[];
270};
271
Filipe Manana95155582016-08-01 01:50:37 +0100272static void inconsistent_snapshot_error(struct send_ctx *sctx,
273 enum btrfs_compare_tree_result result,
274 const char *what)
275{
276 const char *result_string;
277
278 switch (result) {
279 case BTRFS_COMPARE_TREE_NEW:
280 result_string = "new";
281 break;
282 case BTRFS_COMPARE_TREE_DELETED:
283 result_string = "deleted";
284 break;
285 case BTRFS_COMPARE_TREE_CHANGED:
286 result_string = "updated";
287 break;
288 case BTRFS_COMPARE_TREE_SAME:
289 ASSERT(0);
290 result_string = "unchanged";
291 break;
292 default:
293 ASSERT(0);
294 result_string = "unexpected";
295 }
296
297 btrfs_err(sctx->send_root->fs_info,
298 "Send: inconsistent snapshot, found %s %s for inode %llu without updated inode item, send root is %llu, parent root is %llu",
299 result_string, what, sctx->cmp_key->objectid,
300 sctx->send_root->root_key.objectid,
301 (sctx->parent_root ?
302 sctx->parent_root->root_key.objectid : 0));
303}
304
Filipe David Borba Manana9f037402014-01-22 10:00:53 +0000305static int is_waiting_for_move(struct send_ctx *sctx, u64 ino);
306
Filipe Manana9dc44212014-02-19 14:31:44 +0000307static struct waiting_dir_move *
308get_waiting_dir_move(struct send_ctx *sctx, u64 ino);
309
310static int is_waiting_for_rm(struct send_ctx *sctx, u64 dir_ino);
311
Josef Bacik16e75492013-10-22 12:18:51 -0400312static int need_send_hole(struct send_ctx *sctx)
313{
314 return (sctx->parent_root && !sctx->cur_inode_new &&
315 !sctx->cur_inode_new_gen && !sctx->cur_inode_deleted &&
316 S_ISREG(sctx->cur_inode_mode));
317}
318
Alexander Block31db9f72012-07-25 23:19:24 +0200319static void fs_path_reset(struct fs_path *p)
320{
321 if (p->reversed) {
322 p->start = p->buf + p->buf_len - 1;
323 p->end = p->start;
324 *p->start = 0;
325 } else {
326 p->start = p->buf;
327 p->end = p->start;
328 *p->start = 0;
329 }
330}
331
Tsutomu Itoh924794c2013-05-08 07:51:52 +0000332static struct fs_path *fs_path_alloc(void)
Alexander Block31db9f72012-07-25 23:19:24 +0200333{
334 struct fs_path *p;
335
David Sterbae780b0d2016-01-18 18:42:13 +0100336 p = kmalloc(sizeof(*p), GFP_KERNEL);
Alexander Block31db9f72012-07-25 23:19:24 +0200337 if (!p)
338 return NULL;
339 p->reversed = 0;
Alexander Block31db9f72012-07-25 23:19:24 +0200340 p->buf = p->inline_buf;
341 p->buf_len = FS_PATH_INLINE_SIZE;
342 fs_path_reset(p);
343 return p;
344}
345
Tsutomu Itoh924794c2013-05-08 07:51:52 +0000346static struct fs_path *fs_path_alloc_reversed(void)
Alexander Block31db9f72012-07-25 23:19:24 +0200347{
348 struct fs_path *p;
349
Tsutomu Itoh924794c2013-05-08 07:51:52 +0000350 p = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +0200351 if (!p)
352 return NULL;
353 p->reversed = 1;
354 fs_path_reset(p);
355 return p;
356}
357
Tsutomu Itoh924794c2013-05-08 07:51:52 +0000358static void fs_path_free(struct fs_path *p)
Alexander Block31db9f72012-07-25 23:19:24 +0200359{
360 if (!p)
361 return;
David Sterbaace01052014-02-05 16:17:34 +0100362 if (p->buf != p->inline_buf)
363 kfree(p->buf);
Alexander Block31db9f72012-07-25 23:19:24 +0200364 kfree(p);
365}
366
367static int fs_path_len(struct fs_path *p)
368{
369 return p->end - p->start;
370}
371
372static int fs_path_ensure_buf(struct fs_path *p, int len)
373{
374 char *tmp_buf;
375 int path_len;
376 int old_buf_len;
377
378 len++;
379
380 if (p->buf_len >= len)
381 return 0;
382
Chris Masoncfd4a532014-04-26 05:02:03 -0700383 if (len > PATH_MAX) {
384 WARN_ON(1);
385 return -ENOMEM;
386 }
387
David Sterba1b2782c2014-02-25 19:32:59 +0100388 path_len = p->end - p->start;
389 old_buf_len = p->buf_len;
390
David Sterbaace01052014-02-05 16:17:34 +0100391 /*
392 * First time the inline_buf does not suffice
393 */
Filipe Manana01a9a8a2014-05-21 17:38:13 +0100394 if (p->buf == p->inline_buf) {
David Sterbae780b0d2016-01-18 18:42:13 +0100395 tmp_buf = kmalloc(len, GFP_KERNEL);
Filipe Manana01a9a8a2014-05-21 17:38:13 +0100396 if (tmp_buf)
397 memcpy(tmp_buf, p->buf, old_buf_len);
398 } else {
David Sterbae780b0d2016-01-18 18:42:13 +0100399 tmp_buf = krealloc(p->buf, len, GFP_KERNEL);
Filipe Manana01a9a8a2014-05-21 17:38:13 +0100400 }
David Sterba9c9ca002014-02-25 19:33:08 +0100401 if (!tmp_buf)
402 return -ENOMEM;
403 p->buf = tmp_buf;
404 /*
405 * The real size of the buffer is bigger, this will let the fast path
406 * happen most of the time
407 */
408 p->buf_len = ksize(p->buf);
David Sterbaace01052014-02-05 16:17:34 +0100409
Alexander Block31db9f72012-07-25 23:19:24 +0200410 if (p->reversed) {
411 tmp_buf = p->buf + old_buf_len - path_len - 1;
412 p->end = p->buf + p->buf_len - 1;
413 p->start = p->end - path_len;
414 memmove(p->start, tmp_buf, path_len + 1);
415 } else {
416 p->start = p->buf;
417 p->end = p->start + path_len;
418 }
419 return 0;
420}
421
David Sterbab23ab572014-02-03 19:23:19 +0100422static int fs_path_prepare_for_add(struct fs_path *p, int name_len,
423 char **prepared)
Alexander Block31db9f72012-07-25 23:19:24 +0200424{
425 int ret;
426 int new_len;
427
428 new_len = p->end - p->start + name_len;
429 if (p->start != p->end)
430 new_len++;
431 ret = fs_path_ensure_buf(p, new_len);
432 if (ret < 0)
433 goto out;
434
435 if (p->reversed) {
436 if (p->start != p->end)
437 *--p->start = '/';
438 p->start -= name_len;
David Sterbab23ab572014-02-03 19:23:19 +0100439 *prepared = p->start;
Alexander Block31db9f72012-07-25 23:19:24 +0200440 } else {
441 if (p->start != p->end)
442 *p->end++ = '/';
David Sterbab23ab572014-02-03 19:23:19 +0100443 *prepared = p->end;
Alexander Block31db9f72012-07-25 23:19:24 +0200444 p->end += name_len;
445 *p->end = 0;
446 }
447
448out:
449 return ret;
450}
451
452static int fs_path_add(struct fs_path *p, const char *name, int name_len)
453{
454 int ret;
David Sterbab23ab572014-02-03 19:23:19 +0100455 char *prepared;
Alexander Block31db9f72012-07-25 23:19:24 +0200456
David Sterbab23ab572014-02-03 19:23:19 +0100457 ret = fs_path_prepare_for_add(p, name_len, &prepared);
Alexander Block31db9f72012-07-25 23:19:24 +0200458 if (ret < 0)
459 goto out;
David Sterbab23ab572014-02-03 19:23:19 +0100460 memcpy(prepared, name, name_len);
Alexander Block31db9f72012-07-25 23:19:24 +0200461
462out:
463 return ret;
464}
465
466static int fs_path_add_path(struct fs_path *p, struct fs_path *p2)
467{
468 int ret;
David Sterbab23ab572014-02-03 19:23:19 +0100469 char *prepared;
Alexander Block31db9f72012-07-25 23:19:24 +0200470
David Sterbab23ab572014-02-03 19:23:19 +0100471 ret = fs_path_prepare_for_add(p, p2->end - p2->start, &prepared);
Alexander Block31db9f72012-07-25 23:19:24 +0200472 if (ret < 0)
473 goto out;
David Sterbab23ab572014-02-03 19:23:19 +0100474 memcpy(prepared, p2->start, p2->end - p2->start);
Alexander Block31db9f72012-07-25 23:19:24 +0200475
476out:
477 return ret;
478}
479
480static int fs_path_add_from_extent_buffer(struct fs_path *p,
481 struct extent_buffer *eb,
482 unsigned long off, int len)
483{
484 int ret;
David Sterbab23ab572014-02-03 19:23:19 +0100485 char *prepared;
Alexander Block31db9f72012-07-25 23:19:24 +0200486
David Sterbab23ab572014-02-03 19:23:19 +0100487 ret = fs_path_prepare_for_add(p, len, &prepared);
Alexander Block31db9f72012-07-25 23:19:24 +0200488 if (ret < 0)
489 goto out;
490
David Sterbab23ab572014-02-03 19:23:19 +0100491 read_extent_buffer(eb, prepared, off, len);
Alexander Block31db9f72012-07-25 23:19:24 +0200492
493out:
494 return ret;
495}
496
Alexander Block31db9f72012-07-25 23:19:24 +0200497static int fs_path_copy(struct fs_path *p, struct fs_path *from)
498{
499 int ret;
500
501 p->reversed = from->reversed;
502 fs_path_reset(p);
503
504 ret = fs_path_add_path(p, from);
505
506 return ret;
507}
508
509
510static void fs_path_unreverse(struct fs_path *p)
511{
512 char *tmp;
513 int len;
514
515 if (!p->reversed)
516 return;
517
518 tmp = p->start;
519 len = p->end - p->start;
520 p->start = p->buf;
521 p->end = p->start + len;
522 memmove(p->start, tmp, len + 1);
523 p->reversed = 0;
524}
525
526static struct btrfs_path *alloc_path_for_send(void)
527{
528 struct btrfs_path *path;
529
530 path = btrfs_alloc_path();
531 if (!path)
532 return NULL;
533 path->search_commit_root = 1;
534 path->skip_locking = 1;
Josef Bacik3f8a18c2014-03-28 17:16:01 -0400535 path->need_commit_sem = 1;
Alexander Block31db9f72012-07-25 23:19:24 +0200536 return path;
537}
538
Eric Sandeen48a3b632013-04-25 20:41:01 +0000539static int write_buf(struct file *filp, const void *buf, u32 len, loff_t *off)
Alexander Block31db9f72012-07-25 23:19:24 +0200540{
541 int ret;
542 mm_segment_t old_fs;
543 u32 pos = 0;
544
545 old_fs = get_fs();
546 set_fs(KERNEL_DS);
547
548 while (pos < len) {
Fabian Frederickd447d0d2014-07-15 21:17:17 +0200549 ret = vfs_write(filp, (__force const char __user *)buf + pos,
550 len - pos, off);
Alexander Block31db9f72012-07-25 23:19:24 +0200551 /* TODO handle that correctly */
552 /*if (ret == -ERESTARTSYS) {
553 continue;
554 }*/
555 if (ret < 0)
556 goto out;
557 if (ret == 0) {
558 ret = -EIO;
559 goto out;
560 }
561 pos += ret;
562 }
563
564 ret = 0;
565
566out:
567 set_fs(old_fs);
568 return ret;
569}
570
571static int tlv_put(struct send_ctx *sctx, u16 attr, const void *data, int len)
572{
573 struct btrfs_tlv_header *hdr;
574 int total_len = sizeof(*hdr) + len;
575 int left = sctx->send_max_size - sctx->send_size;
576
577 if (unlikely(left < total_len))
578 return -EOVERFLOW;
579
580 hdr = (struct btrfs_tlv_header *) (sctx->send_buf + sctx->send_size);
581 hdr->tlv_type = cpu_to_le16(attr);
582 hdr->tlv_len = cpu_to_le16(len);
583 memcpy(hdr + 1, data, len);
584 sctx->send_size += total_len;
585
586 return 0;
587}
588
David Sterba95bc79d2013-12-16 17:34:10 +0100589#define TLV_PUT_DEFINE_INT(bits) \
590 static int tlv_put_u##bits(struct send_ctx *sctx, \
591 u##bits attr, u##bits value) \
592 { \
593 __le##bits __tmp = cpu_to_le##bits(value); \
594 return tlv_put(sctx, attr, &__tmp, sizeof(__tmp)); \
595 }
Alexander Block31db9f72012-07-25 23:19:24 +0200596
David Sterba95bc79d2013-12-16 17:34:10 +0100597TLV_PUT_DEFINE_INT(64)
Alexander Block31db9f72012-07-25 23:19:24 +0200598
599static int tlv_put_string(struct send_ctx *sctx, u16 attr,
600 const char *str, int len)
601{
602 if (len == -1)
603 len = strlen(str);
604 return tlv_put(sctx, attr, str, len);
605}
606
607static int tlv_put_uuid(struct send_ctx *sctx, u16 attr,
608 const u8 *uuid)
609{
610 return tlv_put(sctx, attr, uuid, BTRFS_UUID_SIZE);
611}
612
Alexander Block31db9f72012-07-25 23:19:24 +0200613static int tlv_put_btrfs_timespec(struct send_ctx *sctx, u16 attr,
614 struct extent_buffer *eb,
615 struct btrfs_timespec *ts)
616{
617 struct btrfs_timespec bts;
618 read_extent_buffer(eb, &bts, (unsigned long)ts, sizeof(bts));
619 return tlv_put(sctx, attr, &bts, sizeof(bts));
620}
621
622
623#define TLV_PUT(sctx, attrtype, attrlen, data) \
624 do { \
625 ret = tlv_put(sctx, attrtype, attrlen, data); \
626 if (ret < 0) \
627 goto tlv_put_failure; \
628 } while (0)
629
630#define TLV_PUT_INT(sctx, attrtype, bits, value) \
631 do { \
632 ret = tlv_put_u##bits(sctx, attrtype, value); \
633 if (ret < 0) \
634 goto tlv_put_failure; \
635 } while (0)
636
637#define TLV_PUT_U8(sctx, attrtype, data) TLV_PUT_INT(sctx, attrtype, 8, data)
638#define TLV_PUT_U16(sctx, attrtype, data) TLV_PUT_INT(sctx, attrtype, 16, data)
639#define TLV_PUT_U32(sctx, attrtype, data) TLV_PUT_INT(sctx, attrtype, 32, data)
640#define TLV_PUT_U64(sctx, attrtype, data) TLV_PUT_INT(sctx, attrtype, 64, data)
641#define TLV_PUT_STRING(sctx, attrtype, str, len) \
642 do { \
643 ret = tlv_put_string(sctx, attrtype, str, len); \
644 if (ret < 0) \
645 goto tlv_put_failure; \
646 } while (0)
647#define TLV_PUT_PATH(sctx, attrtype, p) \
648 do { \
649 ret = tlv_put_string(sctx, attrtype, p->start, \
650 p->end - p->start); \
651 if (ret < 0) \
652 goto tlv_put_failure; \
653 } while(0)
654#define TLV_PUT_UUID(sctx, attrtype, uuid) \
655 do { \
656 ret = tlv_put_uuid(sctx, attrtype, uuid); \
657 if (ret < 0) \
658 goto tlv_put_failure; \
659 } while (0)
Alexander Block31db9f72012-07-25 23:19:24 +0200660#define TLV_PUT_BTRFS_TIMESPEC(sctx, attrtype, eb, ts) \
661 do { \
662 ret = tlv_put_btrfs_timespec(sctx, attrtype, eb, ts); \
663 if (ret < 0) \
664 goto tlv_put_failure; \
665 } while (0)
666
667static int send_header(struct send_ctx *sctx)
668{
669 struct btrfs_stream_header hdr;
670
671 strcpy(hdr.magic, BTRFS_SEND_STREAM_MAGIC);
672 hdr.version = cpu_to_le32(BTRFS_SEND_STREAM_VERSION);
673
Anand Jain1bcea352012-09-14 00:04:21 -0600674 return write_buf(sctx->send_filp, &hdr, sizeof(hdr),
675 &sctx->send_off);
Alexander Block31db9f72012-07-25 23:19:24 +0200676}
677
678/*
679 * For each command/item we want to send to userspace, we call this function.
680 */
681static int begin_cmd(struct send_ctx *sctx, int cmd)
682{
683 struct btrfs_cmd_header *hdr;
684
Dulshani Gunawardhanafae7f212013-10-31 10:30:08 +0530685 if (WARN_ON(!sctx->send_buf))
Alexander Block31db9f72012-07-25 23:19:24 +0200686 return -EINVAL;
Alexander Block31db9f72012-07-25 23:19:24 +0200687
688 BUG_ON(sctx->send_size);
689
690 sctx->send_size += sizeof(*hdr);
691 hdr = (struct btrfs_cmd_header *)sctx->send_buf;
692 hdr->cmd = cpu_to_le16(cmd);
693
694 return 0;
695}
696
697static int send_cmd(struct send_ctx *sctx)
698{
699 int ret;
700 struct btrfs_cmd_header *hdr;
701 u32 crc;
702
703 hdr = (struct btrfs_cmd_header *)sctx->send_buf;
704 hdr->len = cpu_to_le32(sctx->send_size - sizeof(*hdr));
705 hdr->crc = 0;
706
Filipe David Borba Manana0b947af2014-01-29 21:06:04 +0000707 crc = btrfs_crc32c(0, (unsigned char *)sctx->send_buf, sctx->send_size);
Alexander Block31db9f72012-07-25 23:19:24 +0200708 hdr->crc = cpu_to_le32(crc);
709
Anand Jain1bcea352012-09-14 00:04:21 -0600710 ret = write_buf(sctx->send_filp, sctx->send_buf, sctx->send_size,
711 &sctx->send_off);
Alexander Block31db9f72012-07-25 23:19:24 +0200712
713 sctx->total_send_size += sctx->send_size;
714 sctx->cmd_send_size[le16_to_cpu(hdr->cmd)] += sctx->send_size;
715 sctx->send_size = 0;
716
717 return ret;
718}
719
720/*
721 * Sends a move instruction to user space
722 */
723static int send_rename(struct send_ctx *sctx,
724 struct fs_path *from, struct fs_path *to)
725{
Jeff Mahoney04ab9562016-09-20 10:05:03 -0400726 struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;
Alexander Block31db9f72012-07-25 23:19:24 +0200727 int ret;
728
Jeff Mahoney04ab9562016-09-20 10:05:03 -0400729 btrfs_debug(fs_info, "send_rename %s -> %s", from->start, to->start);
Alexander Block31db9f72012-07-25 23:19:24 +0200730
731 ret = begin_cmd(sctx, BTRFS_SEND_C_RENAME);
732 if (ret < 0)
733 goto out;
734
735 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, from);
736 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH_TO, to);
737
738 ret = send_cmd(sctx);
739
740tlv_put_failure:
741out:
742 return ret;
743}
744
745/*
746 * Sends a link instruction to user space
747 */
748static int send_link(struct send_ctx *sctx,
749 struct fs_path *path, struct fs_path *lnk)
750{
Jeff Mahoney04ab9562016-09-20 10:05:03 -0400751 struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;
Alexander Block31db9f72012-07-25 23:19:24 +0200752 int ret;
753
Jeff Mahoney04ab9562016-09-20 10:05:03 -0400754 btrfs_debug(fs_info, "send_link %s -> %s", path->start, lnk->start);
Alexander Block31db9f72012-07-25 23:19:24 +0200755
756 ret = begin_cmd(sctx, BTRFS_SEND_C_LINK);
757 if (ret < 0)
758 goto out;
759
760 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, path);
761 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH_LINK, lnk);
762
763 ret = send_cmd(sctx);
764
765tlv_put_failure:
766out:
767 return ret;
768}
769
770/*
771 * Sends an unlink instruction to user space
772 */
773static int send_unlink(struct send_ctx *sctx, struct fs_path *path)
774{
Jeff Mahoney04ab9562016-09-20 10:05:03 -0400775 struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;
Alexander Block31db9f72012-07-25 23:19:24 +0200776 int ret;
777
Jeff Mahoney04ab9562016-09-20 10:05:03 -0400778 btrfs_debug(fs_info, "send_unlink %s", path->start);
Alexander Block31db9f72012-07-25 23:19:24 +0200779
780 ret = begin_cmd(sctx, BTRFS_SEND_C_UNLINK);
781 if (ret < 0)
782 goto out;
783
784 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, path);
785
786 ret = send_cmd(sctx);
787
788tlv_put_failure:
789out:
790 return ret;
791}
792
793/*
794 * Sends a rmdir instruction to user space
795 */
796static int send_rmdir(struct send_ctx *sctx, struct fs_path *path)
797{
Jeff Mahoney04ab9562016-09-20 10:05:03 -0400798 struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;
Alexander Block31db9f72012-07-25 23:19:24 +0200799 int ret;
800
Jeff Mahoney04ab9562016-09-20 10:05:03 -0400801 btrfs_debug(fs_info, "send_rmdir %s", path->start);
Alexander Block31db9f72012-07-25 23:19:24 +0200802
803 ret = begin_cmd(sctx, BTRFS_SEND_C_RMDIR);
804 if (ret < 0)
805 goto out;
806
807 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, path);
808
809 ret = send_cmd(sctx);
810
811tlv_put_failure:
812out:
813 return ret;
814}
815
816/*
817 * Helper function to retrieve some fields from an inode item.
818 */
Josef Bacik3f8a18c2014-03-28 17:16:01 -0400819static int __get_inode_info(struct btrfs_root *root, struct btrfs_path *path,
820 u64 ino, u64 *size, u64 *gen, u64 *mode, u64 *uid,
821 u64 *gid, u64 *rdev)
Alexander Block31db9f72012-07-25 23:19:24 +0200822{
823 int ret;
824 struct btrfs_inode_item *ii;
825 struct btrfs_key key;
Alexander Block31db9f72012-07-25 23:19:24 +0200826
827 key.objectid = ino;
828 key.type = BTRFS_INODE_ITEM_KEY;
829 key.offset = 0;
830 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
Alexander Block31db9f72012-07-25 23:19:24 +0200831 if (ret) {
Josef Bacik3f8a18c2014-03-28 17:16:01 -0400832 if (ret > 0)
833 ret = -ENOENT;
834 return ret;
Alexander Block31db9f72012-07-25 23:19:24 +0200835 }
836
837 ii = btrfs_item_ptr(path->nodes[0], path->slots[0],
838 struct btrfs_inode_item);
839 if (size)
840 *size = btrfs_inode_size(path->nodes[0], ii);
841 if (gen)
842 *gen = btrfs_inode_generation(path->nodes[0], ii);
843 if (mode)
844 *mode = btrfs_inode_mode(path->nodes[0], ii);
845 if (uid)
846 *uid = btrfs_inode_uid(path->nodes[0], ii);
847 if (gid)
848 *gid = btrfs_inode_gid(path->nodes[0], ii);
Alexander Block85a7b332012-07-26 23:39:10 +0200849 if (rdev)
850 *rdev = btrfs_inode_rdev(path->nodes[0], ii);
Alexander Block31db9f72012-07-25 23:19:24 +0200851
Josef Bacik3f8a18c2014-03-28 17:16:01 -0400852 return ret;
853}
854
855static int get_inode_info(struct btrfs_root *root,
856 u64 ino, u64 *size, u64 *gen,
857 u64 *mode, u64 *uid, u64 *gid,
858 u64 *rdev)
859{
860 struct btrfs_path *path;
861 int ret;
862
863 path = alloc_path_for_send();
864 if (!path)
865 return -ENOMEM;
866 ret = __get_inode_info(root, path, ino, size, gen, mode, uid, gid,
867 rdev);
Alexander Block31db9f72012-07-25 23:19:24 +0200868 btrfs_free_path(path);
869 return ret;
870}
871
872typedef int (*iterate_inode_ref_t)(int num, u64 dir, int index,
873 struct fs_path *p,
874 void *ctx);
875
876/*
Jan Schmidt96b5bd72012-10-15 08:30:45 +0000877 * Helper function to iterate the entries in ONE btrfs_inode_ref or
878 * btrfs_inode_extref.
Alexander Block31db9f72012-07-25 23:19:24 +0200879 * The iterate callback may return a non zero value to stop iteration. This can
880 * be a negative value for error codes or 1 to simply stop it.
881 *
Jan Schmidt96b5bd72012-10-15 08:30:45 +0000882 * path must point to the INODE_REF or INODE_EXTREF when called.
Alexander Block31db9f72012-07-25 23:19:24 +0200883 */
Tsutomu Itoh924794c2013-05-08 07:51:52 +0000884static int iterate_inode_ref(struct btrfs_root *root, struct btrfs_path *path,
Alexander Block31db9f72012-07-25 23:19:24 +0200885 struct btrfs_key *found_key, int resolve,
886 iterate_inode_ref_t iterate, void *ctx)
887{
Jan Schmidt96b5bd72012-10-15 08:30:45 +0000888 struct extent_buffer *eb = path->nodes[0];
Alexander Block31db9f72012-07-25 23:19:24 +0200889 struct btrfs_item *item;
890 struct btrfs_inode_ref *iref;
Jan Schmidt96b5bd72012-10-15 08:30:45 +0000891 struct btrfs_inode_extref *extref;
Alexander Block31db9f72012-07-25 23:19:24 +0200892 struct btrfs_path *tmp_path;
893 struct fs_path *p;
Jan Schmidt96b5bd72012-10-15 08:30:45 +0000894 u32 cur = 0;
Alexander Block31db9f72012-07-25 23:19:24 +0200895 u32 total;
Jan Schmidt96b5bd72012-10-15 08:30:45 +0000896 int slot = path->slots[0];
Alexander Block31db9f72012-07-25 23:19:24 +0200897 u32 name_len;
898 char *start;
899 int ret = 0;
Jan Schmidt96b5bd72012-10-15 08:30:45 +0000900 int num = 0;
Alexander Block31db9f72012-07-25 23:19:24 +0200901 int index;
Jan Schmidt96b5bd72012-10-15 08:30:45 +0000902 u64 dir;
903 unsigned long name_off;
904 unsigned long elem_size;
905 unsigned long ptr;
Alexander Block31db9f72012-07-25 23:19:24 +0200906
Tsutomu Itoh924794c2013-05-08 07:51:52 +0000907 p = fs_path_alloc_reversed();
Alexander Block31db9f72012-07-25 23:19:24 +0200908 if (!p)
909 return -ENOMEM;
910
911 tmp_path = alloc_path_for_send();
912 if (!tmp_path) {
Tsutomu Itoh924794c2013-05-08 07:51:52 +0000913 fs_path_free(p);
Alexander Block31db9f72012-07-25 23:19:24 +0200914 return -ENOMEM;
915 }
916
Alexander Block31db9f72012-07-25 23:19:24 +0200917
Jan Schmidt96b5bd72012-10-15 08:30:45 +0000918 if (found_key->type == BTRFS_INODE_REF_KEY) {
919 ptr = (unsigned long)btrfs_item_ptr(eb, slot,
920 struct btrfs_inode_ref);
Ross Kirkdd3cc162013-09-16 15:58:09 +0100921 item = btrfs_item_nr(slot);
Jan Schmidt96b5bd72012-10-15 08:30:45 +0000922 total = btrfs_item_size(eb, item);
923 elem_size = sizeof(*iref);
924 } else {
925 ptr = btrfs_item_ptr_offset(eb, slot);
926 total = btrfs_item_size_nr(eb, slot);
927 elem_size = sizeof(*extref);
928 }
929
Alexander Block31db9f72012-07-25 23:19:24 +0200930 while (cur < total) {
931 fs_path_reset(p);
932
Jan Schmidt96b5bd72012-10-15 08:30:45 +0000933 if (found_key->type == BTRFS_INODE_REF_KEY) {
934 iref = (struct btrfs_inode_ref *)(ptr + cur);
935 name_len = btrfs_inode_ref_name_len(eb, iref);
936 name_off = (unsigned long)(iref + 1);
937 index = btrfs_inode_ref_index(eb, iref);
938 dir = found_key->offset;
939 } else {
940 extref = (struct btrfs_inode_extref *)(ptr + cur);
941 name_len = btrfs_inode_extref_name_len(eb, extref);
942 name_off = (unsigned long)&extref->name;
943 index = btrfs_inode_extref_index(eb, extref);
944 dir = btrfs_inode_extref_parent(eb, extref);
945 }
946
Alexander Block31db9f72012-07-25 23:19:24 +0200947 if (resolve) {
Jan Schmidt96b5bd72012-10-15 08:30:45 +0000948 start = btrfs_ref_to_path(root, tmp_path, name_len,
949 name_off, eb, dir,
950 p->buf, p->buf_len);
Alexander Block31db9f72012-07-25 23:19:24 +0200951 if (IS_ERR(start)) {
952 ret = PTR_ERR(start);
953 goto out;
954 }
955 if (start < p->buf) {
956 /* overflow , try again with larger buffer */
957 ret = fs_path_ensure_buf(p,
958 p->buf_len + p->buf - start);
959 if (ret < 0)
960 goto out;
Jan Schmidt96b5bd72012-10-15 08:30:45 +0000961 start = btrfs_ref_to_path(root, tmp_path,
962 name_len, name_off,
963 eb, dir,
964 p->buf, p->buf_len);
Alexander Block31db9f72012-07-25 23:19:24 +0200965 if (IS_ERR(start)) {
966 ret = PTR_ERR(start);
967 goto out;
968 }
969 BUG_ON(start < p->buf);
970 }
971 p->start = start;
972 } else {
Jan Schmidt96b5bd72012-10-15 08:30:45 +0000973 ret = fs_path_add_from_extent_buffer(p, eb, name_off,
974 name_len);
Alexander Block31db9f72012-07-25 23:19:24 +0200975 if (ret < 0)
976 goto out;
977 }
978
Jan Schmidt96b5bd72012-10-15 08:30:45 +0000979 cur += elem_size + name_len;
980 ret = iterate(num, dir, index, p, ctx);
Alexander Block31db9f72012-07-25 23:19:24 +0200981 if (ret)
982 goto out;
Alexander Block31db9f72012-07-25 23:19:24 +0200983 num++;
984 }
985
986out:
987 btrfs_free_path(tmp_path);
Tsutomu Itoh924794c2013-05-08 07:51:52 +0000988 fs_path_free(p);
Alexander Block31db9f72012-07-25 23:19:24 +0200989 return ret;
990}
991
992typedef int (*iterate_dir_item_t)(int num, struct btrfs_key *di_key,
993 const char *name, int name_len,
994 const char *data, int data_len,
995 u8 type, void *ctx);
996
997/*
998 * Helper function to iterate the entries in ONE btrfs_dir_item.
999 * The iterate callback may return a non zero value to stop iteration. This can
1000 * be a negative value for error codes or 1 to simply stop it.
1001 *
1002 * path must point to the dir item when called.
1003 */
Tsutomu Itoh924794c2013-05-08 07:51:52 +00001004static int iterate_dir_item(struct btrfs_root *root, struct btrfs_path *path,
Alexander Block31db9f72012-07-25 23:19:24 +02001005 struct btrfs_key *found_key,
1006 iterate_dir_item_t iterate, void *ctx)
1007{
1008 int ret = 0;
1009 struct extent_buffer *eb;
1010 struct btrfs_item *item;
1011 struct btrfs_dir_item *di;
Alexander Block31db9f72012-07-25 23:19:24 +02001012 struct btrfs_key di_key;
1013 char *buf = NULL;
Filipe Manana7e3ae332014-05-23 20:15:16 +01001014 int buf_len;
Alexander Block31db9f72012-07-25 23:19:24 +02001015 u32 name_len;
1016 u32 data_len;
1017 u32 cur;
1018 u32 len;
1019 u32 total;
1020 int slot;
1021 int num;
1022 u8 type;
1023
Filipe Manana4395e0c2014-08-20 10:45:45 +01001024 /*
1025 * Start with a small buffer (1 page). If later we end up needing more
1026 * space, which can happen for xattrs on a fs with a leaf size greater
1027 * then the page size, attempt to increase the buffer. Typically xattr
1028 * values are small.
1029 */
1030 buf_len = PATH_MAX;
David Sterbae780b0d2016-01-18 18:42:13 +01001031 buf = kmalloc(buf_len, GFP_KERNEL);
Alexander Block31db9f72012-07-25 23:19:24 +02001032 if (!buf) {
1033 ret = -ENOMEM;
1034 goto out;
1035 }
1036
Alexander Block31db9f72012-07-25 23:19:24 +02001037 eb = path->nodes[0];
1038 slot = path->slots[0];
Ross Kirkdd3cc162013-09-16 15:58:09 +01001039 item = btrfs_item_nr(slot);
Alexander Block31db9f72012-07-25 23:19:24 +02001040 di = btrfs_item_ptr(eb, slot, struct btrfs_dir_item);
1041 cur = 0;
1042 len = 0;
1043 total = btrfs_item_size(eb, item);
1044
1045 num = 0;
1046 while (cur < total) {
1047 name_len = btrfs_dir_name_len(eb, di);
1048 data_len = btrfs_dir_data_len(eb, di);
1049 type = btrfs_dir_type(eb, di);
1050 btrfs_dir_item_key_to_cpu(eb, di, &di_key);
1051
Filipe Manana7e3ae332014-05-23 20:15:16 +01001052 if (type == BTRFS_FT_XATTR) {
1053 if (name_len > XATTR_NAME_MAX) {
1054 ret = -ENAMETOOLONG;
1055 goto out;
1056 }
Jeff Mahoneyda170662016-06-15 09:22:56 -04001057 if (name_len + data_len >
1058 BTRFS_MAX_XATTR_SIZE(root->fs_info)) {
Filipe Manana7e3ae332014-05-23 20:15:16 +01001059 ret = -E2BIG;
1060 goto out;
1061 }
1062 } else {
1063 /*
1064 * Path too long
1065 */
Filipe Manana4395e0c2014-08-20 10:45:45 +01001066 if (name_len + data_len > PATH_MAX) {
Filipe Manana7e3ae332014-05-23 20:15:16 +01001067 ret = -ENAMETOOLONG;
1068 goto out;
1069 }
Alexander Block31db9f72012-07-25 23:19:24 +02001070 }
1071
Filipe Manana4395e0c2014-08-20 10:45:45 +01001072 if (name_len + data_len > buf_len) {
1073 buf_len = name_len + data_len;
1074 if (is_vmalloc_addr(buf)) {
1075 vfree(buf);
1076 buf = NULL;
1077 } else {
1078 char *tmp = krealloc(buf, buf_len,
David Sterbae780b0d2016-01-18 18:42:13 +01001079 GFP_KERNEL | __GFP_NOWARN);
Filipe Manana4395e0c2014-08-20 10:45:45 +01001080
1081 if (!tmp)
1082 kfree(buf);
1083 buf = tmp;
1084 }
1085 if (!buf) {
David Sterbaf11f7442017-05-31 18:40:02 +02001086 buf = kvmalloc(buf_len, GFP_KERNEL);
Filipe Manana4395e0c2014-08-20 10:45:45 +01001087 if (!buf) {
1088 ret = -ENOMEM;
1089 goto out;
1090 }
1091 }
1092 }
1093
Alexander Block31db9f72012-07-25 23:19:24 +02001094 read_extent_buffer(eb, buf, (unsigned long)(di + 1),
1095 name_len + data_len);
1096
1097 len = sizeof(*di) + name_len + data_len;
1098 di = (struct btrfs_dir_item *)((char *)di + len);
1099 cur += len;
1100
1101 ret = iterate(num, &di_key, buf, name_len, buf + name_len,
1102 data_len, type, ctx);
1103 if (ret < 0)
1104 goto out;
1105 if (ret) {
1106 ret = 0;
1107 goto out;
1108 }
1109
1110 num++;
1111 }
1112
1113out:
Filipe Manana4395e0c2014-08-20 10:45:45 +01001114 kvfree(buf);
Alexander Block31db9f72012-07-25 23:19:24 +02001115 return ret;
1116}
1117
1118static int __copy_first_ref(int num, u64 dir, int index,
1119 struct fs_path *p, void *ctx)
1120{
1121 int ret;
1122 struct fs_path *pt = ctx;
1123
1124 ret = fs_path_copy(pt, p);
1125 if (ret < 0)
1126 return ret;
1127
1128 /* we want the first only */
1129 return 1;
1130}
1131
1132/*
1133 * Retrieve the first path of an inode. If an inode has more then one
1134 * ref/hardlink, this is ignored.
1135 */
Tsutomu Itoh924794c2013-05-08 07:51:52 +00001136static int get_inode_path(struct btrfs_root *root,
Alexander Block31db9f72012-07-25 23:19:24 +02001137 u64 ino, struct fs_path *path)
1138{
1139 int ret;
1140 struct btrfs_key key, found_key;
1141 struct btrfs_path *p;
1142
1143 p = alloc_path_for_send();
1144 if (!p)
1145 return -ENOMEM;
1146
1147 fs_path_reset(path);
1148
1149 key.objectid = ino;
1150 key.type = BTRFS_INODE_REF_KEY;
1151 key.offset = 0;
1152
1153 ret = btrfs_search_slot_for_read(root, &key, p, 1, 0);
1154 if (ret < 0)
1155 goto out;
1156 if (ret) {
1157 ret = 1;
1158 goto out;
1159 }
1160 btrfs_item_key_to_cpu(p->nodes[0], &found_key, p->slots[0]);
1161 if (found_key.objectid != ino ||
Jan Schmidt96b5bd72012-10-15 08:30:45 +00001162 (found_key.type != BTRFS_INODE_REF_KEY &&
1163 found_key.type != BTRFS_INODE_EXTREF_KEY)) {
Alexander Block31db9f72012-07-25 23:19:24 +02001164 ret = -ENOENT;
1165 goto out;
1166 }
1167
Tsutomu Itoh924794c2013-05-08 07:51:52 +00001168 ret = iterate_inode_ref(root, p, &found_key, 1,
1169 __copy_first_ref, path);
Alexander Block31db9f72012-07-25 23:19:24 +02001170 if (ret < 0)
1171 goto out;
1172 ret = 0;
1173
1174out:
1175 btrfs_free_path(p);
1176 return ret;
1177}
1178
1179struct backref_ctx {
1180 struct send_ctx *sctx;
1181
Josef Bacik3f8a18c2014-03-28 17:16:01 -04001182 struct btrfs_path *path;
Alexander Block31db9f72012-07-25 23:19:24 +02001183 /* number of total found references */
1184 u64 found;
1185
1186 /*
1187 * used for clones found in send_root. clones found behind cur_objectid
1188 * and cur_offset are not considered as allowed clones.
1189 */
1190 u64 cur_objectid;
1191 u64 cur_offset;
1192
1193 /* may be truncated in case it's the last extent in a file */
1194 u64 extent_len;
1195
Filipe Manana619d8c42015-05-03 01:56:00 +01001196 /* data offset in the file extent item */
1197 u64 data_offset;
1198
Alexander Block31db9f72012-07-25 23:19:24 +02001199 /* Just to check for bugs in backref resolving */
Alexander Blockee849c02012-07-28 12:42:05 +02001200 int found_itself;
Alexander Block31db9f72012-07-25 23:19:24 +02001201};
1202
1203static int __clone_root_cmp_bsearch(const void *key, const void *elt)
1204{
Jan Schmidt995e01b2012-08-13 02:52:38 -06001205 u64 root = (u64)(uintptr_t)key;
Alexander Block31db9f72012-07-25 23:19:24 +02001206 struct clone_root *cr = (struct clone_root *)elt;
1207
1208 if (root < cr->root->objectid)
1209 return -1;
1210 if (root > cr->root->objectid)
1211 return 1;
1212 return 0;
1213}
1214
1215static int __clone_root_cmp_sort(const void *e1, const void *e2)
1216{
1217 struct clone_root *cr1 = (struct clone_root *)e1;
1218 struct clone_root *cr2 = (struct clone_root *)e2;
1219
1220 if (cr1->root->objectid < cr2->root->objectid)
1221 return -1;
1222 if (cr1->root->objectid > cr2->root->objectid)
1223 return 1;
1224 return 0;
1225}
1226
1227/*
1228 * Called for every backref that is found for the current extent.
Alexander Block766702e2012-07-28 14:11:31 +02001229 * Results are collected in sctx->clone_roots->ino/offset/found_refs
Alexander Block31db9f72012-07-25 23:19:24 +02001230 */
1231static int __iterate_backrefs(u64 ino, u64 offset, u64 root, void *ctx_)
1232{
1233 struct backref_ctx *bctx = ctx_;
1234 struct clone_root *found;
1235 int ret;
1236 u64 i_size;
1237
1238 /* First check if the root is in the list of accepted clone sources */
Jan Schmidt995e01b2012-08-13 02:52:38 -06001239 found = bsearch((void *)(uintptr_t)root, bctx->sctx->clone_roots,
Alexander Block31db9f72012-07-25 23:19:24 +02001240 bctx->sctx->clone_roots_cnt,
1241 sizeof(struct clone_root),
1242 __clone_root_cmp_bsearch);
1243 if (!found)
1244 return 0;
1245
1246 if (found->root == bctx->sctx->send_root &&
1247 ino == bctx->cur_objectid &&
1248 offset == bctx->cur_offset) {
Alexander Blockee849c02012-07-28 12:42:05 +02001249 bctx->found_itself = 1;
Alexander Block31db9f72012-07-25 23:19:24 +02001250 }
1251
1252 /*
Alexander Block766702e2012-07-28 14:11:31 +02001253 * There are inodes that have extents that lie behind its i_size. Don't
Alexander Block31db9f72012-07-25 23:19:24 +02001254 * accept clones from these extents.
1255 */
Josef Bacik3f8a18c2014-03-28 17:16:01 -04001256 ret = __get_inode_info(found->root, bctx->path, ino, &i_size, NULL, NULL,
1257 NULL, NULL, NULL);
1258 btrfs_release_path(bctx->path);
Alexander Block31db9f72012-07-25 23:19:24 +02001259 if (ret < 0)
1260 return ret;
1261
Filipe Manana619d8c42015-05-03 01:56:00 +01001262 if (offset + bctx->data_offset + bctx->extent_len > i_size)
Alexander Block31db9f72012-07-25 23:19:24 +02001263 return 0;
1264
1265 /*
1266 * Make sure we don't consider clones from send_root that are
1267 * behind the current inode/offset.
1268 */
1269 if (found->root == bctx->sctx->send_root) {
1270 /*
1271 * TODO for the moment we don't accept clones from the inode
1272 * that is currently send. We may change this when
1273 * BTRFS_IOC_CLONE_RANGE supports cloning from and to the same
1274 * file.
1275 */
1276 if (ino >= bctx->cur_objectid)
1277 return 0;
Alexander Blocke938c8a2012-07-28 16:33:49 +02001278#if 0
1279 if (ino > bctx->cur_objectid)
Alexander Block31db9f72012-07-25 23:19:24 +02001280 return 0;
Alexander Blocke938c8a2012-07-28 16:33:49 +02001281 if (offset + bctx->extent_len > bctx->cur_offset)
1282 return 0;
1283#endif
Alexander Block31db9f72012-07-25 23:19:24 +02001284 }
1285
1286 bctx->found++;
1287 found->found_refs++;
1288 if (ino < found->ino) {
1289 found->ino = ino;
1290 found->offset = offset;
1291 } else if (found->ino == ino) {
1292 /*
1293 * same extent found more then once in the same file.
1294 */
1295 if (found->offset > offset + bctx->extent_len)
1296 found->offset = offset;
1297 }
1298
1299 return 0;
1300}
1301
1302/*
Alexander Block766702e2012-07-28 14:11:31 +02001303 * Given an inode, offset and extent item, it finds a good clone for a clone
1304 * instruction. Returns -ENOENT when none could be found. The function makes
1305 * sure that the returned clone is usable at the point where sending is at the
1306 * moment. This means, that no clones are accepted which lie behind the current
1307 * inode+offset.
1308 *
Alexander Block31db9f72012-07-25 23:19:24 +02001309 * path must point to the extent item when called.
1310 */
1311static int find_extent_clone(struct send_ctx *sctx,
1312 struct btrfs_path *path,
1313 u64 ino, u64 data_offset,
1314 u64 ino_size,
1315 struct clone_root **found)
1316{
Jeff Mahoney04ab9562016-09-20 10:05:03 -04001317 struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;
Alexander Block31db9f72012-07-25 23:19:24 +02001318 int ret;
1319 int extent_type;
1320 u64 logical;
Chris Mason74dd17f2012-08-07 16:25:13 -04001321 u64 disk_byte;
Alexander Block31db9f72012-07-25 23:19:24 +02001322 u64 num_bytes;
1323 u64 extent_item_pos;
Liu Bo69917e42012-09-07 20:01:28 -06001324 u64 flags = 0;
Alexander Block31db9f72012-07-25 23:19:24 +02001325 struct btrfs_file_extent_item *fi;
1326 struct extent_buffer *eb = path->nodes[0];
Alexander Block35075bb2012-07-28 12:44:34 +02001327 struct backref_ctx *backref_ctx = NULL;
Alexander Block31db9f72012-07-25 23:19:24 +02001328 struct clone_root *cur_clone_root;
1329 struct btrfs_key found_key;
1330 struct btrfs_path *tmp_path;
Chris Mason74dd17f2012-08-07 16:25:13 -04001331 int compressed;
Alexander Block31db9f72012-07-25 23:19:24 +02001332 u32 i;
1333
1334 tmp_path = alloc_path_for_send();
1335 if (!tmp_path)
1336 return -ENOMEM;
1337
Josef Bacik3f8a18c2014-03-28 17:16:01 -04001338 /* We only use this path under the commit sem */
1339 tmp_path->need_commit_sem = 0;
1340
David Sterbae780b0d2016-01-18 18:42:13 +01001341 backref_ctx = kmalloc(sizeof(*backref_ctx), GFP_KERNEL);
Alexander Block35075bb2012-07-28 12:44:34 +02001342 if (!backref_ctx) {
1343 ret = -ENOMEM;
1344 goto out;
1345 }
1346
Josef Bacik3f8a18c2014-03-28 17:16:01 -04001347 backref_ctx->path = tmp_path;
1348
Alexander Block31db9f72012-07-25 23:19:24 +02001349 if (data_offset >= ino_size) {
1350 /*
1351 * There may be extents that lie behind the file's size.
1352 * I at least had this in combination with snapshotting while
1353 * writing large files.
1354 */
1355 ret = 0;
1356 goto out;
1357 }
1358
1359 fi = btrfs_item_ptr(eb, path->slots[0],
1360 struct btrfs_file_extent_item);
1361 extent_type = btrfs_file_extent_type(eb, fi);
1362 if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
1363 ret = -ENOENT;
1364 goto out;
1365 }
Chris Mason74dd17f2012-08-07 16:25:13 -04001366 compressed = btrfs_file_extent_compression(eb, fi);
Alexander Block31db9f72012-07-25 23:19:24 +02001367
1368 num_bytes = btrfs_file_extent_num_bytes(eb, fi);
Chris Mason74dd17f2012-08-07 16:25:13 -04001369 disk_byte = btrfs_file_extent_disk_bytenr(eb, fi);
1370 if (disk_byte == 0) {
Alexander Block31db9f72012-07-25 23:19:24 +02001371 ret = -ENOENT;
1372 goto out;
1373 }
Chris Mason74dd17f2012-08-07 16:25:13 -04001374 logical = disk_byte + btrfs_file_extent_offset(eb, fi);
Alexander Block31db9f72012-07-25 23:19:24 +02001375
Jeff Mahoney04ab9562016-09-20 10:05:03 -04001376 down_read(&fs_info->commit_root_sem);
1377 ret = extent_from_logical(fs_info, disk_byte, tmp_path,
Liu Bo69917e42012-09-07 20:01:28 -06001378 &found_key, &flags);
Jeff Mahoney04ab9562016-09-20 10:05:03 -04001379 up_read(&fs_info->commit_root_sem);
Alexander Block31db9f72012-07-25 23:19:24 +02001380 btrfs_release_path(tmp_path);
1381
1382 if (ret < 0)
1383 goto out;
Liu Bo69917e42012-09-07 20:01:28 -06001384 if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
Alexander Block31db9f72012-07-25 23:19:24 +02001385 ret = -EIO;
1386 goto out;
1387 }
1388
1389 /*
1390 * Setup the clone roots.
1391 */
1392 for (i = 0; i < sctx->clone_roots_cnt; i++) {
1393 cur_clone_root = sctx->clone_roots + i;
1394 cur_clone_root->ino = (u64)-1;
1395 cur_clone_root->offset = 0;
1396 cur_clone_root->found_refs = 0;
1397 }
1398
Alexander Block35075bb2012-07-28 12:44:34 +02001399 backref_ctx->sctx = sctx;
1400 backref_ctx->found = 0;
1401 backref_ctx->cur_objectid = ino;
1402 backref_ctx->cur_offset = data_offset;
1403 backref_ctx->found_itself = 0;
1404 backref_ctx->extent_len = num_bytes;
Filipe Manana619d8c42015-05-03 01:56:00 +01001405 /*
1406 * For non-compressed extents iterate_extent_inodes() gives us extent
1407 * offsets that already take into account the data offset, but not for
1408 * compressed extents, since the offset is logical and not relative to
1409 * the physical extent locations. We must take this into account to
1410 * avoid sending clone offsets that go beyond the source file's size,
1411 * which would result in the clone ioctl failing with -EINVAL on the
1412 * receiving end.
1413 */
1414 if (compressed == BTRFS_COMPRESS_NONE)
1415 backref_ctx->data_offset = 0;
1416 else
1417 backref_ctx->data_offset = btrfs_file_extent_offset(eb, fi);
Alexander Block31db9f72012-07-25 23:19:24 +02001418
1419 /*
1420 * The last extent of a file may be too large due to page alignment.
1421 * We need to adjust extent_len in this case so that the checks in
1422 * __iterate_backrefs work.
1423 */
1424 if (data_offset + num_bytes >= ino_size)
Alexander Block35075bb2012-07-28 12:44:34 +02001425 backref_ctx->extent_len = ino_size - data_offset;
Alexander Block31db9f72012-07-25 23:19:24 +02001426
1427 /*
1428 * Now collect all backrefs.
1429 */
Chris Mason74dd17f2012-08-07 16:25:13 -04001430 if (compressed == BTRFS_COMPRESS_NONE)
1431 extent_item_pos = logical - found_key.objectid;
1432 else
1433 extent_item_pos = 0;
Jeff Mahoney0b246af2016-06-22 18:54:23 -04001434 ret = iterate_extent_inodes(fs_info, found_key.objectid,
1435 extent_item_pos, 1, __iterate_backrefs,
1436 backref_ctx);
Chris Mason74dd17f2012-08-07 16:25:13 -04001437
Alexander Block31db9f72012-07-25 23:19:24 +02001438 if (ret < 0)
1439 goto out;
1440
Alexander Block35075bb2012-07-28 12:44:34 +02001441 if (!backref_ctx->found_itself) {
Alexander Block31db9f72012-07-25 23:19:24 +02001442 /* found a bug in backref code? */
1443 ret = -EIO;
Jeff Mahoney04ab9562016-09-20 10:05:03 -04001444 btrfs_err(fs_info,
Jeff Mahoney5d163e02016-09-20 10:05:00 -04001445 "did not find backref in send_root. inode=%llu, offset=%llu, disk_byte=%llu found extent=%llu",
Jeff Mahoney04ab9562016-09-20 10:05:03 -04001446 ino, data_offset, disk_byte, found_key.objectid);
Alexander Block31db9f72012-07-25 23:19:24 +02001447 goto out;
1448 }
1449
Jeff Mahoney04ab9562016-09-20 10:05:03 -04001450 btrfs_debug(fs_info,
1451 "find_extent_clone: data_offset=%llu, ino=%llu, num_bytes=%llu, logical=%llu",
1452 data_offset, ino, num_bytes, logical);
Alexander Block31db9f72012-07-25 23:19:24 +02001453
Alexander Block35075bb2012-07-28 12:44:34 +02001454 if (!backref_ctx->found)
Jeff Mahoney04ab9562016-09-20 10:05:03 -04001455 btrfs_debug(fs_info, "no clones found");
Alexander Block31db9f72012-07-25 23:19:24 +02001456
1457 cur_clone_root = NULL;
1458 for (i = 0; i < sctx->clone_roots_cnt; i++) {
1459 if (sctx->clone_roots[i].found_refs) {
1460 if (!cur_clone_root)
1461 cur_clone_root = sctx->clone_roots + i;
1462 else if (sctx->clone_roots[i].root == sctx->send_root)
1463 /* prefer clones from send_root over others */
1464 cur_clone_root = sctx->clone_roots + i;
Alexander Block31db9f72012-07-25 23:19:24 +02001465 }
1466
1467 }
1468
1469 if (cur_clone_root) {
1470 *found = cur_clone_root;
1471 ret = 0;
1472 } else {
1473 ret = -ENOENT;
1474 }
1475
1476out:
1477 btrfs_free_path(tmp_path);
Alexander Block35075bb2012-07-28 12:44:34 +02001478 kfree(backref_ctx);
Alexander Block31db9f72012-07-25 23:19:24 +02001479 return ret;
1480}
1481
Tsutomu Itoh924794c2013-05-08 07:51:52 +00001482static int read_symlink(struct btrfs_root *root,
Alexander Block31db9f72012-07-25 23:19:24 +02001483 u64 ino,
1484 struct fs_path *dest)
1485{
1486 int ret;
1487 struct btrfs_path *path;
1488 struct btrfs_key key;
1489 struct btrfs_file_extent_item *ei;
1490 u8 type;
1491 u8 compression;
1492 unsigned long off;
1493 int len;
1494
1495 path = alloc_path_for_send();
1496 if (!path)
1497 return -ENOMEM;
1498
1499 key.objectid = ino;
1500 key.type = BTRFS_EXTENT_DATA_KEY;
1501 key.offset = 0;
1502 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1503 if (ret < 0)
1504 goto out;
Filipe Mananaa8797192015-12-31 18:07:59 +00001505 if (ret) {
1506 /*
1507 * An empty symlink inode. Can happen in rare error paths when
1508 * creating a symlink (transaction committed before the inode
1509 * eviction handler removed the symlink inode items and a crash
1510 * happened in between or the subvol was snapshoted in between).
1511 * Print an informative message to dmesg/syslog so that the user
1512 * can delete the symlink.
1513 */
1514 btrfs_err(root->fs_info,
1515 "Found empty symlink inode %llu at root %llu",
1516 ino, root->root_key.objectid);
1517 ret = -EIO;
1518 goto out;
1519 }
Alexander Block31db9f72012-07-25 23:19:24 +02001520
1521 ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
1522 struct btrfs_file_extent_item);
1523 type = btrfs_file_extent_type(path->nodes[0], ei);
1524 compression = btrfs_file_extent_compression(path->nodes[0], ei);
1525 BUG_ON(type != BTRFS_FILE_EXTENT_INLINE);
1526 BUG_ON(compression);
1527
1528 off = btrfs_file_extent_inline_start(ei);
Chris Mason514ac8a2014-01-03 21:07:00 -08001529 len = btrfs_file_extent_inline_len(path->nodes[0], path->slots[0], ei);
Alexander Block31db9f72012-07-25 23:19:24 +02001530
1531 ret = fs_path_add_from_extent_buffer(dest, path->nodes[0], off, len);
Alexander Block31db9f72012-07-25 23:19:24 +02001532
1533out:
1534 btrfs_free_path(path);
1535 return ret;
1536}
1537
1538/*
1539 * Helper function to generate a file name that is unique in the root of
1540 * send_root and parent_root. This is used to generate names for orphan inodes.
1541 */
1542static int gen_unique_name(struct send_ctx *sctx,
1543 u64 ino, u64 gen,
1544 struct fs_path *dest)
1545{
1546 int ret = 0;
1547 struct btrfs_path *path;
1548 struct btrfs_dir_item *di;
1549 char tmp[64];
1550 int len;
1551 u64 idx = 0;
1552
1553 path = alloc_path_for_send();
1554 if (!path)
1555 return -ENOMEM;
1556
1557 while (1) {
Filipe David Borba Mananaf74b86d2014-01-21 23:36:38 +00001558 len = snprintf(tmp, sizeof(tmp), "o%llu-%llu-%llu",
Alexander Block31db9f72012-07-25 23:19:24 +02001559 ino, gen, idx);
David Sterba64792f22014-02-03 18:24:09 +01001560 ASSERT(len < sizeof(tmp));
Alexander Block31db9f72012-07-25 23:19:24 +02001561
1562 di = btrfs_lookup_dir_item(NULL, sctx->send_root,
1563 path, BTRFS_FIRST_FREE_OBJECTID,
1564 tmp, strlen(tmp), 0);
1565 btrfs_release_path(path);
1566 if (IS_ERR(di)) {
1567 ret = PTR_ERR(di);
1568 goto out;
1569 }
1570 if (di) {
1571 /* not unique, try again */
1572 idx++;
1573 continue;
1574 }
1575
1576 if (!sctx->parent_root) {
1577 /* unique */
1578 ret = 0;
1579 break;
1580 }
1581
1582 di = btrfs_lookup_dir_item(NULL, sctx->parent_root,
1583 path, BTRFS_FIRST_FREE_OBJECTID,
1584 tmp, strlen(tmp), 0);
1585 btrfs_release_path(path);
1586 if (IS_ERR(di)) {
1587 ret = PTR_ERR(di);
1588 goto out;
1589 }
1590 if (di) {
1591 /* not unique, try again */
1592 idx++;
1593 continue;
1594 }
1595 /* unique */
1596 break;
1597 }
1598
1599 ret = fs_path_add(dest, tmp, strlen(tmp));
1600
1601out:
1602 btrfs_free_path(path);
1603 return ret;
1604}
1605
1606enum inode_state {
1607 inode_state_no_change,
1608 inode_state_will_create,
1609 inode_state_did_create,
1610 inode_state_will_delete,
1611 inode_state_did_delete,
1612};
1613
1614static int get_cur_inode_state(struct send_ctx *sctx, u64 ino, u64 gen)
1615{
1616 int ret;
1617 int left_ret;
1618 int right_ret;
1619 u64 left_gen;
1620 u64 right_gen;
1621
1622 ret = get_inode_info(sctx->send_root, ino, NULL, &left_gen, NULL, NULL,
Alexander Block85a7b332012-07-26 23:39:10 +02001623 NULL, NULL);
Alexander Block31db9f72012-07-25 23:19:24 +02001624 if (ret < 0 && ret != -ENOENT)
1625 goto out;
1626 left_ret = ret;
1627
1628 if (!sctx->parent_root) {
1629 right_ret = -ENOENT;
1630 } else {
1631 ret = get_inode_info(sctx->parent_root, ino, NULL, &right_gen,
Alexander Block85a7b332012-07-26 23:39:10 +02001632 NULL, NULL, NULL, NULL);
Alexander Block31db9f72012-07-25 23:19:24 +02001633 if (ret < 0 && ret != -ENOENT)
1634 goto out;
1635 right_ret = ret;
1636 }
1637
1638 if (!left_ret && !right_ret) {
Alexander Blocke938c8a2012-07-28 16:33:49 +02001639 if (left_gen == gen && right_gen == gen) {
Alexander Block31db9f72012-07-25 23:19:24 +02001640 ret = inode_state_no_change;
Alexander Blocke938c8a2012-07-28 16:33:49 +02001641 } else if (left_gen == gen) {
Alexander Block31db9f72012-07-25 23:19:24 +02001642 if (ino < sctx->send_progress)
1643 ret = inode_state_did_create;
1644 else
1645 ret = inode_state_will_create;
1646 } else if (right_gen == gen) {
1647 if (ino < sctx->send_progress)
1648 ret = inode_state_did_delete;
1649 else
1650 ret = inode_state_will_delete;
1651 } else {
1652 ret = -ENOENT;
1653 }
1654 } else if (!left_ret) {
1655 if (left_gen == gen) {
1656 if (ino < sctx->send_progress)
1657 ret = inode_state_did_create;
1658 else
1659 ret = inode_state_will_create;
1660 } else {
1661 ret = -ENOENT;
1662 }
1663 } else if (!right_ret) {
1664 if (right_gen == gen) {
1665 if (ino < sctx->send_progress)
1666 ret = inode_state_did_delete;
1667 else
1668 ret = inode_state_will_delete;
1669 } else {
1670 ret = -ENOENT;
1671 }
1672 } else {
1673 ret = -ENOENT;
1674 }
1675
1676out:
1677 return ret;
1678}
1679
1680static int is_inode_existent(struct send_ctx *sctx, u64 ino, u64 gen)
1681{
1682 int ret;
1683
Robbie Ko4dd99202017-01-05 16:24:55 +08001684 if (ino == BTRFS_FIRST_FREE_OBJECTID)
1685 return 1;
1686
Alexander Block31db9f72012-07-25 23:19:24 +02001687 ret = get_cur_inode_state(sctx, ino, gen);
1688 if (ret < 0)
1689 goto out;
1690
1691 if (ret == inode_state_no_change ||
1692 ret == inode_state_did_create ||
1693 ret == inode_state_will_delete)
1694 ret = 1;
1695 else
1696 ret = 0;
1697
1698out:
1699 return ret;
1700}
1701
1702/*
1703 * Helper function to lookup a dir item in a dir.
1704 */
1705static int lookup_dir_item_inode(struct btrfs_root *root,
1706 u64 dir, const char *name, int name_len,
1707 u64 *found_inode,
1708 u8 *found_type)
1709{
1710 int ret = 0;
1711 struct btrfs_dir_item *di;
1712 struct btrfs_key key;
1713 struct btrfs_path *path;
1714
1715 path = alloc_path_for_send();
1716 if (!path)
1717 return -ENOMEM;
1718
1719 di = btrfs_lookup_dir_item(NULL, root, path,
1720 dir, name, name_len, 0);
1721 if (!di) {
1722 ret = -ENOENT;
1723 goto out;
1724 }
1725 if (IS_ERR(di)) {
1726 ret = PTR_ERR(di);
1727 goto out;
1728 }
1729 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &key);
Filipe Manana1af56072014-05-25 04:49:24 +01001730 if (key.type == BTRFS_ROOT_ITEM_KEY) {
1731 ret = -ENOENT;
1732 goto out;
1733 }
Alexander Block31db9f72012-07-25 23:19:24 +02001734 *found_inode = key.objectid;
1735 *found_type = btrfs_dir_type(path->nodes[0], di);
1736
1737out:
1738 btrfs_free_path(path);
1739 return ret;
1740}
1741
Alexander Block766702e2012-07-28 14:11:31 +02001742/*
1743 * Looks up the first btrfs_inode_ref of a given ino. It returns the parent dir,
1744 * generation of the parent dir and the name of the dir entry.
1745 */
Tsutomu Itoh924794c2013-05-08 07:51:52 +00001746static int get_first_ref(struct btrfs_root *root, u64 ino,
Alexander Block31db9f72012-07-25 23:19:24 +02001747 u64 *dir, u64 *dir_gen, struct fs_path *name)
1748{
1749 int ret;
1750 struct btrfs_key key;
1751 struct btrfs_key found_key;
1752 struct btrfs_path *path;
Alexander Block31db9f72012-07-25 23:19:24 +02001753 int len;
Jan Schmidt96b5bd72012-10-15 08:30:45 +00001754 u64 parent_dir;
Alexander Block31db9f72012-07-25 23:19:24 +02001755
1756 path = alloc_path_for_send();
1757 if (!path)
1758 return -ENOMEM;
1759
1760 key.objectid = ino;
1761 key.type = BTRFS_INODE_REF_KEY;
1762 key.offset = 0;
1763
1764 ret = btrfs_search_slot_for_read(root, &key, path, 1, 0);
1765 if (ret < 0)
1766 goto out;
1767 if (!ret)
1768 btrfs_item_key_to_cpu(path->nodes[0], &found_key,
1769 path->slots[0]);
Jan Schmidt96b5bd72012-10-15 08:30:45 +00001770 if (ret || found_key.objectid != ino ||
1771 (found_key.type != BTRFS_INODE_REF_KEY &&
1772 found_key.type != BTRFS_INODE_EXTREF_KEY)) {
Alexander Block31db9f72012-07-25 23:19:24 +02001773 ret = -ENOENT;
1774 goto out;
1775 }
1776
Filipe Manana51a60252014-05-13 22:01:02 +01001777 if (found_key.type == BTRFS_INODE_REF_KEY) {
Jan Schmidt96b5bd72012-10-15 08:30:45 +00001778 struct btrfs_inode_ref *iref;
1779 iref = btrfs_item_ptr(path->nodes[0], path->slots[0],
1780 struct btrfs_inode_ref);
1781 len = btrfs_inode_ref_name_len(path->nodes[0], iref);
1782 ret = fs_path_add_from_extent_buffer(name, path->nodes[0],
1783 (unsigned long)(iref + 1),
1784 len);
1785 parent_dir = found_key.offset;
1786 } else {
1787 struct btrfs_inode_extref *extref;
1788 extref = btrfs_item_ptr(path->nodes[0], path->slots[0],
1789 struct btrfs_inode_extref);
1790 len = btrfs_inode_extref_name_len(path->nodes[0], extref);
1791 ret = fs_path_add_from_extent_buffer(name, path->nodes[0],
1792 (unsigned long)&extref->name, len);
1793 parent_dir = btrfs_inode_extref_parent(path->nodes[0], extref);
1794 }
Alexander Block31db9f72012-07-25 23:19:24 +02001795 if (ret < 0)
1796 goto out;
1797 btrfs_release_path(path);
1798
Filipe Mananab46ab972014-03-21 12:46:54 +00001799 if (dir_gen) {
1800 ret = get_inode_info(root, parent_dir, NULL, dir_gen, NULL,
1801 NULL, NULL, NULL);
1802 if (ret < 0)
1803 goto out;
1804 }
Alexander Block31db9f72012-07-25 23:19:24 +02001805
Jan Schmidt96b5bd72012-10-15 08:30:45 +00001806 *dir = parent_dir;
Alexander Block31db9f72012-07-25 23:19:24 +02001807
1808out:
1809 btrfs_free_path(path);
1810 return ret;
1811}
1812
Tsutomu Itoh924794c2013-05-08 07:51:52 +00001813static int is_first_ref(struct btrfs_root *root,
Alexander Block31db9f72012-07-25 23:19:24 +02001814 u64 ino, u64 dir,
1815 const char *name, int name_len)
1816{
1817 int ret;
1818 struct fs_path *tmp_name;
1819 u64 tmp_dir;
Alexander Block31db9f72012-07-25 23:19:24 +02001820
Tsutomu Itoh924794c2013-05-08 07:51:52 +00001821 tmp_name = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +02001822 if (!tmp_name)
1823 return -ENOMEM;
1824
Filipe Mananab46ab972014-03-21 12:46:54 +00001825 ret = get_first_ref(root, ino, &tmp_dir, NULL, tmp_name);
Alexander Block31db9f72012-07-25 23:19:24 +02001826 if (ret < 0)
1827 goto out;
1828
Alexander Blockb9291af2012-07-28 11:07:18 +02001829 if (dir != tmp_dir || name_len != fs_path_len(tmp_name)) {
Alexander Block31db9f72012-07-25 23:19:24 +02001830 ret = 0;
1831 goto out;
1832 }
1833
Alexander Blocke938c8a2012-07-28 16:33:49 +02001834 ret = !memcmp(tmp_name->start, name, name_len);
Alexander Block31db9f72012-07-25 23:19:24 +02001835
1836out:
Tsutomu Itoh924794c2013-05-08 07:51:52 +00001837 fs_path_free(tmp_name);
Alexander Block31db9f72012-07-25 23:19:24 +02001838 return ret;
1839}
1840
Alexander Block766702e2012-07-28 14:11:31 +02001841/*
1842 * Used by process_recorded_refs to determine if a new ref would overwrite an
1843 * already existing ref. In case it detects an overwrite, it returns the
1844 * inode/gen in who_ino/who_gen.
1845 * When an overwrite is detected, process_recorded_refs does proper orphanizing
1846 * to make sure later references to the overwritten inode are possible.
1847 * Orphanizing is however only required for the first ref of an inode.
1848 * process_recorded_refs does an additional is_first_ref check to see if
1849 * orphanizing is really required.
1850 */
Alexander Block31db9f72012-07-25 23:19:24 +02001851static int will_overwrite_ref(struct send_ctx *sctx, u64 dir, u64 dir_gen,
1852 const char *name, int name_len,
1853 u64 *who_ino, u64 *who_gen)
1854{
1855 int ret = 0;
Josef Bacikebdad912013-08-06 16:47:48 -04001856 u64 gen;
Alexander Block31db9f72012-07-25 23:19:24 +02001857 u64 other_inode = 0;
1858 u8 other_type = 0;
1859
1860 if (!sctx->parent_root)
1861 goto out;
1862
1863 ret = is_inode_existent(sctx, dir, dir_gen);
1864 if (ret <= 0)
1865 goto out;
1866
Josef Bacikebdad912013-08-06 16:47:48 -04001867 /*
1868 * If we have a parent root we need to verify that the parent dir was
Nicholas D Steeves01327612016-05-19 21:18:45 -04001869 * not deleted and then re-created, if it was then we have no overwrite
Josef Bacikebdad912013-08-06 16:47:48 -04001870 * and we can just unlink this entry.
1871 */
Robbie Ko4dd99202017-01-05 16:24:55 +08001872 if (sctx->parent_root && dir != BTRFS_FIRST_FREE_OBJECTID) {
Josef Bacikebdad912013-08-06 16:47:48 -04001873 ret = get_inode_info(sctx->parent_root, dir, NULL, &gen, NULL,
1874 NULL, NULL, NULL);
1875 if (ret < 0 && ret != -ENOENT)
1876 goto out;
1877 if (ret) {
1878 ret = 0;
1879 goto out;
1880 }
1881 if (gen != dir_gen)
1882 goto out;
1883 }
1884
Alexander Block31db9f72012-07-25 23:19:24 +02001885 ret = lookup_dir_item_inode(sctx->parent_root, dir, name, name_len,
1886 &other_inode, &other_type);
1887 if (ret < 0 && ret != -ENOENT)
1888 goto out;
1889 if (ret) {
1890 ret = 0;
1891 goto out;
1892 }
1893
Alexander Block766702e2012-07-28 14:11:31 +02001894 /*
1895 * Check if the overwritten ref was already processed. If yes, the ref
1896 * was already unlinked/moved, so we can safely assume that we will not
1897 * overwrite anything at this point in time.
1898 */
Robbie Ko801bec32015-06-23 18:39:46 +08001899 if (other_inode > sctx->send_progress ||
1900 is_waiting_for_move(sctx, other_inode)) {
Alexander Block31db9f72012-07-25 23:19:24 +02001901 ret = get_inode_info(sctx->parent_root, other_inode, NULL,
Alexander Block85a7b332012-07-26 23:39:10 +02001902 who_gen, NULL, NULL, NULL, NULL);
Alexander Block31db9f72012-07-25 23:19:24 +02001903 if (ret < 0)
1904 goto out;
1905
1906 ret = 1;
1907 *who_ino = other_inode;
1908 } else {
1909 ret = 0;
1910 }
1911
1912out:
1913 return ret;
1914}
1915
Alexander Block766702e2012-07-28 14:11:31 +02001916/*
1917 * Checks if the ref was overwritten by an already processed inode. This is
1918 * used by __get_cur_name_and_parent to find out if the ref was orphanized and
1919 * thus the orphan name needs be used.
1920 * process_recorded_refs also uses it to avoid unlinking of refs that were
1921 * overwritten.
1922 */
Alexander Block31db9f72012-07-25 23:19:24 +02001923static int did_overwrite_ref(struct send_ctx *sctx,
1924 u64 dir, u64 dir_gen,
1925 u64 ino, u64 ino_gen,
1926 const char *name, int name_len)
1927{
1928 int ret = 0;
1929 u64 gen;
1930 u64 ow_inode;
1931 u8 other_type;
1932
1933 if (!sctx->parent_root)
1934 goto out;
1935
1936 ret = is_inode_existent(sctx, dir, dir_gen);
1937 if (ret <= 0)
1938 goto out;
1939
Robbie Ko01914102017-01-05 16:24:58 +08001940 if (dir != BTRFS_FIRST_FREE_OBJECTID) {
1941 ret = get_inode_info(sctx->send_root, dir, NULL, &gen, NULL,
1942 NULL, NULL, NULL);
1943 if (ret < 0 && ret != -ENOENT)
1944 goto out;
1945 if (ret) {
1946 ret = 0;
1947 goto out;
1948 }
1949 if (gen != dir_gen)
1950 goto out;
1951 }
1952
Alexander Block31db9f72012-07-25 23:19:24 +02001953 /* check if the ref was overwritten by another ref */
1954 ret = lookup_dir_item_inode(sctx->send_root, dir, name, name_len,
1955 &ow_inode, &other_type);
1956 if (ret < 0 && ret != -ENOENT)
1957 goto out;
1958 if (ret) {
1959 /* was never and will never be overwritten */
1960 ret = 0;
1961 goto out;
1962 }
1963
1964 ret = get_inode_info(sctx->send_root, ow_inode, NULL, &gen, NULL, NULL,
Alexander Block85a7b332012-07-26 23:39:10 +02001965 NULL, NULL);
Alexander Block31db9f72012-07-25 23:19:24 +02001966 if (ret < 0)
1967 goto out;
1968
1969 if (ow_inode == ino && gen == ino_gen) {
1970 ret = 0;
1971 goto out;
1972 }
1973
Filipe Manana8b191a62015-04-09 14:09:14 +01001974 /*
1975 * We know that it is or will be overwritten. Check this now.
1976 * The current inode being processed might have been the one that caused
Filipe Mananab786f162015-09-26 15:30:23 +01001977 * inode 'ino' to be orphanized, therefore check if ow_inode matches
1978 * the current inode being processed.
Filipe Manana8b191a62015-04-09 14:09:14 +01001979 */
Filipe Mananab786f162015-09-26 15:30:23 +01001980 if ((ow_inode < sctx->send_progress) ||
1981 (ino != sctx->cur_ino && ow_inode == sctx->cur_ino &&
1982 gen == sctx->cur_inode_gen))
Alexander Block31db9f72012-07-25 23:19:24 +02001983 ret = 1;
1984 else
1985 ret = 0;
1986
1987out:
1988 return ret;
1989}
1990
Alexander Block766702e2012-07-28 14:11:31 +02001991/*
1992 * Same as did_overwrite_ref, but also checks if it is the first ref of an inode
1993 * that got overwritten. This is used by process_recorded_refs to determine
1994 * if it has to use the path as returned by get_cur_path or the orphan name.
1995 */
Alexander Block31db9f72012-07-25 23:19:24 +02001996static int did_overwrite_first_ref(struct send_ctx *sctx, u64 ino, u64 gen)
1997{
1998 int ret = 0;
1999 struct fs_path *name = NULL;
2000 u64 dir;
2001 u64 dir_gen;
2002
2003 if (!sctx->parent_root)
2004 goto out;
2005
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002006 name = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +02002007 if (!name)
2008 return -ENOMEM;
2009
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002010 ret = get_first_ref(sctx->parent_root, ino, &dir, &dir_gen, name);
Alexander Block31db9f72012-07-25 23:19:24 +02002011 if (ret < 0)
2012 goto out;
2013
2014 ret = did_overwrite_ref(sctx, dir, dir_gen, ino, gen,
2015 name->start, fs_path_len(name));
Alexander Block31db9f72012-07-25 23:19:24 +02002016
2017out:
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002018 fs_path_free(name);
Alexander Block31db9f72012-07-25 23:19:24 +02002019 return ret;
2020}
2021
Alexander Block766702e2012-07-28 14:11:31 +02002022/*
2023 * Insert a name cache entry. On 32bit kernels the radix tree index is 32bit,
2024 * so we need to do some special handling in case we have clashes. This function
2025 * takes care of this with the help of name_cache_entry::radix_list.
Alexander Block5dc67d02012-08-01 12:07:43 +02002026 * In case of error, nce is kfreed.
Alexander Block766702e2012-07-28 14:11:31 +02002027 */
Alexander Block31db9f72012-07-25 23:19:24 +02002028static int name_cache_insert(struct send_ctx *sctx,
2029 struct name_cache_entry *nce)
2030{
2031 int ret = 0;
Alexander Block7e0926f2012-07-28 14:20:58 +02002032 struct list_head *nce_head;
Alexander Block31db9f72012-07-25 23:19:24 +02002033
Alexander Block7e0926f2012-07-28 14:20:58 +02002034 nce_head = radix_tree_lookup(&sctx->name_cache,
2035 (unsigned long)nce->ino);
2036 if (!nce_head) {
David Sterbae780b0d2016-01-18 18:42:13 +01002037 nce_head = kmalloc(sizeof(*nce_head), GFP_KERNEL);
Tsutomu Itohcfa7a9c2012-12-17 06:38:51 +00002038 if (!nce_head) {
2039 kfree(nce);
Alexander Block31db9f72012-07-25 23:19:24 +02002040 return -ENOMEM;
Tsutomu Itohcfa7a9c2012-12-17 06:38:51 +00002041 }
Alexander Block7e0926f2012-07-28 14:20:58 +02002042 INIT_LIST_HEAD(nce_head);
Alexander Block31db9f72012-07-25 23:19:24 +02002043
Alexander Block7e0926f2012-07-28 14:20:58 +02002044 ret = radix_tree_insert(&sctx->name_cache, nce->ino, nce_head);
Alexander Block5dc67d02012-08-01 12:07:43 +02002045 if (ret < 0) {
2046 kfree(nce_head);
2047 kfree(nce);
Alexander Block31db9f72012-07-25 23:19:24 +02002048 return ret;
Alexander Block5dc67d02012-08-01 12:07:43 +02002049 }
Alexander Block31db9f72012-07-25 23:19:24 +02002050 }
Alexander Block7e0926f2012-07-28 14:20:58 +02002051 list_add_tail(&nce->radix_list, nce_head);
Alexander Block31db9f72012-07-25 23:19:24 +02002052 list_add_tail(&nce->list, &sctx->name_cache_list);
2053 sctx->name_cache_size++;
2054
2055 return ret;
2056}
2057
2058static void name_cache_delete(struct send_ctx *sctx,
2059 struct name_cache_entry *nce)
2060{
Alexander Block7e0926f2012-07-28 14:20:58 +02002061 struct list_head *nce_head;
Alexander Block31db9f72012-07-25 23:19:24 +02002062
Alexander Block7e0926f2012-07-28 14:20:58 +02002063 nce_head = radix_tree_lookup(&sctx->name_cache,
2064 (unsigned long)nce->ino);
David Sterba57fb8912014-02-03 19:24:40 +01002065 if (!nce_head) {
2066 btrfs_err(sctx->send_root->fs_info,
2067 "name_cache_delete lookup failed ino %llu cache size %d, leaking memory",
2068 nce->ino, sctx->name_cache_size);
2069 }
Alexander Block31db9f72012-07-25 23:19:24 +02002070
Alexander Block7e0926f2012-07-28 14:20:58 +02002071 list_del(&nce->radix_list);
Alexander Block31db9f72012-07-25 23:19:24 +02002072 list_del(&nce->list);
Alexander Block31db9f72012-07-25 23:19:24 +02002073 sctx->name_cache_size--;
Alexander Block7e0926f2012-07-28 14:20:58 +02002074
David Sterba57fb8912014-02-03 19:24:40 +01002075 /*
2076 * We may not get to the final release of nce_head if the lookup fails
2077 */
2078 if (nce_head && list_empty(nce_head)) {
Alexander Block7e0926f2012-07-28 14:20:58 +02002079 radix_tree_delete(&sctx->name_cache, (unsigned long)nce->ino);
2080 kfree(nce_head);
2081 }
Alexander Block31db9f72012-07-25 23:19:24 +02002082}
2083
2084static struct name_cache_entry *name_cache_search(struct send_ctx *sctx,
2085 u64 ino, u64 gen)
2086{
Alexander Block7e0926f2012-07-28 14:20:58 +02002087 struct list_head *nce_head;
2088 struct name_cache_entry *cur;
Alexander Block31db9f72012-07-25 23:19:24 +02002089
Alexander Block7e0926f2012-07-28 14:20:58 +02002090 nce_head = radix_tree_lookup(&sctx->name_cache, (unsigned long)ino);
2091 if (!nce_head)
Alexander Block31db9f72012-07-25 23:19:24 +02002092 return NULL;
2093
Alexander Block7e0926f2012-07-28 14:20:58 +02002094 list_for_each_entry(cur, nce_head, radix_list) {
2095 if (cur->ino == ino && cur->gen == gen)
2096 return cur;
2097 }
Alexander Block31db9f72012-07-25 23:19:24 +02002098 return NULL;
2099}
2100
Alexander Block766702e2012-07-28 14:11:31 +02002101/*
2102 * Removes the entry from the list and adds it back to the end. This marks the
2103 * entry as recently used so that name_cache_clean_unused does not remove it.
2104 */
Alexander Block31db9f72012-07-25 23:19:24 +02002105static void name_cache_used(struct send_ctx *sctx, struct name_cache_entry *nce)
2106{
2107 list_del(&nce->list);
2108 list_add_tail(&nce->list, &sctx->name_cache_list);
2109}
2110
Alexander Block766702e2012-07-28 14:11:31 +02002111/*
2112 * Remove some entries from the beginning of name_cache_list.
2113 */
Alexander Block31db9f72012-07-25 23:19:24 +02002114static void name_cache_clean_unused(struct send_ctx *sctx)
2115{
2116 struct name_cache_entry *nce;
2117
2118 if (sctx->name_cache_size < SEND_CTX_NAME_CACHE_CLEAN_SIZE)
2119 return;
2120
2121 while (sctx->name_cache_size > SEND_CTX_MAX_NAME_CACHE_SIZE) {
2122 nce = list_entry(sctx->name_cache_list.next,
2123 struct name_cache_entry, list);
2124 name_cache_delete(sctx, nce);
2125 kfree(nce);
2126 }
2127}
2128
2129static void name_cache_free(struct send_ctx *sctx)
2130{
2131 struct name_cache_entry *nce;
Alexander Block31db9f72012-07-25 23:19:24 +02002132
Alexander Blocke938c8a2012-07-28 16:33:49 +02002133 while (!list_empty(&sctx->name_cache_list)) {
2134 nce = list_entry(sctx->name_cache_list.next,
2135 struct name_cache_entry, list);
Alexander Block31db9f72012-07-25 23:19:24 +02002136 name_cache_delete(sctx, nce);
Alexander Block17589bd2012-07-28 14:13:35 +02002137 kfree(nce);
Alexander Block31db9f72012-07-25 23:19:24 +02002138 }
2139}
2140
Alexander Block766702e2012-07-28 14:11:31 +02002141/*
2142 * Used by get_cur_path for each ref up to the root.
2143 * Returns 0 if it succeeded.
2144 * Returns 1 if the inode is not existent or got overwritten. In that case, the
2145 * name is an orphan name. This instructs get_cur_path to stop iterating. If 1
2146 * is returned, parent_ino/parent_gen are not guaranteed to be valid.
2147 * Returns <0 in case of error.
2148 */
Alexander Block31db9f72012-07-25 23:19:24 +02002149static int __get_cur_name_and_parent(struct send_ctx *sctx,
2150 u64 ino, u64 gen,
2151 u64 *parent_ino,
2152 u64 *parent_gen,
2153 struct fs_path *dest)
2154{
2155 int ret;
2156 int nce_ret;
Alexander Block31db9f72012-07-25 23:19:24 +02002157 struct name_cache_entry *nce = NULL;
2158
Alexander Block766702e2012-07-28 14:11:31 +02002159 /*
2160 * First check if we already did a call to this function with the same
2161 * ino/gen. If yes, check if the cache entry is still up-to-date. If yes
2162 * return the cached result.
2163 */
Alexander Block31db9f72012-07-25 23:19:24 +02002164 nce = name_cache_search(sctx, ino, gen);
2165 if (nce) {
2166 if (ino < sctx->send_progress && nce->need_later_update) {
2167 name_cache_delete(sctx, nce);
2168 kfree(nce);
2169 nce = NULL;
2170 } else {
2171 name_cache_used(sctx, nce);
2172 *parent_ino = nce->parent_ino;
2173 *parent_gen = nce->parent_gen;
2174 ret = fs_path_add(dest, nce->name, nce->name_len);
2175 if (ret < 0)
2176 goto out;
2177 ret = nce->ret;
2178 goto out;
2179 }
2180 }
2181
Alexander Block766702e2012-07-28 14:11:31 +02002182 /*
2183 * If the inode is not existent yet, add the orphan name and return 1.
2184 * This should only happen for the parent dir that we determine in
2185 * __record_new_ref
2186 */
Alexander Block31db9f72012-07-25 23:19:24 +02002187 ret = is_inode_existent(sctx, ino, gen);
2188 if (ret < 0)
2189 goto out;
2190
2191 if (!ret) {
2192 ret = gen_unique_name(sctx, ino, gen, dest);
2193 if (ret < 0)
2194 goto out;
2195 ret = 1;
2196 goto out_cache;
2197 }
2198
Alexander Block766702e2012-07-28 14:11:31 +02002199 /*
2200 * Depending on whether the inode was already processed or not, use
2201 * send_root or parent_root for ref lookup.
2202 */
Filipe Mananabf0d1f42014-02-21 00:01:32 +00002203 if (ino < sctx->send_progress)
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002204 ret = get_first_ref(sctx->send_root, ino,
2205 parent_ino, parent_gen, dest);
Alexander Block31db9f72012-07-25 23:19:24 +02002206 else
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002207 ret = get_first_ref(sctx->parent_root, ino,
2208 parent_ino, parent_gen, dest);
Alexander Block31db9f72012-07-25 23:19:24 +02002209 if (ret < 0)
2210 goto out;
2211
Alexander Block766702e2012-07-28 14:11:31 +02002212 /*
2213 * Check if the ref was overwritten by an inode's ref that was processed
2214 * earlier. If yes, treat as orphan and return 1.
2215 */
Alexander Block31db9f72012-07-25 23:19:24 +02002216 ret = did_overwrite_ref(sctx, *parent_ino, *parent_gen, ino, gen,
2217 dest->start, dest->end - dest->start);
2218 if (ret < 0)
2219 goto out;
2220 if (ret) {
2221 fs_path_reset(dest);
2222 ret = gen_unique_name(sctx, ino, gen, dest);
2223 if (ret < 0)
2224 goto out;
2225 ret = 1;
2226 }
2227
2228out_cache:
Alexander Block766702e2012-07-28 14:11:31 +02002229 /*
2230 * Store the result of the lookup in the name cache.
2231 */
David Sterbae780b0d2016-01-18 18:42:13 +01002232 nce = kmalloc(sizeof(*nce) + fs_path_len(dest) + 1, GFP_KERNEL);
Alexander Block31db9f72012-07-25 23:19:24 +02002233 if (!nce) {
2234 ret = -ENOMEM;
2235 goto out;
2236 }
2237
2238 nce->ino = ino;
2239 nce->gen = gen;
2240 nce->parent_ino = *parent_ino;
2241 nce->parent_gen = *parent_gen;
2242 nce->name_len = fs_path_len(dest);
2243 nce->ret = ret;
2244 strcpy(nce->name, dest->start);
Alexander Block31db9f72012-07-25 23:19:24 +02002245
2246 if (ino < sctx->send_progress)
2247 nce->need_later_update = 0;
2248 else
2249 nce->need_later_update = 1;
2250
2251 nce_ret = name_cache_insert(sctx, nce);
2252 if (nce_ret < 0)
2253 ret = nce_ret;
2254 name_cache_clean_unused(sctx);
2255
2256out:
Alexander Block31db9f72012-07-25 23:19:24 +02002257 return ret;
2258}
2259
2260/*
2261 * Magic happens here. This function returns the first ref to an inode as it
2262 * would look like while receiving the stream at this point in time.
2263 * We walk the path up to the root. For every inode in between, we check if it
2264 * was already processed/sent. If yes, we continue with the parent as found
2265 * in send_root. If not, we continue with the parent as found in parent_root.
2266 * If we encounter an inode that was deleted at this point in time, we use the
2267 * inodes "orphan" name instead of the real name and stop. Same with new inodes
2268 * that were not created yet and overwritten inodes/refs.
2269 *
2270 * When do we have have orphan inodes:
2271 * 1. When an inode is freshly created and thus no valid refs are available yet
2272 * 2. When a directory lost all it's refs (deleted) but still has dir items
2273 * inside which were not processed yet (pending for move/delete). If anyone
2274 * tried to get the path to the dir items, it would get a path inside that
2275 * orphan directory.
2276 * 3. When an inode is moved around or gets new links, it may overwrite the ref
2277 * of an unprocessed inode. If in that case the first ref would be
2278 * overwritten, the overwritten inode gets "orphanized". Later when we
2279 * process this overwritten inode, it is restored at a new place by moving
2280 * the orphan inode.
2281 *
2282 * sctx->send_progress tells this function at which point in time receiving
2283 * would be.
2284 */
2285static int get_cur_path(struct send_ctx *sctx, u64 ino, u64 gen,
2286 struct fs_path *dest)
2287{
2288 int ret = 0;
2289 struct fs_path *name = NULL;
2290 u64 parent_inode = 0;
2291 u64 parent_gen = 0;
2292 int stop = 0;
2293
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002294 name = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +02002295 if (!name) {
2296 ret = -ENOMEM;
2297 goto out;
2298 }
2299
2300 dest->reversed = 1;
2301 fs_path_reset(dest);
2302
2303 while (!stop && ino != BTRFS_FIRST_FREE_OBJECTID) {
Filipe Manana8b191a62015-04-09 14:09:14 +01002304 struct waiting_dir_move *wdm;
2305
Alexander Block31db9f72012-07-25 23:19:24 +02002306 fs_path_reset(name);
2307
Filipe Manana9dc44212014-02-19 14:31:44 +00002308 if (is_waiting_for_rm(sctx, ino)) {
2309 ret = gen_unique_name(sctx, ino, gen, name);
2310 if (ret < 0)
2311 goto out;
2312 ret = fs_path_add_path(dest, name);
2313 break;
2314 }
2315
Filipe Manana8b191a62015-04-09 14:09:14 +01002316 wdm = get_waiting_dir_move(sctx, ino);
2317 if (wdm && wdm->orphanized) {
2318 ret = gen_unique_name(sctx, ino, gen, name);
2319 stop = 1;
2320 } else if (wdm) {
Filipe Mananabf0d1f42014-02-21 00:01:32 +00002321 ret = get_first_ref(sctx->parent_root, ino,
2322 &parent_inode, &parent_gen, name);
2323 } else {
2324 ret = __get_cur_name_and_parent(sctx, ino, gen,
2325 &parent_inode,
2326 &parent_gen, name);
2327 if (ret)
2328 stop = 1;
2329 }
2330
Alexander Block31db9f72012-07-25 23:19:24 +02002331 if (ret < 0)
2332 goto out;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00002333
Alexander Block31db9f72012-07-25 23:19:24 +02002334 ret = fs_path_add_path(dest, name);
2335 if (ret < 0)
2336 goto out;
2337
2338 ino = parent_inode;
2339 gen = parent_gen;
2340 }
2341
2342out:
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002343 fs_path_free(name);
Alexander Block31db9f72012-07-25 23:19:24 +02002344 if (!ret)
2345 fs_path_unreverse(dest);
2346 return ret;
2347}
2348
2349/*
Alexander Block31db9f72012-07-25 23:19:24 +02002350 * Sends a BTRFS_SEND_C_SUBVOL command/item to userspace
2351 */
2352static int send_subvol_begin(struct send_ctx *sctx)
2353{
2354 int ret;
2355 struct btrfs_root *send_root = sctx->send_root;
2356 struct btrfs_root *parent_root = sctx->parent_root;
2357 struct btrfs_path *path;
2358 struct btrfs_key key;
2359 struct btrfs_root_ref *ref;
2360 struct extent_buffer *leaf;
2361 char *name = NULL;
2362 int namelen;
2363
Wang Shilongffcfaf82014-01-15 00:26:43 +08002364 path = btrfs_alloc_path();
Alexander Block31db9f72012-07-25 23:19:24 +02002365 if (!path)
2366 return -ENOMEM;
2367
David Sterbae780b0d2016-01-18 18:42:13 +01002368 name = kmalloc(BTRFS_PATH_NAME_MAX, GFP_KERNEL);
Alexander Block31db9f72012-07-25 23:19:24 +02002369 if (!name) {
2370 btrfs_free_path(path);
2371 return -ENOMEM;
2372 }
2373
2374 key.objectid = send_root->objectid;
2375 key.type = BTRFS_ROOT_BACKREF_KEY;
2376 key.offset = 0;
2377
2378 ret = btrfs_search_slot_for_read(send_root->fs_info->tree_root,
2379 &key, path, 1, 0);
2380 if (ret < 0)
2381 goto out;
2382 if (ret) {
2383 ret = -ENOENT;
2384 goto out;
2385 }
2386
2387 leaf = path->nodes[0];
2388 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
2389 if (key.type != BTRFS_ROOT_BACKREF_KEY ||
2390 key.objectid != send_root->objectid) {
2391 ret = -ENOENT;
2392 goto out;
2393 }
2394 ref = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_root_ref);
2395 namelen = btrfs_root_ref_name_len(leaf, ref);
2396 read_extent_buffer(leaf, name, (unsigned long)(ref + 1), namelen);
2397 btrfs_release_path(path);
2398
Alexander Block31db9f72012-07-25 23:19:24 +02002399 if (parent_root) {
2400 ret = begin_cmd(sctx, BTRFS_SEND_C_SNAPSHOT);
2401 if (ret < 0)
2402 goto out;
2403 } else {
2404 ret = begin_cmd(sctx, BTRFS_SEND_C_SUBVOL);
2405 if (ret < 0)
2406 goto out;
2407 }
2408
2409 TLV_PUT_STRING(sctx, BTRFS_SEND_A_PATH, name, namelen);
Robin Ruedeb96b1db2015-09-30 21:23:33 +02002410
2411 if (!btrfs_is_empty_uuid(sctx->send_root->root_item.received_uuid))
2412 TLV_PUT_UUID(sctx, BTRFS_SEND_A_UUID,
2413 sctx->send_root->root_item.received_uuid);
2414 else
2415 TLV_PUT_UUID(sctx, BTRFS_SEND_A_UUID,
2416 sctx->send_root->root_item.uuid);
2417
Alexander Block31db9f72012-07-25 23:19:24 +02002418 TLV_PUT_U64(sctx, BTRFS_SEND_A_CTRANSID,
Filipe David Borba Manana5a0f4e22013-12-03 15:55:48 +00002419 le64_to_cpu(sctx->send_root->root_item.ctransid));
Alexander Block31db9f72012-07-25 23:19:24 +02002420 if (parent_root) {
Josef Bacik37b8d272015-06-04 17:17:25 -04002421 if (!btrfs_is_empty_uuid(parent_root->root_item.received_uuid))
2422 TLV_PUT_UUID(sctx, BTRFS_SEND_A_CLONE_UUID,
2423 parent_root->root_item.received_uuid);
2424 else
2425 TLV_PUT_UUID(sctx, BTRFS_SEND_A_CLONE_UUID,
2426 parent_root->root_item.uuid);
Alexander Block31db9f72012-07-25 23:19:24 +02002427 TLV_PUT_U64(sctx, BTRFS_SEND_A_CLONE_CTRANSID,
Filipe David Borba Manana5a0f4e22013-12-03 15:55:48 +00002428 le64_to_cpu(sctx->parent_root->root_item.ctransid));
Alexander Block31db9f72012-07-25 23:19:24 +02002429 }
2430
2431 ret = send_cmd(sctx);
2432
2433tlv_put_failure:
2434out:
2435 btrfs_free_path(path);
2436 kfree(name);
2437 return ret;
2438}
2439
2440static int send_truncate(struct send_ctx *sctx, u64 ino, u64 gen, u64 size)
2441{
Jeff Mahoney04ab9562016-09-20 10:05:03 -04002442 struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;
Alexander Block31db9f72012-07-25 23:19:24 +02002443 int ret = 0;
2444 struct fs_path *p;
2445
Jeff Mahoney04ab9562016-09-20 10:05:03 -04002446 btrfs_debug(fs_info, "send_truncate %llu size=%llu", ino, size);
Alexander Block31db9f72012-07-25 23:19:24 +02002447
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002448 p = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +02002449 if (!p)
2450 return -ENOMEM;
2451
2452 ret = begin_cmd(sctx, BTRFS_SEND_C_TRUNCATE);
2453 if (ret < 0)
2454 goto out;
2455
2456 ret = get_cur_path(sctx, ino, gen, p);
2457 if (ret < 0)
2458 goto out;
2459 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
2460 TLV_PUT_U64(sctx, BTRFS_SEND_A_SIZE, size);
2461
2462 ret = send_cmd(sctx);
2463
2464tlv_put_failure:
2465out:
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002466 fs_path_free(p);
Alexander Block31db9f72012-07-25 23:19:24 +02002467 return ret;
2468}
2469
2470static int send_chmod(struct send_ctx *sctx, u64 ino, u64 gen, u64 mode)
2471{
Jeff Mahoney04ab9562016-09-20 10:05:03 -04002472 struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;
Alexander Block31db9f72012-07-25 23:19:24 +02002473 int ret = 0;
2474 struct fs_path *p;
2475
Jeff Mahoney04ab9562016-09-20 10:05:03 -04002476 btrfs_debug(fs_info, "send_chmod %llu mode=%llu", ino, mode);
Alexander Block31db9f72012-07-25 23:19:24 +02002477
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002478 p = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +02002479 if (!p)
2480 return -ENOMEM;
2481
2482 ret = begin_cmd(sctx, BTRFS_SEND_C_CHMOD);
2483 if (ret < 0)
2484 goto out;
2485
2486 ret = get_cur_path(sctx, ino, gen, p);
2487 if (ret < 0)
2488 goto out;
2489 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
2490 TLV_PUT_U64(sctx, BTRFS_SEND_A_MODE, mode & 07777);
2491
2492 ret = send_cmd(sctx);
2493
2494tlv_put_failure:
2495out:
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002496 fs_path_free(p);
Alexander Block31db9f72012-07-25 23:19:24 +02002497 return ret;
2498}
2499
2500static int send_chown(struct send_ctx *sctx, u64 ino, u64 gen, u64 uid, u64 gid)
2501{
Jeff Mahoney04ab9562016-09-20 10:05:03 -04002502 struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;
Alexander Block31db9f72012-07-25 23:19:24 +02002503 int ret = 0;
2504 struct fs_path *p;
2505
Jeff Mahoney04ab9562016-09-20 10:05:03 -04002506 btrfs_debug(fs_info, "send_chown %llu uid=%llu, gid=%llu",
2507 ino, uid, gid);
Alexander Block31db9f72012-07-25 23:19:24 +02002508
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002509 p = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +02002510 if (!p)
2511 return -ENOMEM;
2512
2513 ret = begin_cmd(sctx, BTRFS_SEND_C_CHOWN);
2514 if (ret < 0)
2515 goto out;
2516
2517 ret = get_cur_path(sctx, ino, gen, p);
2518 if (ret < 0)
2519 goto out;
2520 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
2521 TLV_PUT_U64(sctx, BTRFS_SEND_A_UID, uid);
2522 TLV_PUT_U64(sctx, BTRFS_SEND_A_GID, gid);
2523
2524 ret = send_cmd(sctx);
2525
2526tlv_put_failure:
2527out:
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002528 fs_path_free(p);
Alexander Block31db9f72012-07-25 23:19:24 +02002529 return ret;
2530}
2531
2532static int send_utimes(struct send_ctx *sctx, u64 ino, u64 gen)
2533{
Jeff Mahoney04ab9562016-09-20 10:05:03 -04002534 struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;
Alexander Block31db9f72012-07-25 23:19:24 +02002535 int ret = 0;
2536 struct fs_path *p = NULL;
2537 struct btrfs_inode_item *ii;
2538 struct btrfs_path *path = NULL;
2539 struct extent_buffer *eb;
2540 struct btrfs_key key;
2541 int slot;
2542
Jeff Mahoney04ab9562016-09-20 10:05:03 -04002543 btrfs_debug(fs_info, "send_utimes %llu", ino);
Alexander Block31db9f72012-07-25 23:19:24 +02002544
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002545 p = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +02002546 if (!p)
2547 return -ENOMEM;
2548
2549 path = alloc_path_for_send();
2550 if (!path) {
2551 ret = -ENOMEM;
2552 goto out;
2553 }
2554
2555 key.objectid = ino;
2556 key.type = BTRFS_INODE_ITEM_KEY;
2557 key.offset = 0;
2558 ret = btrfs_search_slot(NULL, sctx->send_root, &key, path, 0, 0);
Filipe Manana15b253e2016-07-02 05:43:46 +01002559 if (ret > 0)
2560 ret = -ENOENT;
Alexander Block31db9f72012-07-25 23:19:24 +02002561 if (ret < 0)
2562 goto out;
2563
2564 eb = path->nodes[0];
2565 slot = path->slots[0];
2566 ii = btrfs_item_ptr(eb, slot, struct btrfs_inode_item);
2567
2568 ret = begin_cmd(sctx, BTRFS_SEND_C_UTIMES);
2569 if (ret < 0)
2570 goto out;
2571
2572 ret = get_cur_path(sctx, ino, gen, p);
2573 if (ret < 0)
2574 goto out;
2575 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
David Sterbaa937b972014-12-12 17:39:12 +01002576 TLV_PUT_BTRFS_TIMESPEC(sctx, BTRFS_SEND_A_ATIME, eb, &ii->atime);
2577 TLV_PUT_BTRFS_TIMESPEC(sctx, BTRFS_SEND_A_MTIME, eb, &ii->mtime);
2578 TLV_PUT_BTRFS_TIMESPEC(sctx, BTRFS_SEND_A_CTIME, eb, &ii->ctime);
Alexander Block766702e2012-07-28 14:11:31 +02002579 /* TODO Add otime support when the otime patches get into upstream */
Alexander Block31db9f72012-07-25 23:19:24 +02002580
2581 ret = send_cmd(sctx);
2582
2583tlv_put_failure:
2584out:
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002585 fs_path_free(p);
Alexander Block31db9f72012-07-25 23:19:24 +02002586 btrfs_free_path(path);
2587 return ret;
2588}
2589
2590/*
2591 * Sends a BTRFS_SEND_C_MKXXX or SYMLINK command to user space. We don't have
2592 * a valid path yet because we did not process the refs yet. So, the inode
2593 * is created as orphan.
2594 */
Alexander Block1f4692d2012-07-28 10:42:24 +02002595static int send_create_inode(struct send_ctx *sctx, u64 ino)
Alexander Block31db9f72012-07-25 23:19:24 +02002596{
Jeff Mahoney04ab9562016-09-20 10:05:03 -04002597 struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;
Alexander Block31db9f72012-07-25 23:19:24 +02002598 int ret = 0;
Alexander Block31db9f72012-07-25 23:19:24 +02002599 struct fs_path *p;
Alexander Block31db9f72012-07-25 23:19:24 +02002600 int cmd;
Alexander Block1f4692d2012-07-28 10:42:24 +02002601 u64 gen;
Alexander Block31db9f72012-07-25 23:19:24 +02002602 u64 mode;
Alexander Block1f4692d2012-07-28 10:42:24 +02002603 u64 rdev;
Alexander Block31db9f72012-07-25 23:19:24 +02002604
Jeff Mahoney04ab9562016-09-20 10:05:03 -04002605 btrfs_debug(fs_info, "send_create_inode %llu", ino);
Alexander Block31db9f72012-07-25 23:19:24 +02002606
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002607 p = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +02002608 if (!p)
2609 return -ENOMEM;
2610
Liu Bo644d1942014-02-27 17:29:01 +08002611 if (ino != sctx->cur_ino) {
2612 ret = get_inode_info(sctx->send_root, ino, NULL, &gen, &mode,
2613 NULL, NULL, &rdev);
2614 if (ret < 0)
2615 goto out;
2616 } else {
2617 gen = sctx->cur_inode_gen;
2618 mode = sctx->cur_inode_mode;
2619 rdev = sctx->cur_inode_rdev;
2620 }
Alexander Block31db9f72012-07-25 23:19:24 +02002621
Alexander Blocke938c8a2012-07-28 16:33:49 +02002622 if (S_ISREG(mode)) {
Alexander Block31db9f72012-07-25 23:19:24 +02002623 cmd = BTRFS_SEND_C_MKFILE;
Alexander Blocke938c8a2012-07-28 16:33:49 +02002624 } else if (S_ISDIR(mode)) {
Alexander Block31db9f72012-07-25 23:19:24 +02002625 cmd = BTRFS_SEND_C_MKDIR;
Alexander Blocke938c8a2012-07-28 16:33:49 +02002626 } else if (S_ISLNK(mode)) {
Alexander Block31db9f72012-07-25 23:19:24 +02002627 cmd = BTRFS_SEND_C_SYMLINK;
Alexander Blocke938c8a2012-07-28 16:33:49 +02002628 } else if (S_ISCHR(mode) || S_ISBLK(mode)) {
Alexander Block31db9f72012-07-25 23:19:24 +02002629 cmd = BTRFS_SEND_C_MKNOD;
Alexander Blocke938c8a2012-07-28 16:33:49 +02002630 } else if (S_ISFIFO(mode)) {
Alexander Block31db9f72012-07-25 23:19:24 +02002631 cmd = BTRFS_SEND_C_MKFIFO;
Alexander Blocke938c8a2012-07-28 16:33:49 +02002632 } else if (S_ISSOCK(mode)) {
Alexander Block31db9f72012-07-25 23:19:24 +02002633 cmd = BTRFS_SEND_C_MKSOCK;
Alexander Blocke938c8a2012-07-28 16:33:49 +02002634 } else {
David Sterbaf14d1042015-10-08 11:37:06 +02002635 btrfs_warn(sctx->send_root->fs_info, "unexpected inode type %o",
Alexander Block31db9f72012-07-25 23:19:24 +02002636 (int)(mode & S_IFMT));
2637 ret = -ENOTSUPP;
2638 goto out;
2639 }
2640
2641 ret = begin_cmd(sctx, cmd);
2642 if (ret < 0)
2643 goto out;
2644
Alexander Block1f4692d2012-07-28 10:42:24 +02002645 ret = gen_unique_name(sctx, ino, gen, p);
Alexander Block31db9f72012-07-25 23:19:24 +02002646 if (ret < 0)
2647 goto out;
2648
2649 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
Alexander Block1f4692d2012-07-28 10:42:24 +02002650 TLV_PUT_U64(sctx, BTRFS_SEND_A_INO, ino);
Alexander Block31db9f72012-07-25 23:19:24 +02002651
2652 if (S_ISLNK(mode)) {
2653 fs_path_reset(p);
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002654 ret = read_symlink(sctx->send_root, ino, p);
Alexander Block31db9f72012-07-25 23:19:24 +02002655 if (ret < 0)
2656 goto out;
2657 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH_LINK, p);
2658 } else if (S_ISCHR(mode) || S_ISBLK(mode) ||
2659 S_ISFIFO(mode) || S_ISSOCK(mode)) {
Arne Jansend79e5042012-10-15 18:28:46 +00002660 TLV_PUT_U64(sctx, BTRFS_SEND_A_RDEV, new_encode_dev(rdev));
2661 TLV_PUT_U64(sctx, BTRFS_SEND_A_MODE, mode);
Alexander Block31db9f72012-07-25 23:19:24 +02002662 }
2663
2664 ret = send_cmd(sctx);
2665 if (ret < 0)
2666 goto out;
2667
2668
2669tlv_put_failure:
2670out:
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002671 fs_path_free(p);
Alexander Block31db9f72012-07-25 23:19:24 +02002672 return ret;
2673}
2674
Alexander Block1f4692d2012-07-28 10:42:24 +02002675/*
2676 * We need some special handling for inodes that get processed before the parent
2677 * directory got created. See process_recorded_refs for details.
2678 * This function does the check if we already created the dir out of order.
2679 */
2680static int did_create_dir(struct send_ctx *sctx, u64 dir)
2681{
2682 int ret = 0;
2683 struct btrfs_path *path = NULL;
2684 struct btrfs_key key;
2685 struct btrfs_key found_key;
2686 struct btrfs_key di_key;
2687 struct extent_buffer *eb;
2688 struct btrfs_dir_item *di;
2689 int slot;
2690
2691 path = alloc_path_for_send();
2692 if (!path) {
2693 ret = -ENOMEM;
2694 goto out;
2695 }
2696
2697 key.objectid = dir;
2698 key.type = BTRFS_DIR_INDEX_KEY;
2699 key.offset = 0;
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00002700 ret = btrfs_search_slot(NULL, sctx->send_root, &key, path, 0, 0);
2701 if (ret < 0)
2702 goto out;
2703
Alexander Block1f4692d2012-07-28 10:42:24 +02002704 while (1) {
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00002705 eb = path->nodes[0];
2706 slot = path->slots[0];
2707 if (slot >= btrfs_header_nritems(eb)) {
2708 ret = btrfs_next_leaf(sctx->send_root, path);
2709 if (ret < 0) {
2710 goto out;
2711 } else if (ret > 0) {
2712 ret = 0;
2713 break;
2714 }
2715 continue;
Alexander Block1f4692d2012-07-28 10:42:24 +02002716 }
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00002717
2718 btrfs_item_key_to_cpu(eb, &found_key, slot);
2719 if (found_key.objectid != key.objectid ||
Alexander Block1f4692d2012-07-28 10:42:24 +02002720 found_key.type != key.type) {
2721 ret = 0;
2722 goto out;
2723 }
2724
2725 di = btrfs_item_ptr(eb, slot, struct btrfs_dir_item);
2726 btrfs_dir_item_key_to_cpu(eb, di, &di_key);
2727
Josef Bacika0525412013-08-12 10:56:14 -04002728 if (di_key.type != BTRFS_ROOT_ITEM_KEY &&
2729 di_key.objectid < sctx->send_progress) {
Alexander Block1f4692d2012-07-28 10:42:24 +02002730 ret = 1;
2731 goto out;
2732 }
2733
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00002734 path->slots[0]++;
Alexander Block1f4692d2012-07-28 10:42:24 +02002735 }
2736
2737out:
2738 btrfs_free_path(path);
2739 return ret;
2740}
2741
2742/*
2743 * Only creates the inode if it is:
2744 * 1. Not a directory
2745 * 2. Or a directory which was not created already due to out of order
2746 * directories. See did_create_dir and process_recorded_refs for details.
2747 */
2748static int send_create_inode_if_needed(struct send_ctx *sctx)
2749{
2750 int ret;
2751
2752 if (S_ISDIR(sctx->cur_inode_mode)) {
2753 ret = did_create_dir(sctx, sctx->cur_ino);
2754 if (ret < 0)
2755 goto out;
2756 if (ret) {
2757 ret = 0;
2758 goto out;
2759 }
2760 }
2761
2762 ret = send_create_inode(sctx, sctx->cur_ino);
2763 if (ret < 0)
2764 goto out;
2765
2766out:
2767 return ret;
2768}
2769
Alexander Block31db9f72012-07-25 23:19:24 +02002770struct recorded_ref {
2771 struct list_head list;
Alexander Block31db9f72012-07-25 23:19:24 +02002772 char *name;
2773 struct fs_path *full_path;
2774 u64 dir;
2775 u64 dir_gen;
Alexander Block31db9f72012-07-25 23:19:24 +02002776 int name_len;
2777};
2778
2779/*
2780 * We need to process new refs before deleted refs, but compare_tree gives us
2781 * everything mixed. So we first record all refs and later process them.
2782 * This function is a helper to record one ref.
2783 */
Liu Boa4d96d62014-03-03 21:31:03 +08002784static int __record_ref(struct list_head *head, u64 dir,
Alexander Block31db9f72012-07-25 23:19:24 +02002785 u64 dir_gen, struct fs_path *path)
2786{
2787 struct recorded_ref *ref;
Alexander Block31db9f72012-07-25 23:19:24 +02002788
David Sterbae780b0d2016-01-18 18:42:13 +01002789 ref = kmalloc(sizeof(*ref), GFP_KERNEL);
Alexander Block31db9f72012-07-25 23:19:24 +02002790 if (!ref)
2791 return -ENOMEM;
2792
2793 ref->dir = dir;
2794 ref->dir_gen = dir_gen;
2795 ref->full_path = path;
2796
Andy Shevchenkoed848852013-08-21 10:32:13 +03002797 ref->name = (char *)kbasename(ref->full_path->start);
2798 ref->name_len = ref->full_path->end - ref->name;
Alexander Block31db9f72012-07-25 23:19:24 +02002799
2800 list_add_tail(&ref->list, head);
2801 return 0;
2802}
2803
Josef Bacikba5e8f22013-08-16 16:52:55 -04002804static int dup_ref(struct recorded_ref *ref, struct list_head *list)
2805{
2806 struct recorded_ref *new;
2807
David Sterbae780b0d2016-01-18 18:42:13 +01002808 new = kmalloc(sizeof(*ref), GFP_KERNEL);
Josef Bacikba5e8f22013-08-16 16:52:55 -04002809 if (!new)
2810 return -ENOMEM;
2811
2812 new->dir = ref->dir;
2813 new->dir_gen = ref->dir_gen;
2814 new->full_path = NULL;
2815 INIT_LIST_HEAD(&new->list);
2816 list_add_tail(&new->list, list);
2817 return 0;
2818}
2819
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002820static void __free_recorded_refs(struct list_head *head)
Alexander Block31db9f72012-07-25 23:19:24 +02002821{
2822 struct recorded_ref *cur;
Alexander Block31db9f72012-07-25 23:19:24 +02002823
Alexander Blocke938c8a2012-07-28 16:33:49 +02002824 while (!list_empty(head)) {
2825 cur = list_entry(head->next, struct recorded_ref, list);
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002826 fs_path_free(cur->full_path);
Alexander Blocke938c8a2012-07-28 16:33:49 +02002827 list_del(&cur->list);
Alexander Block31db9f72012-07-25 23:19:24 +02002828 kfree(cur);
2829 }
Alexander Block31db9f72012-07-25 23:19:24 +02002830}
2831
2832static void free_recorded_refs(struct send_ctx *sctx)
2833{
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002834 __free_recorded_refs(&sctx->new_refs);
2835 __free_recorded_refs(&sctx->deleted_refs);
Alexander Block31db9f72012-07-25 23:19:24 +02002836}
2837
2838/*
Alexander Block766702e2012-07-28 14:11:31 +02002839 * Renames/moves a file/dir to its orphan name. Used when the first
Alexander Block31db9f72012-07-25 23:19:24 +02002840 * ref of an unprocessed inode gets overwritten and for all non empty
2841 * directories.
2842 */
2843static int orphanize_inode(struct send_ctx *sctx, u64 ino, u64 gen,
2844 struct fs_path *path)
2845{
2846 int ret;
2847 struct fs_path *orphan;
2848
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002849 orphan = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +02002850 if (!orphan)
2851 return -ENOMEM;
2852
2853 ret = gen_unique_name(sctx, ino, gen, orphan);
2854 if (ret < 0)
2855 goto out;
2856
2857 ret = send_rename(sctx, path, orphan);
2858
2859out:
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002860 fs_path_free(orphan);
Alexander Block31db9f72012-07-25 23:19:24 +02002861 return ret;
2862}
2863
Filipe Manana9dc44212014-02-19 14:31:44 +00002864static struct orphan_dir_info *
2865add_orphan_dir_info(struct send_ctx *sctx, u64 dir_ino)
2866{
2867 struct rb_node **p = &sctx->orphan_dirs.rb_node;
2868 struct rb_node *parent = NULL;
2869 struct orphan_dir_info *entry, *odi;
2870
David Sterbae780b0d2016-01-18 18:42:13 +01002871 odi = kmalloc(sizeof(*odi), GFP_KERNEL);
Filipe Manana9dc44212014-02-19 14:31:44 +00002872 if (!odi)
2873 return ERR_PTR(-ENOMEM);
2874 odi->ino = dir_ino;
2875 odi->gen = 0;
2876
2877 while (*p) {
2878 parent = *p;
2879 entry = rb_entry(parent, struct orphan_dir_info, node);
2880 if (dir_ino < entry->ino) {
2881 p = &(*p)->rb_left;
2882 } else if (dir_ino > entry->ino) {
2883 p = &(*p)->rb_right;
2884 } else {
2885 kfree(odi);
2886 return entry;
2887 }
2888 }
2889
2890 rb_link_node(&odi->node, parent, p);
2891 rb_insert_color(&odi->node, &sctx->orphan_dirs);
2892 return odi;
2893}
2894
2895static struct orphan_dir_info *
2896get_orphan_dir_info(struct send_ctx *sctx, u64 dir_ino)
2897{
2898 struct rb_node *n = sctx->orphan_dirs.rb_node;
2899 struct orphan_dir_info *entry;
2900
2901 while (n) {
2902 entry = rb_entry(n, struct orphan_dir_info, node);
2903 if (dir_ino < entry->ino)
2904 n = n->rb_left;
2905 else if (dir_ino > entry->ino)
2906 n = n->rb_right;
2907 else
2908 return entry;
2909 }
2910 return NULL;
2911}
2912
2913static int is_waiting_for_rm(struct send_ctx *sctx, u64 dir_ino)
2914{
2915 struct orphan_dir_info *odi = get_orphan_dir_info(sctx, dir_ino);
2916
2917 return odi != NULL;
2918}
2919
2920static void free_orphan_dir_info(struct send_ctx *sctx,
2921 struct orphan_dir_info *odi)
2922{
2923 if (!odi)
2924 return;
2925 rb_erase(&odi->node, &sctx->orphan_dirs);
2926 kfree(odi);
2927}
2928
Alexander Block31db9f72012-07-25 23:19:24 +02002929/*
2930 * Returns 1 if a directory can be removed at this point in time.
2931 * We check this by iterating all dir items and checking if the inode behind
2932 * the dir item was already processed.
2933 */
Filipe Manana9dc44212014-02-19 14:31:44 +00002934static int can_rmdir(struct send_ctx *sctx, u64 dir, u64 dir_gen,
2935 u64 send_progress)
Alexander Block31db9f72012-07-25 23:19:24 +02002936{
2937 int ret = 0;
2938 struct btrfs_root *root = sctx->parent_root;
2939 struct btrfs_path *path;
2940 struct btrfs_key key;
2941 struct btrfs_key found_key;
2942 struct btrfs_key loc;
2943 struct btrfs_dir_item *di;
2944
Alexander Block6d85ed052012-08-01 14:48:59 +02002945 /*
2946 * Don't try to rmdir the top/root subvolume dir.
2947 */
2948 if (dir == BTRFS_FIRST_FREE_OBJECTID)
2949 return 0;
2950
Alexander Block31db9f72012-07-25 23:19:24 +02002951 path = alloc_path_for_send();
2952 if (!path)
2953 return -ENOMEM;
2954
2955 key.objectid = dir;
2956 key.type = BTRFS_DIR_INDEX_KEY;
2957 key.offset = 0;
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00002958 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
2959 if (ret < 0)
2960 goto out;
Alexander Block31db9f72012-07-25 23:19:24 +02002961
2962 while (1) {
Filipe Manana9dc44212014-02-19 14:31:44 +00002963 struct waiting_dir_move *dm;
2964
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00002965 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
2966 ret = btrfs_next_leaf(root, path);
2967 if (ret < 0)
2968 goto out;
2969 else if (ret > 0)
2970 break;
2971 continue;
Alexander Block31db9f72012-07-25 23:19:24 +02002972 }
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00002973 btrfs_item_key_to_cpu(path->nodes[0], &found_key,
2974 path->slots[0]);
2975 if (found_key.objectid != key.objectid ||
2976 found_key.type != key.type)
Alexander Block31db9f72012-07-25 23:19:24 +02002977 break;
Alexander Block31db9f72012-07-25 23:19:24 +02002978
2979 di = btrfs_item_ptr(path->nodes[0], path->slots[0],
2980 struct btrfs_dir_item);
2981 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &loc);
2982
Filipe Manana9dc44212014-02-19 14:31:44 +00002983 dm = get_waiting_dir_move(sctx, loc.objectid);
2984 if (dm) {
2985 struct orphan_dir_info *odi;
2986
2987 odi = add_orphan_dir_info(sctx, dir);
2988 if (IS_ERR(odi)) {
2989 ret = PTR_ERR(odi);
2990 goto out;
2991 }
2992 odi->gen = dir_gen;
2993 dm->rmdir_ino = dir;
2994 ret = 0;
2995 goto out;
2996 }
2997
Alexander Block31db9f72012-07-25 23:19:24 +02002998 if (loc.objectid > send_progress) {
Robbie Ko443f9d22015-06-22 17:08:45 +08002999 struct orphan_dir_info *odi;
3000
3001 odi = get_orphan_dir_info(sctx, dir);
3002 free_orphan_dir_info(sctx, odi);
Alexander Block31db9f72012-07-25 23:19:24 +02003003 ret = 0;
3004 goto out;
3005 }
3006
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00003007 path->slots[0]++;
Alexander Block31db9f72012-07-25 23:19:24 +02003008 }
3009
3010 ret = 1;
3011
3012out:
3013 btrfs_free_path(path);
3014 return ret;
3015}
3016
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003017static int is_waiting_for_move(struct send_ctx *sctx, u64 ino)
3018{
Filipe Manana9dc44212014-02-19 14:31:44 +00003019 struct waiting_dir_move *entry = get_waiting_dir_move(sctx, ino);
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003020
Filipe Manana9dc44212014-02-19 14:31:44 +00003021 return entry != NULL;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003022}
3023
Filipe Manana8b191a62015-04-09 14:09:14 +01003024static int add_waiting_dir_move(struct send_ctx *sctx, u64 ino, bool orphanized)
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003025{
3026 struct rb_node **p = &sctx->waiting_dir_moves.rb_node;
3027 struct rb_node *parent = NULL;
3028 struct waiting_dir_move *entry, *dm;
3029
David Sterbae780b0d2016-01-18 18:42:13 +01003030 dm = kmalloc(sizeof(*dm), GFP_KERNEL);
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003031 if (!dm)
3032 return -ENOMEM;
3033 dm->ino = ino;
Filipe Manana9dc44212014-02-19 14:31:44 +00003034 dm->rmdir_ino = 0;
Filipe Manana8b191a62015-04-09 14:09:14 +01003035 dm->orphanized = orphanized;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003036
3037 while (*p) {
3038 parent = *p;
3039 entry = rb_entry(parent, struct waiting_dir_move, node);
3040 if (ino < entry->ino) {
3041 p = &(*p)->rb_left;
3042 } else if (ino > entry->ino) {
3043 p = &(*p)->rb_right;
3044 } else {
3045 kfree(dm);
3046 return -EEXIST;
3047 }
3048 }
3049
3050 rb_link_node(&dm->node, parent, p);
3051 rb_insert_color(&dm->node, &sctx->waiting_dir_moves);
3052 return 0;
3053}
3054
Filipe Manana9dc44212014-02-19 14:31:44 +00003055static struct waiting_dir_move *
3056get_waiting_dir_move(struct send_ctx *sctx, u64 ino)
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003057{
3058 struct rb_node *n = sctx->waiting_dir_moves.rb_node;
3059 struct waiting_dir_move *entry;
3060
3061 while (n) {
3062 entry = rb_entry(n, struct waiting_dir_move, node);
Filipe Manana9dc44212014-02-19 14:31:44 +00003063 if (ino < entry->ino)
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003064 n = n->rb_left;
Filipe Manana9dc44212014-02-19 14:31:44 +00003065 else if (ino > entry->ino)
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003066 n = n->rb_right;
Filipe Manana9dc44212014-02-19 14:31:44 +00003067 else
3068 return entry;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003069 }
Filipe Manana9dc44212014-02-19 14:31:44 +00003070 return NULL;
3071}
3072
3073static void free_waiting_dir_move(struct send_ctx *sctx,
3074 struct waiting_dir_move *dm)
3075{
3076 if (!dm)
3077 return;
3078 rb_erase(&dm->node, &sctx->waiting_dir_moves);
3079 kfree(dm);
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003080}
3081
Filipe Mananabfa7e1f2014-03-19 14:20:54 +00003082static int add_pending_dir_move(struct send_ctx *sctx,
3083 u64 ino,
3084 u64 ino_gen,
Filipe Mananaf9594922014-03-27 20:14:01 +00003085 u64 parent_ino,
3086 struct list_head *new_refs,
Filipe Manana84471e22015-02-28 22:29:22 +00003087 struct list_head *deleted_refs,
3088 const bool is_orphan)
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003089{
3090 struct rb_node **p = &sctx->pending_dir_moves.rb_node;
3091 struct rb_node *parent = NULL;
Chris Mason73b802f2014-03-21 15:30:44 -07003092 struct pending_dir_move *entry = NULL, *pm;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003093 struct recorded_ref *cur;
3094 int exists = 0;
3095 int ret;
3096
David Sterbae780b0d2016-01-18 18:42:13 +01003097 pm = kmalloc(sizeof(*pm), GFP_KERNEL);
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003098 if (!pm)
3099 return -ENOMEM;
3100 pm->parent_ino = parent_ino;
Filipe Mananabfa7e1f2014-03-19 14:20:54 +00003101 pm->ino = ino;
3102 pm->gen = ino_gen;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003103 INIT_LIST_HEAD(&pm->list);
3104 INIT_LIST_HEAD(&pm->update_refs);
3105 RB_CLEAR_NODE(&pm->node);
3106
3107 while (*p) {
3108 parent = *p;
3109 entry = rb_entry(parent, struct pending_dir_move, node);
3110 if (parent_ino < entry->parent_ino) {
3111 p = &(*p)->rb_left;
3112 } else if (parent_ino > entry->parent_ino) {
3113 p = &(*p)->rb_right;
3114 } else {
3115 exists = 1;
3116 break;
3117 }
3118 }
3119
Filipe Mananaf9594922014-03-27 20:14:01 +00003120 list_for_each_entry(cur, deleted_refs, list) {
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003121 ret = dup_ref(cur, &pm->update_refs);
3122 if (ret < 0)
3123 goto out;
3124 }
Filipe Mananaf9594922014-03-27 20:14:01 +00003125 list_for_each_entry(cur, new_refs, list) {
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003126 ret = dup_ref(cur, &pm->update_refs);
3127 if (ret < 0)
3128 goto out;
3129 }
3130
Filipe Manana8b191a62015-04-09 14:09:14 +01003131 ret = add_waiting_dir_move(sctx, pm->ino, is_orphan);
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003132 if (ret)
3133 goto out;
3134
3135 if (exists) {
3136 list_add_tail(&pm->list, &entry->list);
3137 } else {
3138 rb_link_node(&pm->node, parent, p);
3139 rb_insert_color(&pm->node, &sctx->pending_dir_moves);
3140 }
3141 ret = 0;
3142out:
3143 if (ret) {
3144 __free_recorded_refs(&pm->update_refs);
3145 kfree(pm);
3146 }
3147 return ret;
3148}
3149
3150static struct pending_dir_move *get_pending_dir_moves(struct send_ctx *sctx,
3151 u64 parent_ino)
3152{
3153 struct rb_node *n = sctx->pending_dir_moves.rb_node;
3154 struct pending_dir_move *entry;
3155
3156 while (n) {
3157 entry = rb_entry(n, struct pending_dir_move, node);
3158 if (parent_ino < entry->parent_ino)
3159 n = n->rb_left;
3160 else if (parent_ino > entry->parent_ino)
3161 n = n->rb_right;
3162 else
3163 return entry;
3164 }
3165 return NULL;
3166}
3167
Robbie Ko801bec32015-06-23 18:39:46 +08003168static int path_loop(struct send_ctx *sctx, struct fs_path *name,
3169 u64 ino, u64 gen, u64 *ancestor_ino)
3170{
3171 int ret = 0;
3172 u64 parent_inode = 0;
3173 u64 parent_gen = 0;
3174 u64 start_ino = ino;
3175
3176 *ancestor_ino = 0;
3177 while (ino != BTRFS_FIRST_FREE_OBJECTID) {
3178 fs_path_reset(name);
3179
3180 if (is_waiting_for_rm(sctx, ino))
3181 break;
3182 if (is_waiting_for_move(sctx, ino)) {
3183 if (*ancestor_ino == 0)
3184 *ancestor_ino = ino;
3185 ret = get_first_ref(sctx->parent_root, ino,
3186 &parent_inode, &parent_gen, name);
3187 } else {
3188 ret = __get_cur_name_and_parent(sctx, ino, gen,
3189 &parent_inode,
3190 &parent_gen, name);
3191 if (ret > 0) {
3192 ret = 0;
3193 break;
3194 }
3195 }
3196 if (ret < 0)
3197 break;
3198 if (parent_inode == start_ino) {
3199 ret = 1;
3200 if (*ancestor_ino == 0)
3201 *ancestor_ino = ino;
3202 break;
3203 }
3204 ino = parent_inode;
3205 gen = parent_gen;
3206 }
3207 return ret;
3208}
3209
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003210static int apply_dir_move(struct send_ctx *sctx, struct pending_dir_move *pm)
3211{
3212 struct fs_path *from_path = NULL;
3213 struct fs_path *to_path = NULL;
Filipe Manana2b863a12014-02-16 13:43:11 +00003214 struct fs_path *name = NULL;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003215 u64 orig_progress = sctx->send_progress;
3216 struct recorded_ref *cur;
Filipe Manana2b863a12014-02-16 13:43:11 +00003217 u64 parent_ino, parent_gen;
Filipe Manana9dc44212014-02-19 14:31:44 +00003218 struct waiting_dir_move *dm = NULL;
3219 u64 rmdir_ino = 0;
Robbie Ko801bec32015-06-23 18:39:46 +08003220 u64 ancestor;
3221 bool is_orphan;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003222 int ret;
3223
Filipe Manana2b863a12014-02-16 13:43:11 +00003224 name = fs_path_alloc();
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003225 from_path = fs_path_alloc();
Filipe Manana2b863a12014-02-16 13:43:11 +00003226 if (!name || !from_path) {
3227 ret = -ENOMEM;
3228 goto out;
3229 }
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003230
Filipe Manana9dc44212014-02-19 14:31:44 +00003231 dm = get_waiting_dir_move(sctx, pm->ino);
3232 ASSERT(dm);
3233 rmdir_ino = dm->rmdir_ino;
Robbie Ko801bec32015-06-23 18:39:46 +08003234 is_orphan = dm->orphanized;
Filipe Manana9dc44212014-02-19 14:31:44 +00003235 free_waiting_dir_move(sctx, dm);
Filipe Manana2b863a12014-02-16 13:43:11 +00003236
Robbie Ko801bec32015-06-23 18:39:46 +08003237 if (is_orphan) {
Filipe Manana84471e22015-02-28 22:29:22 +00003238 ret = gen_unique_name(sctx, pm->ino,
3239 pm->gen, from_path);
3240 } else {
3241 ret = get_first_ref(sctx->parent_root, pm->ino,
3242 &parent_ino, &parent_gen, name);
3243 if (ret < 0)
3244 goto out;
3245 ret = get_cur_path(sctx, parent_ino, parent_gen,
3246 from_path);
3247 if (ret < 0)
3248 goto out;
3249 ret = fs_path_add_path(from_path, name);
3250 }
Filipe Mananac992ec92014-03-22 17:15:24 +00003251 if (ret < 0)
3252 goto out;
3253
Filipe Mananaf9594922014-03-27 20:14:01 +00003254 sctx->send_progress = sctx->cur_ino + 1;
Robbie Ko801bec32015-06-23 18:39:46 +08003255 ret = path_loop(sctx, name, pm->ino, pm->gen, &ancestor);
Filipe Manana7969e772016-06-17 17:13:36 +01003256 if (ret < 0)
3257 goto out;
Robbie Ko801bec32015-06-23 18:39:46 +08003258 if (ret) {
3259 LIST_HEAD(deleted_refs);
3260 ASSERT(ancestor > BTRFS_FIRST_FREE_OBJECTID);
3261 ret = add_pending_dir_move(sctx, pm->ino, pm->gen, ancestor,
3262 &pm->update_refs, &deleted_refs,
3263 is_orphan);
3264 if (ret < 0)
3265 goto out;
3266 if (rmdir_ino) {
3267 dm = get_waiting_dir_move(sctx, pm->ino);
3268 ASSERT(dm);
3269 dm->rmdir_ino = rmdir_ino;
3270 }
3271 goto out;
3272 }
Filipe Mananac992ec92014-03-22 17:15:24 +00003273 fs_path_reset(name);
3274 to_path = name;
3275 name = NULL;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003276 ret = get_cur_path(sctx, pm->ino, pm->gen, to_path);
3277 if (ret < 0)
3278 goto out;
3279
3280 ret = send_rename(sctx, from_path, to_path);
3281 if (ret < 0)
3282 goto out;
3283
Filipe Manana9dc44212014-02-19 14:31:44 +00003284 if (rmdir_ino) {
3285 struct orphan_dir_info *odi;
3286
3287 odi = get_orphan_dir_info(sctx, rmdir_ino);
3288 if (!odi) {
3289 /* already deleted */
3290 goto finish;
3291 }
Robbie Ko99ea42d2015-06-23 18:39:49 +08003292 ret = can_rmdir(sctx, rmdir_ino, odi->gen, sctx->cur_ino);
Filipe Manana9dc44212014-02-19 14:31:44 +00003293 if (ret < 0)
3294 goto out;
3295 if (!ret)
3296 goto finish;
3297
3298 name = fs_path_alloc();
3299 if (!name) {
3300 ret = -ENOMEM;
3301 goto out;
3302 }
3303 ret = get_cur_path(sctx, rmdir_ino, odi->gen, name);
3304 if (ret < 0)
3305 goto out;
3306 ret = send_rmdir(sctx, name);
3307 if (ret < 0)
3308 goto out;
3309 free_orphan_dir_info(sctx, odi);
3310 }
3311
3312finish:
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003313 ret = send_utimes(sctx, pm->ino, pm->gen);
3314 if (ret < 0)
3315 goto out;
3316
3317 /*
3318 * After rename/move, need to update the utimes of both new parent(s)
3319 * and old parent(s).
3320 */
3321 list_for_each_entry(cur, &pm->update_refs, list) {
Robbie Ko764433a2015-06-23 18:39:50 +08003322 /*
3323 * The parent inode might have been deleted in the send snapshot
3324 */
3325 ret = get_inode_info(sctx->send_root, cur->dir, NULL,
3326 NULL, NULL, NULL, NULL, NULL);
3327 if (ret == -ENOENT) {
3328 ret = 0;
Filipe Manana9dc44212014-02-19 14:31:44 +00003329 continue;
Robbie Ko764433a2015-06-23 18:39:50 +08003330 }
3331 if (ret < 0)
3332 goto out;
3333
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003334 ret = send_utimes(sctx, cur->dir, cur->dir_gen);
3335 if (ret < 0)
3336 goto out;
3337 }
3338
3339out:
Filipe Manana2b863a12014-02-16 13:43:11 +00003340 fs_path_free(name);
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003341 fs_path_free(from_path);
3342 fs_path_free(to_path);
3343 sctx->send_progress = orig_progress;
3344
3345 return ret;
3346}
3347
3348static void free_pending_move(struct send_ctx *sctx, struct pending_dir_move *m)
3349{
3350 if (!list_empty(&m->list))
3351 list_del(&m->list);
3352 if (!RB_EMPTY_NODE(&m->node))
3353 rb_erase(&m->node, &sctx->pending_dir_moves);
3354 __free_recorded_refs(&m->update_refs);
3355 kfree(m);
3356}
3357
3358static void tail_append_pending_moves(struct pending_dir_move *moves,
3359 struct list_head *stack)
3360{
3361 if (list_empty(&moves->list)) {
3362 list_add_tail(&moves->list, stack);
3363 } else {
3364 LIST_HEAD(list);
3365 list_splice_init(&moves->list, &list);
3366 list_add_tail(&moves->list, stack);
3367 list_splice_tail(&list, stack);
3368 }
3369}
3370
3371static int apply_children_dir_moves(struct send_ctx *sctx)
3372{
3373 struct pending_dir_move *pm;
3374 struct list_head stack;
3375 u64 parent_ino = sctx->cur_ino;
3376 int ret = 0;
3377
3378 pm = get_pending_dir_moves(sctx, parent_ino);
3379 if (!pm)
3380 return 0;
3381
3382 INIT_LIST_HEAD(&stack);
3383 tail_append_pending_moves(pm, &stack);
3384
3385 while (!list_empty(&stack)) {
3386 pm = list_first_entry(&stack, struct pending_dir_move, list);
3387 parent_ino = pm->ino;
3388 ret = apply_dir_move(sctx, pm);
3389 free_pending_move(sctx, pm);
3390 if (ret)
3391 goto out;
3392 pm = get_pending_dir_moves(sctx, parent_ino);
3393 if (pm)
3394 tail_append_pending_moves(pm, &stack);
3395 }
3396 return 0;
3397
3398out:
3399 while (!list_empty(&stack)) {
3400 pm = list_first_entry(&stack, struct pending_dir_move, list);
3401 free_pending_move(sctx, pm);
3402 }
3403 return ret;
3404}
3405
Filipe Manana84471e22015-02-28 22:29:22 +00003406/*
3407 * We might need to delay a directory rename even when no ancestor directory
3408 * (in the send root) with a higher inode number than ours (sctx->cur_ino) was
3409 * renamed. This happens when we rename a directory to the old name (the name
3410 * in the parent root) of some other unrelated directory that got its rename
3411 * delayed due to some ancestor with higher number that got renamed.
3412 *
3413 * Example:
3414 *
3415 * Parent snapshot:
3416 * . (ino 256)
3417 * |---- a/ (ino 257)
3418 * | |---- file (ino 260)
3419 * |
3420 * |---- b/ (ino 258)
3421 * |---- c/ (ino 259)
3422 *
3423 * Send snapshot:
3424 * . (ino 256)
3425 * |---- a/ (ino 258)
3426 * |---- x/ (ino 259)
3427 * |---- y/ (ino 257)
3428 * |----- file (ino 260)
3429 *
3430 * Here we can not rename 258 from 'b' to 'a' without the rename of inode 257
3431 * from 'a' to 'x/y' happening first, which in turn depends on the rename of
3432 * inode 259 from 'c' to 'x'. So the order of rename commands the send stream
3433 * must issue is:
3434 *
3435 * 1 - rename 259 from 'c' to 'x'
3436 * 2 - rename 257 from 'a' to 'x/y'
3437 * 3 - rename 258 from 'b' to 'a'
3438 *
3439 * Returns 1 if the rename of sctx->cur_ino needs to be delayed, 0 if it can
3440 * be done right away and < 0 on error.
3441 */
3442static int wait_for_dest_dir_move(struct send_ctx *sctx,
3443 struct recorded_ref *parent_ref,
3444 const bool is_orphan)
3445{
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04003446 struct btrfs_fs_info *fs_info = sctx->parent_root->fs_info;
Filipe Manana84471e22015-02-28 22:29:22 +00003447 struct btrfs_path *path;
3448 struct btrfs_key key;
3449 struct btrfs_key di_key;
3450 struct btrfs_dir_item *di;
3451 u64 left_gen;
3452 u64 right_gen;
3453 int ret = 0;
Robbie Ko801bec32015-06-23 18:39:46 +08003454 struct waiting_dir_move *wdm;
Filipe Manana84471e22015-02-28 22:29:22 +00003455
3456 if (RB_EMPTY_ROOT(&sctx->waiting_dir_moves))
3457 return 0;
3458
3459 path = alloc_path_for_send();
3460 if (!path)
3461 return -ENOMEM;
3462
3463 key.objectid = parent_ref->dir;
3464 key.type = BTRFS_DIR_ITEM_KEY;
3465 key.offset = btrfs_name_hash(parent_ref->name, parent_ref->name_len);
3466
3467 ret = btrfs_search_slot(NULL, sctx->parent_root, &key, path, 0, 0);
3468 if (ret < 0) {
3469 goto out;
3470 } else if (ret > 0) {
3471 ret = 0;
3472 goto out;
3473 }
3474
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04003475 di = btrfs_match_dir_item_name(fs_info, path, parent_ref->name,
3476 parent_ref->name_len);
Filipe Manana84471e22015-02-28 22:29:22 +00003477 if (!di) {
3478 ret = 0;
3479 goto out;
3480 }
3481 /*
3482 * di_key.objectid has the number of the inode that has a dentry in the
3483 * parent directory with the same name that sctx->cur_ino is being
3484 * renamed to. We need to check if that inode is in the send root as
3485 * well and if it is currently marked as an inode with a pending rename,
3486 * if it is, we need to delay the rename of sctx->cur_ino as well, so
3487 * that it happens after that other inode is renamed.
3488 */
3489 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &di_key);
3490 if (di_key.type != BTRFS_INODE_ITEM_KEY) {
3491 ret = 0;
3492 goto out;
3493 }
3494
3495 ret = get_inode_info(sctx->parent_root, di_key.objectid, NULL,
3496 &left_gen, NULL, NULL, NULL, NULL);
3497 if (ret < 0)
3498 goto out;
3499 ret = get_inode_info(sctx->send_root, di_key.objectid, NULL,
3500 &right_gen, NULL, NULL, NULL, NULL);
3501 if (ret < 0) {
3502 if (ret == -ENOENT)
3503 ret = 0;
3504 goto out;
3505 }
3506
3507 /* Different inode, no need to delay the rename of sctx->cur_ino */
3508 if (right_gen != left_gen) {
3509 ret = 0;
3510 goto out;
3511 }
3512
Robbie Ko801bec32015-06-23 18:39:46 +08003513 wdm = get_waiting_dir_move(sctx, di_key.objectid);
3514 if (wdm && !wdm->orphanized) {
Filipe Manana84471e22015-02-28 22:29:22 +00003515 ret = add_pending_dir_move(sctx,
3516 sctx->cur_ino,
3517 sctx->cur_inode_gen,
3518 di_key.objectid,
3519 &sctx->new_refs,
3520 &sctx->deleted_refs,
3521 is_orphan);
3522 if (!ret)
3523 ret = 1;
3524 }
3525out:
3526 btrfs_free_path(path);
3527 return ret;
3528}
3529
Filipe Manana80aa6022015-03-27 17:50:45 +00003530/*
3531 * Check if ino ino1 is an ancestor of inode ino2 in the given root.
3532 * Return 1 if true, 0 if false and < 0 on error.
3533 */
3534static int is_ancestor(struct btrfs_root *root,
3535 const u64 ino1,
3536 const u64 ino1_gen,
3537 const u64 ino2,
3538 struct fs_path *fs_path)
3539{
3540 u64 ino = ino2;
Filipe Manana72c36682017-06-07 11:41:29 +01003541 bool free_path = false;
3542 int ret = 0;
3543
3544 if (!fs_path) {
3545 fs_path = fs_path_alloc();
3546 if (!fs_path)
3547 return -ENOMEM;
3548 free_path = true;
3549 }
Filipe Manana80aa6022015-03-27 17:50:45 +00003550
3551 while (ino > BTRFS_FIRST_FREE_OBJECTID) {
Filipe Manana80aa6022015-03-27 17:50:45 +00003552 u64 parent;
3553 u64 parent_gen;
3554
3555 fs_path_reset(fs_path);
3556 ret = get_first_ref(root, ino, &parent, &parent_gen, fs_path);
3557 if (ret < 0) {
3558 if (ret == -ENOENT && ino == ino2)
3559 ret = 0;
Filipe Manana72c36682017-06-07 11:41:29 +01003560 goto out;
Filipe Manana80aa6022015-03-27 17:50:45 +00003561 }
Filipe Manana72c36682017-06-07 11:41:29 +01003562 if (parent == ino1) {
3563 ret = parent_gen == ino1_gen ? 1 : 0;
3564 goto out;
3565 }
Filipe Manana80aa6022015-03-27 17:50:45 +00003566 ino = parent;
3567 }
Filipe Manana72c36682017-06-07 11:41:29 +01003568 out:
3569 if (free_path)
3570 fs_path_free(fs_path);
3571 return ret;
Filipe Manana80aa6022015-03-27 17:50:45 +00003572}
3573
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003574static int wait_for_parent_move(struct send_ctx *sctx,
Filipe Manana8b191a62015-04-09 14:09:14 +01003575 struct recorded_ref *parent_ref,
3576 const bool is_orphan)
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003577{
Filipe Mananaf9594922014-03-27 20:14:01 +00003578 int ret = 0;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003579 u64 ino = parent_ref->dir;
Filipe Mananafe9c7982017-01-11 02:15:39 +00003580 u64 ino_gen = parent_ref->dir_gen;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003581 u64 parent_ino_before, parent_ino_after;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003582 struct fs_path *path_before = NULL;
3583 struct fs_path *path_after = NULL;
3584 int len1, len2;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003585
3586 path_after = fs_path_alloc();
Filipe Mananaf9594922014-03-27 20:14:01 +00003587 path_before = fs_path_alloc();
3588 if (!path_after || !path_before) {
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003589 ret = -ENOMEM;
3590 goto out;
3591 }
3592
Filipe Mananabfa7e1f2014-03-19 14:20:54 +00003593 /*
Filipe Mananaf9594922014-03-27 20:14:01 +00003594 * Our current directory inode may not yet be renamed/moved because some
3595 * ancestor (immediate or not) has to be renamed/moved first. So find if
3596 * such ancestor exists and make sure our own rename/move happens after
Filipe Manana80aa6022015-03-27 17:50:45 +00003597 * that ancestor is processed to avoid path build infinite loops (done
3598 * at get_cur_path()).
Filipe Mananabfa7e1f2014-03-19 14:20:54 +00003599 */
Filipe Mananaf9594922014-03-27 20:14:01 +00003600 while (ino > BTRFS_FIRST_FREE_OBJECTID) {
Filipe Mananafe9c7982017-01-11 02:15:39 +00003601 u64 parent_ino_after_gen;
3602
Filipe Mananaf9594922014-03-27 20:14:01 +00003603 if (is_waiting_for_move(sctx, ino)) {
Filipe Manana80aa6022015-03-27 17:50:45 +00003604 /*
3605 * If the current inode is an ancestor of ino in the
3606 * parent root, we need to delay the rename of the
3607 * current inode, otherwise don't delayed the rename
3608 * because we can end up with a circular dependency
3609 * of renames, resulting in some directories never
3610 * getting the respective rename operations issued in
3611 * the send stream or getting into infinite path build
3612 * loops.
3613 */
3614 ret = is_ancestor(sctx->parent_root,
3615 sctx->cur_ino, sctx->cur_inode_gen,
3616 ino, path_before);
Filipe Manana4122ea62016-06-27 16:54:44 +01003617 if (ret)
3618 break;
Filipe Mananaf9594922014-03-27 20:14:01 +00003619 }
Filipe Mananabfa7e1f2014-03-19 14:20:54 +00003620
3621 fs_path_reset(path_before);
3622 fs_path_reset(path_after);
3623
3624 ret = get_first_ref(sctx->send_root, ino, &parent_ino_after,
Filipe Mananafe9c7982017-01-11 02:15:39 +00003625 &parent_ino_after_gen, path_after);
Filipe Mananabfa7e1f2014-03-19 14:20:54 +00003626 if (ret < 0)
3627 goto out;
3628 ret = get_first_ref(sctx->parent_root, ino, &parent_ino_before,
3629 NULL, path_before);
Filipe Mananaf9594922014-03-27 20:14:01 +00003630 if (ret < 0 && ret != -ENOENT) {
Filipe Mananabfa7e1f2014-03-19 14:20:54 +00003631 goto out;
Filipe Mananaf9594922014-03-27 20:14:01 +00003632 } else if (ret == -ENOENT) {
Filipe Mananabf8e8ca2014-10-02 19:17:32 +01003633 ret = 0;
Filipe Mananaf9594922014-03-27 20:14:01 +00003634 break;
Filipe Mananabfa7e1f2014-03-19 14:20:54 +00003635 }
3636
3637 len1 = fs_path_len(path_before);
3638 len2 = fs_path_len(path_after);
Filipe Mananaf9594922014-03-27 20:14:01 +00003639 if (ino > sctx->cur_ino &&
3640 (parent_ino_before != parent_ino_after || len1 != len2 ||
3641 memcmp(path_before->start, path_after->start, len1))) {
Filipe Mananafe9c7982017-01-11 02:15:39 +00003642 u64 parent_ino_gen;
3643
3644 ret = get_inode_info(sctx->parent_root, ino, NULL,
3645 &parent_ino_gen, NULL, NULL, NULL,
3646 NULL);
3647 if (ret < 0)
3648 goto out;
3649 if (ino_gen == parent_ino_gen) {
3650 ret = 1;
3651 break;
3652 }
Filipe Mananabfa7e1f2014-03-19 14:20:54 +00003653 }
Filipe Mananabfa7e1f2014-03-19 14:20:54 +00003654 ino = parent_ino_after;
Filipe Mananafe9c7982017-01-11 02:15:39 +00003655 ino_gen = parent_ino_after_gen;
Filipe Mananabfa7e1f2014-03-19 14:20:54 +00003656 }
3657
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003658out:
3659 fs_path_free(path_before);
3660 fs_path_free(path_after);
3661
Filipe Mananaf9594922014-03-27 20:14:01 +00003662 if (ret == 1) {
3663 ret = add_pending_dir_move(sctx,
3664 sctx->cur_ino,
3665 sctx->cur_inode_gen,
3666 ino,
3667 &sctx->new_refs,
Filipe Manana84471e22015-02-28 22:29:22 +00003668 &sctx->deleted_refs,
Filipe Manana8b191a62015-04-09 14:09:14 +01003669 is_orphan);
Filipe Mananaf9594922014-03-27 20:14:01 +00003670 if (!ret)
3671 ret = 1;
3672 }
3673
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003674 return ret;
3675}
3676
Alexander Block31db9f72012-07-25 23:19:24 +02003677/*
3678 * This does all the move/link/unlink/rmdir magic.
3679 */
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003680static int process_recorded_refs(struct send_ctx *sctx, int *pending_move)
Alexander Block31db9f72012-07-25 23:19:24 +02003681{
Jeff Mahoney04ab9562016-09-20 10:05:03 -04003682 struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;
Alexander Block31db9f72012-07-25 23:19:24 +02003683 int ret = 0;
3684 struct recorded_ref *cur;
Alexander Block1f4692d2012-07-28 10:42:24 +02003685 struct recorded_ref *cur2;
Josef Bacikba5e8f22013-08-16 16:52:55 -04003686 struct list_head check_dirs;
Alexander Block31db9f72012-07-25 23:19:24 +02003687 struct fs_path *valid_path = NULL;
Chris Masonb24baf62012-07-25 19:21:10 -04003688 u64 ow_inode = 0;
Alexander Block31db9f72012-07-25 23:19:24 +02003689 u64 ow_gen;
3690 int did_overwrite = 0;
3691 int is_orphan = 0;
Filipe Manana29d6d302014-02-16 21:01:39 +00003692 u64 last_dir_ino_rm = 0;
Filipe Manana84471e22015-02-28 22:29:22 +00003693 bool can_rename = true;
Alexander Block31db9f72012-07-25 23:19:24 +02003694
Jeff Mahoney04ab9562016-09-20 10:05:03 -04003695 btrfs_debug(fs_info, "process_recorded_refs %llu", sctx->cur_ino);
Alexander Block31db9f72012-07-25 23:19:24 +02003696
Alexander Block6d85ed052012-08-01 14:48:59 +02003697 /*
3698 * This should never happen as the root dir always has the same ref
3699 * which is always '..'
3700 */
3701 BUG_ON(sctx->cur_ino <= BTRFS_FIRST_FREE_OBJECTID);
Josef Bacikba5e8f22013-08-16 16:52:55 -04003702 INIT_LIST_HEAD(&check_dirs);
Alexander Block6d85ed052012-08-01 14:48:59 +02003703
Tsutomu Itoh924794c2013-05-08 07:51:52 +00003704 valid_path = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +02003705 if (!valid_path) {
3706 ret = -ENOMEM;
3707 goto out;
3708 }
3709
Alexander Block31db9f72012-07-25 23:19:24 +02003710 /*
3711 * First, check if the first ref of the current inode was overwritten
3712 * before. If yes, we know that the current inode was already orphanized
3713 * and thus use the orphan name. If not, we can use get_cur_path to
3714 * get the path of the first ref as it would like while receiving at
3715 * this point in time.
3716 * New inodes are always orphan at the beginning, so force to use the
3717 * orphan name in this case.
3718 * The first ref is stored in valid_path and will be updated if it
3719 * gets moved around.
3720 */
3721 if (!sctx->cur_inode_new) {
3722 ret = did_overwrite_first_ref(sctx, sctx->cur_ino,
3723 sctx->cur_inode_gen);
3724 if (ret < 0)
3725 goto out;
3726 if (ret)
3727 did_overwrite = 1;
3728 }
3729 if (sctx->cur_inode_new || did_overwrite) {
3730 ret = gen_unique_name(sctx, sctx->cur_ino,
3731 sctx->cur_inode_gen, valid_path);
3732 if (ret < 0)
3733 goto out;
3734 is_orphan = 1;
3735 } else {
3736 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen,
3737 valid_path);
3738 if (ret < 0)
3739 goto out;
3740 }
3741
3742 list_for_each_entry(cur, &sctx->new_refs, list) {
3743 /*
Alexander Block1f4692d2012-07-28 10:42:24 +02003744 * We may have refs where the parent directory does not exist
3745 * yet. This happens if the parent directories inum is higher
3746 * the the current inum. To handle this case, we create the
3747 * parent directory out of order. But we need to check if this
3748 * did already happen before due to other refs in the same dir.
3749 */
3750 ret = get_cur_inode_state(sctx, cur->dir, cur->dir_gen);
3751 if (ret < 0)
3752 goto out;
3753 if (ret == inode_state_will_create) {
3754 ret = 0;
3755 /*
3756 * First check if any of the current inodes refs did
3757 * already create the dir.
3758 */
3759 list_for_each_entry(cur2, &sctx->new_refs, list) {
3760 if (cur == cur2)
3761 break;
3762 if (cur2->dir == cur->dir) {
3763 ret = 1;
3764 break;
3765 }
3766 }
3767
3768 /*
3769 * If that did not happen, check if a previous inode
3770 * did already create the dir.
3771 */
3772 if (!ret)
3773 ret = did_create_dir(sctx, cur->dir);
3774 if (ret < 0)
3775 goto out;
3776 if (!ret) {
3777 ret = send_create_inode(sctx, cur->dir);
3778 if (ret < 0)
3779 goto out;
3780 }
3781 }
3782
3783 /*
Alexander Block31db9f72012-07-25 23:19:24 +02003784 * Check if this new ref would overwrite the first ref of
3785 * another unprocessed inode. If yes, orphanize the
3786 * overwritten inode. If we find an overwritten ref that is
3787 * not the first ref, simply unlink it.
3788 */
3789 ret = will_overwrite_ref(sctx, cur->dir, cur->dir_gen,
3790 cur->name, cur->name_len,
3791 &ow_inode, &ow_gen);
3792 if (ret < 0)
3793 goto out;
3794 if (ret) {
Tsutomu Itoh924794c2013-05-08 07:51:52 +00003795 ret = is_first_ref(sctx->parent_root,
3796 ow_inode, cur->dir, cur->name,
3797 cur->name_len);
Alexander Block31db9f72012-07-25 23:19:24 +02003798 if (ret < 0)
3799 goto out;
3800 if (ret) {
Filipe Manana8996a482015-03-12 15:16:20 +00003801 struct name_cache_entry *nce;
Robbie Ko801bec32015-06-23 18:39:46 +08003802 struct waiting_dir_move *wdm;
Filipe Manana8996a482015-03-12 15:16:20 +00003803
Alexander Block31db9f72012-07-25 23:19:24 +02003804 ret = orphanize_inode(sctx, ow_inode, ow_gen,
3805 cur->full_path);
3806 if (ret < 0)
3807 goto out;
Robbie Ko801bec32015-06-23 18:39:46 +08003808
3809 /*
3810 * If ow_inode has its rename operation delayed
3811 * make sure that its orphanized name is used in
3812 * the source path when performing its rename
3813 * operation.
3814 */
3815 if (is_waiting_for_move(sctx, ow_inode)) {
3816 wdm = get_waiting_dir_move(sctx,
3817 ow_inode);
3818 ASSERT(wdm);
3819 wdm->orphanized = true;
3820 }
3821
Filipe Manana8996a482015-03-12 15:16:20 +00003822 /*
3823 * Make sure we clear our orphanized inode's
3824 * name from the name cache. This is because the
3825 * inode ow_inode might be an ancestor of some
3826 * other inode that will be orphanized as well
3827 * later and has an inode number greater than
3828 * sctx->send_progress. We need to prevent
3829 * future name lookups from using the old name
3830 * and get instead the orphan name.
3831 */
3832 nce = name_cache_search(sctx, ow_inode, ow_gen);
3833 if (nce) {
3834 name_cache_delete(sctx, nce);
3835 kfree(nce);
3836 }
Robbie Ko801bec32015-06-23 18:39:46 +08003837
3838 /*
3839 * ow_inode might currently be an ancestor of
3840 * cur_ino, therefore compute valid_path (the
3841 * current path of cur_ino) again because it
3842 * might contain the pre-orphanization name of
3843 * ow_inode, which is no longer valid.
3844 */
Filipe Manana72c36682017-06-07 11:41:29 +01003845 ret = is_ancestor(sctx->parent_root,
3846 ow_inode, ow_gen,
3847 sctx->cur_ino, NULL);
3848 if (ret > 0) {
3849 fs_path_reset(valid_path);
3850 ret = get_cur_path(sctx, sctx->cur_ino,
3851 sctx->cur_inode_gen,
3852 valid_path);
3853 }
Robbie Ko801bec32015-06-23 18:39:46 +08003854 if (ret < 0)
3855 goto out;
Alexander Block31db9f72012-07-25 23:19:24 +02003856 } else {
3857 ret = send_unlink(sctx, cur->full_path);
3858 if (ret < 0)
3859 goto out;
3860 }
3861 }
3862
Filipe Manana84471e22015-02-28 22:29:22 +00003863 if (S_ISDIR(sctx->cur_inode_mode) && sctx->parent_root) {
3864 ret = wait_for_dest_dir_move(sctx, cur, is_orphan);
3865 if (ret < 0)
3866 goto out;
3867 if (ret == 1) {
3868 can_rename = false;
3869 *pending_move = 1;
3870 }
3871 }
3872
Filipe Manana8b191a62015-04-09 14:09:14 +01003873 if (S_ISDIR(sctx->cur_inode_mode) && sctx->parent_root &&
3874 can_rename) {
3875 ret = wait_for_parent_move(sctx, cur, is_orphan);
3876 if (ret < 0)
3877 goto out;
3878 if (ret == 1) {
3879 can_rename = false;
3880 *pending_move = 1;
3881 }
3882 }
3883
Alexander Block31db9f72012-07-25 23:19:24 +02003884 /*
3885 * link/move the ref to the new place. If we have an orphan
3886 * inode, move it and update valid_path. If not, link or move
3887 * it depending on the inode mode.
3888 */
Filipe Manana84471e22015-02-28 22:29:22 +00003889 if (is_orphan && can_rename) {
Alexander Block31db9f72012-07-25 23:19:24 +02003890 ret = send_rename(sctx, valid_path, cur->full_path);
3891 if (ret < 0)
3892 goto out;
3893 is_orphan = 0;
3894 ret = fs_path_copy(valid_path, cur->full_path);
3895 if (ret < 0)
3896 goto out;
Filipe Manana84471e22015-02-28 22:29:22 +00003897 } else if (can_rename) {
Alexander Block31db9f72012-07-25 23:19:24 +02003898 if (S_ISDIR(sctx->cur_inode_mode)) {
3899 /*
3900 * Dirs can't be linked, so move it. For moved
3901 * dirs, we always have one new and one deleted
3902 * ref. The deleted ref is ignored later.
3903 */
Filipe Manana8b191a62015-04-09 14:09:14 +01003904 ret = send_rename(sctx, valid_path,
3905 cur->full_path);
3906 if (!ret)
3907 ret = fs_path_copy(valid_path,
3908 cur->full_path);
Alexander Block31db9f72012-07-25 23:19:24 +02003909 if (ret < 0)
3910 goto out;
3911 } else {
3912 ret = send_link(sctx, cur->full_path,
3913 valid_path);
3914 if (ret < 0)
3915 goto out;
3916 }
3917 }
Josef Bacikba5e8f22013-08-16 16:52:55 -04003918 ret = dup_ref(cur, &check_dirs);
Alexander Block31db9f72012-07-25 23:19:24 +02003919 if (ret < 0)
3920 goto out;
3921 }
3922
3923 if (S_ISDIR(sctx->cur_inode_mode) && sctx->cur_inode_deleted) {
3924 /*
3925 * Check if we can already rmdir the directory. If not,
3926 * orphanize it. For every dir item inside that gets deleted
3927 * later, we do this check again and rmdir it then if possible.
3928 * See the use of check_dirs for more details.
3929 */
Filipe Manana9dc44212014-02-19 14:31:44 +00003930 ret = can_rmdir(sctx, sctx->cur_ino, sctx->cur_inode_gen,
3931 sctx->cur_ino);
Alexander Block31db9f72012-07-25 23:19:24 +02003932 if (ret < 0)
3933 goto out;
3934 if (ret) {
3935 ret = send_rmdir(sctx, valid_path);
3936 if (ret < 0)
3937 goto out;
3938 } else if (!is_orphan) {
3939 ret = orphanize_inode(sctx, sctx->cur_ino,
3940 sctx->cur_inode_gen, valid_path);
3941 if (ret < 0)
3942 goto out;
3943 is_orphan = 1;
3944 }
3945
3946 list_for_each_entry(cur, &sctx->deleted_refs, list) {
Josef Bacikba5e8f22013-08-16 16:52:55 -04003947 ret = dup_ref(cur, &check_dirs);
Alexander Block31db9f72012-07-25 23:19:24 +02003948 if (ret < 0)
3949 goto out;
3950 }
Alexander Blockccf16262012-07-28 11:46:29 +02003951 } else if (S_ISDIR(sctx->cur_inode_mode) &&
3952 !list_empty(&sctx->deleted_refs)) {
3953 /*
3954 * We have a moved dir. Add the old parent to check_dirs
3955 */
3956 cur = list_entry(sctx->deleted_refs.next, struct recorded_ref,
3957 list);
Josef Bacikba5e8f22013-08-16 16:52:55 -04003958 ret = dup_ref(cur, &check_dirs);
Alexander Blockccf16262012-07-28 11:46:29 +02003959 if (ret < 0)
3960 goto out;
Alexander Block31db9f72012-07-25 23:19:24 +02003961 } else if (!S_ISDIR(sctx->cur_inode_mode)) {
3962 /*
3963 * We have a non dir inode. Go through all deleted refs and
3964 * unlink them if they were not already overwritten by other
3965 * inodes.
3966 */
3967 list_for_each_entry(cur, &sctx->deleted_refs, list) {
3968 ret = did_overwrite_ref(sctx, cur->dir, cur->dir_gen,
3969 sctx->cur_ino, sctx->cur_inode_gen,
3970 cur->name, cur->name_len);
3971 if (ret < 0)
3972 goto out;
3973 if (!ret) {
Alexander Block1f4692d2012-07-28 10:42:24 +02003974 ret = send_unlink(sctx, cur->full_path);
3975 if (ret < 0)
3976 goto out;
Alexander Block31db9f72012-07-25 23:19:24 +02003977 }
Josef Bacikba5e8f22013-08-16 16:52:55 -04003978 ret = dup_ref(cur, &check_dirs);
Alexander Block31db9f72012-07-25 23:19:24 +02003979 if (ret < 0)
3980 goto out;
3981 }
Alexander Block31db9f72012-07-25 23:19:24 +02003982 /*
3983 * If the inode is still orphan, unlink the orphan. This may
3984 * happen when a previous inode did overwrite the first ref
3985 * of this inode and no new refs were added for the current
Alexander Block766702e2012-07-28 14:11:31 +02003986 * inode. Unlinking does not mean that the inode is deleted in
3987 * all cases. There may still be links to this inode in other
3988 * places.
Alexander Block31db9f72012-07-25 23:19:24 +02003989 */
Alexander Block1f4692d2012-07-28 10:42:24 +02003990 if (is_orphan) {
Alexander Block31db9f72012-07-25 23:19:24 +02003991 ret = send_unlink(sctx, valid_path);
3992 if (ret < 0)
3993 goto out;
3994 }
3995 }
3996
3997 /*
3998 * We did collect all parent dirs where cur_inode was once located. We
3999 * now go through all these dirs and check if they are pending for
4000 * deletion and if it's finally possible to perform the rmdir now.
4001 * We also update the inode stats of the parent dirs here.
4002 */
Josef Bacikba5e8f22013-08-16 16:52:55 -04004003 list_for_each_entry(cur, &check_dirs, list) {
Alexander Block766702e2012-07-28 14:11:31 +02004004 /*
4005 * In case we had refs into dirs that were not processed yet,
4006 * we don't need to do the utime and rmdir logic for these dirs.
4007 * The dir will be processed later.
4008 */
Josef Bacikba5e8f22013-08-16 16:52:55 -04004009 if (cur->dir > sctx->cur_ino)
Alexander Block31db9f72012-07-25 23:19:24 +02004010 continue;
4011
Josef Bacikba5e8f22013-08-16 16:52:55 -04004012 ret = get_cur_inode_state(sctx, cur->dir, cur->dir_gen);
Alexander Block31db9f72012-07-25 23:19:24 +02004013 if (ret < 0)
4014 goto out;
4015
4016 if (ret == inode_state_did_create ||
4017 ret == inode_state_no_change) {
4018 /* TODO delayed utimes */
Josef Bacikba5e8f22013-08-16 16:52:55 -04004019 ret = send_utimes(sctx, cur->dir, cur->dir_gen);
Alexander Block31db9f72012-07-25 23:19:24 +02004020 if (ret < 0)
4021 goto out;
Filipe Manana29d6d302014-02-16 21:01:39 +00004022 } else if (ret == inode_state_did_delete &&
4023 cur->dir != last_dir_ino_rm) {
Filipe Manana9dc44212014-02-19 14:31:44 +00004024 ret = can_rmdir(sctx, cur->dir, cur->dir_gen,
4025 sctx->cur_ino);
Alexander Block31db9f72012-07-25 23:19:24 +02004026 if (ret < 0)
4027 goto out;
4028 if (ret) {
Josef Bacikba5e8f22013-08-16 16:52:55 -04004029 ret = get_cur_path(sctx, cur->dir,
4030 cur->dir_gen, valid_path);
Alexander Block31db9f72012-07-25 23:19:24 +02004031 if (ret < 0)
4032 goto out;
4033 ret = send_rmdir(sctx, valid_path);
4034 if (ret < 0)
4035 goto out;
Filipe Manana29d6d302014-02-16 21:01:39 +00004036 last_dir_ino_rm = cur->dir;
Alexander Block31db9f72012-07-25 23:19:24 +02004037 }
4038 }
4039 }
4040
Alexander Block31db9f72012-07-25 23:19:24 +02004041 ret = 0;
4042
4043out:
Josef Bacikba5e8f22013-08-16 16:52:55 -04004044 __free_recorded_refs(&check_dirs);
Alexander Block31db9f72012-07-25 23:19:24 +02004045 free_recorded_refs(sctx);
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004046 fs_path_free(valid_path);
Alexander Block31db9f72012-07-25 23:19:24 +02004047 return ret;
4048}
4049
Liu Boa4d96d62014-03-03 21:31:03 +08004050static int record_ref(struct btrfs_root *root, int num, u64 dir, int index,
4051 struct fs_path *name, void *ctx, struct list_head *refs)
Alexander Block31db9f72012-07-25 23:19:24 +02004052{
4053 int ret = 0;
4054 struct send_ctx *sctx = ctx;
4055 struct fs_path *p;
4056 u64 gen;
4057
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004058 p = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +02004059 if (!p)
4060 return -ENOMEM;
4061
Liu Boa4d96d62014-03-03 21:31:03 +08004062 ret = get_inode_info(root, dir, NULL, &gen, NULL, NULL,
Alexander Block85a7b332012-07-26 23:39:10 +02004063 NULL, NULL);
Alexander Block31db9f72012-07-25 23:19:24 +02004064 if (ret < 0)
4065 goto out;
4066
Alexander Block31db9f72012-07-25 23:19:24 +02004067 ret = get_cur_path(sctx, dir, gen, p);
4068 if (ret < 0)
4069 goto out;
4070 ret = fs_path_add_path(p, name);
4071 if (ret < 0)
4072 goto out;
4073
Liu Boa4d96d62014-03-03 21:31:03 +08004074 ret = __record_ref(refs, dir, gen, p);
Alexander Block31db9f72012-07-25 23:19:24 +02004075
4076out:
4077 if (ret)
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004078 fs_path_free(p);
Alexander Block31db9f72012-07-25 23:19:24 +02004079 return ret;
4080}
4081
Liu Boa4d96d62014-03-03 21:31:03 +08004082static int __record_new_ref(int num, u64 dir, int index,
4083 struct fs_path *name,
4084 void *ctx)
4085{
4086 struct send_ctx *sctx = ctx;
4087 return record_ref(sctx->send_root, num, dir, index, name,
4088 ctx, &sctx->new_refs);
4089}
4090
4091
Alexander Block31db9f72012-07-25 23:19:24 +02004092static int __record_deleted_ref(int num, u64 dir, int index,
4093 struct fs_path *name,
4094 void *ctx)
4095{
Alexander Block31db9f72012-07-25 23:19:24 +02004096 struct send_ctx *sctx = ctx;
Liu Boa4d96d62014-03-03 21:31:03 +08004097 return record_ref(sctx->parent_root, num, dir, index, name,
4098 ctx, &sctx->deleted_refs);
Alexander Block31db9f72012-07-25 23:19:24 +02004099}
4100
4101static int record_new_ref(struct send_ctx *sctx)
4102{
4103 int ret;
4104
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004105 ret = iterate_inode_ref(sctx->send_root, sctx->left_path,
4106 sctx->cmp_key, 0, __record_new_ref, sctx);
Alexander Block31db9f72012-07-25 23:19:24 +02004107 if (ret < 0)
4108 goto out;
4109 ret = 0;
4110
4111out:
4112 return ret;
4113}
4114
4115static int record_deleted_ref(struct send_ctx *sctx)
4116{
4117 int ret;
4118
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004119 ret = iterate_inode_ref(sctx->parent_root, sctx->right_path,
4120 sctx->cmp_key, 0, __record_deleted_ref, sctx);
Alexander Block31db9f72012-07-25 23:19:24 +02004121 if (ret < 0)
4122 goto out;
4123 ret = 0;
4124
4125out:
4126 return ret;
4127}
4128
4129struct find_ref_ctx {
4130 u64 dir;
Josef Bacikba5e8f22013-08-16 16:52:55 -04004131 u64 dir_gen;
4132 struct btrfs_root *root;
Alexander Block31db9f72012-07-25 23:19:24 +02004133 struct fs_path *name;
4134 int found_idx;
4135};
4136
4137static int __find_iref(int num, u64 dir, int index,
4138 struct fs_path *name,
4139 void *ctx_)
4140{
4141 struct find_ref_ctx *ctx = ctx_;
Josef Bacikba5e8f22013-08-16 16:52:55 -04004142 u64 dir_gen;
4143 int ret;
Alexander Block31db9f72012-07-25 23:19:24 +02004144
4145 if (dir == ctx->dir && fs_path_len(name) == fs_path_len(ctx->name) &&
4146 strncmp(name->start, ctx->name->start, fs_path_len(name)) == 0) {
Josef Bacikba5e8f22013-08-16 16:52:55 -04004147 /*
4148 * To avoid doing extra lookups we'll only do this if everything
4149 * else matches.
4150 */
4151 ret = get_inode_info(ctx->root, dir, NULL, &dir_gen, NULL,
4152 NULL, NULL, NULL);
4153 if (ret)
4154 return ret;
4155 if (dir_gen != ctx->dir_gen)
4156 return 0;
Alexander Block31db9f72012-07-25 23:19:24 +02004157 ctx->found_idx = num;
4158 return 1;
4159 }
4160 return 0;
4161}
4162
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004163static int find_iref(struct btrfs_root *root,
Alexander Block31db9f72012-07-25 23:19:24 +02004164 struct btrfs_path *path,
4165 struct btrfs_key *key,
Josef Bacikba5e8f22013-08-16 16:52:55 -04004166 u64 dir, u64 dir_gen, struct fs_path *name)
Alexander Block31db9f72012-07-25 23:19:24 +02004167{
4168 int ret;
4169 struct find_ref_ctx ctx;
4170
4171 ctx.dir = dir;
4172 ctx.name = name;
Josef Bacikba5e8f22013-08-16 16:52:55 -04004173 ctx.dir_gen = dir_gen;
Alexander Block31db9f72012-07-25 23:19:24 +02004174 ctx.found_idx = -1;
Josef Bacikba5e8f22013-08-16 16:52:55 -04004175 ctx.root = root;
Alexander Block31db9f72012-07-25 23:19:24 +02004176
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004177 ret = iterate_inode_ref(root, path, key, 0, __find_iref, &ctx);
Alexander Block31db9f72012-07-25 23:19:24 +02004178 if (ret < 0)
4179 return ret;
4180
4181 if (ctx.found_idx == -1)
4182 return -ENOENT;
4183
4184 return ctx.found_idx;
4185}
4186
4187static int __record_changed_new_ref(int num, u64 dir, int index,
4188 struct fs_path *name,
4189 void *ctx)
4190{
Josef Bacikba5e8f22013-08-16 16:52:55 -04004191 u64 dir_gen;
Alexander Block31db9f72012-07-25 23:19:24 +02004192 int ret;
4193 struct send_ctx *sctx = ctx;
4194
Josef Bacikba5e8f22013-08-16 16:52:55 -04004195 ret = get_inode_info(sctx->send_root, dir, NULL, &dir_gen, NULL,
4196 NULL, NULL, NULL);
4197 if (ret)
4198 return ret;
4199
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004200 ret = find_iref(sctx->parent_root, sctx->right_path,
Josef Bacikba5e8f22013-08-16 16:52:55 -04004201 sctx->cmp_key, dir, dir_gen, name);
Alexander Block31db9f72012-07-25 23:19:24 +02004202 if (ret == -ENOENT)
4203 ret = __record_new_ref(num, dir, index, name, sctx);
4204 else if (ret > 0)
4205 ret = 0;
4206
4207 return ret;
4208}
4209
4210static int __record_changed_deleted_ref(int num, u64 dir, int index,
4211 struct fs_path *name,
4212 void *ctx)
4213{
Josef Bacikba5e8f22013-08-16 16:52:55 -04004214 u64 dir_gen;
Alexander Block31db9f72012-07-25 23:19:24 +02004215 int ret;
4216 struct send_ctx *sctx = ctx;
4217
Josef Bacikba5e8f22013-08-16 16:52:55 -04004218 ret = get_inode_info(sctx->parent_root, dir, NULL, &dir_gen, NULL,
4219 NULL, NULL, NULL);
4220 if (ret)
4221 return ret;
4222
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004223 ret = find_iref(sctx->send_root, sctx->left_path, sctx->cmp_key,
Josef Bacikba5e8f22013-08-16 16:52:55 -04004224 dir, dir_gen, name);
Alexander Block31db9f72012-07-25 23:19:24 +02004225 if (ret == -ENOENT)
4226 ret = __record_deleted_ref(num, dir, index, name, sctx);
4227 else if (ret > 0)
4228 ret = 0;
4229
4230 return ret;
4231}
4232
4233static int record_changed_ref(struct send_ctx *sctx)
4234{
4235 int ret = 0;
4236
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004237 ret = iterate_inode_ref(sctx->send_root, sctx->left_path,
Alexander Block31db9f72012-07-25 23:19:24 +02004238 sctx->cmp_key, 0, __record_changed_new_ref, sctx);
4239 if (ret < 0)
4240 goto out;
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004241 ret = iterate_inode_ref(sctx->parent_root, sctx->right_path,
Alexander Block31db9f72012-07-25 23:19:24 +02004242 sctx->cmp_key, 0, __record_changed_deleted_ref, sctx);
4243 if (ret < 0)
4244 goto out;
4245 ret = 0;
4246
4247out:
4248 return ret;
4249}
4250
4251/*
4252 * Record and process all refs at once. Needed when an inode changes the
4253 * generation number, which means that it was deleted and recreated.
4254 */
4255static int process_all_refs(struct send_ctx *sctx,
4256 enum btrfs_compare_tree_result cmd)
4257{
4258 int ret;
4259 struct btrfs_root *root;
4260 struct btrfs_path *path;
4261 struct btrfs_key key;
4262 struct btrfs_key found_key;
4263 struct extent_buffer *eb;
4264 int slot;
4265 iterate_inode_ref_t cb;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00004266 int pending_move = 0;
Alexander Block31db9f72012-07-25 23:19:24 +02004267
4268 path = alloc_path_for_send();
4269 if (!path)
4270 return -ENOMEM;
4271
4272 if (cmd == BTRFS_COMPARE_TREE_NEW) {
4273 root = sctx->send_root;
4274 cb = __record_new_ref;
4275 } else if (cmd == BTRFS_COMPARE_TREE_DELETED) {
4276 root = sctx->parent_root;
4277 cb = __record_deleted_ref;
4278 } else {
David Sterba4d1a63b2014-02-03 19:24:19 +01004279 btrfs_err(sctx->send_root->fs_info,
4280 "Wrong command %d in process_all_refs", cmd);
4281 ret = -EINVAL;
4282 goto out;
Alexander Block31db9f72012-07-25 23:19:24 +02004283 }
4284
4285 key.objectid = sctx->cmp_key->objectid;
4286 key.type = BTRFS_INODE_REF_KEY;
4287 key.offset = 0;
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00004288 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
4289 if (ret < 0)
4290 goto out;
Alexander Block31db9f72012-07-25 23:19:24 +02004291
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00004292 while (1) {
Alexander Block31db9f72012-07-25 23:19:24 +02004293 eb = path->nodes[0];
4294 slot = path->slots[0];
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00004295 if (slot >= btrfs_header_nritems(eb)) {
4296 ret = btrfs_next_leaf(root, path);
4297 if (ret < 0)
4298 goto out;
4299 else if (ret > 0)
4300 break;
4301 continue;
4302 }
4303
Alexander Block31db9f72012-07-25 23:19:24 +02004304 btrfs_item_key_to_cpu(eb, &found_key, slot);
4305
4306 if (found_key.objectid != key.objectid ||
Jan Schmidt96b5bd72012-10-15 08:30:45 +00004307 (found_key.type != BTRFS_INODE_REF_KEY &&
4308 found_key.type != BTRFS_INODE_EXTREF_KEY))
Alexander Block31db9f72012-07-25 23:19:24 +02004309 break;
Alexander Block31db9f72012-07-25 23:19:24 +02004310
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004311 ret = iterate_inode_ref(root, path, &found_key, 0, cb, sctx);
Alexander Block31db9f72012-07-25 23:19:24 +02004312 if (ret < 0)
4313 goto out;
4314
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00004315 path->slots[0]++;
Alexander Block31db9f72012-07-25 23:19:24 +02004316 }
Alexander Blocke938c8a2012-07-28 16:33:49 +02004317 btrfs_release_path(path);
Alexander Block31db9f72012-07-25 23:19:24 +02004318
Josef Bacik3dc09ec2016-08-24 11:57:52 -04004319 /*
4320 * We don't actually care about pending_move as we are simply
4321 * re-creating this inode and will be rename'ing it into place once we
4322 * rename the parent directory.
4323 */
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00004324 ret = process_recorded_refs(sctx, &pending_move);
Alexander Block31db9f72012-07-25 23:19:24 +02004325out:
4326 btrfs_free_path(path);
4327 return ret;
4328}
4329
4330static int send_set_xattr(struct send_ctx *sctx,
4331 struct fs_path *path,
4332 const char *name, int name_len,
4333 const char *data, int data_len)
4334{
4335 int ret = 0;
4336
4337 ret = begin_cmd(sctx, BTRFS_SEND_C_SET_XATTR);
4338 if (ret < 0)
4339 goto out;
4340
4341 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, path);
4342 TLV_PUT_STRING(sctx, BTRFS_SEND_A_XATTR_NAME, name, name_len);
4343 TLV_PUT(sctx, BTRFS_SEND_A_XATTR_DATA, data, data_len);
4344
4345 ret = send_cmd(sctx);
4346
4347tlv_put_failure:
4348out:
4349 return ret;
4350}
4351
4352static int send_remove_xattr(struct send_ctx *sctx,
4353 struct fs_path *path,
4354 const char *name, int name_len)
4355{
4356 int ret = 0;
4357
4358 ret = begin_cmd(sctx, BTRFS_SEND_C_REMOVE_XATTR);
4359 if (ret < 0)
4360 goto out;
4361
4362 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, path);
4363 TLV_PUT_STRING(sctx, BTRFS_SEND_A_XATTR_NAME, name, name_len);
4364
4365 ret = send_cmd(sctx);
4366
4367tlv_put_failure:
4368out:
4369 return ret;
4370}
4371
4372static int __process_new_xattr(int num, struct btrfs_key *di_key,
4373 const char *name, int name_len,
4374 const char *data, int data_len,
4375 u8 type, void *ctx)
4376{
4377 int ret;
4378 struct send_ctx *sctx = ctx;
4379 struct fs_path *p;
Andreas Gruenbacher2211d5b2016-09-27 13:03:22 +02004380 struct posix_acl_xattr_header dummy_acl;
Alexander Block31db9f72012-07-25 23:19:24 +02004381
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004382 p = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +02004383 if (!p)
4384 return -ENOMEM;
4385
4386 /*
Nicholas D Steeves01327612016-05-19 21:18:45 -04004387 * This hack is needed because empty acls are stored as zero byte
Alexander Block31db9f72012-07-25 23:19:24 +02004388 * data in xattrs. Problem with that is, that receiving these zero byte
Nicholas D Steeves01327612016-05-19 21:18:45 -04004389 * acls will fail later. To fix this, we send a dummy acl list that
Alexander Block31db9f72012-07-25 23:19:24 +02004390 * only contains the version number and no entries.
4391 */
4392 if (!strncmp(name, XATTR_NAME_POSIX_ACL_ACCESS, name_len) ||
4393 !strncmp(name, XATTR_NAME_POSIX_ACL_DEFAULT, name_len)) {
4394 if (data_len == 0) {
4395 dummy_acl.a_version =
4396 cpu_to_le32(POSIX_ACL_XATTR_VERSION);
4397 data = (char *)&dummy_acl;
4398 data_len = sizeof(dummy_acl);
4399 }
4400 }
4401
4402 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
4403 if (ret < 0)
4404 goto out;
4405
4406 ret = send_set_xattr(sctx, p, name, name_len, data, data_len);
4407
4408out:
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004409 fs_path_free(p);
Alexander Block31db9f72012-07-25 23:19:24 +02004410 return ret;
4411}
4412
4413static int __process_deleted_xattr(int num, struct btrfs_key *di_key,
4414 const char *name, int name_len,
4415 const char *data, int data_len,
4416 u8 type, void *ctx)
4417{
4418 int ret;
4419 struct send_ctx *sctx = ctx;
4420 struct fs_path *p;
4421
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004422 p = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +02004423 if (!p)
4424 return -ENOMEM;
4425
4426 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
4427 if (ret < 0)
4428 goto out;
4429
4430 ret = send_remove_xattr(sctx, p, name, name_len);
4431
4432out:
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004433 fs_path_free(p);
Alexander Block31db9f72012-07-25 23:19:24 +02004434 return ret;
4435}
4436
4437static int process_new_xattr(struct send_ctx *sctx)
4438{
4439 int ret = 0;
4440
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004441 ret = iterate_dir_item(sctx->send_root, sctx->left_path,
4442 sctx->cmp_key, __process_new_xattr, sctx);
Alexander Block31db9f72012-07-25 23:19:24 +02004443
4444 return ret;
4445}
4446
4447static int process_deleted_xattr(struct send_ctx *sctx)
4448{
Masahiro Yamadae2c89902016-09-13 04:35:52 +09004449 return iterate_dir_item(sctx->parent_root, sctx->right_path,
4450 sctx->cmp_key, __process_deleted_xattr, sctx);
Alexander Block31db9f72012-07-25 23:19:24 +02004451}
4452
4453struct find_xattr_ctx {
4454 const char *name;
4455 int name_len;
4456 int found_idx;
4457 char *found_data;
4458 int found_data_len;
4459};
4460
4461static int __find_xattr(int num, struct btrfs_key *di_key,
4462 const char *name, int name_len,
4463 const char *data, int data_len,
4464 u8 type, void *vctx)
4465{
4466 struct find_xattr_ctx *ctx = vctx;
4467
4468 if (name_len == ctx->name_len &&
4469 strncmp(name, ctx->name, name_len) == 0) {
4470 ctx->found_idx = num;
4471 ctx->found_data_len = data_len;
David Sterbae780b0d2016-01-18 18:42:13 +01004472 ctx->found_data = kmemdup(data, data_len, GFP_KERNEL);
Alexander Block31db9f72012-07-25 23:19:24 +02004473 if (!ctx->found_data)
4474 return -ENOMEM;
Alexander Block31db9f72012-07-25 23:19:24 +02004475 return 1;
4476 }
4477 return 0;
4478}
4479
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004480static int find_xattr(struct btrfs_root *root,
Alexander Block31db9f72012-07-25 23:19:24 +02004481 struct btrfs_path *path,
4482 struct btrfs_key *key,
4483 const char *name, int name_len,
4484 char **data, int *data_len)
4485{
4486 int ret;
4487 struct find_xattr_ctx ctx;
4488
4489 ctx.name = name;
4490 ctx.name_len = name_len;
4491 ctx.found_idx = -1;
4492 ctx.found_data = NULL;
4493 ctx.found_data_len = 0;
4494
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004495 ret = iterate_dir_item(root, path, key, __find_xattr, &ctx);
Alexander Block31db9f72012-07-25 23:19:24 +02004496 if (ret < 0)
4497 return ret;
4498
4499 if (ctx.found_idx == -1)
4500 return -ENOENT;
4501 if (data) {
4502 *data = ctx.found_data;
4503 *data_len = ctx.found_data_len;
4504 } else {
4505 kfree(ctx.found_data);
4506 }
4507 return ctx.found_idx;
4508}
4509
4510
4511static int __process_changed_new_xattr(int num, struct btrfs_key *di_key,
4512 const char *name, int name_len,
4513 const char *data, int data_len,
4514 u8 type, void *ctx)
4515{
4516 int ret;
4517 struct send_ctx *sctx = ctx;
4518 char *found_data = NULL;
4519 int found_data_len = 0;
Alexander Block31db9f72012-07-25 23:19:24 +02004520
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004521 ret = find_xattr(sctx->parent_root, sctx->right_path,
4522 sctx->cmp_key, name, name_len, &found_data,
4523 &found_data_len);
Alexander Block31db9f72012-07-25 23:19:24 +02004524 if (ret == -ENOENT) {
4525 ret = __process_new_xattr(num, di_key, name, name_len, data,
4526 data_len, type, ctx);
4527 } else if (ret >= 0) {
4528 if (data_len != found_data_len ||
4529 memcmp(data, found_data, data_len)) {
4530 ret = __process_new_xattr(num, di_key, name, name_len,
4531 data, data_len, type, ctx);
4532 } else {
4533 ret = 0;
4534 }
4535 }
4536
4537 kfree(found_data);
Alexander Block31db9f72012-07-25 23:19:24 +02004538 return ret;
4539}
4540
4541static int __process_changed_deleted_xattr(int num, struct btrfs_key *di_key,
4542 const char *name, int name_len,
4543 const char *data, int data_len,
4544 u8 type, void *ctx)
4545{
4546 int ret;
4547 struct send_ctx *sctx = ctx;
4548
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004549 ret = find_xattr(sctx->send_root, sctx->left_path, sctx->cmp_key,
4550 name, name_len, NULL, NULL);
Alexander Block31db9f72012-07-25 23:19:24 +02004551 if (ret == -ENOENT)
4552 ret = __process_deleted_xattr(num, di_key, name, name_len, data,
4553 data_len, type, ctx);
4554 else if (ret >= 0)
4555 ret = 0;
4556
4557 return ret;
4558}
4559
4560static int process_changed_xattr(struct send_ctx *sctx)
4561{
4562 int ret = 0;
4563
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004564 ret = iterate_dir_item(sctx->send_root, sctx->left_path,
Alexander Block31db9f72012-07-25 23:19:24 +02004565 sctx->cmp_key, __process_changed_new_xattr, sctx);
4566 if (ret < 0)
4567 goto out;
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004568 ret = iterate_dir_item(sctx->parent_root, sctx->right_path,
Alexander Block31db9f72012-07-25 23:19:24 +02004569 sctx->cmp_key, __process_changed_deleted_xattr, sctx);
4570
4571out:
4572 return ret;
4573}
4574
4575static int process_all_new_xattrs(struct send_ctx *sctx)
4576{
4577 int ret;
4578 struct btrfs_root *root;
4579 struct btrfs_path *path;
4580 struct btrfs_key key;
4581 struct btrfs_key found_key;
4582 struct extent_buffer *eb;
4583 int slot;
4584
4585 path = alloc_path_for_send();
4586 if (!path)
4587 return -ENOMEM;
4588
4589 root = sctx->send_root;
4590
4591 key.objectid = sctx->cmp_key->objectid;
4592 key.type = BTRFS_XATTR_ITEM_KEY;
4593 key.offset = 0;
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00004594 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
4595 if (ret < 0)
4596 goto out;
Alexander Block31db9f72012-07-25 23:19:24 +02004597
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00004598 while (1) {
Alexander Block31db9f72012-07-25 23:19:24 +02004599 eb = path->nodes[0];
4600 slot = path->slots[0];
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00004601 if (slot >= btrfs_header_nritems(eb)) {
4602 ret = btrfs_next_leaf(root, path);
4603 if (ret < 0) {
4604 goto out;
4605 } else if (ret > 0) {
4606 ret = 0;
4607 break;
4608 }
4609 continue;
4610 }
Alexander Block31db9f72012-07-25 23:19:24 +02004611
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00004612 btrfs_item_key_to_cpu(eb, &found_key, slot);
Alexander Block31db9f72012-07-25 23:19:24 +02004613 if (found_key.objectid != key.objectid ||
4614 found_key.type != key.type) {
4615 ret = 0;
4616 goto out;
4617 }
4618
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004619 ret = iterate_dir_item(root, path, &found_key,
4620 __process_new_xattr, sctx);
Alexander Block31db9f72012-07-25 23:19:24 +02004621 if (ret < 0)
4622 goto out;
4623
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00004624 path->slots[0]++;
Alexander Block31db9f72012-07-25 23:19:24 +02004625 }
4626
4627out:
4628 btrfs_free_path(path);
4629 return ret;
4630}
4631
Josef Baciked259092013-10-25 11:36:01 -04004632static ssize_t fill_read_buf(struct send_ctx *sctx, u64 offset, u32 len)
4633{
4634 struct btrfs_root *root = sctx->send_root;
4635 struct btrfs_fs_info *fs_info = root->fs_info;
4636 struct inode *inode;
4637 struct page *page;
4638 char *addr;
4639 struct btrfs_key key;
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03004640 pgoff_t index = offset >> PAGE_SHIFT;
Josef Baciked259092013-10-25 11:36:01 -04004641 pgoff_t last_index;
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03004642 unsigned pg_offset = offset & ~PAGE_MASK;
Josef Baciked259092013-10-25 11:36:01 -04004643 ssize_t ret = 0;
4644
4645 key.objectid = sctx->cur_ino;
4646 key.type = BTRFS_INODE_ITEM_KEY;
4647 key.offset = 0;
4648
4649 inode = btrfs_iget(fs_info->sb, &key, root, NULL);
4650 if (IS_ERR(inode))
4651 return PTR_ERR(inode);
4652
4653 if (offset + len > i_size_read(inode)) {
4654 if (offset > i_size_read(inode))
4655 len = 0;
4656 else
4657 len = offset - i_size_read(inode);
4658 }
4659 if (len == 0)
4660 goto out;
4661
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03004662 last_index = (offset + len - 1) >> PAGE_SHIFT;
Liu Bo2131bcd2014-03-05 10:07:35 +08004663
4664 /* initial readahead */
4665 memset(&sctx->ra, 0, sizeof(struct file_ra_state));
4666 file_ra_state_init(&sctx->ra, inode->i_mapping);
4667 btrfs_force_ra(inode->i_mapping, &sctx->ra, NULL, index,
4668 last_index - index + 1);
4669
Josef Baciked259092013-10-25 11:36:01 -04004670 while (index <= last_index) {
4671 unsigned cur_len = min_t(unsigned, len,
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03004672 PAGE_SIZE - pg_offset);
David Sterbae780b0d2016-01-18 18:42:13 +01004673 page = find_or_create_page(inode->i_mapping, index, GFP_KERNEL);
Josef Baciked259092013-10-25 11:36:01 -04004674 if (!page) {
4675 ret = -ENOMEM;
4676 break;
4677 }
4678
4679 if (!PageUptodate(page)) {
4680 btrfs_readpage(NULL, page);
4681 lock_page(page);
4682 if (!PageUptodate(page)) {
4683 unlock_page(page);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03004684 put_page(page);
Josef Baciked259092013-10-25 11:36:01 -04004685 ret = -EIO;
4686 break;
4687 }
4688 }
4689
4690 addr = kmap(page);
4691 memcpy(sctx->read_buf + ret, addr + pg_offset, cur_len);
4692 kunmap(page);
4693 unlock_page(page);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03004694 put_page(page);
Josef Baciked259092013-10-25 11:36:01 -04004695 index++;
4696 pg_offset = 0;
4697 len -= cur_len;
4698 ret += cur_len;
4699 }
4700out:
4701 iput(inode);
4702 return ret;
4703}
4704
Alexander Block31db9f72012-07-25 23:19:24 +02004705/*
4706 * Read some bytes from the current inode/file and send a write command to
4707 * user space.
4708 */
4709static int send_write(struct send_ctx *sctx, u64 offset, u32 len)
4710{
Jeff Mahoney04ab9562016-09-20 10:05:03 -04004711 struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;
Alexander Block31db9f72012-07-25 23:19:24 +02004712 int ret = 0;
4713 struct fs_path *p;
Josef Baciked259092013-10-25 11:36:01 -04004714 ssize_t num_read = 0;
Alexander Block31db9f72012-07-25 23:19:24 +02004715
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004716 p = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +02004717 if (!p)
4718 return -ENOMEM;
4719
Jeff Mahoney04ab9562016-09-20 10:05:03 -04004720 btrfs_debug(fs_info, "send_write offset=%llu, len=%d", offset, len);
Alexander Block31db9f72012-07-25 23:19:24 +02004721
Josef Baciked259092013-10-25 11:36:01 -04004722 num_read = fill_read_buf(sctx, offset, len);
4723 if (num_read <= 0) {
4724 if (num_read < 0)
4725 ret = num_read;
Alexander Block31db9f72012-07-25 23:19:24 +02004726 goto out;
Josef Baciked259092013-10-25 11:36:01 -04004727 }
Alexander Block31db9f72012-07-25 23:19:24 +02004728
4729 ret = begin_cmd(sctx, BTRFS_SEND_C_WRITE);
4730 if (ret < 0)
4731 goto out;
4732
4733 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
4734 if (ret < 0)
4735 goto out;
4736
4737 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
4738 TLV_PUT_U64(sctx, BTRFS_SEND_A_FILE_OFFSET, offset);
Alexander Blocke938c8a2012-07-28 16:33:49 +02004739 TLV_PUT(sctx, BTRFS_SEND_A_DATA, sctx->read_buf, num_read);
Alexander Block31db9f72012-07-25 23:19:24 +02004740
4741 ret = send_cmd(sctx);
4742
4743tlv_put_failure:
4744out:
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004745 fs_path_free(p);
Alexander Block31db9f72012-07-25 23:19:24 +02004746 if (ret < 0)
4747 return ret;
Alexander Blocke938c8a2012-07-28 16:33:49 +02004748 return num_read;
Alexander Block31db9f72012-07-25 23:19:24 +02004749}
4750
4751/*
4752 * Send a clone command to user space.
4753 */
4754static int send_clone(struct send_ctx *sctx,
4755 u64 offset, u32 len,
4756 struct clone_root *clone_root)
4757{
4758 int ret = 0;
Alexander Block31db9f72012-07-25 23:19:24 +02004759 struct fs_path *p;
4760 u64 gen;
4761
Jeff Mahoney04ab9562016-09-20 10:05:03 -04004762 btrfs_debug(sctx->send_root->fs_info,
4763 "send_clone offset=%llu, len=%d, clone_root=%llu, clone_inode=%llu, clone_offset=%llu",
4764 offset, len, clone_root->root->objectid, clone_root->ino,
4765 clone_root->offset);
Alexander Block31db9f72012-07-25 23:19:24 +02004766
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004767 p = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +02004768 if (!p)
4769 return -ENOMEM;
4770
4771 ret = begin_cmd(sctx, BTRFS_SEND_C_CLONE);
4772 if (ret < 0)
4773 goto out;
4774
4775 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
4776 if (ret < 0)
4777 goto out;
4778
4779 TLV_PUT_U64(sctx, BTRFS_SEND_A_FILE_OFFSET, offset);
4780 TLV_PUT_U64(sctx, BTRFS_SEND_A_CLONE_LEN, len);
4781 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
4782
Alexander Blocke938c8a2012-07-28 16:33:49 +02004783 if (clone_root->root == sctx->send_root) {
Alexander Block31db9f72012-07-25 23:19:24 +02004784 ret = get_inode_info(sctx->send_root, clone_root->ino, NULL,
Alexander Block85a7b332012-07-26 23:39:10 +02004785 &gen, NULL, NULL, NULL, NULL);
Alexander Block31db9f72012-07-25 23:19:24 +02004786 if (ret < 0)
4787 goto out;
4788 ret = get_cur_path(sctx, clone_root->ino, gen, p);
4789 } else {
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004790 ret = get_inode_path(clone_root->root, clone_root->ino, p);
Alexander Block31db9f72012-07-25 23:19:24 +02004791 }
4792 if (ret < 0)
4793 goto out;
4794
Josef Bacik37b8d272015-06-04 17:17:25 -04004795 /*
4796 * If the parent we're using has a received_uuid set then use that as
4797 * our clone source as that is what we will look for when doing a
4798 * receive.
4799 *
4800 * This covers the case that we create a snapshot off of a received
4801 * subvolume and then use that as the parent and try to receive on a
4802 * different host.
4803 */
4804 if (!btrfs_is_empty_uuid(clone_root->root->root_item.received_uuid))
4805 TLV_PUT_UUID(sctx, BTRFS_SEND_A_CLONE_UUID,
4806 clone_root->root->root_item.received_uuid);
4807 else
4808 TLV_PUT_UUID(sctx, BTRFS_SEND_A_CLONE_UUID,
4809 clone_root->root->root_item.uuid);
Alexander Block31db9f72012-07-25 23:19:24 +02004810 TLV_PUT_U64(sctx, BTRFS_SEND_A_CLONE_CTRANSID,
Filipe David Borba Manana5a0f4e22013-12-03 15:55:48 +00004811 le64_to_cpu(clone_root->root->root_item.ctransid));
Alexander Block31db9f72012-07-25 23:19:24 +02004812 TLV_PUT_PATH(sctx, BTRFS_SEND_A_CLONE_PATH, p);
4813 TLV_PUT_U64(sctx, BTRFS_SEND_A_CLONE_OFFSET,
4814 clone_root->offset);
4815
4816 ret = send_cmd(sctx);
4817
4818tlv_put_failure:
4819out:
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004820 fs_path_free(p);
Alexander Block31db9f72012-07-25 23:19:24 +02004821 return ret;
4822}
4823
Mark Fashehcb95e7b2013-02-04 20:54:57 +00004824/*
4825 * Send an update extent command to user space.
4826 */
4827static int send_update_extent(struct send_ctx *sctx,
4828 u64 offset, u32 len)
4829{
4830 int ret = 0;
4831 struct fs_path *p;
4832
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004833 p = fs_path_alloc();
Mark Fashehcb95e7b2013-02-04 20:54:57 +00004834 if (!p)
4835 return -ENOMEM;
4836
4837 ret = begin_cmd(sctx, BTRFS_SEND_C_UPDATE_EXTENT);
4838 if (ret < 0)
4839 goto out;
4840
4841 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
4842 if (ret < 0)
4843 goto out;
4844
4845 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
4846 TLV_PUT_U64(sctx, BTRFS_SEND_A_FILE_OFFSET, offset);
4847 TLV_PUT_U64(sctx, BTRFS_SEND_A_SIZE, len);
4848
4849 ret = send_cmd(sctx);
4850
4851tlv_put_failure:
4852out:
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004853 fs_path_free(p);
Mark Fashehcb95e7b2013-02-04 20:54:57 +00004854 return ret;
4855}
4856
Josef Bacik16e75492013-10-22 12:18:51 -04004857static int send_hole(struct send_ctx *sctx, u64 end)
4858{
4859 struct fs_path *p = NULL;
4860 u64 offset = sctx->cur_inode_last_extent;
4861 u64 len;
4862 int ret = 0;
4863
4864 p = fs_path_alloc();
4865 if (!p)
4866 return -ENOMEM;
Filipe Mananac715e152014-03-31 14:52:14 +01004867 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
4868 if (ret < 0)
4869 goto tlv_put_failure;
Josef Bacik16e75492013-10-22 12:18:51 -04004870 memset(sctx->read_buf, 0, BTRFS_SEND_READ_SIZE);
4871 while (offset < end) {
4872 len = min_t(u64, end - offset, BTRFS_SEND_READ_SIZE);
4873
4874 ret = begin_cmd(sctx, BTRFS_SEND_C_WRITE);
4875 if (ret < 0)
4876 break;
Josef Bacik16e75492013-10-22 12:18:51 -04004877 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
4878 TLV_PUT_U64(sctx, BTRFS_SEND_A_FILE_OFFSET, offset);
4879 TLV_PUT(sctx, BTRFS_SEND_A_DATA, sctx->read_buf, len);
4880 ret = send_cmd(sctx);
4881 if (ret < 0)
4882 break;
4883 offset += len;
4884 }
4885tlv_put_failure:
4886 fs_path_free(p);
4887 return ret;
4888}
4889
Filipe Mananad906d492015-10-02 10:47:34 +01004890static int send_extent_data(struct send_ctx *sctx,
4891 const u64 offset,
4892 const u64 len)
4893{
4894 u64 sent = 0;
4895
4896 if (sctx->flags & BTRFS_SEND_FLAG_NO_FILE_DATA)
4897 return send_update_extent(sctx, offset, len);
4898
4899 while (sent < len) {
4900 u64 size = len - sent;
4901 int ret;
4902
4903 if (size > BTRFS_SEND_READ_SIZE)
4904 size = BTRFS_SEND_READ_SIZE;
4905 ret = send_write(sctx, offset + sent, size);
4906 if (ret < 0)
4907 return ret;
4908 if (!ret)
4909 break;
4910 sent += ret;
4911 }
4912 return 0;
4913}
4914
4915static int clone_range(struct send_ctx *sctx,
4916 struct clone_root *clone_root,
4917 const u64 disk_byte,
4918 u64 data_offset,
4919 u64 offset,
4920 u64 len)
4921{
4922 struct btrfs_path *path;
4923 struct btrfs_key key;
4924 int ret;
4925
4926 path = alloc_path_for_send();
4927 if (!path)
4928 return -ENOMEM;
4929
4930 /*
4931 * We can't send a clone operation for the entire range if we find
4932 * extent items in the respective range in the source file that
4933 * refer to different extents or if we find holes.
4934 * So check for that and do a mix of clone and regular write/copy
4935 * operations if needed.
4936 *
4937 * Example:
4938 *
4939 * mkfs.btrfs -f /dev/sda
4940 * mount /dev/sda /mnt
4941 * xfs_io -f -c "pwrite -S 0xaa 0K 100K" /mnt/foo
4942 * cp --reflink=always /mnt/foo /mnt/bar
4943 * xfs_io -c "pwrite -S 0xbb 50K 50K" /mnt/foo
4944 * btrfs subvolume snapshot -r /mnt /mnt/snap
4945 *
4946 * If when we send the snapshot and we are processing file bar (which
4947 * has a higher inode number than foo) we blindly send a clone operation
4948 * for the [0, 100K[ range from foo to bar, the receiver ends up getting
4949 * a file bar that matches the content of file foo - iow, doesn't match
4950 * the content from bar in the original filesystem.
4951 */
4952 key.objectid = clone_root->ino;
4953 key.type = BTRFS_EXTENT_DATA_KEY;
4954 key.offset = clone_root->offset;
4955 ret = btrfs_search_slot(NULL, clone_root->root, &key, path, 0, 0);
4956 if (ret < 0)
4957 goto out;
4958 if (ret > 0 && path->slots[0] > 0) {
4959 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0] - 1);
4960 if (key.objectid == clone_root->ino &&
4961 key.type == BTRFS_EXTENT_DATA_KEY)
4962 path->slots[0]--;
4963 }
4964
4965 while (true) {
4966 struct extent_buffer *leaf = path->nodes[0];
4967 int slot = path->slots[0];
4968 struct btrfs_file_extent_item *ei;
4969 u8 type;
4970 u64 ext_len;
4971 u64 clone_len;
4972
4973 if (slot >= btrfs_header_nritems(leaf)) {
4974 ret = btrfs_next_leaf(clone_root->root, path);
4975 if (ret < 0)
4976 goto out;
4977 else if (ret > 0)
4978 break;
4979 continue;
4980 }
4981
4982 btrfs_item_key_to_cpu(leaf, &key, slot);
4983
4984 /*
4985 * We might have an implicit trailing hole (NO_HOLES feature
4986 * enabled). We deal with it after leaving this loop.
4987 */
4988 if (key.objectid != clone_root->ino ||
4989 key.type != BTRFS_EXTENT_DATA_KEY)
4990 break;
4991
4992 ei = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
4993 type = btrfs_file_extent_type(leaf, ei);
4994 if (type == BTRFS_FILE_EXTENT_INLINE) {
4995 ext_len = btrfs_file_extent_inline_len(leaf, slot, ei);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03004996 ext_len = PAGE_ALIGN(ext_len);
Filipe Mananad906d492015-10-02 10:47:34 +01004997 } else {
4998 ext_len = btrfs_file_extent_num_bytes(leaf, ei);
4999 }
5000
5001 if (key.offset + ext_len <= clone_root->offset)
5002 goto next;
5003
5004 if (key.offset > clone_root->offset) {
5005 /* Implicit hole, NO_HOLES feature enabled. */
5006 u64 hole_len = key.offset - clone_root->offset;
5007
5008 if (hole_len > len)
5009 hole_len = len;
5010 ret = send_extent_data(sctx, offset, hole_len);
5011 if (ret < 0)
5012 goto out;
5013
5014 len -= hole_len;
5015 if (len == 0)
5016 break;
5017 offset += hole_len;
5018 clone_root->offset += hole_len;
5019 data_offset += hole_len;
5020 }
5021
5022 if (key.offset >= clone_root->offset + len)
5023 break;
5024
5025 clone_len = min_t(u64, ext_len, len);
5026
5027 if (btrfs_file_extent_disk_bytenr(leaf, ei) == disk_byte &&
5028 btrfs_file_extent_offset(leaf, ei) == data_offset)
5029 ret = send_clone(sctx, offset, clone_len, clone_root);
5030 else
5031 ret = send_extent_data(sctx, offset, clone_len);
5032
5033 if (ret < 0)
5034 goto out;
5035
5036 len -= clone_len;
5037 if (len == 0)
5038 break;
5039 offset += clone_len;
5040 clone_root->offset += clone_len;
5041 data_offset += clone_len;
5042next:
5043 path->slots[0]++;
5044 }
5045
5046 if (len > 0)
5047 ret = send_extent_data(sctx, offset, len);
5048 else
5049 ret = 0;
5050out:
5051 btrfs_free_path(path);
5052 return ret;
5053}
5054
Alexander Block31db9f72012-07-25 23:19:24 +02005055static int send_write_or_clone(struct send_ctx *sctx,
5056 struct btrfs_path *path,
5057 struct btrfs_key *key,
5058 struct clone_root *clone_root)
5059{
5060 int ret = 0;
5061 struct btrfs_file_extent_item *ei;
5062 u64 offset = key->offset;
Alexander Block31db9f72012-07-25 23:19:24 +02005063 u64 len;
Alexander Block31db9f72012-07-25 23:19:24 +02005064 u8 type;
Filipe David Borba Manana28e5dd82014-01-12 02:26:28 +00005065 u64 bs = sctx->send_root->fs_info->sb->s_blocksize;
Alexander Block31db9f72012-07-25 23:19:24 +02005066
5067 ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
5068 struct btrfs_file_extent_item);
5069 type = btrfs_file_extent_type(path->nodes[0], ei);
Chris Mason74dd17f2012-08-07 16:25:13 -04005070 if (type == BTRFS_FILE_EXTENT_INLINE) {
Chris Mason514ac8a2014-01-03 21:07:00 -08005071 len = btrfs_file_extent_inline_len(path->nodes[0],
5072 path->slots[0], ei);
Chris Mason74dd17f2012-08-07 16:25:13 -04005073 /*
5074 * it is possible the inline item won't cover the whole page,
5075 * but there may be items after this page. Make
5076 * sure to send the whole thing
5077 */
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03005078 len = PAGE_ALIGN(len);
Chris Mason74dd17f2012-08-07 16:25:13 -04005079 } else {
Alexander Block31db9f72012-07-25 23:19:24 +02005080 len = btrfs_file_extent_num_bytes(path->nodes[0], ei);
Chris Mason74dd17f2012-08-07 16:25:13 -04005081 }
Alexander Block31db9f72012-07-25 23:19:24 +02005082
5083 if (offset + len > sctx->cur_inode_size)
5084 len = sctx->cur_inode_size - offset;
5085 if (len == 0) {
5086 ret = 0;
5087 goto out;
5088 }
5089
Filipe David Borba Manana28e5dd82014-01-12 02:26:28 +00005090 if (clone_root && IS_ALIGNED(offset + len, bs)) {
Filipe Mananad906d492015-10-02 10:47:34 +01005091 u64 disk_byte;
5092 u64 data_offset;
5093
5094 disk_byte = btrfs_file_extent_disk_bytenr(path->nodes[0], ei);
5095 data_offset = btrfs_file_extent_offset(path->nodes[0], ei);
5096 ret = clone_range(sctx, clone_root, disk_byte, data_offset,
5097 offset, len);
Mark Fashehcb95e7b2013-02-04 20:54:57 +00005098 } else {
Filipe Mananad906d492015-10-02 10:47:34 +01005099 ret = send_extent_data(sctx, offset, len);
Alexander Block31db9f72012-07-25 23:19:24 +02005100 }
Alexander Block31db9f72012-07-25 23:19:24 +02005101out:
5102 return ret;
5103}
5104
5105static int is_extent_unchanged(struct send_ctx *sctx,
5106 struct btrfs_path *left_path,
5107 struct btrfs_key *ekey)
5108{
5109 int ret = 0;
5110 struct btrfs_key key;
5111 struct btrfs_path *path = NULL;
5112 struct extent_buffer *eb;
5113 int slot;
5114 struct btrfs_key found_key;
5115 struct btrfs_file_extent_item *ei;
5116 u64 left_disknr;
5117 u64 right_disknr;
5118 u64 left_offset;
5119 u64 right_offset;
5120 u64 left_offset_fixed;
5121 u64 left_len;
5122 u64 right_len;
Chris Mason74dd17f2012-08-07 16:25:13 -04005123 u64 left_gen;
5124 u64 right_gen;
Alexander Block31db9f72012-07-25 23:19:24 +02005125 u8 left_type;
5126 u8 right_type;
5127
5128 path = alloc_path_for_send();
5129 if (!path)
5130 return -ENOMEM;
5131
5132 eb = left_path->nodes[0];
5133 slot = left_path->slots[0];
Alexander Block31db9f72012-07-25 23:19:24 +02005134 ei = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
5135 left_type = btrfs_file_extent_type(eb, ei);
Alexander Block31db9f72012-07-25 23:19:24 +02005136
5137 if (left_type != BTRFS_FILE_EXTENT_REG) {
5138 ret = 0;
5139 goto out;
5140 }
Chris Mason74dd17f2012-08-07 16:25:13 -04005141 left_disknr = btrfs_file_extent_disk_bytenr(eb, ei);
5142 left_len = btrfs_file_extent_num_bytes(eb, ei);
5143 left_offset = btrfs_file_extent_offset(eb, ei);
5144 left_gen = btrfs_file_extent_generation(eb, ei);
Alexander Block31db9f72012-07-25 23:19:24 +02005145
5146 /*
5147 * Following comments will refer to these graphics. L is the left
5148 * extents which we are checking at the moment. 1-8 are the right
5149 * extents that we iterate.
5150 *
5151 * |-----L-----|
5152 * |-1-|-2a-|-3-|-4-|-5-|-6-|
5153 *
5154 * |-----L-----|
5155 * |--1--|-2b-|...(same as above)
5156 *
5157 * Alternative situation. Happens on files where extents got split.
5158 * |-----L-----|
5159 * |-----------7-----------|-6-|
5160 *
5161 * Alternative situation. Happens on files which got larger.
5162 * |-----L-----|
5163 * |-8-|
5164 * Nothing follows after 8.
5165 */
5166
5167 key.objectid = ekey->objectid;
5168 key.type = BTRFS_EXTENT_DATA_KEY;
5169 key.offset = ekey->offset;
5170 ret = btrfs_search_slot_for_read(sctx->parent_root, &key, path, 0, 0);
5171 if (ret < 0)
5172 goto out;
5173 if (ret) {
5174 ret = 0;
5175 goto out;
5176 }
5177
5178 /*
5179 * Handle special case where the right side has no extents at all.
5180 */
5181 eb = path->nodes[0];
5182 slot = path->slots[0];
5183 btrfs_item_key_to_cpu(eb, &found_key, slot);
5184 if (found_key.objectid != key.objectid ||
5185 found_key.type != key.type) {
Josef Bacik57cfd462013-08-20 15:55:39 -04005186 /* If we're a hole then just pretend nothing changed */
5187 ret = (left_disknr) ? 0 : 1;
Alexander Block31db9f72012-07-25 23:19:24 +02005188 goto out;
5189 }
5190
5191 /*
5192 * We're now on 2a, 2b or 7.
5193 */
5194 key = found_key;
5195 while (key.offset < ekey->offset + left_len) {
5196 ei = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
5197 right_type = btrfs_file_extent_type(eb, ei);
Filipe Mananae1cbfd72017-04-04 20:31:00 +01005198 if (right_type != BTRFS_FILE_EXTENT_REG &&
5199 right_type != BTRFS_FILE_EXTENT_INLINE) {
Alexander Block31db9f72012-07-25 23:19:24 +02005200 ret = 0;
5201 goto out;
5202 }
5203
Josef Bacik007d31f2013-10-31 16:49:02 -04005204 right_disknr = btrfs_file_extent_disk_bytenr(eb, ei);
Filipe Mananae1cbfd72017-04-04 20:31:00 +01005205 if (right_type == BTRFS_FILE_EXTENT_INLINE) {
5206 right_len = btrfs_file_extent_inline_len(eb, slot, ei);
5207 right_len = PAGE_ALIGN(right_len);
5208 } else {
5209 right_len = btrfs_file_extent_num_bytes(eb, ei);
5210 }
Josef Bacik007d31f2013-10-31 16:49:02 -04005211 right_offset = btrfs_file_extent_offset(eb, ei);
5212 right_gen = btrfs_file_extent_generation(eb, ei);
5213
Alexander Block31db9f72012-07-25 23:19:24 +02005214 /*
5215 * Are we at extent 8? If yes, we know the extent is changed.
5216 * This may only happen on the first iteration.
5217 */
Alexander Blockd8347fa2012-08-01 12:49:15 +02005218 if (found_key.offset + right_len <= ekey->offset) {
Josef Bacik57cfd462013-08-20 15:55:39 -04005219 /* If we're a hole just pretend nothing changed */
5220 ret = (left_disknr) ? 0 : 1;
Alexander Block31db9f72012-07-25 23:19:24 +02005221 goto out;
5222 }
5223
Filipe Mananae1cbfd72017-04-04 20:31:00 +01005224 /*
5225 * We just wanted to see if when we have an inline extent, what
5226 * follows it is a regular extent (wanted to check the above
5227 * condition for inline extents too). This should normally not
5228 * happen but it's possible for example when we have an inline
5229 * compressed extent representing data with a size matching
5230 * the page size (currently the same as sector size).
5231 */
5232 if (right_type == BTRFS_FILE_EXTENT_INLINE) {
5233 ret = 0;
5234 goto out;
5235 }
5236
Alexander Block31db9f72012-07-25 23:19:24 +02005237 left_offset_fixed = left_offset;
5238 if (key.offset < ekey->offset) {
5239 /* Fix the right offset for 2a and 7. */
5240 right_offset += ekey->offset - key.offset;
5241 } else {
5242 /* Fix the left offset for all behind 2a and 2b */
5243 left_offset_fixed += key.offset - ekey->offset;
5244 }
5245
5246 /*
5247 * Check if we have the same extent.
5248 */
Alexander Block39540962012-08-01 12:46:05 +02005249 if (left_disknr != right_disknr ||
Chris Mason74dd17f2012-08-07 16:25:13 -04005250 left_offset_fixed != right_offset ||
5251 left_gen != right_gen) {
Alexander Block31db9f72012-07-25 23:19:24 +02005252 ret = 0;
5253 goto out;
5254 }
5255
5256 /*
5257 * Go to the next extent.
5258 */
5259 ret = btrfs_next_item(sctx->parent_root, path);
5260 if (ret < 0)
5261 goto out;
5262 if (!ret) {
5263 eb = path->nodes[0];
5264 slot = path->slots[0];
5265 btrfs_item_key_to_cpu(eb, &found_key, slot);
5266 }
5267 if (ret || found_key.objectid != key.objectid ||
5268 found_key.type != key.type) {
5269 key.offset += right_len;
5270 break;
Jan Schmidtadaa4b82013-03-21 14:30:23 +00005271 }
5272 if (found_key.offset != key.offset + right_len) {
5273 ret = 0;
5274 goto out;
Alexander Block31db9f72012-07-25 23:19:24 +02005275 }
5276 key = found_key;
5277 }
5278
5279 /*
5280 * We're now behind the left extent (treat as unchanged) or at the end
5281 * of the right side (treat as changed).
5282 */
5283 if (key.offset >= ekey->offset + left_len)
5284 ret = 1;
5285 else
5286 ret = 0;
5287
5288
5289out:
5290 btrfs_free_path(path);
5291 return ret;
5292}
5293
Josef Bacik16e75492013-10-22 12:18:51 -04005294static int get_last_extent(struct send_ctx *sctx, u64 offset)
5295{
5296 struct btrfs_path *path;
5297 struct btrfs_root *root = sctx->send_root;
5298 struct btrfs_file_extent_item *fi;
5299 struct btrfs_key key;
5300 u64 extent_end;
5301 u8 type;
5302 int ret;
5303
5304 path = alloc_path_for_send();
5305 if (!path)
5306 return -ENOMEM;
5307
5308 sctx->cur_inode_last_extent = 0;
5309
5310 key.objectid = sctx->cur_ino;
5311 key.type = BTRFS_EXTENT_DATA_KEY;
5312 key.offset = offset;
5313 ret = btrfs_search_slot_for_read(root, &key, path, 0, 1);
5314 if (ret < 0)
5315 goto out;
5316 ret = 0;
5317 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
5318 if (key.objectid != sctx->cur_ino || key.type != BTRFS_EXTENT_DATA_KEY)
5319 goto out;
5320
5321 fi = btrfs_item_ptr(path->nodes[0], path->slots[0],
5322 struct btrfs_file_extent_item);
5323 type = btrfs_file_extent_type(path->nodes[0], fi);
5324 if (type == BTRFS_FILE_EXTENT_INLINE) {
Chris Mason514ac8a2014-01-03 21:07:00 -08005325 u64 size = btrfs_file_extent_inline_len(path->nodes[0],
5326 path->slots[0], fi);
Josef Bacik16e75492013-10-22 12:18:51 -04005327 extent_end = ALIGN(key.offset + size,
Jeff Mahoneyda170662016-06-15 09:22:56 -04005328 sctx->send_root->fs_info->sectorsize);
Josef Bacik16e75492013-10-22 12:18:51 -04005329 } else {
5330 extent_end = key.offset +
5331 btrfs_file_extent_num_bytes(path->nodes[0], fi);
5332 }
5333 sctx->cur_inode_last_extent = extent_end;
5334out:
5335 btrfs_free_path(path);
5336 return ret;
5337}
5338
Filipe Manana82bfb2e2017-02-14 17:56:32 +00005339static int range_is_hole_in_parent(struct send_ctx *sctx,
5340 const u64 start,
5341 const u64 end)
5342{
5343 struct btrfs_path *path;
5344 struct btrfs_key key;
5345 struct btrfs_root *root = sctx->parent_root;
5346 u64 search_start = start;
5347 int ret;
5348
5349 path = alloc_path_for_send();
5350 if (!path)
5351 return -ENOMEM;
5352
5353 key.objectid = sctx->cur_ino;
5354 key.type = BTRFS_EXTENT_DATA_KEY;
5355 key.offset = search_start;
5356 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5357 if (ret < 0)
5358 goto out;
5359 if (ret > 0 && path->slots[0] > 0)
5360 path->slots[0]--;
5361
5362 while (search_start < end) {
5363 struct extent_buffer *leaf = path->nodes[0];
5364 int slot = path->slots[0];
5365 struct btrfs_file_extent_item *fi;
5366 u64 extent_end;
5367
5368 if (slot >= btrfs_header_nritems(leaf)) {
5369 ret = btrfs_next_leaf(root, path);
5370 if (ret < 0)
5371 goto out;
5372 else if (ret > 0)
5373 break;
5374 continue;
5375 }
5376
5377 btrfs_item_key_to_cpu(leaf, &key, slot);
5378 if (key.objectid < sctx->cur_ino ||
5379 key.type < BTRFS_EXTENT_DATA_KEY)
5380 goto next;
5381 if (key.objectid > sctx->cur_ino ||
5382 key.type > BTRFS_EXTENT_DATA_KEY ||
5383 key.offset >= end)
5384 break;
5385
5386 fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
5387 if (btrfs_file_extent_type(leaf, fi) ==
5388 BTRFS_FILE_EXTENT_INLINE) {
5389 u64 size = btrfs_file_extent_inline_len(leaf, slot, fi);
5390
5391 extent_end = ALIGN(key.offset + size,
5392 root->fs_info->sectorsize);
5393 } else {
5394 extent_end = key.offset +
5395 btrfs_file_extent_num_bytes(leaf, fi);
5396 }
5397 if (extent_end <= start)
5398 goto next;
5399 if (btrfs_file_extent_disk_bytenr(leaf, fi) == 0) {
5400 search_start = extent_end;
5401 goto next;
5402 }
5403 ret = 0;
5404 goto out;
5405next:
5406 path->slots[0]++;
5407 }
5408 ret = 1;
5409out:
5410 btrfs_free_path(path);
5411 return ret;
5412}
5413
Josef Bacik16e75492013-10-22 12:18:51 -04005414static int maybe_send_hole(struct send_ctx *sctx, struct btrfs_path *path,
5415 struct btrfs_key *key)
5416{
5417 struct btrfs_file_extent_item *fi;
5418 u64 extent_end;
5419 u8 type;
5420 int ret = 0;
5421
5422 if (sctx->cur_ino != key->objectid || !need_send_hole(sctx))
5423 return 0;
5424
5425 if (sctx->cur_inode_last_extent == (u64)-1) {
5426 ret = get_last_extent(sctx, key->offset - 1);
5427 if (ret)
5428 return ret;
5429 }
5430
5431 fi = btrfs_item_ptr(path->nodes[0], path->slots[0],
5432 struct btrfs_file_extent_item);
5433 type = btrfs_file_extent_type(path->nodes[0], fi);
5434 if (type == BTRFS_FILE_EXTENT_INLINE) {
Chris Mason514ac8a2014-01-03 21:07:00 -08005435 u64 size = btrfs_file_extent_inline_len(path->nodes[0],
5436 path->slots[0], fi);
Josef Bacik16e75492013-10-22 12:18:51 -04005437 extent_end = ALIGN(key->offset + size,
Jeff Mahoneyda170662016-06-15 09:22:56 -04005438 sctx->send_root->fs_info->sectorsize);
Josef Bacik16e75492013-10-22 12:18:51 -04005439 } else {
5440 extent_end = key->offset +
5441 btrfs_file_extent_num_bytes(path->nodes[0], fi);
5442 }
Filipe David Borba Mananabf54f412014-01-28 01:38:06 +00005443
5444 if (path->slots[0] == 0 &&
5445 sctx->cur_inode_last_extent < key->offset) {
5446 /*
5447 * We might have skipped entire leafs that contained only
5448 * file extent items for our current inode. These leafs have
5449 * a generation number smaller (older) than the one in the
5450 * current leaf and the leaf our last extent came from, and
5451 * are located between these 2 leafs.
5452 */
5453 ret = get_last_extent(sctx, key->offset - 1);
5454 if (ret)
5455 return ret;
5456 }
5457
Filipe Manana82bfb2e2017-02-14 17:56:32 +00005458 if (sctx->cur_inode_last_extent < key->offset) {
5459 ret = range_is_hole_in_parent(sctx,
5460 sctx->cur_inode_last_extent,
5461 key->offset);
5462 if (ret < 0)
5463 return ret;
5464 else if (ret == 0)
5465 ret = send_hole(sctx, key->offset);
5466 else
5467 ret = 0;
5468 }
Josef Bacik16e75492013-10-22 12:18:51 -04005469 sctx->cur_inode_last_extent = extent_end;
5470 return ret;
5471}
5472
Alexander Block31db9f72012-07-25 23:19:24 +02005473static int process_extent(struct send_ctx *sctx,
5474 struct btrfs_path *path,
5475 struct btrfs_key *key)
5476{
Alexander Block31db9f72012-07-25 23:19:24 +02005477 struct clone_root *found_clone = NULL;
Josef Bacik57cfd462013-08-20 15:55:39 -04005478 int ret = 0;
Alexander Block31db9f72012-07-25 23:19:24 +02005479
5480 if (S_ISLNK(sctx->cur_inode_mode))
5481 return 0;
5482
5483 if (sctx->parent_root && !sctx->cur_inode_new) {
5484 ret = is_extent_unchanged(sctx, path, key);
5485 if (ret < 0)
5486 goto out;
5487 if (ret) {
5488 ret = 0;
Josef Bacik16e75492013-10-22 12:18:51 -04005489 goto out_hole;
Alexander Block31db9f72012-07-25 23:19:24 +02005490 }
Josef Bacik57cfd462013-08-20 15:55:39 -04005491 } else {
5492 struct btrfs_file_extent_item *ei;
5493 u8 type;
5494
5495 ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
5496 struct btrfs_file_extent_item);
5497 type = btrfs_file_extent_type(path->nodes[0], ei);
5498 if (type == BTRFS_FILE_EXTENT_PREALLOC ||
5499 type == BTRFS_FILE_EXTENT_REG) {
5500 /*
5501 * The send spec does not have a prealloc command yet,
5502 * so just leave a hole for prealloc'ed extents until
5503 * we have enough commands queued up to justify rev'ing
5504 * the send spec.
5505 */
5506 if (type == BTRFS_FILE_EXTENT_PREALLOC) {
5507 ret = 0;
5508 goto out;
5509 }
5510
5511 /* Have a hole, just skip it. */
5512 if (btrfs_file_extent_disk_bytenr(path->nodes[0], ei) == 0) {
5513 ret = 0;
5514 goto out;
5515 }
5516 }
Alexander Block31db9f72012-07-25 23:19:24 +02005517 }
5518
5519 ret = find_extent_clone(sctx, path, key->objectid, key->offset,
5520 sctx->cur_inode_size, &found_clone);
5521 if (ret != -ENOENT && ret < 0)
5522 goto out;
5523
5524 ret = send_write_or_clone(sctx, path, key, found_clone);
Josef Bacik16e75492013-10-22 12:18:51 -04005525 if (ret)
5526 goto out;
5527out_hole:
5528 ret = maybe_send_hole(sctx, path, key);
Alexander Block31db9f72012-07-25 23:19:24 +02005529out:
5530 return ret;
5531}
5532
5533static int process_all_extents(struct send_ctx *sctx)
5534{
5535 int ret;
5536 struct btrfs_root *root;
5537 struct btrfs_path *path;
5538 struct btrfs_key key;
5539 struct btrfs_key found_key;
5540 struct extent_buffer *eb;
5541 int slot;
5542
5543 root = sctx->send_root;
5544 path = alloc_path_for_send();
5545 if (!path)
5546 return -ENOMEM;
5547
5548 key.objectid = sctx->cmp_key->objectid;
5549 key.type = BTRFS_EXTENT_DATA_KEY;
5550 key.offset = 0;
Filipe David Borba Manana7fdd29d2014-01-24 17:42:09 +00005551 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5552 if (ret < 0)
5553 goto out;
Alexander Block31db9f72012-07-25 23:19:24 +02005554
Filipe David Borba Manana7fdd29d2014-01-24 17:42:09 +00005555 while (1) {
Alexander Block31db9f72012-07-25 23:19:24 +02005556 eb = path->nodes[0];
5557 slot = path->slots[0];
Filipe David Borba Manana7fdd29d2014-01-24 17:42:09 +00005558
5559 if (slot >= btrfs_header_nritems(eb)) {
5560 ret = btrfs_next_leaf(root, path);
5561 if (ret < 0) {
5562 goto out;
5563 } else if (ret > 0) {
5564 ret = 0;
5565 break;
5566 }
5567 continue;
5568 }
5569
Alexander Block31db9f72012-07-25 23:19:24 +02005570 btrfs_item_key_to_cpu(eb, &found_key, slot);
5571
5572 if (found_key.objectid != key.objectid ||
5573 found_key.type != key.type) {
5574 ret = 0;
5575 goto out;
5576 }
5577
5578 ret = process_extent(sctx, path, &found_key);
5579 if (ret < 0)
5580 goto out;
5581
Filipe David Borba Manana7fdd29d2014-01-24 17:42:09 +00005582 path->slots[0]++;
Alexander Block31db9f72012-07-25 23:19:24 +02005583 }
5584
5585out:
5586 btrfs_free_path(path);
5587 return ret;
5588}
5589
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00005590static int process_recorded_refs_if_needed(struct send_ctx *sctx, int at_end,
5591 int *pending_move,
5592 int *refs_processed)
Alexander Block31db9f72012-07-25 23:19:24 +02005593{
5594 int ret = 0;
5595
5596 if (sctx->cur_ino == 0)
5597 goto out;
5598 if (!at_end && sctx->cur_ino == sctx->cmp_key->objectid &&
Jan Schmidt96b5bd72012-10-15 08:30:45 +00005599 sctx->cmp_key->type <= BTRFS_INODE_EXTREF_KEY)
Alexander Block31db9f72012-07-25 23:19:24 +02005600 goto out;
5601 if (list_empty(&sctx->new_refs) && list_empty(&sctx->deleted_refs))
5602 goto out;
5603
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00005604 ret = process_recorded_refs(sctx, pending_move);
Alexander Blocke479d9b2012-07-28 16:09:35 +02005605 if (ret < 0)
5606 goto out;
5607
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00005608 *refs_processed = 1;
Alexander Block31db9f72012-07-25 23:19:24 +02005609out:
5610 return ret;
5611}
5612
5613static int finish_inode_if_needed(struct send_ctx *sctx, int at_end)
5614{
5615 int ret = 0;
5616 u64 left_mode;
5617 u64 left_uid;
5618 u64 left_gid;
5619 u64 right_mode;
5620 u64 right_uid;
5621 u64 right_gid;
5622 int need_chmod = 0;
5623 int need_chown = 0;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00005624 int pending_move = 0;
5625 int refs_processed = 0;
Alexander Block31db9f72012-07-25 23:19:24 +02005626
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00005627 ret = process_recorded_refs_if_needed(sctx, at_end, &pending_move,
5628 &refs_processed);
Alexander Block31db9f72012-07-25 23:19:24 +02005629 if (ret < 0)
5630 goto out;
5631
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00005632 /*
5633 * We have processed the refs and thus need to advance send_progress.
5634 * Now, calls to get_cur_xxx will take the updated refs of the current
5635 * inode into account.
5636 *
5637 * On the other hand, if our current inode is a directory and couldn't
5638 * be moved/renamed because its parent was renamed/moved too and it has
5639 * a higher inode number, we can only move/rename our current inode
5640 * after we moved/renamed its parent. Therefore in this case operate on
5641 * the old path (pre move/rename) of our current inode, and the
5642 * move/rename will be performed later.
5643 */
5644 if (refs_processed && !pending_move)
5645 sctx->send_progress = sctx->cur_ino + 1;
5646
Alexander Block31db9f72012-07-25 23:19:24 +02005647 if (sctx->cur_ino == 0 || sctx->cur_inode_deleted)
5648 goto out;
5649 if (!at_end && sctx->cmp_key->objectid == sctx->cur_ino)
5650 goto out;
5651
5652 ret = get_inode_info(sctx->send_root, sctx->cur_ino, NULL, NULL,
Alexander Block85a7b332012-07-26 23:39:10 +02005653 &left_mode, &left_uid, &left_gid, NULL);
Alexander Block31db9f72012-07-25 23:19:24 +02005654 if (ret < 0)
5655 goto out;
5656
Alex Lyakase2d044f2012-10-17 13:52:47 +00005657 if (!sctx->parent_root || sctx->cur_inode_new) {
5658 need_chown = 1;
5659 if (!S_ISLNK(sctx->cur_inode_mode))
Alexander Block31db9f72012-07-25 23:19:24 +02005660 need_chmod = 1;
Alex Lyakase2d044f2012-10-17 13:52:47 +00005661 } else {
5662 ret = get_inode_info(sctx->parent_root, sctx->cur_ino,
5663 NULL, NULL, &right_mode, &right_uid,
5664 &right_gid, NULL);
5665 if (ret < 0)
5666 goto out;
Alexander Block31db9f72012-07-25 23:19:24 +02005667
Alex Lyakase2d044f2012-10-17 13:52:47 +00005668 if (left_uid != right_uid || left_gid != right_gid)
5669 need_chown = 1;
5670 if (!S_ISLNK(sctx->cur_inode_mode) && left_mode != right_mode)
5671 need_chmod = 1;
Alexander Block31db9f72012-07-25 23:19:24 +02005672 }
5673
5674 if (S_ISREG(sctx->cur_inode_mode)) {
Josef Bacik16e75492013-10-22 12:18:51 -04005675 if (need_send_hole(sctx)) {
Filipe Manana766b5e52014-03-30 23:02:53 +01005676 if (sctx->cur_inode_last_extent == (u64)-1 ||
5677 sctx->cur_inode_last_extent <
5678 sctx->cur_inode_size) {
Josef Bacik16e75492013-10-22 12:18:51 -04005679 ret = get_last_extent(sctx, (u64)-1);
5680 if (ret)
5681 goto out;
5682 }
5683 if (sctx->cur_inode_last_extent <
5684 sctx->cur_inode_size) {
5685 ret = send_hole(sctx, sctx->cur_inode_size);
5686 if (ret)
5687 goto out;
5688 }
5689 }
Alexander Block31db9f72012-07-25 23:19:24 +02005690 ret = send_truncate(sctx, sctx->cur_ino, sctx->cur_inode_gen,
5691 sctx->cur_inode_size);
5692 if (ret < 0)
5693 goto out;
5694 }
5695
5696 if (need_chown) {
5697 ret = send_chown(sctx, sctx->cur_ino, sctx->cur_inode_gen,
5698 left_uid, left_gid);
5699 if (ret < 0)
5700 goto out;
5701 }
5702 if (need_chmod) {
5703 ret = send_chmod(sctx, sctx->cur_ino, sctx->cur_inode_gen,
5704 left_mode);
5705 if (ret < 0)
5706 goto out;
5707 }
5708
5709 /*
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00005710 * If other directory inodes depended on our current directory
5711 * inode's move/rename, now do their move/rename operations.
Alexander Block31db9f72012-07-25 23:19:24 +02005712 */
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00005713 if (!is_waiting_for_move(sctx, sctx->cur_ino)) {
5714 ret = apply_children_dir_moves(sctx);
5715 if (ret)
5716 goto out;
Filipe Mananafcbd2152014-03-03 12:28:40 +00005717 /*
5718 * Need to send that every time, no matter if it actually
5719 * changed between the two trees as we have done changes to
5720 * the inode before. If our inode is a directory and it's
5721 * waiting to be moved/renamed, we will send its utimes when
5722 * it's moved/renamed, therefore we don't need to do it here.
5723 */
5724 sctx->send_progress = sctx->cur_ino + 1;
5725 ret = send_utimes(sctx, sctx->cur_ino, sctx->cur_inode_gen);
5726 if (ret < 0)
5727 goto out;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00005728 }
5729
Alexander Block31db9f72012-07-25 23:19:24 +02005730out:
5731 return ret;
5732}
5733
5734static int changed_inode(struct send_ctx *sctx,
5735 enum btrfs_compare_tree_result result)
5736{
5737 int ret = 0;
5738 struct btrfs_key *key = sctx->cmp_key;
5739 struct btrfs_inode_item *left_ii = NULL;
5740 struct btrfs_inode_item *right_ii = NULL;
5741 u64 left_gen = 0;
5742 u64 right_gen = 0;
5743
Alexander Block31db9f72012-07-25 23:19:24 +02005744 sctx->cur_ino = key->objectid;
5745 sctx->cur_inode_new_gen = 0;
Josef Bacik16e75492013-10-22 12:18:51 -04005746 sctx->cur_inode_last_extent = (u64)-1;
Alexander Blocke479d9b2012-07-28 16:09:35 +02005747
5748 /*
5749 * Set send_progress to current inode. This will tell all get_cur_xxx
5750 * functions that the current inode's refs are not updated yet. Later,
5751 * when process_recorded_refs is finished, it is set to cur_ino + 1.
5752 */
Alexander Block31db9f72012-07-25 23:19:24 +02005753 sctx->send_progress = sctx->cur_ino;
5754
5755 if (result == BTRFS_COMPARE_TREE_NEW ||
5756 result == BTRFS_COMPARE_TREE_CHANGED) {
5757 left_ii = btrfs_item_ptr(sctx->left_path->nodes[0],
5758 sctx->left_path->slots[0],
5759 struct btrfs_inode_item);
5760 left_gen = btrfs_inode_generation(sctx->left_path->nodes[0],
5761 left_ii);
5762 } else {
5763 right_ii = btrfs_item_ptr(sctx->right_path->nodes[0],
5764 sctx->right_path->slots[0],
5765 struct btrfs_inode_item);
5766 right_gen = btrfs_inode_generation(sctx->right_path->nodes[0],
5767 right_ii);
5768 }
5769 if (result == BTRFS_COMPARE_TREE_CHANGED) {
5770 right_ii = btrfs_item_ptr(sctx->right_path->nodes[0],
5771 sctx->right_path->slots[0],
5772 struct btrfs_inode_item);
5773
5774 right_gen = btrfs_inode_generation(sctx->right_path->nodes[0],
5775 right_ii);
Alexander Block6d85ed052012-08-01 14:48:59 +02005776
5777 /*
5778 * The cur_ino = root dir case is special here. We can't treat
5779 * the inode as deleted+reused because it would generate a
5780 * stream that tries to delete/mkdir the root dir.
5781 */
5782 if (left_gen != right_gen &&
5783 sctx->cur_ino != BTRFS_FIRST_FREE_OBJECTID)
Alexander Block31db9f72012-07-25 23:19:24 +02005784 sctx->cur_inode_new_gen = 1;
5785 }
5786
5787 if (result == BTRFS_COMPARE_TREE_NEW) {
5788 sctx->cur_inode_gen = left_gen;
5789 sctx->cur_inode_new = 1;
5790 sctx->cur_inode_deleted = 0;
5791 sctx->cur_inode_size = btrfs_inode_size(
5792 sctx->left_path->nodes[0], left_ii);
5793 sctx->cur_inode_mode = btrfs_inode_mode(
5794 sctx->left_path->nodes[0], left_ii);
Liu Bo644d1942014-02-27 17:29:01 +08005795 sctx->cur_inode_rdev = btrfs_inode_rdev(
5796 sctx->left_path->nodes[0], left_ii);
Alexander Block31db9f72012-07-25 23:19:24 +02005797 if (sctx->cur_ino != BTRFS_FIRST_FREE_OBJECTID)
Alexander Block1f4692d2012-07-28 10:42:24 +02005798 ret = send_create_inode_if_needed(sctx);
Alexander Block31db9f72012-07-25 23:19:24 +02005799 } else if (result == BTRFS_COMPARE_TREE_DELETED) {
5800 sctx->cur_inode_gen = right_gen;
5801 sctx->cur_inode_new = 0;
5802 sctx->cur_inode_deleted = 1;
5803 sctx->cur_inode_size = btrfs_inode_size(
5804 sctx->right_path->nodes[0], right_ii);
5805 sctx->cur_inode_mode = btrfs_inode_mode(
5806 sctx->right_path->nodes[0], right_ii);
5807 } else if (result == BTRFS_COMPARE_TREE_CHANGED) {
Alexander Block766702e2012-07-28 14:11:31 +02005808 /*
5809 * We need to do some special handling in case the inode was
5810 * reported as changed with a changed generation number. This
5811 * means that the original inode was deleted and new inode
5812 * reused the same inum. So we have to treat the old inode as
5813 * deleted and the new one as new.
5814 */
Alexander Block31db9f72012-07-25 23:19:24 +02005815 if (sctx->cur_inode_new_gen) {
Alexander Block766702e2012-07-28 14:11:31 +02005816 /*
5817 * First, process the inode as if it was deleted.
5818 */
Alexander Block31db9f72012-07-25 23:19:24 +02005819 sctx->cur_inode_gen = right_gen;
5820 sctx->cur_inode_new = 0;
5821 sctx->cur_inode_deleted = 1;
5822 sctx->cur_inode_size = btrfs_inode_size(
5823 sctx->right_path->nodes[0], right_ii);
5824 sctx->cur_inode_mode = btrfs_inode_mode(
5825 sctx->right_path->nodes[0], right_ii);
5826 ret = process_all_refs(sctx,
5827 BTRFS_COMPARE_TREE_DELETED);
5828 if (ret < 0)
5829 goto out;
5830
Alexander Block766702e2012-07-28 14:11:31 +02005831 /*
5832 * Now process the inode as if it was new.
5833 */
Alexander Block31db9f72012-07-25 23:19:24 +02005834 sctx->cur_inode_gen = left_gen;
5835 sctx->cur_inode_new = 1;
5836 sctx->cur_inode_deleted = 0;
5837 sctx->cur_inode_size = btrfs_inode_size(
5838 sctx->left_path->nodes[0], left_ii);
5839 sctx->cur_inode_mode = btrfs_inode_mode(
5840 sctx->left_path->nodes[0], left_ii);
Liu Bo644d1942014-02-27 17:29:01 +08005841 sctx->cur_inode_rdev = btrfs_inode_rdev(
5842 sctx->left_path->nodes[0], left_ii);
Alexander Block1f4692d2012-07-28 10:42:24 +02005843 ret = send_create_inode_if_needed(sctx);
Alexander Block31db9f72012-07-25 23:19:24 +02005844 if (ret < 0)
5845 goto out;
5846
5847 ret = process_all_refs(sctx, BTRFS_COMPARE_TREE_NEW);
5848 if (ret < 0)
5849 goto out;
Alexander Blocke479d9b2012-07-28 16:09:35 +02005850 /*
5851 * Advance send_progress now as we did not get into
5852 * process_recorded_refs_if_needed in the new_gen case.
5853 */
5854 sctx->send_progress = sctx->cur_ino + 1;
Alexander Block766702e2012-07-28 14:11:31 +02005855
5856 /*
5857 * Now process all extents and xattrs of the inode as if
5858 * they were all new.
5859 */
Alexander Block31db9f72012-07-25 23:19:24 +02005860 ret = process_all_extents(sctx);
5861 if (ret < 0)
5862 goto out;
5863 ret = process_all_new_xattrs(sctx);
5864 if (ret < 0)
5865 goto out;
5866 } else {
5867 sctx->cur_inode_gen = left_gen;
5868 sctx->cur_inode_new = 0;
5869 sctx->cur_inode_new_gen = 0;
5870 sctx->cur_inode_deleted = 0;
5871 sctx->cur_inode_size = btrfs_inode_size(
5872 sctx->left_path->nodes[0], left_ii);
5873 sctx->cur_inode_mode = btrfs_inode_mode(
5874 sctx->left_path->nodes[0], left_ii);
5875 }
5876 }
5877
5878out:
5879 return ret;
5880}
5881
Alexander Block766702e2012-07-28 14:11:31 +02005882/*
5883 * We have to process new refs before deleted refs, but compare_trees gives us
5884 * the new and deleted refs mixed. To fix this, we record the new/deleted refs
5885 * first and later process them in process_recorded_refs.
5886 * For the cur_inode_new_gen case, we skip recording completely because
5887 * changed_inode did already initiate processing of refs. The reason for this is
5888 * that in this case, compare_tree actually compares the refs of 2 different
5889 * inodes. To fix this, process_all_refs is used in changed_inode to handle all
5890 * refs of the right tree as deleted and all refs of the left tree as new.
5891 */
Alexander Block31db9f72012-07-25 23:19:24 +02005892static int changed_ref(struct send_ctx *sctx,
5893 enum btrfs_compare_tree_result result)
5894{
5895 int ret = 0;
5896
Filipe Manana95155582016-08-01 01:50:37 +01005897 if (sctx->cur_ino != sctx->cmp_key->objectid) {
5898 inconsistent_snapshot_error(sctx, result, "reference");
5899 return -EIO;
5900 }
Alexander Block31db9f72012-07-25 23:19:24 +02005901
5902 if (!sctx->cur_inode_new_gen &&
5903 sctx->cur_ino != BTRFS_FIRST_FREE_OBJECTID) {
5904 if (result == BTRFS_COMPARE_TREE_NEW)
5905 ret = record_new_ref(sctx);
5906 else if (result == BTRFS_COMPARE_TREE_DELETED)
5907 ret = record_deleted_ref(sctx);
5908 else if (result == BTRFS_COMPARE_TREE_CHANGED)
5909 ret = record_changed_ref(sctx);
5910 }
5911
5912 return ret;
5913}
5914
Alexander Block766702e2012-07-28 14:11:31 +02005915/*
5916 * Process new/deleted/changed xattrs. We skip processing in the
5917 * cur_inode_new_gen case because changed_inode did already initiate processing
5918 * of xattrs. The reason is the same as in changed_ref
5919 */
Alexander Block31db9f72012-07-25 23:19:24 +02005920static int changed_xattr(struct send_ctx *sctx,
5921 enum btrfs_compare_tree_result result)
5922{
5923 int ret = 0;
5924
Filipe Manana95155582016-08-01 01:50:37 +01005925 if (sctx->cur_ino != sctx->cmp_key->objectid) {
5926 inconsistent_snapshot_error(sctx, result, "xattr");
5927 return -EIO;
5928 }
Alexander Block31db9f72012-07-25 23:19:24 +02005929
5930 if (!sctx->cur_inode_new_gen && !sctx->cur_inode_deleted) {
5931 if (result == BTRFS_COMPARE_TREE_NEW)
5932 ret = process_new_xattr(sctx);
5933 else if (result == BTRFS_COMPARE_TREE_DELETED)
5934 ret = process_deleted_xattr(sctx);
5935 else if (result == BTRFS_COMPARE_TREE_CHANGED)
5936 ret = process_changed_xattr(sctx);
5937 }
5938
5939 return ret;
5940}
5941
Alexander Block766702e2012-07-28 14:11:31 +02005942/*
5943 * Process new/deleted/changed extents. We skip processing in the
5944 * cur_inode_new_gen case because changed_inode did already initiate processing
5945 * of extents. The reason is the same as in changed_ref
5946 */
Alexander Block31db9f72012-07-25 23:19:24 +02005947static int changed_extent(struct send_ctx *sctx,
5948 enum btrfs_compare_tree_result result)
5949{
5950 int ret = 0;
5951
Filipe Manana95155582016-08-01 01:50:37 +01005952 if (sctx->cur_ino != sctx->cmp_key->objectid) {
Filipe Mananad5e84fd2016-09-19 10:57:40 +01005953
5954 if (result == BTRFS_COMPARE_TREE_CHANGED) {
5955 struct extent_buffer *leaf_l;
5956 struct extent_buffer *leaf_r;
5957 struct btrfs_file_extent_item *ei_l;
5958 struct btrfs_file_extent_item *ei_r;
5959
5960 leaf_l = sctx->left_path->nodes[0];
5961 leaf_r = sctx->right_path->nodes[0];
5962 ei_l = btrfs_item_ptr(leaf_l,
5963 sctx->left_path->slots[0],
5964 struct btrfs_file_extent_item);
5965 ei_r = btrfs_item_ptr(leaf_r,
5966 sctx->right_path->slots[0],
5967 struct btrfs_file_extent_item);
5968
5969 /*
5970 * We may have found an extent item that has changed
5971 * only its disk_bytenr field and the corresponding
5972 * inode item was not updated. This case happens due to
5973 * very specific timings during relocation when a leaf
5974 * that contains file extent items is COWed while
5975 * relocation is ongoing and its in the stage where it
5976 * updates data pointers. So when this happens we can
5977 * safely ignore it since we know it's the same extent,
5978 * but just at different logical and physical locations
5979 * (when an extent is fully replaced with a new one, we
5980 * know the generation number must have changed too,
5981 * since snapshot creation implies committing the current
5982 * transaction, and the inode item must have been updated
5983 * as well).
5984 * This replacement of the disk_bytenr happens at
5985 * relocation.c:replace_file_extents() through
5986 * relocation.c:btrfs_reloc_cow_block().
5987 */
5988 if (btrfs_file_extent_generation(leaf_l, ei_l) ==
5989 btrfs_file_extent_generation(leaf_r, ei_r) &&
5990 btrfs_file_extent_ram_bytes(leaf_l, ei_l) ==
5991 btrfs_file_extent_ram_bytes(leaf_r, ei_r) &&
5992 btrfs_file_extent_compression(leaf_l, ei_l) ==
5993 btrfs_file_extent_compression(leaf_r, ei_r) &&
5994 btrfs_file_extent_encryption(leaf_l, ei_l) ==
5995 btrfs_file_extent_encryption(leaf_r, ei_r) &&
5996 btrfs_file_extent_other_encoding(leaf_l, ei_l) ==
5997 btrfs_file_extent_other_encoding(leaf_r, ei_r) &&
5998 btrfs_file_extent_type(leaf_l, ei_l) ==
5999 btrfs_file_extent_type(leaf_r, ei_r) &&
6000 btrfs_file_extent_disk_bytenr(leaf_l, ei_l) !=
6001 btrfs_file_extent_disk_bytenr(leaf_r, ei_r) &&
6002 btrfs_file_extent_disk_num_bytes(leaf_l, ei_l) ==
6003 btrfs_file_extent_disk_num_bytes(leaf_r, ei_r) &&
6004 btrfs_file_extent_offset(leaf_l, ei_l) ==
6005 btrfs_file_extent_offset(leaf_r, ei_r) &&
6006 btrfs_file_extent_num_bytes(leaf_l, ei_l) ==
6007 btrfs_file_extent_num_bytes(leaf_r, ei_r))
6008 return 0;
6009 }
6010
Filipe Manana95155582016-08-01 01:50:37 +01006011 inconsistent_snapshot_error(sctx, result, "extent");
6012 return -EIO;
6013 }
Alexander Block31db9f72012-07-25 23:19:24 +02006014
6015 if (!sctx->cur_inode_new_gen && !sctx->cur_inode_deleted) {
6016 if (result != BTRFS_COMPARE_TREE_DELETED)
6017 ret = process_extent(sctx, sctx->left_path,
6018 sctx->cmp_key);
6019 }
6020
6021 return ret;
6022}
6023
Josef Bacikba5e8f22013-08-16 16:52:55 -04006024static int dir_changed(struct send_ctx *sctx, u64 dir)
6025{
6026 u64 orig_gen, new_gen;
6027 int ret;
6028
6029 ret = get_inode_info(sctx->send_root, dir, NULL, &new_gen, NULL, NULL,
6030 NULL, NULL);
6031 if (ret)
6032 return ret;
6033
6034 ret = get_inode_info(sctx->parent_root, dir, NULL, &orig_gen, NULL,
6035 NULL, NULL, NULL);
6036 if (ret)
6037 return ret;
6038
6039 return (orig_gen != new_gen) ? 1 : 0;
6040}
6041
6042static int compare_refs(struct send_ctx *sctx, struct btrfs_path *path,
6043 struct btrfs_key *key)
6044{
6045 struct btrfs_inode_extref *extref;
6046 struct extent_buffer *leaf;
6047 u64 dirid = 0, last_dirid = 0;
6048 unsigned long ptr;
6049 u32 item_size;
6050 u32 cur_offset = 0;
6051 int ref_name_len;
6052 int ret = 0;
6053
6054 /* Easy case, just check this one dirid */
6055 if (key->type == BTRFS_INODE_REF_KEY) {
6056 dirid = key->offset;
6057
6058 ret = dir_changed(sctx, dirid);
6059 goto out;
6060 }
6061
6062 leaf = path->nodes[0];
6063 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
6064 ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
6065 while (cur_offset < item_size) {
6066 extref = (struct btrfs_inode_extref *)(ptr +
6067 cur_offset);
6068 dirid = btrfs_inode_extref_parent(leaf, extref);
6069 ref_name_len = btrfs_inode_extref_name_len(leaf, extref);
6070 cur_offset += ref_name_len + sizeof(*extref);
6071 if (dirid == last_dirid)
6072 continue;
6073 ret = dir_changed(sctx, dirid);
6074 if (ret)
6075 break;
6076 last_dirid = dirid;
6077 }
6078out:
6079 return ret;
6080}
6081
Alexander Block766702e2012-07-28 14:11:31 +02006082/*
6083 * Updates compare related fields in sctx and simply forwards to the actual
6084 * changed_xxx functions.
6085 */
Alexander Block31db9f72012-07-25 23:19:24 +02006086static int changed_cb(struct btrfs_root *left_root,
6087 struct btrfs_root *right_root,
6088 struct btrfs_path *left_path,
6089 struct btrfs_path *right_path,
6090 struct btrfs_key *key,
6091 enum btrfs_compare_tree_result result,
6092 void *ctx)
6093{
6094 int ret = 0;
6095 struct send_ctx *sctx = ctx;
6096
Josef Bacikba5e8f22013-08-16 16:52:55 -04006097 if (result == BTRFS_COMPARE_TREE_SAME) {
Josef Bacik16e75492013-10-22 12:18:51 -04006098 if (key->type == BTRFS_INODE_REF_KEY ||
6099 key->type == BTRFS_INODE_EXTREF_KEY) {
6100 ret = compare_refs(sctx, left_path, key);
6101 if (!ret)
6102 return 0;
6103 if (ret < 0)
6104 return ret;
6105 } else if (key->type == BTRFS_EXTENT_DATA_KEY) {
6106 return maybe_send_hole(sctx, left_path, key);
6107 } else {
Josef Bacikba5e8f22013-08-16 16:52:55 -04006108 return 0;
Josef Bacik16e75492013-10-22 12:18:51 -04006109 }
Josef Bacikba5e8f22013-08-16 16:52:55 -04006110 result = BTRFS_COMPARE_TREE_CHANGED;
6111 ret = 0;
6112 }
6113
Alexander Block31db9f72012-07-25 23:19:24 +02006114 sctx->left_path = left_path;
6115 sctx->right_path = right_path;
6116 sctx->cmp_key = key;
6117
6118 ret = finish_inode_if_needed(sctx, 0);
6119 if (ret < 0)
6120 goto out;
6121
Alexander Block2981e222012-08-01 14:47:03 +02006122 /* Ignore non-FS objects */
6123 if (key->objectid == BTRFS_FREE_INO_OBJECTID ||
6124 key->objectid == BTRFS_FREE_SPACE_OBJECTID)
6125 goto out;
6126
Alexander Block31db9f72012-07-25 23:19:24 +02006127 if (key->type == BTRFS_INODE_ITEM_KEY)
6128 ret = changed_inode(sctx, result);
Jan Schmidt96b5bd72012-10-15 08:30:45 +00006129 else if (key->type == BTRFS_INODE_REF_KEY ||
6130 key->type == BTRFS_INODE_EXTREF_KEY)
Alexander Block31db9f72012-07-25 23:19:24 +02006131 ret = changed_ref(sctx, result);
6132 else if (key->type == BTRFS_XATTR_ITEM_KEY)
6133 ret = changed_xattr(sctx, result);
6134 else if (key->type == BTRFS_EXTENT_DATA_KEY)
6135 ret = changed_extent(sctx, result);
6136
6137out:
6138 return ret;
6139}
6140
6141static int full_send_tree(struct send_ctx *sctx)
6142{
6143 int ret;
Alexander Block31db9f72012-07-25 23:19:24 +02006144 struct btrfs_root *send_root = sctx->send_root;
6145 struct btrfs_key key;
6146 struct btrfs_key found_key;
6147 struct btrfs_path *path;
6148 struct extent_buffer *eb;
6149 int slot;
Alexander Block31db9f72012-07-25 23:19:24 +02006150
6151 path = alloc_path_for_send();
6152 if (!path)
6153 return -ENOMEM;
6154
Alexander Block31db9f72012-07-25 23:19:24 +02006155 key.objectid = BTRFS_FIRST_FREE_OBJECTID;
6156 key.type = BTRFS_INODE_ITEM_KEY;
6157 key.offset = 0;
6158
Alexander Block31db9f72012-07-25 23:19:24 +02006159 ret = btrfs_search_slot_for_read(send_root, &key, path, 1, 0);
6160 if (ret < 0)
6161 goto out;
6162 if (ret)
6163 goto out_finish;
6164
6165 while (1) {
Alexander Block31db9f72012-07-25 23:19:24 +02006166 eb = path->nodes[0];
6167 slot = path->slots[0];
6168 btrfs_item_key_to_cpu(eb, &found_key, slot);
6169
6170 ret = changed_cb(send_root, NULL, path, NULL,
6171 &found_key, BTRFS_COMPARE_TREE_NEW, sctx);
6172 if (ret < 0)
6173 goto out;
6174
6175 key.objectid = found_key.objectid;
6176 key.type = found_key.type;
6177 key.offset = found_key.offset + 1;
6178
6179 ret = btrfs_next_item(send_root, path);
6180 if (ret < 0)
6181 goto out;
6182 if (ret) {
6183 ret = 0;
6184 break;
6185 }
6186 }
6187
6188out_finish:
6189 ret = finish_inode_if_needed(sctx, 1);
6190
6191out:
6192 btrfs_free_path(path);
Alexander Block31db9f72012-07-25 23:19:24 +02006193 return ret;
6194}
6195
6196static int send_subvol(struct send_ctx *sctx)
6197{
6198 int ret;
6199
Stefan Behrensc2c71322013-04-10 17:10:52 +00006200 if (!(sctx->flags & BTRFS_SEND_FLAG_OMIT_STREAM_HEADER)) {
6201 ret = send_header(sctx);
6202 if (ret < 0)
6203 goto out;
6204 }
Alexander Block31db9f72012-07-25 23:19:24 +02006205
6206 ret = send_subvol_begin(sctx);
6207 if (ret < 0)
6208 goto out;
6209
6210 if (sctx->parent_root) {
6211 ret = btrfs_compare_trees(sctx->send_root, sctx->parent_root,
6212 changed_cb, sctx);
6213 if (ret < 0)
6214 goto out;
6215 ret = finish_inode_if_needed(sctx, 1);
6216 if (ret < 0)
6217 goto out;
6218 } else {
6219 ret = full_send_tree(sctx);
6220 if (ret < 0)
6221 goto out;
6222 }
6223
6224out:
Alexander Block31db9f72012-07-25 23:19:24 +02006225 free_recorded_refs(sctx);
6226 return ret;
6227}
6228
Filipe Mananae5fa8f82014-10-21 11:11:41 +01006229/*
6230 * If orphan cleanup did remove any orphans from a root, it means the tree
6231 * was modified and therefore the commit root is not the same as the current
6232 * root anymore. This is a problem, because send uses the commit root and
6233 * therefore can see inode items that don't exist in the current root anymore,
6234 * and for example make calls to btrfs_iget, which will do tree lookups based
6235 * on the current root and not on the commit root. Those lookups will fail,
6236 * returning a -ESTALE error, and making send fail with that error. So make
6237 * sure a send does not see any orphans we have just removed, and that it will
6238 * see the same inodes regardless of whether a transaction commit happened
6239 * before it started (meaning that the commit root will be the same as the
6240 * current root) or not.
6241 */
6242static int ensure_commit_roots_uptodate(struct send_ctx *sctx)
6243{
6244 int i;
6245 struct btrfs_trans_handle *trans = NULL;
6246
6247again:
6248 if (sctx->parent_root &&
6249 sctx->parent_root->node != sctx->parent_root->commit_root)
6250 goto commit_trans;
6251
6252 for (i = 0; i < sctx->clone_roots_cnt; i++)
6253 if (sctx->clone_roots[i].root->node !=
6254 sctx->clone_roots[i].root->commit_root)
6255 goto commit_trans;
6256
6257 if (trans)
Jeff Mahoney3a45bb22016-09-09 21:39:03 -04006258 return btrfs_end_transaction(trans);
Filipe Mananae5fa8f82014-10-21 11:11:41 +01006259
6260 return 0;
6261
6262commit_trans:
6263 /* Use any root, all fs roots will get their commit roots updated. */
6264 if (!trans) {
6265 trans = btrfs_join_transaction(sctx->send_root);
6266 if (IS_ERR(trans))
6267 return PTR_ERR(trans);
6268 goto again;
6269 }
6270
Jeff Mahoney3a45bb22016-09-09 21:39:03 -04006271 return btrfs_commit_transaction(trans);
Filipe Mananae5fa8f82014-10-21 11:11:41 +01006272}
6273
David Sterba66ef7d62013-12-17 15:07:20 +01006274static void btrfs_root_dec_send_in_progress(struct btrfs_root* root)
6275{
6276 spin_lock(&root->root_item_lock);
6277 root->send_in_progress--;
6278 /*
6279 * Not much left to do, we don't know why it's unbalanced and
6280 * can't blindly reset it to 0.
6281 */
6282 if (root->send_in_progress < 0)
6283 btrfs_err(root->fs_info,
Jeff Mahoney0b246af2016-06-22 18:54:23 -04006284 "send_in_progres unbalanced %d root %llu",
6285 root->send_in_progress, root->root_key.objectid);
David Sterba66ef7d62013-12-17 15:07:20 +01006286 spin_unlock(&root->root_item_lock);
6287}
6288
Alexander Block31db9f72012-07-25 23:19:24 +02006289long btrfs_ioctl_send(struct file *mnt_file, void __user *arg_)
6290{
6291 int ret = 0;
Jeff Mahoney0b246af2016-06-22 18:54:23 -04006292 struct btrfs_root *send_root = BTRFS_I(file_inode(mnt_file))->root;
6293 struct btrfs_fs_info *fs_info = send_root->fs_info;
Alexander Block31db9f72012-07-25 23:19:24 +02006294 struct btrfs_root *clone_root;
Alexander Block31db9f72012-07-25 23:19:24 +02006295 struct btrfs_ioctl_send_args *arg = NULL;
6296 struct btrfs_key key;
Alexander Block31db9f72012-07-25 23:19:24 +02006297 struct send_ctx *sctx = NULL;
6298 u32 i;
6299 u64 *clone_sources_tmp = NULL;
David Sterba2c686532013-12-16 17:34:17 +01006300 int clone_sources_to_rollback = 0;
David Sterbae55d1152016-04-11 18:52:02 +02006301 unsigned alloc_size;
Wang Shilong896c14f2014-01-07 17:25:18 +08006302 int sort_clone_roots = 0;
Wang Shilong18f687d2014-01-07 17:25:19 +08006303 int index;
Alexander Block31db9f72012-07-25 23:19:24 +02006304
6305 if (!capable(CAP_SYS_ADMIN))
6306 return -EPERM;
6307
Josef Bacik139f8072013-05-20 11:26:50 -04006308 /*
David Sterba2c686532013-12-16 17:34:17 +01006309 * The subvolume must remain read-only during send, protect against
David Sterba521e0542014-04-15 16:41:44 +02006310 * making it RW. This also protects against deletion.
David Sterba2c686532013-12-16 17:34:17 +01006311 */
6312 spin_lock(&send_root->root_item_lock);
6313 send_root->send_in_progress++;
6314 spin_unlock(&send_root->root_item_lock);
6315
6316 /*
Josef Bacik139f8072013-05-20 11:26:50 -04006317 * This is done when we lookup the root, it should already be complete
6318 * by the time we get here.
6319 */
6320 WARN_ON(send_root->orphan_cleanup_state != ORPHAN_CLEANUP_DONE);
6321
6322 /*
David Sterba2c686532013-12-16 17:34:17 +01006323 * Userspace tools do the checks and warn the user if it's
6324 * not RO.
6325 */
6326 if (!btrfs_root_readonly(send_root)) {
6327 ret = -EPERM;
6328 goto out;
6329 }
6330
Alexander Block31db9f72012-07-25 23:19:24 +02006331 arg = memdup_user(arg_, sizeof(*arg));
6332 if (IS_ERR(arg)) {
6333 ret = PTR_ERR(arg);
6334 arg = NULL;
6335 goto out;
6336 }
6337
Dan Carpenter457ae722017-03-17 23:51:20 +03006338 /*
6339 * Check that we don't overflow at later allocations, we request
6340 * clone_sources_count + 1 items, and compare to unsigned long inside
6341 * access_ok.
6342 */
Dan Carpenterf5ecec32016-04-13 09:40:59 +03006343 if (arg->clone_sources_count >
Dan Carpenter457ae722017-03-17 23:51:20 +03006344 ULONG_MAX / sizeof(struct clone_root) - 1) {
Dan Carpenterf5ecec32016-04-13 09:40:59 +03006345 ret = -EINVAL;
6346 goto out;
6347 }
6348
Alexander Block31db9f72012-07-25 23:19:24 +02006349 if (!access_ok(VERIFY_READ, arg->clone_sources,
Dan Carpenter700ff4f2013-01-10 03:57:25 -05006350 sizeof(*arg->clone_sources) *
6351 arg->clone_sources_count)) {
Alexander Block31db9f72012-07-25 23:19:24 +02006352 ret = -EFAULT;
6353 goto out;
6354 }
6355
Stefan Behrensc2c71322013-04-10 17:10:52 +00006356 if (arg->flags & ~BTRFS_SEND_FLAG_MASK) {
Mark Fashehcb95e7b2013-02-04 20:54:57 +00006357 ret = -EINVAL;
6358 goto out;
6359 }
6360
David Sterbae780b0d2016-01-18 18:42:13 +01006361 sctx = kzalloc(sizeof(struct send_ctx), GFP_KERNEL);
Alexander Block31db9f72012-07-25 23:19:24 +02006362 if (!sctx) {
6363 ret = -ENOMEM;
6364 goto out;
6365 }
6366
6367 INIT_LIST_HEAD(&sctx->new_refs);
6368 INIT_LIST_HEAD(&sctx->deleted_refs);
David Sterbae780b0d2016-01-18 18:42:13 +01006369 INIT_RADIX_TREE(&sctx->name_cache, GFP_KERNEL);
Alexander Block31db9f72012-07-25 23:19:24 +02006370 INIT_LIST_HEAD(&sctx->name_cache_list);
6371
Mark Fashehcb95e7b2013-02-04 20:54:57 +00006372 sctx->flags = arg->flags;
6373
Alexander Block31db9f72012-07-25 23:19:24 +02006374 sctx->send_filp = fget(arg->send_fd);
Tsutomu Itohecc7ada2013-04-19 01:04:46 +00006375 if (!sctx->send_filp) {
6376 ret = -EBADF;
Alexander Block31db9f72012-07-25 23:19:24 +02006377 goto out;
6378 }
6379
Alexander Block31db9f72012-07-25 23:19:24 +02006380 sctx->send_root = send_root;
David Sterba521e0542014-04-15 16:41:44 +02006381 /*
6382 * Unlikely but possible, if the subvolume is marked for deletion but
6383 * is slow to remove the directory entry, send can still be started
6384 */
6385 if (btrfs_root_dead(sctx->send_root)) {
6386 ret = -EPERM;
6387 goto out;
6388 }
6389
Alexander Block31db9f72012-07-25 23:19:24 +02006390 sctx->clone_roots_cnt = arg->clone_sources_count;
6391
6392 sctx->send_max_size = BTRFS_SEND_BUF_SIZE;
Michal Hocko752ade62017-05-08 15:57:27 -07006393 sctx->send_buf = kvmalloc(sctx->send_max_size, GFP_KERNEL);
Alexander Block31db9f72012-07-25 23:19:24 +02006394 if (!sctx->send_buf) {
Michal Hocko752ade62017-05-08 15:57:27 -07006395 ret = -ENOMEM;
6396 goto out;
Alexander Block31db9f72012-07-25 23:19:24 +02006397 }
6398
Michal Hocko752ade62017-05-08 15:57:27 -07006399 sctx->read_buf = kvmalloc(BTRFS_SEND_READ_SIZE, GFP_KERNEL);
Alexander Block31db9f72012-07-25 23:19:24 +02006400 if (!sctx->read_buf) {
Michal Hocko752ade62017-05-08 15:57:27 -07006401 ret = -ENOMEM;
6402 goto out;
Alexander Block31db9f72012-07-25 23:19:24 +02006403 }
6404
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00006405 sctx->pending_dir_moves = RB_ROOT;
6406 sctx->waiting_dir_moves = RB_ROOT;
Filipe Manana9dc44212014-02-19 14:31:44 +00006407 sctx->orphan_dirs = RB_ROOT;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00006408
David Sterbae55d1152016-04-11 18:52:02 +02006409 alloc_size = sizeof(struct clone_root) * (arg->clone_sources_count + 1);
6410
David Sterba818e0102017-05-31 18:40:02 +02006411 sctx->clone_roots = kzalloc(alloc_size, GFP_KERNEL);
Alexander Block31db9f72012-07-25 23:19:24 +02006412 if (!sctx->clone_roots) {
David Sterba818e0102017-05-31 18:40:02 +02006413 ret = -ENOMEM;
6414 goto out;
Alexander Block31db9f72012-07-25 23:19:24 +02006415 }
6416
David Sterbae55d1152016-04-11 18:52:02 +02006417 alloc_size = arg->clone_sources_count * sizeof(*arg->clone_sources);
6418
Alexander Block31db9f72012-07-25 23:19:24 +02006419 if (arg->clone_sources_count) {
Michal Hocko752ade62017-05-08 15:57:27 -07006420 clone_sources_tmp = kvmalloc(alloc_size, GFP_KERNEL);
Alexander Block31db9f72012-07-25 23:19:24 +02006421 if (!clone_sources_tmp) {
Michal Hocko752ade62017-05-08 15:57:27 -07006422 ret = -ENOMEM;
6423 goto out;
Alexander Block31db9f72012-07-25 23:19:24 +02006424 }
6425
6426 ret = copy_from_user(clone_sources_tmp, arg->clone_sources,
David Sterbae55d1152016-04-11 18:52:02 +02006427 alloc_size);
Alexander Block31db9f72012-07-25 23:19:24 +02006428 if (ret) {
6429 ret = -EFAULT;
6430 goto out;
6431 }
6432
6433 for (i = 0; i < arg->clone_sources_count; i++) {
6434 key.objectid = clone_sources_tmp[i];
6435 key.type = BTRFS_ROOT_ITEM_KEY;
6436 key.offset = (u64)-1;
Wang Shilong18f687d2014-01-07 17:25:19 +08006437
6438 index = srcu_read_lock(&fs_info->subvol_srcu);
6439
Alexander Block31db9f72012-07-25 23:19:24 +02006440 clone_root = btrfs_read_fs_root_no_name(fs_info, &key);
Alexander Block31db9f72012-07-25 23:19:24 +02006441 if (IS_ERR(clone_root)) {
Wang Shilong18f687d2014-01-07 17:25:19 +08006442 srcu_read_unlock(&fs_info->subvol_srcu, index);
Alexander Block31db9f72012-07-25 23:19:24 +02006443 ret = PTR_ERR(clone_root);
6444 goto out;
6445 }
David Sterba2c686532013-12-16 17:34:17 +01006446 spin_lock(&clone_root->root_item_lock);
Filipe Manana5cc2b172015-03-02 20:53:52 +00006447 if (!btrfs_root_readonly(clone_root) ||
6448 btrfs_root_dead(clone_root)) {
David Sterba2c686532013-12-16 17:34:17 +01006449 spin_unlock(&clone_root->root_item_lock);
Wang Shilong18f687d2014-01-07 17:25:19 +08006450 srcu_read_unlock(&fs_info->subvol_srcu, index);
David Sterba2c686532013-12-16 17:34:17 +01006451 ret = -EPERM;
6452 goto out;
6453 }
Filipe Manana2f1f4652015-03-02 20:53:53 +00006454 clone_root->send_in_progress++;
David Sterba2c686532013-12-16 17:34:17 +01006455 spin_unlock(&clone_root->root_item_lock);
Wang Shilong18f687d2014-01-07 17:25:19 +08006456 srcu_read_unlock(&fs_info->subvol_srcu, index);
6457
Alexander Block31db9f72012-07-25 23:19:24 +02006458 sctx->clone_roots[i].root = clone_root;
Filipe Manana2f1f4652015-03-02 20:53:53 +00006459 clone_sources_to_rollback = i + 1;
Alexander Block31db9f72012-07-25 23:19:24 +02006460 }
David Sterba2f913062016-04-11 18:40:08 +02006461 kvfree(clone_sources_tmp);
Alexander Block31db9f72012-07-25 23:19:24 +02006462 clone_sources_tmp = NULL;
6463 }
6464
6465 if (arg->parent_root) {
6466 key.objectid = arg->parent_root;
6467 key.type = BTRFS_ROOT_ITEM_KEY;
6468 key.offset = (u64)-1;
Wang Shilong18f687d2014-01-07 17:25:19 +08006469
6470 index = srcu_read_lock(&fs_info->subvol_srcu);
6471
Alexander Block31db9f72012-07-25 23:19:24 +02006472 sctx->parent_root = btrfs_read_fs_root_no_name(fs_info, &key);
Stefan Behrensb1b19592013-05-13 14:42:57 +00006473 if (IS_ERR(sctx->parent_root)) {
Wang Shilong18f687d2014-01-07 17:25:19 +08006474 srcu_read_unlock(&fs_info->subvol_srcu, index);
Stefan Behrensb1b19592013-05-13 14:42:57 +00006475 ret = PTR_ERR(sctx->parent_root);
Alexander Block31db9f72012-07-25 23:19:24 +02006476 goto out;
6477 }
Wang Shilong18f687d2014-01-07 17:25:19 +08006478
David Sterba2c686532013-12-16 17:34:17 +01006479 spin_lock(&sctx->parent_root->root_item_lock);
6480 sctx->parent_root->send_in_progress++;
David Sterba521e0542014-04-15 16:41:44 +02006481 if (!btrfs_root_readonly(sctx->parent_root) ||
6482 btrfs_root_dead(sctx->parent_root)) {
David Sterba2c686532013-12-16 17:34:17 +01006483 spin_unlock(&sctx->parent_root->root_item_lock);
Wang Shilong18f687d2014-01-07 17:25:19 +08006484 srcu_read_unlock(&fs_info->subvol_srcu, index);
David Sterba2c686532013-12-16 17:34:17 +01006485 ret = -EPERM;
6486 goto out;
6487 }
6488 spin_unlock(&sctx->parent_root->root_item_lock);
Wang Shilong18f687d2014-01-07 17:25:19 +08006489
6490 srcu_read_unlock(&fs_info->subvol_srcu, index);
Alexander Block31db9f72012-07-25 23:19:24 +02006491 }
6492
6493 /*
6494 * Clones from send_root are allowed, but only if the clone source
6495 * is behind the current send position. This is checked while searching
6496 * for possible clone sources.
6497 */
6498 sctx->clone_roots[sctx->clone_roots_cnt++].root = sctx->send_root;
6499
6500 /* We do a bsearch later */
6501 sort(sctx->clone_roots, sctx->clone_roots_cnt,
6502 sizeof(*sctx->clone_roots), __clone_root_cmp_sort,
6503 NULL);
Wang Shilong896c14f2014-01-07 17:25:18 +08006504 sort_clone_roots = 1;
Alexander Block31db9f72012-07-25 23:19:24 +02006505
Filipe Mananae5fa8f82014-10-21 11:11:41 +01006506 ret = ensure_commit_roots_uptodate(sctx);
6507 if (ret)
6508 goto out;
6509
David Sterba2755a0d2014-07-31 00:43:18 +02006510 current->journal_info = BTRFS_SEND_TRANS_STUB;
Alexander Block31db9f72012-07-25 23:19:24 +02006511 ret = send_subvol(sctx);
Josef Bacika26e8c92014-03-28 17:07:27 -04006512 current->journal_info = NULL;
Alexander Block31db9f72012-07-25 23:19:24 +02006513 if (ret < 0)
6514 goto out;
6515
Stefan Behrensc2c71322013-04-10 17:10:52 +00006516 if (!(sctx->flags & BTRFS_SEND_FLAG_OMIT_END_CMD)) {
6517 ret = begin_cmd(sctx, BTRFS_SEND_C_END);
6518 if (ret < 0)
6519 goto out;
6520 ret = send_cmd(sctx);
6521 if (ret < 0)
6522 goto out;
6523 }
Alexander Block31db9f72012-07-25 23:19:24 +02006524
6525out:
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00006526 WARN_ON(sctx && !ret && !RB_EMPTY_ROOT(&sctx->pending_dir_moves));
6527 while (sctx && !RB_EMPTY_ROOT(&sctx->pending_dir_moves)) {
6528 struct rb_node *n;
6529 struct pending_dir_move *pm;
6530
6531 n = rb_first(&sctx->pending_dir_moves);
6532 pm = rb_entry(n, struct pending_dir_move, node);
6533 while (!list_empty(&pm->list)) {
6534 struct pending_dir_move *pm2;
6535
6536 pm2 = list_first_entry(&pm->list,
6537 struct pending_dir_move, list);
6538 free_pending_move(sctx, pm2);
6539 }
6540 free_pending_move(sctx, pm);
6541 }
6542
6543 WARN_ON(sctx && !ret && !RB_EMPTY_ROOT(&sctx->waiting_dir_moves));
6544 while (sctx && !RB_EMPTY_ROOT(&sctx->waiting_dir_moves)) {
6545 struct rb_node *n;
6546 struct waiting_dir_move *dm;
6547
6548 n = rb_first(&sctx->waiting_dir_moves);
6549 dm = rb_entry(n, struct waiting_dir_move, node);
6550 rb_erase(&dm->node, &sctx->waiting_dir_moves);
6551 kfree(dm);
6552 }
6553
Filipe Manana9dc44212014-02-19 14:31:44 +00006554 WARN_ON(sctx && !ret && !RB_EMPTY_ROOT(&sctx->orphan_dirs));
6555 while (sctx && !RB_EMPTY_ROOT(&sctx->orphan_dirs)) {
6556 struct rb_node *n;
6557 struct orphan_dir_info *odi;
6558
6559 n = rb_first(&sctx->orphan_dirs);
6560 odi = rb_entry(n, struct orphan_dir_info, node);
6561 free_orphan_dir_info(sctx, odi);
6562 }
6563
Wang Shilong896c14f2014-01-07 17:25:18 +08006564 if (sort_clone_roots) {
6565 for (i = 0; i < sctx->clone_roots_cnt; i++)
6566 btrfs_root_dec_send_in_progress(
6567 sctx->clone_roots[i].root);
6568 } else {
6569 for (i = 0; sctx && i < clone_sources_to_rollback; i++)
6570 btrfs_root_dec_send_in_progress(
6571 sctx->clone_roots[i].root);
6572
6573 btrfs_root_dec_send_in_progress(send_root);
6574 }
David Sterba66ef7d62013-12-17 15:07:20 +01006575 if (sctx && !IS_ERR_OR_NULL(sctx->parent_root))
6576 btrfs_root_dec_send_in_progress(sctx->parent_root);
David Sterba2c686532013-12-16 17:34:17 +01006577
Alexander Block31db9f72012-07-25 23:19:24 +02006578 kfree(arg);
David Sterba2f913062016-04-11 18:40:08 +02006579 kvfree(clone_sources_tmp);
Alexander Block31db9f72012-07-25 23:19:24 +02006580
6581 if (sctx) {
6582 if (sctx->send_filp)
6583 fput(sctx->send_filp);
6584
David Sterbac03d01f2016-04-11 18:40:08 +02006585 kvfree(sctx->clone_roots);
David Sterba6ff48ce2016-04-11 18:40:08 +02006586 kvfree(sctx->send_buf);
David Sterbaeb5b75f2016-04-11 18:40:08 +02006587 kvfree(sctx->read_buf);
Alexander Block31db9f72012-07-25 23:19:24 +02006588
6589 name_cache_free(sctx);
6590
6591 kfree(sctx);
6592 }
6593
6594 return ret;
6595}