Lines Matching refs:ret
265 int ret;
435 int ret;
441 ret = fs_path_ensure_buf(p, new_len);
442 if (ret < 0)
459 return ret;
464 int ret;
467 ret = fs_path_prepare_for_add(p, name_len, &prepared);
468 if (ret < 0)
473 return ret;
478 int ret;
481 ret = fs_path_prepare_for_add(p, p2->end - p2->start, &prepared);
482 if (ret < 0)
487 return ret;
494 int ret;
497 ret = fs_path_prepare_for_add(p, len, &prepared);
498 if (ret < 0)
504 return ret;
509 int ret;
514 ret = fs_path_add_path(p, from);
516 return ret;
551 int ret;
555 ret = kernel_write(filp, buf + pos, len - pos, off);
557 /*if (ret == -ERESTARTSYS) {
560 if (ret < 0)
561 return ret;
562 if (ret == 0) {
565 pos += ret;
625 ret = tlv_put(sctx, attrtype, data, attrlen); \
626 if (ret < 0) \
632 ret = tlv_put_u##bits(sctx, attrtype, value); \
633 if (ret < 0) \
643 ret = tlv_put_string(sctx, attrtype, str, len); \
644 if (ret < 0) \
649 ret = tlv_put_string(sctx, attrtype, p->start, \
651 if (ret < 0) \
656 ret = tlv_put_uuid(sctx, attrtype, uuid); \
657 if (ret < 0) \
662 ret = tlv_put_btrfs_timespec(sctx, attrtype, eb, ts); \
663 if (ret < 0) \
699 int ret;
710 ret = write_buf(sctx->send_filp, sctx->send_buf, sctx->send_size,
717 return ret;
727 int ret;
731 ret = begin_cmd(sctx, BTRFS_SEND_C_RENAME);
732 if (ret < 0)
738 ret = send_cmd(sctx);
742 return ret;
752 int ret;
756 ret = begin_cmd(sctx, BTRFS_SEND_C_LINK);
757 if (ret < 0)
763 ret = send_cmd(sctx);
767 return ret;
776 int ret;
780 ret = begin_cmd(sctx, BTRFS_SEND_C_UNLINK);
781 if (ret < 0)
786 ret = send_cmd(sctx);
790 return ret;
799 int ret;
803 ret = begin_cmd(sctx, BTRFS_SEND_C_RMDIR);
804 if (ret < 0)
809 ret = send_cmd(sctx);
813 return ret;
823 int ret;
830 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
831 if (ret) {
832 if (ret > 0)
833 ret = -ENOENT;
834 return ret;
852 return ret;
861 int ret;
866 ret = __get_inode_info(root, path, ino, size, gen, mode, uid, gid,
869 return ret;
899 int ret = 0;
952 ret = PTR_ERR(start);
957 ret = fs_path_ensure_buf(p,
959 if (ret < 0)
966 ret = PTR_ERR(start);
973 ret = fs_path_add_from_extent_buffer(p, eb, name_off,
975 if (ret < 0)
980 ret = iterate(num, dir, index, p, ctx);
981 if (ret)
989 return ret;
1007 int ret = 0;
1032 ret = -ENOMEM;
1053 ret = -ENAMETOOLONG;
1058 ret = -E2BIG;
1066 ret = -ENAMETOOLONG;
1087 ret = -ENOMEM;
1100 ret = iterate(num, &di_key, buf, name_len, buf + name_len,
1102 if (ret < 0)
1104 if (ret) {
1105 ret = 0;
1114 return ret;
1120 int ret;
1123 ret = fs_path_copy(pt, p);
1124 if (ret < 0)
1125 return ret;
1138 int ret;
1152 ret = btrfs_search_slot_for_read(root, &key, p, 1, 0);
1153 if (ret < 0)
1155 if (ret) {
1156 ret = 1;
1163 ret = -ENOENT;
1167 ret = iterate_inode_ref(root, p, &found_key, 1,
1169 if (ret < 0)
1171 ret = 0;
1175 return ret;
1304 int ret;
1330 ret = -ENOMEM;
1340 ret = 0;
1348 ret = -ENOENT;
1356 ret = -ENOENT;
1362 ret = extent_from_logical(fs_info, disk_byte, tmp_path,
1366 if (ret < 0)
1369 ret = -EIO;
1383 ret = -ENOENT;
1433 ret = iterate_extent_inodes(fs_info, found_key.objectid,
1437 if (ret < 0)
1442 ret = -EIO;
1470 ret = 0;
1472 ret = -ENOENT;
1478 return ret;
1485 int ret;
1501 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1502 if (ret < 0)
1504 if (ret) {
1516 ret = -EIO;
1530 ret = fs_path_add_from_extent_buffer(dest, path->nodes[0], off, len);
1534 return ret;
1545 int ret = 0;
1566 ret = PTR_ERR(di);
1577 ret = 0;
1586 ret = PTR_ERR(di);
1598 ret = fs_path_add(dest, tmp, strlen(tmp));
1602 return ret;
1615 int ret;
1621 ret = get_inode_info(sctx->send_root, ino, NULL, &left_gen, NULL, NULL,
1623 if (ret < 0 && ret != -ENOENT)
1625 left_ret = ret;
1630 ret = get_inode_info(sctx->parent_root, ino, NULL, &right_gen,
1632 if (ret < 0 && ret != -ENOENT)
1634 right_ret = ret;
1639 ret = inode_state_no_change;
1642 ret = inode_state_did_create;
1644 ret = inode_state_will_create;
1647 ret = inode_state_did_delete;
1649 ret = inode_state_will_delete;
1651 ret = -ENOENT;
1656 ret = inode_state_did_create;
1658 ret = inode_state_will_create;
1660 ret = -ENOENT;
1665 ret = inode_state_did_delete;
1667 ret = inode_state_will_delete;
1669 ret = -ENOENT;
1672 ret = -ENOENT;
1676 return ret;
1681 int ret;
1686 ret = get_cur_inode_state(sctx, ino, gen);
1687 if (ret < 0)
1690 if (ret == inode_state_no_change ||
1691 ret == inode_state_did_create ||
1692 ret == inode_state_will_delete)
1693 ret = 1;
1695 ret = 0;
1698 return ret;
1709 int ret = 0;
1721 ret = di ? PTR_ERR(di) : -ENOENT;
1726 ret = -ENOENT;
1734 return ret;
1744 int ret;
1759 ret = btrfs_search_slot_for_read(root, &key, path, 1, 0);
1760 if (ret < 0)
1762 if (!ret)
1765 if (ret || found_key.objectid != ino ||
1768 ret = -ENOENT;
1777 ret = fs_path_add_from_extent_buffer(name, path->nodes[0],
1786 ret = fs_path_add_from_extent_buffer(name, path->nodes[0],
1790 if (ret < 0)
1795 ret = get_inode_info(root, parent_dir, NULL, dir_gen, NULL,
1797 if (ret < 0)
1805 return ret;
1812 int ret;
1820 ret = get_first_ref(root, ino, &tmp_dir, NULL, tmp_name);
1821 if (ret < 0)
1825 ret = 0;
1829 ret = !memcmp(tmp_name->start, name, name_len);
1833 return ret;
1850 int ret = 0;
1858 ret = is_inode_existent(sctx, dir, dir_gen);
1859 if (ret <= 0)
1868 ret = get_inode_info(sctx->parent_root, dir, NULL, &gen, NULL,
1870 if (ret < 0 && ret != -ENOENT)
1872 if (ret) {
1873 ret = 0;
1880 ret = lookup_dir_item_inode(sctx->parent_root, dir, name, name_len,
1882 if (ret < 0 && ret != -ENOENT)
1884 if (ret) {
1885 ret = 0;
1896 ret = get_inode_info(sctx->parent_root, other_inode, NULL,
1898 if (ret < 0)
1901 ret = 1;
1904 ret = 0;
1908 return ret;
1923 int ret = 0;
1931 ret = is_inode_existent(sctx, dir, dir_gen);
1932 if (ret <= 0)
1936 ret = get_inode_info(sctx->send_root, dir, NULL, &gen, NULL,
1938 if (ret < 0 && ret != -ENOENT)
1940 if (ret) {
1941 ret = 0;
1949 ret = lookup_dir_item_inode(sctx->send_root, dir, name, name_len,
1951 if (ret < 0 && ret != -ENOENT)
1953 if (ret) {
1955 ret = 0;
1959 ret = get_inode_info(sctx->send_root, ow_inode, NULL, &gen, NULL, NULL,
1961 if (ret < 0)
1965 ret = 0;
1978 ret = 1;
1980 ret = 0;
1983 return ret;
1993 int ret = 0;
2005 ret = get_first_ref(sctx->parent_root, ino, &dir, &dir_gen, name);
2006 if (ret < 0)
2009 ret = did_overwrite_ref(sctx, dir, dir_gen, ino, gen,
2014 return ret;
2026 int ret = 0;
2039 ret = radix_tree_insert(&sctx->name_cache, nce->ino, nce_head);
2040 if (ret < 0) {
2043 return ret;
2050 return ret;
2150 int ret;
2169 ret = fs_path_add(dest, nce->name, nce->name_len);
2170 if (ret < 0)
2172 ret = nce->ret;
2182 ret = is_inode_existent(sctx, ino, gen);
2183 if (ret < 0)
2186 if (!ret) {
2187 ret = gen_unique_name(sctx, ino, gen, dest);
2188 if (ret < 0)
2190 ret = 1;
2199 ret = get_first_ref(sctx->send_root, ino,
2202 ret = get_first_ref(sctx->parent_root, ino,
2204 if (ret < 0)
2211 ret = did_overwrite_ref(sctx, *parent_ino, *parent_gen, ino, gen,
2213 if (ret < 0)
2215 if (ret) {
2217 ret = gen_unique_name(sctx, ino, gen, dest);
2218 if (ret < 0)
2220 ret = 1;
2229 ret = -ENOMEM;
2238 nce->ret = ret;
2248 ret = nce_ret;
2252 return ret;
2283 int ret = 0;
2291 ret = -ENOMEM;
2304 ret = gen_unique_name(sctx, ino, gen, name);
2305 if (ret < 0)
2307 ret = fs_path_add_path(dest, name);
2313 ret = gen_unique_name(sctx, ino, gen, name);
2316 ret = get_first_ref(sctx->parent_root, ino,
2319 ret = __get_cur_name_and_parent(sctx, ino, gen,
2322 if (ret)
2326 if (ret < 0)
2329 ret = fs_path_add_path(dest, name);
2330 if (ret < 0)
2339 if (!ret)
2341 return ret;
2349 int ret;
2373 ret = btrfs_search_slot_for_read(send_root->fs_info->tree_root,
2375 if (ret < 0)
2377 if (ret) {
2378 ret = -ENOENT;
2386 ret = -ENOENT;
2395 ret = begin_cmd(sctx, BTRFS_SEND_C_SNAPSHOT);
2396 if (ret < 0)
2399 ret = begin_cmd(sctx, BTRFS_SEND_C_SUBVOL);
2400 if (ret < 0)
2426 ret = send_cmd(sctx);
2432 return ret;
2438 int ret = 0;
2447 ret = begin_cmd(sctx, BTRFS_SEND_C_TRUNCATE);
2448 if (ret < 0)
2451 ret = get_cur_path(sctx, ino, gen, p);
2452 if (ret < 0)
2457 ret = send_cmd(sctx);
2462 return ret;
2468 int ret = 0;
2477 ret = begin_cmd(sctx, BTRFS_SEND_C_CHMOD);
2478 if (ret < 0)
2481 ret = get_cur_path(sctx, ino, gen, p);
2482 if (ret < 0)
2487 ret = send_cmd(sctx);
2492 return ret;
2498 int ret = 0;
2508 ret = begin_cmd(sctx, BTRFS_SEND_C_CHOWN);
2509 if (ret < 0)
2512 ret = get_cur_path(sctx, ino, gen, p);
2513 if (ret < 0)
2519 ret = send_cmd(sctx);
2524 return ret;
2530 int ret = 0;
2546 ret = -ENOMEM;
2553 ret = btrfs_search_slot(NULL, sctx->send_root, &key, path, 0, 0);
2554 if (ret > 0)
2555 ret = -ENOENT;
2556 if (ret < 0)
2563 ret = begin_cmd(sctx, BTRFS_SEND_C_UTIMES);
2564 if (ret < 0)
2567 ret = get_cur_path(sctx, ino, gen, p);
2568 if (ret < 0)
2576 ret = send_cmd(sctx);
2582 return ret;
2593 int ret = 0;
2607 ret = get_inode_info(sctx->send_root, ino, NULL, &gen, &mode,
2609 if (ret < 0)
2632 ret = -EOPNOTSUPP;
2636 ret = begin_cmd(sctx, cmd);
2637 if (ret < 0)
2640 ret = gen_unique_name(sctx, ino, gen, p);
2641 if (ret < 0)
2649 ret = read_symlink(sctx->send_root, ino, p);
2650 if (ret < 0)
2659 ret = send_cmd(sctx);
2660 if (ret < 0)
2667 return ret;
2677 int ret = 0;
2688 ret = -ENOMEM;
2695 ret = btrfs_search_slot(NULL, sctx->send_root, &key, path, 0, 0);
2696 if (ret < 0)
2703 ret = btrfs_next_leaf(sctx->send_root, path);
2704 if (ret < 0) {
2706 } else if (ret > 0) {
2707 ret = 0;
2716 ret = 0;
2725 ret = 1;
2734 return ret;
2745 int ret;
2748 ret = did_create_dir(sctx, sctx->cur_ino);
2749 if (ret < 0)
2751 if (ret) {
2752 ret = 0;
2757 ret = send_create_inode(sctx, sctx->cur_ino);
2758 if (ret < 0)
2762 return ret;
2844 int ret;
2851 ret = gen_unique_name(sctx, ino, gen, orphan);
2852 if (ret < 0)
2855 ret = send_rename(sctx, path, orphan);
2859 return ret;
2942 int ret = 0;
2969 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
2970 if (ret < 0)
2977 ret = btrfs_next_leaf(root, path);
2978 if (ret < 0)
2980 else if (ret > 0)
2998 ret = PTR_ERR(odi);
3005 ret = 0;
3012 ret = PTR_ERR(odi);
3017 ret = 0;
3025 ret = 1;
3029 return ret;
3111 int ret;
3137 ret = dup_ref(cur, &pm->update_refs);
3138 if (ret < 0)
3142 ret = dup_ref(cur, &pm->update_refs);
3143 if (ret < 0)
3147 ret = add_waiting_dir_move(sctx, pm->ino, is_orphan);
3148 if (ret)
3157 ret = 0;
3159 if (ret) {
3163 return ret;
3187 int ret = 0;
3201 ret = get_first_ref(sctx->parent_root, ino,
3204 ret = __get_cur_name_and_parent(sctx, ino, gen,
3207 if (ret > 0) {
3208 ret = 0;
3212 if (ret < 0)
3215 ret = 1;
3223 return ret;
3239 int ret;
3244 ret = -ENOMEM;
3256 ret = gen_unique_name(sctx, pm->ino,
3259 ret = get_first_ref(sctx->parent_root, pm->ino,
3261 if (ret < 0)
3263 ret = get_cur_path(sctx, parent_ino, parent_gen,
3265 if (ret < 0)
3267 ret = fs_path_add_path(from_path, name);
3269 if (ret < 0)
3273 ret = path_loop(sctx, name, pm->ino, pm->gen, &ancestor);
3274 if (ret < 0)
3276 if (ret) {
3279 ret = add_pending_dir_move(sctx, pm->ino, pm->gen, ancestor,
3282 if (ret < 0)
3295 ret = get_cur_path(sctx, pm->ino, pm->gen, to_path);
3296 if (ret < 0)
3299 ret = send_rename(sctx, from_path, to_path);
3300 if (ret < 0)
3314 ret = can_rmdir(sctx, rmdir_ino, gen, sctx->cur_ino);
3315 if (ret < 0)
3317 if (!ret)
3322 ret = -ENOMEM;
3325 ret = get_cur_path(sctx, rmdir_ino, gen, name);
3326 if (ret < 0)
3328 ret = send_rmdir(sctx, name);
3329 if (ret < 0)
3334 ret = send_utimes(sctx, pm->ino, pm->gen);
3335 if (ret < 0)
3346 ret = get_inode_info(sctx->send_root, cur->dir, NULL,
3348 if (ret == -ENOENT) {
3349 ret = 0;
3352 if (ret < 0)
3355 ret = send_utimes(sctx, cur->dir, cur->dir_gen);
3356 if (ret < 0)
3366 return ret;
3402 int ret = 0;
3414 ret = apply_dir_move(sctx, pm);
3416 if (ret)
3429 return ret;
3479 int ret = 0;
3493 ret = btrfs_search_slot(NULL, sctx->parent_root, &key, path, 0, 0);
3494 if (ret < 0) {
3496 } else if (ret > 0) {
3497 ret = 0;
3504 ret = 0;
3517 ret = 0;
3521 ret = get_inode_info(sctx->parent_root, di_key.objectid, NULL,
3523 if (ret < 0)
3525 ret = get_inode_info(sctx->send_root, di_key.objectid, NULL,
3527 if (ret < 0) {
3528 if (ret == -ENOENT)
3529 ret = 0;
3535 ret = 0;
3541 ret = add_pending_dir_move(sctx,
3548 if (!ret)
3549 ret = 1;
3553 return ret;
3575 int ret;
3578 ret = get_first_ref(root, ino, &parent, &parent_gen, fs_path);
3579 if (ret < 0)
3580 return ret;
3600 int ret = 0;
3613 ret = -ENOMEM;
3621 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
3622 if (ret < 0)
3632 ret = btrfs_next_leaf(root, path);
3633 if (ret < 0)
3635 if (ret > 0)
3669 ret = get_inode_info(root, parent, NULL, &parent_gen,
3671 if (ret < 0)
3673 ret = check_ino_in_path(root, ino1, ino1_gen,
3675 if (ret)
3680 ret = 0;
3685 return ret;
3692 int ret = 0;
3703 ret = -ENOMEM;
3728 ret = is_ancestor(sctx->parent_root,
3731 if (ret)
3738 ret = get_first_ref(sctx->send_root, ino, &parent_ino_after,
3740 if (ret < 0)
3742 ret = get_first_ref(sctx->parent_root, ino, &parent_ino_before,
3744 if (ret < 0 && ret != -ENOENT) {
3746 } else if (ret == -ENOENT) {
3747 ret = 0;
3758 ret = get_inode_info(sctx->parent_root, ino, NULL,
3761 if (ret < 0)
3764 ret = 1;
3776 if (ret == 1) {
3777 ret = add_pending_dir_move(sctx,
3784 if (!ret)
3785 ret = 1;
3788 return ret;
3793 int ret;
3804 ret = get_cur_path(sctx, ref->dir, ref->dir_gen, new_path);
3805 if (ret < 0) {
3807 return ret;
3809 ret = fs_path_add(new_path, ref->name, ref->name_len);
3810 if (ret < 0) {
3812 return ret;
3865 int ret;
3872 ret = get_cur_path(sctx, ref->dir, ref->dir_gen, ref->full_path);
3873 if (ret < 0)
3876 ret = fs_path_add(ref->full_path, name, ref->name_len);
3877 if (ret < 0)
3884 return ret;
3893 int ret = 0;
3919 ret = -ENOMEM;
3935 ret = did_overwrite_first_ref(sctx, sctx->cur_ino,
3937 if (ret < 0)
3939 if (ret)
3943 ret = gen_unique_name(sctx, sctx->cur_ino,
3945 if (ret < 0)
3949 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen,
3951 if (ret < 0)
3994 ret = get_cur_inode_state(sctx, cur->dir, cur->dir_gen);
3995 if (ret < 0)
3997 if (ret == inode_state_will_create)
4006 ret = will_overwrite_ref(sctx, cur->dir, cur->dir_gen,
4009 if (ret < 0)
4011 if (ret) {
4012 ret = is_first_ref(sctx->parent_root,
4015 if (ret < 0)
4017 if (ret) {
4022 ret = refresh_ref_path(sctx, cur);
4023 if (ret < 0)
4027 ret = orphanize_inode(sctx, ow_inode, ow_gen,
4029 if (ret < 0)
4070 ret = is_ancestor(sctx->parent_root,
4073 if (ret > 0) {
4076 ret = get_cur_path(sctx, sctx->cur_ino,
4080 if (ret < 0)
4090 ret = refresh_ref_path(sctx, cur);
4091 if (ret < 0)
4094 ret = send_unlink(sctx, cur->full_path);
4095 if (ret < 0)
4110 ret = get_cur_inode_state(sctx, cur->dir, cur->dir_gen);
4111 if (ret < 0)
4113 if (ret == inode_state_will_create) {
4114 ret = 0;
4123 ret = 1;
4132 if (!ret)
4133 ret = did_create_dir(sctx, cur->dir);
4134 if (ret < 0)
4136 if (!ret) {
4137 ret = send_create_inode(sctx, cur->dir);
4138 if (ret < 0)
4144 ret = wait_for_dest_dir_move(sctx, cur, is_orphan);
4145 if (ret < 0)
4147 if (ret == 1) {
4155 ret = wait_for_parent_move(sctx, cur, is_orphan);
4156 if (ret < 0)
4158 if (ret == 1) {
4170 ret = send_rename(sctx, valid_path, cur->full_path);
4171 if (ret < 0)
4174 ret = fs_path_copy(valid_path, cur->full_path);
4175 if (ret < 0)
4184 ret = send_rename(sctx, valid_path,
4186 if (!ret)
4187 ret = fs_path_copy(valid_path,
4189 if (ret < 0)
4200 ret = update_ref_path(sctx, cur);
4201 if (ret < 0)
4204 ret = send_link(sctx, cur->full_path,
4206 if (ret < 0)
4210 ret = dup_ref(cur, &check_dirs);
4211 if (ret < 0)
4222 ret = can_rmdir(sctx, sctx->cur_ino, sctx->cur_inode_gen,
4224 if (ret < 0)
4226 if (ret) {
4227 ret = send_rmdir(sctx, valid_path);
4228 if (ret < 0)
4231 ret = orphanize_inode(sctx, sctx->cur_ino,
4233 if (ret < 0)
4239 ret = dup_ref(cur, &check_dirs);
4240 if (ret < 0)
4250 ret = dup_ref(cur, &check_dirs);
4251 if (ret < 0)
4260 ret = did_overwrite_ref(sctx, cur->dir, cur->dir_gen,
4263 if (ret < 0)
4265 if (!ret) {
4274 ret = update_ref_path(sctx, cur);
4275 if (ret < 0)
4278 ret = send_unlink(sctx, cur->full_path);
4279 if (ret < 0)
4282 ret = dup_ref(cur, &check_dirs);
4283 if (ret < 0)
4295 ret = send_unlink(sctx, valid_path);
4296 if (ret < 0)
4316 ret = get_cur_inode_state(sctx, cur->dir, cur->dir_gen);
4317 if (ret < 0)
4320 if (ret == inode_state_did_create ||
4321 ret == inode_state_no_change) {
4323 ret = send_utimes(sctx, cur->dir, cur->dir_gen);
4324 if (ret < 0)
4326 } else if (ret == inode_state_did_delete &&
4328 ret = can_rmdir(sctx, cur->dir, cur->dir_gen,
4330 if (ret < 0)
4332 if (ret) {
4333 ret = get_cur_path(sctx, cur->dir,
4335 if (ret < 0)
4337 ret = send_rmdir(sctx, valid_path);
4338 if (ret < 0)
4345 ret = 0;
4351 return ret;
4357 int ret = 0;
4366 ret = get_inode_info(root, dir, NULL, &gen, NULL, NULL,
4368 if (ret < 0)
4371 ret = get_cur_path(sctx, dir, gen, p);
4372 if (ret < 0)
4374 ret = fs_path_add_path(p, name);
4375 if (ret < 0)
4378 ret = __record_ref(refs, dir, gen, p);
4381 if (ret)
4383 return ret;
4406 int ret;
4408 ret = iterate_inode_ref(sctx->send_root, sctx->left_path,
4410 if (ret < 0)
4412 ret = 0;
4415 return ret;
4420 int ret;
4422 ret = iterate_inode_ref(sctx->parent_root, sctx->right_path,
4424 if (ret < 0)
4426 ret = 0;
4429 return ret;
4446 int ret;
4454 ret = get_inode_info(ctx->root, dir, NULL, &dir_gen, NULL,
4456 if (ret)
4457 return ret;
4471 int ret;
4480 ret = iterate_inode_ref(root, path, key, 0, __find_iref, &ctx);
4481 if (ret < 0)
4482 return ret;
4495 int ret;
4498 ret = get_inode_info(sctx->send_root, dir, NULL, &dir_gen, NULL,
4500 if (ret)
4501 return ret;
4503 ret = find_iref(sctx->parent_root, sctx->right_path,
4505 if (ret == -ENOENT)
4506 ret = __record_new_ref(num, dir, index, name, sctx);
4507 else if (ret > 0)
4508 ret = 0;
4510 return ret;
4518 int ret;
4521 ret = get_inode_info(sctx->parent_root, dir, NULL, &dir_gen, NULL,
4523 if (ret)
4524 return ret;
4526 ret = find_iref(sctx->send_root, sctx->left_path, sctx->cmp_key,
4528 if (ret == -ENOENT)
4529 ret = __record_deleted_ref(num, dir, index, name, sctx);
4530 else if (ret > 0)
4531 ret = 0;
4533 return ret;
4538 int ret = 0;
4540 ret = iterate_inode_ref(sctx->send_root, sctx->left_path,
4542 if (ret < 0)
4544 ret = iterate_inode_ref(sctx->parent_root, sctx->right_path,
4546 if (ret < 0)
4548 ret = 0;
4551 return ret;
4561 int ret;
4584 ret = -EINVAL;
4591 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
4592 if (ret < 0)
4599 ret = btrfs_next_leaf(root, path);
4600 if (ret < 0)
4602 else if (ret > 0)
4614 ret = iterate_inode_ref(root, path, &found_key, 0, cb, sctx);
4615 if (ret < 0)
4627 ret = process_recorded_refs(sctx, &pending_move);
4630 return ret;
4638 int ret = 0;
4640 ret = begin_cmd(sctx, BTRFS_SEND_C_SET_XATTR);
4641 if (ret < 0)
4648 ret = send_cmd(sctx);
4652 return ret;
4659 int ret = 0;
4661 ret = begin_cmd(sctx, BTRFS_SEND_C_REMOVE_XATTR);
4662 if (ret < 0)
4668 ret = send_cmd(sctx);
4672 return ret;
4680 int ret;
4709 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
4710 if (ret < 0)
4713 ret = send_set_xattr(sctx, p, name, name_len, data, data_len);
4717 return ret;
4725 int ret;
4733 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
4734 if (ret < 0)
4737 ret = send_remove_xattr(sctx, p, name, name_len);
4741 return ret;
4746 int ret = 0;
4748 ret = iterate_dir_item(sctx->send_root, sctx->left_path,
4751 return ret;
4793 int ret;
4802 ret = iterate_dir_item(root, path, __find_xattr, &ctx);
4803 if (ret < 0)
4804 return ret;
4823 int ret;
4828 ret = find_xattr(sctx->parent_root, sctx->right_path,
4831 if (ret == -ENOENT) {
4832 ret = __process_new_xattr(num, di_key, name, name_len, data,
4834 } else if (ret >= 0) {
4837 ret = __process_new_xattr(num, di_key, name, name_len,
4840 ret = 0;
4845 return ret;
4853 int ret;
4856 ret = find_xattr(sctx->send_root, sctx->left_path, sctx->cmp_key,
4858 if (ret == -ENOENT)
4859 ret = __process_deleted_xattr(num, di_key, name, name_len, data,
4861 else if (ret >= 0)
4862 ret = 0;
4864 return ret;
4869 int ret = 0;
4871 ret = iterate_dir_item(sctx->send_root, sctx->left_path,
4873 if (ret < 0)
4875 ret = iterate_dir_item(sctx->parent_root, sctx->right_path,
4879 return ret;
4884 int ret;
4901 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
4902 if (ret < 0)
4909 ret = btrfs_next_leaf(root, path);
4910 if (ret < 0) {
4912 } else if (ret > 0) {
4913 ret = 0;
4922 ret = 0;
4926 ret = iterate_dir_item(root, path, __process_new_xattr, sctx);
4927 if (ret < 0)
4935 return ret;
4966 int ret;
4968 ret = put_data_header(sctx, len);
4969 if (ret)
4970 return ret;
4994 ret = -ENOMEM;
5014 ret = -EIO;
5031 return ret;
5041 int ret = 0;
5050 ret = begin_cmd(sctx, BTRFS_SEND_C_WRITE);
5051 if (ret < 0)
5054 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
5055 if (ret < 0)
5060 ret = put_file_data(sctx, offset, len);
5061 if (ret < 0)
5064 ret = send_cmd(sctx);
5069 return ret;
5079 int ret = 0;
5092 ret = begin_cmd(sctx, BTRFS_SEND_C_CLONE);
5093 if (ret < 0)
5096 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
5097 if (ret < 0)
5105 ret = get_inode_info(sctx->send_root, clone_root->ino, NULL,
5107 if (ret < 0)
5109 ret = get_cur_path(sctx, clone_root->ino, gen, p);
5111 ret = get_inode_path(clone_root->root, clone_root->ino, p);
5113 if (ret < 0)
5137 ret = send_cmd(sctx);
5142 return ret;
5151 int ret = 0;
5158 ret = begin_cmd(sctx, BTRFS_SEND_C_UPDATE_EXTENT);
5159 if (ret < 0)
5162 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
5163 if (ret < 0)
5170 ret = send_cmd(sctx);
5175 return ret;
5183 int ret = 0;
5206 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
5207 if (ret < 0)
5212 ret = begin_cmd(sctx, BTRFS_SEND_C_WRITE);
5213 if (ret < 0)
5217 ret = put_data_header(sctx, len);
5218 if (ret < 0)
5222 ret = send_cmd(sctx);
5223 if (ret < 0)
5230 return ret;
5245 int ret;
5247 ret = send_write(sctx, offset + sent, size);
5248 if (ret < 0)
5249 return ret;
5271 int ret = 0;
5283 ret = PTR_ERR(di);
5293 ret = -ENOMEM;
5297 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, fspath);
5298 if (ret < 0)
5304 ret = send_set_xattr(sctx, fspath, XATTR_NAME_CAPS,
5310 return ret;
5322 int ret;
5352 ret = __get_inode_info(clone_root->root, path, clone_root->ino,
5355 if (ret < 0)
5383 ret = btrfs_search_slot(NULL, clone_root->root, &key, path, 0, 0);
5384 if (ret < 0)
5386 if (ret > 0 && path->slots[0] > 0) {
5404 ret = btrfs_next_leaf(clone_root->root, path);
5405 if (ret < 0)
5407 else if (ret > 0)
5440 ret = send_extent_data(sctx, offset, hole_len);
5441 if (ret < 0)
5510 ret = send_clone(sctx, offset, slen,
5512 if (ret < 0)
5515 ret = send_extent_data(sctx, offset + slen,
5518 ret = send_clone(sctx, offset, clone_len,
5541 ret = send_extent_data(sctx, offset, clone_len);
5544 if (ret < 0)
5573 ret = send_extent_data(sctx, offset, len);
5575 ret = 0;
5578 return ret;
5586 int ret = 0;
5604 ret = clone_range(sctx, clone_root, disk_byte, data_offset,
5607 ret = send_extent_data(sctx, offset, end - offset);
5610 return ret;
5617 int ret = 0;
5646 ret = 0;
5678 ret = btrfs_search_slot_for_read(sctx->parent_root, &key, path, 0, 0);
5679 if (ret < 0)
5681 if (ret) {
5682 ret = 0;
5695 ret = (left_disknr) ? 0 : 1;
5708 ret = 0;
5725 ret = (left_disknr) ? 0 : 1;
5738 ret = 0;
5761 ret = 0;
5768 ret = btrfs_next_item(sctx->parent_root, path);
5769 if (ret < 0)
5771 if (!ret) {
5776 if (ret || found_key.objectid != key.objectid ||
5782 ret = 0;
5793 ret = 1;
5795 ret = 0;
5800 return ret;
5808 int ret;
5819 ret = btrfs_search_slot_for_read(root, &key, path, 0, 1);
5820 if (ret < 0)
5822 ret = 0;
5830 return ret;
5841 int ret;
5850 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5851 if (ret < 0)
5853 if (ret > 0 && path->slots[0] > 0)
5863 ret = btrfs_next_leaf(root, path);
5864 if (ret < 0)
5866 else if (ret > 0)
5888 ret = 0;
5893 ret = 1;
5896 return ret;
5902 int ret = 0;
5908 ret = get_last_extent(sctx, key->offset - 1);
5909 if (ret)
5910 return ret;
5922 ret = get_last_extent(sctx, key->offset - 1);
5923 if (ret)
5924 return ret;
5928 ret = range_is_hole_in_parent(sctx,
5931 if (ret < 0)
5932 return ret;
5933 else if (ret == 0)
5934 ret = send_hole(sctx, key->offset);
5936 ret = 0;
5939 return ret;
5947 int ret = 0;
5953 ret = is_extent_unchanged(sctx, path, key);
5954 if (ret < 0)
5956 if (ret) {
5957 ret = 0;
5976 ret = 0;
5982 ret = 0;
5988 ret = find_extent_clone(sctx, path, key->objectid, key->offset,
5990 if (ret != -ENOENT && ret < 0)
5993 ret = send_write_or_clone(sctx, path, key, found_clone);
5994 if (ret)
5997 ret = maybe_send_hole(sctx, path, key);
5999 return ret;
6004 int ret;
6020 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
6021 if (ret < 0)
6029 ret = btrfs_next_leaf(root, path);
6030 if (ret < 0) {
6032 } else if (ret > 0) {
6033 ret = 0;
6043 ret = 0;
6047 ret = process_extent(sctx, path, &found_key);
6048 if (ret < 0)
6056 return ret;
6063 int ret = 0;
6073 ret = process_recorded_refs(sctx, pending_move);
6074 if (ret < 0)
6079 return ret;
6084 int ret = 0;
6100 ret = process_recorded_refs_if_needed(sctx, at_end, &pending_move,
6102 if (ret < 0)
6125 ret = get_inode_info(sctx->send_root, sctx->cur_ino, NULL, NULL,
6127 if (ret < 0)
6139 ret = get_inode_info(sctx->parent_root, sctx->cur_ino,
6142 if (ret < 0)
6160 ret = get_last_extent(sctx, (u64)-1);
6161 if (ret)
6166 ret = send_hole(sctx, sctx->cur_inode_size);
6167 if (ret)
6172 ret = send_truncate(sctx, sctx->cur_ino,
6175 if (ret < 0)
6181 ret = send_chown(sctx, sctx->cur_ino, sctx->cur_inode_gen,
6183 if (ret < 0)
6187 ret = send_chmod(sctx, sctx->cur_ino, sctx->cur_inode_gen,
6189 if (ret < 0)
6193 ret = send_capabilities(sctx);
6194 if (ret < 0)
6202 ret = apply_children_dir_moves(sctx);
6203 if (ret)
6213 ret = send_utimes(sctx, sctx->cur_ino, sctx->cur_inode_gen);
6214 if (ret < 0)
6219 return ret;
6246 int ret;
6255 ret = btrfs_search_slot(NULL, sctx->parent_root, &key, path, 0, 0);
6256 if (ret < 0)
6267 ret = btrfs_next_leaf(sctx->parent_root, path);
6268 if (ret < 0)
6270 else if (ret > 0)
6282 ret = iterate_inode_ref(sctx->parent_root, path, &key, 1,
6284 if (ret < 0)
6294 ret = send_unlink(sctx, ref->full_path);
6295 if (ret < 0)
6301 ret = 0;
6304 if (ret)
6306 return ret;
6312 int ret = 0;
6386 ret = btrfs_unlink_all_paths(sctx);
6402 ret = send_create_inode_if_needed(sctx);
6430 ret = process_all_refs(sctx,
6432 if (ret < 0)
6447 ret = send_create_inode_if_needed(sctx);
6448 if (ret < 0)
6451 ret = process_all_refs(sctx, BTRFS_COMPARE_TREE_NEW);
6452 if (ret < 0)
6464 ret = process_all_extents(sctx);
6465 if (ret < 0)
6467 ret = process_all_new_xattrs(sctx);
6468 if (ret < 0)
6483 return ret;
6499 int ret = 0;
6509 ret = record_new_ref(sctx);
6511 ret = record_deleted_ref(sctx);
6513 ret = record_changed_ref(sctx);
6516 return ret;
6527 int ret = 0;
6536 ret = process_new_xattr(sctx);
6538 ret = process_deleted_xattr(sctx);
6540 ret = process_changed_xattr(sctx);
6543 return ret;
6554 int ret = 0;
6574 ret = process_extent(sctx, sctx->left_path,
6578 return ret;
6584 int ret;
6586 ret = get_inode_info(sctx->send_root, dir, NULL, &new_gen, NULL, NULL,
6588 if (ret)
6589 return ret;
6591 ret = get_inode_info(sctx->parent_root, dir, NULL, &orig_gen, NULL,
6593 if (ret)
6594 return ret;
6609 int ret = 0;
6615 ret = dir_changed(sctx, dirid);
6630 ret = dir_changed(sctx, dirid);
6631 if (ret)
6636 return ret;
6649 int ret = 0;
6655 ret = compare_refs(sctx, left_path, key);
6656 if (!ret)
6658 if (ret < 0)
6659 return ret;
6666 ret = 0;
6673 ret = finish_inode_if_needed(sctx, 0);
6674 if (ret < 0)
6683 ret = changed_inode(sctx, result);
6687 ret = changed_ref(sctx, result);
6689 ret = changed_xattr(sctx, result);
6691 ret = changed_extent(sctx, result);
6695 return ret;
6700 int ret;
6715 ret = btrfs_search_slot_for_read(send_root, &key, path, 1, 0);
6716 if (ret < 0)
6718 if (ret)
6726 ret = changed_cb(path, NULL, &key,
6728 if (ret < 0)
6731 ret = btrfs_next_item(send_root, path);
6732 if (ret < 0)
6734 if (ret) {
6735 ret = 0;
6741 ret = finish_inode_if_needed(sctx, 1);
6745 return ret;
6766 int ret = 0;
6784 ret = 1;
6786 return ret;
6798 int ret;
6801 ret = tree_move_next_or_upnext(path, level, root_level);
6803 ret = tree_move_down(path, level);
6805 if (ret >= 0) {
6813 return ret;
6858 int ret;
6880 ret = -ENOMEM;
6885 ret = -ENOMEM;
6891 ret = -ENOMEM;
6943 ret = -ENOMEM;
6953 ret = -ENOMEM;
6977 ret = tree_advance(left_path, &left_level,
6981 if (ret == -1)
6983 else if (ret < 0)
6988 ret = tree_advance(right_path, &right_level,
6992 if (ret == -1)
6994 else if (ret < 0)
7000 ret = 0;
7004 ret = changed_cb(left_path, right_path,
7008 if (ret < 0)
7015 ret = changed_cb(left_path, right_path,
7019 if (ret < 0)
7029 ret = changed_cb(left_path, right_path,
7033 if (ret < 0)
7037 ret = changed_cb(left_path, right_path,
7041 if (ret < 0)
7048 ret = tree_compare_item(left_path, right_path,
7050 if (ret)
7054 ret = changed_cb(left_path, right_path,
7056 if (ret < 0)
7104 return ret;
7109 int ret;
7112 ret = send_header(sctx);
7113 if (ret < 0)
7117 ret = send_subvol_begin(sctx);
7118 if (ret < 0)
7122 ret = btrfs_compare_trees(sctx->send_root, sctx->parent_root, sctx);
7123 if (ret < 0)
7125 ret = finish_inode_if_needed(sctx, 1);
7126 if (ret < 0)
7129 ret = full_send_tree(sctx);
7130 if (ret < 0)
7136 return ret;
7195 int ret;
7199 ret = btrfs_start_delalloc_snapshot(root);
7200 if (ret)
7201 return ret;
7207 ret = btrfs_start_delalloc_snapshot(root);
7208 if (ret)
7209 return ret;
7240 int ret = 0;
7272 ret = -EPERM;
7283 ret = -EINVAL;
7288 ret = -EOPNOTSUPP;
7294 ret = -ENOMEM;
7307 ret = -EBADF;
7317 ret = -EPERM;
7326 ret = -ENOMEM;
7338 ret = -ENOMEM;
7348 ret = -ENOMEM;
7352 ret = copy_from_user(clone_sources_tmp, arg->clone_sources,
7354 if (ret) {
7355 ret = -EFAULT;
7363 ret = PTR_ERR(clone_root);
7371 ret = -EPERM;
7378 ret = -EAGAIN;
7395 ret = PTR_ERR(sctx->parent_root);
7404 ret = -EPERM;
7410 ret = -EAGAIN;
7430 ret = flush_delalloc_roots(sctx);
7431 if (ret)
7434 ret = ensure_commit_roots_uptodate(sctx);
7435 if (ret)
7443 ret = -EAGAIN;
7450 ret = send_subvol(sctx);
7455 if (ret < 0)
7459 ret = begin_cmd(sctx, BTRFS_SEND_C_END);
7460 if (ret < 0)
7462 ret = send_cmd(sctx);
7463 if (ret < 0)
7468 WARN_ON(sctx && !ret && !RB_EMPTY_ROOT(&sctx->pending_dir_moves));
7485 WARN_ON(sctx && !ret && !RB_EMPTY_ROOT(&sctx->waiting_dir_moves));
7496 WARN_ON(sctx && !ret && !RB_EMPTY_ROOT(&sctx->orphan_dirs));
7540 return ret;