Lines Matching refs:ret
348 int ret;
533 int ret;
539 ret = fs_path_ensure_buf(p, new_len);
540 if (ret < 0)
557 return ret;
562 int ret;
565 ret = fs_path_prepare_for_add(p, name_len, &prepared);
566 if (ret < 0)
571 return ret;
576 int ret;
579 ret = fs_path_prepare_for_add(p, p2->end - p2->start, &prepared);
580 if (ret < 0)
585 return ret;
592 int ret;
595 ret = fs_path_prepare_for_add(p, len, &prepared);
596 if (ret < 0)
602 return ret;
644 int ret;
648 ret = kernel_write(filp, buf + pos, len - pos, off);
649 if (ret < 0)
650 return ret;
651 if (ret == 0)
653 pos += ret;
718 ret = tlv_put(sctx, attrtype, data, attrlen); \
719 if (ret < 0) \
725 ret = tlv_put_u##bits(sctx, attrtype, value); \
726 if (ret < 0) \
736 ret = tlv_put_string(sctx, attrtype, str, len); \
737 if (ret < 0) \
742 ret = tlv_put_string(sctx, attrtype, p->start, \
744 if (ret < 0) \
749 ret = tlv_put_uuid(sctx, attrtype, uuid); \
750 if (ret < 0) \
755 ret = tlv_put_btrfs_timespec(sctx, attrtype, eb, ts); \
756 if (ret < 0) \
791 int ret;
802 ret = write_buf(sctx->send_filp, sctx->send_buf, sctx->send_size,
808 return ret;
818 int ret;
822 ret = begin_cmd(sctx, BTRFS_SEND_C_RENAME);
823 if (ret < 0)
829 ret = send_cmd(sctx);
833 return ret;
843 int ret;
847 ret = begin_cmd(sctx, BTRFS_SEND_C_LINK);
848 if (ret < 0)
854 ret = send_cmd(sctx);
858 return ret;
867 int ret;
871 ret = begin_cmd(sctx, BTRFS_SEND_C_UNLINK);
872 if (ret < 0)
877 ret = send_cmd(sctx);
881 return ret;
890 int ret;
894 ret = begin_cmd(sctx, BTRFS_SEND_C_RMDIR);
895 if (ret < 0)
900 ret = send_cmd(sctx);
904 return ret;
924 int ret;
936 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
937 if (ret) {
938 if (ret > 0)
939 ret = -ENOENT;
963 return ret;
968 int ret;
973 ret = get_inode_info(root, ino, &info);
975 return ret;
1004 int ret = 0;
1056 ret = PTR_ERR(start);
1061 ret = fs_path_ensure_buf(p,
1063 if (ret < 0)
1070 ret = PTR_ERR(start);
1077 ret = fs_path_add_from_extent_buffer(p, eb, name_off,
1079 if (ret < 0)
1084 ret = iterate(num, dir, index, p, ctx);
1085 if (ret)
1093 return ret;
1111 int ret = 0;
1134 ret = -ENOMEM;
1153 ret = -ENAMETOOLONG;
1158 ret = -E2BIG;
1166 ret = -ENAMETOOLONG;
1187 ret = -ENOMEM;
1200 ret = iterate(num, &di_key, buf, name_len, buf + name_len,
1202 if (ret < 0)
1204 if (ret) {
1205 ret = 0;
1214 return ret;
1220 int ret;
1223 ret = fs_path_copy(pt, p);
1224 if (ret < 0)
1225 return ret;
1238 int ret;
1252 ret = btrfs_search_slot_for_read(root, &key, p, 1, 0);
1253 if (ret < 0)
1255 if (ret) {
1256 ret = 1;
1263 ret = -ENOENT;
1267 ret = iterate_inode_ref(root, p, &found_key, 1,
1269 if (ret < 0)
1271 ret = 0;
1275 return ret;
1448 int ret;
1493 ret = btrfs_lru_cache_store(&sctx->backref_cache, &new_entry->entry,
1495 ASSERT(ret == 0 || ret == -ENOMEM);
1496 if (ret) {
1576 int ret;
1667 ret = iterate_extent_inodes(&backref_walk_ctx, true, iterate_backrefs,
1669 if (ret < 0)
1670 return ret;
1727 ret = 0;
1729 ret = -ENOENT;
1732 return ret;
1739 int ret;
1755 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1756 if (ret < 0)
1758 if (ret) {
1770 ret = -EIO;
1778 ret = -EUCLEAN;
1786 ret = -EUCLEAN;
1796 ret = fs_path_add_from_extent_buffer(dest, path->nodes[0], off, len);
1800 return ret;
1811 int ret = 0;
1836 ret = PTR_ERR(di);
1847 ret = 0;
1856 ret = PTR_ERR(di);
1868 ret = fs_path_add(dest, tmp, strlen(tmp));
1872 return ret;
1886 int ret;
1893 ret = get_inode_info(sctx->send_root, ino, &info);
1894 if (ret < 0 && ret != -ENOENT)
1896 left_ret = (info.nlink == 0) ? -ENOENT : ret;
1904 ret = get_inode_info(sctx->parent_root, ino, &info);
1905 if (ret < 0 && ret != -ENOENT)
1907 right_ret = (info.nlink == 0) ? -ENOENT : ret;
1915 ret = inode_state_no_change;
1918 ret = inode_state_did_create;
1920 ret = inode_state_will_create;
1923 ret = inode_state_did_delete;
1925 ret = inode_state_will_delete;
1927 ret = -ENOENT;
1932 ret = inode_state_did_create;
1934 ret = inode_state_will_create;
1936 ret = -ENOENT;
1941 ret = inode_state_did_delete;
1943 ret = inode_state_will_delete;
1945 ret = -ENOENT;
1948 ret = -ENOENT;
1952 return ret;
1958 int ret;
1963 ret = get_cur_inode_state(sctx, ino, gen, send_gen, parent_gen);
1964 if (ret < 0)
1967 if (ret == inode_state_no_change ||
1968 ret == inode_state_did_create ||
1969 ret == inode_state_will_delete)
1970 ret = 1;
1972 ret = 0;
1975 return ret;
1985 int ret = 0;
1997 ret = di ? PTR_ERR(di) : -ENOENT;
2002 ret = -ENOENT;
2009 return ret;
2019 int ret;
2034 ret = btrfs_search_slot_for_read(root, &key, path, 1, 0);
2035 if (ret < 0)
2037 if (!ret)
2040 if (ret || found_key.objectid != ino ||
2043 ret = -ENOENT;
2052 ret = fs_path_add_from_extent_buffer(name, path->nodes[0],
2061 ret = fs_path_add_from_extent_buffer(name, path->nodes[0],
2065 if (ret < 0)
2070 ret = get_inode_gen(root, parent_dir, dir_gen);
2071 if (ret < 0)
2079 return ret;
2086 int ret;
2094 ret = get_first_ref(root, ino, &tmp_dir, NULL, tmp_name);
2095 if (ret < 0)
2099 ret = 0;
2103 ret = !memcmp(tmp_name->start, name, name_len);
2107 return ret;
2124 int ret;
2132 ret = is_inode_existent(sctx, dir, dir_gen, NULL, &parent_root_dir_gen);
2133 if (ret <= 0)
2148 ret = lookup_dir_item_inode(sctx->parent_root, dir, name, name_len,
2150 if (ret == -ENOENT)
2152 else if (ret < 0)
2153 return ret;
2162 ret = get_inode_info(sctx->parent_root, other_inode, &info);
2163 if (ret < 0)
2164 return ret;
2187 int ret;
2195 ret = is_inode_existent(sctx, dir, dir_gen, &send_root_dir_gen, NULL);
2196 if (ret <= 0)
2197 return ret;
2207 ret = lookup_dir_item_inode(sctx->send_root, dir, name, name_len,
2209 if (ret == -ENOENT) {
2212 } else if (ret < 0) {
2213 return ret;
2217 ret = get_inode_gen(sctx->send_root, ow_inode, &ow_gen);
2218 if (ret < 0)
2219 return ret;
2237 ret = get_inode_gen(sctx->send_root, ow_inode, &ow_gen);
2238 if (ret < 0)
2239 return ret;
2255 int ret = 0;
2267 ret = get_first_ref(sctx->parent_root, ino, &dir, &dir_gen, name);
2268 if (ret < 0)
2271 ret = did_overwrite_ref(sctx, dir, dir_gen, ino, gen,
2276 return ret;
2305 int ret;
2322 ret = fs_path_add(dest, nce->name, nce->name_len);
2323 if (ret < 0)
2325 ret = nce->ret;
2335 ret = is_inode_existent(sctx, ino, gen, NULL, NULL);
2336 if (ret < 0)
2339 if (!ret) {
2340 ret = gen_unique_name(sctx, ino, gen, dest);
2341 if (ret < 0)
2343 ret = 1;
2352 ret = get_first_ref(sctx->send_root, ino,
2355 ret = get_first_ref(sctx->parent_root, ino,
2357 if (ret < 0)
2364 ret = did_overwrite_ref(sctx, *parent_ino, *parent_gen, ino, gen,
2366 if (ret < 0)
2368 if (ret) {
2370 ret = gen_unique_name(sctx, ino, gen, dest);
2371 if (ret < 0)
2373 ret = 1;
2382 ret = -ENOMEM;
2391 nce->ret = ret;
2402 ret = nce_ret;
2406 return ret;
2437 int ret = 0;
2445 ret = -ENOMEM;
2458 ret = gen_unique_name(sctx, ino, gen, name);
2459 if (ret < 0)
2461 ret = fs_path_add_path(dest, name);
2467 ret = gen_unique_name(sctx, ino, gen, name);
2470 ret = get_first_ref(sctx->parent_root, ino,
2473 ret = __get_cur_name_and_parent(sctx, ino, gen,
2476 if (ret)
2480 if (ret < 0)
2483 ret = fs_path_add_path(dest, name);
2484 if (ret < 0)
2493 if (!ret)
2495 return ret;
2503 int ret;
2527 ret = btrfs_search_slot_for_read(send_root->fs_info->tree_root,
2529 if (ret < 0)
2531 if (ret) {
2532 ret = -ENOENT;
2540 ret = -ENOENT;
2549 ret = begin_cmd(sctx, BTRFS_SEND_C_SNAPSHOT);
2550 if (ret < 0)
2553 ret = begin_cmd(sctx, BTRFS_SEND_C_SUBVOL);
2554 if (ret < 0)
2580 ret = send_cmd(sctx);
2586 return ret;
2592 int ret = 0;
2601 ret = begin_cmd(sctx, BTRFS_SEND_C_TRUNCATE);
2602 if (ret < 0)
2605 ret = get_cur_path(sctx, ino, gen, p);
2606 if (ret < 0)
2611 ret = send_cmd(sctx);
2616 return ret;
2622 int ret = 0;
2631 ret = begin_cmd(sctx, BTRFS_SEND_C_CHMOD);
2632 if (ret < 0)
2635 ret = get_cur_path(sctx, ino, gen, p);
2636 if (ret < 0)
2641 ret = send_cmd(sctx);
2646 return ret;
2652 int ret = 0;
2664 ret = begin_cmd(sctx, BTRFS_SEND_C_FILEATTR);
2665 if (ret < 0)
2668 ret = get_cur_path(sctx, ino, gen, p);
2669 if (ret < 0)
2674 ret = send_cmd(sctx);
2679 return ret;
2685 int ret = 0;
2695 ret = begin_cmd(sctx, BTRFS_SEND_C_CHOWN);
2696 if (ret < 0)
2699 ret = get_cur_path(sctx, ino, gen, p);
2700 if (ret < 0)
2706 ret = send_cmd(sctx);
2711 return ret;
2717 int ret = 0;
2733 ret = -ENOMEM;
2740 ret = btrfs_search_slot(NULL, sctx->send_root, &key, path, 0, 0);
2741 if (ret > 0)
2742 ret = -ENOENT;
2743 if (ret < 0)
2750 ret = begin_cmd(sctx, BTRFS_SEND_C_UTIMES);
2751 if (ret < 0)
2754 ret = get_cur_path(sctx, ino, gen, p);
2755 if (ret < 0)
2764 ret = send_cmd(sctx);
2770 return ret;
2786 int ret;
2800 ret = btrfs_lru_cache_store(&sctx->dir_utimes_cache, entry, GFP_KERNEL);
2801 ASSERT(ret != -EEXIST);
2802 if (ret) {
2815 int ret;
2820 ret = send_utimes(sctx, lru->key, lru->gen);
2821 if (ret)
2822 return ret;
2838 int ret = 0;
2853 ret = get_inode_info(sctx->send_root, ino, &info);
2854 if (ret < 0)
2880 ret = -EOPNOTSUPP;
2884 ret = begin_cmd(sctx, cmd);
2885 if (ret < 0)
2888 ret = gen_unique_name(sctx, ino, gen, p);
2889 if (ret < 0)
2897 ret = read_symlink(sctx->send_root, ino, p);
2898 if (ret < 0)
2907 ret = send_cmd(sctx);
2908 if (ret < 0)
2915 return ret;
2921 int ret;
2930 ret = btrfs_lru_cache_store(&sctx->dir_created_cache, entry, GFP_KERNEL);
2931 if (ret < 0)
2942 int ret = 0;
2966 ret = 0;
2975 ret = 1;
2982 ret = iter_ret;
2985 return ret;
2996 int ret;
2999 ret = did_create_dir(sctx, sctx->cur_ino);
3000 if (ret < 0)
3001 return ret;
3002 else if (ret > 0)
3006 ret = send_create_inode(sctx, sctx->cur_ino);
3008 if (ret == 0 && S_ISDIR(sctx->cur_inode_mode))
3011 return ret;
3093 int ret;
3100 ret = gen_unique_name(sctx, ino, gen, orphan);
3101 if (ret < 0)
3104 ret = send_rename(sctx, path, orphan);
3108 return ret;
3191 int ret = 0;
3230 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
3231 if (ret < 0) {
3233 } else if (ret > 0) {
3237 ret = -EUCLEAN;
3246 ret = 1;
3255 ret = 0;
3284 ret = 0;
3289 ret = 0;
3294 ret = iter_ret;
3299 ret = 1;
3304 if (ret)
3305 return ret;
3400 int ret;
3426 ret = dup_ref(cur, &pm->update_refs);
3427 if (ret < 0)
3431 ret = dup_ref(cur, &pm->update_refs);
3432 if (ret < 0)
3436 ret = add_waiting_dir_move(sctx, pm->ino, is_orphan);
3437 if (ret)
3446 ret = 0;
3448 if (ret) {
3452 return ret;
3476 int ret = 0;
3490 ret = get_first_ref(sctx->parent_root, ino,
3493 ret = __get_cur_name_and_parent(sctx, ino, gen,
3496 if (ret > 0) {
3497 ret = 0;
3501 if (ret < 0)
3504 ret = 1;
3512 return ret;
3528 int ret;
3533 ret = -ENOMEM;
3545 ret = gen_unique_name(sctx, pm->ino,
3548 ret = get_first_ref(sctx->parent_root, pm->ino,
3550 if (ret < 0)
3552 ret = get_cur_path(sctx, parent_ino, parent_gen,
3554 if (ret < 0)
3556 ret = fs_path_add_path(from_path, name);
3558 if (ret < 0)
3562 ret = path_loop(sctx, name, pm->ino, pm->gen, &ancestor);
3563 if (ret < 0)
3565 if (ret) {
3568 ret = add_pending_dir_move(sctx, pm->ino, pm->gen, ancestor,
3571 if (ret < 0)
3584 ret = get_cur_path(sctx, pm->ino, pm->gen, to_path);
3585 if (ret < 0)
3588 ret = send_rename(sctx, from_path, to_path);
3589 if (ret < 0)
3603 ret = can_rmdir(sctx, rmdir_ino, gen);
3604 if (ret < 0)
3606 if (!ret)
3611 ret = -ENOMEM;
3614 ret = get_cur_path(sctx, rmdir_ino, gen, name);
3615 if (ret < 0)
3617 ret = send_rmdir(sctx, name);
3618 if (ret < 0)
3623 ret = cache_dir_utimes(sctx, pm->ino, pm->gen);
3624 if (ret < 0)
3635 ret = get_inode_info(sctx->send_root, cur->dir, NULL);
3636 if (ret == -ENOENT) {
3637 ret = 0;
3640 if (ret < 0)
3643 ret = cache_dir_utimes(sctx, cur->dir, cur->dir_gen);
3644 if (ret < 0)
3654 return ret;
3690 int ret = 0;
3701 ret = apply_dir_move(sctx, pm);
3703 if (ret)
3716 return ret;
3766 int ret = 0;
3780 ret = btrfs_search_slot(NULL, sctx->parent_root, &key, path, 0, 0);
3781 if (ret < 0) {
3783 } else if (ret > 0) {
3784 ret = 0;
3791 ret = 0;
3804 ret = 0;
3808 ret = get_inode_gen(sctx->parent_root, di_key.objectid, &left_gen);
3809 if (ret < 0)
3811 ret = get_inode_gen(sctx->send_root, di_key.objectid, &right_gen);
3812 if (ret < 0) {
3813 if (ret == -ENOENT)
3814 ret = 0;
3820 ret = 0;
3826 ret = add_pending_dir_move(sctx,
3833 if (!ret)
3834 ret = 1;
3838 return ret;
3860 int ret;
3863 ret = get_first_ref(root, ino, &parent, &parent_gen, fs_path);
3864 if (ret < 0)
3865 return ret;
3885 int ret = 0;
3899 ret = -ENOMEM;
3941 ret = get_inode_gen(root, parent, &parent_gen);
3942 if (ret < 0)
3944 ret = check_ino_in_path(root, ino1, ino1_gen,
3946 if (ret)
3950 ret = 0;
3952 ret = iter_ret;
3958 return ret;
3965 int ret = 0;
3976 ret = -ENOMEM;
4001 ret = is_ancestor(sctx->parent_root,
4004 if (ret)
4011 ret = get_first_ref(sctx->send_root, ino, &parent_ino_after,
4013 if (ret < 0)
4015 ret = get_first_ref(sctx->parent_root, ino, &parent_ino_before,
4017 if (ret < 0 && ret != -ENOENT) {
4019 } else if (ret == -ENOENT) {
4020 ret = 0;
4031 ret = get_inode_gen(sctx->parent_root, ino, &parent_ino_gen);
4032 if (ret < 0)
4035 ret = 1;
4047 if (ret == 1) {
4048 ret = add_pending_dir_move(sctx,
4055 if (!ret)
4056 ret = 1;
4059 return ret;
4064 int ret;
4075 ret = get_cur_path(sctx, ref->dir, ref->dir_gen, new_path);
4076 if (ret < 0) {
4078 return ret;
4080 ret = fs_path_add(new_path, ref->name, ref->name_len);
4081 if (ret < 0) {
4083 return ret;
4136 int ret;
4143 ret = get_cur_path(sctx, ref->dir, ref->dir_gen, ref->full_path);
4144 if (ret < 0)
4147 ret = fs_path_add(ref->full_path, name, ref->name_len);
4148 if (ret < 0)
4155 return ret;
4164 int ret = 0;
4189 ret = -ENOMEM;
4205 ret = did_overwrite_first_ref(sctx, sctx->cur_ino,
4207 if (ret < 0)
4209 if (ret)
4213 ret = gen_unique_name(sctx, sctx->cur_ino,
4215 if (ret < 0)
4219 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen,
4221 if (ret < 0)
4264 ret = get_cur_inode_state(sctx, cur->dir, cur->dir_gen, NULL, NULL);
4265 if (ret < 0)
4267 if (ret == inode_state_will_create)
4276 ret = will_overwrite_ref(sctx, cur->dir, cur->dir_gen,
4279 if (ret < 0)
4281 if (ret) {
4282 ret = is_first_ref(sctx->parent_root,
4285 if (ret < 0)
4287 if (ret) {
4292 ret = refresh_ref_path(sctx, cur);
4293 if (ret < 0)
4297 ret = orphanize_inode(sctx, ow_inode, ow_gen,
4299 if (ret < 0)
4336 ret = is_ancestor(sctx->parent_root,
4339 if (ret > 0) {
4342 ret = get_cur_path(sctx, sctx->cur_ino,
4346 if (ret < 0)
4356 ret = refresh_ref_path(sctx, cur);
4357 if (ret < 0)
4360 ret = send_unlink(sctx, cur->full_path);
4361 if (ret < 0)
4376 ret = get_cur_inode_state(sctx, cur->dir, cur->dir_gen, NULL, NULL);
4377 if (ret < 0)
4379 if (ret == inode_state_will_create) {
4380 ret = 0;
4389 ret = 1;
4398 if (!ret)
4399 ret = did_create_dir(sctx, cur->dir);
4400 if (ret < 0)
4402 if (!ret) {
4403 ret = send_create_inode(sctx, cur->dir);
4404 if (ret < 0)
4411 ret = wait_for_dest_dir_move(sctx, cur, is_orphan);
4412 if (ret < 0)
4414 if (ret == 1) {
4422 ret = wait_for_parent_move(sctx, cur, is_orphan);
4423 if (ret < 0)
4425 if (ret == 1) {
4437 ret = send_rename(sctx, valid_path, cur->full_path);
4438 if (ret < 0)
4441 ret = fs_path_copy(valid_path, cur->full_path);
4442 if (ret < 0)
4451 ret = send_rename(sctx, valid_path,
4453 if (!ret)
4454 ret = fs_path_copy(valid_path,
4456 if (ret < 0)
4467 ret = update_ref_path(sctx, cur);
4468 if (ret < 0)
4471 ret = send_link(sctx, cur->full_path,
4473 if (ret < 0)
4477 ret = dup_ref(cur, &check_dirs);
4478 if (ret < 0)
4489 ret = can_rmdir(sctx, sctx->cur_ino, sctx->cur_inode_gen);
4490 if (ret < 0)
4492 if (ret) {
4493 ret = send_rmdir(sctx, valid_path);
4494 if (ret < 0)
4497 ret = orphanize_inode(sctx, sctx->cur_ino,
4499 if (ret < 0)
4505 ret = dup_ref(cur, &check_dirs);
4506 if (ret < 0)
4516 ret = dup_ref(cur, &check_dirs);
4517 if (ret < 0)
4526 ret = did_overwrite_ref(sctx, cur->dir, cur->dir_gen,
4529 if (ret < 0)
4531 if (!ret) {
4540 ret = update_ref_path(sctx, cur);
4541 if (ret < 0)
4544 ret = send_unlink(sctx, cur->full_path);
4545 if (ret < 0)
4548 ret = dup_ref(cur, &check_dirs);
4549 if (ret < 0)
4561 ret = send_unlink(sctx, valid_path);
4562 if (ret < 0)
4582 ret = get_cur_inode_state(sctx, cur->dir, cur->dir_gen, NULL, NULL);
4583 if (ret < 0)
4586 if (ret == inode_state_did_create ||
4587 ret == inode_state_no_change) {
4588 ret = cache_dir_utimes(sctx, cur->dir, cur->dir_gen);
4589 if (ret < 0)
4591 } else if (ret == inode_state_did_delete &&
4593 ret = can_rmdir(sctx, cur->dir, cur->dir_gen);
4594 if (ret < 0)
4596 if (ret) {
4597 ret = get_cur_path(sctx, cur->dir,
4599 if (ret < 0)
4601 ret = send_rmdir(sctx, valid_path);
4602 if (ret < 0)
4609 ret = 0;
4615 return ret;
4655 int ret = 0;
4661 ret = -ENOMEM;
4667 ret = -ENOMEM;
4671 ret = get_cur_path(sctx, dir, dir_gen, path);
4672 if (ret < 0)
4674 ret = fs_path_add_path(path, name);
4675 if (ret < 0)
4685 if (ret) {
4690 return ret;
4696 int ret = 0;
4703 ret = get_inode_gen(sctx->send_root, dir, &dir_gen);
4704 if (ret < 0)
4715 ret = record_ref_in_tree(&sctx->rbtree_new_refs,
4720 return ret;
4726 int ret = 0;
4733 ret = get_inode_gen(sctx->parent_root, dir, &dir_gen);
4734 if (ret < 0)
4745 ret = record_ref_in_tree(&sctx->rbtree_deleted_refs,
4750 return ret;
4755 int ret;
4757 ret = iterate_inode_ref(sctx->send_root, sctx->left_path,
4759 if (ret < 0)
4761 ret = 0;
4764 return ret;
4769 int ret;
4771 ret = iterate_inode_ref(sctx->parent_root, sctx->right_path,
4774 if (ret < 0)
4776 ret = 0;
4779 return ret;
4784 int ret = 0;
4786 ret = iterate_inode_ref(sctx->send_root, sctx->left_path,
4788 if (ret < 0)
4790 ret = iterate_inode_ref(sctx->parent_root, sctx->right_path,
4792 if (ret < 0)
4794 ret = 0;
4797 return ret;
4807 int ret = 0;
4829 ret = -EINVAL;
4842 ret = iterate_inode_ref(root, path, &found_key, 0, cb, sctx);
4843 if (ret < 0)
4848 ret = iter_ret;
4858 ret = process_recorded_refs(sctx, &pending_move);
4861 return ret;
4869 int ret = 0;
4871 ret = begin_cmd(sctx, BTRFS_SEND_C_SET_XATTR);
4872 if (ret < 0)
4879 ret = send_cmd(sctx);
4883 return ret;
4890 int ret = 0;
4892 ret = begin_cmd(sctx, BTRFS_SEND_C_REMOVE_XATTR);
4893 if (ret < 0)
4899 ret = send_cmd(sctx);
4903 return ret;
4910 int ret;
4939 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
4940 if (ret < 0)
4943 ret = send_set_xattr(sctx, p, name, name_len, data, data_len);
4947 return ret;
4954 int ret;
4962 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
4963 if (ret < 0)
4966 ret = send_remove_xattr(sctx, p, name, name_len);
4970 return ret;
4975 int ret = 0;
4977 ret = iterate_dir_item(sctx->send_root, sctx->left_path,
4980 return ret;
5020 int ret;
5029 ret = iterate_dir_item(root, path, __find_xattr, &ctx);
5030 if (ret < 0)
5031 return ret;
5050 int ret;
5055 ret = find_xattr(sctx->parent_root, sctx->right_path,
5058 if (ret == -ENOENT) {
5059 ret = __process_new_xattr(num, di_key, name, name_len, data,
5061 } else if (ret >= 0) {
5064 ret = __process_new_xattr(num, di_key, name, name_len,
5067 ret = 0;
5072 return ret;
5080 int ret;
5083 ret = find_xattr(sctx->send_root, sctx->left_path, sctx->cmp_key,
5085 if (ret == -ENOENT)
5086 ret = __process_deleted_xattr(num, di_key, name, name_len, data,
5088 else if (ret >= 0)
5089 ret = 0;
5091 return ret;
5096 int ret = 0;
5098 ret = iterate_dir_item(sctx->send_root, sctx->left_path,
5100 if (ret < 0)
5102 ret = iterate_dir_item(sctx->parent_root, sctx->right_path,
5106 return ret;
5111 int ret = 0;
5130 ret = 0;
5134 ret = iterate_dir_item(root, path, __process_new_xattr, sctx);
5135 if (ret < 0)
5140 ret = iter_ret;
5143 return ret;
5149 int ret;
5151 ret = begin_cmd(sctx, BTRFS_SEND_C_ENABLE_VERITY);
5152 if (ret < 0)
5165 ret = send_cmd(sctx);
5169 return ret;
5174 int ret = 0;
5183 ret = btrfs_get_verity_descriptor(inode, NULL, 0);
5184 if (ret < 0)
5187 if (ret > FS_VERITY_MAX_DESCRIPTOR_SIZE) {
5188 ret = -EMSGSIZE;
5195 ret = -ENOMEM;
5200 ret = btrfs_get_verity_descriptor(inode, sctx->verity_descriptor, ret);
5201 if (ret < 0)
5206 ret = -ENOMEM;
5209 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
5210 if (ret < 0)
5213 ret = send_verity(sctx, p, sctx->verity_descriptor);
5214 if (ret < 0)
5221 return ret;
5264 int ret;
5266 ret = put_data_header(sctx, len);
5267 if (ret)
5268 return ret;
5285 ret = -ENOMEM;
5305 ret = -EIO;
5320 return ret;
5330 int ret = 0;
5339 ret = begin_cmd(sctx, BTRFS_SEND_C_WRITE);
5340 if (ret < 0)
5343 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
5344 if (ret < 0)
5349 ret = put_file_data(sctx, offset, len);
5350 if (ret < 0)
5353 ret = send_cmd(sctx);
5358 return ret;
5368 int ret = 0;
5381 ret = begin_cmd(sctx, BTRFS_SEND_C_CLONE);
5382 if (ret < 0)
5385 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
5386 if (ret < 0)
5394 ret = get_inode_gen(sctx->send_root, clone_root->ino, &gen);
5395 if (ret < 0)
5397 ret = get_cur_path(sctx, clone_root->ino, gen, p);
5399 ret = get_inode_path(clone_root->root, clone_root->ino, p);
5401 if (ret < 0)
5425 ret = send_cmd(sctx);
5430 return ret;
5439 int ret = 0;
5446 ret = begin_cmd(sctx, BTRFS_SEND_C_UPDATE_EXTENT);
5447 if (ret < 0)
5450 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
5451 if (ret < 0)
5458 ret = send_cmd(sctx);
5463 return ret;
5471 int ret = 0;
5494 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
5495 if (ret < 0)
5500 ret = begin_cmd(sctx, BTRFS_SEND_C_WRITE);
5501 if (ret < 0)
5505 ret = put_data_header(sctx, len);
5506 if (ret < 0)
5510 ret = send_cmd(sctx);
5511 if (ret < 0)
5518 return ret;
5534 int ret;
5542 ret = -ENOMEM;
5546 ret = begin_cmd(sctx, BTRFS_SEND_C_ENCODED_WRITE);
5547 if (ret < 0)
5550 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, fspath);
5551 if (ret < 0)
5565 ret = btrfs_encoded_io_compression_from_extent(fs_info,
5567 if (ret < 0)
5569 TLV_PUT_U32(sctx, BTRFS_SEND_A_COMPRESSION, ret);
5571 ret = put_data_header(sctx, inline_size);
5572 if (ret < 0)
5578 ret = send_cmd(sctx);
5584 return ret;
5601 int ret;
5609 ret = -ENOMEM;
5613 ret = begin_cmd(sctx, BTRFS_SEND_C_ENCODED_WRITE);
5614 if (ret < 0)
5617 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, fspath);
5618 if (ret < 0)
5635 ret = btrfs_encoded_io_compression_from_extent(fs_info,
5637 if (ret < 0)
5639 TLV_PUT_U32(sctx, BTRFS_SEND_A_COMPRESSION, ret);
5642 ret = put_data_header(sctx, disk_num_bytes);
5643 if (ret < 0)
5654 ret = -EOVERFLOW;
5662 ret = btrfs_encoded_read_regular_fill_pages(BTRFS_I(inode), offset,
5666 if (ret)
5676 ret = write_buf(sctx->send_filp, sctx->send_buf, sctx->send_size,
5678 if (!ret) {
5679 ret = write_buf(sctx->send_filp, sctx->send_buf + data_offset,
5689 return ret;
5767 int ret;
5769 ret = send_write(sctx, offset + sent, size);
5770 if (ret < 0)
5771 return ret;
5824 int ret = 0;
5836 ret = PTR_ERR(di);
5846 ret = -ENOMEM;
5850 ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, fspath);
5851 if (ret < 0)
5857 ret = send_set_xattr(sctx, fspath, XATTR_NAME_CAPS,
5863 return ret;
5872 int ret;
5903 ret = get_inode_info(clone_root->root, clone_root->ino, &info);
5905 if (ret < 0)
5934 ret = btrfs_search_slot(NULL, clone_root->root, &key, path, 0, 0);
5935 if (ret < 0)
5937 if (ret > 0 && path->slots[0] > 0) {
5955 ret = btrfs_next_leaf(clone_root->root, path);
5956 if (ret < 0)
5958 else if (ret > 0)
5991 ret = send_extent_data(sctx, dst_path, offset,
5993 if (ret < 0)
6062 ret = send_clone(sctx, offset, slen,
6064 if (ret < 0)
6067 ret = send_extent_data(sctx, dst_path,
6071 ret = send_clone(sctx, offset, clone_len,
6094 ret = send_extent_data(sctx, dst_path, offset,
6098 if (ret < 0)
6127 ret = send_extent_data(sctx, dst_path, offset, len);
6129 ret = 0;
6132 return ret;
6140 int ret = 0;
6158 ret = clone_range(sctx, path, clone_root, disk_byte,
6161 ret = send_extent_data(sctx, path, offset, end - offset);
6164 return ret;
6171 int ret = 0;
6200 ret = 0;
6232 ret = btrfs_search_slot_for_read(sctx->parent_root, &key, path, 0, 0);
6233 if (ret < 0)
6235 if (ret) {
6236 ret = 0;
6249 ret = (left_disknr) ? 0 : 1;
6262 ret = 0;
6279 ret = (left_disknr) ? 0 : 1;
6292 ret = 0;
6315 ret = 0;
6322 ret = btrfs_next_item(sctx->parent_root, path);
6323 if (ret < 0)
6325 if (!ret) {
6330 if (ret || found_key.objectid != key.objectid ||
6336 ret = 0;
6347 ret = 1;
6349 ret = 0;
6354 return ret;
6362 int ret;
6373 ret = btrfs_search_slot_for_read(root, &key, path, 0, 1);
6374 if (ret < 0)
6376 ret = 0;
6384 return ret;
6395 int ret;
6404 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
6405 if (ret < 0)
6407 if (ret > 0 && path->slots[0] > 0)
6417 ret = btrfs_next_leaf(root, path);
6418 if (ret < 0)
6420 else if (ret > 0)
6442 ret = 0;
6447 ret = 1;
6450 return ret;
6456 int ret = 0;
6462 ret = get_last_extent(sctx, key->offset - 1);
6463 if (ret)
6464 return ret;
6476 ret = get_last_extent(sctx, key->offset - 1);
6477 if (ret)
6478 return ret;
6482 ret = range_is_hole_in_parent(sctx,
6485 if (ret < 0)
6486 return ret;
6487 else if (ret == 0)
6488 ret = send_hole(sctx, key->offset);
6490 ret = 0;
6493 return ret;
6501 int ret = 0;
6507 ret = is_extent_unchanged(sctx, path, key);
6508 if (ret < 0)
6510 if (ret) {
6511 ret = 0;
6530 ret = 0;
6536 ret = 0;
6542 ret = find_extent_clone(sctx, path, key->objectid, key->offset,
6544 if (ret != -ENOENT && ret < 0)
6547 ret = send_write_or_clone(sctx, path, key, found_clone);
6548 if (ret)
6551 ret = maybe_send_hole(sctx, path, key);
6553 return ret;
6558 int ret = 0;
6576 ret = 0;
6580 ret = process_extent(sctx, path, &found_key);
6581 if (ret < 0)
6586 ret = iter_ret;
6589 return ret;
6596 int ret = 0;
6606 ret = process_recorded_refs(sctx, pending_move);
6607 if (ret < 0)
6612 return ret;
6617 int ret = 0;
6637 ret = process_recorded_refs_if_needed(sctx, at_end, &pending_move,
6639 if (ret < 0)
6661 ret = get_inode_info(sctx->send_root, sctx->cur_ino, &info);
6662 if (ret < 0)
6678 ret = get_inode_info(sctx->parent_root, sctx->cur_ino, &info);
6679 if (ret < 0)
6704 ret = get_last_extent(sctx, (u64)-1);
6705 if (ret)
6709 ret = range_is_hole_in_parent(sctx,
6712 if (ret < 0) {
6714 } else if (ret == 0) {
6715 ret = send_hole(sctx, sctx->cur_inode_size);
6716 if (ret < 0)
6720 ret = 0;
6725 ret = send_truncate(sctx, sctx->cur_ino,
6728 if (ret < 0)
6734 ret = send_chown(sctx, sctx->cur_ino, sctx->cur_inode_gen,
6736 if (ret < 0)
6740 ret = send_chmod(sctx, sctx->cur_ino, sctx->cur_inode_gen,
6742 if (ret < 0)
6746 ret = send_fileattr(sctx, sctx->cur_ino, sctx->cur_inode_gen,
6748 if (ret < 0)
6754 ret = process_verity(sctx);
6755 if (ret < 0)
6759 ret = send_capabilities(sctx);
6760 if (ret < 0)
6768 ret = apply_children_dir_moves(sctx);
6769 if (ret)
6787 ret = cache_dir_utimes(sctx, sctx->cur_ino, sctx->cur_inode_gen);
6789 ret = send_utimes(sctx, sctx->cur_ino, sctx->cur_inode_gen);
6791 if (ret < 0)
6796 if (!ret)
6797 ret = trim_dir_utimes_cache(sctx);
6799 return ret;
6829 int ret = 0;
6932 ret = send_create_inode_if_needed(sctx);
6971 ret = process_all_refs(sctx,
6973 if (ret < 0)
6993 ret = send_create_inode_if_needed(sctx);
6994 if (ret < 0)
6997 ret = process_all_refs(sctx, BTRFS_COMPARE_TREE_NEW);
6998 if (ret < 0)
7011 ret = process_all_extents(sctx);
7012 if (ret < 0)
7014 ret = process_all_new_xattrs(sctx);
7015 if (ret < 0)
7031 return ret;
7047 int ret = 0;
7057 ret = record_new_ref(sctx);
7059 ret = record_deleted_ref(sctx);
7061 ret = record_changed_ref(sctx);
7064 return ret;
7075 int ret = 0;
7084 ret = process_new_xattr(sctx);
7086 ret = process_deleted_xattr(sctx);
7088 ret = process_changed_xattr(sctx);
7091 return ret;
7102 int ret = 0;
7122 ret = process_extent(sctx, sctx->left_path,
7126 return ret;
7131 int ret = 0;
7137 return ret;
7143 int ret;
7145 ret = get_inode_gen(sctx->send_root, dir, &new_gen);
7146 if (ret)
7147 return ret;
7149 ret = get_inode_gen(sctx->parent_root, dir, &orig_gen);
7150 if (ret)
7151 return ret;
7166 int ret = 0;
7172 ret = dir_changed(sctx, dirid);
7187 ret = dir_changed(sctx, dirid);
7188 if (ret)
7193 return ret;
7206 int ret = 0;
7255 ret = compare_refs(sctx, left_path, key);
7256 if (!ret)
7258 if (ret < 0)
7259 return ret;
7266 ret = 0;
7273 ret = finish_inode_if_needed(sctx, 0);
7274 if (ret < 0)
7283 ret = changed_inode(sctx, result);
7287 ret = changed_ref(sctx, result);
7289 ret = changed_xattr(sctx, result);
7291 ret = changed_extent(sctx, result);
7294 ret = changed_verity(sctx, result);
7298 return ret;
7306 int ret;
7318 ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
7319 ASSERT(ret <= 0);
7320 if (ret > 0) {
7331 return ret;
7336 int ret;
7355 ret = btrfs_search_slot_for_read(send_root, &key, path, 1, 0);
7356 if (ret < 0)
7358 if (ret)
7364 ret = changed_cb(path, NULL, &key,
7366 if (ret < 0)
7384 ret = search_key_again(sctx, send_root, path, &key);
7385 if (ret < 0)
7391 ret = btrfs_next_item(send_root, path);
7392 if (ret < 0)
7394 if (ret) {
7395 ret = 0;
7401 ret = finish_inode_if_needed(sctx, 1);
7405 return ret;
7466 int ret = 0;
7486 ret = 1;
7488 return ret;
7501 int ret;
7504 ret = tree_move_next_or_upnext(path, level, root_level);
7506 ret = tree_move_down(path, level, reada_min_gen);
7510 * Even if we have reached the end of a tree, ret is -1, update the key
7522 return ret;
7578 int ret;
7592 ret = search_key_again(sctx, sctx->send_root, left_path, left_key);
7593 if (ret < 0)
7594 return ret;
7597 ret = search_key_again(sctx, sctx->parent_root, right_path, right_key);
7598 if (ret < 0)
7599 return ret;
7608 ret = replace_node_with_clone(left_path, 0);
7609 if (ret < 0)
7610 return ret;
7614 ret = replace_node_with_clone(right_path, 0);
7615 if (ret < 0)
7616 return ret;
7626 ret = replace_node_with_clone(left_path, root_level);
7627 if (ret < 0)
7628 return ret;
7633 ret = replace_node_with_clone(right_path, root_level);
7634 if (ret < 0)
7635 return ret;
7658 int ret;
7681 ret = -ENOMEM;
7686 ret = -ENOMEM;
7692 ret = -ENOMEM;
7750 ret = -ENOMEM;
7759 ret = -ENOMEM;
7795 ret = restart_after_relocation(left_path, right_path,
7799 if (ret < 0)
7805 ret = tree_advance(left_path, &left_level,
7809 if (ret == -1)
7811 else if (ret < 0)
7816 ret = tree_advance(right_path, &right_level,
7820 if (ret == -1)
7822 else if (ret < 0)
7828 ret = 0;
7833 ret = changed_cb(left_path, right_path,
7837 if (ret < 0)
7846 ret = changed_cb(left_path, right_path,
7850 if (ret < 0)
7862 ret = changed_cb(left_path, right_path,
7868 ret = changed_cb(left_path, right_path,
7877 ret = tree_compare_item(left_path, right_path,
7879 if (ret)
7883 ret = changed_cb(left_path, right_path,
7889 if (ret < 0)
7937 return ret;
7942 int ret;
7945 ret = send_header(sctx);
7946 if (ret < 0)
7950 ret = send_subvol_begin(sctx);
7951 if (ret < 0)
7955 ret = btrfs_compare_trees(sctx->send_root, sctx->parent_root, sctx);
7956 if (ret < 0)
7958 ret = finish_inode_if_needed(sctx, 1);
7959 if (ret < 0)
7962 ret = full_send_tree(sctx);
7963 if (ret < 0)
7969 return ret;
8028 int ret;
8032 ret = btrfs_start_delalloc_snapshot(root, false);
8033 if (ret)
8034 return ret;
8040 ret = btrfs_start_delalloc_snapshot(root, false);
8041 if (ret)
8042 return ret;
8073 int ret = 0;
8107 ret = -EPERM;
8118 ret = -EINVAL;
8123 ret = -EOPNOTSUPP;
8129 ret = -ENOMEM;
8156 ret = -EPROTO;
8165 ret = -EINVAL;
8171 ret = -EBADF;
8181 ret = -EPERM;
8193 ret = -ENOMEM;
8201 ret = -ENOMEM;
8213 ret = -ENOMEM;
8221 ret = -ENOMEM;
8231 ret = -ENOMEM;
8235 ret = copy_from_user(clone_sources_tmp, arg->clone_sources,
8237 if (ret) {
8238 ret = -EFAULT;
8246 ret = PTR_ERR(clone_root);
8254 ret = -EPERM;
8261 ret = -EAGAIN;
8278 ret = PTR_ERR(sctx->parent_root);
8287 ret = -EPERM;
8293 ret = -EAGAIN;
8313 ret = flush_delalloc_roots(sctx);
8314 if (ret)
8317 ret = ensure_commit_roots_uptodate(sctx);
8318 if (ret)
8321 ret = send_subvol(sctx);
8322 if (ret < 0)
8326 ret = send_utimes(sctx, entry->key, entry->gen);
8327 if (ret < 0)
8333 ret = begin_cmd(sctx, BTRFS_SEND_C_END);
8334 if (ret < 0)
8336 ret = send_cmd(sctx);
8337 if (ret < 0)
8342 WARN_ON(sctx && !ret && !RB_EMPTY_ROOT(&sctx->pending_dir_moves));
8359 WARN_ON(sctx && !ret && !RB_EMPTY_ROOT(&sctx->waiting_dir_moves));
8370 WARN_ON(sctx && !ret && !RB_EMPTY_ROOT(&sctx->orphan_dirs));
8421 return ret;