1 /* 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> 27 #include <linux/crc32c.h> 28 #include <linux/vmalloc.h> 29 30 #include "send.h" 31 #include "backref.h" 32 #include "locking.h" 33 #include "disk-io.h" 34 #include "btrfs_inode.h" 35 #include "transaction.h" 36 37 static int g_verbose = 0; 38 39 #define verbose_printk(...) if (g_verbose) printk(__VA_ARGS__) 40 41 /* 42 * A fs_path is a helper to dynamically build path names with unknown size. 43 * It reallocates the internal buffer on demand. 44 * It allows fast adding of path elements on the right side (normal path) and 45 * fast adding to the left side (reversed path). A reversed path can also be 46 * unreversed if needed. 47 */ 48 struct fs_path { 49 union { 50 struct { 51 char *start; 52 char *end; 53 char *prepared; 54 55 char *buf; 56 int buf_len; 57 int reversed:1; 58 int virtual_mem:1; 59 char inline_buf[]; 60 }; 61 char pad[PAGE_SIZE]; 62 }; 63 }; 64 #define FS_PATH_INLINE_SIZE \ 65 (sizeof(struct fs_path) - offsetof(struct fs_path, inline_buf)) 66 67 68 /* reused for each extent */ 69 struct clone_root { 70 struct btrfs_root *root; 71 u64 ino; 72 u64 offset; 73 74 u64 found_refs; 75 }; 76 77 #define SEND_CTX_MAX_NAME_CACHE_SIZE 128 78 #define SEND_CTX_NAME_CACHE_CLEAN_SIZE (SEND_CTX_MAX_NAME_CACHE_SIZE * 2) 79 80 struct send_ctx { 81 struct file *send_filp; 82 loff_t send_off; 83 char *send_buf; 84 u32 send_size; 85 u32 send_max_size; 86 u64 total_send_size; 87 u64 cmd_send_size[BTRFS_SEND_C_MAX + 1]; 88 u64 flags; /* 'flags' member of btrfs_ioctl_send_args is u64 */ 89 90 struct vfsmount *mnt; 91 92 struct btrfs_root *send_root; 93 struct btrfs_root *parent_root; 94 struct clone_root *clone_roots; 95 int clone_roots_cnt; 96 97 /* current state of the compare_tree call */ 98 struct btrfs_path *left_path; 99 struct btrfs_path *right_path; 100 struct btrfs_key *cmp_key; 101 102 /* 103 * infos of the currently processed inode. In case of deleted inodes, 104 * these are the values from the deleted inode. 105 */ 106 u64 cur_ino; 107 u64 cur_inode_gen; 108 int cur_inode_new; 109 int cur_inode_new_gen; 110 int cur_inode_deleted; 111 u64 cur_inode_size; 112 u64 cur_inode_mode; 113 114 u64 send_progress; 115 116 struct list_head new_refs; 117 struct list_head deleted_refs; 118 119 struct radix_tree_root name_cache; 120 struct list_head name_cache_list; 121 int name_cache_size; 122 123 struct file *cur_inode_filp; 124 char *read_buf; 125 }; 126 127 struct name_cache_entry { 128 struct list_head list; 129 /* 130 * radix_tree has only 32bit entries but we need to handle 64bit inums. 131 * We use the lower 32bit of the 64bit inum to store it in the tree. If 132 * more then one inum would fall into the same entry, we use radix_list 133 * to store the additional entries. radix_list is also used to store 134 * entries where two entries have the same inum but different 135 * generations. 136 */ 137 struct list_head radix_list; 138 u64 ino; 139 u64 gen; 140 u64 parent_ino; 141 u64 parent_gen; 142 int ret; 143 int need_later_update; 144 int name_len; 145 char name[]; 146 }; 147 148 static void fs_path_reset(struct fs_path *p) 149 { 150 if (p->reversed) { 151 p->start = p->buf + p->buf_len - 1; 152 p->end = p->start; 153 *p->start = 0; 154 } else { 155 p->start = p->buf; 156 p->end = p->start; 157 *p->start = 0; 158 } 159 } 160 161 static struct fs_path *fs_path_alloc(struct send_ctx *sctx) 162 { 163 struct fs_path *p; 164 165 p = kmalloc(sizeof(*p), GFP_NOFS); 166 if (!p) 167 return NULL; 168 p->reversed = 0; 169 p->virtual_mem = 0; 170 p->buf = p->inline_buf; 171 p->buf_len = FS_PATH_INLINE_SIZE; 172 fs_path_reset(p); 173 return p; 174 } 175 176 static struct fs_path *fs_path_alloc_reversed(struct send_ctx *sctx) 177 { 178 struct fs_path *p; 179 180 p = fs_path_alloc(sctx); 181 if (!p) 182 return NULL; 183 p->reversed = 1; 184 fs_path_reset(p); 185 return p; 186 } 187 188 static void fs_path_free(struct send_ctx *sctx, struct fs_path *p) 189 { 190 if (!p) 191 return; 192 if (p->buf != p->inline_buf) { 193 if (p->virtual_mem) 194 vfree(p->buf); 195 else 196 kfree(p->buf); 197 } 198 kfree(p); 199 } 200 201 static int fs_path_len(struct fs_path *p) 202 { 203 return p->end - p->start; 204 } 205 206 static int fs_path_ensure_buf(struct fs_path *p, int len) 207 { 208 char *tmp_buf; 209 int path_len; 210 int old_buf_len; 211 212 len++; 213 214 if (p->buf_len >= len) 215 return 0; 216 217 path_len = p->end - p->start; 218 old_buf_len = p->buf_len; 219 len = PAGE_ALIGN(len); 220 221 if (p->buf == p->inline_buf) { 222 tmp_buf = kmalloc(len, GFP_NOFS); 223 if (!tmp_buf) { 224 tmp_buf = vmalloc(len); 225 if (!tmp_buf) 226 return -ENOMEM; 227 p->virtual_mem = 1; 228 } 229 memcpy(tmp_buf, p->buf, p->buf_len); 230 p->buf = tmp_buf; 231 p->buf_len = len; 232 } else { 233 if (p->virtual_mem) { 234 tmp_buf = vmalloc(len); 235 if (!tmp_buf) 236 return -ENOMEM; 237 memcpy(tmp_buf, p->buf, p->buf_len); 238 vfree(p->buf); 239 } else { 240 tmp_buf = krealloc(p->buf, len, GFP_NOFS); 241 if (!tmp_buf) { 242 tmp_buf = vmalloc(len); 243 if (!tmp_buf) 244 return -ENOMEM; 245 memcpy(tmp_buf, p->buf, p->buf_len); 246 kfree(p->buf); 247 p->virtual_mem = 1; 248 } 249 } 250 p->buf = tmp_buf; 251 p->buf_len = len; 252 } 253 if (p->reversed) { 254 tmp_buf = p->buf + old_buf_len - path_len - 1; 255 p->end = p->buf + p->buf_len - 1; 256 p->start = p->end - path_len; 257 memmove(p->start, tmp_buf, path_len + 1); 258 } else { 259 p->start = p->buf; 260 p->end = p->start + path_len; 261 } 262 return 0; 263 } 264 265 static int fs_path_prepare_for_add(struct fs_path *p, int name_len) 266 { 267 int ret; 268 int new_len; 269 270 new_len = p->end - p->start + name_len; 271 if (p->start != p->end) 272 new_len++; 273 ret = fs_path_ensure_buf(p, new_len); 274 if (ret < 0) 275 goto out; 276 277 if (p->reversed) { 278 if (p->start != p->end) 279 *--p->start = '/'; 280 p->start -= name_len; 281 p->prepared = p->start; 282 } else { 283 if (p->start != p->end) 284 *p->end++ = '/'; 285 p->prepared = p->end; 286 p->end += name_len; 287 *p->end = 0; 288 } 289 290 out: 291 return ret; 292 } 293 294 static int fs_path_add(struct fs_path *p, const char *name, int name_len) 295 { 296 int ret; 297 298 ret = fs_path_prepare_for_add(p, name_len); 299 if (ret < 0) 300 goto out; 301 memcpy(p->prepared, name, name_len); 302 p->prepared = NULL; 303 304 out: 305 return ret; 306 } 307 308 static int fs_path_add_path(struct fs_path *p, struct fs_path *p2) 309 { 310 int ret; 311 312 ret = fs_path_prepare_for_add(p, p2->end - p2->start); 313 if (ret < 0) 314 goto out; 315 memcpy(p->prepared, p2->start, p2->end - p2->start); 316 p->prepared = NULL; 317 318 out: 319 return ret; 320 } 321 322 static int fs_path_add_from_extent_buffer(struct fs_path *p, 323 struct extent_buffer *eb, 324 unsigned long off, int len) 325 { 326 int ret; 327 328 ret = fs_path_prepare_for_add(p, len); 329 if (ret < 0) 330 goto out; 331 332 read_extent_buffer(eb, p->prepared, off, len); 333 p->prepared = NULL; 334 335 out: 336 return ret; 337 } 338 339 #if 0 340 static void fs_path_remove(struct fs_path *p) 341 { 342 BUG_ON(p->reversed); 343 while (p->start != p->end && *p->end != '/') 344 p->end--; 345 *p->end = 0; 346 } 347 #endif 348 349 static int fs_path_copy(struct fs_path *p, struct fs_path *from) 350 { 351 int ret; 352 353 p->reversed = from->reversed; 354 fs_path_reset(p); 355 356 ret = fs_path_add_path(p, from); 357 358 return ret; 359 } 360 361 362 static void fs_path_unreverse(struct fs_path *p) 363 { 364 char *tmp; 365 int len; 366 367 if (!p->reversed) 368 return; 369 370 tmp = p->start; 371 len = p->end - p->start; 372 p->start = p->buf; 373 p->end = p->start + len; 374 memmove(p->start, tmp, len + 1); 375 p->reversed = 0; 376 } 377 378 static struct btrfs_path *alloc_path_for_send(void) 379 { 380 struct btrfs_path *path; 381 382 path = btrfs_alloc_path(); 383 if (!path) 384 return NULL; 385 path->search_commit_root = 1; 386 path->skip_locking = 1; 387 return path; 388 } 389 390 static int write_buf(struct file *filp, const void *buf, u32 len, loff_t *off) 391 { 392 int ret; 393 mm_segment_t old_fs; 394 u32 pos = 0; 395 396 old_fs = get_fs(); 397 set_fs(KERNEL_DS); 398 399 while (pos < len) { 400 ret = vfs_write(filp, (char *)buf + pos, len - pos, off); 401 /* TODO handle that correctly */ 402 /*if (ret == -ERESTARTSYS) { 403 continue; 404 }*/ 405 if (ret < 0) 406 goto out; 407 if (ret == 0) { 408 ret = -EIO; 409 goto out; 410 } 411 pos += ret; 412 } 413 414 ret = 0; 415 416 out: 417 set_fs(old_fs); 418 return ret; 419 } 420 421 static int tlv_put(struct send_ctx *sctx, u16 attr, const void *data, int len) 422 { 423 struct btrfs_tlv_header *hdr; 424 int total_len = sizeof(*hdr) + len; 425 int left = sctx->send_max_size - sctx->send_size; 426 427 if (unlikely(left < total_len)) 428 return -EOVERFLOW; 429 430 hdr = (struct btrfs_tlv_header *) (sctx->send_buf + sctx->send_size); 431 hdr->tlv_type = cpu_to_le16(attr); 432 hdr->tlv_len = cpu_to_le16(len); 433 memcpy(hdr + 1, data, len); 434 sctx->send_size += total_len; 435 436 return 0; 437 } 438 439 #if 0 440 static int tlv_put_u8(struct send_ctx *sctx, u16 attr, u8 value) 441 { 442 return tlv_put(sctx, attr, &value, sizeof(value)); 443 } 444 445 static int tlv_put_u16(struct send_ctx *sctx, u16 attr, u16 value) 446 { 447 __le16 tmp = cpu_to_le16(value); 448 return tlv_put(sctx, attr, &tmp, sizeof(tmp)); 449 } 450 451 static int tlv_put_u32(struct send_ctx *sctx, u16 attr, u32 value) 452 { 453 __le32 tmp = cpu_to_le32(value); 454 return tlv_put(sctx, attr, &tmp, sizeof(tmp)); 455 } 456 #endif 457 458 static int tlv_put_u64(struct send_ctx *sctx, u16 attr, u64 value) 459 { 460 __le64 tmp = cpu_to_le64(value); 461 return tlv_put(sctx, attr, &tmp, sizeof(tmp)); 462 } 463 464 static int tlv_put_string(struct send_ctx *sctx, u16 attr, 465 const char *str, int len) 466 { 467 if (len == -1) 468 len = strlen(str); 469 return tlv_put(sctx, attr, str, len); 470 } 471 472 static int tlv_put_uuid(struct send_ctx *sctx, u16 attr, 473 const u8 *uuid) 474 { 475 return tlv_put(sctx, attr, uuid, BTRFS_UUID_SIZE); 476 } 477 478 #if 0 479 static int tlv_put_timespec(struct send_ctx *sctx, u16 attr, 480 struct timespec *ts) 481 { 482 struct btrfs_timespec bts; 483 bts.sec = cpu_to_le64(ts->tv_sec); 484 bts.nsec = cpu_to_le32(ts->tv_nsec); 485 return tlv_put(sctx, attr, &bts, sizeof(bts)); 486 } 487 #endif 488 489 static int tlv_put_btrfs_timespec(struct send_ctx *sctx, u16 attr, 490 struct extent_buffer *eb, 491 struct btrfs_timespec *ts) 492 { 493 struct btrfs_timespec bts; 494 read_extent_buffer(eb, &bts, (unsigned long)ts, sizeof(bts)); 495 return tlv_put(sctx, attr, &bts, sizeof(bts)); 496 } 497 498 499 #define TLV_PUT(sctx, attrtype, attrlen, data) \ 500 do { \ 501 ret = tlv_put(sctx, attrtype, attrlen, data); \ 502 if (ret < 0) \ 503 goto tlv_put_failure; \ 504 } while (0) 505 506 #define TLV_PUT_INT(sctx, attrtype, bits, value) \ 507 do { \ 508 ret = tlv_put_u##bits(sctx, attrtype, value); \ 509 if (ret < 0) \ 510 goto tlv_put_failure; \ 511 } while (0) 512 513 #define TLV_PUT_U8(sctx, attrtype, data) TLV_PUT_INT(sctx, attrtype, 8, data) 514 #define TLV_PUT_U16(sctx, attrtype, data) TLV_PUT_INT(sctx, attrtype, 16, data) 515 #define TLV_PUT_U32(sctx, attrtype, data) TLV_PUT_INT(sctx, attrtype, 32, data) 516 #define TLV_PUT_U64(sctx, attrtype, data) TLV_PUT_INT(sctx, attrtype, 64, data) 517 #define TLV_PUT_STRING(sctx, attrtype, str, len) \ 518 do { \ 519 ret = tlv_put_string(sctx, attrtype, str, len); \ 520 if (ret < 0) \ 521 goto tlv_put_failure; \ 522 } while (0) 523 #define TLV_PUT_PATH(sctx, attrtype, p) \ 524 do { \ 525 ret = tlv_put_string(sctx, attrtype, p->start, \ 526 p->end - p->start); \ 527 if (ret < 0) \ 528 goto tlv_put_failure; \ 529 } while(0) 530 #define TLV_PUT_UUID(sctx, attrtype, uuid) \ 531 do { \ 532 ret = tlv_put_uuid(sctx, attrtype, uuid); \ 533 if (ret < 0) \ 534 goto tlv_put_failure; \ 535 } while (0) 536 #define TLV_PUT_TIMESPEC(sctx, attrtype, ts) \ 537 do { \ 538 ret = tlv_put_timespec(sctx, attrtype, ts); \ 539 if (ret < 0) \ 540 goto tlv_put_failure; \ 541 } while (0) 542 #define TLV_PUT_BTRFS_TIMESPEC(sctx, attrtype, eb, ts) \ 543 do { \ 544 ret = tlv_put_btrfs_timespec(sctx, attrtype, eb, ts); \ 545 if (ret < 0) \ 546 goto tlv_put_failure; \ 547 } while (0) 548 549 static int send_header(struct send_ctx *sctx) 550 { 551 struct btrfs_stream_header hdr; 552 553 strcpy(hdr.magic, BTRFS_SEND_STREAM_MAGIC); 554 hdr.version = cpu_to_le32(BTRFS_SEND_STREAM_VERSION); 555 556 return write_buf(sctx->send_filp, &hdr, sizeof(hdr), 557 &sctx->send_off); 558 } 559 560 /* 561 * For each command/item we want to send to userspace, we call this function. 562 */ 563 static int begin_cmd(struct send_ctx *sctx, int cmd) 564 { 565 struct btrfs_cmd_header *hdr; 566 567 if (!sctx->send_buf) { 568 WARN_ON(1); 569 return -EINVAL; 570 } 571 572 BUG_ON(sctx->send_size); 573 574 sctx->send_size += sizeof(*hdr); 575 hdr = (struct btrfs_cmd_header *)sctx->send_buf; 576 hdr->cmd = cpu_to_le16(cmd); 577 578 return 0; 579 } 580 581 static int send_cmd(struct send_ctx *sctx) 582 { 583 int ret; 584 struct btrfs_cmd_header *hdr; 585 u32 crc; 586 587 hdr = (struct btrfs_cmd_header *)sctx->send_buf; 588 hdr->len = cpu_to_le32(sctx->send_size - sizeof(*hdr)); 589 hdr->crc = 0; 590 591 crc = crc32c(0, (unsigned char *)sctx->send_buf, sctx->send_size); 592 hdr->crc = cpu_to_le32(crc); 593 594 ret = write_buf(sctx->send_filp, sctx->send_buf, sctx->send_size, 595 &sctx->send_off); 596 597 sctx->total_send_size += sctx->send_size; 598 sctx->cmd_send_size[le16_to_cpu(hdr->cmd)] += sctx->send_size; 599 sctx->send_size = 0; 600 601 return ret; 602 } 603 604 /* 605 * Sends a move instruction to user space 606 */ 607 static int send_rename(struct send_ctx *sctx, 608 struct fs_path *from, struct fs_path *to) 609 { 610 int ret; 611 612 verbose_printk("btrfs: send_rename %s -> %s\n", from->start, to->start); 613 614 ret = begin_cmd(sctx, BTRFS_SEND_C_RENAME); 615 if (ret < 0) 616 goto out; 617 618 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, from); 619 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH_TO, to); 620 621 ret = send_cmd(sctx); 622 623 tlv_put_failure: 624 out: 625 return ret; 626 } 627 628 /* 629 * Sends a link instruction to user space 630 */ 631 static int send_link(struct send_ctx *sctx, 632 struct fs_path *path, struct fs_path *lnk) 633 { 634 int ret; 635 636 verbose_printk("btrfs: send_link %s -> %s\n", path->start, lnk->start); 637 638 ret = begin_cmd(sctx, BTRFS_SEND_C_LINK); 639 if (ret < 0) 640 goto out; 641 642 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, path); 643 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH_LINK, lnk); 644 645 ret = send_cmd(sctx); 646 647 tlv_put_failure: 648 out: 649 return ret; 650 } 651 652 /* 653 * Sends an unlink instruction to user space 654 */ 655 static int send_unlink(struct send_ctx *sctx, struct fs_path *path) 656 { 657 int ret; 658 659 verbose_printk("btrfs: send_unlink %s\n", path->start); 660 661 ret = begin_cmd(sctx, BTRFS_SEND_C_UNLINK); 662 if (ret < 0) 663 goto out; 664 665 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, path); 666 667 ret = send_cmd(sctx); 668 669 tlv_put_failure: 670 out: 671 return ret; 672 } 673 674 /* 675 * Sends a rmdir instruction to user space 676 */ 677 static int send_rmdir(struct send_ctx *sctx, struct fs_path *path) 678 { 679 int ret; 680 681 verbose_printk("btrfs: send_rmdir %s\n", path->start); 682 683 ret = begin_cmd(sctx, BTRFS_SEND_C_RMDIR); 684 if (ret < 0) 685 goto out; 686 687 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, path); 688 689 ret = send_cmd(sctx); 690 691 tlv_put_failure: 692 out: 693 return ret; 694 } 695 696 /* 697 * Helper function to retrieve some fields from an inode item. 698 */ 699 static int get_inode_info(struct btrfs_root *root, 700 u64 ino, u64 *size, u64 *gen, 701 u64 *mode, u64 *uid, u64 *gid, 702 u64 *rdev) 703 { 704 int ret; 705 struct btrfs_inode_item *ii; 706 struct btrfs_key key; 707 struct btrfs_path *path; 708 709 path = alloc_path_for_send(); 710 if (!path) 711 return -ENOMEM; 712 713 key.objectid = ino; 714 key.type = BTRFS_INODE_ITEM_KEY; 715 key.offset = 0; 716 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); 717 if (ret < 0) 718 goto out; 719 if (ret) { 720 ret = -ENOENT; 721 goto out; 722 } 723 724 ii = btrfs_item_ptr(path->nodes[0], path->slots[0], 725 struct btrfs_inode_item); 726 if (size) 727 *size = btrfs_inode_size(path->nodes[0], ii); 728 if (gen) 729 *gen = btrfs_inode_generation(path->nodes[0], ii); 730 if (mode) 731 *mode = btrfs_inode_mode(path->nodes[0], ii); 732 if (uid) 733 *uid = btrfs_inode_uid(path->nodes[0], ii); 734 if (gid) 735 *gid = btrfs_inode_gid(path->nodes[0], ii); 736 if (rdev) 737 *rdev = btrfs_inode_rdev(path->nodes[0], ii); 738 739 out: 740 btrfs_free_path(path); 741 return ret; 742 } 743 744 typedef int (*iterate_inode_ref_t)(int num, u64 dir, int index, 745 struct fs_path *p, 746 void *ctx); 747 748 /* 749 * Helper function to iterate the entries in ONE btrfs_inode_ref or 750 * btrfs_inode_extref. 751 * The iterate callback may return a non zero value to stop iteration. This can 752 * be a negative value for error codes or 1 to simply stop it. 753 * 754 * path must point to the INODE_REF or INODE_EXTREF when called. 755 */ 756 static int iterate_inode_ref(struct send_ctx *sctx, 757 struct btrfs_root *root, struct btrfs_path *path, 758 struct btrfs_key *found_key, int resolve, 759 iterate_inode_ref_t iterate, void *ctx) 760 { 761 struct extent_buffer *eb = path->nodes[0]; 762 struct btrfs_item *item; 763 struct btrfs_inode_ref *iref; 764 struct btrfs_inode_extref *extref; 765 struct btrfs_path *tmp_path; 766 struct fs_path *p; 767 u32 cur = 0; 768 u32 total; 769 int slot = path->slots[0]; 770 u32 name_len; 771 char *start; 772 int ret = 0; 773 int num = 0; 774 int index; 775 u64 dir; 776 unsigned long name_off; 777 unsigned long elem_size; 778 unsigned long ptr; 779 780 p = fs_path_alloc_reversed(sctx); 781 if (!p) 782 return -ENOMEM; 783 784 tmp_path = alloc_path_for_send(); 785 if (!tmp_path) { 786 fs_path_free(sctx, p); 787 return -ENOMEM; 788 } 789 790 791 if (found_key->type == BTRFS_INODE_REF_KEY) { 792 ptr = (unsigned long)btrfs_item_ptr(eb, slot, 793 struct btrfs_inode_ref); 794 item = btrfs_item_nr(eb, slot); 795 total = btrfs_item_size(eb, item); 796 elem_size = sizeof(*iref); 797 } else { 798 ptr = btrfs_item_ptr_offset(eb, slot); 799 total = btrfs_item_size_nr(eb, slot); 800 elem_size = sizeof(*extref); 801 } 802 803 while (cur < total) { 804 fs_path_reset(p); 805 806 if (found_key->type == BTRFS_INODE_REF_KEY) { 807 iref = (struct btrfs_inode_ref *)(ptr + cur); 808 name_len = btrfs_inode_ref_name_len(eb, iref); 809 name_off = (unsigned long)(iref + 1); 810 index = btrfs_inode_ref_index(eb, iref); 811 dir = found_key->offset; 812 } else { 813 extref = (struct btrfs_inode_extref *)(ptr + cur); 814 name_len = btrfs_inode_extref_name_len(eb, extref); 815 name_off = (unsigned long)&extref->name; 816 index = btrfs_inode_extref_index(eb, extref); 817 dir = btrfs_inode_extref_parent(eb, extref); 818 } 819 820 if (resolve) { 821 start = btrfs_ref_to_path(root, tmp_path, name_len, 822 name_off, eb, dir, 823 p->buf, p->buf_len); 824 if (IS_ERR(start)) { 825 ret = PTR_ERR(start); 826 goto out; 827 } 828 if (start < p->buf) { 829 /* overflow , try again with larger buffer */ 830 ret = fs_path_ensure_buf(p, 831 p->buf_len + p->buf - start); 832 if (ret < 0) 833 goto out; 834 start = btrfs_ref_to_path(root, tmp_path, 835 name_len, name_off, 836 eb, dir, 837 p->buf, p->buf_len); 838 if (IS_ERR(start)) { 839 ret = PTR_ERR(start); 840 goto out; 841 } 842 BUG_ON(start < p->buf); 843 } 844 p->start = start; 845 } else { 846 ret = fs_path_add_from_extent_buffer(p, eb, name_off, 847 name_len); 848 if (ret < 0) 849 goto out; 850 } 851 852 cur += elem_size + name_len; 853 ret = iterate(num, dir, index, p, ctx); 854 if (ret) 855 goto out; 856 num++; 857 } 858 859 out: 860 btrfs_free_path(tmp_path); 861 fs_path_free(sctx, p); 862 return ret; 863 } 864 865 typedef int (*iterate_dir_item_t)(int num, struct btrfs_key *di_key, 866 const char *name, int name_len, 867 const char *data, int data_len, 868 u8 type, void *ctx); 869 870 /* 871 * Helper function to iterate the entries in ONE btrfs_dir_item. 872 * The iterate callback may return a non zero value to stop iteration. This can 873 * be a negative value for error codes or 1 to simply stop it. 874 * 875 * path must point to the dir item when called. 876 */ 877 static int iterate_dir_item(struct send_ctx *sctx, 878 struct btrfs_root *root, struct btrfs_path *path, 879 struct btrfs_key *found_key, 880 iterate_dir_item_t iterate, void *ctx) 881 { 882 int ret = 0; 883 struct extent_buffer *eb; 884 struct btrfs_item *item; 885 struct btrfs_dir_item *di; 886 struct btrfs_key di_key; 887 char *buf = NULL; 888 char *buf2 = NULL; 889 int buf_len; 890 int buf_virtual = 0; 891 u32 name_len; 892 u32 data_len; 893 u32 cur; 894 u32 len; 895 u32 total; 896 int slot; 897 int num; 898 u8 type; 899 900 buf_len = PAGE_SIZE; 901 buf = kmalloc(buf_len, GFP_NOFS); 902 if (!buf) { 903 ret = -ENOMEM; 904 goto out; 905 } 906 907 eb = path->nodes[0]; 908 slot = path->slots[0]; 909 item = btrfs_item_nr(eb, slot); 910 di = btrfs_item_ptr(eb, slot, struct btrfs_dir_item); 911 cur = 0; 912 len = 0; 913 total = btrfs_item_size(eb, item); 914 915 num = 0; 916 while (cur < total) { 917 name_len = btrfs_dir_name_len(eb, di); 918 data_len = btrfs_dir_data_len(eb, di); 919 type = btrfs_dir_type(eb, di); 920 btrfs_dir_item_key_to_cpu(eb, di, &di_key); 921 922 if (name_len + data_len > buf_len) { 923 buf_len = PAGE_ALIGN(name_len + data_len); 924 if (buf_virtual) { 925 buf2 = vmalloc(buf_len); 926 if (!buf2) { 927 ret = -ENOMEM; 928 goto out; 929 } 930 vfree(buf); 931 } else { 932 buf2 = krealloc(buf, buf_len, GFP_NOFS); 933 if (!buf2) { 934 buf2 = vmalloc(buf_len); 935 if (!buf2) { 936 ret = -ENOMEM; 937 goto out; 938 } 939 kfree(buf); 940 buf_virtual = 1; 941 } 942 } 943 944 buf = buf2; 945 buf2 = NULL; 946 } 947 948 read_extent_buffer(eb, buf, (unsigned long)(di + 1), 949 name_len + data_len); 950 951 len = sizeof(*di) + name_len + data_len; 952 di = (struct btrfs_dir_item *)((char *)di + len); 953 cur += len; 954 955 ret = iterate(num, &di_key, buf, name_len, buf + name_len, 956 data_len, type, ctx); 957 if (ret < 0) 958 goto out; 959 if (ret) { 960 ret = 0; 961 goto out; 962 } 963 964 num++; 965 } 966 967 out: 968 if (buf_virtual) 969 vfree(buf); 970 else 971 kfree(buf); 972 return ret; 973 } 974 975 static int __copy_first_ref(int num, u64 dir, int index, 976 struct fs_path *p, void *ctx) 977 { 978 int ret; 979 struct fs_path *pt = ctx; 980 981 ret = fs_path_copy(pt, p); 982 if (ret < 0) 983 return ret; 984 985 /* we want the first only */ 986 return 1; 987 } 988 989 /* 990 * Retrieve the first path of an inode. If an inode has more then one 991 * ref/hardlink, this is ignored. 992 */ 993 static int get_inode_path(struct send_ctx *sctx, struct btrfs_root *root, 994 u64 ino, struct fs_path *path) 995 { 996 int ret; 997 struct btrfs_key key, found_key; 998 struct btrfs_path *p; 999 1000 p = alloc_path_for_send(); 1001 if (!p) 1002 return -ENOMEM; 1003 1004 fs_path_reset(path); 1005 1006 key.objectid = ino; 1007 key.type = BTRFS_INODE_REF_KEY; 1008 key.offset = 0; 1009 1010 ret = btrfs_search_slot_for_read(root, &key, p, 1, 0); 1011 if (ret < 0) 1012 goto out; 1013 if (ret) { 1014 ret = 1; 1015 goto out; 1016 } 1017 btrfs_item_key_to_cpu(p->nodes[0], &found_key, p->slots[0]); 1018 if (found_key.objectid != ino || 1019 (found_key.type != BTRFS_INODE_REF_KEY && 1020 found_key.type != BTRFS_INODE_EXTREF_KEY)) { 1021 ret = -ENOENT; 1022 goto out; 1023 } 1024 1025 ret = iterate_inode_ref(sctx, root, p, &found_key, 1, 1026 __copy_first_ref, path); 1027 if (ret < 0) 1028 goto out; 1029 ret = 0; 1030 1031 out: 1032 btrfs_free_path(p); 1033 return ret; 1034 } 1035 1036 struct backref_ctx { 1037 struct send_ctx *sctx; 1038 1039 /* number of total found references */ 1040 u64 found; 1041 1042 /* 1043 * used for clones found in send_root. clones found behind cur_objectid 1044 * and cur_offset are not considered as allowed clones. 1045 */ 1046 u64 cur_objectid; 1047 u64 cur_offset; 1048 1049 /* may be truncated in case it's the last extent in a file */ 1050 u64 extent_len; 1051 1052 /* Just to check for bugs in backref resolving */ 1053 int found_itself; 1054 }; 1055 1056 static int __clone_root_cmp_bsearch(const void *key, const void *elt) 1057 { 1058 u64 root = (u64)(uintptr_t)key; 1059 struct clone_root *cr = (struct clone_root *)elt; 1060 1061 if (root < cr->root->objectid) 1062 return -1; 1063 if (root > cr->root->objectid) 1064 return 1; 1065 return 0; 1066 } 1067 1068 static int __clone_root_cmp_sort(const void *e1, const void *e2) 1069 { 1070 struct clone_root *cr1 = (struct clone_root *)e1; 1071 struct clone_root *cr2 = (struct clone_root *)e2; 1072 1073 if (cr1->root->objectid < cr2->root->objectid) 1074 return -1; 1075 if (cr1->root->objectid > cr2->root->objectid) 1076 return 1; 1077 return 0; 1078 } 1079 1080 /* 1081 * Called for every backref that is found for the current extent. 1082 * Results are collected in sctx->clone_roots->ino/offset/found_refs 1083 */ 1084 static int __iterate_backrefs(u64 ino, u64 offset, u64 root, void *ctx_) 1085 { 1086 struct backref_ctx *bctx = ctx_; 1087 struct clone_root *found; 1088 int ret; 1089 u64 i_size; 1090 1091 /* First check if the root is in the list of accepted clone sources */ 1092 found = bsearch((void *)(uintptr_t)root, bctx->sctx->clone_roots, 1093 bctx->sctx->clone_roots_cnt, 1094 sizeof(struct clone_root), 1095 __clone_root_cmp_bsearch); 1096 if (!found) 1097 return 0; 1098 1099 if (found->root == bctx->sctx->send_root && 1100 ino == bctx->cur_objectid && 1101 offset == bctx->cur_offset) { 1102 bctx->found_itself = 1; 1103 } 1104 1105 /* 1106 * There are inodes that have extents that lie behind its i_size. Don't 1107 * accept clones from these extents. 1108 */ 1109 ret = get_inode_info(found->root, ino, &i_size, NULL, NULL, NULL, NULL, 1110 NULL); 1111 if (ret < 0) 1112 return ret; 1113 1114 if (offset + bctx->extent_len > i_size) 1115 return 0; 1116 1117 /* 1118 * Make sure we don't consider clones from send_root that are 1119 * behind the current inode/offset. 1120 */ 1121 if (found->root == bctx->sctx->send_root) { 1122 /* 1123 * TODO for the moment we don't accept clones from the inode 1124 * that is currently send. We may change this when 1125 * BTRFS_IOC_CLONE_RANGE supports cloning from and to the same 1126 * file. 1127 */ 1128 if (ino >= bctx->cur_objectid) 1129 return 0; 1130 #if 0 1131 if (ino > bctx->cur_objectid) 1132 return 0; 1133 if (offset + bctx->extent_len > bctx->cur_offset) 1134 return 0; 1135 #endif 1136 } 1137 1138 bctx->found++; 1139 found->found_refs++; 1140 if (ino < found->ino) { 1141 found->ino = ino; 1142 found->offset = offset; 1143 } else if (found->ino == ino) { 1144 /* 1145 * same extent found more then once in the same file. 1146 */ 1147 if (found->offset > offset + bctx->extent_len) 1148 found->offset = offset; 1149 } 1150 1151 return 0; 1152 } 1153 1154 /* 1155 * Given an inode, offset and extent item, it finds a good clone for a clone 1156 * instruction. Returns -ENOENT when none could be found. The function makes 1157 * sure that the returned clone is usable at the point where sending is at the 1158 * moment. This means, that no clones are accepted which lie behind the current 1159 * inode+offset. 1160 * 1161 * path must point to the extent item when called. 1162 */ 1163 static int find_extent_clone(struct send_ctx *sctx, 1164 struct btrfs_path *path, 1165 u64 ino, u64 data_offset, 1166 u64 ino_size, 1167 struct clone_root **found) 1168 { 1169 int ret; 1170 int extent_type; 1171 u64 logical; 1172 u64 disk_byte; 1173 u64 num_bytes; 1174 u64 extent_item_pos; 1175 u64 flags = 0; 1176 struct btrfs_file_extent_item *fi; 1177 struct extent_buffer *eb = path->nodes[0]; 1178 struct backref_ctx *backref_ctx = NULL; 1179 struct clone_root *cur_clone_root; 1180 struct btrfs_key found_key; 1181 struct btrfs_path *tmp_path; 1182 int compressed; 1183 u32 i; 1184 1185 tmp_path = alloc_path_for_send(); 1186 if (!tmp_path) 1187 return -ENOMEM; 1188 1189 backref_ctx = kmalloc(sizeof(*backref_ctx), GFP_NOFS); 1190 if (!backref_ctx) { 1191 ret = -ENOMEM; 1192 goto out; 1193 } 1194 1195 if (data_offset >= ino_size) { 1196 /* 1197 * There may be extents that lie behind the file's size. 1198 * I at least had this in combination with snapshotting while 1199 * writing large files. 1200 */ 1201 ret = 0; 1202 goto out; 1203 } 1204 1205 fi = btrfs_item_ptr(eb, path->slots[0], 1206 struct btrfs_file_extent_item); 1207 extent_type = btrfs_file_extent_type(eb, fi); 1208 if (extent_type == BTRFS_FILE_EXTENT_INLINE) { 1209 ret = -ENOENT; 1210 goto out; 1211 } 1212 compressed = btrfs_file_extent_compression(eb, fi); 1213 1214 num_bytes = btrfs_file_extent_num_bytes(eb, fi); 1215 disk_byte = btrfs_file_extent_disk_bytenr(eb, fi); 1216 if (disk_byte == 0) { 1217 ret = -ENOENT; 1218 goto out; 1219 } 1220 logical = disk_byte + btrfs_file_extent_offset(eb, fi); 1221 1222 ret = extent_from_logical(sctx->send_root->fs_info, disk_byte, tmp_path, 1223 &found_key, &flags); 1224 btrfs_release_path(tmp_path); 1225 1226 if (ret < 0) 1227 goto out; 1228 if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) { 1229 ret = -EIO; 1230 goto out; 1231 } 1232 1233 /* 1234 * Setup the clone roots. 1235 */ 1236 for (i = 0; i < sctx->clone_roots_cnt; i++) { 1237 cur_clone_root = sctx->clone_roots + i; 1238 cur_clone_root->ino = (u64)-1; 1239 cur_clone_root->offset = 0; 1240 cur_clone_root->found_refs = 0; 1241 } 1242 1243 backref_ctx->sctx = sctx; 1244 backref_ctx->found = 0; 1245 backref_ctx->cur_objectid = ino; 1246 backref_ctx->cur_offset = data_offset; 1247 backref_ctx->found_itself = 0; 1248 backref_ctx->extent_len = num_bytes; 1249 1250 /* 1251 * The last extent of a file may be too large due to page alignment. 1252 * We need to adjust extent_len in this case so that the checks in 1253 * __iterate_backrefs work. 1254 */ 1255 if (data_offset + num_bytes >= ino_size) 1256 backref_ctx->extent_len = ino_size - data_offset; 1257 1258 /* 1259 * Now collect all backrefs. 1260 */ 1261 if (compressed == BTRFS_COMPRESS_NONE) 1262 extent_item_pos = logical - found_key.objectid; 1263 else 1264 extent_item_pos = 0; 1265 1266 extent_item_pos = logical - found_key.objectid; 1267 ret = iterate_extent_inodes(sctx->send_root->fs_info, 1268 found_key.objectid, extent_item_pos, 1, 1269 __iterate_backrefs, backref_ctx); 1270 1271 if (ret < 0) 1272 goto out; 1273 1274 if (!backref_ctx->found_itself) { 1275 /* found a bug in backref code? */ 1276 ret = -EIO; 1277 printk(KERN_ERR "btrfs: ERROR did not find backref in " 1278 "send_root. inode=%llu, offset=%llu, " 1279 "disk_byte=%llu found extent=%llu\n", 1280 ino, data_offset, disk_byte, found_key.objectid); 1281 goto out; 1282 } 1283 1284 verbose_printk(KERN_DEBUG "btrfs: find_extent_clone: data_offset=%llu, " 1285 "ino=%llu, " 1286 "num_bytes=%llu, logical=%llu\n", 1287 data_offset, ino, num_bytes, logical); 1288 1289 if (!backref_ctx->found) 1290 verbose_printk("btrfs: no clones found\n"); 1291 1292 cur_clone_root = NULL; 1293 for (i = 0; i < sctx->clone_roots_cnt; i++) { 1294 if (sctx->clone_roots[i].found_refs) { 1295 if (!cur_clone_root) 1296 cur_clone_root = sctx->clone_roots + i; 1297 else if (sctx->clone_roots[i].root == sctx->send_root) 1298 /* prefer clones from send_root over others */ 1299 cur_clone_root = sctx->clone_roots + i; 1300 } 1301 1302 } 1303 1304 if (cur_clone_root) { 1305 *found = cur_clone_root; 1306 ret = 0; 1307 } else { 1308 ret = -ENOENT; 1309 } 1310 1311 out: 1312 btrfs_free_path(tmp_path); 1313 kfree(backref_ctx); 1314 return ret; 1315 } 1316 1317 static int read_symlink(struct send_ctx *sctx, 1318 struct btrfs_root *root, 1319 u64 ino, 1320 struct fs_path *dest) 1321 { 1322 int ret; 1323 struct btrfs_path *path; 1324 struct btrfs_key key; 1325 struct btrfs_file_extent_item *ei; 1326 u8 type; 1327 u8 compression; 1328 unsigned long off; 1329 int len; 1330 1331 path = alloc_path_for_send(); 1332 if (!path) 1333 return -ENOMEM; 1334 1335 key.objectid = ino; 1336 key.type = BTRFS_EXTENT_DATA_KEY; 1337 key.offset = 0; 1338 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); 1339 if (ret < 0) 1340 goto out; 1341 BUG_ON(ret); 1342 1343 ei = btrfs_item_ptr(path->nodes[0], path->slots[0], 1344 struct btrfs_file_extent_item); 1345 type = btrfs_file_extent_type(path->nodes[0], ei); 1346 compression = btrfs_file_extent_compression(path->nodes[0], ei); 1347 BUG_ON(type != BTRFS_FILE_EXTENT_INLINE); 1348 BUG_ON(compression); 1349 1350 off = btrfs_file_extent_inline_start(ei); 1351 len = btrfs_file_extent_inline_len(path->nodes[0], ei); 1352 1353 ret = fs_path_add_from_extent_buffer(dest, path->nodes[0], off, len); 1354 1355 out: 1356 btrfs_free_path(path); 1357 return ret; 1358 } 1359 1360 /* 1361 * Helper function to generate a file name that is unique in the root of 1362 * send_root and parent_root. This is used to generate names for orphan inodes. 1363 */ 1364 static int gen_unique_name(struct send_ctx *sctx, 1365 u64 ino, u64 gen, 1366 struct fs_path *dest) 1367 { 1368 int ret = 0; 1369 struct btrfs_path *path; 1370 struct btrfs_dir_item *di; 1371 char tmp[64]; 1372 int len; 1373 u64 idx = 0; 1374 1375 path = alloc_path_for_send(); 1376 if (!path) 1377 return -ENOMEM; 1378 1379 while (1) { 1380 len = snprintf(tmp, sizeof(tmp) - 1, "o%llu-%llu-%llu", 1381 ino, gen, idx); 1382 if (len >= sizeof(tmp)) { 1383 /* should really not happen */ 1384 ret = -EOVERFLOW; 1385 goto out; 1386 } 1387 1388 di = btrfs_lookup_dir_item(NULL, sctx->send_root, 1389 path, BTRFS_FIRST_FREE_OBJECTID, 1390 tmp, strlen(tmp), 0); 1391 btrfs_release_path(path); 1392 if (IS_ERR(di)) { 1393 ret = PTR_ERR(di); 1394 goto out; 1395 } 1396 if (di) { 1397 /* not unique, try again */ 1398 idx++; 1399 continue; 1400 } 1401 1402 if (!sctx->parent_root) { 1403 /* unique */ 1404 ret = 0; 1405 break; 1406 } 1407 1408 di = btrfs_lookup_dir_item(NULL, sctx->parent_root, 1409 path, BTRFS_FIRST_FREE_OBJECTID, 1410 tmp, strlen(tmp), 0); 1411 btrfs_release_path(path); 1412 if (IS_ERR(di)) { 1413 ret = PTR_ERR(di); 1414 goto out; 1415 } 1416 if (di) { 1417 /* not unique, try again */ 1418 idx++; 1419 continue; 1420 } 1421 /* unique */ 1422 break; 1423 } 1424 1425 ret = fs_path_add(dest, tmp, strlen(tmp)); 1426 1427 out: 1428 btrfs_free_path(path); 1429 return ret; 1430 } 1431 1432 enum inode_state { 1433 inode_state_no_change, 1434 inode_state_will_create, 1435 inode_state_did_create, 1436 inode_state_will_delete, 1437 inode_state_did_delete, 1438 }; 1439 1440 static int get_cur_inode_state(struct send_ctx *sctx, u64 ino, u64 gen) 1441 { 1442 int ret; 1443 int left_ret; 1444 int right_ret; 1445 u64 left_gen; 1446 u64 right_gen; 1447 1448 ret = get_inode_info(sctx->send_root, ino, NULL, &left_gen, NULL, NULL, 1449 NULL, NULL); 1450 if (ret < 0 && ret != -ENOENT) 1451 goto out; 1452 left_ret = ret; 1453 1454 if (!sctx->parent_root) { 1455 right_ret = -ENOENT; 1456 } else { 1457 ret = get_inode_info(sctx->parent_root, ino, NULL, &right_gen, 1458 NULL, NULL, NULL, NULL); 1459 if (ret < 0 && ret != -ENOENT) 1460 goto out; 1461 right_ret = ret; 1462 } 1463 1464 if (!left_ret && !right_ret) { 1465 if (left_gen == gen && right_gen == gen) { 1466 ret = inode_state_no_change; 1467 } else if (left_gen == gen) { 1468 if (ino < sctx->send_progress) 1469 ret = inode_state_did_create; 1470 else 1471 ret = inode_state_will_create; 1472 } else if (right_gen == gen) { 1473 if (ino < sctx->send_progress) 1474 ret = inode_state_did_delete; 1475 else 1476 ret = inode_state_will_delete; 1477 } else { 1478 ret = -ENOENT; 1479 } 1480 } else if (!left_ret) { 1481 if (left_gen == gen) { 1482 if (ino < sctx->send_progress) 1483 ret = inode_state_did_create; 1484 else 1485 ret = inode_state_will_create; 1486 } else { 1487 ret = -ENOENT; 1488 } 1489 } else if (!right_ret) { 1490 if (right_gen == gen) { 1491 if (ino < sctx->send_progress) 1492 ret = inode_state_did_delete; 1493 else 1494 ret = inode_state_will_delete; 1495 } else { 1496 ret = -ENOENT; 1497 } 1498 } else { 1499 ret = -ENOENT; 1500 } 1501 1502 out: 1503 return ret; 1504 } 1505 1506 static int is_inode_existent(struct send_ctx *sctx, u64 ino, u64 gen) 1507 { 1508 int ret; 1509 1510 ret = get_cur_inode_state(sctx, ino, gen); 1511 if (ret < 0) 1512 goto out; 1513 1514 if (ret == inode_state_no_change || 1515 ret == inode_state_did_create || 1516 ret == inode_state_will_delete) 1517 ret = 1; 1518 else 1519 ret = 0; 1520 1521 out: 1522 return ret; 1523 } 1524 1525 /* 1526 * Helper function to lookup a dir item in a dir. 1527 */ 1528 static int lookup_dir_item_inode(struct btrfs_root *root, 1529 u64 dir, const char *name, int name_len, 1530 u64 *found_inode, 1531 u8 *found_type) 1532 { 1533 int ret = 0; 1534 struct btrfs_dir_item *di; 1535 struct btrfs_key key; 1536 struct btrfs_path *path; 1537 1538 path = alloc_path_for_send(); 1539 if (!path) 1540 return -ENOMEM; 1541 1542 di = btrfs_lookup_dir_item(NULL, root, path, 1543 dir, name, name_len, 0); 1544 if (!di) { 1545 ret = -ENOENT; 1546 goto out; 1547 } 1548 if (IS_ERR(di)) { 1549 ret = PTR_ERR(di); 1550 goto out; 1551 } 1552 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &key); 1553 *found_inode = key.objectid; 1554 *found_type = btrfs_dir_type(path->nodes[0], di); 1555 1556 out: 1557 btrfs_free_path(path); 1558 return ret; 1559 } 1560 1561 /* 1562 * Looks up the first btrfs_inode_ref of a given ino. It returns the parent dir, 1563 * generation of the parent dir and the name of the dir entry. 1564 */ 1565 static int get_first_ref(struct send_ctx *sctx, 1566 struct btrfs_root *root, u64 ino, 1567 u64 *dir, u64 *dir_gen, struct fs_path *name) 1568 { 1569 int ret; 1570 struct btrfs_key key; 1571 struct btrfs_key found_key; 1572 struct btrfs_path *path; 1573 int len; 1574 u64 parent_dir; 1575 1576 path = alloc_path_for_send(); 1577 if (!path) 1578 return -ENOMEM; 1579 1580 key.objectid = ino; 1581 key.type = BTRFS_INODE_REF_KEY; 1582 key.offset = 0; 1583 1584 ret = btrfs_search_slot_for_read(root, &key, path, 1, 0); 1585 if (ret < 0) 1586 goto out; 1587 if (!ret) 1588 btrfs_item_key_to_cpu(path->nodes[0], &found_key, 1589 path->slots[0]); 1590 if (ret || found_key.objectid != ino || 1591 (found_key.type != BTRFS_INODE_REF_KEY && 1592 found_key.type != BTRFS_INODE_EXTREF_KEY)) { 1593 ret = -ENOENT; 1594 goto out; 1595 } 1596 1597 if (key.type == BTRFS_INODE_REF_KEY) { 1598 struct btrfs_inode_ref *iref; 1599 iref = btrfs_item_ptr(path->nodes[0], path->slots[0], 1600 struct btrfs_inode_ref); 1601 len = btrfs_inode_ref_name_len(path->nodes[0], iref); 1602 ret = fs_path_add_from_extent_buffer(name, path->nodes[0], 1603 (unsigned long)(iref + 1), 1604 len); 1605 parent_dir = found_key.offset; 1606 } else { 1607 struct btrfs_inode_extref *extref; 1608 extref = btrfs_item_ptr(path->nodes[0], path->slots[0], 1609 struct btrfs_inode_extref); 1610 len = btrfs_inode_extref_name_len(path->nodes[0], extref); 1611 ret = fs_path_add_from_extent_buffer(name, path->nodes[0], 1612 (unsigned long)&extref->name, len); 1613 parent_dir = btrfs_inode_extref_parent(path->nodes[0], extref); 1614 } 1615 if (ret < 0) 1616 goto out; 1617 btrfs_release_path(path); 1618 1619 ret = get_inode_info(root, parent_dir, NULL, dir_gen, NULL, NULL, 1620 NULL, NULL); 1621 if (ret < 0) 1622 goto out; 1623 1624 *dir = parent_dir; 1625 1626 out: 1627 btrfs_free_path(path); 1628 return ret; 1629 } 1630 1631 static int is_first_ref(struct send_ctx *sctx, 1632 struct btrfs_root *root, 1633 u64 ino, u64 dir, 1634 const char *name, int name_len) 1635 { 1636 int ret; 1637 struct fs_path *tmp_name; 1638 u64 tmp_dir; 1639 u64 tmp_dir_gen; 1640 1641 tmp_name = fs_path_alloc(sctx); 1642 if (!tmp_name) 1643 return -ENOMEM; 1644 1645 ret = get_first_ref(sctx, root, ino, &tmp_dir, &tmp_dir_gen, tmp_name); 1646 if (ret < 0) 1647 goto out; 1648 1649 if (dir != tmp_dir || name_len != fs_path_len(tmp_name)) { 1650 ret = 0; 1651 goto out; 1652 } 1653 1654 ret = !memcmp(tmp_name->start, name, name_len); 1655 1656 out: 1657 fs_path_free(sctx, tmp_name); 1658 return ret; 1659 } 1660 1661 /* 1662 * Used by process_recorded_refs to determine if a new ref would overwrite an 1663 * already existing ref. In case it detects an overwrite, it returns the 1664 * inode/gen in who_ino/who_gen. 1665 * When an overwrite is detected, process_recorded_refs does proper orphanizing 1666 * to make sure later references to the overwritten inode are possible. 1667 * Orphanizing is however only required for the first ref of an inode. 1668 * process_recorded_refs does an additional is_first_ref check to see if 1669 * orphanizing is really required. 1670 */ 1671 static int will_overwrite_ref(struct send_ctx *sctx, u64 dir, u64 dir_gen, 1672 const char *name, int name_len, 1673 u64 *who_ino, u64 *who_gen) 1674 { 1675 int ret = 0; 1676 u64 other_inode = 0; 1677 u8 other_type = 0; 1678 1679 if (!sctx->parent_root) 1680 goto out; 1681 1682 ret = is_inode_existent(sctx, dir, dir_gen); 1683 if (ret <= 0) 1684 goto out; 1685 1686 ret = lookup_dir_item_inode(sctx->parent_root, dir, name, name_len, 1687 &other_inode, &other_type); 1688 if (ret < 0 && ret != -ENOENT) 1689 goto out; 1690 if (ret) { 1691 ret = 0; 1692 goto out; 1693 } 1694 1695 /* 1696 * Check if the overwritten ref was already processed. If yes, the ref 1697 * was already unlinked/moved, so we can safely assume that we will not 1698 * overwrite anything at this point in time. 1699 */ 1700 if (other_inode > sctx->send_progress) { 1701 ret = get_inode_info(sctx->parent_root, other_inode, NULL, 1702 who_gen, NULL, NULL, NULL, NULL); 1703 if (ret < 0) 1704 goto out; 1705 1706 ret = 1; 1707 *who_ino = other_inode; 1708 } else { 1709 ret = 0; 1710 } 1711 1712 out: 1713 return ret; 1714 } 1715 1716 /* 1717 * Checks if the ref was overwritten by an already processed inode. This is 1718 * used by __get_cur_name_and_parent to find out if the ref was orphanized and 1719 * thus the orphan name needs be used. 1720 * process_recorded_refs also uses it to avoid unlinking of refs that were 1721 * overwritten. 1722 */ 1723 static int did_overwrite_ref(struct send_ctx *sctx, 1724 u64 dir, u64 dir_gen, 1725 u64 ino, u64 ino_gen, 1726 const char *name, int name_len) 1727 { 1728 int ret = 0; 1729 u64 gen; 1730 u64 ow_inode; 1731 u8 other_type; 1732 1733 if (!sctx->parent_root) 1734 goto out; 1735 1736 ret = is_inode_existent(sctx, dir, dir_gen); 1737 if (ret <= 0) 1738 goto out; 1739 1740 /* check if the ref was overwritten by another ref */ 1741 ret = lookup_dir_item_inode(sctx->send_root, dir, name, name_len, 1742 &ow_inode, &other_type); 1743 if (ret < 0 && ret != -ENOENT) 1744 goto out; 1745 if (ret) { 1746 /* was never and will never be overwritten */ 1747 ret = 0; 1748 goto out; 1749 } 1750 1751 ret = get_inode_info(sctx->send_root, ow_inode, NULL, &gen, NULL, NULL, 1752 NULL, NULL); 1753 if (ret < 0) 1754 goto out; 1755 1756 if (ow_inode == ino && gen == ino_gen) { 1757 ret = 0; 1758 goto out; 1759 } 1760 1761 /* we know that it is or will be overwritten. check this now */ 1762 if (ow_inode < sctx->send_progress) 1763 ret = 1; 1764 else 1765 ret = 0; 1766 1767 out: 1768 return ret; 1769 } 1770 1771 /* 1772 * Same as did_overwrite_ref, but also checks if it is the first ref of an inode 1773 * that got overwritten. This is used by process_recorded_refs to determine 1774 * if it has to use the path as returned by get_cur_path or the orphan name. 1775 */ 1776 static int did_overwrite_first_ref(struct send_ctx *sctx, u64 ino, u64 gen) 1777 { 1778 int ret = 0; 1779 struct fs_path *name = NULL; 1780 u64 dir; 1781 u64 dir_gen; 1782 1783 if (!sctx->parent_root) 1784 goto out; 1785 1786 name = fs_path_alloc(sctx); 1787 if (!name) 1788 return -ENOMEM; 1789 1790 ret = get_first_ref(sctx, sctx->parent_root, ino, &dir, &dir_gen, name); 1791 if (ret < 0) 1792 goto out; 1793 1794 ret = did_overwrite_ref(sctx, dir, dir_gen, ino, gen, 1795 name->start, fs_path_len(name)); 1796 1797 out: 1798 fs_path_free(sctx, name); 1799 return ret; 1800 } 1801 1802 /* 1803 * Insert a name cache entry. On 32bit kernels the radix tree index is 32bit, 1804 * so we need to do some special handling in case we have clashes. This function 1805 * takes care of this with the help of name_cache_entry::radix_list. 1806 * In case of error, nce is kfreed. 1807 */ 1808 static int name_cache_insert(struct send_ctx *sctx, 1809 struct name_cache_entry *nce) 1810 { 1811 int ret = 0; 1812 struct list_head *nce_head; 1813 1814 nce_head = radix_tree_lookup(&sctx->name_cache, 1815 (unsigned long)nce->ino); 1816 if (!nce_head) { 1817 nce_head = kmalloc(sizeof(*nce_head), GFP_NOFS); 1818 if (!nce_head) { 1819 kfree(nce); 1820 return -ENOMEM; 1821 } 1822 INIT_LIST_HEAD(nce_head); 1823 1824 ret = radix_tree_insert(&sctx->name_cache, nce->ino, nce_head); 1825 if (ret < 0) { 1826 kfree(nce_head); 1827 kfree(nce); 1828 return ret; 1829 } 1830 } 1831 list_add_tail(&nce->radix_list, nce_head); 1832 list_add_tail(&nce->list, &sctx->name_cache_list); 1833 sctx->name_cache_size++; 1834 1835 return ret; 1836 } 1837 1838 static void name_cache_delete(struct send_ctx *sctx, 1839 struct name_cache_entry *nce) 1840 { 1841 struct list_head *nce_head; 1842 1843 nce_head = radix_tree_lookup(&sctx->name_cache, 1844 (unsigned long)nce->ino); 1845 BUG_ON(!nce_head); 1846 1847 list_del(&nce->radix_list); 1848 list_del(&nce->list); 1849 sctx->name_cache_size--; 1850 1851 if (list_empty(nce_head)) { 1852 radix_tree_delete(&sctx->name_cache, (unsigned long)nce->ino); 1853 kfree(nce_head); 1854 } 1855 } 1856 1857 static struct name_cache_entry *name_cache_search(struct send_ctx *sctx, 1858 u64 ino, u64 gen) 1859 { 1860 struct list_head *nce_head; 1861 struct name_cache_entry *cur; 1862 1863 nce_head = radix_tree_lookup(&sctx->name_cache, (unsigned long)ino); 1864 if (!nce_head) 1865 return NULL; 1866 1867 list_for_each_entry(cur, nce_head, radix_list) { 1868 if (cur->ino == ino && cur->gen == gen) 1869 return cur; 1870 } 1871 return NULL; 1872 } 1873 1874 /* 1875 * Removes the entry from the list and adds it back to the end. This marks the 1876 * entry as recently used so that name_cache_clean_unused does not remove it. 1877 */ 1878 static void name_cache_used(struct send_ctx *sctx, struct name_cache_entry *nce) 1879 { 1880 list_del(&nce->list); 1881 list_add_tail(&nce->list, &sctx->name_cache_list); 1882 } 1883 1884 /* 1885 * Remove some entries from the beginning of name_cache_list. 1886 */ 1887 static void name_cache_clean_unused(struct send_ctx *sctx) 1888 { 1889 struct name_cache_entry *nce; 1890 1891 if (sctx->name_cache_size < SEND_CTX_NAME_CACHE_CLEAN_SIZE) 1892 return; 1893 1894 while (sctx->name_cache_size > SEND_CTX_MAX_NAME_CACHE_SIZE) { 1895 nce = list_entry(sctx->name_cache_list.next, 1896 struct name_cache_entry, list); 1897 name_cache_delete(sctx, nce); 1898 kfree(nce); 1899 } 1900 } 1901 1902 static void name_cache_free(struct send_ctx *sctx) 1903 { 1904 struct name_cache_entry *nce; 1905 1906 while (!list_empty(&sctx->name_cache_list)) { 1907 nce = list_entry(sctx->name_cache_list.next, 1908 struct name_cache_entry, list); 1909 name_cache_delete(sctx, nce); 1910 kfree(nce); 1911 } 1912 } 1913 1914 /* 1915 * Used by get_cur_path for each ref up to the root. 1916 * Returns 0 if it succeeded. 1917 * Returns 1 if the inode is not existent or got overwritten. In that case, the 1918 * name is an orphan name. This instructs get_cur_path to stop iterating. If 1 1919 * is returned, parent_ino/parent_gen are not guaranteed to be valid. 1920 * Returns <0 in case of error. 1921 */ 1922 static int __get_cur_name_and_parent(struct send_ctx *sctx, 1923 u64 ino, u64 gen, 1924 u64 *parent_ino, 1925 u64 *parent_gen, 1926 struct fs_path *dest) 1927 { 1928 int ret; 1929 int nce_ret; 1930 struct btrfs_path *path = NULL; 1931 struct name_cache_entry *nce = NULL; 1932 1933 /* 1934 * First check if we already did a call to this function with the same 1935 * ino/gen. If yes, check if the cache entry is still up-to-date. If yes 1936 * return the cached result. 1937 */ 1938 nce = name_cache_search(sctx, ino, gen); 1939 if (nce) { 1940 if (ino < sctx->send_progress && nce->need_later_update) { 1941 name_cache_delete(sctx, nce); 1942 kfree(nce); 1943 nce = NULL; 1944 } else { 1945 name_cache_used(sctx, nce); 1946 *parent_ino = nce->parent_ino; 1947 *parent_gen = nce->parent_gen; 1948 ret = fs_path_add(dest, nce->name, nce->name_len); 1949 if (ret < 0) 1950 goto out; 1951 ret = nce->ret; 1952 goto out; 1953 } 1954 } 1955 1956 path = alloc_path_for_send(); 1957 if (!path) 1958 return -ENOMEM; 1959 1960 /* 1961 * If the inode is not existent yet, add the orphan name and return 1. 1962 * This should only happen for the parent dir that we determine in 1963 * __record_new_ref 1964 */ 1965 ret = is_inode_existent(sctx, ino, gen); 1966 if (ret < 0) 1967 goto out; 1968 1969 if (!ret) { 1970 ret = gen_unique_name(sctx, ino, gen, dest); 1971 if (ret < 0) 1972 goto out; 1973 ret = 1; 1974 goto out_cache; 1975 } 1976 1977 /* 1978 * Depending on whether the inode was already processed or not, use 1979 * send_root or parent_root for ref lookup. 1980 */ 1981 if (ino < sctx->send_progress) 1982 ret = get_first_ref(sctx, sctx->send_root, ino, 1983 parent_ino, parent_gen, dest); 1984 else 1985 ret = get_first_ref(sctx, sctx->parent_root, ino, 1986 parent_ino, parent_gen, dest); 1987 if (ret < 0) 1988 goto out; 1989 1990 /* 1991 * Check if the ref was overwritten by an inode's ref that was processed 1992 * earlier. If yes, treat as orphan and return 1. 1993 */ 1994 ret = did_overwrite_ref(sctx, *parent_ino, *parent_gen, ino, gen, 1995 dest->start, dest->end - dest->start); 1996 if (ret < 0) 1997 goto out; 1998 if (ret) { 1999 fs_path_reset(dest); 2000 ret = gen_unique_name(sctx, ino, gen, dest); 2001 if (ret < 0) 2002 goto out; 2003 ret = 1; 2004 } 2005 2006 out_cache: 2007 /* 2008 * Store the result of the lookup in the name cache. 2009 */ 2010 nce = kmalloc(sizeof(*nce) + fs_path_len(dest) + 1, GFP_NOFS); 2011 if (!nce) { 2012 ret = -ENOMEM; 2013 goto out; 2014 } 2015 2016 nce->ino = ino; 2017 nce->gen = gen; 2018 nce->parent_ino = *parent_ino; 2019 nce->parent_gen = *parent_gen; 2020 nce->name_len = fs_path_len(dest); 2021 nce->ret = ret; 2022 strcpy(nce->name, dest->start); 2023 2024 if (ino < sctx->send_progress) 2025 nce->need_later_update = 0; 2026 else 2027 nce->need_later_update = 1; 2028 2029 nce_ret = name_cache_insert(sctx, nce); 2030 if (nce_ret < 0) 2031 ret = nce_ret; 2032 name_cache_clean_unused(sctx); 2033 2034 out: 2035 btrfs_free_path(path); 2036 return ret; 2037 } 2038 2039 /* 2040 * Magic happens here. This function returns the first ref to an inode as it 2041 * would look like while receiving the stream at this point in time. 2042 * We walk the path up to the root. For every inode in between, we check if it 2043 * was already processed/sent. If yes, we continue with the parent as found 2044 * in send_root. If not, we continue with the parent as found in parent_root. 2045 * If we encounter an inode that was deleted at this point in time, we use the 2046 * inodes "orphan" name instead of the real name and stop. Same with new inodes 2047 * that were not created yet and overwritten inodes/refs. 2048 * 2049 * When do we have have orphan inodes: 2050 * 1. When an inode is freshly created and thus no valid refs are available yet 2051 * 2. When a directory lost all it's refs (deleted) but still has dir items 2052 * inside which were not processed yet (pending for move/delete). If anyone 2053 * tried to get the path to the dir items, it would get a path inside that 2054 * orphan directory. 2055 * 3. When an inode is moved around or gets new links, it may overwrite the ref 2056 * of an unprocessed inode. If in that case the first ref would be 2057 * overwritten, the overwritten inode gets "orphanized". Later when we 2058 * process this overwritten inode, it is restored at a new place by moving 2059 * the orphan inode. 2060 * 2061 * sctx->send_progress tells this function at which point in time receiving 2062 * would be. 2063 */ 2064 static int get_cur_path(struct send_ctx *sctx, u64 ino, u64 gen, 2065 struct fs_path *dest) 2066 { 2067 int ret = 0; 2068 struct fs_path *name = NULL; 2069 u64 parent_inode = 0; 2070 u64 parent_gen = 0; 2071 int stop = 0; 2072 2073 name = fs_path_alloc(sctx); 2074 if (!name) { 2075 ret = -ENOMEM; 2076 goto out; 2077 } 2078 2079 dest->reversed = 1; 2080 fs_path_reset(dest); 2081 2082 while (!stop && ino != BTRFS_FIRST_FREE_OBJECTID) { 2083 fs_path_reset(name); 2084 2085 ret = __get_cur_name_and_parent(sctx, ino, gen, 2086 &parent_inode, &parent_gen, name); 2087 if (ret < 0) 2088 goto out; 2089 if (ret) 2090 stop = 1; 2091 2092 ret = fs_path_add_path(dest, name); 2093 if (ret < 0) 2094 goto out; 2095 2096 ino = parent_inode; 2097 gen = parent_gen; 2098 } 2099 2100 out: 2101 fs_path_free(sctx, name); 2102 if (!ret) 2103 fs_path_unreverse(dest); 2104 return ret; 2105 } 2106 2107 /* 2108 * Called for regular files when sending extents data. Opens a struct file 2109 * to read from the file. 2110 */ 2111 static int open_cur_inode_file(struct send_ctx *sctx) 2112 { 2113 int ret = 0; 2114 struct btrfs_key key; 2115 struct path path; 2116 struct inode *inode; 2117 struct dentry *dentry; 2118 struct file *filp; 2119 int new = 0; 2120 2121 if (sctx->cur_inode_filp) 2122 goto out; 2123 2124 key.objectid = sctx->cur_ino; 2125 key.type = BTRFS_INODE_ITEM_KEY; 2126 key.offset = 0; 2127 2128 inode = btrfs_iget(sctx->send_root->fs_info->sb, &key, sctx->send_root, 2129 &new); 2130 if (IS_ERR(inode)) { 2131 ret = PTR_ERR(inode); 2132 goto out; 2133 } 2134 2135 dentry = d_obtain_alias(inode); 2136 inode = NULL; 2137 if (IS_ERR(dentry)) { 2138 ret = PTR_ERR(dentry); 2139 goto out; 2140 } 2141 2142 path.mnt = sctx->mnt; 2143 path.dentry = dentry; 2144 filp = dentry_open(&path, O_RDONLY | O_LARGEFILE, current_cred()); 2145 dput(dentry); 2146 dentry = NULL; 2147 if (IS_ERR(filp)) { 2148 ret = PTR_ERR(filp); 2149 goto out; 2150 } 2151 sctx->cur_inode_filp = filp; 2152 2153 out: 2154 /* 2155 * no xxxput required here as every vfs op 2156 * does it by itself on failure 2157 */ 2158 return ret; 2159 } 2160 2161 /* 2162 * Closes the struct file that was created in open_cur_inode_file 2163 */ 2164 static int close_cur_inode_file(struct send_ctx *sctx) 2165 { 2166 int ret = 0; 2167 2168 if (!sctx->cur_inode_filp) 2169 goto out; 2170 2171 ret = filp_close(sctx->cur_inode_filp, NULL); 2172 sctx->cur_inode_filp = NULL; 2173 2174 out: 2175 return ret; 2176 } 2177 2178 /* 2179 * Sends a BTRFS_SEND_C_SUBVOL command/item to userspace 2180 */ 2181 static int send_subvol_begin(struct send_ctx *sctx) 2182 { 2183 int ret; 2184 struct btrfs_root *send_root = sctx->send_root; 2185 struct btrfs_root *parent_root = sctx->parent_root; 2186 struct btrfs_path *path; 2187 struct btrfs_key key; 2188 struct btrfs_root_ref *ref; 2189 struct extent_buffer *leaf; 2190 char *name = NULL; 2191 int namelen; 2192 2193 path = alloc_path_for_send(); 2194 if (!path) 2195 return -ENOMEM; 2196 2197 name = kmalloc(BTRFS_PATH_NAME_MAX, GFP_NOFS); 2198 if (!name) { 2199 btrfs_free_path(path); 2200 return -ENOMEM; 2201 } 2202 2203 key.objectid = send_root->objectid; 2204 key.type = BTRFS_ROOT_BACKREF_KEY; 2205 key.offset = 0; 2206 2207 ret = btrfs_search_slot_for_read(send_root->fs_info->tree_root, 2208 &key, path, 1, 0); 2209 if (ret < 0) 2210 goto out; 2211 if (ret) { 2212 ret = -ENOENT; 2213 goto out; 2214 } 2215 2216 leaf = path->nodes[0]; 2217 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); 2218 if (key.type != BTRFS_ROOT_BACKREF_KEY || 2219 key.objectid != send_root->objectid) { 2220 ret = -ENOENT; 2221 goto out; 2222 } 2223 ref = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_root_ref); 2224 namelen = btrfs_root_ref_name_len(leaf, ref); 2225 read_extent_buffer(leaf, name, (unsigned long)(ref + 1), namelen); 2226 btrfs_release_path(path); 2227 2228 if (parent_root) { 2229 ret = begin_cmd(sctx, BTRFS_SEND_C_SNAPSHOT); 2230 if (ret < 0) 2231 goto out; 2232 } else { 2233 ret = begin_cmd(sctx, BTRFS_SEND_C_SUBVOL); 2234 if (ret < 0) 2235 goto out; 2236 } 2237 2238 TLV_PUT_STRING(sctx, BTRFS_SEND_A_PATH, name, namelen); 2239 TLV_PUT_UUID(sctx, BTRFS_SEND_A_UUID, 2240 sctx->send_root->root_item.uuid); 2241 TLV_PUT_U64(sctx, BTRFS_SEND_A_CTRANSID, 2242 sctx->send_root->root_item.ctransid); 2243 if (parent_root) { 2244 TLV_PUT_UUID(sctx, BTRFS_SEND_A_CLONE_UUID, 2245 sctx->parent_root->root_item.uuid); 2246 TLV_PUT_U64(sctx, BTRFS_SEND_A_CLONE_CTRANSID, 2247 sctx->parent_root->root_item.ctransid); 2248 } 2249 2250 ret = send_cmd(sctx); 2251 2252 tlv_put_failure: 2253 out: 2254 btrfs_free_path(path); 2255 kfree(name); 2256 return ret; 2257 } 2258 2259 static int send_truncate(struct send_ctx *sctx, u64 ino, u64 gen, u64 size) 2260 { 2261 int ret = 0; 2262 struct fs_path *p; 2263 2264 verbose_printk("btrfs: send_truncate %llu size=%llu\n", ino, size); 2265 2266 p = fs_path_alloc(sctx); 2267 if (!p) 2268 return -ENOMEM; 2269 2270 ret = begin_cmd(sctx, BTRFS_SEND_C_TRUNCATE); 2271 if (ret < 0) 2272 goto out; 2273 2274 ret = get_cur_path(sctx, ino, gen, p); 2275 if (ret < 0) 2276 goto out; 2277 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p); 2278 TLV_PUT_U64(sctx, BTRFS_SEND_A_SIZE, size); 2279 2280 ret = send_cmd(sctx); 2281 2282 tlv_put_failure: 2283 out: 2284 fs_path_free(sctx, p); 2285 return ret; 2286 } 2287 2288 static int send_chmod(struct send_ctx *sctx, u64 ino, u64 gen, u64 mode) 2289 { 2290 int ret = 0; 2291 struct fs_path *p; 2292 2293 verbose_printk("btrfs: send_chmod %llu mode=%llu\n", ino, mode); 2294 2295 p = fs_path_alloc(sctx); 2296 if (!p) 2297 return -ENOMEM; 2298 2299 ret = begin_cmd(sctx, BTRFS_SEND_C_CHMOD); 2300 if (ret < 0) 2301 goto out; 2302 2303 ret = get_cur_path(sctx, ino, gen, p); 2304 if (ret < 0) 2305 goto out; 2306 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p); 2307 TLV_PUT_U64(sctx, BTRFS_SEND_A_MODE, mode & 07777); 2308 2309 ret = send_cmd(sctx); 2310 2311 tlv_put_failure: 2312 out: 2313 fs_path_free(sctx, p); 2314 return ret; 2315 } 2316 2317 static int send_chown(struct send_ctx *sctx, u64 ino, u64 gen, u64 uid, u64 gid) 2318 { 2319 int ret = 0; 2320 struct fs_path *p; 2321 2322 verbose_printk("btrfs: send_chown %llu uid=%llu, gid=%llu\n", ino, uid, gid); 2323 2324 p = fs_path_alloc(sctx); 2325 if (!p) 2326 return -ENOMEM; 2327 2328 ret = begin_cmd(sctx, BTRFS_SEND_C_CHOWN); 2329 if (ret < 0) 2330 goto out; 2331 2332 ret = get_cur_path(sctx, ino, gen, p); 2333 if (ret < 0) 2334 goto out; 2335 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p); 2336 TLV_PUT_U64(sctx, BTRFS_SEND_A_UID, uid); 2337 TLV_PUT_U64(sctx, BTRFS_SEND_A_GID, gid); 2338 2339 ret = send_cmd(sctx); 2340 2341 tlv_put_failure: 2342 out: 2343 fs_path_free(sctx, p); 2344 return ret; 2345 } 2346 2347 static int send_utimes(struct send_ctx *sctx, u64 ino, u64 gen) 2348 { 2349 int ret = 0; 2350 struct fs_path *p = NULL; 2351 struct btrfs_inode_item *ii; 2352 struct btrfs_path *path = NULL; 2353 struct extent_buffer *eb; 2354 struct btrfs_key key; 2355 int slot; 2356 2357 verbose_printk("btrfs: send_utimes %llu\n", ino); 2358 2359 p = fs_path_alloc(sctx); 2360 if (!p) 2361 return -ENOMEM; 2362 2363 path = alloc_path_for_send(); 2364 if (!path) { 2365 ret = -ENOMEM; 2366 goto out; 2367 } 2368 2369 key.objectid = ino; 2370 key.type = BTRFS_INODE_ITEM_KEY; 2371 key.offset = 0; 2372 ret = btrfs_search_slot(NULL, sctx->send_root, &key, path, 0, 0); 2373 if (ret < 0) 2374 goto out; 2375 2376 eb = path->nodes[0]; 2377 slot = path->slots[0]; 2378 ii = btrfs_item_ptr(eb, slot, struct btrfs_inode_item); 2379 2380 ret = begin_cmd(sctx, BTRFS_SEND_C_UTIMES); 2381 if (ret < 0) 2382 goto out; 2383 2384 ret = get_cur_path(sctx, ino, gen, p); 2385 if (ret < 0) 2386 goto out; 2387 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p); 2388 TLV_PUT_BTRFS_TIMESPEC(sctx, BTRFS_SEND_A_ATIME, eb, 2389 btrfs_inode_atime(ii)); 2390 TLV_PUT_BTRFS_TIMESPEC(sctx, BTRFS_SEND_A_MTIME, eb, 2391 btrfs_inode_mtime(ii)); 2392 TLV_PUT_BTRFS_TIMESPEC(sctx, BTRFS_SEND_A_CTIME, eb, 2393 btrfs_inode_ctime(ii)); 2394 /* TODO Add otime support when the otime patches get into upstream */ 2395 2396 ret = send_cmd(sctx); 2397 2398 tlv_put_failure: 2399 out: 2400 fs_path_free(sctx, p); 2401 btrfs_free_path(path); 2402 return ret; 2403 } 2404 2405 /* 2406 * Sends a BTRFS_SEND_C_MKXXX or SYMLINK command to user space. We don't have 2407 * a valid path yet because we did not process the refs yet. So, the inode 2408 * is created as orphan. 2409 */ 2410 static int send_create_inode(struct send_ctx *sctx, u64 ino) 2411 { 2412 int ret = 0; 2413 struct fs_path *p; 2414 int cmd; 2415 u64 gen; 2416 u64 mode; 2417 u64 rdev; 2418 2419 verbose_printk("btrfs: send_create_inode %llu\n", ino); 2420 2421 p = fs_path_alloc(sctx); 2422 if (!p) 2423 return -ENOMEM; 2424 2425 ret = get_inode_info(sctx->send_root, ino, NULL, &gen, &mode, NULL, 2426 NULL, &rdev); 2427 if (ret < 0) 2428 goto out; 2429 2430 if (S_ISREG(mode)) { 2431 cmd = BTRFS_SEND_C_MKFILE; 2432 } else if (S_ISDIR(mode)) { 2433 cmd = BTRFS_SEND_C_MKDIR; 2434 } else if (S_ISLNK(mode)) { 2435 cmd = BTRFS_SEND_C_SYMLINK; 2436 } else if (S_ISCHR(mode) || S_ISBLK(mode)) { 2437 cmd = BTRFS_SEND_C_MKNOD; 2438 } else if (S_ISFIFO(mode)) { 2439 cmd = BTRFS_SEND_C_MKFIFO; 2440 } else if (S_ISSOCK(mode)) { 2441 cmd = BTRFS_SEND_C_MKSOCK; 2442 } else { 2443 printk(KERN_WARNING "btrfs: unexpected inode type %o", 2444 (int)(mode & S_IFMT)); 2445 ret = -ENOTSUPP; 2446 goto out; 2447 } 2448 2449 ret = begin_cmd(sctx, cmd); 2450 if (ret < 0) 2451 goto out; 2452 2453 ret = gen_unique_name(sctx, ino, gen, p); 2454 if (ret < 0) 2455 goto out; 2456 2457 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p); 2458 TLV_PUT_U64(sctx, BTRFS_SEND_A_INO, ino); 2459 2460 if (S_ISLNK(mode)) { 2461 fs_path_reset(p); 2462 ret = read_symlink(sctx, sctx->send_root, ino, p); 2463 if (ret < 0) 2464 goto out; 2465 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH_LINK, p); 2466 } else if (S_ISCHR(mode) || S_ISBLK(mode) || 2467 S_ISFIFO(mode) || S_ISSOCK(mode)) { 2468 TLV_PUT_U64(sctx, BTRFS_SEND_A_RDEV, new_encode_dev(rdev)); 2469 TLV_PUT_U64(sctx, BTRFS_SEND_A_MODE, mode); 2470 } 2471 2472 ret = send_cmd(sctx); 2473 if (ret < 0) 2474 goto out; 2475 2476 2477 tlv_put_failure: 2478 out: 2479 fs_path_free(sctx, p); 2480 return ret; 2481 } 2482 2483 /* 2484 * We need some special handling for inodes that get processed before the parent 2485 * directory got created. See process_recorded_refs for details. 2486 * This function does the check if we already created the dir out of order. 2487 */ 2488 static int did_create_dir(struct send_ctx *sctx, u64 dir) 2489 { 2490 int ret = 0; 2491 struct btrfs_path *path = NULL; 2492 struct btrfs_key key; 2493 struct btrfs_key found_key; 2494 struct btrfs_key di_key; 2495 struct extent_buffer *eb; 2496 struct btrfs_dir_item *di; 2497 int slot; 2498 2499 path = alloc_path_for_send(); 2500 if (!path) { 2501 ret = -ENOMEM; 2502 goto out; 2503 } 2504 2505 key.objectid = dir; 2506 key.type = BTRFS_DIR_INDEX_KEY; 2507 key.offset = 0; 2508 while (1) { 2509 ret = btrfs_search_slot_for_read(sctx->send_root, &key, path, 2510 1, 0); 2511 if (ret < 0) 2512 goto out; 2513 if (!ret) { 2514 eb = path->nodes[0]; 2515 slot = path->slots[0]; 2516 btrfs_item_key_to_cpu(eb, &found_key, slot); 2517 } 2518 if (ret || found_key.objectid != key.objectid || 2519 found_key.type != key.type) { 2520 ret = 0; 2521 goto out; 2522 } 2523 2524 di = btrfs_item_ptr(eb, slot, struct btrfs_dir_item); 2525 btrfs_dir_item_key_to_cpu(eb, di, &di_key); 2526 2527 if (di_key.objectid < sctx->send_progress) { 2528 ret = 1; 2529 goto out; 2530 } 2531 2532 key.offset = found_key.offset + 1; 2533 btrfs_release_path(path); 2534 } 2535 2536 out: 2537 btrfs_free_path(path); 2538 return ret; 2539 } 2540 2541 /* 2542 * Only creates the inode if it is: 2543 * 1. Not a directory 2544 * 2. Or a directory which was not created already due to out of order 2545 * directories. See did_create_dir and process_recorded_refs for details. 2546 */ 2547 static int send_create_inode_if_needed(struct send_ctx *sctx) 2548 { 2549 int ret; 2550 2551 if (S_ISDIR(sctx->cur_inode_mode)) { 2552 ret = did_create_dir(sctx, sctx->cur_ino); 2553 if (ret < 0) 2554 goto out; 2555 if (ret) { 2556 ret = 0; 2557 goto out; 2558 } 2559 } 2560 2561 ret = send_create_inode(sctx, sctx->cur_ino); 2562 if (ret < 0) 2563 goto out; 2564 2565 out: 2566 return ret; 2567 } 2568 2569 struct recorded_ref { 2570 struct list_head list; 2571 char *dir_path; 2572 char *name; 2573 struct fs_path *full_path; 2574 u64 dir; 2575 u64 dir_gen; 2576 int dir_path_len; 2577 int name_len; 2578 }; 2579 2580 /* 2581 * We need to process new refs before deleted refs, but compare_tree gives us 2582 * everything mixed. So we first record all refs and later process them. 2583 * This function is a helper to record one ref. 2584 */ 2585 static int record_ref(struct list_head *head, u64 dir, 2586 u64 dir_gen, struct fs_path *path) 2587 { 2588 struct recorded_ref *ref; 2589 char *tmp; 2590 2591 ref = kmalloc(sizeof(*ref), GFP_NOFS); 2592 if (!ref) 2593 return -ENOMEM; 2594 2595 ref->dir = dir; 2596 ref->dir_gen = dir_gen; 2597 ref->full_path = path; 2598 2599 tmp = strrchr(ref->full_path->start, '/'); 2600 if (!tmp) { 2601 ref->name_len = ref->full_path->end - ref->full_path->start; 2602 ref->name = ref->full_path->start; 2603 ref->dir_path_len = 0; 2604 ref->dir_path = ref->full_path->start; 2605 } else { 2606 tmp++; 2607 ref->name_len = ref->full_path->end - tmp; 2608 ref->name = tmp; 2609 ref->dir_path = ref->full_path->start; 2610 ref->dir_path_len = ref->full_path->end - 2611 ref->full_path->start - 1 - ref->name_len; 2612 } 2613 2614 list_add_tail(&ref->list, head); 2615 return 0; 2616 } 2617 2618 static void __free_recorded_refs(struct send_ctx *sctx, struct list_head *head) 2619 { 2620 struct recorded_ref *cur; 2621 2622 while (!list_empty(head)) { 2623 cur = list_entry(head->next, struct recorded_ref, list); 2624 fs_path_free(sctx, cur->full_path); 2625 list_del(&cur->list); 2626 kfree(cur); 2627 } 2628 } 2629 2630 static void free_recorded_refs(struct send_ctx *sctx) 2631 { 2632 __free_recorded_refs(sctx, &sctx->new_refs); 2633 __free_recorded_refs(sctx, &sctx->deleted_refs); 2634 } 2635 2636 /* 2637 * Renames/moves a file/dir to its orphan name. Used when the first 2638 * ref of an unprocessed inode gets overwritten and for all non empty 2639 * directories. 2640 */ 2641 static int orphanize_inode(struct send_ctx *sctx, u64 ino, u64 gen, 2642 struct fs_path *path) 2643 { 2644 int ret; 2645 struct fs_path *orphan; 2646 2647 orphan = fs_path_alloc(sctx); 2648 if (!orphan) 2649 return -ENOMEM; 2650 2651 ret = gen_unique_name(sctx, ino, gen, orphan); 2652 if (ret < 0) 2653 goto out; 2654 2655 ret = send_rename(sctx, path, orphan); 2656 2657 out: 2658 fs_path_free(sctx, orphan); 2659 return ret; 2660 } 2661 2662 /* 2663 * Returns 1 if a directory can be removed at this point in time. 2664 * We check this by iterating all dir items and checking if the inode behind 2665 * the dir item was already processed. 2666 */ 2667 static int can_rmdir(struct send_ctx *sctx, u64 dir, u64 send_progress) 2668 { 2669 int ret = 0; 2670 struct btrfs_root *root = sctx->parent_root; 2671 struct btrfs_path *path; 2672 struct btrfs_key key; 2673 struct btrfs_key found_key; 2674 struct btrfs_key loc; 2675 struct btrfs_dir_item *di; 2676 2677 /* 2678 * Don't try to rmdir the top/root subvolume dir. 2679 */ 2680 if (dir == BTRFS_FIRST_FREE_OBJECTID) 2681 return 0; 2682 2683 path = alloc_path_for_send(); 2684 if (!path) 2685 return -ENOMEM; 2686 2687 key.objectid = dir; 2688 key.type = BTRFS_DIR_INDEX_KEY; 2689 key.offset = 0; 2690 2691 while (1) { 2692 ret = btrfs_search_slot_for_read(root, &key, path, 1, 0); 2693 if (ret < 0) 2694 goto out; 2695 if (!ret) { 2696 btrfs_item_key_to_cpu(path->nodes[0], &found_key, 2697 path->slots[0]); 2698 } 2699 if (ret || found_key.objectid != key.objectid || 2700 found_key.type != key.type) { 2701 break; 2702 } 2703 2704 di = btrfs_item_ptr(path->nodes[0], path->slots[0], 2705 struct btrfs_dir_item); 2706 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &loc); 2707 2708 if (loc.objectid > send_progress) { 2709 ret = 0; 2710 goto out; 2711 } 2712 2713 btrfs_release_path(path); 2714 key.offset = found_key.offset + 1; 2715 } 2716 2717 ret = 1; 2718 2719 out: 2720 btrfs_free_path(path); 2721 return ret; 2722 } 2723 2724 /* 2725 * This does all the move/link/unlink/rmdir magic. 2726 */ 2727 static int process_recorded_refs(struct send_ctx *sctx) 2728 { 2729 int ret = 0; 2730 struct recorded_ref *cur; 2731 struct recorded_ref *cur2; 2732 struct ulist *check_dirs = NULL; 2733 struct ulist_iterator uit; 2734 struct ulist_node *un; 2735 struct fs_path *valid_path = NULL; 2736 u64 ow_inode = 0; 2737 u64 ow_gen; 2738 int did_overwrite = 0; 2739 int is_orphan = 0; 2740 2741 verbose_printk("btrfs: process_recorded_refs %llu\n", sctx->cur_ino); 2742 2743 /* 2744 * This should never happen as the root dir always has the same ref 2745 * which is always '..' 2746 */ 2747 BUG_ON(sctx->cur_ino <= BTRFS_FIRST_FREE_OBJECTID); 2748 2749 valid_path = fs_path_alloc(sctx); 2750 if (!valid_path) { 2751 ret = -ENOMEM; 2752 goto out; 2753 } 2754 2755 check_dirs = ulist_alloc(GFP_NOFS); 2756 if (!check_dirs) { 2757 ret = -ENOMEM; 2758 goto out; 2759 } 2760 2761 /* 2762 * First, check if the first ref of the current inode was overwritten 2763 * before. If yes, we know that the current inode was already orphanized 2764 * and thus use the orphan name. If not, we can use get_cur_path to 2765 * get the path of the first ref as it would like while receiving at 2766 * this point in time. 2767 * New inodes are always orphan at the beginning, so force to use the 2768 * orphan name in this case. 2769 * The first ref is stored in valid_path and will be updated if it 2770 * gets moved around. 2771 */ 2772 if (!sctx->cur_inode_new) { 2773 ret = did_overwrite_first_ref(sctx, sctx->cur_ino, 2774 sctx->cur_inode_gen); 2775 if (ret < 0) 2776 goto out; 2777 if (ret) 2778 did_overwrite = 1; 2779 } 2780 if (sctx->cur_inode_new || did_overwrite) { 2781 ret = gen_unique_name(sctx, sctx->cur_ino, 2782 sctx->cur_inode_gen, valid_path); 2783 if (ret < 0) 2784 goto out; 2785 is_orphan = 1; 2786 } else { 2787 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, 2788 valid_path); 2789 if (ret < 0) 2790 goto out; 2791 } 2792 2793 list_for_each_entry(cur, &sctx->new_refs, list) { 2794 /* 2795 * We may have refs where the parent directory does not exist 2796 * yet. This happens if the parent directories inum is higher 2797 * the the current inum. To handle this case, we create the 2798 * parent directory out of order. But we need to check if this 2799 * did already happen before due to other refs in the same dir. 2800 */ 2801 ret = get_cur_inode_state(sctx, cur->dir, cur->dir_gen); 2802 if (ret < 0) 2803 goto out; 2804 if (ret == inode_state_will_create) { 2805 ret = 0; 2806 /* 2807 * First check if any of the current inodes refs did 2808 * already create the dir. 2809 */ 2810 list_for_each_entry(cur2, &sctx->new_refs, list) { 2811 if (cur == cur2) 2812 break; 2813 if (cur2->dir == cur->dir) { 2814 ret = 1; 2815 break; 2816 } 2817 } 2818 2819 /* 2820 * If that did not happen, check if a previous inode 2821 * did already create the dir. 2822 */ 2823 if (!ret) 2824 ret = did_create_dir(sctx, cur->dir); 2825 if (ret < 0) 2826 goto out; 2827 if (!ret) { 2828 ret = send_create_inode(sctx, cur->dir); 2829 if (ret < 0) 2830 goto out; 2831 } 2832 } 2833 2834 /* 2835 * Check if this new ref would overwrite the first ref of 2836 * another unprocessed inode. If yes, orphanize the 2837 * overwritten inode. If we find an overwritten ref that is 2838 * not the first ref, simply unlink it. 2839 */ 2840 ret = will_overwrite_ref(sctx, cur->dir, cur->dir_gen, 2841 cur->name, cur->name_len, 2842 &ow_inode, &ow_gen); 2843 if (ret < 0) 2844 goto out; 2845 if (ret) { 2846 ret = is_first_ref(sctx, sctx->parent_root, 2847 ow_inode, cur->dir, cur->name, 2848 cur->name_len); 2849 if (ret < 0) 2850 goto out; 2851 if (ret) { 2852 ret = orphanize_inode(sctx, ow_inode, ow_gen, 2853 cur->full_path); 2854 if (ret < 0) 2855 goto out; 2856 } else { 2857 ret = send_unlink(sctx, cur->full_path); 2858 if (ret < 0) 2859 goto out; 2860 } 2861 } 2862 2863 /* 2864 * link/move the ref to the new place. If we have an orphan 2865 * inode, move it and update valid_path. If not, link or move 2866 * it depending on the inode mode. 2867 */ 2868 if (is_orphan) { 2869 ret = send_rename(sctx, valid_path, cur->full_path); 2870 if (ret < 0) 2871 goto out; 2872 is_orphan = 0; 2873 ret = fs_path_copy(valid_path, cur->full_path); 2874 if (ret < 0) 2875 goto out; 2876 } else { 2877 if (S_ISDIR(sctx->cur_inode_mode)) { 2878 /* 2879 * Dirs can't be linked, so move it. For moved 2880 * dirs, we always have one new and one deleted 2881 * ref. The deleted ref is ignored later. 2882 */ 2883 ret = send_rename(sctx, valid_path, 2884 cur->full_path); 2885 if (ret < 0) 2886 goto out; 2887 ret = fs_path_copy(valid_path, cur->full_path); 2888 if (ret < 0) 2889 goto out; 2890 } else { 2891 ret = send_link(sctx, cur->full_path, 2892 valid_path); 2893 if (ret < 0) 2894 goto out; 2895 } 2896 } 2897 ret = ulist_add(check_dirs, cur->dir, cur->dir_gen, 2898 GFP_NOFS); 2899 if (ret < 0) 2900 goto out; 2901 } 2902 2903 if (S_ISDIR(sctx->cur_inode_mode) && sctx->cur_inode_deleted) { 2904 /* 2905 * Check if we can already rmdir the directory. If not, 2906 * orphanize it. For every dir item inside that gets deleted 2907 * later, we do this check again and rmdir it then if possible. 2908 * See the use of check_dirs for more details. 2909 */ 2910 ret = can_rmdir(sctx, sctx->cur_ino, sctx->cur_ino); 2911 if (ret < 0) 2912 goto out; 2913 if (ret) { 2914 ret = send_rmdir(sctx, valid_path); 2915 if (ret < 0) 2916 goto out; 2917 } else if (!is_orphan) { 2918 ret = orphanize_inode(sctx, sctx->cur_ino, 2919 sctx->cur_inode_gen, valid_path); 2920 if (ret < 0) 2921 goto out; 2922 is_orphan = 1; 2923 } 2924 2925 list_for_each_entry(cur, &sctx->deleted_refs, list) { 2926 ret = ulist_add(check_dirs, cur->dir, cur->dir_gen, 2927 GFP_NOFS); 2928 if (ret < 0) 2929 goto out; 2930 } 2931 } else if (S_ISDIR(sctx->cur_inode_mode) && 2932 !list_empty(&sctx->deleted_refs)) { 2933 /* 2934 * We have a moved dir. Add the old parent to check_dirs 2935 */ 2936 cur = list_entry(sctx->deleted_refs.next, struct recorded_ref, 2937 list); 2938 ret = ulist_add(check_dirs, cur->dir, cur->dir_gen, 2939 GFP_NOFS); 2940 if (ret < 0) 2941 goto out; 2942 } else if (!S_ISDIR(sctx->cur_inode_mode)) { 2943 /* 2944 * We have a non dir inode. Go through all deleted refs and 2945 * unlink them if they were not already overwritten by other 2946 * inodes. 2947 */ 2948 list_for_each_entry(cur, &sctx->deleted_refs, list) { 2949 ret = did_overwrite_ref(sctx, cur->dir, cur->dir_gen, 2950 sctx->cur_ino, sctx->cur_inode_gen, 2951 cur->name, cur->name_len); 2952 if (ret < 0) 2953 goto out; 2954 if (!ret) { 2955 ret = send_unlink(sctx, cur->full_path); 2956 if (ret < 0) 2957 goto out; 2958 } 2959 ret = ulist_add(check_dirs, cur->dir, cur->dir_gen, 2960 GFP_NOFS); 2961 if (ret < 0) 2962 goto out; 2963 } 2964 2965 /* 2966 * If the inode is still orphan, unlink the orphan. This may 2967 * happen when a previous inode did overwrite the first ref 2968 * of this inode and no new refs were added for the current 2969 * inode. Unlinking does not mean that the inode is deleted in 2970 * all cases. There may still be links to this inode in other 2971 * places. 2972 */ 2973 if (is_orphan) { 2974 ret = send_unlink(sctx, valid_path); 2975 if (ret < 0) 2976 goto out; 2977 } 2978 } 2979 2980 /* 2981 * We did collect all parent dirs where cur_inode was once located. We 2982 * now go through all these dirs and check if they are pending for 2983 * deletion and if it's finally possible to perform the rmdir now. 2984 * We also update the inode stats of the parent dirs here. 2985 */ 2986 ULIST_ITER_INIT(&uit); 2987 while ((un = ulist_next(check_dirs, &uit))) { 2988 /* 2989 * In case we had refs into dirs that were not processed yet, 2990 * we don't need to do the utime and rmdir logic for these dirs. 2991 * The dir will be processed later. 2992 */ 2993 if (un->val > sctx->cur_ino) 2994 continue; 2995 2996 ret = get_cur_inode_state(sctx, un->val, un->aux); 2997 if (ret < 0) 2998 goto out; 2999 3000 if (ret == inode_state_did_create || 3001 ret == inode_state_no_change) { 3002 /* TODO delayed utimes */ 3003 ret = send_utimes(sctx, un->val, un->aux); 3004 if (ret < 0) 3005 goto out; 3006 } else if (ret == inode_state_did_delete) { 3007 ret = can_rmdir(sctx, un->val, sctx->cur_ino); 3008 if (ret < 0) 3009 goto out; 3010 if (ret) { 3011 ret = get_cur_path(sctx, un->val, un->aux, 3012 valid_path); 3013 if (ret < 0) 3014 goto out; 3015 ret = send_rmdir(sctx, valid_path); 3016 if (ret < 0) 3017 goto out; 3018 } 3019 } 3020 } 3021 3022 ret = 0; 3023 3024 out: 3025 free_recorded_refs(sctx); 3026 ulist_free(check_dirs); 3027 fs_path_free(sctx, valid_path); 3028 return ret; 3029 } 3030 3031 static int __record_new_ref(int num, u64 dir, int index, 3032 struct fs_path *name, 3033 void *ctx) 3034 { 3035 int ret = 0; 3036 struct send_ctx *sctx = ctx; 3037 struct fs_path *p; 3038 u64 gen; 3039 3040 p = fs_path_alloc(sctx); 3041 if (!p) 3042 return -ENOMEM; 3043 3044 ret = get_inode_info(sctx->send_root, dir, NULL, &gen, NULL, NULL, 3045 NULL, NULL); 3046 if (ret < 0) 3047 goto out; 3048 3049 ret = get_cur_path(sctx, dir, gen, p); 3050 if (ret < 0) 3051 goto out; 3052 ret = fs_path_add_path(p, name); 3053 if (ret < 0) 3054 goto out; 3055 3056 ret = record_ref(&sctx->new_refs, dir, gen, p); 3057 3058 out: 3059 if (ret) 3060 fs_path_free(sctx, p); 3061 return ret; 3062 } 3063 3064 static int __record_deleted_ref(int num, u64 dir, int index, 3065 struct fs_path *name, 3066 void *ctx) 3067 { 3068 int ret = 0; 3069 struct send_ctx *sctx = ctx; 3070 struct fs_path *p; 3071 u64 gen; 3072 3073 p = fs_path_alloc(sctx); 3074 if (!p) 3075 return -ENOMEM; 3076 3077 ret = get_inode_info(sctx->parent_root, dir, NULL, &gen, NULL, NULL, 3078 NULL, NULL); 3079 if (ret < 0) 3080 goto out; 3081 3082 ret = get_cur_path(sctx, dir, gen, p); 3083 if (ret < 0) 3084 goto out; 3085 ret = fs_path_add_path(p, name); 3086 if (ret < 0) 3087 goto out; 3088 3089 ret = record_ref(&sctx->deleted_refs, dir, gen, p); 3090 3091 out: 3092 if (ret) 3093 fs_path_free(sctx, p); 3094 return ret; 3095 } 3096 3097 static int record_new_ref(struct send_ctx *sctx) 3098 { 3099 int ret; 3100 3101 ret = iterate_inode_ref(sctx, sctx->send_root, sctx->left_path, 3102 sctx->cmp_key, 0, __record_new_ref, sctx); 3103 if (ret < 0) 3104 goto out; 3105 ret = 0; 3106 3107 out: 3108 return ret; 3109 } 3110 3111 static int record_deleted_ref(struct send_ctx *sctx) 3112 { 3113 int ret; 3114 3115 ret = iterate_inode_ref(sctx, sctx->parent_root, sctx->right_path, 3116 sctx->cmp_key, 0, __record_deleted_ref, sctx); 3117 if (ret < 0) 3118 goto out; 3119 ret = 0; 3120 3121 out: 3122 return ret; 3123 } 3124 3125 struct find_ref_ctx { 3126 u64 dir; 3127 struct fs_path *name; 3128 int found_idx; 3129 }; 3130 3131 static int __find_iref(int num, u64 dir, int index, 3132 struct fs_path *name, 3133 void *ctx_) 3134 { 3135 struct find_ref_ctx *ctx = ctx_; 3136 3137 if (dir == ctx->dir && fs_path_len(name) == fs_path_len(ctx->name) && 3138 strncmp(name->start, ctx->name->start, fs_path_len(name)) == 0) { 3139 ctx->found_idx = num; 3140 return 1; 3141 } 3142 return 0; 3143 } 3144 3145 static int find_iref(struct send_ctx *sctx, 3146 struct btrfs_root *root, 3147 struct btrfs_path *path, 3148 struct btrfs_key *key, 3149 u64 dir, struct fs_path *name) 3150 { 3151 int ret; 3152 struct find_ref_ctx ctx; 3153 3154 ctx.dir = dir; 3155 ctx.name = name; 3156 ctx.found_idx = -1; 3157 3158 ret = iterate_inode_ref(sctx, root, path, key, 0, __find_iref, &ctx); 3159 if (ret < 0) 3160 return ret; 3161 3162 if (ctx.found_idx == -1) 3163 return -ENOENT; 3164 3165 return ctx.found_idx; 3166 } 3167 3168 static int __record_changed_new_ref(int num, u64 dir, int index, 3169 struct fs_path *name, 3170 void *ctx) 3171 { 3172 int ret; 3173 struct send_ctx *sctx = ctx; 3174 3175 ret = find_iref(sctx, sctx->parent_root, sctx->right_path, 3176 sctx->cmp_key, dir, name); 3177 if (ret == -ENOENT) 3178 ret = __record_new_ref(num, dir, index, name, sctx); 3179 else if (ret > 0) 3180 ret = 0; 3181 3182 return ret; 3183 } 3184 3185 static int __record_changed_deleted_ref(int num, u64 dir, int index, 3186 struct fs_path *name, 3187 void *ctx) 3188 { 3189 int ret; 3190 struct send_ctx *sctx = ctx; 3191 3192 ret = find_iref(sctx, sctx->send_root, sctx->left_path, sctx->cmp_key, 3193 dir, name); 3194 if (ret == -ENOENT) 3195 ret = __record_deleted_ref(num, dir, index, name, sctx); 3196 else if (ret > 0) 3197 ret = 0; 3198 3199 return ret; 3200 } 3201 3202 static int record_changed_ref(struct send_ctx *sctx) 3203 { 3204 int ret = 0; 3205 3206 ret = iterate_inode_ref(sctx, sctx->send_root, sctx->left_path, 3207 sctx->cmp_key, 0, __record_changed_new_ref, sctx); 3208 if (ret < 0) 3209 goto out; 3210 ret = iterate_inode_ref(sctx, sctx->parent_root, sctx->right_path, 3211 sctx->cmp_key, 0, __record_changed_deleted_ref, sctx); 3212 if (ret < 0) 3213 goto out; 3214 ret = 0; 3215 3216 out: 3217 return ret; 3218 } 3219 3220 /* 3221 * Record and process all refs at once. Needed when an inode changes the 3222 * generation number, which means that it was deleted and recreated. 3223 */ 3224 static int process_all_refs(struct send_ctx *sctx, 3225 enum btrfs_compare_tree_result cmd) 3226 { 3227 int ret; 3228 struct btrfs_root *root; 3229 struct btrfs_path *path; 3230 struct btrfs_key key; 3231 struct btrfs_key found_key; 3232 struct extent_buffer *eb; 3233 int slot; 3234 iterate_inode_ref_t cb; 3235 3236 path = alloc_path_for_send(); 3237 if (!path) 3238 return -ENOMEM; 3239 3240 if (cmd == BTRFS_COMPARE_TREE_NEW) { 3241 root = sctx->send_root; 3242 cb = __record_new_ref; 3243 } else if (cmd == BTRFS_COMPARE_TREE_DELETED) { 3244 root = sctx->parent_root; 3245 cb = __record_deleted_ref; 3246 } else { 3247 BUG(); 3248 } 3249 3250 key.objectid = sctx->cmp_key->objectid; 3251 key.type = BTRFS_INODE_REF_KEY; 3252 key.offset = 0; 3253 while (1) { 3254 ret = btrfs_search_slot_for_read(root, &key, path, 1, 0); 3255 if (ret < 0) 3256 goto out; 3257 if (ret) 3258 break; 3259 3260 eb = path->nodes[0]; 3261 slot = path->slots[0]; 3262 btrfs_item_key_to_cpu(eb, &found_key, slot); 3263 3264 if (found_key.objectid != key.objectid || 3265 (found_key.type != BTRFS_INODE_REF_KEY && 3266 found_key.type != BTRFS_INODE_EXTREF_KEY)) 3267 break; 3268 3269 ret = iterate_inode_ref(sctx, root, path, &found_key, 0, cb, 3270 sctx); 3271 btrfs_release_path(path); 3272 if (ret < 0) 3273 goto out; 3274 3275 key.offset = found_key.offset + 1; 3276 } 3277 btrfs_release_path(path); 3278 3279 ret = process_recorded_refs(sctx); 3280 3281 out: 3282 btrfs_free_path(path); 3283 return ret; 3284 } 3285 3286 static int send_set_xattr(struct send_ctx *sctx, 3287 struct fs_path *path, 3288 const char *name, int name_len, 3289 const char *data, int data_len) 3290 { 3291 int ret = 0; 3292 3293 ret = begin_cmd(sctx, BTRFS_SEND_C_SET_XATTR); 3294 if (ret < 0) 3295 goto out; 3296 3297 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, path); 3298 TLV_PUT_STRING(sctx, BTRFS_SEND_A_XATTR_NAME, name, name_len); 3299 TLV_PUT(sctx, BTRFS_SEND_A_XATTR_DATA, data, data_len); 3300 3301 ret = send_cmd(sctx); 3302 3303 tlv_put_failure: 3304 out: 3305 return ret; 3306 } 3307 3308 static int send_remove_xattr(struct send_ctx *sctx, 3309 struct fs_path *path, 3310 const char *name, int name_len) 3311 { 3312 int ret = 0; 3313 3314 ret = begin_cmd(sctx, BTRFS_SEND_C_REMOVE_XATTR); 3315 if (ret < 0) 3316 goto out; 3317 3318 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, path); 3319 TLV_PUT_STRING(sctx, BTRFS_SEND_A_XATTR_NAME, name, name_len); 3320 3321 ret = send_cmd(sctx); 3322 3323 tlv_put_failure: 3324 out: 3325 return ret; 3326 } 3327 3328 static int __process_new_xattr(int num, struct btrfs_key *di_key, 3329 const char *name, int name_len, 3330 const char *data, int data_len, 3331 u8 type, void *ctx) 3332 { 3333 int ret; 3334 struct send_ctx *sctx = ctx; 3335 struct fs_path *p; 3336 posix_acl_xattr_header dummy_acl; 3337 3338 p = fs_path_alloc(sctx); 3339 if (!p) 3340 return -ENOMEM; 3341 3342 /* 3343 * This hack is needed because empty acl's are stored as zero byte 3344 * data in xattrs. Problem with that is, that receiving these zero byte 3345 * acl's will fail later. To fix this, we send a dummy acl list that 3346 * only contains the version number and no entries. 3347 */ 3348 if (!strncmp(name, XATTR_NAME_POSIX_ACL_ACCESS, name_len) || 3349 !strncmp(name, XATTR_NAME_POSIX_ACL_DEFAULT, name_len)) { 3350 if (data_len == 0) { 3351 dummy_acl.a_version = 3352 cpu_to_le32(POSIX_ACL_XATTR_VERSION); 3353 data = (char *)&dummy_acl; 3354 data_len = sizeof(dummy_acl); 3355 } 3356 } 3357 3358 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p); 3359 if (ret < 0) 3360 goto out; 3361 3362 ret = send_set_xattr(sctx, p, name, name_len, data, data_len); 3363 3364 out: 3365 fs_path_free(sctx, p); 3366 return ret; 3367 } 3368 3369 static int __process_deleted_xattr(int num, struct btrfs_key *di_key, 3370 const char *name, int name_len, 3371 const char *data, int data_len, 3372 u8 type, void *ctx) 3373 { 3374 int ret; 3375 struct send_ctx *sctx = ctx; 3376 struct fs_path *p; 3377 3378 p = fs_path_alloc(sctx); 3379 if (!p) 3380 return -ENOMEM; 3381 3382 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p); 3383 if (ret < 0) 3384 goto out; 3385 3386 ret = send_remove_xattr(sctx, p, name, name_len); 3387 3388 out: 3389 fs_path_free(sctx, p); 3390 return ret; 3391 } 3392 3393 static int process_new_xattr(struct send_ctx *sctx) 3394 { 3395 int ret = 0; 3396 3397 ret = iterate_dir_item(sctx, sctx->send_root, sctx->left_path, 3398 sctx->cmp_key, __process_new_xattr, sctx); 3399 3400 return ret; 3401 } 3402 3403 static int process_deleted_xattr(struct send_ctx *sctx) 3404 { 3405 int ret; 3406 3407 ret = iterate_dir_item(sctx, sctx->parent_root, sctx->right_path, 3408 sctx->cmp_key, __process_deleted_xattr, sctx); 3409 3410 return ret; 3411 } 3412 3413 struct find_xattr_ctx { 3414 const char *name; 3415 int name_len; 3416 int found_idx; 3417 char *found_data; 3418 int found_data_len; 3419 }; 3420 3421 static int __find_xattr(int num, struct btrfs_key *di_key, 3422 const char *name, int name_len, 3423 const char *data, int data_len, 3424 u8 type, void *vctx) 3425 { 3426 struct find_xattr_ctx *ctx = vctx; 3427 3428 if (name_len == ctx->name_len && 3429 strncmp(name, ctx->name, name_len) == 0) { 3430 ctx->found_idx = num; 3431 ctx->found_data_len = data_len; 3432 ctx->found_data = kmalloc(data_len, GFP_NOFS); 3433 if (!ctx->found_data) 3434 return -ENOMEM; 3435 memcpy(ctx->found_data, data, data_len); 3436 return 1; 3437 } 3438 return 0; 3439 } 3440 3441 static int find_xattr(struct send_ctx *sctx, 3442 struct btrfs_root *root, 3443 struct btrfs_path *path, 3444 struct btrfs_key *key, 3445 const char *name, int name_len, 3446 char **data, int *data_len) 3447 { 3448 int ret; 3449 struct find_xattr_ctx ctx; 3450 3451 ctx.name = name; 3452 ctx.name_len = name_len; 3453 ctx.found_idx = -1; 3454 ctx.found_data = NULL; 3455 ctx.found_data_len = 0; 3456 3457 ret = iterate_dir_item(sctx, root, path, key, __find_xattr, &ctx); 3458 if (ret < 0) 3459 return ret; 3460 3461 if (ctx.found_idx == -1) 3462 return -ENOENT; 3463 if (data) { 3464 *data = ctx.found_data; 3465 *data_len = ctx.found_data_len; 3466 } else { 3467 kfree(ctx.found_data); 3468 } 3469 return ctx.found_idx; 3470 } 3471 3472 3473 static int __process_changed_new_xattr(int num, struct btrfs_key *di_key, 3474 const char *name, int name_len, 3475 const char *data, int data_len, 3476 u8 type, void *ctx) 3477 { 3478 int ret; 3479 struct send_ctx *sctx = ctx; 3480 char *found_data = NULL; 3481 int found_data_len = 0; 3482 3483 ret = find_xattr(sctx, sctx->parent_root, sctx->right_path, 3484 sctx->cmp_key, name, name_len, &found_data, 3485 &found_data_len); 3486 if (ret == -ENOENT) { 3487 ret = __process_new_xattr(num, di_key, name, name_len, data, 3488 data_len, type, ctx); 3489 } else if (ret >= 0) { 3490 if (data_len != found_data_len || 3491 memcmp(data, found_data, data_len)) { 3492 ret = __process_new_xattr(num, di_key, name, name_len, 3493 data, data_len, type, ctx); 3494 } else { 3495 ret = 0; 3496 } 3497 } 3498 3499 kfree(found_data); 3500 return ret; 3501 } 3502 3503 static int __process_changed_deleted_xattr(int num, struct btrfs_key *di_key, 3504 const char *name, int name_len, 3505 const char *data, int data_len, 3506 u8 type, void *ctx) 3507 { 3508 int ret; 3509 struct send_ctx *sctx = ctx; 3510 3511 ret = find_xattr(sctx, sctx->send_root, sctx->left_path, sctx->cmp_key, 3512 name, name_len, NULL, NULL); 3513 if (ret == -ENOENT) 3514 ret = __process_deleted_xattr(num, di_key, name, name_len, data, 3515 data_len, type, ctx); 3516 else if (ret >= 0) 3517 ret = 0; 3518 3519 return ret; 3520 } 3521 3522 static int process_changed_xattr(struct send_ctx *sctx) 3523 { 3524 int ret = 0; 3525 3526 ret = iterate_dir_item(sctx, sctx->send_root, sctx->left_path, 3527 sctx->cmp_key, __process_changed_new_xattr, sctx); 3528 if (ret < 0) 3529 goto out; 3530 ret = iterate_dir_item(sctx, sctx->parent_root, sctx->right_path, 3531 sctx->cmp_key, __process_changed_deleted_xattr, sctx); 3532 3533 out: 3534 return ret; 3535 } 3536 3537 static int process_all_new_xattrs(struct send_ctx *sctx) 3538 { 3539 int ret; 3540 struct btrfs_root *root; 3541 struct btrfs_path *path; 3542 struct btrfs_key key; 3543 struct btrfs_key found_key; 3544 struct extent_buffer *eb; 3545 int slot; 3546 3547 path = alloc_path_for_send(); 3548 if (!path) 3549 return -ENOMEM; 3550 3551 root = sctx->send_root; 3552 3553 key.objectid = sctx->cmp_key->objectid; 3554 key.type = BTRFS_XATTR_ITEM_KEY; 3555 key.offset = 0; 3556 while (1) { 3557 ret = btrfs_search_slot_for_read(root, &key, path, 1, 0); 3558 if (ret < 0) 3559 goto out; 3560 if (ret) { 3561 ret = 0; 3562 goto out; 3563 } 3564 3565 eb = path->nodes[0]; 3566 slot = path->slots[0]; 3567 btrfs_item_key_to_cpu(eb, &found_key, slot); 3568 3569 if (found_key.objectid != key.objectid || 3570 found_key.type != key.type) { 3571 ret = 0; 3572 goto out; 3573 } 3574 3575 ret = iterate_dir_item(sctx, root, path, &found_key, 3576 __process_new_xattr, sctx); 3577 if (ret < 0) 3578 goto out; 3579 3580 btrfs_release_path(path); 3581 key.offset = found_key.offset + 1; 3582 } 3583 3584 out: 3585 btrfs_free_path(path); 3586 return ret; 3587 } 3588 3589 /* 3590 * Read some bytes from the current inode/file and send a write command to 3591 * user space. 3592 */ 3593 static int send_write(struct send_ctx *sctx, u64 offset, u32 len) 3594 { 3595 int ret = 0; 3596 struct fs_path *p; 3597 loff_t pos = offset; 3598 int num_read = 0; 3599 mm_segment_t old_fs; 3600 3601 p = fs_path_alloc(sctx); 3602 if (!p) 3603 return -ENOMEM; 3604 3605 /* 3606 * vfs normally only accepts user space buffers for security reasons. 3607 * we only read from the file and also only provide the read_buf buffer 3608 * to vfs. As this buffer does not come from a user space call, it's 3609 * ok to temporary allow kernel space buffers. 3610 */ 3611 old_fs = get_fs(); 3612 set_fs(KERNEL_DS); 3613 3614 verbose_printk("btrfs: send_write offset=%llu, len=%d\n", offset, len); 3615 3616 ret = open_cur_inode_file(sctx); 3617 if (ret < 0) 3618 goto out; 3619 3620 ret = vfs_read(sctx->cur_inode_filp, sctx->read_buf, len, &pos); 3621 if (ret < 0) 3622 goto out; 3623 num_read = ret; 3624 if (!num_read) 3625 goto out; 3626 3627 ret = begin_cmd(sctx, BTRFS_SEND_C_WRITE); 3628 if (ret < 0) 3629 goto out; 3630 3631 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p); 3632 if (ret < 0) 3633 goto out; 3634 3635 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p); 3636 TLV_PUT_U64(sctx, BTRFS_SEND_A_FILE_OFFSET, offset); 3637 TLV_PUT(sctx, BTRFS_SEND_A_DATA, sctx->read_buf, num_read); 3638 3639 ret = send_cmd(sctx); 3640 3641 tlv_put_failure: 3642 out: 3643 fs_path_free(sctx, p); 3644 set_fs(old_fs); 3645 if (ret < 0) 3646 return ret; 3647 return num_read; 3648 } 3649 3650 /* 3651 * Send a clone command to user space. 3652 */ 3653 static int send_clone(struct send_ctx *sctx, 3654 u64 offset, u32 len, 3655 struct clone_root *clone_root) 3656 { 3657 int ret = 0; 3658 struct fs_path *p; 3659 u64 gen; 3660 3661 verbose_printk("btrfs: send_clone offset=%llu, len=%d, clone_root=%llu, " 3662 "clone_inode=%llu, clone_offset=%llu\n", offset, len, 3663 clone_root->root->objectid, clone_root->ino, 3664 clone_root->offset); 3665 3666 p = fs_path_alloc(sctx); 3667 if (!p) 3668 return -ENOMEM; 3669 3670 ret = begin_cmd(sctx, BTRFS_SEND_C_CLONE); 3671 if (ret < 0) 3672 goto out; 3673 3674 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p); 3675 if (ret < 0) 3676 goto out; 3677 3678 TLV_PUT_U64(sctx, BTRFS_SEND_A_FILE_OFFSET, offset); 3679 TLV_PUT_U64(sctx, BTRFS_SEND_A_CLONE_LEN, len); 3680 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p); 3681 3682 if (clone_root->root == sctx->send_root) { 3683 ret = get_inode_info(sctx->send_root, clone_root->ino, NULL, 3684 &gen, NULL, NULL, NULL, NULL); 3685 if (ret < 0) 3686 goto out; 3687 ret = get_cur_path(sctx, clone_root->ino, gen, p); 3688 } else { 3689 ret = get_inode_path(sctx, clone_root->root, 3690 clone_root->ino, p); 3691 } 3692 if (ret < 0) 3693 goto out; 3694 3695 TLV_PUT_UUID(sctx, BTRFS_SEND_A_CLONE_UUID, 3696 clone_root->root->root_item.uuid); 3697 TLV_PUT_U64(sctx, BTRFS_SEND_A_CLONE_CTRANSID, 3698 clone_root->root->root_item.ctransid); 3699 TLV_PUT_PATH(sctx, BTRFS_SEND_A_CLONE_PATH, p); 3700 TLV_PUT_U64(sctx, BTRFS_SEND_A_CLONE_OFFSET, 3701 clone_root->offset); 3702 3703 ret = send_cmd(sctx); 3704 3705 tlv_put_failure: 3706 out: 3707 fs_path_free(sctx, p); 3708 return ret; 3709 } 3710 3711 /* 3712 * Send an update extent command to user space. 3713 */ 3714 static int send_update_extent(struct send_ctx *sctx, 3715 u64 offset, u32 len) 3716 { 3717 int ret = 0; 3718 struct fs_path *p; 3719 3720 p = fs_path_alloc(sctx); 3721 if (!p) 3722 return -ENOMEM; 3723 3724 ret = begin_cmd(sctx, BTRFS_SEND_C_UPDATE_EXTENT); 3725 if (ret < 0) 3726 goto out; 3727 3728 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p); 3729 if (ret < 0) 3730 goto out; 3731 3732 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p); 3733 TLV_PUT_U64(sctx, BTRFS_SEND_A_FILE_OFFSET, offset); 3734 TLV_PUT_U64(sctx, BTRFS_SEND_A_SIZE, len); 3735 3736 ret = send_cmd(sctx); 3737 3738 tlv_put_failure: 3739 out: 3740 fs_path_free(sctx, p); 3741 return ret; 3742 } 3743 3744 static int send_write_or_clone(struct send_ctx *sctx, 3745 struct btrfs_path *path, 3746 struct btrfs_key *key, 3747 struct clone_root *clone_root) 3748 { 3749 int ret = 0; 3750 struct btrfs_file_extent_item *ei; 3751 u64 offset = key->offset; 3752 u64 pos = 0; 3753 u64 len; 3754 u32 l; 3755 u8 type; 3756 3757 ei = btrfs_item_ptr(path->nodes[0], path->slots[0], 3758 struct btrfs_file_extent_item); 3759 type = btrfs_file_extent_type(path->nodes[0], ei); 3760 if (type == BTRFS_FILE_EXTENT_INLINE) { 3761 len = btrfs_file_extent_inline_len(path->nodes[0], ei); 3762 /* 3763 * it is possible the inline item won't cover the whole page, 3764 * but there may be items after this page. Make 3765 * sure to send the whole thing 3766 */ 3767 len = PAGE_CACHE_ALIGN(len); 3768 } else { 3769 len = btrfs_file_extent_num_bytes(path->nodes[0], ei); 3770 } 3771 3772 if (offset + len > sctx->cur_inode_size) 3773 len = sctx->cur_inode_size - offset; 3774 if (len == 0) { 3775 ret = 0; 3776 goto out; 3777 } 3778 3779 if (clone_root) { 3780 ret = send_clone(sctx, offset, len, clone_root); 3781 } else if (sctx->flags & BTRFS_SEND_FLAG_NO_FILE_DATA) { 3782 ret = send_update_extent(sctx, offset, len); 3783 } else { 3784 while (pos < len) { 3785 l = len - pos; 3786 if (l > BTRFS_SEND_READ_SIZE) 3787 l = BTRFS_SEND_READ_SIZE; 3788 ret = send_write(sctx, pos + offset, l); 3789 if (ret < 0) 3790 goto out; 3791 if (!ret) 3792 break; 3793 pos += ret; 3794 } 3795 ret = 0; 3796 } 3797 out: 3798 return ret; 3799 } 3800 3801 static int is_extent_unchanged(struct send_ctx *sctx, 3802 struct btrfs_path *left_path, 3803 struct btrfs_key *ekey) 3804 { 3805 int ret = 0; 3806 struct btrfs_key key; 3807 struct btrfs_path *path = NULL; 3808 struct extent_buffer *eb; 3809 int slot; 3810 struct btrfs_key found_key; 3811 struct btrfs_file_extent_item *ei; 3812 u64 left_disknr; 3813 u64 right_disknr; 3814 u64 left_offset; 3815 u64 right_offset; 3816 u64 left_offset_fixed; 3817 u64 left_len; 3818 u64 right_len; 3819 u64 left_gen; 3820 u64 right_gen; 3821 u8 left_type; 3822 u8 right_type; 3823 3824 path = alloc_path_for_send(); 3825 if (!path) 3826 return -ENOMEM; 3827 3828 eb = left_path->nodes[0]; 3829 slot = left_path->slots[0]; 3830 ei = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item); 3831 left_type = btrfs_file_extent_type(eb, ei); 3832 3833 if (left_type != BTRFS_FILE_EXTENT_REG) { 3834 ret = 0; 3835 goto out; 3836 } 3837 left_disknr = btrfs_file_extent_disk_bytenr(eb, ei); 3838 left_len = btrfs_file_extent_num_bytes(eb, ei); 3839 left_offset = btrfs_file_extent_offset(eb, ei); 3840 left_gen = btrfs_file_extent_generation(eb, ei); 3841 3842 /* 3843 * Following comments will refer to these graphics. L is the left 3844 * extents which we are checking at the moment. 1-8 are the right 3845 * extents that we iterate. 3846 * 3847 * |-----L-----| 3848 * |-1-|-2a-|-3-|-4-|-5-|-6-| 3849 * 3850 * |-----L-----| 3851 * |--1--|-2b-|...(same as above) 3852 * 3853 * Alternative situation. Happens on files where extents got split. 3854 * |-----L-----| 3855 * |-----------7-----------|-6-| 3856 * 3857 * Alternative situation. Happens on files which got larger. 3858 * |-----L-----| 3859 * |-8-| 3860 * Nothing follows after 8. 3861 */ 3862 3863 key.objectid = ekey->objectid; 3864 key.type = BTRFS_EXTENT_DATA_KEY; 3865 key.offset = ekey->offset; 3866 ret = btrfs_search_slot_for_read(sctx->parent_root, &key, path, 0, 0); 3867 if (ret < 0) 3868 goto out; 3869 if (ret) { 3870 ret = 0; 3871 goto out; 3872 } 3873 3874 /* 3875 * Handle special case where the right side has no extents at all. 3876 */ 3877 eb = path->nodes[0]; 3878 slot = path->slots[0]; 3879 btrfs_item_key_to_cpu(eb, &found_key, slot); 3880 if (found_key.objectid != key.objectid || 3881 found_key.type != key.type) { 3882 ret = 0; 3883 goto out; 3884 } 3885 3886 /* 3887 * We're now on 2a, 2b or 7. 3888 */ 3889 key = found_key; 3890 while (key.offset < ekey->offset + left_len) { 3891 ei = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item); 3892 right_type = btrfs_file_extent_type(eb, ei); 3893 right_disknr = btrfs_file_extent_disk_bytenr(eb, ei); 3894 right_len = btrfs_file_extent_num_bytes(eb, ei); 3895 right_offset = btrfs_file_extent_offset(eb, ei); 3896 right_gen = btrfs_file_extent_generation(eb, ei); 3897 3898 if (right_type != BTRFS_FILE_EXTENT_REG) { 3899 ret = 0; 3900 goto out; 3901 } 3902 3903 /* 3904 * Are we at extent 8? If yes, we know the extent is changed. 3905 * This may only happen on the first iteration. 3906 */ 3907 if (found_key.offset + right_len <= ekey->offset) { 3908 ret = 0; 3909 goto out; 3910 } 3911 3912 left_offset_fixed = left_offset; 3913 if (key.offset < ekey->offset) { 3914 /* Fix the right offset for 2a and 7. */ 3915 right_offset += ekey->offset - key.offset; 3916 } else { 3917 /* Fix the left offset for all behind 2a and 2b */ 3918 left_offset_fixed += key.offset - ekey->offset; 3919 } 3920 3921 /* 3922 * Check if we have the same extent. 3923 */ 3924 if (left_disknr != right_disknr || 3925 left_offset_fixed != right_offset || 3926 left_gen != right_gen) { 3927 ret = 0; 3928 goto out; 3929 } 3930 3931 /* 3932 * Go to the next extent. 3933 */ 3934 ret = btrfs_next_item(sctx->parent_root, path); 3935 if (ret < 0) 3936 goto out; 3937 if (!ret) { 3938 eb = path->nodes[0]; 3939 slot = path->slots[0]; 3940 btrfs_item_key_to_cpu(eb, &found_key, slot); 3941 } 3942 if (ret || found_key.objectid != key.objectid || 3943 found_key.type != key.type) { 3944 key.offset += right_len; 3945 break; 3946 } 3947 if (found_key.offset != key.offset + right_len) { 3948 ret = 0; 3949 goto out; 3950 } 3951 key = found_key; 3952 } 3953 3954 /* 3955 * We're now behind the left extent (treat as unchanged) or at the end 3956 * of the right side (treat as changed). 3957 */ 3958 if (key.offset >= ekey->offset + left_len) 3959 ret = 1; 3960 else 3961 ret = 0; 3962 3963 3964 out: 3965 btrfs_free_path(path); 3966 return ret; 3967 } 3968 3969 static int process_extent(struct send_ctx *sctx, 3970 struct btrfs_path *path, 3971 struct btrfs_key *key) 3972 { 3973 int ret = 0; 3974 struct clone_root *found_clone = NULL; 3975 3976 if (S_ISLNK(sctx->cur_inode_mode)) 3977 return 0; 3978 3979 if (sctx->parent_root && !sctx->cur_inode_new) { 3980 ret = is_extent_unchanged(sctx, path, key); 3981 if (ret < 0) 3982 goto out; 3983 if (ret) { 3984 ret = 0; 3985 goto out; 3986 } 3987 } 3988 3989 ret = find_extent_clone(sctx, path, key->objectid, key->offset, 3990 sctx->cur_inode_size, &found_clone); 3991 if (ret != -ENOENT && ret < 0) 3992 goto out; 3993 3994 ret = send_write_or_clone(sctx, path, key, found_clone); 3995 3996 out: 3997 return ret; 3998 } 3999 4000 static int process_all_extents(struct send_ctx *sctx) 4001 { 4002 int ret; 4003 struct btrfs_root *root; 4004 struct btrfs_path *path; 4005 struct btrfs_key key; 4006 struct btrfs_key found_key; 4007 struct extent_buffer *eb; 4008 int slot; 4009 4010 root = sctx->send_root; 4011 path = alloc_path_for_send(); 4012 if (!path) 4013 return -ENOMEM; 4014 4015 key.objectid = sctx->cmp_key->objectid; 4016 key.type = BTRFS_EXTENT_DATA_KEY; 4017 key.offset = 0; 4018 while (1) { 4019 ret = btrfs_search_slot_for_read(root, &key, path, 1, 0); 4020 if (ret < 0) 4021 goto out; 4022 if (ret) { 4023 ret = 0; 4024 goto out; 4025 } 4026 4027 eb = path->nodes[0]; 4028 slot = path->slots[0]; 4029 btrfs_item_key_to_cpu(eb, &found_key, slot); 4030 4031 if (found_key.objectid != key.objectid || 4032 found_key.type != key.type) { 4033 ret = 0; 4034 goto out; 4035 } 4036 4037 ret = process_extent(sctx, path, &found_key); 4038 if (ret < 0) 4039 goto out; 4040 4041 btrfs_release_path(path); 4042 key.offset = found_key.offset + 1; 4043 } 4044 4045 out: 4046 btrfs_free_path(path); 4047 return ret; 4048 } 4049 4050 static int process_recorded_refs_if_needed(struct send_ctx *sctx, int at_end) 4051 { 4052 int ret = 0; 4053 4054 if (sctx->cur_ino == 0) 4055 goto out; 4056 if (!at_end && sctx->cur_ino == sctx->cmp_key->objectid && 4057 sctx->cmp_key->type <= BTRFS_INODE_EXTREF_KEY) 4058 goto out; 4059 if (list_empty(&sctx->new_refs) && list_empty(&sctx->deleted_refs)) 4060 goto out; 4061 4062 ret = process_recorded_refs(sctx); 4063 if (ret < 0) 4064 goto out; 4065 4066 /* 4067 * We have processed the refs and thus need to advance send_progress. 4068 * Now, calls to get_cur_xxx will take the updated refs of the current 4069 * inode into account. 4070 */ 4071 sctx->send_progress = sctx->cur_ino + 1; 4072 4073 out: 4074 return ret; 4075 } 4076 4077 static int finish_inode_if_needed(struct send_ctx *sctx, int at_end) 4078 { 4079 int ret = 0; 4080 u64 left_mode; 4081 u64 left_uid; 4082 u64 left_gid; 4083 u64 right_mode; 4084 u64 right_uid; 4085 u64 right_gid; 4086 int need_chmod = 0; 4087 int need_chown = 0; 4088 4089 ret = process_recorded_refs_if_needed(sctx, at_end); 4090 if (ret < 0) 4091 goto out; 4092 4093 if (sctx->cur_ino == 0 || sctx->cur_inode_deleted) 4094 goto out; 4095 if (!at_end && sctx->cmp_key->objectid == sctx->cur_ino) 4096 goto out; 4097 4098 ret = get_inode_info(sctx->send_root, sctx->cur_ino, NULL, NULL, 4099 &left_mode, &left_uid, &left_gid, NULL); 4100 if (ret < 0) 4101 goto out; 4102 4103 if (!sctx->parent_root || sctx->cur_inode_new) { 4104 need_chown = 1; 4105 if (!S_ISLNK(sctx->cur_inode_mode)) 4106 need_chmod = 1; 4107 } else { 4108 ret = get_inode_info(sctx->parent_root, sctx->cur_ino, 4109 NULL, NULL, &right_mode, &right_uid, 4110 &right_gid, NULL); 4111 if (ret < 0) 4112 goto out; 4113 4114 if (left_uid != right_uid || left_gid != right_gid) 4115 need_chown = 1; 4116 if (!S_ISLNK(sctx->cur_inode_mode) && left_mode != right_mode) 4117 need_chmod = 1; 4118 } 4119 4120 if (S_ISREG(sctx->cur_inode_mode)) { 4121 ret = send_truncate(sctx, sctx->cur_ino, sctx->cur_inode_gen, 4122 sctx->cur_inode_size); 4123 if (ret < 0) 4124 goto out; 4125 } 4126 4127 if (need_chown) { 4128 ret = send_chown(sctx, sctx->cur_ino, sctx->cur_inode_gen, 4129 left_uid, left_gid); 4130 if (ret < 0) 4131 goto out; 4132 } 4133 if (need_chmod) { 4134 ret = send_chmod(sctx, sctx->cur_ino, sctx->cur_inode_gen, 4135 left_mode); 4136 if (ret < 0) 4137 goto out; 4138 } 4139 4140 /* 4141 * Need to send that every time, no matter if it actually changed 4142 * between the two trees as we have done changes to the inode before. 4143 */ 4144 ret = send_utimes(sctx, sctx->cur_ino, sctx->cur_inode_gen); 4145 if (ret < 0) 4146 goto out; 4147 4148 out: 4149 return ret; 4150 } 4151 4152 static int changed_inode(struct send_ctx *sctx, 4153 enum btrfs_compare_tree_result result) 4154 { 4155 int ret = 0; 4156 struct btrfs_key *key = sctx->cmp_key; 4157 struct btrfs_inode_item *left_ii = NULL; 4158 struct btrfs_inode_item *right_ii = NULL; 4159 u64 left_gen = 0; 4160 u64 right_gen = 0; 4161 4162 ret = close_cur_inode_file(sctx); 4163 if (ret < 0) 4164 goto out; 4165 4166 sctx->cur_ino = key->objectid; 4167 sctx->cur_inode_new_gen = 0; 4168 4169 /* 4170 * Set send_progress to current inode. This will tell all get_cur_xxx 4171 * functions that the current inode's refs are not updated yet. Later, 4172 * when process_recorded_refs is finished, it is set to cur_ino + 1. 4173 */ 4174 sctx->send_progress = sctx->cur_ino; 4175 4176 if (result == BTRFS_COMPARE_TREE_NEW || 4177 result == BTRFS_COMPARE_TREE_CHANGED) { 4178 left_ii = btrfs_item_ptr(sctx->left_path->nodes[0], 4179 sctx->left_path->slots[0], 4180 struct btrfs_inode_item); 4181 left_gen = btrfs_inode_generation(sctx->left_path->nodes[0], 4182 left_ii); 4183 } else { 4184 right_ii = btrfs_item_ptr(sctx->right_path->nodes[0], 4185 sctx->right_path->slots[0], 4186 struct btrfs_inode_item); 4187 right_gen = btrfs_inode_generation(sctx->right_path->nodes[0], 4188 right_ii); 4189 } 4190 if (result == BTRFS_COMPARE_TREE_CHANGED) { 4191 right_ii = btrfs_item_ptr(sctx->right_path->nodes[0], 4192 sctx->right_path->slots[0], 4193 struct btrfs_inode_item); 4194 4195 right_gen = btrfs_inode_generation(sctx->right_path->nodes[0], 4196 right_ii); 4197 4198 /* 4199 * The cur_ino = root dir case is special here. We can't treat 4200 * the inode as deleted+reused because it would generate a 4201 * stream that tries to delete/mkdir the root dir. 4202 */ 4203 if (left_gen != right_gen && 4204 sctx->cur_ino != BTRFS_FIRST_FREE_OBJECTID) 4205 sctx->cur_inode_new_gen = 1; 4206 } 4207 4208 if (result == BTRFS_COMPARE_TREE_NEW) { 4209 sctx->cur_inode_gen = left_gen; 4210 sctx->cur_inode_new = 1; 4211 sctx->cur_inode_deleted = 0; 4212 sctx->cur_inode_size = btrfs_inode_size( 4213 sctx->left_path->nodes[0], left_ii); 4214 sctx->cur_inode_mode = btrfs_inode_mode( 4215 sctx->left_path->nodes[0], left_ii); 4216 if (sctx->cur_ino != BTRFS_FIRST_FREE_OBJECTID) 4217 ret = send_create_inode_if_needed(sctx); 4218 } else if (result == BTRFS_COMPARE_TREE_DELETED) { 4219 sctx->cur_inode_gen = right_gen; 4220 sctx->cur_inode_new = 0; 4221 sctx->cur_inode_deleted = 1; 4222 sctx->cur_inode_size = btrfs_inode_size( 4223 sctx->right_path->nodes[0], right_ii); 4224 sctx->cur_inode_mode = btrfs_inode_mode( 4225 sctx->right_path->nodes[0], right_ii); 4226 } else if (result == BTRFS_COMPARE_TREE_CHANGED) { 4227 /* 4228 * We need to do some special handling in case the inode was 4229 * reported as changed with a changed generation number. This 4230 * means that the original inode was deleted and new inode 4231 * reused the same inum. So we have to treat the old inode as 4232 * deleted and the new one as new. 4233 */ 4234 if (sctx->cur_inode_new_gen) { 4235 /* 4236 * First, process the inode as if it was deleted. 4237 */ 4238 sctx->cur_inode_gen = right_gen; 4239 sctx->cur_inode_new = 0; 4240 sctx->cur_inode_deleted = 1; 4241 sctx->cur_inode_size = btrfs_inode_size( 4242 sctx->right_path->nodes[0], right_ii); 4243 sctx->cur_inode_mode = btrfs_inode_mode( 4244 sctx->right_path->nodes[0], right_ii); 4245 ret = process_all_refs(sctx, 4246 BTRFS_COMPARE_TREE_DELETED); 4247 if (ret < 0) 4248 goto out; 4249 4250 /* 4251 * Now process the inode as if it was new. 4252 */ 4253 sctx->cur_inode_gen = left_gen; 4254 sctx->cur_inode_new = 1; 4255 sctx->cur_inode_deleted = 0; 4256 sctx->cur_inode_size = btrfs_inode_size( 4257 sctx->left_path->nodes[0], left_ii); 4258 sctx->cur_inode_mode = btrfs_inode_mode( 4259 sctx->left_path->nodes[0], left_ii); 4260 ret = send_create_inode_if_needed(sctx); 4261 if (ret < 0) 4262 goto out; 4263 4264 ret = process_all_refs(sctx, BTRFS_COMPARE_TREE_NEW); 4265 if (ret < 0) 4266 goto out; 4267 /* 4268 * Advance send_progress now as we did not get into 4269 * process_recorded_refs_if_needed in the new_gen case. 4270 */ 4271 sctx->send_progress = sctx->cur_ino + 1; 4272 4273 /* 4274 * Now process all extents and xattrs of the inode as if 4275 * they were all new. 4276 */ 4277 ret = process_all_extents(sctx); 4278 if (ret < 0) 4279 goto out; 4280 ret = process_all_new_xattrs(sctx); 4281 if (ret < 0) 4282 goto out; 4283 } else { 4284 sctx->cur_inode_gen = left_gen; 4285 sctx->cur_inode_new = 0; 4286 sctx->cur_inode_new_gen = 0; 4287 sctx->cur_inode_deleted = 0; 4288 sctx->cur_inode_size = btrfs_inode_size( 4289 sctx->left_path->nodes[0], left_ii); 4290 sctx->cur_inode_mode = btrfs_inode_mode( 4291 sctx->left_path->nodes[0], left_ii); 4292 } 4293 } 4294 4295 out: 4296 return ret; 4297 } 4298 4299 /* 4300 * We have to process new refs before deleted refs, but compare_trees gives us 4301 * the new and deleted refs mixed. To fix this, we record the new/deleted refs 4302 * first and later process them in process_recorded_refs. 4303 * For the cur_inode_new_gen case, we skip recording completely because 4304 * changed_inode did already initiate processing of refs. The reason for this is 4305 * that in this case, compare_tree actually compares the refs of 2 different 4306 * inodes. To fix this, process_all_refs is used in changed_inode to handle all 4307 * refs of the right tree as deleted and all refs of the left tree as new. 4308 */ 4309 static int changed_ref(struct send_ctx *sctx, 4310 enum btrfs_compare_tree_result result) 4311 { 4312 int ret = 0; 4313 4314 BUG_ON(sctx->cur_ino != sctx->cmp_key->objectid); 4315 4316 if (!sctx->cur_inode_new_gen && 4317 sctx->cur_ino != BTRFS_FIRST_FREE_OBJECTID) { 4318 if (result == BTRFS_COMPARE_TREE_NEW) 4319 ret = record_new_ref(sctx); 4320 else if (result == BTRFS_COMPARE_TREE_DELETED) 4321 ret = record_deleted_ref(sctx); 4322 else if (result == BTRFS_COMPARE_TREE_CHANGED) 4323 ret = record_changed_ref(sctx); 4324 } 4325 4326 return ret; 4327 } 4328 4329 /* 4330 * Process new/deleted/changed xattrs. We skip processing in the 4331 * cur_inode_new_gen case because changed_inode did already initiate processing 4332 * of xattrs. The reason is the same as in changed_ref 4333 */ 4334 static int changed_xattr(struct send_ctx *sctx, 4335 enum btrfs_compare_tree_result result) 4336 { 4337 int ret = 0; 4338 4339 BUG_ON(sctx->cur_ino != sctx->cmp_key->objectid); 4340 4341 if (!sctx->cur_inode_new_gen && !sctx->cur_inode_deleted) { 4342 if (result == BTRFS_COMPARE_TREE_NEW) 4343 ret = process_new_xattr(sctx); 4344 else if (result == BTRFS_COMPARE_TREE_DELETED) 4345 ret = process_deleted_xattr(sctx); 4346 else if (result == BTRFS_COMPARE_TREE_CHANGED) 4347 ret = process_changed_xattr(sctx); 4348 } 4349 4350 return ret; 4351 } 4352 4353 /* 4354 * Process new/deleted/changed extents. We skip processing in the 4355 * cur_inode_new_gen case because changed_inode did already initiate processing 4356 * of extents. The reason is the same as in changed_ref 4357 */ 4358 static int changed_extent(struct send_ctx *sctx, 4359 enum btrfs_compare_tree_result result) 4360 { 4361 int ret = 0; 4362 4363 BUG_ON(sctx->cur_ino != sctx->cmp_key->objectid); 4364 4365 if (!sctx->cur_inode_new_gen && !sctx->cur_inode_deleted) { 4366 if (result != BTRFS_COMPARE_TREE_DELETED) 4367 ret = process_extent(sctx, sctx->left_path, 4368 sctx->cmp_key); 4369 } 4370 4371 return ret; 4372 } 4373 4374 /* 4375 * Updates compare related fields in sctx and simply forwards to the actual 4376 * changed_xxx functions. 4377 */ 4378 static int changed_cb(struct btrfs_root *left_root, 4379 struct btrfs_root *right_root, 4380 struct btrfs_path *left_path, 4381 struct btrfs_path *right_path, 4382 struct btrfs_key *key, 4383 enum btrfs_compare_tree_result result, 4384 void *ctx) 4385 { 4386 int ret = 0; 4387 struct send_ctx *sctx = ctx; 4388 4389 sctx->left_path = left_path; 4390 sctx->right_path = right_path; 4391 sctx->cmp_key = key; 4392 4393 ret = finish_inode_if_needed(sctx, 0); 4394 if (ret < 0) 4395 goto out; 4396 4397 /* Ignore non-FS objects */ 4398 if (key->objectid == BTRFS_FREE_INO_OBJECTID || 4399 key->objectid == BTRFS_FREE_SPACE_OBJECTID) 4400 goto out; 4401 4402 if (key->type == BTRFS_INODE_ITEM_KEY) 4403 ret = changed_inode(sctx, result); 4404 else if (key->type == BTRFS_INODE_REF_KEY || 4405 key->type == BTRFS_INODE_EXTREF_KEY) 4406 ret = changed_ref(sctx, result); 4407 else if (key->type == BTRFS_XATTR_ITEM_KEY) 4408 ret = changed_xattr(sctx, result); 4409 else if (key->type == BTRFS_EXTENT_DATA_KEY) 4410 ret = changed_extent(sctx, result); 4411 4412 out: 4413 return ret; 4414 } 4415 4416 static int full_send_tree(struct send_ctx *sctx) 4417 { 4418 int ret; 4419 struct btrfs_trans_handle *trans = NULL; 4420 struct btrfs_root *send_root = sctx->send_root; 4421 struct btrfs_key key; 4422 struct btrfs_key found_key; 4423 struct btrfs_path *path; 4424 struct extent_buffer *eb; 4425 int slot; 4426 u64 start_ctransid; 4427 u64 ctransid; 4428 4429 path = alloc_path_for_send(); 4430 if (!path) 4431 return -ENOMEM; 4432 4433 spin_lock(&send_root->root_item_lock); 4434 start_ctransid = btrfs_root_ctransid(&send_root->root_item); 4435 spin_unlock(&send_root->root_item_lock); 4436 4437 key.objectid = BTRFS_FIRST_FREE_OBJECTID; 4438 key.type = BTRFS_INODE_ITEM_KEY; 4439 key.offset = 0; 4440 4441 join_trans: 4442 /* 4443 * We need to make sure the transaction does not get committed 4444 * while we do anything on commit roots. Join a transaction to prevent 4445 * this. 4446 */ 4447 trans = btrfs_join_transaction(send_root); 4448 if (IS_ERR(trans)) { 4449 ret = PTR_ERR(trans); 4450 trans = NULL; 4451 goto out; 4452 } 4453 4454 /* 4455 * Make sure the tree has not changed after re-joining. We detect this 4456 * by comparing start_ctransid and ctransid. They should always match. 4457 */ 4458 spin_lock(&send_root->root_item_lock); 4459 ctransid = btrfs_root_ctransid(&send_root->root_item); 4460 spin_unlock(&send_root->root_item_lock); 4461 4462 if (ctransid != start_ctransid) { 4463 WARN(1, KERN_WARNING "btrfs: the root that you're trying to " 4464 "send was modified in between. This is " 4465 "probably a bug.\n"); 4466 ret = -EIO; 4467 goto out; 4468 } 4469 4470 ret = btrfs_search_slot_for_read(send_root, &key, path, 1, 0); 4471 if (ret < 0) 4472 goto out; 4473 if (ret) 4474 goto out_finish; 4475 4476 while (1) { 4477 /* 4478 * When someone want to commit while we iterate, end the 4479 * joined transaction and rejoin. 4480 */ 4481 if (btrfs_should_end_transaction(trans, send_root)) { 4482 ret = btrfs_end_transaction(trans, send_root); 4483 trans = NULL; 4484 if (ret < 0) 4485 goto out; 4486 btrfs_release_path(path); 4487 goto join_trans; 4488 } 4489 4490 eb = path->nodes[0]; 4491 slot = path->slots[0]; 4492 btrfs_item_key_to_cpu(eb, &found_key, slot); 4493 4494 ret = changed_cb(send_root, NULL, path, NULL, 4495 &found_key, BTRFS_COMPARE_TREE_NEW, sctx); 4496 if (ret < 0) 4497 goto out; 4498 4499 key.objectid = found_key.objectid; 4500 key.type = found_key.type; 4501 key.offset = found_key.offset + 1; 4502 4503 ret = btrfs_next_item(send_root, path); 4504 if (ret < 0) 4505 goto out; 4506 if (ret) { 4507 ret = 0; 4508 break; 4509 } 4510 } 4511 4512 out_finish: 4513 ret = finish_inode_if_needed(sctx, 1); 4514 4515 out: 4516 btrfs_free_path(path); 4517 if (trans) { 4518 if (!ret) 4519 ret = btrfs_end_transaction(trans, send_root); 4520 else 4521 btrfs_end_transaction(trans, send_root); 4522 } 4523 return ret; 4524 } 4525 4526 static int send_subvol(struct send_ctx *sctx) 4527 { 4528 int ret; 4529 4530 if (!(sctx->flags & BTRFS_SEND_FLAG_OMIT_STREAM_HEADER)) { 4531 ret = send_header(sctx); 4532 if (ret < 0) 4533 goto out; 4534 } 4535 4536 ret = send_subvol_begin(sctx); 4537 if (ret < 0) 4538 goto out; 4539 4540 if (sctx->parent_root) { 4541 ret = btrfs_compare_trees(sctx->send_root, sctx->parent_root, 4542 changed_cb, sctx); 4543 if (ret < 0) 4544 goto out; 4545 ret = finish_inode_if_needed(sctx, 1); 4546 if (ret < 0) 4547 goto out; 4548 } else { 4549 ret = full_send_tree(sctx); 4550 if (ret < 0) 4551 goto out; 4552 } 4553 4554 out: 4555 if (!ret) 4556 ret = close_cur_inode_file(sctx); 4557 else 4558 close_cur_inode_file(sctx); 4559 4560 free_recorded_refs(sctx); 4561 return ret; 4562 } 4563 4564 long btrfs_ioctl_send(struct file *mnt_file, void __user *arg_) 4565 { 4566 int ret = 0; 4567 struct btrfs_root *send_root; 4568 struct btrfs_root *clone_root; 4569 struct btrfs_fs_info *fs_info; 4570 struct btrfs_ioctl_send_args *arg = NULL; 4571 struct btrfs_key key; 4572 struct send_ctx *sctx = NULL; 4573 u32 i; 4574 u64 *clone_sources_tmp = NULL; 4575 4576 if (!capable(CAP_SYS_ADMIN)) 4577 return -EPERM; 4578 4579 send_root = BTRFS_I(file_inode(mnt_file))->root; 4580 fs_info = send_root->fs_info; 4581 4582 arg = memdup_user(arg_, sizeof(*arg)); 4583 if (IS_ERR(arg)) { 4584 ret = PTR_ERR(arg); 4585 arg = NULL; 4586 goto out; 4587 } 4588 4589 if (!access_ok(VERIFY_READ, arg->clone_sources, 4590 sizeof(*arg->clone_sources * 4591 arg->clone_sources_count))) { 4592 ret = -EFAULT; 4593 goto out; 4594 } 4595 4596 if (arg->flags & ~BTRFS_SEND_FLAG_MASK) { 4597 ret = -EINVAL; 4598 goto out; 4599 } 4600 4601 sctx = kzalloc(sizeof(struct send_ctx), GFP_NOFS); 4602 if (!sctx) { 4603 ret = -ENOMEM; 4604 goto out; 4605 } 4606 4607 INIT_LIST_HEAD(&sctx->new_refs); 4608 INIT_LIST_HEAD(&sctx->deleted_refs); 4609 INIT_RADIX_TREE(&sctx->name_cache, GFP_NOFS); 4610 INIT_LIST_HEAD(&sctx->name_cache_list); 4611 4612 sctx->flags = arg->flags; 4613 4614 sctx->send_filp = fget(arg->send_fd); 4615 if (!sctx->send_filp) { 4616 ret = -EBADF; 4617 goto out; 4618 } 4619 4620 sctx->mnt = mnt_file->f_path.mnt; 4621 4622 sctx->send_root = send_root; 4623 sctx->clone_roots_cnt = arg->clone_sources_count; 4624 4625 sctx->send_max_size = BTRFS_SEND_BUF_SIZE; 4626 sctx->send_buf = vmalloc(sctx->send_max_size); 4627 if (!sctx->send_buf) { 4628 ret = -ENOMEM; 4629 goto out; 4630 } 4631 4632 sctx->read_buf = vmalloc(BTRFS_SEND_READ_SIZE); 4633 if (!sctx->read_buf) { 4634 ret = -ENOMEM; 4635 goto out; 4636 } 4637 4638 sctx->clone_roots = vzalloc(sizeof(struct clone_root) * 4639 (arg->clone_sources_count + 1)); 4640 if (!sctx->clone_roots) { 4641 ret = -ENOMEM; 4642 goto out; 4643 } 4644 4645 if (arg->clone_sources_count) { 4646 clone_sources_tmp = vmalloc(arg->clone_sources_count * 4647 sizeof(*arg->clone_sources)); 4648 if (!clone_sources_tmp) { 4649 ret = -ENOMEM; 4650 goto out; 4651 } 4652 4653 ret = copy_from_user(clone_sources_tmp, arg->clone_sources, 4654 arg->clone_sources_count * 4655 sizeof(*arg->clone_sources)); 4656 if (ret) { 4657 ret = -EFAULT; 4658 goto out; 4659 } 4660 4661 for (i = 0; i < arg->clone_sources_count; i++) { 4662 key.objectid = clone_sources_tmp[i]; 4663 key.type = BTRFS_ROOT_ITEM_KEY; 4664 key.offset = (u64)-1; 4665 clone_root = btrfs_read_fs_root_no_name(fs_info, &key); 4666 if (!clone_root) { 4667 ret = -EINVAL; 4668 goto out; 4669 } 4670 if (IS_ERR(clone_root)) { 4671 ret = PTR_ERR(clone_root); 4672 goto out; 4673 } 4674 sctx->clone_roots[i].root = clone_root; 4675 } 4676 vfree(clone_sources_tmp); 4677 clone_sources_tmp = NULL; 4678 } 4679 4680 if (arg->parent_root) { 4681 key.objectid = arg->parent_root; 4682 key.type = BTRFS_ROOT_ITEM_KEY; 4683 key.offset = (u64)-1; 4684 sctx->parent_root = btrfs_read_fs_root_no_name(fs_info, &key); 4685 if (!sctx->parent_root) { 4686 ret = -EINVAL; 4687 goto out; 4688 } 4689 } 4690 4691 /* 4692 * Clones from send_root are allowed, but only if the clone source 4693 * is behind the current send position. This is checked while searching 4694 * for possible clone sources. 4695 */ 4696 sctx->clone_roots[sctx->clone_roots_cnt++].root = sctx->send_root; 4697 4698 /* We do a bsearch later */ 4699 sort(sctx->clone_roots, sctx->clone_roots_cnt, 4700 sizeof(*sctx->clone_roots), __clone_root_cmp_sort, 4701 NULL); 4702 4703 ret = send_subvol(sctx); 4704 if (ret < 0) 4705 goto out; 4706 4707 if (!(sctx->flags & BTRFS_SEND_FLAG_OMIT_END_CMD)) { 4708 ret = begin_cmd(sctx, BTRFS_SEND_C_END); 4709 if (ret < 0) 4710 goto out; 4711 ret = send_cmd(sctx); 4712 if (ret < 0) 4713 goto out; 4714 } 4715 4716 out: 4717 kfree(arg); 4718 vfree(clone_sources_tmp); 4719 4720 if (sctx) { 4721 if (sctx->send_filp) 4722 fput(sctx->send_filp); 4723 4724 vfree(sctx->clone_roots); 4725 vfree(sctx->send_buf); 4726 vfree(sctx->read_buf); 4727 4728 name_cache_free(sctx); 4729 4730 kfree(sctx); 4731 } 4732 4733 return ret; 4734 } 4735