blob: 6a8c86074aa4cb7d60b57a0fceb630fd8d0810ac [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
39static int g_verbose = 0;
40
41#define verbose_printk(...) if (g_verbose) printk(__VA_ARGS__)
42
43/*
44 * A fs_path is a helper to dynamically build path names with unknown size.
45 * It reallocates the internal buffer on demand.
46 * It allows fast adding of path elements on the right side (normal path) and
47 * fast adding to the left side (reversed path). A reversed path can also be
48 * unreversed if needed.
49 */
50struct fs_path {
51 union {
52 struct {
53 char *start;
54 char *end;
Alexander Block31db9f72012-07-25 23:19:24 +020055
56 char *buf;
David Sterba1f5a7ff2014-02-03 19:23:47 +010057 unsigned short buf_len:15;
58 unsigned short reversed:1;
Alexander Block31db9f72012-07-25 23:19:24 +020059 char inline_buf[];
60 };
David Sterbaace01052014-02-05 16:17:34 +010061 /*
62 * Average path length does not exceed 200 bytes, we'll have
63 * better packing in the slab and higher chance to satisfy
64 * a allocation later during send.
65 */
66 char pad[256];
Alexander Block31db9f72012-07-25 23:19:24 +020067 };
68};
69#define FS_PATH_INLINE_SIZE \
70 (sizeof(struct fs_path) - offsetof(struct fs_path, inline_buf))
71
72
73/* reused for each extent */
74struct clone_root {
75 struct btrfs_root *root;
76 u64 ino;
77 u64 offset;
78
79 u64 found_refs;
80};
81
82#define SEND_CTX_MAX_NAME_CACHE_SIZE 128
83#define SEND_CTX_NAME_CACHE_CLEAN_SIZE (SEND_CTX_MAX_NAME_CACHE_SIZE * 2)
84
85struct send_ctx {
86 struct file *send_filp;
87 loff_t send_off;
88 char *send_buf;
89 u32 send_size;
90 u32 send_max_size;
91 u64 total_send_size;
92 u64 cmd_send_size[BTRFS_SEND_C_MAX + 1];
Mark Fashehcb95e7b2013-02-04 20:54:57 +000093 u64 flags; /* 'flags' member of btrfs_ioctl_send_args is u64 */
Alexander Block31db9f72012-07-25 23:19:24 +020094
Alexander Block31db9f72012-07-25 23:19:24 +020095 struct btrfs_root *send_root;
96 struct btrfs_root *parent_root;
97 struct clone_root *clone_roots;
98 int clone_roots_cnt;
99
100 /* current state of the compare_tree call */
101 struct btrfs_path *left_path;
102 struct btrfs_path *right_path;
103 struct btrfs_key *cmp_key;
104
105 /*
106 * infos of the currently processed inode. In case of deleted inodes,
107 * these are the values from the deleted inode.
108 */
109 u64 cur_ino;
110 u64 cur_inode_gen;
111 int cur_inode_new;
112 int cur_inode_new_gen;
113 int cur_inode_deleted;
Alexander Block31db9f72012-07-25 23:19:24 +0200114 u64 cur_inode_size;
115 u64 cur_inode_mode;
Liu Bo644d1942014-02-27 17:29:01 +0800116 u64 cur_inode_rdev;
Josef Bacik16e75492013-10-22 12:18:51 -0400117 u64 cur_inode_last_extent;
Alexander Block31db9f72012-07-25 23:19:24 +0200118
119 u64 send_progress;
120
121 struct list_head new_refs;
122 struct list_head deleted_refs;
123
124 struct radix_tree_root name_cache;
125 struct list_head name_cache_list;
126 int name_cache_size;
127
Liu Bo2131bcd32014-03-05 10:07:35 +0800128 struct file_ra_state ra;
129
Alexander Block31db9f72012-07-25 23:19:24 +0200130 char *read_buf;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +0000131
132 /*
133 * We process inodes by their increasing order, so if before an
134 * incremental send we reverse the parent/child relationship of
135 * directories such that a directory with a lower inode number was
136 * the parent of a directory with a higher inode number, and the one
137 * becoming the new parent got renamed too, we can't rename/move the
138 * directory with lower inode number when we finish processing it - we
139 * must process the directory with higher inode number first, then
140 * rename/move it and then rename/move the directory with lower inode
141 * number. Example follows.
142 *
143 * Tree state when the first send was performed:
144 *
145 * .
146 * |-- a (ino 257)
147 * |-- b (ino 258)
148 * |
149 * |
150 * |-- c (ino 259)
151 * | |-- d (ino 260)
152 * |
153 * |-- c2 (ino 261)
154 *
155 * Tree state when the second (incremental) send is performed:
156 *
157 * .
158 * |-- a (ino 257)
159 * |-- b (ino 258)
160 * |-- c2 (ino 261)
161 * |-- d2 (ino 260)
162 * |-- cc (ino 259)
163 *
164 * The sequence of steps that lead to the second state was:
165 *
166 * mv /a/b/c/d /a/b/c2/d2
167 * mv /a/b/c /a/b/c2/d2/cc
168 *
169 * "c" has lower inode number, but we can't move it (2nd mv operation)
170 * before we move "d", which has higher inode number.
171 *
172 * So we just memorize which move/rename operations must be performed
173 * later when their respective parent is processed and moved/renamed.
174 */
175
176 /* Indexed by parent directory inode number. */
177 struct rb_root pending_dir_moves;
178
179 /*
180 * Reverse index, indexed by the inode number of a directory that
181 * is waiting for the move/rename of its immediate parent before its
182 * own move/rename can be performed.
183 */
184 struct rb_root waiting_dir_moves;
Filipe Manana9dc44212014-02-19 14:31:44 +0000185
186 /*
187 * A directory that is going to be rm'ed might have a child directory
188 * which is in the pending directory moves index above. In this case,
189 * the directory can only be removed after the move/rename of its child
190 * is performed. Example:
191 *
192 * Parent snapshot:
193 *
194 * . (ino 256)
195 * |-- a/ (ino 257)
196 * |-- b/ (ino 258)
197 * |-- c/ (ino 259)
198 * | |-- x/ (ino 260)
199 * |
200 * |-- y/ (ino 261)
201 *
202 * Send snapshot:
203 *
204 * . (ino 256)
205 * |-- a/ (ino 257)
206 * |-- b/ (ino 258)
207 * |-- YY/ (ino 261)
208 * |-- x/ (ino 260)
209 *
210 * Sequence of steps that lead to the send snapshot:
211 * rm -f /a/b/c/foo.txt
212 * mv /a/b/y /a/b/YY
213 * mv /a/b/c/x /a/b/YY
214 * rmdir /a/b/c
215 *
216 * When the child is processed, its move/rename is delayed until its
217 * parent is processed (as explained above), but all other operations
218 * like update utimes, chown, chgrp, etc, are performed and the paths
219 * that it uses for those operations must use the orphanized name of
220 * its parent (the directory we're going to rm later), so we need to
221 * memorize that name.
222 *
223 * Indexed by the inode number of the directory to be deleted.
224 */
225 struct rb_root orphan_dirs;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +0000226};
227
228struct pending_dir_move {
229 struct rb_node node;
230 struct list_head list;
231 u64 parent_ino;
232 u64 ino;
233 u64 gen;
Filipe Manana84471e22015-02-28 22:29:22 +0000234 bool is_orphan;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +0000235 struct list_head update_refs;
236};
237
238struct waiting_dir_move {
239 struct rb_node node;
240 u64 ino;
Filipe Manana9dc44212014-02-19 14:31:44 +0000241 /*
242 * There might be some directory that could not be removed because it
243 * was waiting for this directory inode to be moved first. Therefore
244 * after this directory is moved, we can try to rmdir the ino rmdir_ino.
245 */
246 u64 rmdir_ino;
Filipe Manana8b191a62015-04-09 14:09:14 +0100247 bool orphanized;
Filipe Manana9dc44212014-02-19 14:31:44 +0000248};
249
250struct orphan_dir_info {
251 struct rb_node node;
252 u64 ino;
253 u64 gen;
Alexander Block31db9f72012-07-25 23:19:24 +0200254};
255
256struct name_cache_entry {
257 struct list_head list;
Alexander Block7e0926f2012-07-28 14:20:58 +0200258 /*
259 * radix_tree has only 32bit entries but we need to handle 64bit inums.
260 * We use the lower 32bit of the 64bit inum to store it in the tree. If
261 * more then one inum would fall into the same entry, we use radix_list
262 * to store the additional entries. radix_list is also used to store
263 * entries where two entries have the same inum but different
264 * generations.
265 */
266 struct list_head radix_list;
Alexander Block31db9f72012-07-25 23:19:24 +0200267 u64 ino;
268 u64 gen;
269 u64 parent_ino;
270 u64 parent_gen;
271 int ret;
272 int need_later_update;
273 int name_len;
274 char name[];
275};
276
Filipe David Borba Manana9f037402014-01-22 10:00:53 +0000277static int is_waiting_for_move(struct send_ctx *sctx, u64 ino);
278
Filipe Manana9dc44212014-02-19 14:31:44 +0000279static struct waiting_dir_move *
280get_waiting_dir_move(struct send_ctx *sctx, u64 ino);
281
282static int is_waiting_for_rm(struct send_ctx *sctx, u64 dir_ino);
283
Josef Bacik16e75492013-10-22 12:18:51 -0400284static int need_send_hole(struct send_ctx *sctx)
285{
286 return (sctx->parent_root && !sctx->cur_inode_new &&
287 !sctx->cur_inode_new_gen && !sctx->cur_inode_deleted &&
288 S_ISREG(sctx->cur_inode_mode));
289}
290
Alexander Block31db9f72012-07-25 23:19:24 +0200291static void fs_path_reset(struct fs_path *p)
292{
293 if (p->reversed) {
294 p->start = p->buf + p->buf_len - 1;
295 p->end = p->start;
296 *p->start = 0;
297 } else {
298 p->start = p->buf;
299 p->end = p->start;
300 *p->start = 0;
301 }
302}
303
Tsutomu Itoh924794c2013-05-08 07:51:52 +0000304static struct fs_path *fs_path_alloc(void)
Alexander Block31db9f72012-07-25 23:19:24 +0200305{
306 struct fs_path *p;
307
David Sterbae780b0d2016-01-18 18:42:13 +0100308 p = kmalloc(sizeof(*p), GFP_KERNEL);
Alexander Block31db9f72012-07-25 23:19:24 +0200309 if (!p)
310 return NULL;
311 p->reversed = 0;
Alexander Block31db9f72012-07-25 23:19:24 +0200312 p->buf = p->inline_buf;
313 p->buf_len = FS_PATH_INLINE_SIZE;
314 fs_path_reset(p);
315 return p;
316}
317
Tsutomu Itoh924794c2013-05-08 07:51:52 +0000318static struct fs_path *fs_path_alloc_reversed(void)
Alexander Block31db9f72012-07-25 23:19:24 +0200319{
320 struct fs_path *p;
321
Tsutomu Itoh924794c2013-05-08 07:51:52 +0000322 p = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +0200323 if (!p)
324 return NULL;
325 p->reversed = 1;
326 fs_path_reset(p);
327 return p;
328}
329
Tsutomu Itoh924794c2013-05-08 07:51:52 +0000330static void fs_path_free(struct fs_path *p)
Alexander Block31db9f72012-07-25 23:19:24 +0200331{
332 if (!p)
333 return;
David Sterbaace01052014-02-05 16:17:34 +0100334 if (p->buf != p->inline_buf)
335 kfree(p->buf);
Alexander Block31db9f72012-07-25 23:19:24 +0200336 kfree(p);
337}
338
339static int fs_path_len(struct fs_path *p)
340{
341 return p->end - p->start;
342}
343
344static int fs_path_ensure_buf(struct fs_path *p, int len)
345{
346 char *tmp_buf;
347 int path_len;
348 int old_buf_len;
349
350 len++;
351
352 if (p->buf_len >= len)
353 return 0;
354
Chris Masoncfd4a532014-04-26 05:02:03 -0700355 if (len > PATH_MAX) {
356 WARN_ON(1);
357 return -ENOMEM;
358 }
359
David Sterba1b2782c2014-02-25 19:32:59 +0100360 path_len = p->end - p->start;
361 old_buf_len = p->buf_len;
362
David Sterbaace01052014-02-05 16:17:34 +0100363 /*
364 * First time the inline_buf does not suffice
365 */
Filipe Manana01a9a8a2014-05-21 17:38:13 +0100366 if (p->buf == p->inline_buf) {
David Sterbae780b0d2016-01-18 18:42:13 +0100367 tmp_buf = kmalloc(len, GFP_KERNEL);
Filipe Manana01a9a8a2014-05-21 17:38:13 +0100368 if (tmp_buf)
369 memcpy(tmp_buf, p->buf, old_buf_len);
370 } else {
David Sterbae780b0d2016-01-18 18:42:13 +0100371 tmp_buf = krealloc(p->buf, len, GFP_KERNEL);
Filipe Manana01a9a8a2014-05-21 17:38:13 +0100372 }
David Sterba9c9ca002014-02-25 19:33:08 +0100373 if (!tmp_buf)
374 return -ENOMEM;
375 p->buf = tmp_buf;
376 /*
377 * The real size of the buffer is bigger, this will let the fast path
378 * happen most of the time
379 */
380 p->buf_len = ksize(p->buf);
David Sterbaace01052014-02-05 16:17:34 +0100381
Alexander Block31db9f72012-07-25 23:19:24 +0200382 if (p->reversed) {
383 tmp_buf = p->buf + old_buf_len - path_len - 1;
384 p->end = p->buf + p->buf_len - 1;
385 p->start = p->end - path_len;
386 memmove(p->start, tmp_buf, path_len + 1);
387 } else {
388 p->start = p->buf;
389 p->end = p->start + path_len;
390 }
391 return 0;
392}
393
David Sterbab23ab572014-02-03 19:23:19 +0100394static int fs_path_prepare_for_add(struct fs_path *p, int name_len,
395 char **prepared)
Alexander Block31db9f72012-07-25 23:19:24 +0200396{
397 int ret;
398 int new_len;
399
400 new_len = p->end - p->start + name_len;
401 if (p->start != p->end)
402 new_len++;
403 ret = fs_path_ensure_buf(p, new_len);
404 if (ret < 0)
405 goto out;
406
407 if (p->reversed) {
408 if (p->start != p->end)
409 *--p->start = '/';
410 p->start -= name_len;
David Sterbab23ab572014-02-03 19:23:19 +0100411 *prepared = p->start;
Alexander Block31db9f72012-07-25 23:19:24 +0200412 } else {
413 if (p->start != p->end)
414 *p->end++ = '/';
David Sterbab23ab572014-02-03 19:23:19 +0100415 *prepared = p->end;
Alexander Block31db9f72012-07-25 23:19:24 +0200416 p->end += name_len;
417 *p->end = 0;
418 }
419
420out:
421 return ret;
422}
423
424static int fs_path_add(struct fs_path *p, const char *name, int name_len)
425{
426 int ret;
David Sterbab23ab572014-02-03 19:23:19 +0100427 char *prepared;
Alexander Block31db9f72012-07-25 23:19:24 +0200428
David Sterbab23ab572014-02-03 19:23:19 +0100429 ret = fs_path_prepare_for_add(p, name_len, &prepared);
Alexander Block31db9f72012-07-25 23:19:24 +0200430 if (ret < 0)
431 goto out;
David Sterbab23ab572014-02-03 19:23:19 +0100432 memcpy(prepared, name, name_len);
Alexander Block31db9f72012-07-25 23:19:24 +0200433
434out:
435 return ret;
436}
437
438static int fs_path_add_path(struct fs_path *p, struct fs_path *p2)
439{
440 int ret;
David Sterbab23ab572014-02-03 19:23:19 +0100441 char *prepared;
Alexander Block31db9f72012-07-25 23:19:24 +0200442
David Sterbab23ab572014-02-03 19:23:19 +0100443 ret = fs_path_prepare_for_add(p, p2->end - p2->start, &prepared);
Alexander Block31db9f72012-07-25 23:19:24 +0200444 if (ret < 0)
445 goto out;
David Sterbab23ab572014-02-03 19:23:19 +0100446 memcpy(prepared, p2->start, p2->end - p2->start);
Alexander Block31db9f72012-07-25 23:19:24 +0200447
448out:
449 return ret;
450}
451
452static int fs_path_add_from_extent_buffer(struct fs_path *p,
453 struct extent_buffer *eb,
454 unsigned long off, int len)
455{
456 int ret;
David Sterbab23ab572014-02-03 19:23:19 +0100457 char *prepared;
Alexander Block31db9f72012-07-25 23:19:24 +0200458
David Sterbab23ab572014-02-03 19:23:19 +0100459 ret = fs_path_prepare_for_add(p, len, &prepared);
Alexander Block31db9f72012-07-25 23:19:24 +0200460 if (ret < 0)
461 goto out;
462
David Sterbab23ab572014-02-03 19:23:19 +0100463 read_extent_buffer(eb, prepared, off, len);
Alexander Block31db9f72012-07-25 23:19:24 +0200464
465out:
466 return ret;
467}
468
Alexander Block31db9f72012-07-25 23:19:24 +0200469static int fs_path_copy(struct fs_path *p, struct fs_path *from)
470{
471 int ret;
472
473 p->reversed = from->reversed;
474 fs_path_reset(p);
475
476 ret = fs_path_add_path(p, from);
477
478 return ret;
479}
480
481
482static void fs_path_unreverse(struct fs_path *p)
483{
484 char *tmp;
485 int len;
486
487 if (!p->reversed)
488 return;
489
490 tmp = p->start;
491 len = p->end - p->start;
492 p->start = p->buf;
493 p->end = p->start + len;
494 memmove(p->start, tmp, len + 1);
495 p->reversed = 0;
496}
497
498static struct btrfs_path *alloc_path_for_send(void)
499{
500 struct btrfs_path *path;
501
502 path = btrfs_alloc_path();
503 if (!path)
504 return NULL;
505 path->search_commit_root = 1;
506 path->skip_locking = 1;
Josef Bacik3f8a18c2014-03-28 17:16:01 -0400507 path->need_commit_sem = 1;
Alexander Block31db9f72012-07-25 23:19:24 +0200508 return path;
509}
510
Eric Sandeen48a3b632013-04-25 20:41:01 +0000511static int write_buf(struct file *filp, const void *buf, u32 len, loff_t *off)
Alexander Block31db9f72012-07-25 23:19:24 +0200512{
513 int ret;
514 mm_segment_t old_fs;
515 u32 pos = 0;
516
517 old_fs = get_fs();
518 set_fs(KERNEL_DS);
519
520 while (pos < len) {
Fabian Frederickd447d0d2014-07-15 21:17:17 +0200521 ret = vfs_write(filp, (__force const char __user *)buf + pos,
522 len - pos, off);
Alexander Block31db9f72012-07-25 23:19:24 +0200523 /* TODO handle that correctly */
524 /*if (ret == -ERESTARTSYS) {
525 continue;
526 }*/
527 if (ret < 0)
528 goto out;
529 if (ret == 0) {
530 ret = -EIO;
531 goto out;
532 }
533 pos += ret;
534 }
535
536 ret = 0;
537
538out:
539 set_fs(old_fs);
540 return ret;
541}
542
543static int tlv_put(struct send_ctx *sctx, u16 attr, const void *data, int len)
544{
545 struct btrfs_tlv_header *hdr;
546 int total_len = sizeof(*hdr) + len;
547 int left = sctx->send_max_size - sctx->send_size;
548
549 if (unlikely(left < total_len))
550 return -EOVERFLOW;
551
552 hdr = (struct btrfs_tlv_header *) (sctx->send_buf + sctx->send_size);
553 hdr->tlv_type = cpu_to_le16(attr);
554 hdr->tlv_len = cpu_to_le16(len);
555 memcpy(hdr + 1, data, len);
556 sctx->send_size += total_len;
557
558 return 0;
559}
560
David Sterba95bc79d2013-12-16 17:34:10 +0100561#define TLV_PUT_DEFINE_INT(bits) \
562 static int tlv_put_u##bits(struct send_ctx *sctx, \
563 u##bits attr, u##bits value) \
564 { \
565 __le##bits __tmp = cpu_to_le##bits(value); \
566 return tlv_put(sctx, attr, &__tmp, sizeof(__tmp)); \
567 }
Alexander Block31db9f72012-07-25 23:19:24 +0200568
David Sterba95bc79d2013-12-16 17:34:10 +0100569TLV_PUT_DEFINE_INT(64)
Alexander Block31db9f72012-07-25 23:19:24 +0200570
571static int tlv_put_string(struct send_ctx *sctx, u16 attr,
572 const char *str, int len)
573{
574 if (len == -1)
575 len = strlen(str);
576 return tlv_put(sctx, attr, str, len);
577}
578
579static int tlv_put_uuid(struct send_ctx *sctx, u16 attr,
580 const u8 *uuid)
581{
582 return tlv_put(sctx, attr, uuid, BTRFS_UUID_SIZE);
583}
584
Alexander Block31db9f72012-07-25 23:19:24 +0200585static int tlv_put_btrfs_timespec(struct send_ctx *sctx, u16 attr,
586 struct extent_buffer *eb,
587 struct btrfs_timespec *ts)
588{
589 struct btrfs_timespec bts;
590 read_extent_buffer(eb, &bts, (unsigned long)ts, sizeof(bts));
591 return tlv_put(sctx, attr, &bts, sizeof(bts));
592}
593
594
595#define TLV_PUT(sctx, attrtype, attrlen, data) \
596 do { \
597 ret = tlv_put(sctx, attrtype, attrlen, data); \
598 if (ret < 0) \
599 goto tlv_put_failure; \
600 } while (0)
601
602#define TLV_PUT_INT(sctx, attrtype, bits, value) \
603 do { \
604 ret = tlv_put_u##bits(sctx, attrtype, value); \
605 if (ret < 0) \
606 goto tlv_put_failure; \
607 } while (0)
608
609#define TLV_PUT_U8(sctx, attrtype, data) TLV_PUT_INT(sctx, attrtype, 8, data)
610#define TLV_PUT_U16(sctx, attrtype, data) TLV_PUT_INT(sctx, attrtype, 16, data)
611#define TLV_PUT_U32(sctx, attrtype, data) TLV_PUT_INT(sctx, attrtype, 32, data)
612#define TLV_PUT_U64(sctx, attrtype, data) TLV_PUT_INT(sctx, attrtype, 64, data)
613#define TLV_PUT_STRING(sctx, attrtype, str, len) \
614 do { \
615 ret = tlv_put_string(sctx, attrtype, str, len); \
616 if (ret < 0) \
617 goto tlv_put_failure; \
618 } while (0)
619#define TLV_PUT_PATH(sctx, attrtype, p) \
620 do { \
621 ret = tlv_put_string(sctx, attrtype, p->start, \
622 p->end - p->start); \
623 if (ret < 0) \
624 goto tlv_put_failure; \
625 } while(0)
626#define TLV_PUT_UUID(sctx, attrtype, uuid) \
627 do { \
628 ret = tlv_put_uuid(sctx, attrtype, uuid); \
629 if (ret < 0) \
630 goto tlv_put_failure; \
631 } while (0)
Alexander Block31db9f72012-07-25 23:19:24 +0200632#define TLV_PUT_BTRFS_TIMESPEC(sctx, attrtype, eb, ts) \
633 do { \
634 ret = tlv_put_btrfs_timespec(sctx, attrtype, eb, ts); \
635 if (ret < 0) \
636 goto tlv_put_failure; \
637 } while (0)
638
639static int send_header(struct send_ctx *sctx)
640{
641 struct btrfs_stream_header hdr;
642
643 strcpy(hdr.magic, BTRFS_SEND_STREAM_MAGIC);
644 hdr.version = cpu_to_le32(BTRFS_SEND_STREAM_VERSION);
645
Anand Jain1bcea352012-09-14 00:04:21 -0600646 return write_buf(sctx->send_filp, &hdr, sizeof(hdr),
647 &sctx->send_off);
Alexander Block31db9f72012-07-25 23:19:24 +0200648}
649
650/*
651 * For each command/item we want to send to userspace, we call this function.
652 */
653static int begin_cmd(struct send_ctx *sctx, int cmd)
654{
655 struct btrfs_cmd_header *hdr;
656
Dulshani Gunawardhanafae7f212013-10-31 10:30:08 +0530657 if (WARN_ON(!sctx->send_buf))
Alexander Block31db9f72012-07-25 23:19:24 +0200658 return -EINVAL;
Alexander Block31db9f72012-07-25 23:19:24 +0200659
660 BUG_ON(sctx->send_size);
661
662 sctx->send_size += sizeof(*hdr);
663 hdr = (struct btrfs_cmd_header *)sctx->send_buf;
664 hdr->cmd = cpu_to_le16(cmd);
665
666 return 0;
667}
668
669static int send_cmd(struct send_ctx *sctx)
670{
671 int ret;
672 struct btrfs_cmd_header *hdr;
673 u32 crc;
674
675 hdr = (struct btrfs_cmd_header *)sctx->send_buf;
676 hdr->len = cpu_to_le32(sctx->send_size - sizeof(*hdr));
677 hdr->crc = 0;
678
Filipe David Borba Manana0b947af2014-01-29 21:06:04 +0000679 crc = btrfs_crc32c(0, (unsigned char *)sctx->send_buf, sctx->send_size);
Alexander Block31db9f72012-07-25 23:19:24 +0200680 hdr->crc = cpu_to_le32(crc);
681
Anand Jain1bcea352012-09-14 00:04:21 -0600682 ret = write_buf(sctx->send_filp, sctx->send_buf, sctx->send_size,
683 &sctx->send_off);
Alexander Block31db9f72012-07-25 23:19:24 +0200684
685 sctx->total_send_size += sctx->send_size;
686 sctx->cmd_send_size[le16_to_cpu(hdr->cmd)] += sctx->send_size;
687 sctx->send_size = 0;
688
689 return ret;
690}
691
692/*
693 * Sends a move instruction to user space
694 */
695static int send_rename(struct send_ctx *sctx,
696 struct fs_path *from, struct fs_path *to)
697{
698 int ret;
699
700verbose_printk("btrfs: send_rename %s -> %s\n", from->start, to->start);
701
702 ret = begin_cmd(sctx, BTRFS_SEND_C_RENAME);
703 if (ret < 0)
704 goto out;
705
706 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, from);
707 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH_TO, to);
708
709 ret = send_cmd(sctx);
710
711tlv_put_failure:
712out:
713 return ret;
714}
715
716/*
717 * Sends a link instruction to user space
718 */
719static int send_link(struct send_ctx *sctx,
720 struct fs_path *path, struct fs_path *lnk)
721{
722 int ret;
723
724verbose_printk("btrfs: send_link %s -> %s\n", path->start, lnk->start);
725
726 ret = begin_cmd(sctx, BTRFS_SEND_C_LINK);
727 if (ret < 0)
728 goto out;
729
730 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, path);
731 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH_LINK, lnk);
732
733 ret = send_cmd(sctx);
734
735tlv_put_failure:
736out:
737 return ret;
738}
739
740/*
741 * Sends an unlink instruction to user space
742 */
743static int send_unlink(struct send_ctx *sctx, struct fs_path *path)
744{
745 int ret;
746
747verbose_printk("btrfs: send_unlink %s\n", path->start);
748
749 ret = begin_cmd(sctx, BTRFS_SEND_C_UNLINK);
750 if (ret < 0)
751 goto out;
752
753 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, path);
754
755 ret = send_cmd(sctx);
756
757tlv_put_failure:
758out:
759 return ret;
760}
761
762/*
763 * Sends a rmdir instruction to user space
764 */
765static int send_rmdir(struct send_ctx *sctx, struct fs_path *path)
766{
767 int ret;
768
769verbose_printk("btrfs: send_rmdir %s\n", path->start);
770
771 ret = begin_cmd(sctx, BTRFS_SEND_C_RMDIR);
772 if (ret < 0)
773 goto out;
774
775 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, path);
776
777 ret = send_cmd(sctx);
778
779tlv_put_failure:
780out:
781 return ret;
782}
783
784/*
785 * Helper function to retrieve some fields from an inode item.
786 */
Josef Bacik3f8a18c2014-03-28 17:16:01 -0400787static int __get_inode_info(struct btrfs_root *root, struct btrfs_path *path,
788 u64 ino, u64 *size, u64 *gen, u64 *mode, u64 *uid,
789 u64 *gid, u64 *rdev)
Alexander Block31db9f72012-07-25 23:19:24 +0200790{
791 int ret;
792 struct btrfs_inode_item *ii;
793 struct btrfs_key key;
Alexander Block31db9f72012-07-25 23:19:24 +0200794
795 key.objectid = ino;
796 key.type = BTRFS_INODE_ITEM_KEY;
797 key.offset = 0;
798 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
Alexander Block31db9f72012-07-25 23:19:24 +0200799 if (ret) {
Josef Bacik3f8a18c2014-03-28 17:16:01 -0400800 if (ret > 0)
801 ret = -ENOENT;
802 return ret;
Alexander Block31db9f72012-07-25 23:19:24 +0200803 }
804
805 ii = btrfs_item_ptr(path->nodes[0], path->slots[0],
806 struct btrfs_inode_item);
807 if (size)
808 *size = btrfs_inode_size(path->nodes[0], ii);
809 if (gen)
810 *gen = btrfs_inode_generation(path->nodes[0], ii);
811 if (mode)
812 *mode = btrfs_inode_mode(path->nodes[0], ii);
813 if (uid)
814 *uid = btrfs_inode_uid(path->nodes[0], ii);
815 if (gid)
816 *gid = btrfs_inode_gid(path->nodes[0], ii);
Alexander Block85a7b332012-07-26 23:39:10 +0200817 if (rdev)
818 *rdev = btrfs_inode_rdev(path->nodes[0], ii);
Alexander Block31db9f72012-07-25 23:19:24 +0200819
Josef Bacik3f8a18c2014-03-28 17:16:01 -0400820 return ret;
821}
822
823static int get_inode_info(struct btrfs_root *root,
824 u64 ino, u64 *size, u64 *gen,
825 u64 *mode, u64 *uid, u64 *gid,
826 u64 *rdev)
827{
828 struct btrfs_path *path;
829 int ret;
830
831 path = alloc_path_for_send();
832 if (!path)
833 return -ENOMEM;
834 ret = __get_inode_info(root, path, ino, size, gen, mode, uid, gid,
835 rdev);
Alexander Block31db9f72012-07-25 23:19:24 +0200836 btrfs_free_path(path);
837 return ret;
838}
839
840typedef int (*iterate_inode_ref_t)(int num, u64 dir, int index,
841 struct fs_path *p,
842 void *ctx);
843
844/*
Jan Schmidt96b5bd72012-10-15 08:30:45 +0000845 * Helper function to iterate the entries in ONE btrfs_inode_ref or
846 * btrfs_inode_extref.
Alexander Block31db9f72012-07-25 23:19:24 +0200847 * The iterate callback may return a non zero value to stop iteration. This can
848 * be a negative value for error codes or 1 to simply stop it.
849 *
Jan Schmidt96b5bd72012-10-15 08:30:45 +0000850 * path must point to the INODE_REF or INODE_EXTREF when called.
Alexander Block31db9f72012-07-25 23:19:24 +0200851 */
Tsutomu Itoh924794c2013-05-08 07:51:52 +0000852static int iterate_inode_ref(struct btrfs_root *root, struct btrfs_path *path,
Alexander Block31db9f72012-07-25 23:19:24 +0200853 struct btrfs_key *found_key, int resolve,
854 iterate_inode_ref_t iterate, void *ctx)
855{
Jan Schmidt96b5bd72012-10-15 08:30:45 +0000856 struct extent_buffer *eb = path->nodes[0];
Alexander Block31db9f72012-07-25 23:19:24 +0200857 struct btrfs_item *item;
858 struct btrfs_inode_ref *iref;
Jan Schmidt96b5bd72012-10-15 08:30:45 +0000859 struct btrfs_inode_extref *extref;
Alexander Block31db9f72012-07-25 23:19:24 +0200860 struct btrfs_path *tmp_path;
861 struct fs_path *p;
Jan Schmidt96b5bd72012-10-15 08:30:45 +0000862 u32 cur = 0;
Alexander Block31db9f72012-07-25 23:19:24 +0200863 u32 total;
Jan Schmidt96b5bd72012-10-15 08:30:45 +0000864 int slot = path->slots[0];
Alexander Block31db9f72012-07-25 23:19:24 +0200865 u32 name_len;
866 char *start;
867 int ret = 0;
Jan Schmidt96b5bd72012-10-15 08:30:45 +0000868 int num = 0;
Alexander Block31db9f72012-07-25 23:19:24 +0200869 int index;
Jan Schmidt96b5bd72012-10-15 08:30:45 +0000870 u64 dir;
871 unsigned long name_off;
872 unsigned long elem_size;
873 unsigned long ptr;
Alexander Block31db9f72012-07-25 23:19:24 +0200874
Tsutomu Itoh924794c2013-05-08 07:51:52 +0000875 p = fs_path_alloc_reversed();
Alexander Block31db9f72012-07-25 23:19:24 +0200876 if (!p)
877 return -ENOMEM;
878
879 tmp_path = alloc_path_for_send();
880 if (!tmp_path) {
Tsutomu Itoh924794c2013-05-08 07:51:52 +0000881 fs_path_free(p);
Alexander Block31db9f72012-07-25 23:19:24 +0200882 return -ENOMEM;
883 }
884
Alexander Block31db9f72012-07-25 23:19:24 +0200885
Jan Schmidt96b5bd72012-10-15 08:30:45 +0000886 if (found_key->type == BTRFS_INODE_REF_KEY) {
887 ptr = (unsigned long)btrfs_item_ptr(eb, slot,
888 struct btrfs_inode_ref);
Ross Kirkdd3cc162013-09-16 15:58:09 +0100889 item = btrfs_item_nr(slot);
Jan Schmidt96b5bd72012-10-15 08:30:45 +0000890 total = btrfs_item_size(eb, item);
891 elem_size = sizeof(*iref);
892 } else {
893 ptr = btrfs_item_ptr_offset(eb, slot);
894 total = btrfs_item_size_nr(eb, slot);
895 elem_size = sizeof(*extref);
896 }
897
Alexander Block31db9f72012-07-25 23:19:24 +0200898 while (cur < total) {
899 fs_path_reset(p);
900
Jan Schmidt96b5bd72012-10-15 08:30:45 +0000901 if (found_key->type == BTRFS_INODE_REF_KEY) {
902 iref = (struct btrfs_inode_ref *)(ptr + cur);
903 name_len = btrfs_inode_ref_name_len(eb, iref);
904 name_off = (unsigned long)(iref + 1);
905 index = btrfs_inode_ref_index(eb, iref);
906 dir = found_key->offset;
907 } else {
908 extref = (struct btrfs_inode_extref *)(ptr + cur);
909 name_len = btrfs_inode_extref_name_len(eb, extref);
910 name_off = (unsigned long)&extref->name;
911 index = btrfs_inode_extref_index(eb, extref);
912 dir = btrfs_inode_extref_parent(eb, extref);
913 }
914
Alexander Block31db9f72012-07-25 23:19:24 +0200915 if (resolve) {
Jan Schmidt96b5bd72012-10-15 08:30:45 +0000916 start = btrfs_ref_to_path(root, tmp_path, name_len,
917 name_off, eb, dir,
918 p->buf, p->buf_len);
Alexander Block31db9f72012-07-25 23:19:24 +0200919 if (IS_ERR(start)) {
920 ret = PTR_ERR(start);
921 goto out;
922 }
923 if (start < p->buf) {
924 /* overflow , try again with larger buffer */
925 ret = fs_path_ensure_buf(p,
926 p->buf_len + p->buf - start);
927 if (ret < 0)
928 goto out;
Jan Schmidt96b5bd72012-10-15 08:30:45 +0000929 start = btrfs_ref_to_path(root, tmp_path,
930 name_len, name_off,
931 eb, dir,
932 p->buf, p->buf_len);
Alexander Block31db9f72012-07-25 23:19:24 +0200933 if (IS_ERR(start)) {
934 ret = PTR_ERR(start);
935 goto out;
936 }
937 BUG_ON(start < p->buf);
938 }
939 p->start = start;
940 } else {
Jan Schmidt96b5bd72012-10-15 08:30:45 +0000941 ret = fs_path_add_from_extent_buffer(p, eb, name_off,
942 name_len);
Alexander Block31db9f72012-07-25 23:19:24 +0200943 if (ret < 0)
944 goto out;
945 }
946
Jan Schmidt96b5bd72012-10-15 08:30:45 +0000947 cur += elem_size + name_len;
948 ret = iterate(num, dir, index, p, ctx);
Alexander Block31db9f72012-07-25 23:19:24 +0200949 if (ret)
950 goto out;
Alexander Block31db9f72012-07-25 23:19:24 +0200951 num++;
952 }
953
954out:
955 btrfs_free_path(tmp_path);
Tsutomu Itoh924794c2013-05-08 07:51:52 +0000956 fs_path_free(p);
Alexander Block31db9f72012-07-25 23:19:24 +0200957 return ret;
958}
959
960typedef int (*iterate_dir_item_t)(int num, struct btrfs_key *di_key,
961 const char *name, int name_len,
962 const char *data, int data_len,
963 u8 type, void *ctx);
964
965/*
966 * Helper function to iterate the entries in ONE btrfs_dir_item.
967 * The iterate callback may return a non zero value to stop iteration. This can
968 * be a negative value for error codes or 1 to simply stop it.
969 *
970 * path must point to the dir item when called.
971 */
Tsutomu Itoh924794c2013-05-08 07:51:52 +0000972static int iterate_dir_item(struct btrfs_root *root, struct btrfs_path *path,
Alexander Block31db9f72012-07-25 23:19:24 +0200973 struct btrfs_key *found_key,
974 iterate_dir_item_t iterate, void *ctx)
975{
976 int ret = 0;
977 struct extent_buffer *eb;
978 struct btrfs_item *item;
979 struct btrfs_dir_item *di;
Alexander Block31db9f72012-07-25 23:19:24 +0200980 struct btrfs_key di_key;
981 char *buf = NULL;
Filipe Manana7e3ae332014-05-23 20:15:16 +0100982 int buf_len;
Alexander Block31db9f72012-07-25 23:19:24 +0200983 u32 name_len;
984 u32 data_len;
985 u32 cur;
986 u32 len;
987 u32 total;
988 int slot;
989 int num;
990 u8 type;
991
Filipe Manana4395e0c2014-08-20 10:45:45 +0100992 /*
993 * Start with a small buffer (1 page). If later we end up needing more
994 * space, which can happen for xattrs on a fs with a leaf size greater
995 * then the page size, attempt to increase the buffer. Typically xattr
996 * values are small.
997 */
998 buf_len = PATH_MAX;
David Sterbae780b0d2016-01-18 18:42:13 +0100999 buf = kmalloc(buf_len, GFP_KERNEL);
Alexander Block31db9f72012-07-25 23:19:24 +02001000 if (!buf) {
1001 ret = -ENOMEM;
1002 goto out;
1003 }
1004
Alexander Block31db9f72012-07-25 23:19:24 +02001005 eb = path->nodes[0];
1006 slot = path->slots[0];
Ross Kirkdd3cc162013-09-16 15:58:09 +01001007 item = btrfs_item_nr(slot);
Alexander Block31db9f72012-07-25 23:19:24 +02001008 di = btrfs_item_ptr(eb, slot, struct btrfs_dir_item);
1009 cur = 0;
1010 len = 0;
1011 total = btrfs_item_size(eb, item);
1012
1013 num = 0;
1014 while (cur < total) {
1015 name_len = btrfs_dir_name_len(eb, di);
1016 data_len = btrfs_dir_data_len(eb, di);
1017 type = btrfs_dir_type(eb, di);
1018 btrfs_dir_item_key_to_cpu(eb, di, &di_key);
1019
Filipe Manana7e3ae332014-05-23 20:15:16 +01001020 if (type == BTRFS_FT_XATTR) {
1021 if (name_len > XATTR_NAME_MAX) {
1022 ret = -ENAMETOOLONG;
1023 goto out;
1024 }
Filipe Manana4395e0c2014-08-20 10:45:45 +01001025 if (name_len + data_len > BTRFS_MAX_XATTR_SIZE(root)) {
Filipe Manana7e3ae332014-05-23 20:15:16 +01001026 ret = -E2BIG;
1027 goto out;
1028 }
1029 } else {
1030 /*
1031 * Path too long
1032 */
Filipe Manana4395e0c2014-08-20 10:45:45 +01001033 if (name_len + data_len > PATH_MAX) {
Filipe Manana7e3ae332014-05-23 20:15:16 +01001034 ret = -ENAMETOOLONG;
1035 goto out;
1036 }
Alexander Block31db9f72012-07-25 23:19:24 +02001037 }
1038
Filipe Manana4395e0c2014-08-20 10:45:45 +01001039 if (name_len + data_len > buf_len) {
1040 buf_len = name_len + data_len;
1041 if (is_vmalloc_addr(buf)) {
1042 vfree(buf);
1043 buf = NULL;
1044 } else {
1045 char *tmp = krealloc(buf, buf_len,
David Sterbae780b0d2016-01-18 18:42:13 +01001046 GFP_KERNEL | __GFP_NOWARN);
Filipe Manana4395e0c2014-08-20 10:45:45 +01001047
1048 if (!tmp)
1049 kfree(buf);
1050 buf = tmp;
1051 }
1052 if (!buf) {
1053 buf = vmalloc(buf_len);
1054 if (!buf) {
1055 ret = -ENOMEM;
1056 goto out;
1057 }
1058 }
1059 }
1060
Alexander Block31db9f72012-07-25 23:19:24 +02001061 read_extent_buffer(eb, buf, (unsigned long)(di + 1),
1062 name_len + data_len);
1063
1064 len = sizeof(*di) + name_len + data_len;
1065 di = (struct btrfs_dir_item *)((char *)di + len);
1066 cur += len;
1067
1068 ret = iterate(num, &di_key, buf, name_len, buf + name_len,
1069 data_len, type, ctx);
1070 if (ret < 0)
1071 goto out;
1072 if (ret) {
1073 ret = 0;
1074 goto out;
1075 }
1076
1077 num++;
1078 }
1079
1080out:
Filipe Manana4395e0c2014-08-20 10:45:45 +01001081 kvfree(buf);
Alexander Block31db9f72012-07-25 23:19:24 +02001082 return ret;
1083}
1084
1085static int __copy_first_ref(int num, u64 dir, int index,
1086 struct fs_path *p, void *ctx)
1087{
1088 int ret;
1089 struct fs_path *pt = ctx;
1090
1091 ret = fs_path_copy(pt, p);
1092 if (ret < 0)
1093 return ret;
1094
1095 /* we want the first only */
1096 return 1;
1097}
1098
1099/*
1100 * Retrieve the first path of an inode. If an inode has more then one
1101 * ref/hardlink, this is ignored.
1102 */
Tsutomu Itoh924794c2013-05-08 07:51:52 +00001103static int get_inode_path(struct btrfs_root *root,
Alexander Block31db9f72012-07-25 23:19:24 +02001104 u64 ino, struct fs_path *path)
1105{
1106 int ret;
1107 struct btrfs_key key, found_key;
1108 struct btrfs_path *p;
1109
1110 p = alloc_path_for_send();
1111 if (!p)
1112 return -ENOMEM;
1113
1114 fs_path_reset(path);
1115
1116 key.objectid = ino;
1117 key.type = BTRFS_INODE_REF_KEY;
1118 key.offset = 0;
1119
1120 ret = btrfs_search_slot_for_read(root, &key, p, 1, 0);
1121 if (ret < 0)
1122 goto out;
1123 if (ret) {
1124 ret = 1;
1125 goto out;
1126 }
1127 btrfs_item_key_to_cpu(p->nodes[0], &found_key, p->slots[0]);
1128 if (found_key.objectid != ino ||
Jan Schmidt96b5bd72012-10-15 08:30:45 +00001129 (found_key.type != BTRFS_INODE_REF_KEY &&
1130 found_key.type != BTRFS_INODE_EXTREF_KEY)) {
Alexander Block31db9f72012-07-25 23:19:24 +02001131 ret = -ENOENT;
1132 goto out;
1133 }
1134
Tsutomu Itoh924794c2013-05-08 07:51:52 +00001135 ret = iterate_inode_ref(root, p, &found_key, 1,
1136 __copy_first_ref, path);
Alexander Block31db9f72012-07-25 23:19:24 +02001137 if (ret < 0)
1138 goto out;
1139 ret = 0;
1140
1141out:
1142 btrfs_free_path(p);
1143 return ret;
1144}
1145
1146struct backref_ctx {
1147 struct send_ctx *sctx;
1148
Josef Bacik3f8a18c2014-03-28 17:16:01 -04001149 struct btrfs_path *path;
Alexander Block31db9f72012-07-25 23:19:24 +02001150 /* number of total found references */
1151 u64 found;
1152
1153 /*
1154 * used for clones found in send_root. clones found behind cur_objectid
1155 * and cur_offset are not considered as allowed clones.
1156 */
1157 u64 cur_objectid;
1158 u64 cur_offset;
1159
1160 /* may be truncated in case it's the last extent in a file */
1161 u64 extent_len;
1162
Filipe Manana619d8c42015-05-03 01:56:00 +01001163 /* data offset in the file extent item */
1164 u64 data_offset;
1165
Alexander Block31db9f72012-07-25 23:19:24 +02001166 /* Just to check for bugs in backref resolving */
Alexander Blockee849c02012-07-28 12:42:05 +02001167 int found_itself;
Alexander Block31db9f72012-07-25 23:19:24 +02001168};
1169
1170static int __clone_root_cmp_bsearch(const void *key, const void *elt)
1171{
Jan Schmidt995e01b2012-08-13 02:52:38 -06001172 u64 root = (u64)(uintptr_t)key;
Alexander Block31db9f72012-07-25 23:19:24 +02001173 struct clone_root *cr = (struct clone_root *)elt;
1174
1175 if (root < cr->root->objectid)
1176 return -1;
1177 if (root > cr->root->objectid)
1178 return 1;
1179 return 0;
1180}
1181
1182static int __clone_root_cmp_sort(const void *e1, const void *e2)
1183{
1184 struct clone_root *cr1 = (struct clone_root *)e1;
1185 struct clone_root *cr2 = (struct clone_root *)e2;
1186
1187 if (cr1->root->objectid < cr2->root->objectid)
1188 return -1;
1189 if (cr1->root->objectid > cr2->root->objectid)
1190 return 1;
1191 return 0;
1192}
1193
1194/*
1195 * Called for every backref that is found for the current extent.
Alexander Block766702e2012-07-28 14:11:31 +02001196 * Results are collected in sctx->clone_roots->ino/offset/found_refs
Alexander Block31db9f72012-07-25 23:19:24 +02001197 */
1198static int __iterate_backrefs(u64 ino, u64 offset, u64 root, void *ctx_)
1199{
1200 struct backref_ctx *bctx = ctx_;
1201 struct clone_root *found;
1202 int ret;
1203 u64 i_size;
1204
1205 /* First check if the root is in the list of accepted clone sources */
Jan Schmidt995e01b2012-08-13 02:52:38 -06001206 found = bsearch((void *)(uintptr_t)root, bctx->sctx->clone_roots,
Alexander Block31db9f72012-07-25 23:19:24 +02001207 bctx->sctx->clone_roots_cnt,
1208 sizeof(struct clone_root),
1209 __clone_root_cmp_bsearch);
1210 if (!found)
1211 return 0;
1212
1213 if (found->root == bctx->sctx->send_root &&
1214 ino == bctx->cur_objectid &&
1215 offset == bctx->cur_offset) {
Alexander Blockee849c02012-07-28 12:42:05 +02001216 bctx->found_itself = 1;
Alexander Block31db9f72012-07-25 23:19:24 +02001217 }
1218
1219 /*
Alexander Block766702e2012-07-28 14:11:31 +02001220 * There are inodes that have extents that lie behind its i_size. Don't
Alexander Block31db9f72012-07-25 23:19:24 +02001221 * accept clones from these extents.
1222 */
Josef Bacik3f8a18c2014-03-28 17:16:01 -04001223 ret = __get_inode_info(found->root, bctx->path, ino, &i_size, NULL, NULL,
1224 NULL, NULL, NULL);
1225 btrfs_release_path(bctx->path);
Alexander Block31db9f72012-07-25 23:19:24 +02001226 if (ret < 0)
1227 return ret;
1228
Filipe Manana619d8c42015-05-03 01:56:00 +01001229 if (offset + bctx->data_offset + bctx->extent_len > i_size)
Alexander Block31db9f72012-07-25 23:19:24 +02001230 return 0;
1231
1232 /*
1233 * Make sure we don't consider clones from send_root that are
1234 * behind the current inode/offset.
1235 */
1236 if (found->root == bctx->sctx->send_root) {
1237 /*
1238 * TODO for the moment we don't accept clones from the inode
1239 * that is currently send. We may change this when
1240 * BTRFS_IOC_CLONE_RANGE supports cloning from and to the same
1241 * file.
1242 */
1243 if (ino >= bctx->cur_objectid)
1244 return 0;
Alexander Blocke938c8a2012-07-28 16:33:49 +02001245#if 0
1246 if (ino > bctx->cur_objectid)
Alexander Block31db9f72012-07-25 23:19:24 +02001247 return 0;
Alexander Blocke938c8a2012-07-28 16:33:49 +02001248 if (offset + bctx->extent_len > bctx->cur_offset)
1249 return 0;
1250#endif
Alexander Block31db9f72012-07-25 23:19:24 +02001251 }
1252
1253 bctx->found++;
1254 found->found_refs++;
1255 if (ino < found->ino) {
1256 found->ino = ino;
1257 found->offset = offset;
1258 } else if (found->ino == ino) {
1259 /*
1260 * same extent found more then once in the same file.
1261 */
1262 if (found->offset > offset + bctx->extent_len)
1263 found->offset = offset;
1264 }
1265
1266 return 0;
1267}
1268
1269/*
Alexander Block766702e2012-07-28 14:11:31 +02001270 * Given an inode, offset and extent item, it finds a good clone for a clone
1271 * instruction. Returns -ENOENT when none could be found. The function makes
1272 * sure that the returned clone is usable at the point where sending is at the
1273 * moment. This means, that no clones are accepted which lie behind the current
1274 * inode+offset.
1275 *
Alexander Block31db9f72012-07-25 23:19:24 +02001276 * path must point to the extent item when called.
1277 */
1278static int find_extent_clone(struct send_ctx *sctx,
1279 struct btrfs_path *path,
1280 u64 ino, u64 data_offset,
1281 u64 ino_size,
1282 struct clone_root **found)
1283{
1284 int ret;
1285 int extent_type;
1286 u64 logical;
Chris Mason74dd17f2012-08-07 16:25:13 -04001287 u64 disk_byte;
Alexander Block31db9f72012-07-25 23:19:24 +02001288 u64 num_bytes;
1289 u64 extent_item_pos;
Liu Bo69917e42012-09-07 20:01:28 -06001290 u64 flags = 0;
Alexander Block31db9f72012-07-25 23:19:24 +02001291 struct btrfs_file_extent_item *fi;
1292 struct extent_buffer *eb = path->nodes[0];
Alexander Block35075bb2012-07-28 12:44:34 +02001293 struct backref_ctx *backref_ctx = NULL;
Alexander Block31db9f72012-07-25 23:19:24 +02001294 struct clone_root *cur_clone_root;
1295 struct btrfs_key found_key;
1296 struct btrfs_path *tmp_path;
Chris Mason74dd17f2012-08-07 16:25:13 -04001297 int compressed;
Alexander Block31db9f72012-07-25 23:19:24 +02001298 u32 i;
1299
1300 tmp_path = alloc_path_for_send();
1301 if (!tmp_path)
1302 return -ENOMEM;
1303
Josef Bacik3f8a18c2014-03-28 17:16:01 -04001304 /* We only use this path under the commit sem */
1305 tmp_path->need_commit_sem = 0;
1306
David Sterbae780b0d2016-01-18 18:42:13 +01001307 backref_ctx = kmalloc(sizeof(*backref_ctx), GFP_KERNEL);
Alexander Block35075bb2012-07-28 12:44:34 +02001308 if (!backref_ctx) {
1309 ret = -ENOMEM;
1310 goto out;
1311 }
1312
Josef Bacik3f8a18c2014-03-28 17:16:01 -04001313 backref_ctx->path = tmp_path;
1314
Alexander Block31db9f72012-07-25 23:19:24 +02001315 if (data_offset >= ino_size) {
1316 /*
1317 * There may be extents that lie behind the file's size.
1318 * I at least had this in combination with snapshotting while
1319 * writing large files.
1320 */
1321 ret = 0;
1322 goto out;
1323 }
1324
1325 fi = btrfs_item_ptr(eb, path->slots[0],
1326 struct btrfs_file_extent_item);
1327 extent_type = btrfs_file_extent_type(eb, fi);
1328 if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
1329 ret = -ENOENT;
1330 goto out;
1331 }
Chris Mason74dd17f2012-08-07 16:25:13 -04001332 compressed = btrfs_file_extent_compression(eb, fi);
Alexander Block31db9f72012-07-25 23:19:24 +02001333
1334 num_bytes = btrfs_file_extent_num_bytes(eb, fi);
Chris Mason74dd17f2012-08-07 16:25:13 -04001335 disk_byte = btrfs_file_extent_disk_bytenr(eb, fi);
1336 if (disk_byte == 0) {
Alexander Block31db9f72012-07-25 23:19:24 +02001337 ret = -ENOENT;
1338 goto out;
1339 }
Chris Mason74dd17f2012-08-07 16:25:13 -04001340 logical = disk_byte + btrfs_file_extent_offset(eb, fi);
Alexander Block31db9f72012-07-25 23:19:24 +02001341
Josef Bacik9e351cc2014-03-13 15:42:13 -04001342 down_read(&sctx->send_root->fs_info->commit_root_sem);
Liu Bo69917e42012-09-07 20:01:28 -06001343 ret = extent_from_logical(sctx->send_root->fs_info, disk_byte, tmp_path,
1344 &found_key, &flags);
Josef Bacik9e351cc2014-03-13 15:42:13 -04001345 up_read(&sctx->send_root->fs_info->commit_root_sem);
Alexander Block31db9f72012-07-25 23:19:24 +02001346 btrfs_release_path(tmp_path);
1347
1348 if (ret < 0)
1349 goto out;
Liu Bo69917e42012-09-07 20:01:28 -06001350 if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
Alexander Block31db9f72012-07-25 23:19:24 +02001351 ret = -EIO;
1352 goto out;
1353 }
1354
1355 /*
1356 * Setup the clone roots.
1357 */
1358 for (i = 0; i < sctx->clone_roots_cnt; i++) {
1359 cur_clone_root = sctx->clone_roots + i;
1360 cur_clone_root->ino = (u64)-1;
1361 cur_clone_root->offset = 0;
1362 cur_clone_root->found_refs = 0;
1363 }
1364
Alexander Block35075bb2012-07-28 12:44:34 +02001365 backref_ctx->sctx = sctx;
1366 backref_ctx->found = 0;
1367 backref_ctx->cur_objectid = ino;
1368 backref_ctx->cur_offset = data_offset;
1369 backref_ctx->found_itself = 0;
1370 backref_ctx->extent_len = num_bytes;
Filipe Manana619d8c42015-05-03 01:56:00 +01001371 /*
1372 * For non-compressed extents iterate_extent_inodes() gives us extent
1373 * offsets that already take into account the data offset, but not for
1374 * compressed extents, since the offset is logical and not relative to
1375 * the physical extent locations. We must take this into account to
1376 * avoid sending clone offsets that go beyond the source file's size,
1377 * which would result in the clone ioctl failing with -EINVAL on the
1378 * receiving end.
1379 */
1380 if (compressed == BTRFS_COMPRESS_NONE)
1381 backref_ctx->data_offset = 0;
1382 else
1383 backref_ctx->data_offset = btrfs_file_extent_offset(eb, fi);
Alexander Block31db9f72012-07-25 23:19:24 +02001384
1385 /*
1386 * The last extent of a file may be too large due to page alignment.
1387 * We need to adjust extent_len in this case so that the checks in
1388 * __iterate_backrefs work.
1389 */
1390 if (data_offset + num_bytes >= ino_size)
Alexander Block35075bb2012-07-28 12:44:34 +02001391 backref_ctx->extent_len = ino_size - data_offset;
Alexander Block31db9f72012-07-25 23:19:24 +02001392
1393 /*
1394 * Now collect all backrefs.
1395 */
Chris Mason74dd17f2012-08-07 16:25:13 -04001396 if (compressed == BTRFS_COMPRESS_NONE)
1397 extent_item_pos = logical - found_key.objectid;
1398 else
1399 extent_item_pos = 0;
Alexander Block31db9f72012-07-25 23:19:24 +02001400 ret = iterate_extent_inodes(sctx->send_root->fs_info,
1401 found_key.objectid, extent_item_pos, 1,
Alexander Block35075bb2012-07-28 12:44:34 +02001402 __iterate_backrefs, backref_ctx);
Chris Mason74dd17f2012-08-07 16:25:13 -04001403
Alexander Block31db9f72012-07-25 23:19:24 +02001404 if (ret < 0)
1405 goto out;
1406
Alexander Block35075bb2012-07-28 12:44:34 +02001407 if (!backref_ctx->found_itself) {
Alexander Block31db9f72012-07-25 23:19:24 +02001408 /* found a bug in backref code? */
1409 ret = -EIO;
Frank Holtonefe120a2013-12-20 11:37:06 -05001410 btrfs_err(sctx->send_root->fs_info, "did not find backref in "
Alexander Block31db9f72012-07-25 23:19:24 +02001411 "send_root. inode=%llu, offset=%llu, "
David Sterba351fd352014-05-15 16:48:20 +02001412 "disk_byte=%llu found extent=%llu",
Chris Mason74dd17f2012-08-07 16:25:13 -04001413 ino, data_offset, disk_byte, found_key.objectid);
Alexander Block31db9f72012-07-25 23:19:24 +02001414 goto out;
1415 }
1416
1417verbose_printk(KERN_DEBUG "btrfs: find_extent_clone: data_offset=%llu, "
1418 "ino=%llu, "
1419 "num_bytes=%llu, logical=%llu\n",
1420 data_offset, ino, num_bytes, logical);
1421
Alexander Block35075bb2012-07-28 12:44:34 +02001422 if (!backref_ctx->found)
Alexander Block31db9f72012-07-25 23:19:24 +02001423 verbose_printk("btrfs: no clones found\n");
1424
1425 cur_clone_root = NULL;
1426 for (i = 0; i < sctx->clone_roots_cnt; i++) {
1427 if (sctx->clone_roots[i].found_refs) {
1428 if (!cur_clone_root)
1429 cur_clone_root = sctx->clone_roots + i;
1430 else if (sctx->clone_roots[i].root == sctx->send_root)
1431 /* prefer clones from send_root over others */
1432 cur_clone_root = sctx->clone_roots + i;
Alexander Block31db9f72012-07-25 23:19:24 +02001433 }
1434
1435 }
1436
1437 if (cur_clone_root) {
1438 *found = cur_clone_root;
1439 ret = 0;
1440 } else {
1441 ret = -ENOENT;
1442 }
1443
1444out:
1445 btrfs_free_path(tmp_path);
Alexander Block35075bb2012-07-28 12:44:34 +02001446 kfree(backref_ctx);
Alexander Block31db9f72012-07-25 23:19:24 +02001447 return ret;
1448}
1449
Tsutomu Itoh924794c2013-05-08 07:51:52 +00001450static int read_symlink(struct btrfs_root *root,
Alexander Block31db9f72012-07-25 23:19:24 +02001451 u64 ino,
1452 struct fs_path *dest)
1453{
1454 int ret;
1455 struct btrfs_path *path;
1456 struct btrfs_key key;
1457 struct btrfs_file_extent_item *ei;
1458 u8 type;
1459 u8 compression;
1460 unsigned long off;
1461 int len;
1462
1463 path = alloc_path_for_send();
1464 if (!path)
1465 return -ENOMEM;
1466
1467 key.objectid = ino;
1468 key.type = BTRFS_EXTENT_DATA_KEY;
1469 key.offset = 0;
1470 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1471 if (ret < 0)
1472 goto out;
Filipe Mananaa8797192015-12-31 18:07:59 +00001473 if (ret) {
1474 /*
1475 * An empty symlink inode. Can happen in rare error paths when
1476 * creating a symlink (transaction committed before the inode
1477 * eviction handler removed the symlink inode items and a crash
1478 * happened in between or the subvol was snapshoted in between).
1479 * Print an informative message to dmesg/syslog so that the user
1480 * can delete the symlink.
1481 */
1482 btrfs_err(root->fs_info,
1483 "Found empty symlink inode %llu at root %llu",
1484 ino, root->root_key.objectid);
1485 ret = -EIO;
1486 goto out;
1487 }
Alexander Block31db9f72012-07-25 23:19:24 +02001488
1489 ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
1490 struct btrfs_file_extent_item);
1491 type = btrfs_file_extent_type(path->nodes[0], ei);
1492 compression = btrfs_file_extent_compression(path->nodes[0], ei);
1493 BUG_ON(type != BTRFS_FILE_EXTENT_INLINE);
1494 BUG_ON(compression);
1495
1496 off = btrfs_file_extent_inline_start(ei);
Chris Mason514ac8a2014-01-03 21:07:00 -08001497 len = btrfs_file_extent_inline_len(path->nodes[0], path->slots[0], ei);
Alexander Block31db9f72012-07-25 23:19:24 +02001498
1499 ret = fs_path_add_from_extent_buffer(dest, path->nodes[0], off, len);
Alexander Block31db9f72012-07-25 23:19:24 +02001500
1501out:
1502 btrfs_free_path(path);
1503 return ret;
1504}
1505
1506/*
1507 * Helper function to generate a file name that is unique in the root of
1508 * send_root and parent_root. This is used to generate names for orphan inodes.
1509 */
1510static int gen_unique_name(struct send_ctx *sctx,
1511 u64 ino, u64 gen,
1512 struct fs_path *dest)
1513{
1514 int ret = 0;
1515 struct btrfs_path *path;
1516 struct btrfs_dir_item *di;
1517 char tmp[64];
1518 int len;
1519 u64 idx = 0;
1520
1521 path = alloc_path_for_send();
1522 if (!path)
1523 return -ENOMEM;
1524
1525 while (1) {
Filipe David Borba Mananaf74b86d2014-01-21 23:36:38 +00001526 len = snprintf(tmp, sizeof(tmp), "o%llu-%llu-%llu",
Alexander Block31db9f72012-07-25 23:19:24 +02001527 ino, gen, idx);
David Sterba64792f22014-02-03 18:24:09 +01001528 ASSERT(len < sizeof(tmp));
Alexander Block31db9f72012-07-25 23:19:24 +02001529
1530 di = btrfs_lookup_dir_item(NULL, sctx->send_root,
1531 path, BTRFS_FIRST_FREE_OBJECTID,
1532 tmp, strlen(tmp), 0);
1533 btrfs_release_path(path);
1534 if (IS_ERR(di)) {
1535 ret = PTR_ERR(di);
1536 goto out;
1537 }
1538 if (di) {
1539 /* not unique, try again */
1540 idx++;
1541 continue;
1542 }
1543
1544 if (!sctx->parent_root) {
1545 /* unique */
1546 ret = 0;
1547 break;
1548 }
1549
1550 di = btrfs_lookup_dir_item(NULL, sctx->parent_root,
1551 path, BTRFS_FIRST_FREE_OBJECTID,
1552 tmp, strlen(tmp), 0);
1553 btrfs_release_path(path);
1554 if (IS_ERR(di)) {
1555 ret = PTR_ERR(di);
1556 goto out;
1557 }
1558 if (di) {
1559 /* not unique, try again */
1560 idx++;
1561 continue;
1562 }
1563 /* unique */
1564 break;
1565 }
1566
1567 ret = fs_path_add(dest, tmp, strlen(tmp));
1568
1569out:
1570 btrfs_free_path(path);
1571 return ret;
1572}
1573
1574enum inode_state {
1575 inode_state_no_change,
1576 inode_state_will_create,
1577 inode_state_did_create,
1578 inode_state_will_delete,
1579 inode_state_did_delete,
1580};
1581
1582static int get_cur_inode_state(struct send_ctx *sctx, u64 ino, u64 gen)
1583{
1584 int ret;
1585 int left_ret;
1586 int right_ret;
1587 u64 left_gen;
1588 u64 right_gen;
1589
1590 ret = get_inode_info(sctx->send_root, ino, NULL, &left_gen, NULL, NULL,
Alexander Block85a7b332012-07-26 23:39:10 +02001591 NULL, NULL);
Alexander Block31db9f72012-07-25 23:19:24 +02001592 if (ret < 0 && ret != -ENOENT)
1593 goto out;
1594 left_ret = ret;
1595
1596 if (!sctx->parent_root) {
1597 right_ret = -ENOENT;
1598 } else {
1599 ret = get_inode_info(sctx->parent_root, ino, NULL, &right_gen,
Alexander Block85a7b332012-07-26 23:39:10 +02001600 NULL, NULL, NULL, NULL);
Alexander Block31db9f72012-07-25 23:19:24 +02001601 if (ret < 0 && ret != -ENOENT)
1602 goto out;
1603 right_ret = ret;
1604 }
1605
1606 if (!left_ret && !right_ret) {
Alexander Blocke938c8a2012-07-28 16:33:49 +02001607 if (left_gen == gen && right_gen == gen) {
Alexander Block31db9f72012-07-25 23:19:24 +02001608 ret = inode_state_no_change;
Alexander Blocke938c8a2012-07-28 16:33:49 +02001609 } else if (left_gen == gen) {
Alexander Block31db9f72012-07-25 23:19:24 +02001610 if (ino < sctx->send_progress)
1611 ret = inode_state_did_create;
1612 else
1613 ret = inode_state_will_create;
1614 } else if (right_gen == gen) {
1615 if (ino < sctx->send_progress)
1616 ret = inode_state_did_delete;
1617 else
1618 ret = inode_state_will_delete;
1619 } else {
1620 ret = -ENOENT;
1621 }
1622 } else if (!left_ret) {
1623 if (left_gen == gen) {
1624 if (ino < sctx->send_progress)
1625 ret = inode_state_did_create;
1626 else
1627 ret = inode_state_will_create;
1628 } else {
1629 ret = -ENOENT;
1630 }
1631 } else if (!right_ret) {
1632 if (right_gen == gen) {
1633 if (ino < sctx->send_progress)
1634 ret = inode_state_did_delete;
1635 else
1636 ret = inode_state_will_delete;
1637 } else {
1638 ret = -ENOENT;
1639 }
1640 } else {
1641 ret = -ENOENT;
1642 }
1643
1644out:
1645 return ret;
1646}
1647
1648static int is_inode_existent(struct send_ctx *sctx, u64 ino, u64 gen)
1649{
1650 int ret;
1651
1652 ret = get_cur_inode_state(sctx, ino, gen);
1653 if (ret < 0)
1654 goto out;
1655
1656 if (ret == inode_state_no_change ||
1657 ret == inode_state_did_create ||
1658 ret == inode_state_will_delete)
1659 ret = 1;
1660 else
1661 ret = 0;
1662
1663out:
1664 return ret;
1665}
1666
1667/*
1668 * Helper function to lookup a dir item in a dir.
1669 */
1670static int lookup_dir_item_inode(struct btrfs_root *root,
1671 u64 dir, const char *name, int name_len,
1672 u64 *found_inode,
1673 u8 *found_type)
1674{
1675 int ret = 0;
1676 struct btrfs_dir_item *di;
1677 struct btrfs_key key;
1678 struct btrfs_path *path;
1679
1680 path = alloc_path_for_send();
1681 if (!path)
1682 return -ENOMEM;
1683
1684 di = btrfs_lookup_dir_item(NULL, root, path,
1685 dir, name, name_len, 0);
1686 if (!di) {
1687 ret = -ENOENT;
1688 goto out;
1689 }
1690 if (IS_ERR(di)) {
1691 ret = PTR_ERR(di);
1692 goto out;
1693 }
1694 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &key);
Filipe Manana1af56072014-05-25 04:49:24 +01001695 if (key.type == BTRFS_ROOT_ITEM_KEY) {
1696 ret = -ENOENT;
1697 goto out;
1698 }
Alexander Block31db9f72012-07-25 23:19:24 +02001699 *found_inode = key.objectid;
1700 *found_type = btrfs_dir_type(path->nodes[0], di);
1701
1702out:
1703 btrfs_free_path(path);
1704 return ret;
1705}
1706
Alexander Block766702e2012-07-28 14:11:31 +02001707/*
1708 * Looks up the first btrfs_inode_ref of a given ino. It returns the parent dir,
1709 * generation of the parent dir and the name of the dir entry.
1710 */
Tsutomu Itoh924794c2013-05-08 07:51:52 +00001711static int get_first_ref(struct btrfs_root *root, u64 ino,
Alexander Block31db9f72012-07-25 23:19:24 +02001712 u64 *dir, u64 *dir_gen, struct fs_path *name)
1713{
1714 int ret;
1715 struct btrfs_key key;
1716 struct btrfs_key found_key;
1717 struct btrfs_path *path;
Alexander Block31db9f72012-07-25 23:19:24 +02001718 int len;
Jan Schmidt96b5bd72012-10-15 08:30:45 +00001719 u64 parent_dir;
Alexander Block31db9f72012-07-25 23:19:24 +02001720
1721 path = alloc_path_for_send();
1722 if (!path)
1723 return -ENOMEM;
1724
1725 key.objectid = ino;
1726 key.type = BTRFS_INODE_REF_KEY;
1727 key.offset = 0;
1728
1729 ret = btrfs_search_slot_for_read(root, &key, path, 1, 0);
1730 if (ret < 0)
1731 goto out;
1732 if (!ret)
1733 btrfs_item_key_to_cpu(path->nodes[0], &found_key,
1734 path->slots[0]);
Jan Schmidt96b5bd72012-10-15 08:30:45 +00001735 if (ret || found_key.objectid != ino ||
1736 (found_key.type != BTRFS_INODE_REF_KEY &&
1737 found_key.type != BTRFS_INODE_EXTREF_KEY)) {
Alexander Block31db9f72012-07-25 23:19:24 +02001738 ret = -ENOENT;
1739 goto out;
1740 }
1741
Filipe Manana51a60252014-05-13 22:01:02 +01001742 if (found_key.type == BTRFS_INODE_REF_KEY) {
Jan Schmidt96b5bd72012-10-15 08:30:45 +00001743 struct btrfs_inode_ref *iref;
1744 iref = btrfs_item_ptr(path->nodes[0], path->slots[0],
1745 struct btrfs_inode_ref);
1746 len = btrfs_inode_ref_name_len(path->nodes[0], iref);
1747 ret = fs_path_add_from_extent_buffer(name, path->nodes[0],
1748 (unsigned long)(iref + 1),
1749 len);
1750 parent_dir = found_key.offset;
1751 } else {
1752 struct btrfs_inode_extref *extref;
1753 extref = btrfs_item_ptr(path->nodes[0], path->slots[0],
1754 struct btrfs_inode_extref);
1755 len = btrfs_inode_extref_name_len(path->nodes[0], extref);
1756 ret = fs_path_add_from_extent_buffer(name, path->nodes[0],
1757 (unsigned long)&extref->name, len);
1758 parent_dir = btrfs_inode_extref_parent(path->nodes[0], extref);
1759 }
Alexander Block31db9f72012-07-25 23:19:24 +02001760 if (ret < 0)
1761 goto out;
1762 btrfs_release_path(path);
1763
Filipe Mananab46ab972014-03-21 12:46:54 +00001764 if (dir_gen) {
1765 ret = get_inode_info(root, parent_dir, NULL, dir_gen, NULL,
1766 NULL, NULL, NULL);
1767 if (ret < 0)
1768 goto out;
1769 }
Alexander Block31db9f72012-07-25 23:19:24 +02001770
Jan Schmidt96b5bd72012-10-15 08:30:45 +00001771 *dir = parent_dir;
Alexander Block31db9f72012-07-25 23:19:24 +02001772
1773out:
1774 btrfs_free_path(path);
1775 return ret;
1776}
1777
Tsutomu Itoh924794c2013-05-08 07:51:52 +00001778static int is_first_ref(struct btrfs_root *root,
Alexander Block31db9f72012-07-25 23:19:24 +02001779 u64 ino, u64 dir,
1780 const char *name, int name_len)
1781{
1782 int ret;
1783 struct fs_path *tmp_name;
1784 u64 tmp_dir;
Alexander Block31db9f72012-07-25 23:19:24 +02001785
Tsutomu Itoh924794c2013-05-08 07:51:52 +00001786 tmp_name = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +02001787 if (!tmp_name)
1788 return -ENOMEM;
1789
Filipe Mananab46ab972014-03-21 12:46:54 +00001790 ret = get_first_ref(root, ino, &tmp_dir, NULL, tmp_name);
Alexander Block31db9f72012-07-25 23:19:24 +02001791 if (ret < 0)
1792 goto out;
1793
Alexander Blockb9291af2012-07-28 11:07:18 +02001794 if (dir != tmp_dir || name_len != fs_path_len(tmp_name)) {
Alexander Block31db9f72012-07-25 23:19:24 +02001795 ret = 0;
1796 goto out;
1797 }
1798
Alexander Blocke938c8a2012-07-28 16:33:49 +02001799 ret = !memcmp(tmp_name->start, name, name_len);
Alexander Block31db9f72012-07-25 23:19:24 +02001800
1801out:
Tsutomu Itoh924794c2013-05-08 07:51:52 +00001802 fs_path_free(tmp_name);
Alexander Block31db9f72012-07-25 23:19:24 +02001803 return ret;
1804}
1805
Alexander Block766702e2012-07-28 14:11:31 +02001806/*
1807 * Used by process_recorded_refs to determine if a new ref would overwrite an
1808 * already existing ref. In case it detects an overwrite, it returns the
1809 * inode/gen in who_ino/who_gen.
1810 * When an overwrite is detected, process_recorded_refs does proper orphanizing
1811 * to make sure later references to the overwritten inode are possible.
1812 * Orphanizing is however only required for the first ref of an inode.
1813 * process_recorded_refs does an additional is_first_ref check to see if
1814 * orphanizing is really required.
1815 */
Alexander Block31db9f72012-07-25 23:19:24 +02001816static int will_overwrite_ref(struct send_ctx *sctx, u64 dir, u64 dir_gen,
1817 const char *name, int name_len,
1818 u64 *who_ino, u64 *who_gen)
1819{
1820 int ret = 0;
Josef Bacikebdad912013-08-06 16:47:48 -04001821 u64 gen;
Alexander Block31db9f72012-07-25 23:19:24 +02001822 u64 other_inode = 0;
1823 u8 other_type = 0;
1824
1825 if (!sctx->parent_root)
1826 goto out;
1827
1828 ret = is_inode_existent(sctx, dir, dir_gen);
1829 if (ret <= 0)
1830 goto out;
1831
Josef Bacikebdad912013-08-06 16:47:48 -04001832 /*
1833 * If we have a parent root we need to verify that the parent dir was
1834 * not delted and then re-created, if it was then we have no overwrite
1835 * and we can just unlink this entry.
1836 */
1837 if (sctx->parent_root) {
1838 ret = get_inode_info(sctx->parent_root, dir, NULL, &gen, NULL,
1839 NULL, NULL, NULL);
1840 if (ret < 0 && ret != -ENOENT)
1841 goto out;
1842 if (ret) {
1843 ret = 0;
1844 goto out;
1845 }
1846 if (gen != dir_gen)
1847 goto out;
1848 }
1849
Alexander Block31db9f72012-07-25 23:19:24 +02001850 ret = lookup_dir_item_inode(sctx->parent_root, dir, name, name_len,
1851 &other_inode, &other_type);
1852 if (ret < 0 && ret != -ENOENT)
1853 goto out;
1854 if (ret) {
1855 ret = 0;
1856 goto out;
1857 }
1858
Alexander Block766702e2012-07-28 14:11:31 +02001859 /*
1860 * Check if the overwritten ref was already processed. If yes, the ref
1861 * was already unlinked/moved, so we can safely assume that we will not
1862 * overwrite anything at this point in time.
1863 */
Alexander Block31db9f72012-07-25 23:19:24 +02001864 if (other_inode > sctx->send_progress) {
1865 ret = get_inode_info(sctx->parent_root, other_inode, NULL,
Alexander Block85a7b332012-07-26 23:39:10 +02001866 who_gen, NULL, NULL, NULL, NULL);
Alexander Block31db9f72012-07-25 23:19:24 +02001867 if (ret < 0)
1868 goto out;
1869
1870 ret = 1;
1871 *who_ino = other_inode;
1872 } else {
1873 ret = 0;
1874 }
1875
1876out:
1877 return ret;
1878}
1879
Alexander Block766702e2012-07-28 14:11:31 +02001880/*
1881 * Checks if the ref was overwritten by an already processed inode. This is
1882 * used by __get_cur_name_and_parent to find out if the ref was orphanized and
1883 * thus the orphan name needs be used.
1884 * process_recorded_refs also uses it to avoid unlinking of refs that were
1885 * overwritten.
1886 */
Alexander Block31db9f72012-07-25 23:19:24 +02001887static int did_overwrite_ref(struct send_ctx *sctx,
1888 u64 dir, u64 dir_gen,
1889 u64 ino, u64 ino_gen,
1890 const char *name, int name_len)
1891{
1892 int ret = 0;
1893 u64 gen;
1894 u64 ow_inode;
1895 u8 other_type;
1896
1897 if (!sctx->parent_root)
1898 goto out;
1899
1900 ret = is_inode_existent(sctx, dir, dir_gen);
1901 if (ret <= 0)
1902 goto out;
1903
1904 /* check if the ref was overwritten by another ref */
1905 ret = lookup_dir_item_inode(sctx->send_root, dir, name, name_len,
1906 &ow_inode, &other_type);
1907 if (ret < 0 && ret != -ENOENT)
1908 goto out;
1909 if (ret) {
1910 /* was never and will never be overwritten */
1911 ret = 0;
1912 goto out;
1913 }
1914
1915 ret = get_inode_info(sctx->send_root, ow_inode, NULL, &gen, NULL, NULL,
Alexander Block85a7b332012-07-26 23:39:10 +02001916 NULL, NULL);
Alexander Block31db9f72012-07-25 23:19:24 +02001917 if (ret < 0)
1918 goto out;
1919
1920 if (ow_inode == ino && gen == ino_gen) {
1921 ret = 0;
1922 goto out;
1923 }
1924
Filipe Manana8b191a62015-04-09 14:09:14 +01001925 /*
1926 * We know that it is or will be overwritten. Check this now.
1927 * The current inode being processed might have been the one that caused
Filipe Mananab786f162015-09-26 15:30:23 +01001928 * inode 'ino' to be orphanized, therefore check if ow_inode matches
1929 * the current inode being processed.
Filipe Manana8b191a62015-04-09 14:09:14 +01001930 */
Filipe Mananab786f162015-09-26 15:30:23 +01001931 if ((ow_inode < sctx->send_progress) ||
1932 (ino != sctx->cur_ino && ow_inode == sctx->cur_ino &&
1933 gen == sctx->cur_inode_gen))
Alexander Block31db9f72012-07-25 23:19:24 +02001934 ret = 1;
1935 else
1936 ret = 0;
1937
1938out:
1939 return ret;
1940}
1941
Alexander Block766702e2012-07-28 14:11:31 +02001942/*
1943 * Same as did_overwrite_ref, but also checks if it is the first ref of an inode
1944 * that got overwritten. This is used by process_recorded_refs to determine
1945 * if it has to use the path as returned by get_cur_path or the orphan name.
1946 */
Alexander Block31db9f72012-07-25 23:19:24 +02001947static int did_overwrite_first_ref(struct send_ctx *sctx, u64 ino, u64 gen)
1948{
1949 int ret = 0;
1950 struct fs_path *name = NULL;
1951 u64 dir;
1952 u64 dir_gen;
1953
1954 if (!sctx->parent_root)
1955 goto out;
1956
Tsutomu Itoh924794c2013-05-08 07:51:52 +00001957 name = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +02001958 if (!name)
1959 return -ENOMEM;
1960
Tsutomu Itoh924794c2013-05-08 07:51:52 +00001961 ret = get_first_ref(sctx->parent_root, ino, &dir, &dir_gen, name);
Alexander Block31db9f72012-07-25 23:19:24 +02001962 if (ret < 0)
1963 goto out;
1964
1965 ret = did_overwrite_ref(sctx, dir, dir_gen, ino, gen,
1966 name->start, fs_path_len(name));
Alexander Block31db9f72012-07-25 23:19:24 +02001967
1968out:
Tsutomu Itoh924794c2013-05-08 07:51:52 +00001969 fs_path_free(name);
Alexander Block31db9f72012-07-25 23:19:24 +02001970 return ret;
1971}
1972
Alexander Block766702e2012-07-28 14:11:31 +02001973/*
1974 * Insert a name cache entry. On 32bit kernels the radix tree index is 32bit,
1975 * so we need to do some special handling in case we have clashes. This function
1976 * takes care of this with the help of name_cache_entry::radix_list.
Alexander Block5dc67d02012-08-01 12:07:43 +02001977 * In case of error, nce is kfreed.
Alexander Block766702e2012-07-28 14:11:31 +02001978 */
Alexander Block31db9f72012-07-25 23:19:24 +02001979static int name_cache_insert(struct send_ctx *sctx,
1980 struct name_cache_entry *nce)
1981{
1982 int ret = 0;
Alexander Block7e0926f2012-07-28 14:20:58 +02001983 struct list_head *nce_head;
Alexander Block31db9f72012-07-25 23:19:24 +02001984
Alexander Block7e0926f2012-07-28 14:20:58 +02001985 nce_head = radix_tree_lookup(&sctx->name_cache,
1986 (unsigned long)nce->ino);
1987 if (!nce_head) {
David Sterbae780b0d2016-01-18 18:42:13 +01001988 nce_head = kmalloc(sizeof(*nce_head), GFP_KERNEL);
Tsutomu Itohcfa7a9c2012-12-17 06:38:51 +00001989 if (!nce_head) {
1990 kfree(nce);
Alexander Block31db9f72012-07-25 23:19:24 +02001991 return -ENOMEM;
Tsutomu Itohcfa7a9c2012-12-17 06:38:51 +00001992 }
Alexander Block7e0926f2012-07-28 14:20:58 +02001993 INIT_LIST_HEAD(nce_head);
Alexander Block31db9f72012-07-25 23:19:24 +02001994
Alexander Block7e0926f2012-07-28 14:20:58 +02001995 ret = radix_tree_insert(&sctx->name_cache, nce->ino, nce_head);
Alexander Block5dc67d02012-08-01 12:07:43 +02001996 if (ret < 0) {
1997 kfree(nce_head);
1998 kfree(nce);
Alexander Block31db9f72012-07-25 23:19:24 +02001999 return ret;
Alexander Block5dc67d02012-08-01 12:07:43 +02002000 }
Alexander Block31db9f72012-07-25 23:19:24 +02002001 }
Alexander Block7e0926f2012-07-28 14:20:58 +02002002 list_add_tail(&nce->radix_list, nce_head);
Alexander Block31db9f72012-07-25 23:19:24 +02002003 list_add_tail(&nce->list, &sctx->name_cache_list);
2004 sctx->name_cache_size++;
2005
2006 return ret;
2007}
2008
2009static void name_cache_delete(struct send_ctx *sctx,
2010 struct name_cache_entry *nce)
2011{
Alexander Block7e0926f2012-07-28 14:20:58 +02002012 struct list_head *nce_head;
Alexander Block31db9f72012-07-25 23:19:24 +02002013
Alexander Block7e0926f2012-07-28 14:20:58 +02002014 nce_head = radix_tree_lookup(&sctx->name_cache,
2015 (unsigned long)nce->ino);
David Sterba57fb8912014-02-03 19:24:40 +01002016 if (!nce_head) {
2017 btrfs_err(sctx->send_root->fs_info,
2018 "name_cache_delete lookup failed ino %llu cache size %d, leaking memory",
2019 nce->ino, sctx->name_cache_size);
2020 }
Alexander Block31db9f72012-07-25 23:19:24 +02002021
Alexander Block7e0926f2012-07-28 14:20:58 +02002022 list_del(&nce->radix_list);
Alexander Block31db9f72012-07-25 23:19:24 +02002023 list_del(&nce->list);
Alexander Block31db9f72012-07-25 23:19:24 +02002024 sctx->name_cache_size--;
Alexander Block7e0926f2012-07-28 14:20:58 +02002025
David Sterba57fb8912014-02-03 19:24:40 +01002026 /*
2027 * We may not get to the final release of nce_head if the lookup fails
2028 */
2029 if (nce_head && list_empty(nce_head)) {
Alexander Block7e0926f2012-07-28 14:20:58 +02002030 radix_tree_delete(&sctx->name_cache, (unsigned long)nce->ino);
2031 kfree(nce_head);
2032 }
Alexander Block31db9f72012-07-25 23:19:24 +02002033}
2034
2035static struct name_cache_entry *name_cache_search(struct send_ctx *sctx,
2036 u64 ino, u64 gen)
2037{
Alexander Block7e0926f2012-07-28 14:20:58 +02002038 struct list_head *nce_head;
2039 struct name_cache_entry *cur;
Alexander Block31db9f72012-07-25 23:19:24 +02002040
Alexander Block7e0926f2012-07-28 14:20:58 +02002041 nce_head = radix_tree_lookup(&sctx->name_cache, (unsigned long)ino);
2042 if (!nce_head)
Alexander Block31db9f72012-07-25 23:19:24 +02002043 return NULL;
2044
Alexander Block7e0926f2012-07-28 14:20:58 +02002045 list_for_each_entry(cur, nce_head, radix_list) {
2046 if (cur->ino == ino && cur->gen == gen)
2047 return cur;
2048 }
Alexander Block31db9f72012-07-25 23:19:24 +02002049 return NULL;
2050}
2051
Alexander Block766702e2012-07-28 14:11:31 +02002052/*
2053 * Removes the entry from the list and adds it back to the end. This marks the
2054 * entry as recently used so that name_cache_clean_unused does not remove it.
2055 */
Alexander Block31db9f72012-07-25 23:19:24 +02002056static void name_cache_used(struct send_ctx *sctx, struct name_cache_entry *nce)
2057{
2058 list_del(&nce->list);
2059 list_add_tail(&nce->list, &sctx->name_cache_list);
2060}
2061
Alexander Block766702e2012-07-28 14:11:31 +02002062/*
2063 * Remove some entries from the beginning of name_cache_list.
2064 */
Alexander Block31db9f72012-07-25 23:19:24 +02002065static void name_cache_clean_unused(struct send_ctx *sctx)
2066{
2067 struct name_cache_entry *nce;
2068
2069 if (sctx->name_cache_size < SEND_CTX_NAME_CACHE_CLEAN_SIZE)
2070 return;
2071
2072 while (sctx->name_cache_size > SEND_CTX_MAX_NAME_CACHE_SIZE) {
2073 nce = list_entry(sctx->name_cache_list.next,
2074 struct name_cache_entry, list);
2075 name_cache_delete(sctx, nce);
2076 kfree(nce);
2077 }
2078}
2079
2080static void name_cache_free(struct send_ctx *sctx)
2081{
2082 struct name_cache_entry *nce;
Alexander Block31db9f72012-07-25 23:19:24 +02002083
Alexander Blocke938c8a2012-07-28 16:33:49 +02002084 while (!list_empty(&sctx->name_cache_list)) {
2085 nce = list_entry(sctx->name_cache_list.next,
2086 struct name_cache_entry, list);
Alexander Block31db9f72012-07-25 23:19:24 +02002087 name_cache_delete(sctx, nce);
Alexander Block17589bd2012-07-28 14:13:35 +02002088 kfree(nce);
Alexander Block31db9f72012-07-25 23:19:24 +02002089 }
2090}
2091
Alexander Block766702e2012-07-28 14:11:31 +02002092/*
2093 * Used by get_cur_path for each ref up to the root.
2094 * Returns 0 if it succeeded.
2095 * Returns 1 if the inode is not existent or got overwritten. In that case, the
2096 * name is an orphan name. This instructs get_cur_path to stop iterating. If 1
2097 * is returned, parent_ino/parent_gen are not guaranteed to be valid.
2098 * Returns <0 in case of error.
2099 */
Alexander Block31db9f72012-07-25 23:19:24 +02002100static int __get_cur_name_and_parent(struct send_ctx *sctx,
2101 u64 ino, u64 gen,
2102 u64 *parent_ino,
2103 u64 *parent_gen,
2104 struct fs_path *dest)
2105{
2106 int ret;
2107 int nce_ret;
Alexander Block31db9f72012-07-25 23:19:24 +02002108 struct name_cache_entry *nce = NULL;
2109
Alexander Block766702e2012-07-28 14:11:31 +02002110 /*
2111 * First check if we already did a call to this function with the same
2112 * ino/gen. If yes, check if the cache entry is still up-to-date. If yes
2113 * return the cached result.
2114 */
Alexander Block31db9f72012-07-25 23:19:24 +02002115 nce = name_cache_search(sctx, ino, gen);
2116 if (nce) {
2117 if (ino < sctx->send_progress && nce->need_later_update) {
2118 name_cache_delete(sctx, nce);
2119 kfree(nce);
2120 nce = NULL;
2121 } else {
2122 name_cache_used(sctx, nce);
2123 *parent_ino = nce->parent_ino;
2124 *parent_gen = nce->parent_gen;
2125 ret = fs_path_add(dest, nce->name, nce->name_len);
2126 if (ret < 0)
2127 goto out;
2128 ret = nce->ret;
2129 goto out;
2130 }
2131 }
2132
Alexander Block766702e2012-07-28 14:11:31 +02002133 /*
2134 * If the inode is not existent yet, add the orphan name and return 1.
2135 * This should only happen for the parent dir that we determine in
2136 * __record_new_ref
2137 */
Alexander Block31db9f72012-07-25 23:19:24 +02002138 ret = is_inode_existent(sctx, ino, gen);
2139 if (ret < 0)
2140 goto out;
2141
2142 if (!ret) {
2143 ret = gen_unique_name(sctx, ino, gen, dest);
2144 if (ret < 0)
2145 goto out;
2146 ret = 1;
2147 goto out_cache;
2148 }
2149
Alexander Block766702e2012-07-28 14:11:31 +02002150 /*
2151 * Depending on whether the inode was already processed or not, use
2152 * send_root or parent_root for ref lookup.
2153 */
Filipe Mananabf0d1f42014-02-21 00:01:32 +00002154 if (ino < sctx->send_progress)
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002155 ret = get_first_ref(sctx->send_root, ino,
2156 parent_ino, parent_gen, dest);
Alexander Block31db9f72012-07-25 23:19:24 +02002157 else
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002158 ret = get_first_ref(sctx->parent_root, ino,
2159 parent_ino, parent_gen, dest);
Alexander Block31db9f72012-07-25 23:19:24 +02002160 if (ret < 0)
2161 goto out;
2162
Alexander Block766702e2012-07-28 14:11:31 +02002163 /*
2164 * Check if the ref was overwritten by an inode's ref that was processed
2165 * earlier. If yes, treat as orphan and return 1.
2166 */
Alexander Block31db9f72012-07-25 23:19:24 +02002167 ret = did_overwrite_ref(sctx, *parent_ino, *parent_gen, ino, gen,
2168 dest->start, dest->end - dest->start);
2169 if (ret < 0)
2170 goto out;
2171 if (ret) {
2172 fs_path_reset(dest);
2173 ret = gen_unique_name(sctx, ino, gen, dest);
2174 if (ret < 0)
2175 goto out;
2176 ret = 1;
2177 }
2178
2179out_cache:
Alexander Block766702e2012-07-28 14:11:31 +02002180 /*
2181 * Store the result of the lookup in the name cache.
2182 */
David Sterbae780b0d2016-01-18 18:42:13 +01002183 nce = kmalloc(sizeof(*nce) + fs_path_len(dest) + 1, GFP_KERNEL);
Alexander Block31db9f72012-07-25 23:19:24 +02002184 if (!nce) {
2185 ret = -ENOMEM;
2186 goto out;
2187 }
2188
2189 nce->ino = ino;
2190 nce->gen = gen;
2191 nce->parent_ino = *parent_ino;
2192 nce->parent_gen = *parent_gen;
2193 nce->name_len = fs_path_len(dest);
2194 nce->ret = ret;
2195 strcpy(nce->name, dest->start);
Alexander Block31db9f72012-07-25 23:19:24 +02002196
2197 if (ino < sctx->send_progress)
2198 nce->need_later_update = 0;
2199 else
2200 nce->need_later_update = 1;
2201
2202 nce_ret = name_cache_insert(sctx, nce);
2203 if (nce_ret < 0)
2204 ret = nce_ret;
2205 name_cache_clean_unused(sctx);
2206
2207out:
Alexander Block31db9f72012-07-25 23:19:24 +02002208 return ret;
2209}
2210
2211/*
2212 * Magic happens here. This function returns the first ref to an inode as it
2213 * would look like while receiving the stream at this point in time.
2214 * We walk the path up to the root. For every inode in between, we check if it
2215 * was already processed/sent. If yes, we continue with the parent as found
2216 * in send_root. If not, we continue with the parent as found in parent_root.
2217 * If we encounter an inode that was deleted at this point in time, we use the
2218 * inodes "orphan" name instead of the real name and stop. Same with new inodes
2219 * that were not created yet and overwritten inodes/refs.
2220 *
2221 * When do we have have orphan inodes:
2222 * 1. When an inode is freshly created and thus no valid refs are available yet
2223 * 2. When a directory lost all it's refs (deleted) but still has dir items
2224 * inside which were not processed yet (pending for move/delete). If anyone
2225 * tried to get the path to the dir items, it would get a path inside that
2226 * orphan directory.
2227 * 3. When an inode is moved around or gets new links, it may overwrite the ref
2228 * of an unprocessed inode. If in that case the first ref would be
2229 * overwritten, the overwritten inode gets "orphanized". Later when we
2230 * process this overwritten inode, it is restored at a new place by moving
2231 * the orphan inode.
2232 *
2233 * sctx->send_progress tells this function at which point in time receiving
2234 * would be.
2235 */
2236static int get_cur_path(struct send_ctx *sctx, u64 ino, u64 gen,
2237 struct fs_path *dest)
2238{
2239 int ret = 0;
2240 struct fs_path *name = NULL;
2241 u64 parent_inode = 0;
2242 u64 parent_gen = 0;
2243 int stop = 0;
2244
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002245 name = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +02002246 if (!name) {
2247 ret = -ENOMEM;
2248 goto out;
2249 }
2250
2251 dest->reversed = 1;
2252 fs_path_reset(dest);
2253
2254 while (!stop && ino != BTRFS_FIRST_FREE_OBJECTID) {
Filipe Manana8b191a62015-04-09 14:09:14 +01002255 struct waiting_dir_move *wdm;
2256
Alexander Block31db9f72012-07-25 23:19:24 +02002257 fs_path_reset(name);
2258
Filipe Manana9dc44212014-02-19 14:31:44 +00002259 if (is_waiting_for_rm(sctx, ino)) {
2260 ret = gen_unique_name(sctx, ino, gen, name);
2261 if (ret < 0)
2262 goto out;
2263 ret = fs_path_add_path(dest, name);
2264 break;
2265 }
2266
Filipe Manana8b191a62015-04-09 14:09:14 +01002267 wdm = get_waiting_dir_move(sctx, ino);
2268 if (wdm && wdm->orphanized) {
2269 ret = gen_unique_name(sctx, ino, gen, name);
2270 stop = 1;
2271 } else if (wdm) {
Filipe Mananabf0d1f42014-02-21 00:01:32 +00002272 ret = get_first_ref(sctx->parent_root, ino,
2273 &parent_inode, &parent_gen, name);
2274 } else {
2275 ret = __get_cur_name_and_parent(sctx, ino, gen,
2276 &parent_inode,
2277 &parent_gen, name);
2278 if (ret)
2279 stop = 1;
2280 }
2281
Alexander Block31db9f72012-07-25 23:19:24 +02002282 if (ret < 0)
2283 goto out;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00002284
Alexander Block31db9f72012-07-25 23:19:24 +02002285 ret = fs_path_add_path(dest, name);
2286 if (ret < 0)
2287 goto out;
2288
2289 ino = parent_inode;
2290 gen = parent_gen;
2291 }
2292
2293out:
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002294 fs_path_free(name);
Alexander Block31db9f72012-07-25 23:19:24 +02002295 if (!ret)
2296 fs_path_unreverse(dest);
2297 return ret;
2298}
2299
2300/*
Alexander Block31db9f72012-07-25 23:19:24 +02002301 * Sends a BTRFS_SEND_C_SUBVOL command/item to userspace
2302 */
2303static int send_subvol_begin(struct send_ctx *sctx)
2304{
2305 int ret;
2306 struct btrfs_root *send_root = sctx->send_root;
2307 struct btrfs_root *parent_root = sctx->parent_root;
2308 struct btrfs_path *path;
2309 struct btrfs_key key;
2310 struct btrfs_root_ref *ref;
2311 struct extent_buffer *leaf;
2312 char *name = NULL;
2313 int namelen;
2314
Wang Shilongffcfaf82014-01-15 00:26:43 +08002315 path = btrfs_alloc_path();
Alexander Block31db9f72012-07-25 23:19:24 +02002316 if (!path)
2317 return -ENOMEM;
2318
David Sterbae780b0d2016-01-18 18:42:13 +01002319 name = kmalloc(BTRFS_PATH_NAME_MAX, GFP_KERNEL);
Alexander Block31db9f72012-07-25 23:19:24 +02002320 if (!name) {
2321 btrfs_free_path(path);
2322 return -ENOMEM;
2323 }
2324
2325 key.objectid = send_root->objectid;
2326 key.type = BTRFS_ROOT_BACKREF_KEY;
2327 key.offset = 0;
2328
2329 ret = btrfs_search_slot_for_read(send_root->fs_info->tree_root,
2330 &key, path, 1, 0);
2331 if (ret < 0)
2332 goto out;
2333 if (ret) {
2334 ret = -ENOENT;
2335 goto out;
2336 }
2337
2338 leaf = path->nodes[0];
2339 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
2340 if (key.type != BTRFS_ROOT_BACKREF_KEY ||
2341 key.objectid != send_root->objectid) {
2342 ret = -ENOENT;
2343 goto out;
2344 }
2345 ref = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_root_ref);
2346 namelen = btrfs_root_ref_name_len(leaf, ref);
2347 read_extent_buffer(leaf, name, (unsigned long)(ref + 1), namelen);
2348 btrfs_release_path(path);
2349
Alexander Block31db9f72012-07-25 23:19:24 +02002350 if (parent_root) {
2351 ret = begin_cmd(sctx, BTRFS_SEND_C_SNAPSHOT);
2352 if (ret < 0)
2353 goto out;
2354 } else {
2355 ret = begin_cmd(sctx, BTRFS_SEND_C_SUBVOL);
2356 if (ret < 0)
2357 goto out;
2358 }
2359
2360 TLV_PUT_STRING(sctx, BTRFS_SEND_A_PATH, name, namelen);
Robin Ruedeb96b1db2015-09-30 21:23:33 +02002361
2362 if (!btrfs_is_empty_uuid(sctx->send_root->root_item.received_uuid))
2363 TLV_PUT_UUID(sctx, BTRFS_SEND_A_UUID,
2364 sctx->send_root->root_item.received_uuid);
2365 else
2366 TLV_PUT_UUID(sctx, BTRFS_SEND_A_UUID,
2367 sctx->send_root->root_item.uuid);
2368
Alexander Block31db9f72012-07-25 23:19:24 +02002369 TLV_PUT_U64(sctx, BTRFS_SEND_A_CTRANSID,
Filipe David Borba Manana5a0f4e22013-12-03 15:55:48 +00002370 le64_to_cpu(sctx->send_root->root_item.ctransid));
Alexander Block31db9f72012-07-25 23:19:24 +02002371 if (parent_root) {
Josef Bacik37b8d272015-06-04 17:17:25 -04002372 if (!btrfs_is_empty_uuid(parent_root->root_item.received_uuid))
2373 TLV_PUT_UUID(sctx, BTRFS_SEND_A_CLONE_UUID,
2374 parent_root->root_item.received_uuid);
2375 else
2376 TLV_PUT_UUID(sctx, BTRFS_SEND_A_CLONE_UUID,
2377 parent_root->root_item.uuid);
Alexander Block31db9f72012-07-25 23:19:24 +02002378 TLV_PUT_U64(sctx, BTRFS_SEND_A_CLONE_CTRANSID,
Filipe David Borba Manana5a0f4e22013-12-03 15:55:48 +00002379 le64_to_cpu(sctx->parent_root->root_item.ctransid));
Alexander Block31db9f72012-07-25 23:19:24 +02002380 }
2381
2382 ret = send_cmd(sctx);
2383
2384tlv_put_failure:
2385out:
2386 btrfs_free_path(path);
2387 kfree(name);
2388 return ret;
2389}
2390
2391static int send_truncate(struct send_ctx *sctx, u64 ino, u64 gen, u64 size)
2392{
2393 int ret = 0;
2394 struct fs_path *p;
2395
2396verbose_printk("btrfs: send_truncate %llu size=%llu\n", ino, size);
2397
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002398 p = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +02002399 if (!p)
2400 return -ENOMEM;
2401
2402 ret = begin_cmd(sctx, BTRFS_SEND_C_TRUNCATE);
2403 if (ret < 0)
2404 goto out;
2405
2406 ret = get_cur_path(sctx, ino, gen, p);
2407 if (ret < 0)
2408 goto out;
2409 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
2410 TLV_PUT_U64(sctx, BTRFS_SEND_A_SIZE, size);
2411
2412 ret = send_cmd(sctx);
2413
2414tlv_put_failure:
2415out:
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002416 fs_path_free(p);
Alexander Block31db9f72012-07-25 23:19:24 +02002417 return ret;
2418}
2419
2420static int send_chmod(struct send_ctx *sctx, u64 ino, u64 gen, u64 mode)
2421{
2422 int ret = 0;
2423 struct fs_path *p;
2424
2425verbose_printk("btrfs: send_chmod %llu mode=%llu\n", ino, mode);
2426
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002427 p = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +02002428 if (!p)
2429 return -ENOMEM;
2430
2431 ret = begin_cmd(sctx, BTRFS_SEND_C_CHMOD);
2432 if (ret < 0)
2433 goto out;
2434
2435 ret = get_cur_path(sctx, ino, gen, p);
2436 if (ret < 0)
2437 goto out;
2438 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
2439 TLV_PUT_U64(sctx, BTRFS_SEND_A_MODE, mode & 07777);
2440
2441 ret = send_cmd(sctx);
2442
2443tlv_put_failure:
2444out:
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002445 fs_path_free(p);
Alexander Block31db9f72012-07-25 23:19:24 +02002446 return ret;
2447}
2448
2449static int send_chown(struct send_ctx *sctx, u64 ino, u64 gen, u64 uid, u64 gid)
2450{
2451 int ret = 0;
2452 struct fs_path *p;
2453
2454verbose_printk("btrfs: send_chown %llu uid=%llu, gid=%llu\n", ino, uid, gid);
2455
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002456 p = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +02002457 if (!p)
2458 return -ENOMEM;
2459
2460 ret = begin_cmd(sctx, BTRFS_SEND_C_CHOWN);
2461 if (ret < 0)
2462 goto out;
2463
2464 ret = get_cur_path(sctx, ino, gen, p);
2465 if (ret < 0)
2466 goto out;
2467 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
2468 TLV_PUT_U64(sctx, BTRFS_SEND_A_UID, uid);
2469 TLV_PUT_U64(sctx, BTRFS_SEND_A_GID, gid);
2470
2471 ret = send_cmd(sctx);
2472
2473tlv_put_failure:
2474out:
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002475 fs_path_free(p);
Alexander Block31db9f72012-07-25 23:19:24 +02002476 return ret;
2477}
2478
2479static int send_utimes(struct send_ctx *sctx, u64 ino, u64 gen)
2480{
2481 int ret = 0;
2482 struct fs_path *p = NULL;
2483 struct btrfs_inode_item *ii;
2484 struct btrfs_path *path = NULL;
2485 struct extent_buffer *eb;
2486 struct btrfs_key key;
2487 int slot;
2488
2489verbose_printk("btrfs: send_utimes %llu\n", ino);
2490
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002491 p = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +02002492 if (!p)
2493 return -ENOMEM;
2494
2495 path = alloc_path_for_send();
2496 if (!path) {
2497 ret = -ENOMEM;
2498 goto out;
2499 }
2500
2501 key.objectid = ino;
2502 key.type = BTRFS_INODE_ITEM_KEY;
2503 key.offset = 0;
2504 ret = btrfs_search_slot(NULL, sctx->send_root, &key, path, 0, 0);
2505 if (ret < 0)
2506 goto out;
2507
2508 eb = path->nodes[0];
2509 slot = path->slots[0];
2510 ii = btrfs_item_ptr(eb, slot, struct btrfs_inode_item);
2511
2512 ret = begin_cmd(sctx, BTRFS_SEND_C_UTIMES);
2513 if (ret < 0)
2514 goto out;
2515
2516 ret = get_cur_path(sctx, ino, gen, p);
2517 if (ret < 0)
2518 goto out;
2519 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
David Sterbaa937b972014-12-12 17:39:12 +01002520 TLV_PUT_BTRFS_TIMESPEC(sctx, BTRFS_SEND_A_ATIME, eb, &ii->atime);
2521 TLV_PUT_BTRFS_TIMESPEC(sctx, BTRFS_SEND_A_MTIME, eb, &ii->mtime);
2522 TLV_PUT_BTRFS_TIMESPEC(sctx, BTRFS_SEND_A_CTIME, eb, &ii->ctime);
Alexander Block766702e2012-07-28 14:11:31 +02002523 /* TODO Add otime support when the otime patches get into upstream */
Alexander Block31db9f72012-07-25 23:19:24 +02002524
2525 ret = send_cmd(sctx);
2526
2527tlv_put_failure:
2528out:
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002529 fs_path_free(p);
Alexander Block31db9f72012-07-25 23:19:24 +02002530 btrfs_free_path(path);
2531 return ret;
2532}
2533
2534/*
2535 * Sends a BTRFS_SEND_C_MKXXX or SYMLINK command to user space. We don't have
2536 * a valid path yet because we did not process the refs yet. So, the inode
2537 * is created as orphan.
2538 */
Alexander Block1f4692d2012-07-28 10:42:24 +02002539static int send_create_inode(struct send_ctx *sctx, u64 ino)
Alexander Block31db9f72012-07-25 23:19:24 +02002540{
2541 int ret = 0;
Alexander Block31db9f72012-07-25 23:19:24 +02002542 struct fs_path *p;
Alexander Block31db9f72012-07-25 23:19:24 +02002543 int cmd;
Alexander Block1f4692d2012-07-28 10:42:24 +02002544 u64 gen;
Alexander Block31db9f72012-07-25 23:19:24 +02002545 u64 mode;
Alexander Block1f4692d2012-07-28 10:42:24 +02002546 u64 rdev;
Alexander Block31db9f72012-07-25 23:19:24 +02002547
Alexander Block1f4692d2012-07-28 10:42:24 +02002548verbose_printk("btrfs: send_create_inode %llu\n", ino);
Alexander Block31db9f72012-07-25 23:19:24 +02002549
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002550 p = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +02002551 if (!p)
2552 return -ENOMEM;
2553
Liu Bo644d1942014-02-27 17:29:01 +08002554 if (ino != sctx->cur_ino) {
2555 ret = get_inode_info(sctx->send_root, ino, NULL, &gen, &mode,
2556 NULL, NULL, &rdev);
2557 if (ret < 0)
2558 goto out;
2559 } else {
2560 gen = sctx->cur_inode_gen;
2561 mode = sctx->cur_inode_mode;
2562 rdev = sctx->cur_inode_rdev;
2563 }
Alexander Block31db9f72012-07-25 23:19:24 +02002564
Alexander Blocke938c8a2012-07-28 16:33:49 +02002565 if (S_ISREG(mode)) {
Alexander Block31db9f72012-07-25 23:19:24 +02002566 cmd = BTRFS_SEND_C_MKFILE;
Alexander Blocke938c8a2012-07-28 16:33:49 +02002567 } else if (S_ISDIR(mode)) {
Alexander Block31db9f72012-07-25 23:19:24 +02002568 cmd = BTRFS_SEND_C_MKDIR;
Alexander Blocke938c8a2012-07-28 16:33:49 +02002569 } else if (S_ISLNK(mode)) {
Alexander Block31db9f72012-07-25 23:19:24 +02002570 cmd = BTRFS_SEND_C_SYMLINK;
Alexander Blocke938c8a2012-07-28 16:33:49 +02002571 } else if (S_ISCHR(mode) || S_ISBLK(mode)) {
Alexander Block31db9f72012-07-25 23:19:24 +02002572 cmd = BTRFS_SEND_C_MKNOD;
Alexander Blocke938c8a2012-07-28 16:33:49 +02002573 } else if (S_ISFIFO(mode)) {
Alexander Block31db9f72012-07-25 23:19:24 +02002574 cmd = BTRFS_SEND_C_MKFIFO;
Alexander Blocke938c8a2012-07-28 16:33:49 +02002575 } else if (S_ISSOCK(mode)) {
Alexander Block31db9f72012-07-25 23:19:24 +02002576 cmd = BTRFS_SEND_C_MKSOCK;
Alexander Blocke938c8a2012-07-28 16:33:49 +02002577 } else {
David Sterbaf14d1042015-10-08 11:37:06 +02002578 btrfs_warn(sctx->send_root->fs_info, "unexpected inode type %o",
Alexander Block31db9f72012-07-25 23:19:24 +02002579 (int)(mode & S_IFMT));
2580 ret = -ENOTSUPP;
2581 goto out;
2582 }
2583
2584 ret = begin_cmd(sctx, cmd);
2585 if (ret < 0)
2586 goto out;
2587
Alexander Block1f4692d2012-07-28 10:42:24 +02002588 ret = gen_unique_name(sctx, ino, gen, p);
Alexander Block31db9f72012-07-25 23:19:24 +02002589 if (ret < 0)
2590 goto out;
2591
2592 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
Alexander Block1f4692d2012-07-28 10:42:24 +02002593 TLV_PUT_U64(sctx, BTRFS_SEND_A_INO, ino);
Alexander Block31db9f72012-07-25 23:19:24 +02002594
2595 if (S_ISLNK(mode)) {
2596 fs_path_reset(p);
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002597 ret = read_symlink(sctx->send_root, ino, p);
Alexander Block31db9f72012-07-25 23:19:24 +02002598 if (ret < 0)
2599 goto out;
2600 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH_LINK, p);
2601 } else if (S_ISCHR(mode) || S_ISBLK(mode) ||
2602 S_ISFIFO(mode) || S_ISSOCK(mode)) {
Arne Jansend79e5042012-10-15 18:28:46 +00002603 TLV_PUT_U64(sctx, BTRFS_SEND_A_RDEV, new_encode_dev(rdev));
2604 TLV_PUT_U64(sctx, BTRFS_SEND_A_MODE, mode);
Alexander Block31db9f72012-07-25 23:19:24 +02002605 }
2606
2607 ret = send_cmd(sctx);
2608 if (ret < 0)
2609 goto out;
2610
2611
2612tlv_put_failure:
2613out:
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002614 fs_path_free(p);
Alexander Block31db9f72012-07-25 23:19:24 +02002615 return ret;
2616}
2617
Alexander Block1f4692d2012-07-28 10:42:24 +02002618/*
2619 * We need some special handling for inodes that get processed before the parent
2620 * directory got created. See process_recorded_refs for details.
2621 * This function does the check if we already created the dir out of order.
2622 */
2623static int did_create_dir(struct send_ctx *sctx, u64 dir)
2624{
2625 int ret = 0;
2626 struct btrfs_path *path = NULL;
2627 struct btrfs_key key;
2628 struct btrfs_key found_key;
2629 struct btrfs_key di_key;
2630 struct extent_buffer *eb;
2631 struct btrfs_dir_item *di;
2632 int slot;
2633
2634 path = alloc_path_for_send();
2635 if (!path) {
2636 ret = -ENOMEM;
2637 goto out;
2638 }
2639
2640 key.objectid = dir;
2641 key.type = BTRFS_DIR_INDEX_KEY;
2642 key.offset = 0;
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00002643 ret = btrfs_search_slot(NULL, sctx->send_root, &key, path, 0, 0);
2644 if (ret < 0)
2645 goto out;
2646
Alexander Block1f4692d2012-07-28 10:42:24 +02002647 while (1) {
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00002648 eb = path->nodes[0];
2649 slot = path->slots[0];
2650 if (slot >= btrfs_header_nritems(eb)) {
2651 ret = btrfs_next_leaf(sctx->send_root, path);
2652 if (ret < 0) {
2653 goto out;
2654 } else if (ret > 0) {
2655 ret = 0;
2656 break;
2657 }
2658 continue;
Alexander Block1f4692d2012-07-28 10:42:24 +02002659 }
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00002660
2661 btrfs_item_key_to_cpu(eb, &found_key, slot);
2662 if (found_key.objectid != key.objectid ||
Alexander Block1f4692d2012-07-28 10:42:24 +02002663 found_key.type != key.type) {
2664 ret = 0;
2665 goto out;
2666 }
2667
2668 di = btrfs_item_ptr(eb, slot, struct btrfs_dir_item);
2669 btrfs_dir_item_key_to_cpu(eb, di, &di_key);
2670
Josef Bacika0525412013-08-12 10:56:14 -04002671 if (di_key.type != BTRFS_ROOT_ITEM_KEY &&
2672 di_key.objectid < sctx->send_progress) {
Alexander Block1f4692d2012-07-28 10:42:24 +02002673 ret = 1;
2674 goto out;
2675 }
2676
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00002677 path->slots[0]++;
Alexander Block1f4692d2012-07-28 10:42:24 +02002678 }
2679
2680out:
2681 btrfs_free_path(path);
2682 return ret;
2683}
2684
2685/*
2686 * Only creates the inode if it is:
2687 * 1. Not a directory
2688 * 2. Or a directory which was not created already due to out of order
2689 * directories. See did_create_dir and process_recorded_refs for details.
2690 */
2691static int send_create_inode_if_needed(struct send_ctx *sctx)
2692{
2693 int ret;
2694
2695 if (S_ISDIR(sctx->cur_inode_mode)) {
2696 ret = did_create_dir(sctx, sctx->cur_ino);
2697 if (ret < 0)
2698 goto out;
2699 if (ret) {
2700 ret = 0;
2701 goto out;
2702 }
2703 }
2704
2705 ret = send_create_inode(sctx, sctx->cur_ino);
2706 if (ret < 0)
2707 goto out;
2708
2709out:
2710 return ret;
2711}
2712
Alexander Block31db9f72012-07-25 23:19:24 +02002713struct recorded_ref {
2714 struct list_head list;
2715 char *dir_path;
2716 char *name;
2717 struct fs_path *full_path;
2718 u64 dir;
2719 u64 dir_gen;
2720 int dir_path_len;
2721 int name_len;
2722};
2723
2724/*
2725 * We need to process new refs before deleted refs, but compare_tree gives us
2726 * everything mixed. So we first record all refs and later process them.
2727 * This function is a helper to record one ref.
2728 */
Liu Boa4d96d62014-03-03 21:31:03 +08002729static int __record_ref(struct list_head *head, u64 dir,
Alexander Block31db9f72012-07-25 23:19:24 +02002730 u64 dir_gen, struct fs_path *path)
2731{
2732 struct recorded_ref *ref;
Alexander Block31db9f72012-07-25 23:19:24 +02002733
David Sterbae780b0d2016-01-18 18:42:13 +01002734 ref = kmalloc(sizeof(*ref), GFP_KERNEL);
Alexander Block31db9f72012-07-25 23:19:24 +02002735 if (!ref)
2736 return -ENOMEM;
2737
2738 ref->dir = dir;
2739 ref->dir_gen = dir_gen;
2740 ref->full_path = path;
2741
Andy Shevchenkoed848852013-08-21 10:32:13 +03002742 ref->name = (char *)kbasename(ref->full_path->start);
2743 ref->name_len = ref->full_path->end - ref->name;
2744 ref->dir_path = ref->full_path->start;
2745 if (ref->name == ref->full_path->start)
Alexander Block31db9f72012-07-25 23:19:24 +02002746 ref->dir_path_len = 0;
Andy Shevchenkoed848852013-08-21 10:32:13 +03002747 else
Alexander Block31db9f72012-07-25 23:19:24 +02002748 ref->dir_path_len = ref->full_path->end -
2749 ref->full_path->start - 1 - ref->name_len;
Alexander Block31db9f72012-07-25 23:19:24 +02002750
2751 list_add_tail(&ref->list, head);
2752 return 0;
2753}
2754
Josef Bacikba5e8f22013-08-16 16:52:55 -04002755static int dup_ref(struct recorded_ref *ref, struct list_head *list)
2756{
2757 struct recorded_ref *new;
2758
David Sterbae780b0d2016-01-18 18:42:13 +01002759 new = kmalloc(sizeof(*ref), GFP_KERNEL);
Josef Bacikba5e8f22013-08-16 16:52:55 -04002760 if (!new)
2761 return -ENOMEM;
2762
2763 new->dir = ref->dir;
2764 new->dir_gen = ref->dir_gen;
2765 new->full_path = NULL;
2766 INIT_LIST_HEAD(&new->list);
2767 list_add_tail(&new->list, list);
2768 return 0;
2769}
2770
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002771static void __free_recorded_refs(struct list_head *head)
Alexander Block31db9f72012-07-25 23:19:24 +02002772{
2773 struct recorded_ref *cur;
Alexander Block31db9f72012-07-25 23:19:24 +02002774
Alexander Blocke938c8a2012-07-28 16:33:49 +02002775 while (!list_empty(head)) {
2776 cur = list_entry(head->next, struct recorded_ref, list);
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002777 fs_path_free(cur->full_path);
Alexander Blocke938c8a2012-07-28 16:33:49 +02002778 list_del(&cur->list);
Alexander Block31db9f72012-07-25 23:19:24 +02002779 kfree(cur);
2780 }
Alexander Block31db9f72012-07-25 23:19:24 +02002781}
2782
2783static void free_recorded_refs(struct send_ctx *sctx)
2784{
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002785 __free_recorded_refs(&sctx->new_refs);
2786 __free_recorded_refs(&sctx->deleted_refs);
Alexander Block31db9f72012-07-25 23:19:24 +02002787}
2788
2789/*
Alexander Block766702e2012-07-28 14:11:31 +02002790 * Renames/moves a file/dir to its orphan name. Used when the first
Alexander Block31db9f72012-07-25 23:19:24 +02002791 * ref of an unprocessed inode gets overwritten and for all non empty
2792 * directories.
2793 */
2794static int orphanize_inode(struct send_ctx *sctx, u64 ino, u64 gen,
2795 struct fs_path *path)
2796{
2797 int ret;
2798 struct fs_path *orphan;
2799
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002800 orphan = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +02002801 if (!orphan)
2802 return -ENOMEM;
2803
2804 ret = gen_unique_name(sctx, ino, gen, orphan);
2805 if (ret < 0)
2806 goto out;
2807
2808 ret = send_rename(sctx, path, orphan);
2809
2810out:
Tsutomu Itoh924794c2013-05-08 07:51:52 +00002811 fs_path_free(orphan);
Alexander Block31db9f72012-07-25 23:19:24 +02002812 return ret;
2813}
2814
Filipe Manana9dc44212014-02-19 14:31:44 +00002815static struct orphan_dir_info *
2816add_orphan_dir_info(struct send_ctx *sctx, u64 dir_ino)
2817{
2818 struct rb_node **p = &sctx->orphan_dirs.rb_node;
2819 struct rb_node *parent = NULL;
2820 struct orphan_dir_info *entry, *odi;
2821
David Sterbae780b0d2016-01-18 18:42:13 +01002822 odi = kmalloc(sizeof(*odi), GFP_KERNEL);
Filipe Manana9dc44212014-02-19 14:31:44 +00002823 if (!odi)
2824 return ERR_PTR(-ENOMEM);
2825 odi->ino = dir_ino;
2826 odi->gen = 0;
2827
2828 while (*p) {
2829 parent = *p;
2830 entry = rb_entry(parent, struct orphan_dir_info, node);
2831 if (dir_ino < entry->ino) {
2832 p = &(*p)->rb_left;
2833 } else if (dir_ino > entry->ino) {
2834 p = &(*p)->rb_right;
2835 } else {
2836 kfree(odi);
2837 return entry;
2838 }
2839 }
2840
2841 rb_link_node(&odi->node, parent, p);
2842 rb_insert_color(&odi->node, &sctx->orphan_dirs);
2843 return odi;
2844}
2845
2846static struct orphan_dir_info *
2847get_orphan_dir_info(struct send_ctx *sctx, u64 dir_ino)
2848{
2849 struct rb_node *n = sctx->orphan_dirs.rb_node;
2850 struct orphan_dir_info *entry;
2851
2852 while (n) {
2853 entry = rb_entry(n, struct orphan_dir_info, node);
2854 if (dir_ino < entry->ino)
2855 n = n->rb_left;
2856 else if (dir_ino > entry->ino)
2857 n = n->rb_right;
2858 else
2859 return entry;
2860 }
2861 return NULL;
2862}
2863
2864static int is_waiting_for_rm(struct send_ctx *sctx, u64 dir_ino)
2865{
2866 struct orphan_dir_info *odi = get_orphan_dir_info(sctx, dir_ino);
2867
2868 return odi != NULL;
2869}
2870
2871static void free_orphan_dir_info(struct send_ctx *sctx,
2872 struct orphan_dir_info *odi)
2873{
2874 if (!odi)
2875 return;
2876 rb_erase(&odi->node, &sctx->orphan_dirs);
2877 kfree(odi);
2878}
2879
Alexander Block31db9f72012-07-25 23:19:24 +02002880/*
2881 * Returns 1 if a directory can be removed at this point in time.
2882 * We check this by iterating all dir items and checking if the inode behind
2883 * the dir item was already processed.
2884 */
Filipe Manana9dc44212014-02-19 14:31:44 +00002885static int can_rmdir(struct send_ctx *sctx, u64 dir, u64 dir_gen,
2886 u64 send_progress)
Alexander Block31db9f72012-07-25 23:19:24 +02002887{
2888 int ret = 0;
2889 struct btrfs_root *root = sctx->parent_root;
2890 struct btrfs_path *path;
2891 struct btrfs_key key;
2892 struct btrfs_key found_key;
2893 struct btrfs_key loc;
2894 struct btrfs_dir_item *di;
2895
Alexander Block6d85ed02012-08-01 14:48:59 +02002896 /*
2897 * Don't try to rmdir the top/root subvolume dir.
2898 */
2899 if (dir == BTRFS_FIRST_FREE_OBJECTID)
2900 return 0;
2901
Alexander Block31db9f72012-07-25 23:19:24 +02002902 path = alloc_path_for_send();
2903 if (!path)
2904 return -ENOMEM;
2905
2906 key.objectid = dir;
2907 key.type = BTRFS_DIR_INDEX_KEY;
2908 key.offset = 0;
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00002909 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
2910 if (ret < 0)
2911 goto out;
Alexander Block31db9f72012-07-25 23:19:24 +02002912
2913 while (1) {
Filipe Manana9dc44212014-02-19 14:31:44 +00002914 struct waiting_dir_move *dm;
2915
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00002916 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
2917 ret = btrfs_next_leaf(root, path);
2918 if (ret < 0)
2919 goto out;
2920 else if (ret > 0)
2921 break;
2922 continue;
Alexander Block31db9f72012-07-25 23:19:24 +02002923 }
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00002924 btrfs_item_key_to_cpu(path->nodes[0], &found_key,
2925 path->slots[0]);
2926 if (found_key.objectid != key.objectid ||
2927 found_key.type != key.type)
Alexander Block31db9f72012-07-25 23:19:24 +02002928 break;
Alexander Block31db9f72012-07-25 23:19:24 +02002929
2930 di = btrfs_item_ptr(path->nodes[0], path->slots[0],
2931 struct btrfs_dir_item);
2932 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &loc);
2933
Filipe Manana9dc44212014-02-19 14:31:44 +00002934 dm = get_waiting_dir_move(sctx, loc.objectid);
2935 if (dm) {
2936 struct orphan_dir_info *odi;
2937
2938 odi = add_orphan_dir_info(sctx, dir);
2939 if (IS_ERR(odi)) {
2940 ret = PTR_ERR(odi);
2941 goto out;
2942 }
2943 odi->gen = dir_gen;
2944 dm->rmdir_ino = dir;
2945 ret = 0;
2946 goto out;
2947 }
2948
Alexander Block31db9f72012-07-25 23:19:24 +02002949 if (loc.objectid > send_progress) {
2950 ret = 0;
2951 goto out;
2952 }
2953
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00002954 path->slots[0]++;
Alexander Block31db9f72012-07-25 23:19:24 +02002955 }
2956
2957 ret = 1;
2958
2959out:
2960 btrfs_free_path(path);
2961 return ret;
2962}
2963
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00002964static int is_waiting_for_move(struct send_ctx *sctx, u64 ino)
2965{
Filipe Manana9dc44212014-02-19 14:31:44 +00002966 struct waiting_dir_move *entry = get_waiting_dir_move(sctx, ino);
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00002967
Filipe Manana9dc44212014-02-19 14:31:44 +00002968 return entry != NULL;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00002969}
2970
Filipe Manana8b191a62015-04-09 14:09:14 +01002971static int add_waiting_dir_move(struct send_ctx *sctx, u64 ino, bool orphanized)
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00002972{
2973 struct rb_node **p = &sctx->waiting_dir_moves.rb_node;
2974 struct rb_node *parent = NULL;
2975 struct waiting_dir_move *entry, *dm;
2976
David Sterbae780b0d2016-01-18 18:42:13 +01002977 dm = kmalloc(sizeof(*dm), GFP_KERNEL);
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00002978 if (!dm)
2979 return -ENOMEM;
2980 dm->ino = ino;
Filipe Manana9dc44212014-02-19 14:31:44 +00002981 dm->rmdir_ino = 0;
Filipe Manana8b191a62015-04-09 14:09:14 +01002982 dm->orphanized = orphanized;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00002983
2984 while (*p) {
2985 parent = *p;
2986 entry = rb_entry(parent, struct waiting_dir_move, node);
2987 if (ino < entry->ino) {
2988 p = &(*p)->rb_left;
2989 } else if (ino > entry->ino) {
2990 p = &(*p)->rb_right;
2991 } else {
2992 kfree(dm);
2993 return -EEXIST;
2994 }
2995 }
2996
2997 rb_link_node(&dm->node, parent, p);
2998 rb_insert_color(&dm->node, &sctx->waiting_dir_moves);
2999 return 0;
3000}
3001
Filipe Manana9dc44212014-02-19 14:31:44 +00003002static struct waiting_dir_move *
3003get_waiting_dir_move(struct send_ctx *sctx, u64 ino)
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003004{
3005 struct rb_node *n = sctx->waiting_dir_moves.rb_node;
3006 struct waiting_dir_move *entry;
3007
3008 while (n) {
3009 entry = rb_entry(n, struct waiting_dir_move, node);
Filipe Manana9dc44212014-02-19 14:31:44 +00003010 if (ino < entry->ino)
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003011 n = n->rb_left;
Filipe Manana9dc44212014-02-19 14:31:44 +00003012 else if (ino > entry->ino)
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003013 n = n->rb_right;
Filipe Manana9dc44212014-02-19 14:31:44 +00003014 else
3015 return entry;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003016 }
Filipe Manana9dc44212014-02-19 14:31:44 +00003017 return NULL;
3018}
3019
3020static void free_waiting_dir_move(struct send_ctx *sctx,
3021 struct waiting_dir_move *dm)
3022{
3023 if (!dm)
3024 return;
3025 rb_erase(&dm->node, &sctx->waiting_dir_moves);
3026 kfree(dm);
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003027}
3028
Filipe Mananabfa7e1f2014-03-19 14:20:54 +00003029static int add_pending_dir_move(struct send_ctx *sctx,
3030 u64 ino,
3031 u64 ino_gen,
Filipe Mananaf9594922014-03-27 20:14:01 +00003032 u64 parent_ino,
3033 struct list_head *new_refs,
Filipe Manana84471e22015-02-28 22:29:22 +00003034 struct list_head *deleted_refs,
3035 const bool is_orphan)
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003036{
3037 struct rb_node **p = &sctx->pending_dir_moves.rb_node;
3038 struct rb_node *parent = NULL;
Chris Mason73b802f2014-03-21 15:30:44 -07003039 struct pending_dir_move *entry = NULL, *pm;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003040 struct recorded_ref *cur;
3041 int exists = 0;
3042 int ret;
3043
David Sterbae780b0d2016-01-18 18:42:13 +01003044 pm = kmalloc(sizeof(*pm), GFP_KERNEL);
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003045 if (!pm)
3046 return -ENOMEM;
3047 pm->parent_ino = parent_ino;
Filipe Mananabfa7e1f2014-03-19 14:20:54 +00003048 pm->ino = ino;
3049 pm->gen = ino_gen;
Filipe Manana84471e22015-02-28 22:29:22 +00003050 pm->is_orphan = is_orphan;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003051 INIT_LIST_HEAD(&pm->list);
3052 INIT_LIST_HEAD(&pm->update_refs);
3053 RB_CLEAR_NODE(&pm->node);
3054
3055 while (*p) {
3056 parent = *p;
3057 entry = rb_entry(parent, struct pending_dir_move, node);
3058 if (parent_ino < entry->parent_ino) {
3059 p = &(*p)->rb_left;
3060 } else if (parent_ino > entry->parent_ino) {
3061 p = &(*p)->rb_right;
3062 } else {
3063 exists = 1;
3064 break;
3065 }
3066 }
3067
Filipe Mananaf9594922014-03-27 20:14:01 +00003068 list_for_each_entry(cur, deleted_refs, list) {
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003069 ret = dup_ref(cur, &pm->update_refs);
3070 if (ret < 0)
3071 goto out;
3072 }
Filipe Mananaf9594922014-03-27 20:14:01 +00003073 list_for_each_entry(cur, new_refs, list) {
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003074 ret = dup_ref(cur, &pm->update_refs);
3075 if (ret < 0)
3076 goto out;
3077 }
3078
Filipe Manana8b191a62015-04-09 14:09:14 +01003079 ret = add_waiting_dir_move(sctx, pm->ino, is_orphan);
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003080 if (ret)
3081 goto out;
3082
3083 if (exists) {
3084 list_add_tail(&pm->list, &entry->list);
3085 } else {
3086 rb_link_node(&pm->node, parent, p);
3087 rb_insert_color(&pm->node, &sctx->pending_dir_moves);
3088 }
3089 ret = 0;
3090out:
3091 if (ret) {
3092 __free_recorded_refs(&pm->update_refs);
3093 kfree(pm);
3094 }
3095 return ret;
3096}
3097
3098static struct pending_dir_move *get_pending_dir_moves(struct send_ctx *sctx,
3099 u64 parent_ino)
3100{
3101 struct rb_node *n = sctx->pending_dir_moves.rb_node;
3102 struct pending_dir_move *entry;
3103
3104 while (n) {
3105 entry = rb_entry(n, struct pending_dir_move, node);
3106 if (parent_ino < entry->parent_ino)
3107 n = n->rb_left;
3108 else if (parent_ino > entry->parent_ino)
3109 n = n->rb_right;
3110 else
3111 return entry;
3112 }
3113 return NULL;
3114}
3115
3116static int apply_dir_move(struct send_ctx *sctx, struct pending_dir_move *pm)
3117{
3118 struct fs_path *from_path = NULL;
3119 struct fs_path *to_path = NULL;
Filipe Manana2b863a12014-02-16 13:43:11 +00003120 struct fs_path *name = NULL;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003121 u64 orig_progress = sctx->send_progress;
3122 struct recorded_ref *cur;
Filipe Manana2b863a12014-02-16 13:43:11 +00003123 u64 parent_ino, parent_gen;
Filipe Manana9dc44212014-02-19 14:31:44 +00003124 struct waiting_dir_move *dm = NULL;
3125 u64 rmdir_ino = 0;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003126 int ret;
3127
Filipe Manana2b863a12014-02-16 13:43:11 +00003128 name = fs_path_alloc();
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003129 from_path = fs_path_alloc();
Filipe Manana2b863a12014-02-16 13:43:11 +00003130 if (!name || !from_path) {
3131 ret = -ENOMEM;
3132 goto out;
3133 }
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003134
Filipe Manana9dc44212014-02-19 14:31:44 +00003135 dm = get_waiting_dir_move(sctx, pm->ino);
3136 ASSERT(dm);
3137 rmdir_ino = dm->rmdir_ino;
3138 free_waiting_dir_move(sctx, dm);
Filipe Manana2b863a12014-02-16 13:43:11 +00003139
Filipe Manana84471e22015-02-28 22:29:22 +00003140 if (pm->is_orphan) {
3141 ret = gen_unique_name(sctx, pm->ino,
3142 pm->gen, from_path);
3143 } else {
3144 ret = get_first_ref(sctx->parent_root, pm->ino,
3145 &parent_ino, &parent_gen, name);
3146 if (ret < 0)
3147 goto out;
3148 ret = get_cur_path(sctx, parent_ino, parent_gen,
3149 from_path);
3150 if (ret < 0)
3151 goto out;
3152 ret = fs_path_add_path(from_path, name);
3153 }
Filipe Mananac992ec92014-03-22 17:15:24 +00003154 if (ret < 0)
3155 goto out;
3156
Filipe Mananaf9594922014-03-27 20:14:01 +00003157 sctx->send_progress = sctx->cur_ino + 1;
Filipe Mananac992ec92014-03-22 17:15:24 +00003158 fs_path_reset(name);
3159 to_path = name;
3160 name = NULL;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003161 ret = get_cur_path(sctx, pm->ino, pm->gen, to_path);
3162 if (ret < 0)
3163 goto out;
3164
3165 ret = send_rename(sctx, from_path, to_path);
3166 if (ret < 0)
3167 goto out;
3168
Filipe Manana9dc44212014-02-19 14:31:44 +00003169 if (rmdir_ino) {
3170 struct orphan_dir_info *odi;
3171
3172 odi = get_orphan_dir_info(sctx, rmdir_ino);
3173 if (!odi) {
3174 /* already deleted */
3175 goto finish;
3176 }
3177 ret = can_rmdir(sctx, rmdir_ino, odi->gen, sctx->cur_ino + 1);
3178 if (ret < 0)
3179 goto out;
3180 if (!ret)
3181 goto finish;
3182
3183 name = fs_path_alloc();
3184 if (!name) {
3185 ret = -ENOMEM;
3186 goto out;
3187 }
3188 ret = get_cur_path(sctx, rmdir_ino, odi->gen, name);
3189 if (ret < 0)
3190 goto out;
3191 ret = send_rmdir(sctx, name);
3192 if (ret < 0)
3193 goto out;
3194 free_orphan_dir_info(sctx, odi);
3195 }
3196
3197finish:
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003198 ret = send_utimes(sctx, pm->ino, pm->gen);
3199 if (ret < 0)
3200 goto out;
3201
3202 /*
3203 * After rename/move, need to update the utimes of both new parent(s)
3204 * and old parent(s).
3205 */
3206 list_for_each_entry(cur, &pm->update_refs, list) {
Filipe Manana9dc44212014-02-19 14:31:44 +00003207 if (cur->dir == rmdir_ino)
3208 continue;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003209 ret = send_utimes(sctx, cur->dir, cur->dir_gen);
3210 if (ret < 0)
3211 goto out;
3212 }
3213
3214out:
Filipe Manana2b863a12014-02-16 13:43:11 +00003215 fs_path_free(name);
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003216 fs_path_free(from_path);
3217 fs_path_free(to_path);
3218 sctx->send_progress = orig_progress;
3219
3220 return ret;
3221}
3222
3223static void free_pending_move(struct send_ctx *sctx, struct pending_dir_move *m)
3224{
3225 if (!list_empty(&m->list))
3226 list_del(&m->list);
3227 if (!RB_EMPTY_NODE(&m->node))
3228 rb_erase(&m->node, &sctx->pending_dir_moves);
3229 __free_recorded_refs(&m->update_refs);
3230 kfree(m);
3231}
3232
3233static void tail_append_pending_moves(struct pending_dir_move *moves,
3234 struct list_head *stack)
3235{
3236 if (list_empty(&moves->list)) {
3237 list_add_tail(&moves->list, stack);
3238 } else {
3239 LIST_HEAD(list);
3240 list_splice_init(&moves->list, &list);
3241 list_add_tail(&moves->list, stack);
3242 list_splice_tail(&list, stack);
3243 }
3244}
3245
3246static int apply_children_dir_moves(struct send_ctx *sctx)
3247{
3248 struct pending_dir_move *pm;
3249 struct list_head stack;
3250 u64 parent_ino = sctx->cur_ino;
3251 int ret = 0;
3252
3253 pm = get_pending_dir_moves(sctx, parent_ino);
3254 if (!pm)
3255 return 0;
3256
3257 INIT_LIST_HEAD(&stack);
3258 tail_append_pending_moves(pm, &stack);
3259
3260 while (!list_empty(&stack)) {
3261 pm = list_first_entry(&stack, struct pending_dir_move, list);
3262 parent_ino = pm->ino;
3263 ret = apply_dir_move(sctx, pm);
3264 free_pending_move(sctx, pm);
3265 if (ret)
3266 goto out;
3267 pm = get_pending_dir_moves(sctx, parent_ino);
3268 if (pm)
3269 tail_append_pending_moves(pm, &stack);
3270 }
3271 return 0;
3272
3273out:
3274 while (!list_empty(&stack)) {
3275 pm = list_first_entry(&stack, struct pending_dir_move, list);
3276 free_pending_move(sctx, pm);
3277 }
3278 return ret;
3279}
3280
Filipe Manana84471e22015-02-28 22:29:22 +00003281/*
3282 * We might need to delay a directory rename even when no ancestor directory
3283 * (in the send root) with a higher inode number than ours (sctx->cur_ino) was
3284 * renamed. This happens when we rename a directory to the old name (the name
3285 * in the parent root) of some other unrelated directory that got its rename
3286 * delayed due to some ancestor with higher number that got renamed.
3287 *
3288 * Example:
3289 *
3290 * Parent snapshot:
3291 * . (ino 256)
3292 * |---- a/ (ino 257)
3293 * | |---- file (ino 260)
3294 * |
3295 * |---- b/ (ino 258)
3296 * |---- c/ (ino 259)
3297 *
3298 * Send snapshot:
3299 * . (ino 256)
3300 * |---- a/ (ino 258)
3301 * |---- x/ (ino 259)
3302 * |---- y/ (ino 257)
3303 * |----- file (ino 260)
3304 *
3305 * Here we can not rename 258 from 'b' to 'a' without the rename of inode 257
3306 * from 'a' to 'x/y' happening first, which in turn depends on the rename of
3307 * inode 259 from 'c' to 'x'. So the order of rename commands the send stream
3308 * must issue is:
3309 *
3310 * 1 - rename 259 from 'c' to 'x'
3311 * 2 - rename 257 from 'a' to 'x/y'
3312 * 3 - rename 258 from 'b' to 'a'
3313 *
3314 * Returns 1 if the rename of sctx->cur_ino needs to be delayed, 0 if it can
3315 * be done right away and < 0 on error.
3316 */
3317static int wait_for_dest_dir_move(struct send_ctx *sctx,
3318 struct recorded_ref *parent_ref,
3319 const bool is_orphan)
3320{
3321 struct btrfs_path *path;
3322 struct btrfs_key key;
3323 struct btrfs_key di_key;
3324 struct btrfs_dir_item *di;
3325 u64 left_gen;
3326 u64 right_gen;
3327 int ret = 0;
3328
3329 if (RB_EMPTY_ROOT(&sctx->waiting_dir_moves))
3330 return 0;
3331
3332 path = alloc_path_for_send();
3333 if (!path)
3334 return -ENOMEM;
3335
3336 key.objectid = parent_ref->dir;
3337 key.type = BTRFS_DIR_ITEM_KEY;
3338 key.offset = btrfs_name_hash(parent_ref->name, parent_ref->name_len);
3339
3340 ret = btrfs_search_slot(NULL, sctx->parent_root, &key, path, 0, 0);
3341 if (ret < 0) {
3342 goto out;
3343 } else if (ret > 0) {
3344 ret = 0;
3345 goto out;
3346 }
3347
3348 di = btrfs_match_dir_item_name(sctx->parent_root, path,
3349 parent_ref->name, parent_ref->name_len);
3350 if (!di) {
3351 ret = 0;
3352 goto out;
3353 }
3354 /*
3355 * di_key.objectid has the number of the inode that has a dentry in the
3356 * parent directory with the same name that sctx->cur_ino is being
3357 * renamed to. We need to check if that inode is in the send root as
3358 * well and if it is currently marked as an inode with a pending rename,
3359 * if it is, we need to delay the rename of sctx->cur_ino as well, so
3360 * that it happens after that other inode is renamed.
3361 */
3362 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &di_key);
3363 if (di_key.type != BTRFS_INODE_ITEM_KEY) {
3364 ret = 0;
3365 goto out;
3366 }
3367
3368 ret = get_inode_info(sctx->parent_root, di_key.objectid, NULL,
3369 &left_gen, NULL, NULL, NULL, NULL);
3370 if (ret < 0)
3371 goto out;
3372 ret = get_inode_info(sctx->send_root, di_key.objectid, NULL,
3373 &right_gen, NULL, NULL, NULL, NULL);
3374 if (ret < 0) {
3375 if (ret == -ENOENT)
3376 ret = 0;
3377 goto out;
3378 }
3379
3380 /* Different inode, no need to delay the rename of sctx->cur_ino */
3381 if (right_gen != left_gen) {
3382 ret = 0;
3383 goto out;
3384 }
3385
3386 if (is_waiting_for_move(sctx, di_key.objectid)) {
3387 ret = add_pending_dir_move(sctx,
3388 sctx->cur_ino,
3389 sctx->cur_inode_gen,
3390 di_key.objectid,
3391 &sctx->new_refs,
3392 &sctx->deleted_refs,
3393 is_orphan);
3394 if (!ret)
3395 ret = 1;
3396 }
3397out:
3398 btrfs_free_path(path);
3399 return ret;
3400}
3401
Filipe Manana80aa6022015-03-27 17:50:45 +00003402/*
3403 * Check if ino ino1 is an ancestor of inode ino2 in the given root.
3404 * Return 1 if true, 0 if false and < 0 on error.
3405 */
3406static int is_ancestor(struct btrfs_root *root,
3407 const u64 ino1,
3408 const u64 ino1_gen,
3409 const u64 ino2,
3410 struct fs_path *fs_path)
3411{
3412 u64 ino = ino2;
3413
3414 while (ino > BTRFS_FIRST_FREE_OBJECTID) {
3415 int ret;
3416 u64 parent;
3417 u64 parent_gen;
3418
3419 fs_path_reset(fs_path);
3420 ret = get_first_ref(root, ino, &parent, &parent_gen, fs_path);
3421 if (ret < 0) {
3422 if (ret == -ENOENT && ino == ino2)
3423 ret = 0;
3424 return ret;
3425 }
3426 if (parent == ino1)
3427 return parent_gen == ino1_gen ? 1 : 0;
3428 ino = parent;
3429 }
3430 return 0;
3431}
3432
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003433static int wait_for_parent_move(struct send_ctx *sctx,
Filipe Manana8b191a62015-04-09 14:09:14 +01003434 struct recorded_ref *parent_ref,
3435 const bool is_orphan)
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003436{
Filipe Mananaf9594922014-03-27 20:14:01 +00003437 int ret = 0;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003438 u64 ino = parent_ref->dir;
3439 u64 parent_ino_before, parent_ino_after;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003440 struct fs_path *path_before = NULL;
3441 struct fs_path *path_after = NULL;
3442 int len1, len2;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003443
3444 path_after = fs_path_alloc();
Filipe Mananaf9594922014-03-27 20:14:01 +00003445 path_before = fs_path_alloc();
3446 if (!path_after || !path_before) {
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003447 ret = -ENOMEM;
3448 goto out;
3449 }
3450
Filipe Mananabfa7e1f2014-03-19 14:20:54 +00003451 /*
Filipe Mananaf9594922014-03-27 20:14:01 +00003452 * Our current directory inode may not yet be renamed/moved because some
3453 * ancestor (immediate or not) has to be renamed/moved first. So find if
3454 * such ancestor exists and make sure our own rename/move happens after
Filipe Manana80aa6022015-03-27 17:50:45 +00003455 * that ancestor is processed to avoid path build infinite loops (done
3456 * at get_cur_path()).
Filipe Mananabfa7e1f2014-03-19 14:20:54 +00003457 */
Filipe Mananaf9594922014-03-27 20:14:01 +00003458 while (ino > BTRFS_FIRST_FREE_OBJECTID) {
3459 if (is_waiting_for_move(sctx, ino)) {
Filipe Manana80aa6022015-03-27 17:50:45 +00003460 /*
3461 * If the current inode is an ancestor of ino in the
3462 * parent root, we need to delay the rename of the
3463 * current inode, otherwise don't delayed the rename
3464 * because we can end up with a circular dependency
3465 * of renames, resulting in some directories never
3466 * getting the respective rename operations issued in
3467 * the send stream or getting into infinite path build
3468 * loops.
3469 */
3470 ret = is_ancestor(sctx->parent_root,
3471 sctx->cur_ino, sctx->cur_inode_gen,
3472 ino, path_before);
Filipe Mananaf9594922014-03-27 20:14:01 +00003473 break;
3474 }
Filipe Mananabfa7e1f2014-03-19 14:20:54 +00003475
3476 fs_path_reset(path_before);
3477 fs_path_reset(path_after);
3478
3479 ret = get_first_ref(sctx->send_root, ino, &parent_ino_after,
Filipe Mananaf9594922014-03-27 20:14:01 +00003480 NULL, path_after);
Filipe Mananabfa7e1f2014-03-19 14:20:54 +00003481 if (ret < 0)
3482 goto out;
3483 ret = get_first_ref(sctx->parent_root, ino, &parent_ino_before,
3484 NULL, path_before);
Filipe Mananaf9594922014-03-27 20:14:01 +00003485 if (ret < 0 && ret != -ENOENT) {
Filipe Mananabfa7e1f2014-03-19 14:20:54 +00003486 goto out;
Filipe Mananaf9594922014-03-27 20:14:01 +00003487 } else if (ret == -ENOENT) {
Filipe Mananabf8e8ca2014-10-02 19:17:32 +01003488 ret = 0;
Filipe Mananaf9594922014-03-27 20:14:01 +00003489 break;
Filipe Mananabfa7e1f2014-03-19 14:20:54 +00003490 }
3491
3492 len1 = fs_path_len(path_before);
3493 len2 = fs_path_len(path_after);
Filipe Mananaf9594922014-03-27 20:14:01 +00003494 if (ino > sctx->cur_ino &&
3495 (parent_ino_before != parent_ino_after || len1 != len2 ||
3496 memcmp(path_before->start, path_after->start, len1))) {
Filipe Mananabfa7e1f2014-03-19 14:20:54 +00003497 ret = 1;
Filipe Mananaf9594922014-03-27 20:14:01 +00003498 break;
Filipe Mananabfa7e1f2014-03-19 14:20:54 +00003499 }
Filipe Mananabfa7e1f2014-03-19 14:20:54 +00003500 ino = parent_ino_after;
Filipe Mananabfa7e1f2014-03-19 14:20:54 +00003501 }
3502
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003503out:
3504 fs_path_free(path_before);
3505 fs_path_free(path_after);
3506
Filipe Mananaf9594922014-03-27 20:14:01 +00003507 if (ret == 1) {
3508 ret = add_pending_dir_move(sctx,
3509 sctx->cur_ino,
3510 sctx->cur_inode_gen,
3511 ino,
3512 &sctx->new_refs,
Filipe Manana84471e22015-02-28 22:29:22 +00003513 &sctx->deleted_refs,
Filipe Manana8b191a62015-04-09 14:09:14 +01003514 is_orphan);
Filipe Mananaf9594922014-03-27 20:14:01 +00003515 if (!ret)
3516 ret = 1;
3517 }
3518
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003519 return ret;
3520}
3521
Alexander Block31db9f72012-07-25 23:19:24 +02003522/*
3523 * This does all the move/link/unlink/rmdir magic.
3524 */
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00003525static int process_recorded_refs(struct send_ctx *sctx, int *pending_move)
Alexander Block31db9f72012-07-25 23:19:24 +02003526{
3527 int ret = 0;
3528 struct recorded_ref *cur;
Alexander Block1f4692d2012-07-28 10:42:24 +02003529 struct recorded_ref *cur2;
Josef Bacikba5e8f22013-08-16 16:52:55 -04003530 struct list_head check_dirs;
Alexander Block31db9f72012-07-25 23:19:24 +02003531 struct fs_path *valid_path = NULL;
Chris Masonb24baf62012-07-25 19:21:10 -04003532 u64 ow_inode = 0;
Alexander Block31db9f72012-07-25 23:19:24 +02003533 u64 ow_gen;
3534 int did_overwrite = 0;
3535 int is_orphan = 0;
Filipe Manana29d6d302014-02-16 21:01:39 +00003536 u64 last_dir_ino_rm = 0;
Filipe Manana84471e22015-02-28 22:29:22 +00003537 bool can_rename = true;
Alexander Block31db9f72012-07-25 23:19:24 +02003538
3539verbose_printk("btrfs: process_recorded_refs %llu\n", sctx->cur_ino);
3540
Alexander Block6d85ed02012-08-01 14:48:59 +02003541 /*
3542 * This should never happen as the root dir always has the same ref
3543 * which is always '..'
3544 */
3545 BUG_ON(sctx->cur_ino <= BTRFS_FIRST_FREE_OBJECTID);
Josef Bacikba5e8f22013-08-16 16:52:55 -04003546 INIT_LIST_HEAD(&check_dirs);
Alexander Block6d85ed02012-08-01 14:48:59 +02003547
Tsutomu Itoh924794c2013-05-08 07:51:52 +00003548 valid_path = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +02003549 if (!valid_path) {
3550 ret = -ENOMEM;
3551 goto out;
3552 }
3553
Alexander Block31db9f72012-07-25 23:19:24 +02003554 /*
3555 * First, check if the first ref of the current inode was overwritten
3556 * before. If yes, we know that the current inode was already orphanized
3557 * and thus use the orphan name. If not, we can use get_cur_path to
3558 * get the path of the first ref as it would like while receiving at
3559 * this point in time.
3560 * New inodes are always orphan at the beginning, so force to use the
3561 * orphan name in this case.
3562 * The first ref is stored in valid_path and will be updated if it
3563 * gets moved around.
3564 */
3565 if (!sctx->cur_inode_new) {
3566 ret = did_overwrite_first_ref(sctx, sctx->cur_ino,
3567 sctx->cur_inode_gen);
3568 if (ret < 0)
3569 goto out;
3570 if (ret)
3571 did_overwrite = 1;
3572 }
3573 if (sctx->cur_inode_new || did_overwrite) {
3574 ret = gen_unique_name(sctx, sctx->cur_ino,
3575 sctx->cur_inode_gen, valid_path);
3576 if (ret < 0)
3577 goto out;
3578 is_orphan = 1;
3579 } else {
3580 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen,
3581 valid_path);
3582 if (ret < 0)
3583 goto out;
3584 }
3585
3586 list_for_each_entry(cur, &sctx->new_refs, list) {
3587 /*
Alexander Block1f4692d2012-07-28 10:42:24 +02003588 * We may have refs where the parent directory does not exist
3589 * yet. This happens if the parent directories inum is higher
3590 * the the current inum. To handle this case, we create the
3591 * parent directory out of order. But we need to check if this
3592 * did already happen before due to other refs in the same dir.
3593 */
3594 ret = get_cur_inode_state(sctx, cur->dir, cur->dir_gen);
3595 if (ret < 0)
3596 goto out;
3597 if (ret == inode_state_will_create) {
3598 ret = 0;
3599 /*
3600 * First check if any of the current inodes refs did
3601 * already create the dir.
3602 */
3603 list_for_each_entry(cur2, &sctx->new_refs, list) {
3604 if (cur == cur2)
3605 break;
3606 if (cur2->dir == cur->dir) {
3607 ret = 1;
3608 break;
3609 }
3610 }
3611
3612 /*
3613 * If that did not happen, check if a previous inode
3614 * did already create the dir.
3615 */
3616 if (!ret)
3617 ret = did_create_dir(sctx, cur->dir);
3618 if (ret < 0)
3619 goto out;
3620 if (!ret) {
3621 ret = send_create_inode(sctx, cur->dir);
3622 if (ret < 0)
3623 goto out;
3624 }
3625 }
3626
3627 /*
Alexander Block31db9f72012-07-25 23:19:24 +02003628 * Check if this new ref would overwrite the first ref of
3629 * another unprocessed inode. If yes, orphanize the
3630 * overwritten inode. If we find an overwritten ref that is
3631 * not the first ref, simply unlink it.
3632 */
3633 ret = will_overwrite_ref(sctx, cur->dir, cur->dir_gen,
3634 cur->name, cur->name_len,
3635 &ow_inode, &ow_gen);
3636 if (ret < 0)
3637 goto out;
3638 if (ret) {
Tsutomu Itoh924794c2013-05-08 07:51:52 +00003639 ret = is_first_ref(sctx->parent_root,
3640 ow_inode, cur->dir, cur->name,
3641 cur->name_len);
Alexander Block31db9f72012-07-25 23:19:24 +02003642 if (ret < 0)
3643 goto out;
3644 if (ret) {
Filipe Manana8996a482015-03-12 15:16:20 +00003645 struct name_cache_entry *nce;
3646
Alexander Block31db9f72012-07-25 23:19:24 +02003647 ret = orphanize_inode(sctx, ow_inode, ow_gen,
3648 cur->full_path);
3649 if (ret < 0)
3650 goto out;
Filipe Manana8996a482015-03-12 15:16:20 +00003651 /*
3652 * Make sure we clear our orphanized inode's
3653 * name from the name cache. This is because the
3654 * inode ow_inode might be an ancestor of some
3655 * other inode that will be orphanized as well
3656 * later and has an inode number greater than
3657 * sctx->send_progress. We need to prevent
3658 * future name lookups from using the old name
3659 * and get instead the orphan name.
3660 */
3661 nce = name_cache_search(sctx, ow_inode, ow_gen);
3662 if (nce) {
3663 name_cache_delete(sctx, nce);
3664 kfree(nce);
3665 }
Alexander Block31db9f72012-07-25 23:19:24 +02003666 } else {
3667 ret = send_unlink(sctx, cur->full_path);
3668 if (ret < 0)
3669 goto out;
3670 }
3671 }
3672
Filipe Manana84471e22015-02-28 22:29:22 +00003673 if (S_ISDIR(sctx->cur_inode_mode) && sctx->parent_root) {
3674 ret = wait_for_dest_dir_move(sctx, cur, is_orphan);
3675 if (ret < 0)
3676 goto out;
3677 if (ret == 1) {
3678 can_rename = false;
3679 *pending_move = 1;
3680 }
3681 }
3682
Filipe Manana8b191a62015-04-09 14:09:14 +01003683 if (S_ISDIR(sctx->cur_inode_mode) && sctx->parent_root &&
3684 can_rename) {
3685 ret = wait_for_parent_move(sctx, cur, is_orphan);
3686 if (ret < 0)
3687 goto out;
3688 if (ret == 1) {
3689 can_rename = false;
3690 *pending_move = 1;
3691 }
3692 }
3693
Alexander Block31db9f72012-07-25 23:19:24 +02003694 /*
3695 * link/move the ref to the new place. If we have an orphan
3696 * inode, move it and update valid_path. If not, link or move
3697 * it depending on the inode mode.
3698 */
Filipe Manana84471e22015-02-28 22:29:22 +00003699 if (is_orphan && can_rename) {
Alexander Block31db9f72012-07-25 23:19:24 +02003700 ret = send_rename(sctx, valid_path, cur->full_path);
3701 if (ret < 0)
3702 goto out;
3703 is_orphan = 0;
3704 ret = fs_path_copy(valid_path, cur->full_path);
3705 if (ret < 0)
3706 goto out;
Filipe Manana84471e22015-02-28 22:29:22 +00003707 } else if (can_rename) {
Alexander Block31db9f72012-07-25 23:19:24 +02003708 if (S_ISDIR(sctx->cur_inode_mode)) {
3709 /*
3710 * Dirs can't be linked, so move it. For moved
3711 * dirs, we always have one new and one deleted
3712 * ref. The deleted ref is ignored later.
3713 */
Filipe Manana8b191a62015-04-09 14:09:14 +01003714 ret = send_rename(sctx, valid_path,
3715 cur->full_path);
3716 if (!ret)
3717 ret = fs_path_copy(valid_path,
3718 cur->full_path);
Alexander Block31db9f72012-07-25 23:19:24 +02003719 if (ret < 0)
3720 goto out;
3721 } else {
3722 ret = send_link(sctx, cur->full_path,
3723 valid_path);
3724 if (ret < 0)
3725 goto out;
3726 }
3727 }
Josef Bacikba5e8f22013-08-16 16:52:55 -04003728 ret = dup_ref(cur, &check_dirs);
Alexander Block31db9f72012-07-25 23:19:24 +02003729 if (ret < 0)
3730 goto out;
3731 }
3732
3733 if (S_ISDIR(sctx->cur_inode_mode) && sctx->cur_inode_deleted) {
3734 /*
3735 * Check if we can already rmdir the directory. If not,
3736 * orphanize it. For every dir item inside that gets deleted
3737 * later, we do this check again and rmdir it then if possible.
3738 * See the use of check_dirs for more details.
3739 */
Filipe Manana9dc44212014-02-19 14:31:44 +00003740 ret = can_rmdir(sctx, sctx->cur_ino, sctx->cur_inode_gen,
3741 sctx->cur_ino);
Alexander Block31db9f72012-07-25 23:19:24 +02003742 if (ret < 0)
3743 goto out;
3744 if (ret) {
3745 ret = send_rmdir(sctx, valid_path);
3746 if (ret < 0)
3747 goto out;
3748 } else if (!is_orphan) {
3749 ret = orphanize_inode(sctx, sctx->cur_ino,
3750 sctx->cur_inode_gen, valid_path);
3751 if (ret < 0)
3752 goto out;
3753 is_orphan = 1;
3754 }
3755
3756 list_for_each_entry(cur, &sctx->deleted_refs, list) {
Josef Bacikba5e8f22013-08-16 16:52:55 -04003757 ret = dup_ref(cur, &check_dirs);
Alexander Block31db9f72012-07-25 23:19:24 +02003758 if (ret < 0)
3759 goto out;
3760 }
Alexander Blockccf16262012-07-28 11:46:29 +02003761 } else if (S_ISDIR(sctx->cur_inode_mode) &&
3762 !list_empty(&sctx->deleted_refs)) {
3763 /*
3764 * We have a moved dir. Add the old parent to check_dirs
3765 */
3766 cur = list_entry(sctx->deleted_refs.next, struct recorded_ref,
3767 list);
Josef Bacikba5e8f22013-08-16 16:52:55 -04003768 ret = dup_ref(cur, &check_dirs);
Alexander Blockccf16262012-07-28 11:46:29 +02003769 if (ret < 0)
3770 goto out;
Alexander Block31db9f72012-07-25 23:19:24 +02003771 } else if (!S_ISDIR(sctx->cur_inode_mode)) {
3772 /*
3773 * We have a non dir inode. Go through all deleted refs and
3774 * unlink them if they were not already overwritten by other
3775 * inodes.
3776 */
3777 list_for_each_entry(cur, &sctx->deleted_refs, list) {
3778 ret = did_overwrite_ref(sctx, cur->dir, cur->dir_gen,
3779 sctx->cur_ino, sctx->cur_inode_gen,
3780 cur->name, cur->name_len);
3781 if (ret < 0)
3782 goto out;
3783 if (!ret) {
Alexander Block1f4692d2012-07-28 10:42:24 +02003784 ret = send_unlink(sctx, cur->full_path);
3785 if (ret < 0)
3786 goto out;
Alexander Block31db9f72012-07-25 23:19:24 +02003787 }
Josef Bacikba5e8f22013-08-16 16:52:55 -04003788 ret = dup_ref(cur, &check_dirs);
Alexander Block31db9f72012-07-25 23:19:24 +02003789 if (ret < 0)
3790 goto out;
3791 }
Alexander Block31db9f72012-07-25 23:19:24 +02003792 /*
3793 * If the inode is still orphan, unlink the orphan. This may
3794 * happen when a previous inode did overwrite the first ref
3795 * of this inode and no new refs were added for the current
Alexander Block766702e2012-07-28 14:11:31 +02003796 * inode. Unlinking does not mean that the inode is deleted in
3797 * all cases. There may still be links to this inode in other
3798 * places.
Alexander Block31db9f72012-07-25 23:19:24 +02003799 */
Alexander Block1f4692d2012-07-28 10:42:24 +02003800 if (is_orphan) {
Alexander Block31db9f72012-07-25 23:19:24 +02003801 ret = send_unlink(sctx, valid_path);
3802 if (ret < 0)
3803 goto out;
3804 }
3805 }
3806
3807 /*
3808 * We did collect all parent dirs where cur_inode was once located. We
3809 * now go through all these dirs and check if they are pending for
3810 * deletion and if it's finally possible to perform the rmdir now.
3811 * We also update the inode stats of the parent dirs here.
3812 */
Josef Bacikba5e8f22013-08-16 16:52:55 -04003813 list_for_each_entry(cur, &check_dirs, list) {
Alexander Block766702e2012-07-28 14:11:31 +02003814 /*
3815 * In case we had refs into dirs that were not processed yet,
3816 * we don't need to do the utime and rmdir logic for these dirs.
3817 * The dir will be processed later.
3818 */
Josef Bacikba5e8f22013-08-16 16:52:55 -04003819 if (cur->dir > sctx->cur_ino)
Alexander Block31db9f72012-07-25 23:19:24 +02003820 continue;
3821
Josef Bacikba5e8f22013-08-16 16:52:55 -04003822 ret = get_cur_inode_state(sctx, cur->dir, cur->dir_gen);
Alexander Block31db9f72012-07-25 23:19:24 +02003823 if (ret < 0)
3824 goto out;
3825
3826 if (ret == inode_state_did_create ||
3827 ret == inode_state_no_change) {
3828 /* TODO delayed utimes */
Josef Bacikba5e8f22013-08-16 16:52:55 -04003829 ret = send_utimes(sctx, cur->dir, cur->dir_gen);
Alexander Block31db9f72012-07-25 23:19:24 +02003830 if (ret < 0)
3831 goto out;
Filipe Manana29d6d302014-02-16 21:01:39 +00003832 } else if (ret == inode_state_did_delete &&
3833 cur->dir != last_dir_ino_rm) {
Filipe Manana9dc44212014-02-19 14:31:44 +00003834 ret = can_rmdir(sctx, cur->dir, cur->dir_gen,
3835 sctx->cur_ino);
Alexander Block31db9f72012-07-25 23:19:24 +02003836 if (ret < 0)
3837 goto out;
3838 if (ret) {
Josef Bacikba5e8f22013-08-16 16:52:55 -04003839 ret = get_cur_path(sctx, cur->dir,
3840 cur->dir_gen, valid_path);
Alexander Block31db9f72012-07-25 23:19:24 +02003841 if (ret < 0)
3842 goto out;
3843 ret = send_rmdir(sctx, valid_path);
3844 if (ret < 0)
3845 goto out;
Filipe Manana29d6d302014-02-16 21:01:39 +00003846 last_dir_ino_rm = cur->dir;
Alexander Block31db9f72012-07-25 23:19:24 +02003847 }
3848 }
3849 }
3850
Alexander Block31db9f72012-07-25 23:19:24 +02003851 ret = 0;
3852
3853out:
Josef Bacikba5e8f22013-08-16 16:52:55 -04003854 __free_recorded_refs(&check_dirs);
Alexander Block31db9f72012-07-25 23:19:24 +02003855 free_recorded_refs(sctx);
Tsutomu Itoh924794c2013-05-08 07:51:52 +00003856 fs_path_free(valid_path);
Alexander Block31db9f72012-07-25 23:19:24 +02003857 return ret;
3858}
3859
Liu Boa4d96d62014-03-03 21:31:03 +08003860static int record_ref(struct btrfs_root *root, int num, u64 dir, int index,
3861 struct fs_path *name, void *ctx, struct list_head *refs)
Alexander Block31db9f72012-07-25 23:19:24 +02003862{
3863 int ret = 0;
3864 struct send_ctx *sctx = ctx;
3865 struct fs_path *p;
3866 u64 gen;
3867
Tsutomu Itoh924794c2013-05-08 07:51:52 +00003868 p = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +02003869 if (!p)
3870 return -ENOMEM;
3871
Liu Boa4d96d62014-03-03 21:31:03 +08003872 ret = get_inode_info(root, dir, NULL, &gen, NULL, NULL,
Alexander Block85a7b332012-07-26 23:39:10 +02003873 NULL, NULL);
Alexander Block31db9f72012-07-25 23:19:24 +02003874 if (ret < 0)
3875 goto out;
3876
Alexander Block31db9f72012-07-25 23:19:24 +02003877 ret = get_cur_path(sctx, dir, gen, p);
3878 if (ret < 0)
3879 goto out;
3880 ret = fs_path_add_path(p, name);
3881 if (ret < 0)
3882 goto out;
3883
Liu Boa4d96d62014-03-03 21:31:03 +08003884 ret = __record_ref(refs, dir, gen, p);
Alexander Block31db9f72012-07-25 23:19:24 +02003885
3886out:
3887 if (ret)
Tsutomu Itoh924794c2013-05-08 07:51:52 +00003888 fs_path_free(p);
Alexander Block31db9f72012-07-25 23:19:24 +02003889 return ret;
3890}
3891
Liu Boa4d96d62014-03-03 21:31:03 +08003892static int __record_new_ref(int num, u64 dir, int index,
3893 struct fs_path *name,
3894 void *ctx)
3895{
3896 struct send_ctx *sctx = ctx;
3897 return record_ref(sctx->send_root, num, dir, index, name,
3898 ctx, &sctx->new_refs);
3899}
3900
3901
Alexander Block31db9f72012-07-25 23:19:24 +02003902static int __record_deleted_ref(int num, u64 dir, int index,
3903 struct fs_path *name,
3904 void *ctx)
3905{
Alexander Block31db9f72012-07-25 23:19:24 +02003906 struct send_ctx *sctx = ctx;
Liu Boa4d96d62014-03-03 21:31:03 +08003907 return record_ref(sctx->parent_root, num, dir, index, name,
3908 ctx, &sctx->deleted_refs);
Alexander Block31db9f72012-07-25 23:19:24 +02003909}
3910
3911static int record_new_ref(struct send_ctx *sctx)
3912{
3913 int ret;
3914
Tsutomu Itoh924794c2013-05-08 07:51:52 +00003915 ret = iterate_inode_ref(sctx->send_root, sctx->left_path,
3916 sctx->cmp_key, 0, __record_new_ref, sctx);
Alexander Block31db9f72012-07-25 23:19:24 +02003917 if (ret < 0)
3918 goto out;
3919 ret = 0;
3920
3921out:
3922 return ret;
3923}
3924
3925static int record_deleted_ref(struct send_ctx *sctx)
3926{
3927 int ret;
3928
Tsutomu Itoh924794c2013-05-08 07:51:52 +00003929 ret = iterate_inode_ref(sctx->parent_root, sctx->right_path,
3930 sctx->cmp_key, 0, __record_deleted_ref, sctx);
Alexander Block31db9f72012-07-25 23:19:24 +02003931 if (ret < 0)
3932 goto out;
3933 ret = 0;
3934
3935out:
3936 return ret;
3937}
3938
3939struct find_ref_ctx {
3940 u64 dir;
Josef Bacikba5e8f22013-08-16 16:52:55 -04003941 u64 dir_gen;
3942 struct btrfs_root *root;
Alexander Block31db9f72012-07-25 23:19:24 +02003943 struct fs_path *name;
3944 int found_idx;
3945};
3946
3947static int __find_iref(int num, u64 dir, int index,
3948 struct fs_path *name,
3949 void *ctx_)
3950{
3951 struct find_ref_ctx *ctx = ctx_;
Josef Bacikba5e8f22013-08-16 16:52:55 -04003952 u64 dir_gen;
3953 int ret;
Alexander Block31db9f72012-07-25 23:19:24 +02003954
3955 if (dir == ctx->dir && fs_path_len(name) == fs_path_len(ctx->name) &&
3956 strncmp(name->start, ctx->name->start, fs_path_len(name)) == 0) {
Josef Bacikba5e8f22013-08-16 16:52:55 -04003957 /*
3958 * To avoid doing extra lookups we'll only do this if everything
3959 * else matches.
3960 */
3961 ret = get_inode_info(ctx->root, dir, NULL, &dir_gen, NULL,
3962 NULL, NULL, NULL);
3963 if (ret)
3964 return ret;
3965 if (dir_gen != ctx->dir_gen)
3966 return 0;
Alexander Block31db9f72012-07-25 23:19:24 +02003967 ctx->found_idx = num;
3968 return 1;
3969 }
3970 return 0;
3971}
3972
Tsutomu Itoh924794c2013-05-08 07:51:52 +00003973static int find_iref(struct btrfs_root *root,
Alexander Block31db9f72012-07-25 23:19:24 +02003974 struct btrfs_path *path,
3975 struct btrfs_key *key,
Josef Bacikba5e8f22013-08-16 16:52:55 -04003976 u64 dir, u64 dir_gen, struct fs_path *name)
Alexander Block31db9f72012-07-25 23:19:24 +02003977{
3978 int ret;
3979 struct find_ref_ctx ctx;
3980
3981 ctx.dir = dir;
3982 ctx.name = name;
Josef Bacikba5e8f22013-08-16 16:52:55 -04003983 ctx.dir_gen = dir_gen;
Alexander Block31db9f72012-07-25 23:19:24 +02003984 ctx.found_idx = -1;
Josef Bacikba5e8f22013-08-16 16:52:55 -04003985 ctx.root = root;
Alexander Block31db9f72012-07-25 23:19:24 +02003986
Tsutomu Itoh924794c2013-05-08 07:51:52 +00003987 ret = iterate_inode_ref(root, path, key, 0, __find_iref, &ctx);
Alexander Block31db9f72012-07-25 23:19:24 +02003988 if (ret < 0)
3989 return ret;
3990
3991 if (ctx.found_idx == -1)
3992 return -ENOENT;
3993
3994 return ctx.found_idx;
3995}
3996
3997static int __record_changed_new_ref(int num, u64 dir, int index,
3998 struct fs_path *name,
3999 void *ctx)
4000{
Josef Bacikba5e8f22013-08-16 16:52:55 -04004001 u64 dir_gen;
Alexander Block31db9f72012-07-25 23:19:24 +02004002 int ret;
4003 struct send_ctx *sctx = ctx;
4004
Josef Bacikba5e8f22013-08-16 16:52:55 -04004005 ret = get_inode_info(sctx->send_root, dir, NULL, &dir_gen, NULL,
4006 NULL, NULL, NULL);
4007 if (ret)
4008 return ret;
4009
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004010 ret = find_iref(sctx->parent_root, sctx->right_path,
Josef Bacikba5e8f22013-08-16 16:52:55 -04004011 sctx->cmp_key, dir, dir_gen, name);
Alexander Block31db9f72012-07-25 23:19:24 +02004012 if (ret == -ENOENT)
4013 ret = __record_new_ref(num, dir, index, name, sctx);
4014 else if (ret > 0)
4015 ret = 0;
4016
4017 return ret;
4018}
4019
4020static int __record_changed_deleted_ref(int num, u64 dir, int index,
4021 struct fs_path *name,
4022 void *ctx)
4023{
Josef Bacikba5e8f22013-08-16 16:52:55 -04004024 u64 dir_gen;
Alexander Block31db9f72012-07-25 23:19:24 +02004025 int ret;
4026 struct send_ctx *sctx = ctx;
4027
Josef Bacikba5e8f22013-08-16 16:52:55 -04004028 ret = get_inode_info(sctx->parent_root, dir, NULL, &dir_gen, NULL,
4029 NULL, NULL, NULL);
4030 if (ret)
4031 return ret;
4032
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004033 ret = find_iref(sctx->send_root, sctx->left_path, sctx->cmp_key,
Josef Bacikba5e8f22013-08-16 16:52:55 -04004034 dir, dir_gen, name);
Alexander Block31db9f72012-07-25 23:19:24 +02004035 if (ret == -ENOENT)
4036 ret = __record_deleted_ref(num, dir, index, name, sctx);
4037 else if (ret > 0)
4038 ret = 0;
4039
4040 return ret;
4041}
4042
4043static int record_changed_ref(struct send_ctx *sctx)
4044{
4045 int ret = 0;
4046
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004047 ret = iterate_inode_ref(sctx->send_root, sctx->left_path,
Alexander Block31db9f72012-07-25 23:19:24 +02004048 sctx->cmp_key, 0, __record_changed_new_ref, sctx);
4049 if (ret < 0)
4050 goto out;
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004051 ret = iterate_inode_ref(sctx->parent_root, sctx->right_path,
Alexander Block31db9f72012-07-25 23:19:24 +02004052 sctx->cmp_key, 0, __record_changed_deleted_ref, sctx);
4053 if (ret < 0)
4054 goto out;
4055 ret = 0;
4056
4057out:
4058 return ret;
4059}
4060
4061/*
4062 * Record and process all refs at once. Needed when an inode changes the
4063 * generation number, which means that it was deleted and recreated.
4064 */
4065static int process_all_refs(struct send_ctx *sctx,
4066 enum btrfs_compare_tree_result cmd)
4067{
4068 int ret;
4069 struct btrfs_root *root;
4070 struct btrfs_path *path;
4071 struct btrfs_key key;
4072 struct btrfs_key found_key;
4073 struct extent_buffer *eb;
4074 int slot;
4075 iterate_inode_ref_t cb;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00004076 int pending_move = 0;
Alexander Block31db9f72012-07-25 23:19:24 +02004077
4078 path = alloc_path_for_send();
4079 if (!path)
4080 return -ENOMEM;
4081
4082 if (cmd == BTRFS_COMPARE_TREE_NEW) {
4083 root = sctx->send_root;
4084 cb = __record_new_ref;
4085 } else if (cmd == BTRFS_COMPARE_TREE_DELETED) {
4086 root = sctx->parent_root;
4087 cb = __record_deleted_ref;
4088 } else {
David Sterba4d1a63b2014-02-03 19:24:19 +01004089 btrfs_err(sctx->send_root->fs_info,
4090 "Wrong command %d in process_all_refs", cmd);
4091 ret = -EINVAL;
4092 goto out;
Alexander Block31db9f72012-07-25 23:19:24 +02004093 }
4094
4095 key.objectid = sctx->cmp_key->objectid;
4096 key.type = BTRFS_INODE_REF_KEY;
4097 key.offset = 0;
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00004098 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
4099 if (ret < 0)
4100 goto out;
Alexander Block31db9f72012-07-25 23:19:24 +02004101
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00004102 while (1) {
Alexander Block31db9f72012-07-25 23:19:24 +02004103 eb = path->nodes[0];
4104 slot = path->slots[0];
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00004105 if (slot >= btrfs_header_nritems(eb)) {
4106 ret = btrfs_next_leaf(root, path);
4107 if (ret < 0)
4108 goto out;
4109 else if (ret > 0)
4110 break;
4111 continue;
4112 }
4113
Alexander Block31db9f72012-07-25 23:19:24 +02004114 btrfs_item_key_to_cpu(eb, &found_key, slot);
4115
4116 if (found_key.objectid != key.objectid ||
Jan Schmidt96b5bd72012-10-15 08:30:45 +00004117 (found_key.type != BTRFS_INODE_REF_KEY &&
4118 found_key.type != BTRFS_INODE_EXTREF_KEY))
Alexander Block31db9f72012-07-25 23:19:24 +02004119 break;
Alexander Block31db9f72012-07-25 23:19:24 +02004120
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004121 ret = iterate_inode_ref(root, path, &found_key, 0, cb, sctx);
Alexander Block31db9f72012-07-25 23:19:24 +02004122 if (ret < 0)
4123 goto out;
4124
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00004125 path->slots[0]++;
Alexander Block31db9f72012-07-25 23:19:24 +02004126 }
Alexander Blocke938c8a2012-07-28 16:33:49 +02004127 btrfs_release_path(path);
Alexander Block31db9f72012-07-25 23:19:24 +02004128
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00004129 ret = process_recorded_refs(sctx, &pending_move);
4130 /* Only applicable to an incremental send. */
4131 ASSERT(pending_move == 0);
Alexander Block31db9f72012-07-25 23:19:24 +02004132
4133out:
4134 btrfs_free_path(path);
4135 return ret;
4136}
4137
4138static int send_set_xattr(struct send_ctx *sctx,
4139 struct fs_path *path,
4140 const char *name, int name_len,
4141 const char *data, int data_len)
4142{
4143 int ret = 0;
4144
4145 ret = begin_cmd(sctx, BTRFS_SEND_C_SET_XATTR);
4146 if (ret < 0)
4147 goto out;
4148
4149 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, path);
4150 TLV_PUT_STRING(sctx, BTRFS_SEND_A_XATTR_NAME, name, name_len);
4151 TLV_PUT(sctx, BTRFS_SEND_A_XATTR_DATA, data, data_len);
4152
4153 ret = send_cmd(sctx);
4154
4155tlv_put_failure:
4156out:
4157 return ret;
4158}
4159
4160static int send_remove_xattr(struct send_ctx *sctx,
4161 struct fs_path *path,
4162 const char *name, int name_len)
4163{
4164 int ret = 0;
4165
4166 ret = begin_cmd(sctx, BTRFS_SEND_C_REMOVE_XATTR);
4167 if (ret < 0)
4168 goto out;
4169
4170 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, path);
4171 TLV_PUT_STRING(sctx, BTRFS_SEND_A_XATTR_NAME, name, name_len);
4172
4173 ret = send_cmd(sctx);
4174
4175tlv_put_failure:
4176out:
4177 return ret;
4178}
4179
4180static int __process_new_xattr(int num, struct btrfs_key *di_key,
4181 const char *name, int name_len,
4182 const char *data, int data_len,
4183 u8 type, void *ctx)
4184{
4185 int ret;
4186 struct send_ctx *sctx = ctx;
4187 struct fs_path *p;
4188 posix_acl_xattr_header dummy_acl;
4189
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004190 p = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +02004191 if (!p)
4192 return -ENOMEM;
4193
4194 /*
4195 * This hack is needed because empty acl's are stored as zero byte
4196 * data in xattrs. Problem with that is, that receiving these zero byte
4197 * acl's will fail later. To fix this, we send a dummy acl list that
4198 * only contains the version number and no entries.
4199 */
4200 if (!strncmp(name, XATTR_NAME_POSIX_ACL_ACCESS, name_len) ||
4201 !strncmp(name, XATTR_NAME_POSIX_ACL_DEFAULT, name_len)) {
4202 if (data_len == 0) {
4203 dummy_acl.a_version =
4204 cpu_to_le32(POSIX_ACL_XATTR_VERSION);
4205 data = (char *)&dummy_acl;
4206 data_len = sizeof(dummy_acl);
4207 }
4208 }
4209
4210 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
4211 if (ret < 0)
4212 goto out;
4213
4214 ret = send_set_xattr(sctx, p, name, name_len, data, data_len);
4215
4216out:
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004217 fs_path_free(p);
Alexander Block31db9f72012-07-25 23:19:24 +02004218 return ret;
4219}
4220
4221static int __process_deleted_xattr(int num, struct btrfs_key *di_key,
4222 const char *name, int name_len,
4223 const char *data, int data_len,
4224 u8 type, void *ctx)
4225{
4226 int ret;
4227 struct send_ctx *sctx = ctx;
4228 struct fs_path *p;
4229
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004230 p = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +02004231 if (!p)
4232 return -ENOMEM;
4233
4234 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
4235 if (ret < 0)
4236 goto out;
4237
4238 ret = send_remove_xattr(sctx, p, name, name_len);
4239
4240out:
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004241 fs_path_free(p);
Alexander Block31db9f72012-07-25 23:19:24 +02004242 return ret;
4243}
4244
4245static int process_new_xattr(struct send_ctx *sctx)
4246{
4247 int ret = 0;
4248
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004249 ret = iterate_dir_item(sctx->send_root, sctx->left_path,
4250 sctx->cmp_key, __process_new_xattr, sctx);
Alexander Block31db9f72012-07-25 23:19:24 +02004251
4252 return ret;
4253}
4254
4255static int process_deleted_xattr(struct send_ctx *sctx)
4256{
4257 int ret;
4258
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004259 ret = iterate_dir_item(sctx->parent_root, sctx->right_path,
4260 sctx->cmp_key, __process_deleted_xattr, sctx);
Alexander Block31db9f72012-07-25 23:19:24 +02004261
4262 return ret;
4263}
4264
4265struct find_xattr_ctx {
4266 const char *name;
4267 int name_len;
4268 int found_idx;
4269 char *found_data;
4270 int found_data_len;
4271};
4272
4273static int __find_xattr(int num, struct btrfs_key *di_key,
4274 const char *name, int name_len,
4275 const char *data, int data_len,
4276 u8 type, void *vctx)
4277{
4278 struct find_xattr_ctx *ctx = vctx;
4279
4280 if (name_len == ctx->name_len &&
4281 strncmp(name, ctx->name, name_len) == 0) {
4282 ctx->found_idx = num;
4283 ctx->found_data_len = data_len;
David Sterbae780b0d2016-01-18 18:42:13 +01004284 ctx->found_data = kmemdup(data, data_len, GFP_KERNEL);
Alexander Block31db9f72012-07-25 23:19:24 +02004285 if (!ctx->found_data)
4286 return -ENOMEM;
Alexander Block31db9f72012-07-25 23:19:24 +02004287 return 1;
4288 }
4289 return 0;
4290}
4291
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004292static int find_xattr(struct btrfs_root *root,
Alexander Block31db9f72012-07-25 23:19:24 +02004293 struct btrfs_path *path,
4294 struct btrfs_key *key,
4295 const char *name, int name_len,
4296 char **data, int *data_len)
4297{
4298 int ret;
4299 struct find_xattr_ctx ctx;
4300
4301 ctx.name = name;
4302 ctx.name_len = name_len;
4303 ctx.found_idx = -1;
4304 ctx.found_data = NULL;
4305 ctx.found_data_len = 0;
4306
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004307 ret = iterate_dir_item(root, path, key, __find_xattr, &ctx);
Alexander Block31db9f72012-07-25 23:19:24 +02004308 if (ret < 0)
4309 return ret;
4310
4311 if (ctx.found_idx == -1)
4312 return -ENOENT;
4313 if (data) {
4314 *data = ctx.found_data;
4315 *data_len = ctx.found_data_len;
4316 } else {
4317 kfree(ctx.found_data);
4318 }
4319 return ctx.found_idx;
4320}
4321
4322
4323static int __process_changed_new_xattr(int num, struct btrfs_key *di_key,
4324 const char *name, int name_len,
4325 const char *data, int data_len,
4326 u8 type, void *ctx)
4327{
4328 int ret;
4329 struct send_ctx *sctx = ctx;
4330 char *found_data = NULL;
4331 int found_data_len = 0;
Alexander Block31db9f72012-07-25 23:19:24 +02004332
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004333 ret = find_xattr(sctx->parent_root, sctx->right_path,
4334 sctx->cmp_key, name, name_len, &found_data,
4335 &found_data_len);
Alexander Block31db9f72012-07-25 23:19:24 +02004336 if (ret == -ENOENT) {
4337 ret = __process_new_xattr(num, di_key, name, name_len, data,
4338 data_len, type, ctx);
4339 } else if (ret >= 0) {
4340 if (data_len != found_data_len ||
4341 memcmp(data, found_data, data_len)) {
4342 ret = __process_new_xattr(num, di_key, name, name_len,
4343 data, data_len, type, ctx);
4344 } else {
4345 ret = 0;
4346 }
4347 }
4348
4349 kfree(found_data);
Alexander Block31db9f72012-07-25 23:19:24 +02004350 return ret;
4351}
4352
4353static int __process_changed_deleted_xattr(int num, struct btrfs_key *di_key,
4354 const char *name, int name_len,
4355 const char *data, int data_len,
4356 u8 type, void *ctx)
4357{
4358 int ret;
4359 struct send_ctx *sctx = ctx;
4360
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004361 ret = find_xattr(sctx->send_root, sctx->left_path, sctx->cmp_key,
4362 name, name_len, NULL, NULL);
Alexander Block31db9f72012-07-25 23:19:24 +02004363 if (ret == -ENOENT)
4364 ret = __process_deleted_xattr(num, di_key, name, name_len, data,
4365 data_len, type, ctx);
4366 else if (ret >= 0)
4367 ret = 0;
4368
4369 return ret;
4370}
4371
4372static int process_changed_xattr(struct send_ctx *sctx)
4373{
4374 int ret = 0;
4375
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004376 ret = iterate_dir_item(sctx->send_root, sctx->left_path,
Alexander Block31db9f72012-07-25 23:19:24 +02004377 sctx->cmp_key, __process_changed_new_xattr, sctx);
4378 if (ret < 0)
4379 goto out;
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004380 ret = iterate_dir_item(sctx->parent_root, sctx->right_path,
Alexander Block31db9f72012-07-25 23:19:24 +02004381 sctx->cmp_key, __process_changed_deleted_xattr, sctx);
4382
4383out:
4384 return ret;
4385}
4386
4387static int process_all_new_xattrs(struct send_ctx *sctx)
4388{
4389 int ret;
4390 struct btrfs_root *root;
4391 struct btrfs_path *path;
4392 struct btrfs_key key;
4393 struct btrfs_key found_key;
4394 struct extent_buffer *eb;
4395 int slot;
4396
4397 path = alloc_path_for_send();
4398 if (!path)
4399 return -ENOMEM;
4400
4401 root = sctx->send_root;
4402
4403 key.objectid = sctx->cmp_key->objectid;
4404 key.type = BTRFS_XATTR_ITEM_KEY;
4405 key.offset = 0;
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00004406 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
4407 if (ret < 0)
4408 goto out;
Alexander Block31db9f72012-07-25 23:19:24 +02004409
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00004410 while (1) {
Alexander Block31db9f72012-07-25 23:19:24 +02004411 eb = path->nodes[0];
4412 slot = path->slots[0];
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00004413 if (slot >= btrfs_header_nritems(eb)) {
4414 ret = btrfs_next_leaf(root, path);
4415 if (ret < 0) {
4416 goto out;
4417 } else if (ret > 0) {
4418 ret = 0;
4419 break;
4420 }
4421 continue;
4422 }
Alexander Block31db9f72012-07-25 23:19:24 +02004423
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00004424 btrfs_item_key_to_cpu(eb, &found_key, slot);
Alexander Block31db9f72012-07-25 23:19:24 +02004425 if (found_key.objectid != key.objectid ||
4426 found_key.type != key.type) {
4427 ret = 0;
4428 goto out;
4429 }
4430
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004431 ret = iterate_dir_item(root, path, &found_key,
4432 __process_new_xattr, sctx);
Alexander Block31db9f72012-07-25 23:19:24 +02004433 if (ret < 0)
4434 goto out;
4435
Filipe David Borba Mananadff6d0a2014-02-05 16:48:56 +00004436 path->slots[0]++;
Alexander Block31db9f72012-07-25 23:19:24 +02004437 }
4438
4439out:
4440 btrfs_free_path(path);
4441 return ret;
4442}
4443
Josef Baciked259092013-10-25 11:36:01 -04004444static ssize_t fill_read_buf(struct send_ctx *sctx, u64 offset, u32 len)
4445{
4446 struct btrfs_root *root = sctx->send_root;
4447 struct btrfs_fs_info *fs_info = root->fs_info;
4448 struct inode *inode;
4449 struct page *page;
4450 char *addr;
4451 struct btrfs_key key;
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03004452 pgoff_t index = offset >> PAGE_SHIFT;
Josef Baciked259092013-10-25 11:36:01 -04004453 pgoff_t last_index;
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03004454 unsigned pg_offset = offset & ~PAGE_MASK;
Josef Baciked259092013-10-25 11:36:01 -04004455 ssize_t ret = 0;
4456
4457 key.objectid = sctx->cur_ino;
4458 key.type = BTRFS_INODE_ITEM_KEY;
4459 key.offset = 0;
4460
4461 inode = btrfs_iget(fs_info->sb, &key, root, NULL);
4462 if (IS_ERR(inode))
4463 return PTR_ERR(inode);
4464
4465 if (offset + len > i_size_read(inode)) {
4466 if (offset > i_size_read(inode))
4467 len = 0;
4468 else
4469 len = offset - i_size_read(inode);
4470 }
4471 if (len == 0)
4472 goto out;
4473
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03004474 last_index = (offset + len - 1) >> PAGE_SHIFT;
Liu Bo2131bcd32014-03-05 10:07:35 +08004475
4476 /* initial readahead */
4477 memset(&sctx->ra, 0, sizeof(struct file_ra_state));
4478 file_ra_state_init(&sctx->ra, inode->i_mapping);
4479 btrfs_force_ra(inode->i_mapping, &sctx->ra, NULL, index,
4480 last_index - index + 1);
4481
Josef Baciked259092013-10-25 11:36:01 -04004482 while (index <= last_index) {
4483 unsigned cur_len = min_t(unsigned, len,
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03004484 PAGE_SIZE - pg_offset);
David Sterbae780b0d2016-01-18 18:42:13 +01004485 page = find_or_create_page(inode->i_mapping, index, GFP_KERNEL);
Josef Baciked259092013-10-25 11:36:01 -04004486 if (!page) {
4487 ret = -ENOMEM;
4488 break;
4489 }
4490
4491 if (!PageUptodate(page)) {
4492 btrfs_readpage(NULL, page);
4493 lock_page(page);
4494 if (!PageUptodate(page)) {
4495 unlock_page(page);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03004496 put_page(page);
Josef Baciked259092013-10-25 11:36:01 -04004497 ret = -EIO;
4498 break;
4499 }
4500 }
4501
4502 addr = kmap(page);
4503 memcpy(sctx->read_buf + ret, addr + pg_offset, cur_len);
4504 kunmap(page);
4505 unlock_page(page);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03004506 put_page(page);
Josef Baciked259092013-10-25 11:36:01 -04004507 index++;
4508 pg_offset = 0;
4509 len -= cur_len;
4510 ret += cur_len;
4511 }
4512out:
4513 iput(inode);
4514 return ret;
4515}
4516
Alexander Block31db9f72012-07-25 23:19:24 +02004517/*
4518 * Read some bytes from the current inode/file and send a write command to
4519 * user space.
4520 */
4521static int send_write(struct send_ctx *sctx, u64 offset, u32 len)
4522{
4523 int ret = 0;
4524 struct fs_path *p;
Josef Baciked259092013-10-25 11:36:01 -04004525 ssize_t num_read = 0;
Alexander Block31db9f72012-07-25 23:19:24 +02004526
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004527 p = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +02004528 if (!p)
4529 return -ENOMEM;
4530
Alexander Block31db9f72012-07-25 23:19:24 +02004531verbose_printk("btrfs: send_write offset=%llu, len=%d\n", offset, len);
4532
Josef Baciked259092013-10-25 11:36:01 -04004533 num_read = fill_read_buf(sctx, offset, len);
4534 if (num_read <= 0) {
4535 if (num_read < 0)
4536 ret = num_read;
Alexander Block31db9f72012-07-25 23:19:24 +02004537 goto out;
Josef Baciked259092013-10-25 11:36:01 -04004538 }
Alexander Block31db9f72012-07-25 23:19:24 +02004539
4540 ret = begin_cmd(sctx, BTRFS_SEND_C_WRITE);
4541 if (ret < 0)
4542 goto out;
4543
4544 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
4545 if (ret < 0)
4546 goto out;
4547
4548 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
4549 TLV_PUT_U64(sctx, BTRFS_SEND_A_FILE_OFFSET, offset);
Alexander Blocke938c8a2012-07-28 16:33:49 +02004550 TLV_PUT(sctx, BTRFS_SEND_A_DATA, sctx->read_buf, num_read);
Alexander Block31db9f72012-07-25 23:19:24 +02004551
4552 ret = send_cmd(sctx);
4553
4554tlv_put_failure:
4555out:
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004556 fs_path_free(p);
Alexander Block31db9f72012-07-25 23:19:24 +02004557 if (ret < 0)
4558 return ret;
Alexander Blocke938c8a2012-07-28 16:33:49 +02004559 return num_read;
Alexander Block31db9f72012-07-25 23:19:24 +02004560}
4561
4562/*
4563 * Send a clone command to user space.
4564 */
4565static int send_clone(struct send_ctx *sctx,
4566 u64 offset, u32 len,
4567 struct clone_root *clone_root)
4568{
4569 int ret = 0;
Alexander Block31db9f72012-07-25 23:19:24 +02004570 struct fs_path *p;
4571 u64 gen;
4572
4573verbose_printk("btrfs: send_clone offset=%llu, len=%d, clone_root=%llu, "
4574 "clone_inode=%llu, clone_offset=%llu\n", offset, len,
4575 clone_root->root->objectid, clone_root->ino,
4576 clone_root->offset);
4577
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004578 p = fs_path_alloc();
Alexander Block31db9f72012-07-25 23:19:24 +02004579 if (!p)
4580 return -ENOMEM;
4581
4582 ret = begin_cmd(sctx, BTRFS_SEND_C_CLONE);
4583 if (ret < 0)
4584 goto out;
4585
4586 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
4587 if (ret < 0)
4588 goto out;
4589
4590 TLV_PUT_U64(sctx, BTRFS_SEND_A_FILE_OFFSET, offset);
4591 TLV_PUT_U64(sctx, BTRFS_SEND_A_CLONE_LEN, len);
4592 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
4593
Alexander Blocke938c8a2012-07-28 16:33:49 +02004594 if (clone_root->root == sctx->send_root) {
Alexander Block31db9f72012-07-25 23:19:24 +02004595 ret = get_inode_info(sctx->send_root, clone_root->ino, NULL,
Alexander Block85a7b332012-07-26 23:39:10 +02004596 &gen, NULL, NULL, NULL, NULL);
Alexander Block31db9f72012-07-25 23:19:24 +02004597 if (ret < 0)
4598 goto out;
4599 ret = get_cur_path(sctx, clone_root->ino, gen, p);
4600 } else {
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004601 ret = get_inode_path(clone_root->root, clone_root->ino, p);
Alexander Block31db9f72012-07-25 23:19:24 +02004602 }
4603 if (ret < 0)
4604 goto out;
4605
Josef Bacik37b8d272015-06-04 17:17:25 -04004606 /*
4607 * If the parent we're using has a received_uuid set then use that as
4608 * our clone source as that is what we will look for when doing a
4609 * receive.
4610 *
4611 * This covers the case that we create a snapshot off of a received
4612 * subvolume and then use that as the parent and try to receive on a
4613 * different host.
4614 */
4615 if (!btrfs_is_empty_uuid(clone_root->root->root_item.received_uuid))
4616 TLV_PUT_UUID(sctx, BTRFS_SEND_A_CLONE_UUID,
4617 clone_root->root->root_item.received_uuid);
4618 else
4619 TLV_PUT_UUID(sctx, BTRFS_SEND_A_CLONE_UUID,
4620 clone_root->root->root_item.uuid);
Alexander Block31db9f72012-07-25 23:19:24 +02004621 TLV_PUT_U64(sctx, BTRFS_SEND_A_CLONE_CTRANSID,
Filipe David Borba Manana5a0f4e22013-12-03 15:55:48 +00004622 le64_to_cpu(clone_root->root->root_item.ctransid));
Alexander Block31db9f72012-07-25 23:19:24 +02004623 TLV_PUT_PATH(sctx, BTRFS_SEND_A_CLONE_PATH, p);
4624 TLV_PUT_U64(sctx, BTRFS_SEND_A_CLONE_OFFSET,
4625 clone_root->offset);
4626
4627 ret = send_cmd(sctx);
4628
4629tlv_put_failure:
4630out:
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004631 fs_path_free(p);
Alexander Block31db9f72012-07-25 23:19:24 +02004632 return ret;
4633}
4634
Mark Fashehcb95e7b2013-02-04 20:54:57 +00004635/*
4636 * Send an update extent command to user space.
4637 */
4638static int send_update_extent(struct send_ctx *sctx,
4639 u64 offset, u32 len)
4640{
4641 int ret = 0;
4642 struct fs_path *p;
4643
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004644 p = fs_path_alloc();
Mark Fashehcb95e7b2013-02-04 20:54:57 +00004645 if (!p)
4646 return -ENOMEM;
4647
4648 ret = begin_cmd(sctx, BTRFS_SEND_C_UPDATE_EXTENT);
4649 if (ret < 0)
4650 goto out;
4651
4652 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
4653 if (ret < 0)
4654 goto out;
4655
4656 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
4657 TLV_PUT_U64(sctx, BTRFS_SEND_A_FILE_OFFSET, offset);
4658 TLV_PUT_U64(sctx, BTRFS_SEND_A_SIZE, len);
4659
4660 ret = send_cmd(sctx);
4661
4662tlv_put_failure:
4663out:
Tsutomu Itoh924794c2013-05-08 07:51:52 +00004664 fs_path_free(p);
Mark Fashehcb95e7b2013-02-04 20:54:57 +00004665 return ret;
4666}
4667
Josef Bacik16e75492013-10-22 12:18:51 -04004668static int send_hole(struct send_ctx *sctx, u64 end)
4669{
4670 struct fs_path *p = NULL;
4671 u64 offset = sctx->cur_inode_last_extent;
4672 u64 len;
4673 int ret = 0;
4674
4675 p = fs_path_alloc();
4676 if (!p)
4677 return -ENOMEM;
Filipe Mananac715e152014-03-31 14:52:14 +01004678 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
4679 if (ret < 0)
4680 goto tlv_put_failure;
Josef Bacik16e75492013-10-22 12:18:51 -04004681 memset(sctx->read_buf, 0, BTRFS_SEND_READ_SIZE);
4682 while (offset < end) {
4683 len = min_t(u64, end - offset, BTRFS_SEND_READ_SIZE);
4684
4685 ret = begin_cmd(sctx, BTRFS_SEND_C_WRITE);
4686 if (ret < 0)
4687 break;
Josef Bacik16e75492013-10-22 12:18:51 -04004688 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
4689 TLV_PUT_U64(sctx, BTRFS_SEND_A_FILE_OFFSET, offset);
4690 TLV_PUT(sctx, BTRFS_SEND_A_DATA, sctx->read_buf, len);
4691 ret = send_cmd(sctx);
4692 if (ret < 0)
4693 break;
4694 offset += len;
4695 }
4696tlv_put_failure:
4697 fs_path_free(p);
4698 return ret;
4699}
4700
Filipe Mananad906d492015-10-02 10:47:34 +01004701static int send_extent_data(struct send_ctx *sctx,
4702 const u64 offset,
4703 const u64 len)
4704{
4705 u64 sent = 0;
4706
4707 if (sctx->flags & BTRFS_SEND_FLAG_NO_FILE_DATA)
4708 return send_update_extent(sctx, offset, len);
4709
4710 while (sent < len) {
4711 u64 size = len - sent;
4712 int ret;
4713
4714 if (size > BTRFS_SEND_READ_SIZE)
4715 size = BTRFS_SEND_READ_SIZE;
4716 ret = send_write(sctx, offset + sent, size);
4717 if (ret < 0)
4718 return ret;
4719 if (!ret)
4720 break;
4721 sent += ret;
4722 }
4723 return 0;
4724}
4725
4726static int clone_range(struct send_ctx *sctx,
4727 struct clone_root *clone_root,
4728 const u64 disk_byte,
4729 u64 data_offset,
4730 u64 offset,
4731 u64 len)
4732{
4733 struct btrfs_path *path;
4734 struct btrfs_key key;
4735 int ret;
4736
4737 path = alloc_path_for_send();
4738 if (!path)
4739 return -ENOMEM;
4740
4741 /*
4742 * We can't send a clone operation for the entire range if we find
4743 * extent items in the respective range in the source file that
4744 * refer to different extents or if we find holes.
4745 * So check for that and do a mix of clone and regular write/copy
4746 * operations if needed.
4747 *
4748 * Example:
4749 *
4750 * mkfs.btrfs -f /dev/sda
4751 * mount /dev/sda /mnt
4752 * xfs_io -f -c "pwrite -S 0xaa 0K 100K" /mnt/foo
4753 * cp --reflink=always /mnt/foo /mnt/bar
4754 * xfs_io -c "pwrite -S 0xbb 50K 50K" /mnt/foo
4755 * btrfs subvolume snapshot -r /mnt /mnt/snap
4756 *
4757 * If when we send the snapshot and we are processing file bar (which
4758 * has a higher inode number than foo) we blindly send a clone operation
4759 * for the [0, 100K[ range from foo to bar, the receiver ends up getting
4760 * a file bar that matches the content of file foo - iow, doesn't match
4761 * the content from bar in the original filesystem.
4762 */
4763 key.objectid = clone_root->ino;
4764 key.type = BTRFS_EXTENT_DATA_KEY;
4765 key.offset = clone_root->offset;
4766 ret = btrfs_search_slot(NULL, clone_root->root, &key, path, 0, 0);
4767 if (ret < 0)
4768 goto out;
4769 if (ret > 0 && path->slots[0] > 0) {
4770 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0] - 1);
4771 if (key.objectid == clone_root->ino &&
4772 key.type == BTRFS_EXTENT_DATA_KEY)
4773 path->slots[0]--;
4774 }
4775
4776 while (true) {
4777 struct extent_buffer *leaf = path->nodes[0];
4778 int slot = path->slots[0];
4779 struct btrfs_file_extent_item *ei;
4780 u8 type;
4781 u64 ext_len;
4782 u64 clone_len;
4783
4784 if (slot >= btrfs_header_nritems(leaf)) {
4785 ret = btrfs_next_leaf(clone_root->root, path);
4786 if (ret < 0)
4787 goto out;
4788 else if (ret > 0)
4789 break;
4790 continue;
4791 }
4792
4793 btrfs_item_key_to_cpu(leaf, &key, slot);
4794
4795 /*
4796 * We might have an implicit trailing hole (NO_HOLES feature
4797 * enabled). We deal with it after leaving this loop.
4798 */
4799 if (key.objectid != clone_root->ino ||
4800 key.type != BTRFS_EXTENT_DATA_KEY)
4801 break;
4802
4803 ei = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
4804 type = btrfs_file_extent_type(leaf, ei);
4805 if (type == BTRFS_FILE_EXTENT_INLINE) {
4806 ext_len = btrfs_file_extent_inline_len(leaf, slot, ei);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03004807 ext_len = PAGE_ALIGN(ext_len);
Filipe Mananad906d492015-10-02 10:47:34 +01004808 } else {
4809 ext_len = btrfs_file_extent_num_bytes(leaf, ei);
4810 }
4811
4812 if (key.offset + ext_len <= clone_root->offset)
4813 goto next;
4814
4815 if (key.offset > clone_root->offset) {
4816 /* Implicit hole, NO_HOLES feature enabled. */
4817 u64 hole_len = key.offset - clone_root->offset;
4818
4819 if (hole_len > len)
4820 hole_len = len;
4821 ret = send_extent_data(sctx, offset, hole_len);
4822 if (ret < 0)
4823 goto out;
4824
4825 len -= hole_len;
4826 if (len == 0)
4827 break;
4828 offset += hole_len;
4829 clone_root->offset += hole_len;
4830 data_offset += hole_len;
4831 }
4832
4833 if (key.offset >= clone_root->offset + len)
4834 break;
4835
4836 clone_len = min_t(u64, ext_len, len);
4837
4838 if (btrfs_file_extent_disk_bytenr(leaf, ei) == disk_byte &&
4839 btrfs_file_extent_offset(leaf, ei) == data_offset)
4840 ret = send_clone(sctx, offset, clone_len, clone_root);
4841 else
4842 ret = send_extent_data(sctx, offset, clone_len);
4843
4844 if (ret < 0)
4845 goto out;
4846
4847 len -= clone_len;
4848 if (len == 0)
4849 break;
4850 offset += clone_len;
4851 clone_root->offset += clone_len;
4852 data_offset += clone_len;
4853next:
4854 path->slots[0]++;
4855 }
4856
4857 if (len > 0)
4858 ret = send_extent_data(sctx, offset, len);
4859 else
4860 ret = 0;
4861out:
4862 btrfs_free_path(path);
4863 return ret;
4864}
4865
Alexander Block31db9f72012-07-25 23:19:24 +02004866static int send_write_or_clone(struct send_ctx *sctx,
4867 struct btrfs_path *path,
4868 struct btrfs_key *key,
4869 struct clone_root *clone_root)
4870{
4871 int ret = 0;
4872 struct btrfs_file_extent_item *ei;
4873 u64 offset = key->offset;
Alexander Block31db9f72012-07-25 23:19:24 +02004874 u64 len;
Alexander Block31db9f72012-07-25 23:19:24 +02004875 u8 type;
Filipe David Borba Manana28e5dd82014-01-12 02:26:28 +00004876 u64 bs = sctx->send_root->fs_info->sb->s_blocksize;
Alexander Block31db9f72012-07-25 23:19:24 +02004877
4878 ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
4879 struct btrfs_file_extent_item);
4880 type = btrfs_file_extent_type(path->nodes[0], ei);
Chris Mason74dd17f2012-08-07 16:25:13 -04004881 if (type == BTRFS_FILE_EXTENT_INLINE) {
Chris Mason514ac8a2014-01-03 21:07:00 -08004882 len = btrfs_file_extent_inline_len(path->nodes[0],
4883 path->slots[0], ei);
Chris Mason74dd17f2012-08-07 16:25:13 -04004884 /*
4885 * it is possible the inline item won't cover the whole page,
4886 * but there may be items after this page. Make
4887 * sure to send the whole thing
4888 */
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03004889 len = PAGE_ALIGN(len);
Chris Mason74dd17f2012-08-07 16:25:13 -04004890 } else {
Alexander Block31db9f72012-07-25 23:19:24 +02004891 len = btrfs_file_extent_num_bytes(path->nodes[0], ei);
Chris Mason74dd17f2012-08-07 16:25:13 -04004892 }
Alexander Block31db9f72012-07-25 23:19:24 +02004893
4894 if (offset + len > sctx->cur_inode_size)
4895 len = sctx->cur_inode_size - offset;
4896 if (len == 0) {
4897 ret = 0;
4898 goto out;
4899 }
4900
Filipe David Borba Manana28e5dd82014-01-12 02:26:28 +00004901 if (clone_root && IS_ALIGNED(offset + len, bs)) {
Filipe Mananad906d492015-10-02 10:47:34 +01004902 u64 disk_byte;
4903 u64 data_offset;
4904
4905 disk_byte = btrfs_file_extent_disk_bytenr(path->nodes[0], ei);
4906 data_offset = btrfs_file_extent_offset(path->nodes[0], ei);
4907 ret = clone_range(sctx, clone_root, disk_byte, data_offset,
4908 offset, len);
Mark Fashehcb95e7b2013-02-04 20:54:57 +00004909 } else {
Filipe Mananad906d492015-10-02 10:47:34 +01004910 ret = send_extent_data(sctx, offset, len);
Alexander Block31db9f72012-07-25 23:19:24 +02004911 }
Alexander Block31db9f72012-07-25 23:19:24 +02004912out:
4913 return ret;
4914}
4915
4916static int is_extent_unchanged(struct send_ctx *sctx,
4917 struct btrfs_path *left_path,
4918 struct btrfs_key *ekey)
4919{
4920 int ret = 0;
4921 struct btrfs_key key;
4922 struct btrfs_path *path = NULL;
4923 struct extent_buffer *eb;
4924 int slot;
4925 struct btrfs_key found_key;
4926 struct btrfs_file_extent_item *ei;
4927 u64 left_disknr;
4928 u64 right_disknr;
4929 u64 left_offset;
4930 u64 right_offset;
4931 u64 left_offset_fixed;
4932 u64 left_len;
4933 u64 right_len;
Chris Mason74dd17f2012-08-07 16:25:13 -04004934 u64 left_gen;
4935 u64 right_gen;
Alexander Block31db9f72012-07-25 23:19:24 +02004936 u8 left_type;
4937 u8 right_type;
4938
4939 path = alloc_path_for_send();
4940 if (!path)
4941 return -ENOMEM;
4942
4943 eb = left_path->nodes[0];
4944 slot = left_path->slots[0];
Alexander Block31db9f72012-07-25 23:19:24 +02004945 ei = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
4946 left_type = btrfs_file_extent_type(eb, ei);
Alexander Block31db9f72012-07-25 23:19:24 +02004947
4948 if (left_type != BTRFS_FILE_EXTENT_REG) {
4949 ret = 0;
4950 goto out;
4951 }
Chris Mason74dd17f2012-08-07 16:25:13 -04004952 left_disknr = btrfs_file_extent_disk_bytenr(eb, ei);
4953 left_len = btrfs_file_extent_num_bytes(eb, ei);
4954 left_offset = btrfs_file_extent_offset(eb, ei);
4955 left_gen = btrfs_file_extent_generation(eb, ei);
Alexander Block31db9f72012-07-25 23:19:24 +02004956
4957 /*
4958 * Following comments will refer to these graphics. L is the left
4959 * extents which we are checking at the moment. 1-8 are the right
4960 * extents that we iterate.
4961 *
4962 * |-----L-----|
4963 * |-1-|-2a-|-3-|-4-|-5-|-6-|
4964 *
4965 * |-----L-----|
4966 * |--1--|-2b-|...(same as above)
4967 *
4968 * Alternative situation. Happens on files where extents got split.
4969 * |-----L-----|
4970 * |-----------7-----------|-6-|
4971 *
4972 * Alternative situation. Happens on files which got larger.
4973 * |-----L-----|
4974 * |-8-|
4975 * Nothing follows after 8.
4976 */
4977
4978 key.objectid = ekey->objectid;
4979 key.type = BTRFS_EXTENT_DATA_KEY;
4980 key.offset = ekey->offset;
4981 ret = btrfs_search_slot_for_read(sctx->parent_root, &key, path, 0, 0);
4982 if (ret < 0)
4983 goto out;
4984 if (ret) {
4985 ret = 0;
4986 goto out;
4987 }
4988
4989 /*
4990 * Handle special case where the right side has no extents at all.
4991 */
4992 eb = path->nodes[0];
4993 slot = path->slots[0];
4994 btrfs_item_key_to_cpu(eb, &found_key, slot);
4995 if (found_key.objectid != key.objectid ||
4996 found_key.type != key.type) {
Josef Bacik57cfd462013-08-20 15:55:39 -04004997 /* If we're a hole then just pretend nothing changed */
4998 ret = (left_disknr) ? 0 : 1;
Alexander Block31db9f72012-07-25 23:19:24 +02004999 goto out;
5000 }
5001
5002 /*
5003 * We're now on 2a, 2b or 7.
5004 */
5005 key = found_key;
5006 while (key.offset < ekey->offset + left_len) {
5007 ei = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
5008 right_type = btrfs_file_extent_type(eb, ei);
Alexander Block31db9f72012-07-25 23:19:24 +02005009 if (right_type != BTRFS_FILE_EXTENT_REG) {
5010 ret = 0;
5011 goto out;
5012 }
5013
Josef Bacik007d31f2013-10-31 16:49:02 -04005014 right_disknr = btrfs_file_extent_disk_bytenr(eb, ei);
5015 right_len = btrfs_file_extent_num_bytes(eb, ei);
5016 right_offset = btrfs_file_extent_offset(eb, ei);
5017 right_gen = btrfs_file_extent_generation(eb, ei);
5018
Alexander Block31db9f72012-07-25 23:19:24 +02005019 /*
5020 * Are we at extent 8? If yes, we know the extent is changed.
5021 * This may only happen on the first iteration.
5022 */
Alexander Blockd8347fa2012-08-01 12:49:15 +02005023 if (found_key.offset + right_len <= ekey->offset) {
Josef Bacik57cfd462013-08-20 15:55:39 -04005024 /* If we're a hole just pretend nothing changed */
5025 ret = (left_disknr) ? 0 : 1;
Alexander Block31db9f72012-07-25 23:19:24 +02005026 goto out;
5027 }
5028
5029 left_offset_fixed = left_offset;
5030 if (key.offset < ekey->offset) {
5031 /* Fix the right offset for 2a and 7. */
5032 right_offset += ekey->offset - key.offset;
5033 } else {
5034 /* Fix the left offset for all behind 2a and 2b */
5035 left_offset_fixed += key.offset - ekey->offset;
5036 }
5037
5038 /*
5039 * Check if we have the same extent.
5040 */
Alexander Block39540962012-08-01 12:46:05 +02005041 if (left_disknr != right_disknr ||
Chris Mason74dd17f2012-08-07 16:25:13 -04005042 left_offset_fixed != right_offset ||
5043 left_gen != right_gen) {
Alexander Block31db9f72012-07-25 23:19:24 +02005044 ret = 0;
5045 goto out;
5046 }
5047
5048 /*
5049 * Go to the next extent.
5050 */
5051 ret = btrfs_next_item(sctx->parent_root, path);
5052 if (ret < 0)
5053 goto out;
5054 if (!ret) {
5055 eb = path->nodes[0];
5056 slot = path->slots[0];
5057 btrfs_item_key_to_cpu(eb, &found_key, slot);
5058 }
5059 if (ret || found_key.objectid != key.objectid ||
5060 found_key.type != key.type) {
5061 key.offset += right_len;
5062 break;
Jan Schmidtadaa4b82013-03-21 14:30:23 +00005063 }
5064 if (found_key.offset != key.offset + right_len) {
5065 ret = 0;
5066 goto out;
Alexander Block31db9f72012-07-25 23:19:24 +02005067 }
5068 key = found_key;
5069 }
5070
5071 /*
5072 * We're now behind the left extent (treat as unchanged) or at the end
5073 * of the right side (treat as changed).
5074 */
5075 if (key.offset >= ekey->offset + left_len)
5076 ret = 1;
5077 else
5078 ret = 0;
5079
5080
5081out:
5082 btrfs_free_path(path);
5083 return ret;
5084}
5085
Josef Bacik16e75492013-10-22 12:18:51 -04005086static int get_last_extent(struct send_ctx *sctx, u64 offset)
5087{
5088 struct btrfs_path *path;
5089 struct btrfs_root *root = sctx->send_root;
5090 struct btrfs_file_extent_item *fi;
5091 struct btrfs_key key;
5092 u64 extent_end;
5093 u8 type;
5094 int ret;
5095
5096 path = alloc_path_for_send();
5097 if (!path)
5098 return -ENOMEM;
5099
5100 sctx->cur_inode_last_extent = 0;
5101
5102 key.objectid = sctx->cur_ino;
5103 key.type = BTRFS_EXTENT_DATA_KEY;
5104 key.offset = offset;
5105 ret = btrfs_search_slot_for_read(root, &key, path, 0, 1);
5106 if (ret < 0)
5107 goto out;
5108 ret = 0;
5109 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
5110 if (key.objectid != sctx->cur_ino || key.type != BTRFS_EXTENT_DATA_KEY)
5111 goto out;
5112
5113 fi = btrfs_item_ptr(path->nodes[0], path->slots[0],
5114 struct btrfs_file_extent_item);
5115 type = btrfs_file_extent_type(path->nodes[0], fi);
5116 if (type == BTRFS_FILE_EXTENT_INLINE) {
Chris Mason514ac8a2014-01-03 21:07:00 -08005117 u64 size = btrfs_file_extent_inline_len(path->nodes[0],
5118 path->slots[0], fi);
Josef Bacik16e75492013-10-22 12:18:51 -04005119 extent_end = ALIGN(key.offset + size,
5120 sctx->send_root->sectorsize);
5121 } else {
5122 extent_end = key.offset +
5123 btrfs_file_extent_num_bytes(path->nodes[0], fi);
5124 }
5125 sctx->cur_inode_last_extent = extent_end;
5126out:
5127 btrfs_free_path(path);
5128 return ret;
5129}
5130
5131static int maybe_send_hole(struct send_ctx *sctx, struct btrfs_path *path,
5132 struct btrfs_key *key)
5133{
5134 struct btrfs_file_extent_item *fi;
5135 u64 extent_end;
5136 u8 type;
5137 int ret = 0;
5138
5139 if (sctx->cur_ino != key->objectid || !need_send_hole(sctx))
5140 return 0;
5141
5142 if (sctx->cur_inode_last_extent == (u64)-1) {
5143 ret = get_last_extent(sctx, key->offset - 1);
5144 if (ret)
5145 return ret;
5146 }
5147
5148 fi = btrfs_item_ptr(path->nodes[0], path->slots[0],
5149 struct btrfs_file_extent_item);
5150 type = btrfs_file_extent_type(path->nodes[0], fi);
5151 if (type == BTRFS_FILE_EXTENT_INLINE) {
Chris Mason514ac8a2014-01-03 21:07:00 -08005152 u64 size = btrfs_file_extent_inline_len(path->nodes[0],
5153 path->slots[0], fi);
Josef Bacik16e75492013-10-22 12:18:51 -04005154 extent_end = ALIGN(key->offset + size,
5155 sctx->send_root->sectorsize);
5156 } else {
5157 extent_end = key->offset +
5158 btrfs_file_extent_num_bytes(path->nodes[0], fi);
5159 }
Filipe David Borba Mananabf54f412014-01-28 01:38:06 +00005160
5161 if (path->slots[0] == 0 &&
5162 sctx->cur_inode_last_extent < key->offset) {
5163 /*
5164 * We might have skipped entire leafs that contained only
5165 * file extent items for our current inode. These leafs have
5166 * a generation number smaller (older) than the one in the
5167 * current leaf and the leaf our last extent came from, and
5168 * are located between these 2 leafs.
5169 */
5170 ret = get_last_extent(sctx, key->offset - 1);
5171 if (ret)
5172 return ret;
5173 }
5174
Josef Bacik16e75492013-10-22 12:18:51 -04005175 if (sctx->cur_inode_last_extent < key->offset)
5176 ret = send_hole(sctx, key->offset);
5177 sctx->cur_inode_last_extent = extent_end;
5178 return ret;
5179}
5180
Alexander Block31db9f72012-07-25 23:19:24 +02005181static int process_extent(struct send_ctx *sctx,
5182 struct btrfs_path *path,
5183 struct btrfs_key *key)
5184{
Alexander Block31db9f72012-07-25 23:19:24 +02005185 struct clone_root *found_clone = NULL;
Josef Bacik57cfd462013-08-20 15:55:39 -04005186 int ret = 0;
Alexander Block31db9f72012-07-25 23:19:24 +02005187
5188 if (S_ISLNK(sctx->cur_inode_mode))
5189 return 0;
5190
5191 if (sctx->parent_root && !sctx->cur_inode_new) {
5192 ret = is_extent_unchanged(sctx, path, key);
5193 if (ret < 0)
5194 goto out;
5195 if (ret) {
5196 ret = 0;
Josef Bacik16e75492013-10-22 12:18:51 -04005197 goto out_hole;
Alexander Block31db9f72012-07-25 23:19:24 +02005198 }
Josef Bacik57cfd462013-08-20 15:55:39 -04005199 } else {
5200 struct btrfs_file_extent_item *ei;
5201 u8 type;
5202
5203 ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
5204 struct btrfs_file_extent_item);
5205 type = btrfs_file_extent_type(path->nodes[0], ei);
5206 if (type == BTRFS_FILE_EXTENT_PREALLOC ||
5207 type == BTRFS_FILE_EXTENT_REG) {
5208 /*
5209 * The send spec does not have a prealloc command yet,
5210 * so just leave a hole for prealloc'ed extents until
5211 * we have enough commands queued up to justify rev'ing
5212 * the send spec.
5213 */
5214 if (type == BTRFS_FILE_EXTENT_PREALLOC) {
5215 ret = 0;
5216 goto out;
5217 }
5218
5219 /* Have a hole, just skip it. */
5220 if (btrfs_file_extent_disk_bytenr(path->nodes[0], ei) == 0) {
5221 ret = 0;
5222 goto out;
5223 }
5224 }
Alexander Block31db9f72012-07-25 23:19:24 +02005225 }
5226
5227 ret = find_extent_clone(sctx, path, key->objectid, key->offset,
5228 sctx->cur_inode_size, &found_clone);
5229 if (ret != -ENOENT && ret < 0)
5230 goto out;
5231
5232 ret = send_write_or_clone(sctx, path, key, found_clone);
Josef Bacik16e75492013-10-22 12:18:51 -04005233 if (ret)
5234 goto out;
5235out_hole:
5236 ret = maybe_send_hole(sctx, path, key);
Alexander Block31db9f72012-07-25 23:19:24 +02005237out:
5238 return ret;
5239}
5240
5241static int process_all_extents(struct send_ctx *sctx)
5242{
5243 int ret;
5244 struct btrfs_root *root;
5245 struct btrfs_path *path;
5246 struct btrfs_key key;
5247 struct btrfs_key found_key;
5248 struct extent_buffer *eb;
5249 int slot;
5250
5251 root = sctx->send_root;
5252 path = alloc_path_for_send();
5253 if (!path)
5254 return -ENOMEM;
5255
5256 key.objectid = sctx->cmp_key->objectid;
5257 key.type = BTRFS_EXTENT_DATA_KEY;
5258 key.offset = 0;
Filipe David Borba Manana7fdd29d2014-01-24 17:42:09 +00005259 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5260 if (ret < 0)
5261 goto out;
Alexander Block31db9f72012-07-25 23:19:24 +02005262
Filipe David Borba Manana7fdd29d2014-01-24 17:42:09 +00005263 while (1) {
Alexander Block31db9f72012-07-25 23:19:24 +02005264 eb = path->nodes[0];
5265 slot = path->slots[0];
Filipe David Borba Manana7fdd29d2014-01-24 17:42:09 +00005266
5267 if (slot >= btrfs_header_nritems(eb)) {
5268 ret = btrfs_next_leaf(root, path);
5269 if (ret < 0) {
5270 goto out;
5271 } else if (ret > 0) {
5272 ret = 0;
5273 break;
5274 }
5275 continue;
5276 }
5277
Alexander Block31db9f72012-07-25 23:19:24 +02005278 btrfs_item_key_to_cpu(eb, &found_key, slot);
5279
5280 if (found_key.objectid != key.objectid ||
5281 found_key.type != key.type) {
5282 ret = 0;
5283 goto out;
5284 }
5285
5286 ret = process_extent(sctx, path, &found_key);
5287 if (ret < 0)
5288 goto out;
5289
Filipe David Borba Manana7fdd29d2014-01-24 17:42:09 +00005290 path->slots[0]++;
Alexander Block31db9f72012-07-25 23:19:24 +02005291 }
5292
5293out:
5294 btrfs_free_path(path);
5295 return ret;
5296}
5297
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00005298static int process_recorded_refs_if_needed(struct send_ctx *sctx, int at_end,
5299 int *pending_move,
5300 int *refs_processed)
Alexander Block31db9f72012-07-25 23:19:24 +02005301{
5302 int ret = 0;
5303
5304 if (sctx->cur_ino == 0)
5305 goto out;
5306 if (!at_end && sctx->cur_ino == sctx->cmp_key->objectid &&
Jan Schmidt96b5bd72012-10-15 08:30:45 +00005307 sctx->cmp_key->type <= BTRFS_INODE_EXTREF_KEY)
Alexander Block31db9f72012-07-25 23:19:24 +02005308 goto out;
5309 if (list_empty(&sctx->new_refs) && list_empty(&sctx->deleted_refs))
5310 goto out;
5311
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00005312 ret = process_recorded_refs(sctx, pending_move);
Alexander Blocke479d9b2012-07-28 16:09:35 +02005313 if (ret < 0)
5314 goto out;
5315
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00005316 *refs_processed = 1;
Alexander Block31db9f72012-07-25 23:19:24 +02005317out:
5318 return ret;
5319}
5320
5321static int finish_inode_if_needed(struct send_ctx *sctx, int at_end)
5322{
5323 int ret = 0;
5324 u64 left_mode;
5325 u64 left_uid;
5326 u64 left_gid;
5327 u64 right_mode;
5328 u64 right_uid;
5329 u64 right_gid;
5330 int need_chmod = 0;
5331 int need_chown = 0;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00005332 int pending_move = 0;
5333 int refs_processed = 0;
Alexander Block31db9f72012-07-25 23:19:24 +02005334
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00005335 ret = process_recorded_refs_if_needed(sctx, at_end, &pending_move,
5336 &refs_processed);
Alexander Block31db9f72012-07-25 23:19:24 +02005337 if (ret < 0)
5338 goto out;
5339
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00005340 /*
5341 * We have processed the refs and thus need to advance send_progress.
5342 * Now, calls to get_cur_xxx will take the updated refs of the current
5343 * inode into account.
5344 *
5345 * On the other hand, if our current inode is a directory and couldn't
5346 * be moved/renamed because its parent was renamed/moved too and it has
5347 * a higher inode number, we can only move/rename our current inode
5348 * after we moved/renamed its parent. Therefore in this case operate on
5349 * the old path (pre move/rename) of our current inode, and the
5350 * move/rename will be performed later.
5351 */
5352 if (refs_processed && !pending_move)
5353 sctx->send_progress = sctx->cur_ino + 1;
5354
Alexander Block31db9f72012-07-25 23:19:24 +02005355 if (sctx->cur_ino == 0 || sctx->cur_inode_deleted)
5356 goto out;
5357 if (!at_end && sctx->cmp_key->objectid == sctx->cur_ino)
5358 goto out;
5359
5360 ret = get_inode_info(sctx->send_root, sctx->cur_ino, NULL, NULL,
Alexander Block85a7b332012-07-26 23:39:10 +02005361 &left_mode, &left_uid, &left_gid, NULL);
Alexander Block31db9f72012-07-25 23:19:24 +02005362 if (ret < 0)
5363 goto out;
5364
Alex Lyakase2d044f2012-10-17 13:52:47 +00005365 if (!sctx->parent_root || sctx->cur_inode_new) {
5366 need_chown = 1;
5367 if (!S_ISLNK(sctx->cur_inode_mode))
Alexander Block31db9f72012-07-25 23:19:24 +02005368 need_chmod = 1;
Alex Lyakase2d044f2012-10-17 13:52:47 +00005369 } else {
5370 ret = get_inode_info(sctx->parent_root, sctx->cur_ino,
5371 NULL, NULL, &right_mode, &right_uid,
5372 &right_gid, NULL);
5373 if (ret < 0)
5374 goto out;
Alexander Block31db9f72012-07-25 23:19:24 +02005375
Alex Lyakase2d044f2012-10-17 13:52:47 +00005376 if (left_uid != right_uid || left_gid != right_gid)
5377 need_chown = 1;
5378 if (!S_ISLNK(sctx->cur_inode_mode) && left_mode != right_mode)
5379 need_chmod = 1;
Alexander Block31db9f72012-07-25 23:19:24 +02005380 }
5381
5382 if (S_ISREG(sctx->cur_inode_mode)) {
Josef Bacik16e75492013-10-22 12:18:51 -04005383 if (need_send_hole(sctx)) {
Filipe Manana766b5e52014-03-30 23:02:53 +01005384 if (sctx->cur_inode_last_extent == (u64)-1 ||
5385 sctx->cur_inode_last_extent <
5386 sctx->cur_inode_size) {
Josef Bacik16e75492013-10-22 12:18:51 -04005387 ret = get_last_extent(sctx, (u64)-1);
5388 if (ret)
5389 goto out;
5390 }
5391 if (sctx->cur_inode_last_extent <
5392 sctx->cur_inode_size) {
5393 ret = send_hole(sctx, sctx->cur_inode_size);
5394 if (ret)
5395 goto out;
5396 }
5397 }
Alexander Block31db9f72012-07-25 23:19:24 +02005398 ret = send_truncate(sctx, sctx->cur_ino, sctx->cur_inode_gen,
5399 sctx->cur_inode_size);
5400 if (ret < 0)
5401 goto out;
5402 }
5403
5404 if (need_chown) {
5405 ret = send_chown(sctx, sctx->cur_ino, sctx->cur_inode_gen,
5406 left_uid, left_gid);
5407 if (ret < 0)
5408 goto out;
5409 }
5410 if (need_chmod) {
5411 ret = send_chmod(sctx, sctx->cur_ino, sctx->cur_inode_gen,
5412 left_mode);
5413 if (ret < 0)
5414 goto out;
5415 }
5416
5417 /*
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00005418 * If other directory inodes depended on our current directory
5419 * inode's move/rename, now do their move/rename operations.
Alexander Block31db9f72012-07-25 23:19:24 +02005420 */
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00005421 if (!is_waiting_for_move(sctx, sctx->cur_ino)) {
5422 ret = apply_children_dir_moves(sctx);
5423 if (ret)
5424 goto out;
Filipe Mananafcbd2152014-03-03 12:28:40 +00005425 /*
5426 * Need to send that every time, no matter if it actually
5427 * changed between the two trees as we have done changes to
5428 * the inode before. If our inode is a directory and it's
5429 * waiting to be moved/renamed, we will send its utimes when
5430 * it's moved/renamed, therefore we don't need to do it here.
5431 */
5432 sctx->send_progress = sctx->cur_ino + 1;
5433 ret = send_utimes(sctx, sctx->cur_ino, sctx->cur_inode_gen);
5434 if (ret < 0)
5435 goto out;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00005436 }
5437
Alexander Block31db9f72012-07-25 23:19:24 +02005438out:
5439 return ret;
5440}
5441
5442static int changed_inode(struct send_ctx *sctx,
5443 enum btrfs_compare_tree_result result)
5444{
5445 int ret = 0;
5446 struct btrfs_key *key = sctx->cmp_key;
5447 struct btrfs_inode_item *left_ii = NULL;
5448 struct btrfs_inode_item *right_ii = NULL;
5449 u64 left_gen = 0;
5450 u64 right_gen = 0;
5451
Alexander Block31db9f72012-07-25 23:19:24 +02005452 sctx->cur_ino = key->objectid;
5453 sctx->cur_inode_new_gen = 0;
Josef Bacik16e75492013-10-22 12:18:51 -04005454 sctx->cur_inode_last_extent = (u64)-1;
Alexander Blocke479d9b2012-07-28 16:09:35 +02005455
5456 /*
5457 * Set send_progress to current inode. This will tell all get_cur_xxx
5458 * functions that the current inode's refs are not updated yet. Later,
5459 * when process_recorded_refs is finished, it is set to cur_ino + 1.
5460 */
Alexander Block31db9f72012-07-25 23:19:24 +02005461 sctx->send_progress = sctx->cur_ino;
5462
5463 if (result == BTRFS_COMPARE_TREE_NEW ||
5464 result == BTRFS_COMPARE_TREE_CHANGED) {
5465 left_ii = btrfs_item_ptr(sctx->left_path->nodes[0],
5466 sctx->left_path->slots[0],
5467 struct btrfs_inode_item);
5468 left_gen = btrfs_inode_generation(sctx->left_path->nodes[0],
5469 left_ii);
5470 } else {
5471 right_ii = btrfs_item_ptr(sctx->right_path->nodes[0],
5472 sctx->right_path->slots[0],
5473 struct btrfs_inode_item);
5474 right_gen = btrfs_inode_generation(sctx->right_path->nodes[0],
5475 right_ii);
5476 }
5477 if (result == BTRFS_COMPARE_TREE_CHANGED) {
5478 right_ii = btrfs_item_ptr(sctx->right_path->nodes[0],
5479 sctx->right_path->slots[0],
5480 struct btrfs_inode_item);
5481
5482 right_gen = btrfs_inode_generation(sctx->right_path->nodes[0],
5483 right_ii);
Alexander Block6d85ed02012-08-01 14:48:59 +02005484
5485 /*
5486 * The cur_ino = root dir case is special here. We can't treat
5487 * the inode as deleted+reused because it would generate a
5488 * stream that tries to delete/mkdir the root dir.
5489 */
5490 if (left_gen != right_gen &&
5491 sctx->cur_ino != BTRFS_FIRST_FREE_OBJECTID)
Alexander Block31db9f72012-07-25 23:19:24 +02005492 sctx->cur_inode_new_gen = 1;
5493 }
5494
5495 if (result == BTRFS_COMPARE_TREE_NEW) {
5496 sctx->cur_inode_gen = left_gen;
5497 sctx->cur_inode_new = 1;
5498 sctx->cur_inode_deleted = 0;
5499 sctx->cur_inode_size = btrfs_inode_size(
5500 sctx->left_path->nodes[0], left_ii);
5501 sctx->cur_inode_mode = btrfs_inode_mode(
5502 sctx->left_path->nodes[0], left_ii);
Liu Bo644d1942014-02-27 17:29:01 +08005503 sctx->cur_inode_rdev = btrfs_inode_rdev(
5504 sctx->left_path->nodes[0], left_ii);
Alexander Block31db9f72012-07-25 23:19:24 +02005505 if (sctx->cur_ino != BTRFS_FIRST_FREE_OBJECTID)
Alexander Block1f4692d2012-07-28 10:42:24 +02005506 ret = send_create_inode_if_needed(sctx);
Alexander Block31db9f72012-07-25 23:19:24 +02005507 } else if (result == BTRFS_COMPARE_TREE_DELETED) {
5508 sctx->cur_inode_gen = right_gen;
5509 sctx->cur_inode_new = 0;
5510 sctx->cur_inode_deleted = 1;
5511 sctx->cur_inode_size = btrfs_inode_size(
5512 sctx->right_path->nodes[0], right_ii);
5513 sctx->cur_inode_mode = btrfs_inode_mode(
5514 sctx->right_path->nodes[0], right_ii);
5515 } else if (result == BTRFS_COMPARE_TREE_CHANGED) {
Alexander Block766702e2012-07-28 14:11:31 +02005516 /*
5517 * We need to do some special handling in case the inode was
5518 * reported as changed with a changed generation number. This
5519 * means that the original inode was deleted and new inode
5520 * reused the same inum. So we have to treat the old inode as
5521 * deleted and the new one as new.
5522 */
Alexander Block31db9f72012-07-25 23:19:24 +02005523 if (sctx->cur_inode_new_gen) {
Alexander Block766702e2012-07-28 14:11:31 +02005524 /*
5525 * First, process the inode as if it was deleted.
5526 */
Alexander Block31db9f72012-07-25 23:19:24 +02005527 sctx->cur_inode_gen = right_gen;
5528 sctx->cur_inode_new = 0;
5529 sctx->cur_inode_deleted = 1;
5530 sctx->cur_inode_size = btrfs_inode_size(
5531 sctx->right_path->nodes[0], right_ii);
5532 sctx->cur_inode_mode = btrfs_inode_mode(
5533 sctx->right_path->nodes[0], right_ii);
5534 ret = process_all_refs(sctx,
5535 BTRFS_COMPARE_TREE_DELETED);
5536 if (ret < 0)
5537 goto out;
5538
Alexander Block766702e2012-07-28 14:11:31 +02005539 /*
5540 * Now process the inode as if it was new.
5541 */
Alexander Block31db9f72012-07-25 23:19:24 +02005542 sctx->cur_inode_gen = left_gen;
5543 sctx->cur_inode_new = 1;
5544 sctx->cur_inode_deleted = 0;
5545 sctx->cur_inode_size = btrfs_inode_size(
5546 sctx->left_path->nodes[0], left_ii);
5547 sctx->cur_inode_mode = btrfs_inode_mode(
5548 sctx->left_path->nodes[0], left_ii);
Liu Bo644d1942014-02-27 17:29:01 +08005549 sctx->cur_inode_rdev = btrfs_inode_rdev(
5550 sctx->left_path->nodes[0], left_ii);
Alexander Block1f4692d2012-07-28 10:42:24 +02005551 ret = send_create_inode_if_needed(sctx);
Alexander Block31db9f72012-07-25 23:19:24 +02005552 if (ret < 0)
5553 goto out;
5554
5555 ret = process_all_refs(sctx, BTRFS_COMPARE_TREE_NEW);
5556 if (ret < 0)
5557 goto out;
Alexander Blocke479d9b2012-07-28 16:09:35 +02005558 /*
5559 * Advance send_progress now as we did not get into
5560 * process_recorded_refs_if_needed in the new_gen case.
5561 */
5562 sctx->send_progress = sctx->cur_ino + 1;
Alexander Block766702e2012-07-28 14:11:31 +02005563
5564 /*
5565 * Now process all extents and xattrs of the inode as if
5566 * they were all new.
5567 */
Alexander Block31db9f72012-07-25 23:19:24 +02005568 ret = process_all_extents(sctx);
5569 if (ret < 0)
5570 goto out;
5571 ret = process_all_new_xattrs(sctx);
5572 if (ret < 0)
5573 goto out;
5574 } else {
5575 sctx->cur_inode_gen = left_gen;
5576 sctx->cur_inode_new = 0;
5577 sctx->cur_inode_new_gen = 0;
5578 sctx->cur_inode_deleted = 0;
5579 sctx->cur_inode_size = btrfs_inode_size(
5580 sctx->left_path->nodes[0], left_ii);
5581 sctx->cur_inode_mode = btrfs_inode_mode(
5582 sctx->left_path->nodes[0], left_ii);
5583 }
5584 }
5585
5586out:
5587 return ret;
5588}
5589
Alexander Block766702e2012-07-28 14:11:31 +02005590/*
5591 * We have to process new refs before deleted refs, but compare_trees gives us
5592 * the new and deleted refs mixed. To fix this, we record the new/deleted refs
5593 * first and later process them in process_recorded_refs.
5594 * For the cur_inode_new_gen case, we skip recording completely because
5595 * changed_inode did already initiate processing of refs. The reason for this is
5596 * that in this case, compare_tree actually compares the refs of 2 different
5597 * inodes. To fix this, process_all_refs is used in changed_inode to handle all
5598 * refs of the right tree as deleted and all refs of the left tree as new.
5599 */
Alexander Block31db9f72012-07-25 23:19:24 +02005600static int changed_ref(struct send_ctx *sctx,
5601 enum btrfs_compare_tree_result result)
5602{
5603 int ret = 0;
5604
5605 BUG_ON(sctx->cur_ino != sctx->cmp_key->objectid);
5606
5607 if (!sctx->cur_inode_new_gen &&
5608 sctx->cur_ino != BTRFS_FIRST_FREE_OBJECTID) {
5609 if (result == BTRFS_COMPARE_TREE_NEW)
5610 ret = record_new_ref(sctx);
5611 else if (result == BTRFS_COMPARE_TREE_DELETED)
5612 ret = record_deleted_ref(sctx);
5613 else if (result == BTRFS_COMPARE_TREE_CHANGED)
5614 ret = record_changed_ref(sctx);
5615 }
5616
5617 return ret;
5618}
5619
Alexander Block766702e2012-07-28 14:11:31 +02005620/*
5621 * Process new/deleted/changed xattrs. We skip processing in the
5622 * cur_inode_new_gen case because changed_inode did already initiate processing
5623 * of xattrs. The reason is the same as in changed_ref
5624 */
Alexander Block31db9f72012-07-25 23:19:24 +02005625static int changed_xattr(struct send_ctx *sctx,
5626 enum btrfs_compare_tree_result result)
5627{
5628 int ret = 0;
5629
5630 BUG_ON(sctx->cur_ino != sctx->cmp_key->objectid);
5631
5632 if (!sctx->cur_inode_new_gen && !sctx->cur_inode_deleted) {
5633 if (result == BTRFS_COMPARE_TREE_NEW)
5634 ret = process_new_xattr(sctx);
5635 else if (result == BTRFS_COMPARE_TREE_DELETED)
5636 ret = process_deleted_xattr(sctx);
5637 else if (result == BTRFS_COMPARE_TREE_CHANGED)
5638 ret = process_changed_xattr(sctx);
5639 }
5640
5641 return ret;
5642}
5643
Alexander Block766702e2012-07-28 14:11:31 +02005644/*
5645 * Process new/deleted/changed extents. We skip processing in the
5646 * cur_inode_new_gen case because changed_inode did already initiate processing
5647 * of extents. The reason is the same as in changed_ref
5648 */
Alexander Block31db9f72012-07-25 23:19:24 +02005649static int changed_extent(struct send_ctx *sctx,
5650 enum btrfs_compare_tree_result result)
5651{
5652 int ret = 0;
5653
5654 BUG_ON(sctx->cur_ino != sctx->cmp_key->objectid);
5655
5656 if (!sctx->cur_inode_new_gen && !sctx->cur_inode_deleted) {
5657 if (result != BTRFS_COMPARE_TREE_DELETED)
5658 ret = process_extent(sctx, sctx->left_path,
5659 sctx->cmp_key);
5660 }
5661
5662 return ret;
5663}
5664
Josef Bacikba5e8f22013-08-16 16:52:55 -04005665static int dir_changed(struct send_ctx *sctx, u64 dir)
5666{
5667 u64 orig_gen, new_gen;
5668 int ret;
5669
5670 ret = get_inode_info(sctx->send_root, dir, NULL, &new_gen, NULL, NULL,
5671 NULL, NULL);
5672 if (ret)
5673 return ret;
5674
5675 ret = get_inode_info(sctx->parent_root, dir, NULL, &orig_gen, NULL,
5676 NULL, NULL, NULL);
5677 if (ret)
5678 return ret;
5679
5680 return (orig_gen != new_gen) ? 1 : 0;
5681}
5682
5683static int compare_refs(struct send_ctx *sctx, struct btrfs_path *path,
5684 struct btrfs_key *key)
5685{
5686 struct btrfs_inode_extref *extref;
5687 struct extent_buffer *leaf;
5688 u64 dirid = 0, last_dirid = 0;
5689 unsigned long ptr;
5690 u32 item_size;
5691 u32 cur_offset = 0;
5692 int ref_name_len;
5693 int ret = 0;
5694
5695 /* Easy case, just check this one dirid */
5696 if (key->type == BTRFS_INODE_REF_KEY) {
5697 dirid = key->offset;
5698
5699 ret = dir_changed(sctx, dirid);
5700 goto out;
5701 }
5702
5703 leaf = path->nodes[0];
5704 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
5705 ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
5706 while (cur_offset < item_size) {
5707 extref = (struct btrfs_inode_extref *)(ptr +
5708 cur_offset);
5709 dirid = btrfs_inode_extref_parent(leaf, extref);
5710 ref_name_len = btrfs_inode_extref_name_len(leaf, extref);
5711 cur_offset += ref_name_len + sizeof(*extref);
5712 if (dirid == last_dirid)
5713 continue;
5714 ret = dir_changed(sctx, dirid);
5715 if (ret)
5716 break;
5717 last_dirid = dirid;
5718 }
5719out:
5720 return ret;
5721}
5722
Alexander Block766702e2012-07-28 14:11:31 +02005723/*
5724 * Updates compare related fields in sctx and simply forwards to the actual
5725 * changed_xxx functions.
5726 */
Alexander Block31db9f72012-07-25 23:19:24 +02005727static int changed_cb(struct btrfs_root *left_root,
5728 struct btrfs_root *right_root,
5729 struct btrfs_path *left_path,
5730 struct btrfs_path *right_path,
5731 struct btrfs_key *key,
5732 enum btrfs_compare_tree_result result,
5733 void *ctx)
5734{
5735 int ret = 0;
5736 struct send_ctx *sctx = ctx;
5737
Josef Bacikba5e8f22013-08-16 16:52:55 -04005738 if (result == BTRFS_COMPARE_TREE_SAME) {
Josef Bacik16e75492013-10-22 12:18:51 -04005739 if (key->type == BTRFS_INODE_REF_KEY ||
5740 key->type == BTRFS_INODE_EXTREF_KEY) {
5741 ret = compare_refs(sctx, left_path, key);
5742 if (!ret)
5743 return 0;
5744 if (ret < 0)
5745 return ret;
5746 } else if (key->type == BTRFS_EXTENT_DATA_KEY) {
5747 return maybe_send_hole(sctx, left_path, key);
5748 } else {
Josef Bacikba5e8f22013-08-16 16:52:55 -04005749 return 0;
Josef Bacik16e75492013-10-22 12:18:51 -04005750 }
Josef Bacikba5e8f22013-08-16 16:52:55 -04005751 result = BTRFS_COMPARE_TREE_CHANGED;
5752 ret = 0;
5753 }
5754
Alexander Block31db9f72012-07-25 23:19:24 +02005755 sctx->left_path = left_path;
5756 sctx->right_path = right_path;
5757 sctx->cmp_key = key;
5758
5759 ret = finish_inode_if_needed(sctx, 0);
5760 if (ret < 0)
5761 goto out;
5762
Alexander Block2981e222012-08-01 14:47:03 +02005763 /* Ignore non-FS objects */
5764 if (key->objectid == BTRFS_FREE_INO_OBJECTID ||
5765 key->objectid == BTRFS_FREE_SPACE_OBJECTID)
5766 goto out;
5767
Alexander Block31db9f72012-07-25 23:19:24 +02005768 if (key->type == BTRFS_INODE_ITEM_KEY)
5769 ret = changed_inode(sctx, result);
Jan Schmidt96b5bd72012-10-15 08:30:45 +00005770 else if (key->type == BTRFS_INODE_REF_KEY ||
5771 key->type == BTRFS_INODE_EXTREF_KEY)
Alexander Block31db9f72012-07-25 23:19:24 +02005772 ret = changed_ref(sctx, result);
5773 else if (key->type == BTRFS_XATTR_ITEM_KEY)
5774 ret = changed_xattr(sctx, result);
5775 else if (key->type == BTRFS_EXTENT_DATA_KEY)
5776 ret = changed_extent(sctx, result);
5777
5778out:
5779 return ret;
5780}
5781
5782static int full_send_tree(struct send_ctx *sctx)
5783{
5784 int ret;
Alexander Block31db9f72012-07-25 23:19:24 +02005785 struct btrfs_root *send_root = sctx->send_root;
5786 struct btrfs_key key;
5787 struct btrfs_key found_key;
5788 struct btrfs_path *path;
5789 struct extent_buffer *eb;
5790 int slot;
Alexander Block31db9f72012-07-25 23:19:24 +02005791
5792 path = alloc_path_for_send();
5793 if (!path)
5794 return -ENOMEM;
5795
Alexander Block31db9f72012-07-25 23:19:24 +02005796 key.objectid = BTRFS_FIRST_FREE_OBJECTID;
5797 key.type = BTRFS_INODE_ITEM_KEY;
5798 key.offset = 0;
5799
Alexander Block31db9f72012-07-25 23:19:24 +02005800 ret = btrfs_search_slot_for_read(send_root, &key, path, 1, 0);
5801 if (ret < 0)
5802 goto out;
5803 if (ret)
5804 goto out_finish;
5805
5806 while (1) {
Alexander Block31db9f72012-07-25 23:19:24 +02005807 eb = path->nodes[0];
5808 slot = path->slots[0];
5809 btrfs_item_key_to_cpu(eb, &found_key, slot);
5810
5811 ret = changed_cb(send_root, NULL, path, NULL,
5812 &found_key, BTRFS_COMPARE_TREE_NEW, sctx);
5813 if (ret < 0)
5814 goto out;
5815
5816 key.objectid = found_key.objectid;
5817 key.type = found_key.type;
5818 key.offset = found_key.offset + 1;
5819
5820 ret = btrfs_next_item(send_root, path);
5821 if (ret < 0)
5822 goto out;
5823 if (ret) {
5824 ret = 0;
5825 break;
5826 }
5827 }
5828
5829out_finish:
5830 ret = finish_inode_if_needed(sctx, 1);
5831
5832out:
5833 btrfs_free_path(path);
Alexander Block31db9f72012-07-25 23:19:24 +02005834 return ret;
5835}
5836
5837static int send_subvol(struct send_ctx *sctx)
5838{
5839 int ret;
5840
Stefan Behrensc2c71322013-04-10 17:10:52 +00005841 if (!(sctx->flags & BTRFS_SEND_FLAG_OMIT_STREAM_HEADER)) {
5842 ret = send_header(sctx);
5843 if (ret < 0)
5844 goto out;
5845 }
Alexander Block31db9f72012-07-25 23:19:24 +02005846
5847 ret = send_subvol_begin(sctx);
5848 if (ret < 0)
5849 goto out;
5850
5851 if (sctx->parent_root) {
5852 ret = btrfs_compare_trees(sctx->send_root, sctx->parent_root,
5853 changed_cb, sctx);
5854 if (ret < 0)
5855 goto out;
5856 ret = finish_inode_if_needed(sctx, 1);
5857 if (ret < 0)
5858 goto out;
5859 } else {
5860 ret = full_send_tree(sctx);
5861 if (ret < 0)
5862 goto out;
5863 }
5864
5865out:
Alexander Block31db9f72012-07-25 23:19:24 +02005866 free_recorded_refs(sctx);
5867 return ret;
5868}
5869
Filipe Mananae5fa8f82014-10-21 11:11:41 +01005870/*
5871 * If orphan cleanup did remove any orphans from a root, it means the tree
5872 * was modified and therefore the commit root is not the same as the current
5873 * root anymore. This is a problem, because send uses the commit root and
5874 * therefore can see inode items that don't exist in the current root anymore,
5875 * and for example make calls to btrfs_iget, which will do tree lookups based
5876 * on the current root and not on the commit root. Those lookups will fail,
5877 * returning a -ESTALE error, and making send fail with that error. So make
5878 * sure a send does not see any orphans we have just removed, and that it will
5879 * see the same inodes regardless of whether a transaction commit happened
5880 * before it started (meaning that the commit root will be the same as the
5881 * current root) or not.
5882 */
5883static int ensure_commit_roots_uptodate(struct send_ctx *sctx)
5884{
5885 int i;
5886 struct btrfs_trans_handle *trans = NULL;
5887
5888again:
5889 if (sctx->parent_root &&
5890 sctx->parent_root->node != sctx->parent_root->commit_root)
5891 goto commit_trans;
5892
5893 for (i = 0; i < sctx->clone_roots_cnt; i++)
5894 if (sctx->clone_roots[i].root->node !=
5895 sctx->clone_roots[i].root->commit_root)
5896 goto commit_trans;
5897
5898 if (trans)
5899 return btrfs_end_transaction(trans, sctx->send_root);
5900
5901 return 0;
5902
5903commit_trans:
5904 /* Use any root, all fs roots will get their commit roots updated. */
5905 if (!trans) {
5906 trans = btrfs_join_transaction(sctx->send_root);
5907 if (IS_ERR(trans))
5908 return PTR_ERR(trans);
5909 goto again;
5910 }
5911
5912 return btrfs_commit_transaction(trans, sctx->send_root);
5913}
5914
David Sterba66ef7d62013-12-17 15:07:20 +01005915static void btrfs_root_dec_send_in_progress(struct btrfs_root* root)
5916{
5917 spin_lock(&root->root_item_lock);
5918 root->send_in_progress--;
5919 /*
5920 * Not much left to do, we don't know why it's unbalanced and
5921 * can't blindly reset it to 0.
5922 */
5923 if (root->send_in_progress < 0)
5924 btrfs_err(root->fs_info,
David Sterba351fd352014-05-15 16:48:20 +02005925 "send_in_progres unbalanced %d root %llu",
David Sterba66ef7d62013-12-17 15:07:20 +01005926 root->send_in_progress, root->root_key.objectid);
5927 spin_unlock(&root->root_item_lock);
5928}
5929
Alexander Block31db9f72012-07-25 23:19:24 +02005930long btrfs_ioctl_send(struct file *mnt_file, void __user *arg_)
5931{
5932 int ret = 0;
5933 struct btrfs_root *send_root;
5934 struct btrfs_root *clone_root;
5935 struct btrfs_fs_info *fs_info;
5936 struct btrfs_ioctl_send_args *arg = NULL;
5937 struct btrfs_key key;
Alexander Block31db9f72012-07-25 23:19:24 +02005938 struct send_ctx *sctx = NULL;
5939 u32 i;
5940 u64 *clone_sources_tmp = NULL;
David Sterba2c686532013-12-16 17:34:17 +01005941 int clone_sources_to_rollback = 0;
David Sterbae55d1152016-04-11 18:52:02 +02005942 unsigned alloc_size;
Wang Shilong896c14f2014-01-07 17:25:18 +08005943 int sort_clone_roots = 0;
Wang Shilong18f687d2014-01-07 17:25:19 +08005944 int index;
Alexander Block31db9f72012-07-25 23:19:24 +02005945
5946 if (!capable(CAP_SYS_ADMIN))
5947 return -EPERM;
5948
Al Viro496ad9a2013-01-23 17:07:38 -05005949 send_root = BTRFS_I(file_inode(mnt_file))->root;
Alexander Block31db9f72012-07-25 23:19:24 +02005950 fs_info = send_root->fs_info;
5951
Josef Bacik139f8072013-05-20 11:26:50 -04005952 /*
David Sterba2c686532013-12-16 17:34:17 +01005953 * The subvolume must remain read-only during send, protect against
David Sterba521e0542014-04-15 16:41:44 +02005954 * making it RW. This also protects against deletion.
David Sterba2c686532013-12-16 17:34:17 +01005955 */
5956 spin_lock(&send_root->root_item_lock);
5957 send_root->send_in_progress++;
5958 spin_unlock(&send_root->root_item_lock);
5959
5960 /*
Josef Bacik139f8072013-05-20 11:26:50 -04005961 * This is done when we lookup the root, it should already be complete
5962 * by the time we get here.
5963 */
5964 WARN_ON(send_root->orphan_cleanup_state != ORPHAN_CLEANUP_DONE);
5965
5966 /*
David Sterba2c686532013-12-16 17:34:17 +01005967 * Userspace tools do the checks and warn the user if it's
5968 * not RO.
5969 */
5970 if (!btrfs_root_readonly(send_root)) {
5971 ret = -EPERM;
5972 goto out;
5973 }
5974
Alexander Block31db9f72012-07-25 23:19:24 +02005975 arg = memdup_user(arg_, sizeof(*arg));
5976 if (IS_ERR(arg)) {
5977 ret = PTR_ERR(arg);
5978 arg = NULL;
5979 goto out;
5980 }
5981
Dan Carpenterf5ecec32016-04-13 09:40:59 +03005982 if (arg->clone_sources_count >
5983 ULLONG_MAX / sizeof(*arg->clone_sources)) {
5984 ret = -EINVAL;
5985 goto out;
5986 }
5987
Alexander Block31db9f72012-07-25 23:19:24 +02005988 if (!access_ok(VERIFY_READ, arg->clone_sources,
Dan Carpenter700ff4f2013-01-10 03:57:25 -05005989 sizeof(*arg->clone_sources) *
5990 arg->clone_sources_count)) {
Alexander Block31db9f72012-07-25 23:19:24 +02005991 ret = -EFAULT;
5992 goto out;
5993 }
5994
Stefan Behrensc2c71322013-04-10 17:10:52 +00005995 if (arg->flags & ~BTRFS_SEND_FLAG_MASK) {
Mark Fashehcb95e7b2013-02-04 20:54:57 +00005996 ret = -EINVAL;
5997 goto out;
5998 }
5999
David Sterbae780b0d2016-01-18 18:42:13 +01006000 sctx = kzalloc(sizeof(struct send_ctx), GFP_KERNEL);
Alexander Block31db9f72012-07-25 23:19:24 +02006001 if (!sctx) {
6002 ret = -ENOMEM;
6003 goto out;
6004 }
6005
6006 INIT_LIST_HEAD(&sctx->new_refs);
6007 INIT_LIST_HEAD(&sctx->deleted_refs);
David Sterbae780b0d2016-01-18 18:42:13 +01006008 INIT_RADIX_TREE(&sctx->name_cache, GFP_KERNEL);
Alexander Block31db9f72012-07-25 23:19:24 +02006009 INIT_LIST_HEAD(&sctx->name_cache_list);
6010
Mark Fashehcb95e7b2013-02-04 20:54:57 +00006011 sctx->flags = arg->flags;
6012
Alexander Block31db9f72012-07-25 23:19:24 +02006013 sctx->send_filp = fget(arg->send_fd);
Tsutomu Itohecc7ada2013-04-19 01:04:46 +00006014 if (!sctx->send_filp) {
6015 ret = -EBADF;
Alexander Block31db9f72012-07-25 23:19:24 +02006016 goto out;
6017 }
6018
Alexander Block31db9f72012-07-25 23:19:24 +02006019 sctx->send_root = send_root;
David Sterba521e0542014-04-15 16:41:44 +02006020 /*
6021 * Unlikely but possible, if the subvolume is marked for deletion but
6022 * is slow to remove the directory entry, send can still be started
6023 */
6024 if (btrfs_root_dead(sctx->send_root)) {
6025 ret = -EPERM;
6026 goto out;
6027 }
6028
Alexander Block31db9f72012-07-25 23:19:24 +02006029 sctx->clone_roots_cnt = arg->clone_sources_count;
6030
6031 sctx->send_max_size = BTRFS_SEND_BUF_SIZE;
David Sterba6ff48ce2016-04-11 18:40:08 +02006032 sctx->send_buf = kmalloc(sctx->send_max_size, GFP_KERNEL | __GFP_NOWARN);
Alexander Block31db9f72012-07-25 23:19:24 +02006033 if (!sctx->send_buf) {
David Sterba6ff48ce2016-04-11 18:40:08 +02006034 sctx->send_buf = vmalloc(sctx->send_max_size);
6035 if (!sctx->send_buf) {
6036 ret = -ENOMEM;
6037 goto out;
6038 }
Alexander Block31db9f72012-07-25 23:19:24 +02006039 }
6040
David Sterbaeb5b75f2016-04-11 18:40:08 +02006041 sctx->read_buf = kmalloc(BTRFS_SEND_READ_SIZE, GFP_KERNEL | __GFP_NOWARN);
Alexander Block31db9f72012-07-25 23:19:24 +02006042 if (!sctx->read_buf) {
David Sterbaeb5b75f2016-04-11 18:40:08 +02006043 sctx->read_buf = vmalloc(BTRFS_SEND_READ_SIZE);
6044 if (!sctx->read_buf) {
6045 ret = -ENOMEM;
6046 goto out;
6047 }
Alexander Block31db9f72012-07-25 23:19:24 +02006048 }
6049
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00006050 sctx->pending_dir_moves = RB_ROOT;
6051 sctx->waiting_dir_moves = RB_ROOT;
Filipe Manana9dc44212014-02-19 14:31:44 +00006052 sctx->orphan_dirs = RB_ROOT;
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00006053
David Sterbae55d1152016-04-11 18:52:02 +02006054 alloc_size = sizeof(struct clone_root) * (arg->clone_sources_count + 1);
6055
David Sterbac03d01f2016-04-11 18:40:08 +02006056 sctx->clone_roots = kzalloc(alloc_size, GFP_KERNEL | __GFP_NOWARN);
Alexander Block31db9f72012-07-25 23:19:24 +02006057 if (!sctx->clone_roots) {
David Sterbac03d01f2016-04-11 18:40:08 +02006058 sctx->clone_roots = vzalloc(alloc_size);
6059 if (!sctx->clone_roots) {
6060 ret = -ENOMEM;
6061 goto out;
6062 }
Alexander Block31db9f72012-07-25 23:19:24 +02006063 }
6064
David Sterbae55d1152016-04-11 18:52:02 +02006065 alloc_size = arg->clone_sources_count * sizeof(*arg->clone_sources);
6066
Alexander Block31db9f72012-07-25 23:19:24 +02006067 if (arg->clone_sources_count) {
David Sterba2f913062016-04-11 18:40:08 +02006068 clone_sources_tmp = kmalloc(alloc_size, GFP_KERNEL | __GFP_NOWARN);
Alexander Block31db9f72012-07-25 23:19:24 +02006069 if (!clone_sources_tmp) {
David Sterba2f913062016-04-11 18:40:08 +02006070 clone_sources_tmp = vmalloc(alloc_size);
6071 if (!clone_sources_tmp) {
6072 ret = -ENOMEM;
6073 goto out;
6074 }
Alexander Block31db9f72012-07-25 23:19:24 +02006075 }
6076
6077 ret = copy_from_user(clone_sources_tmp, arg->clone_sources,
David Sterbae55d1152016-04-11 18:52:02 +02006078 alloc_size);
Alexander Block31db9f72012-07-25 23:19:24 +02006079 if (ret) {
6080 ret = -EFAULT;
6081 goto out;
6082 }
6083
6084 for (i = 0; i < arg->clone_sources_count; i++) {
6085 key.objectid = clone_sources_tmp[i];
6086 key.type = BTRFS_ROOT_ITEM_KEY;
6087 key.offset = (u64)-1;
Wang Shilong18f687d2014-01-07 17:25:19 +08006088
6089 index = srcu_read_lock(&fs_info->subvol_srcu);
6090
Alexander Block31db9f72012-07-25 23:19:24 +02006091 clone_root = btrfs_read_fs_root_no_name(fs_info, &key);
Alexander Block31db9f72012-07-25 23:19:24 +02006092 if (IS_ERR(clone_root)) {
Wang Shilong18f687d2014-01-07 17:25:19 +08006093 srcu_read_unlock(&fs_info->subvol_srcu, index);
Alexander Block31db9f72012-07-25 23:19:24 +02006094 ret = PTR_ERR(clone_root);
6095 goto out;
6096 }
David Sterba2c686532013-12-16 17:34:17 +01006097 spin_lock(&clone_root->root_item_lock);
Filipe Manana5cc2b172015-03-02 20:53:52 +00006098 if (!btrfs_root_readonly(clone_root) ||
6099 btrfs_root_dead(clone_root)) {
David Sterba2c686532013-12-16 17:34:17 +01006100 spin_unlock(&clone_root->root_item_lock);
Wang Shilong18f687d2014-01-07 17:25:19 +08006101 srcu_read_unlock(&fs_info->subvol_srcu, index);
David Sterba2c686532013-12-16 17:34:17 +01006102 ret = -EPERM;
6103 goto out;
6104 }
Filipe Manana2f1f4652015-03-02 20:53:53 +00006105 clone_root->send_in_progress++;
David Sterba2c686532013-12-16 17:34:17 +01006106 spin_unlock(&clone_root->root_item_lock);
Wang Shilong18f687d2014-01-07 17:25:19 +08006107 srcu_read_unlock(&fs_info->subvol_srcu, index);
6108
Alexander Block31db9f72012-07-25 23:19:24 +02006109 sctx->clone_roots[i].root = clone_root;
Filipe Manana2f1f4652015-03-02 20:53:53 +00006110 clone_sources_to_rollback = i + 1;
Alexander Block31db9f72012-07-25 23:19:24 +02006111 }
David Sterba2f913062016-04-11 18:40:08 +02006112 kvfree(clone_sources_tmp);
Alexander Block31db9f72012-07-25 23:19:24 +02006113 clone_sources_tmp = NULL;
6114 }
6115
6116 if (arg->parent_root) {
6117 key.objectid = arg->parent_root;
6118 key.type = BTRFS_ROOT_ITEM_KEY;
6119 key.offset = (u64)-1;
Wang Shilong18f687d2014-01-07 17:25:19 +08006120
6121 index = srcu_read_lock(&fs_info->subvol_srcu);
6122
Alexander Block31db9f72012-07-25 23:19:24 +02006123 sctx->parent_root = btrfs_read_fs_root_no_name(fs_info, &key);
Stefan Behrensb1b19592013-05-13 14:42:57 +00006124 if (IS_ERR(sctx->parent_root)) {
Wang Shilong18f687d2014-01-07 17:25:19 +08006125 srcu_read_unlock(&fs_info->subvol_srcu, index);
Stefan Behrensb1b19592013-05-13 14:42:57 +00006126 ret = PTR_ERR(sctx->parent_root);
Alexander Block31db9f72012-07-25 23:19:24 +02006127 goto out;
6128 }
Wang Shilong18f687d2014-01-07 17:25:19 +08006129
David Sterba2c686532013-12-16 17:34:17 +01006130 spin_lock(&sctx->parent_root->root_item_lock);
6131 sctx->parent_root->send_in_progress++;
David Sterba521e0542014-04-15 16:41:44 +02006132 if (!btrfs_root_readonly(sctx->parent_root) ||
6133 btrfs_root_dead(sctx->parent_root)) {
David Sterba2c686532013-12-16 17:34:17 +01006134 spin_unlock(&sctx->parent_root->root_item_lock);
Wang Shilong18f687d2014-01-07 17:25:19 +08006135 srcu_read_unlock(&fs_info->subvol_srcu, index);
David Sterba2c686532013-12-16 17:34:17 +01006136 ret = -EPERM;
6137 goto out;
6138 }
6139 spin_unlock(&sctx->parent_root->root_item_lock);
Wang Shilong18f687d2014-01-07 17:25:19 +08006140
6141 srcu_read_unlock(&fs_info->subvol_srcu, index);
Alexander Block31db9f72012-07-25 23:19:24 +02006142 }
6143
6144 /*
6145 * Clones from send_root are allowed, but only if the clone source
6146 * is behind the current send position. This is checked while searching
6147 * for possible clone sources.
6148 */
6149 sctx->clone_roots[sctx->clone_roots_cnt++].root = sctx->send_root;
6150
6151 /* We do a bsearch later */
6152 sort(sctx->clone_roots, sctx->clone_roots_cnt,
6153 sizeof(*sctx->clone_roots), __clone_root_cmp_sort,
6154 NULL);
Wang Shilong896c14f2014-01-07 17:25:18 +08006155 sort_clone_roots = 1;
Alexander Block31db9f72012-07-25 23:19:24 +02006156
Filipe Mananae5fa8f82014-10-21 11:11:41 +01006157 ret = ensure_commit_roots_uptodate(sctx);
6158 if (ret)
6159 goto out;
6160
David Sterba2755a0d2014-07-31 00:43:18 +02006161 current->journal_info = BTRFS_SEND_TRANS_STUB;
Alexander Block31db9f72012-07-25 23:19:24 +02006162 ret = send_subvol(sctx);
Josef Bacika26e8c92014-03-28 17:07:27 -04006163 current->journal_info = NULL;
Alexander Block31db9f72012-07-25 23:19:24 +02006164 if (ret < 0)
6165 goto out;
6166
Stefan Behrensc2c71322013-04-10 17:10:52 +00006167 if (!(sctx->flags & BTRFS_SEND_FLAG_OMIT_END_CMD)) {
6168 ret = begin_cmd(sctx, BTRFS_SEND_C_END);
6169 if (ret < 0)
6170 goto out;
6171 ret = send_cmd(sctx);
6172 if (ret < 0)
6173 goto out;
6174 }
Alexander Block31db9f72012-07-25 23:19:24 +02006175
6176out:
Filipe David Borba Manana9f037402014-01-22 10:00:53 +00006177 WARN_ON(sctx && !ret && !RB_EMPTY_ROOT(&sctx->pending_dir_moves));
6178 while (sctx && !RB_EMPTY_ROOT(&sctx->pending_dir_moves)) {
6179 struct rb_node *n;
6180 struct pending_dir_move *pm;
6181
6182 n = rb_first(&sctx->pending_dir_moves);
6183 pm = rb_entry(n, struct pending_dir_move, node);
6184 while (!list_empty(&pm->list)) {
6185 struct pending_dir_move *pm2;
6186
6187 pm2 = list_first_entry(&pm->list,
6188 struct pending_dir_move, list);
6189 free_pending_move(sctx, pm2);
6190 }
6191 free_pending_move(sctx, pm);
6192 }
6193
6194 WARN_ON(sctx && !ret && !RB_EMPTY_ROOT(&sctx->waiting_dir_moves));
6195 while (sctx && !RB_EMPTY_ROOT(&sctx->waiting_dir_moves)) {
6196 struct rb_node *n;
6197 struct waiting_dir_move *dm;
6198
6199 n = rb_first(&sctx->waiting_dir_moves);
6200 dm = rb_entry(n, struct waiting_dir_move, node);
6201 rb_erase(&dm->node, &sctx->waiting_dir_moves);
6202 kfree(dm);
6203 }
6204
Filipe Manana9dc44212014-02-19 14:31:44 +00006205 WARN_ON(sctx && !ret && !RB_EMPTY_ROOT(&sctx->orphan_dirs));
6206 while (sctx && !RB_EMPTY_ROOT(&sctx->orphan_dirs)) {
6207 struct rb_node *n;
6208 struct orphan_dir_info *odi;
6209
6210 n = rb_first(&sctx->orphan_dirs);
6211 odi = rb_entry(n, struct orphan_dir_info, node);
6212 free_orphan_dir_info(sctx, odi);
6213 }
6214
Wang Shilong896c14f2014-01-07 17:25:18 +08006215 if (sort_clone_roots) {
6216 for (i = 0; i < sctx->clone_roots_cnt; i++)
6217 btrfs_root_dec_send_in_progress(
6218 sctx->clone_roots[i].root);
6219 } else {
6220 for (i = 0; sctx && i < clone_sources_to_rollback; i++)
6221 btrfs_root_dec_send_in_progress(
6222 sctx->clone_roots[i].root);
6223
6224 btrfs_root_dec_send_in_progress(send_root);
6225 }
David Sterba66ef7d62013-12-17 15:07:20 +01006226 if (sctx && !IS_ERR_OR_NULL(sctx->parent_root))
6227 btrfs_root_dec_send_in_progress(sctx->parent_root);
David Sterba2c686532013-12-16 17:34:17 +01006228
Alexander Block31db9f72012-07-25 23:19:24 +02006229 kfree(arg);
David Sterba2f913062016-04-11 18:40:08 +02006230 kvfree(clone_sources_tmp);
Alexander Block31db9f72012-07-25 23:19:24 +02006231
6232 if (sctx) {
6233 if (sctx->send_filp)
6234 fput(sctx->send_filp);
6235
David Sterbac03d01f2016-04-11 18:40:08 +02006236 kvfree(sctx->clone_roots);
David Sterba6ff48ce2016-04-11 18:40:08 +02006237 kvfree(sctx->send_buf);
David Sterbaeb5b75f2016-04-11 18:40:08 +02006238 kvfree(sctx->read_buf);
Alexander Block31db9f72012-07-25 23:19:24 +02006239
6240 name_cache_free(sctx);
6241
6242 kfree(sctx);
6243 }
6244
6245 return ret;
6246}