Lines Matching refs:ret
153 int ret = 0;
163 ret = btrfs_init_log_root_tree(trans, fs_info);
164 if (!ret) {
170 if (ret)
171 return ret;
181 ret = BTRFS_LOG_FORCE_COMMIT;
204 ret = BTRFS_LOG_FORCE_COMMIT;
208 ret = btrfs_add_log_tree(trans, root);
209 if (ret)
226 return ret;
237 int ret = -ENOENT;
240 return ret;
247 ret = 0;
255 return ret;
330 int ret = 0;
342 ret = btrfs_read_extent_buffer(eb, &check);
343 if (ret)
344 return ret;
348 ret = btrfs_pin_extent_for_log_replay(wc->trans, eb);
349 if (ret)
350 return ret;
354 ret = btrfs_exclude_logged_extents(eb);
356 return ret;
379 int ret;
400 ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
401 if (ret < 0)
402 return ret;
404 if (ret == 0) {
430 ret = memcmp(dst_copy, src_copy, item_size);
440 if (ret == 0) {
494 ret = btrfs_insert_empty_item(trans, root, path,
499 if (ret == -EEXIST || ret == -EOVERFLOW) {
507 } else if (ret) {
508 return ret;
522 if (key->type == BTRFS_INODE_ITEM_KEY && ret == -EEXIST) {
636 int ret = 0;
658 ret = 0;
664 ret = -EIO;
673 ret = btrfs_lookup_file_extent(trans, root, path,
676 if (ret == 0 &&
708 ret = btrfs_drop_extents(trans, root, BTRFS_I(inode), &drop_args);
709 if (ret)
722 ret = btrfs_insert_empty_item(trans, root, path, key,
724 if (ret)
744 ret = btrfs_qgroup_trace_extent(trans,
747 if (ret < 0)
759 ret = btrfs_lookup_data_extent(fs_info, ins.objectid,
761 if (ret < 0) {
763 } else if (ret == 0) {
773 ret = btrfs_inc_extent_ref(trans, &ref);
774 if (ret)
781 ret = btrfs_alloc_logged_file_extent(trans,
784 if (ret)
799 ret = btrfs_lookup_csums_list(root->log_root,
802 if (ret < 0)
804 ret = 0;
863 if (!ret)
864 ret = btrfs_del_csums(trans, csum_root,
867 if (!ret)
868 ret = btrfs_csum_file_blocks(trans,
874 if (ret)
881 ret = overwrite_item(trans, root, path, eb, slot, key);
882 if (ret)
886 ret = btrfs_inode_set_file_extent_range(BTRFS_I(inode), start,
888 if (ret)
893 ret = btrfs_update_inode(trans, BTRFS_I(inode));
896 return ret;
904 int ret;
906 ret = btrfs_unlink_inode(trans, dir, inode, name);
907 if (ret)
908 return ret;
936 int ret;
941 ret = read_alloc_one_name(leaf, di + 1, btrfs_dir_name_len(leaf, di), &name);
942 if (ret)
949 ret = -EIO;
953 ret = link_to_fixup_dir(trans, root, path, location.objectid);
954 if (ret)
957 ret = unlink_inode_for_log_replay(trans, dir, BTRFS_I(inode), &name);
961 return ret;
978 int ret = 0;
983 ret = PTR_ERR(di);
996 ret = PTR_ERR(di);
1001 ret = 1;
1005 return ret;
1024 int ret;
1030 ret = btrfs_search_slot(NULL, log, key, path, 0, 0);
1031 if (ret < 0) {
1033 } else if (ret == 1) {
1034 ret = 0;
1039 ret = !!btrfs_find_name_in_ext_backref(path->nodes[0],
1043 ret = !!btrfs_find_name_in_backref(path->nodes[0],
1047 return ret;
1059 int ret;
1070 ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0);
1071 if (ret == 0) {
1094 ret = read_alloc_one_name(leaf, (victim_ref + 1),
1097 if (ret)
1098 return ret;
1100 ret = backref_in_log(log_root, &search_key,
1102 if (ret < 0) {
1104 return ret;
1105 } else if (!ret) {
1109 ret = unlink_inode_for_log_replay(trans, dir, inode,
1112 if (ret)
1113 return ret;
1148 ret = read_alloc_one_name(leaf, &extref->name,
1151 if (ret)
1152 return ret;
1159 ret = backref_in_log(log_root, &search_key,
1161 if (ret < 0) {
1163 return ret;
1164 } else if (!ret) {
1165 ret = -ENOENT;
1172 ret = unlink_inode_for_log_replay(trans,
1178 if (ret)
1179 return ret;
1195 ret = drop_one_dir_item(trans, path, dir, di);
1196 if (ret)
1197 return ret;
1206 ret = drop_one_dir_item(trans, path, dir, di);
1207 if (ret)
1208 return ret;
1220 int ret;
1224 ret = read_alloc_one_name(eb, &extref->name,
1226 if (ret)
1227 return ret;
1241 int ret;
1245 ret = read_alloc_one_name(eb, ref + 1, btrfs_inode_ref_name_len(eb, ref),
1247 if (ret)
1248 return ret;
1271 int ret;
1278 ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
1279 if (ret > 0) {
1280 ret = 0;
1283 if (ret < 0)
1294 ret = extref_get_fields(eb, ref_ptr, &name,
1298 ret = ref_get_fields(eb, ref_ptr, &name, NULL);
1300 if (ret)
1304 ret = !!btrfs_find_name_in_ext_backref(log_eb, log_slot,
1307 ret = !!btrfs_find_name_in_backref(log_eb, log_slot, &name);
1309 if (!ret) {
1315 ret = -ENOENT;
1319 ret = unlink_inode_for_log_replay(trans, BTRFS_I(dir),
1323 if (ret)
1335 ret = 0;
1338 return ret;
1359 int ret;
1390 ret = -ENOENT;
1396 ret = -EIO;
1402 ret = extref_get_fields(eb, ref_ptr, &name,
1411 ret = -ENOENT;
1415 ret = ref_get_fields(eb, ref_ptr, &name, &ref_index);
1417 if (ret)
1420 ret = inode_in_dir(root, path, btrfs_ino(BTRFS_I(dir)),
1422 if (ret < 0) {
1424 } else if (ret == 0) {
1432 ret = __add_inode_ref(trans, root, path, log,
1436 if (ret) {
1437 if (ret == 1)
1438 ret = 0;
1443 ret = btrfs_add_link(trans, BTRFS_I(dir), BTRFS_I(inode),
1445 if (ret)
1448 ret = btrfs_update_inode(trans, BTRFS_I(inode));
1449 if (ret)
1452 /* Else, ret == 1, we already have a perfect match, we're done. */
1471 ret = unlink_old_inode_refs(trans, root, path, BTRFS_I(inode), eb, slot,
1473 if (ret)
1477 ret = overwrite_item(trans, root, path, eb, slot, key);
1483 return ret;
1488 int ret = 0;
1500 ret = btrfs_find_one_extref(inode->root, inode_objectid, offset,
1502 if (ret)
1524 if (ret < 0 && ret != -ENOENT)
1525 return ret;
1531 int ret;
1544 ret = btrfs_search_slot(NULL, inode->root, &key, path, 0, 0);
1545 if (ret < 0)
1547 if (ret > 0) {
1600 int ret;
1608 ret = count_inode_refs(BTRFS_I(inode), path);
1609 if (ret < 0)
1612 nlink = ret;
1614 ret = count_inode_extrefs(BTRFS_I(inode), path);
1615 if (ret < 0)
1618 nlink += ret;
1620 ret = 0;
1624 ret = btrfs_update_inode(trans, BTRFS_I(inode));
1625 if (ret)
1632 ret = replay_dir_deletes(trans, root, NULL, path,
1634 if (ret)
1637 ret = btrfs_insert_orphan_item(trans, root, ino);
1638 if (ret == -EEXIST)
1639 ret = 0;
1644 return ret;
1651 int ret;
1659 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1660 if (ret < 0)
1663 if (ret == 1) {
1664 ret = 0;
1675 ret = btrfs_del_item(trans, root, path);
1676 if (ret)
1682 ret = -EIO;
1686 ret = fixup_inode_link_count(trans, inode);
1688 if (ret)
1699 return ret;
1714 int ret = 0;
1725 ret = btrfs_insert_empty_item(trans, root, path, &key, 0);
1728 if (ret == 0) {
1733 ret = btrfs_update_inode(trans, BTRFS_I(inode));
1734 } else if (ret == -EEXIST) {
1735 ret = 0;
1739 return ret;
1755 int ret;
1767 ret = btrfs_add_link(trans, BTRFS_I(dir), BTRFS_I(inode), name,
1774 return ret;
1838 int ret;
1846 ret = read_alloc_one_name(eb, di + 1, btrfs_dir_name_len(eb, di), &name);
1847 if (ret)
1852 ret = btrfs_lookup_inode(trans, root, path, &log_key, 0);
1854 if (ret < 0)
1856 exists = (ret == 0);
1857 ret = 0;
1862 ret = PTR_ERR(dir_dst_di);
1865 ret = delete_conflicting_dir_entry(trans, BTRFS_I(dir), path,
1868 if (ret < 0)
1870 dir_dst_matches = (ret == 1);
1879 ret = PTR_ERR(index_dst_di);
1882 ret = delete_conflicting_dir_entry(trans, BTRFS_I(dir), path,
1885 if (ret < 0)
1887 index_dst_matches = (ret == 1);
1893 ret = 0;
1905 ret = backref_in_log(root->log_root, &search_key, 0, &name);
1906 if (ret < 0) {
1908 } else if (ret) {
1910 ret = 0;
1918 ret = backref_in_log(root->log_root, &search_key, key->objectid, &name);
1919 if (ret < 0) {
1921 } else if (ret) {
1923 ret = 0;
1928 ret = insert_one_name(trans, root, key->objectid, key->offset,
1930 if (ret && ret != -ENOENT && ret != -EEXIST)
1932 if (!ret)
1935 ret = 0;
1938 if (!ret && update_size) {
1940 ret = btrfs_update_inode(trans, BTRFS_I(dir));
1944 if (!ret && name_added)
1945 ret = 1;
1946 return ret;
1956 int ret;
1963 ret = replay_one_name(trans, root, path, eb, di, key);
1964 if (ret < 0)
1965 return ret;
1993 if (ret == 1 && btrfs_dir_ftype(eb, di) != BTRFS_FT_DIR) {
2002 ret = link_to_fixup_dir(trans, root, fixup_path, di_key.objectid);
2006 return ret;
2028 int ret;
2038 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
2039 if (ret < 0)
2041 if (ret > 0) {
2046 if (ret != 0)
2050 ret = 1;
2058 ret = 0;
2063 ret = 1;
2069 ret = btrfs_next_leaf(root, path);
2070 if (ret)
2077 ret = 1;
2085 ret = 0;
2088 return ret;
2104 int ret;
2123 ret = read_alloc_one_name(eb, di + 1, btrfs_dir_name_len(eb, di), &name);
2124 if (ret)
2134 ret = PTR_ERR(log_di);
2138 ret = 0;
2148 ret = -EIO;
2152 ret = link_to_fixup_dir(trans, root, path, location.objectid);
2153 if (ret)
2157 ret = unlink_inode_for_log_replay(trans, BTRFS_I(dir), BTRFS_I(inode),
2169 return ret;
2182 int ret;
2192 ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0);
2193 if (ret < 0)
2206 ret = 0;
2221 ret = -ENOMEM;
2237 ret = PTR_ERR(di);
2241 ret = btrfs_delete_one_dir_name(trans, root,
2243 if (ret)
2251 ret = PTR_ERR(log_di);
2258 ret = btrfs_next_leaf(root, path);
2259 if (ret > 0)
2260 ret = 0;
2261 else if (ret == 0)
2266 return ret;
2288 int ret = 0;
2316 ret = find_dir_range(log, path, dirid,
2318 if (ret < 0)
2320 else if (ret > 0)
2327 ret = btrfs_search_slot(NULL, root, &dir_key, path,
2329 if (ret < 0)
2334 ret = btrfs_next_leaf(root, path);
2335 if (ret == 1)
2337 else if (ret < 0)
2344 ret = 0;
2351 ret = check_item_in_log(trans, log, path,
2354 if (ret)
2365 ret = 0;
2370 return ret;
2396 int ret;
2398 ret = btrfs_read_extent_buffer(eb, &check);
2399 if (ret)
2400 return ret;
2437 ret = replay_xattr_deletes(wc->trans, root, log,
2439 if (ret)
2443 ret = replay_dir_deletes(wc->trans,
2445 if (ret)
2448 ret = overwrite_item(wc->trans, root, path,
2450 if (ret)
2468 ret = -EIO;
2476 ret = btrfs_drop_extents(wc->trans, root,
2479 if (!ret) {
2483 ret = btrfs_update_inode(wc->trans,
2487 if (ret)
2491 ret = link_to_fixup_dir(wc->trans, root,
2493 if (ret)
2502 ret = replay_one_dir_item(wc->trans, root, path,
2504 if (ret)
2513 ret = overwrite_item(wc->trans, root, path,
2515 if (ret)
2519 ret = add_inode_ref(wc->trans, root, log, path,
2521 if (ret && ret != -ENOENT)
2523 ret = 0;
2525 ret = replay_one_extent(wc->trans, root, path,
2527 if (ret)
2538 return ret;
2567 int ret;
2575 ret = btrfs_pin_reserved_extent(trans, eb);
2576 if (ret)
2577 return ret;
2595 int ret = 0;
2622 ret = wc->process_func(root, next, wc, ptr_gen,
2624 if (ret) {
2626 return ret;
2631 ret = btrfs_read_extent_buffer(next, &check);
2632 if (ret) {
2634 return ret;
2637 ret = clean_log_buffer(trans, next);
2638 if (ret) {
2640 return ret;
2646 ret = btrfs_read_extent_buffer(next, &check);
2647 if (ret) {
2649 return ret;
2672 int ret;
2682 ret = wc->process_func(root, path->nodes[*level], wc,
2685 if (ret)
2686 return ret;
2689 ret = clean_log_buffer(trans, path->nodes[*level]);
2690 if (ret)
2691 return ret;
2709 int ret = 0;
2730 ret = wret;
2738 ret = wret;
2745 ret = wc->process_func(log, path->nodes[orig_level], wc,
2748 if (ret)
2751 ret = clean_log_buffer(trans, path->nodes[orig_level]);
2756 return ret;
2768 int ret;
2772 ret = btrfs_insert_root(trans, fs_info->log_root_tree,
2775 ret = btrfs_update_root(trans, fs_info->log_root_tree,
2778 return ret;
2910 int ret;
2957 ret = BTRFS_LOG_FORCE_COMMIT;
2971 ret = btrfs_write_marked_extents(fs_info, &log->dirty_log_pages, mark);
2981 if (ret == -EAGAIN && btrfs_is_zoned(fs_info))
2982 ret = 0;
2983 if (ret) {
3019 ret = btrfs_alloc_log_tree_node(trans, log_root_tree);
3020 if (ret) {
3042 ret = update_log_root(trans, log, &new_root_item);
3043 if (ret) {
3047 if (ret != -ENOSPC)
3049 "failed to update log for root %llu ret %d",
3050 btrfs_root_id(root), ret);
3060 ret = root_log_ctx.log_ret;
3066 ret = btrfs_wait_tree_log_extents(log, mark);
3070 if (!ret)
3071 ret = root_log_ctx.log_ret;
3090 ret = BTRFS_LOG_FORCE_COMMIT;
3094 ret = btrfs_write_marked_extents(fs_info,
3103 if (ret == -EAGAIN && btrfs_is_zoned(fs_info)) {
3108 } else if (ret) {
3113 ret = btrfs_wait_tree_log_extents(log, mark);
3114 if (!ret)
3115 ret = btrfs_wait_tree_log_extents(log_root_tree,
3117 if (ret) {
3153 ret = -EIO;
3155 btrfs_abort_transaction(trans, ret);
3162 ret = write_all_supers(fs_info, 1);
3164 if (ret) {
3166 btrfs_abort_transaction(trans, ret);
3183 btrfs_remove_all_log_ctxs(log_root_tree, index2, ret);
3197 btrfs_remove_all_log_ctxs(root, index1, ret);
3208 return ret;
3214 int ret;
3221 ret = walk_log_tree(trans, log, &wc);
3222 if (ret) {
3247 btrfs_abort_transaction(trans, ret);
3249 btrfs_handle_fs_error(log->fs_info, ret, NULL);
3299 int ret;
3357 ret = btrfs_search_slot(NULL, inode->root->log_root, &key, path, 0, 0);
3368 if (ret < 0) {
3369 return ret;
3370 } else if (ret > 0) {
3464 int ret;
3466 ret = inode_logged(trans, dir, NULL);
3467 if (ret == 0)
3469 else if (ret < 0) {
3474 ret = join_running_log_trans(root);
3475 if (ret)
3482 ret = -ENOMEM;
3486 ret = del_logged_dentry(trans, root->log_root, path, btrfs_ino(dir),
3491 if (ret < 0)
3504 int ret;
3506 ret = inode_logged(trans, inode, NULL);
3507 if (ret == 0)
3509 else if (ret < 0) {
3514 ret = join_running_log_trans(root);
3515 if (ret)
3520 ret = btrfs_del_inode_ref(trans, log, name, btrfs_ino(inode),
3523 if (ret < 0 && ret != -ENOENT)
3539 int ret;
3546 ret = btrfs_insert_empty_item(trans, log, path, &key, sizeof(*item));
3554 if (ret && ret != -EEXIST)
3555 return ret;
3559 if (ret == -EEXIST) {
3592 int ret;
3628 ret = btrfs_insert_empty_items(trans, log, dst_path, &batch);
3629 if (ret)
3656 ret = BTRFS_LOG_FORCE_COMMIT;
3665 return ret;
3706 int ret;
3713 ret = clone_leaf(path, ctx);
3714 if (ret < 0)
3715 return ret;
3722 int ret;
3741 ret = insert_dir_log_key(trans, log, dst_path,
3744 if (ret < 0)
3745 return ret;
3792 int ret;
3794 ret = flush_dir_items_batch(trans, inode, src, dst_path,
3796 if (ret < 0)
3797 return ret;
3818 int ret;
3827 ret = btrfs_search_forward(root, &min_key, path, trans->transid);
3833 if (ret != 0 || min_key.objectid != ino ||
3839 ret = btrfs_search_slot(NULL, root, &min_key, path, 0, 0);
3840 if (ret < 0) {
3842 return ret;
3844 ret = btrfs_previous_item(root, path, ino, BTRFS_DIR_INDEX_KEY);
3846 /* if ret == 0 there are items for this type,
3851 if (ret == 0) {
3858 } else if (ret > 0) {
3859 ret = 0;
3866 ret = btrfs_previous_item(root, path, ino, BTRFS_DIR_INDEX_KEY);
3867 if (ret == 0) {
3881 } else if (ret < 0) {
3902 ret = btrfs_search_slot(NULL, root, &min_key, path, 0, 0);
3903 if (ret > 0) {
3904 ret = btrfs_next_item(root, path);
3905 if (ret > 0) {
3907 ret = 0;
3911 if (ret < 0)
3919 ret = process_dir_items_leaf(trans, inode, path, dst_path, ctx,
3921 if (ret != 0) {
3922 if (ret > 0)
3923 ret = 0;
3932 ret = btrfs_next_leaf(root, path);
3933 if (ret) {
3934 if (ret == 1) {
3936 ret = 0;
3968 if (ret == 0) {
3980 ret = insert_dir_log_key(trans, log, path, ino,
3985 return ret;
4002 int ret;
4018 ret = btrfs_search_slot(NULL, inode->root->log_root, &key, path, 0, 0);
4023 if (ret <= 0)
4026 ret = 0;
4050 return ret;
4073 int ret;
4075 ret = update_last_dir_index_offset(inode, path, ctx);
4076 if (ret)
4077 return ret;
4083 ret = log_dir_items(trans, inode, path, dst_path,
4085 if (ret)
4086 return ret;
4107 int ret;
4117 ret = btrfs_search_slot(trans, log, &key, path, -1, 1);
4118 if (ret < 0) {
4120 } else if (ret > 0) {
4134 ret = btrfs_bin_search(path->nodes[0], 0, &found_key, &start_slot);
4135 if (ret < 0)
4138 ret = btrfs_del_items(trans, log, path, start_slot,
4144 if (ret || start_slot != 0)
4149 if (ret > 0)
4150 ret = 0;
4151 return ret;
4237 int ret;
4250 ret = btrfs_search_slot(trans, log, &inode->location, path, 0, 1);
4251 ASSERT(ret <= 0);
4252 if (ret > 0)
4253 ret = -ENOENT;
4264 ret = btrfs_insert_empty_item(trans, log, path, &inode->location,
4266 ASSERT(ret != -EEXIST);
4268 if (ret)
4269 return ret;
4285 int ret;
4301 ret = lock_extent(&log_root->log_csum_range, sums->logical, lock_end,
4303 if (ret)
4304 return ret;
4314 ret = btrfs_del_csums(trans, log_root, sums->logical, sums->len);
4315 if (!ret)
4316 ret = btrfs_csum_file_blocks(trans, log_root, sums);
4321 return ret;
4334 int ret;
4371 ret = clone_leaf(src_path, ctx);
4372 if (ret < 0)
4373 return ret;
4463 ret = btrfs_lookup_csums_list(csum_root, disk_bytenr,
4466 if (ret < 0)
4468 ret = 0;
4471 if (!ret)
4472 ret = log_csums(trans, inode, log, sums);
4476 if (ret)
4493 ret = btrfs_insert_empty_items(trans, log, dst_path, &batch);
4494 if (ret)
4552 return ret;
4583 int ret = 0;
4638 ret = log_csums(trans, inode, log_root, sums);
4639 if (ret)
4640 return ret;
4659 ret = btrfs_lookup_csums_list(csum_root, em->block_start + csum_offset,
4662 if (ret < 0)
4663 return ret;
4664 ret = 0;
4670 if (!ret)
4671 ret = log_csums(trans, inode, log_root, sums);
4676 return ret;
4693 int ret;
4717 ret = log_extent_csums(trans, inode, log, em, ctx);
4718 if (ret)
4719 return ret;
4736 ret = btrfs_drop_extents(trans, log, inode, &drop_args);
4737 if (ret)
4738 return ret;
4746 ret = btrfs_insert_empty_item(trans, log, path, &key,
4748 if (ret)
4749 return ret;
4759 return ret;
4786 int ret;
4794 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
4795 if (ret < 0)
4806 ret = btrfs_previous_item(root, path, ino, BTRFS_EXTENT_DATA_KEY);
4807 if (ret < 0)
4810 if (ret == 0) {
4829 ret = 0;
4838 ret = copy_items(trans, inode, dst_path, path,
4840 if (ret < 0)
4844 ret = btrfs_next_leaf(root, path);
4845 if (ret < 0)
4847 if (ret > 0) {
4848 ret = 0;
4872 ret = truncate_inode_items(trans, root->log_root, inode,
4875 if (ret)
4887 ret = -ENOMEM;
4893 ret = copy_items(trans, inode, dst_path, path,
4898 return ret;
4911 int ret = 0;
4926 ret = -EFBIG;
4956 if (ret) {
4964 ret = log_one_extent(trans, inode, em, path, ctx);
4972 if (!ret)
4973 ret = btrfs_log_prealloc_extents(trans, inode, path, ctx);
4974 if (ret)
4975 return ret;
5006 int ret;
5012 ret = btrfs_search_slot(NULL, log, &key, path, 0, 0);
5013 if (ret < 0) {
5014 return ret;
5015 } else if (ret > 0) {
5058 int ret;
5072 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5073 if (ret < 0)
5074 return ret;
5083 ret = copy_items(trans, inode, dst_path, path,
5085 if (ret < 0)
5086 return ret;
5089 ret = btrfs_next_leaf(root, path);
5090 if (ret < 0)
5091 return ret;
5092 else if (ret > 0)
5109 ret = copy_items(trans, inode, dst_path, path,
5111 if (ret < 0)
5112 return ret;
5140 int ret;
5149 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5150 if (ret < 0)
5151 return ret;
5157 ret = btrfs_next_leaf(root, path);
5158 if (ret < 0)
5159 return ret;
5160 if (ret > 0) {
5161 ret = 0;
5181 ret = btrfs_insert_hole_extent(trans, root->log_root,
5184 if (ret < 0)
5185 return ret;
5194 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5195 if (ret < 0)
5196 return ret;
5197 if (WARN_ON(ret > 0))
5212 ret = btrfs_insert_hole_extent(trans, root->log_root, ino,
5214 if (ret < 0)
5215 return ret;
5269 int ret;
5315 ret = -ENOMEM;
5335 ret = 1;
5339 ret = 0;
5342 ret = -EAGAIN;
5346 ret = PTR_ERR(di);
5353 ret = 0;
5357 return ret;
5447 int ret = 0;
5504 ret = PTR_ERR(di_inode);
5516 ret = btrfs_log_inode(trans, BTRFS_I(di_inode),
5519 if (ret)
5524 ret = -ENOMEM;
5536 ret = iter_ret;
5564 ret = PTR_ERR(vfs_inode);
5574 if (ret) {
5581 return ret;
5605 int ret;
5614 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5615 if (WARN_ON_ONCE(ret > 0)) {
5621 ret = -ENOENT;
5622 } else if (ret == 0) {
5628 ret = 1;
5635 return ret;
5679 int ret = PTR_ERR(inode);
5681 if (ret != -ENOENT)
5682 return ret;
5684 ret = conflicting_inode_is_dir(root, ino, path);
5686 if (ret <= 0)
5687 return ret;
5759 int ret = 0;
5796 ret = PTR_ERR(inode);
5797 if (ret != -ENOENT)
5802 ret = PTR_ERR(inode);
5814 ret = btrfs_log_inode(trans, BTRFS_I(inode),
5817 if (ret)
5844 ret = btrfs_log_inode(trans, BTRFS_I(inode), LOG_INODE_EXISTS, ctx);
5846 if (ret)
5851 if (ret)
5854 return ret;
5872 int ret;
5875 ret = btrfs_search_forward(root, min_key, path, trans->transid);
5876 if (ret < 0)
5877 return ret;
5878 if (ret > 0) {
5879 ret = 0;
5907 ret = btrfs_check_ref_name_override(path->nodes[0],
5910 if (ret < 0) {
5911 return ret;
5912 } else if (ret > 0 &&
5920 ret = copy_items(trans, inode, dst_path, path,
5923 if (ret < 0)
5924 return ret;
5928 ret = add_conflicting_inode(trans, root, path,
5931 if (ret)
5932 return ret;
5939 ret = copy_items(trans, inode, dst_path, path,
5942 if (ret < 0)
5943 return ret;
5957 ret = copy_items(trans, inode, dst_path, path, ins_start_slot,
5959 if (ret < 0)
5960 return ret;
5971 ret = copy_items(trans, inode, dst_path, path,
5974 if (ret < 0)
5975 return ret;
5997 ret = copy_items(trans, inode, dst_path, path, ins_start_slot,
5999 if (ret)
6000 return ret;
6009 ret = btrfs_log_prealloc_extents(trans, inode, dst_path, ctx);
6012 return ret;
6022 int ret;
6024 ret = btrfs_insert_empty_items(trans, log, path, batch);
6025 if (ret)
6026 return ret;
6065 int ret;
6104 ret = insert_delayed_items_batch(trans, log, path,
6106 if (ret)
6127 ret = insert_delayed_items_batch(trans, log, path, &batch, first);
6135 return ret;
6154 int ret;
6172 ret = insert_dir_log_key(trans, inode->root->log_root, path,
6174 if (ret)
6175 return ret;
6239 int ret;
6242 ret = btrfs_search_slot(trans, log, &key, path, -1, 1);
6243 if (ret < 0) {
6244 return ret;
6245 } else if (ret == 0) {
6246 ret = batch_delete_dir_index_items(trans, inode, path, ctx,
6249 if (ret)
6250 return ret;
6275 ret = insert_dir_log_key(trans, log, path, key.objectid,
6277 if (ret)
6278 return ret;
6324 int ret = 0;
6350 ret = PTR_ERR(di_inode);
6363 ret = btrfs_log_inode(trans, BTRFS_I(di_inode), log_mode, ctx);
6365 if (!ret && ctx->log_new_dentries)
6366 ret = log_new_dir_dentries(trans, BTRFS_I(di_inode), ctx);
6370 if (ret)
6377 return ret;
6404 int ret;
6476 ret = btrfs_commit_inode_delayed_items(trans, inode);
6477 if (ret)
6500 ret = inode_logged(trans, inode, path);
6501 if (ret < 0)
6503 ctx->logged_before = (ret == 1);
6504 ret = 0;
6514 ret = BTRFS_LOG_FORCE_COMMIT;
6525 ret = drop_inode_items(trans, log, path, inode,
6542 ret = logged_inode_size(log, inode, path, &logged_isize);
6543 if (ret)
6551 ret = drop_inode_items(trans, log, path,
6559 ret = truncate_inode_items(trans, log,
6569 ret = drop_inode_items(trans, log, path, inode,
6579 if (ret)
6592 ret = copy_inode_items_to_log(trans, inode, &min_key, &max_key,
6596 if (ret)
6601 ret = btrfs_log_all_xattrs(trans, inode, path, dst_path, ctx);
6602 if (ret)
6608 ret = btrfs_log_holes(trans, inode, path);
6609 if (ret)
6616 ret = log_inode_item(trans, log, dst_path, inode, inode_item_dropped);
6617 if (ret)
6628 ret = btrfs_log_all_xattrs(trans, inode, path, dst_path, ctx);
6629 if (ret)
6635 ret = btrfs_log_changed_extents(trans, inode, dst_path, ctx);
6636 if (ret)
6648 ret = log_directory_changes(trans, inode, path, dst_path, ctx);
6649 if (ret)
6651 ret = log_delayed_insertion_items(trans, inode, path,
6653 if (ret)
6655 ret = log_delayed_deletion_items(trans, inode, path,
6657 if (ret)
6711 if (ret)
6714 ret = log_conflicting_inodes(trans, inode->root, ctx);
6717 if (!ret)
6718 ret = log_new_delayed_dentries(trans, inode,
6725 return ret;
6733 int ret;
6748 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
6749 if (ret < 0)
6760 ret = btrfs_next_leaf(root, path);
6761 if (ret < 0)
6763 else if (ret > 0)
6823 ret = PTR_ERR(dir_inode);
6833 ret = btrfs_log_inode(trans, BTRFS_I(dir_inode),
6835 if (!ret && ctx->log_new_dentries)
6836 ret = log_new_dir_dentries(trans,
6839 if (ret)
6844 ret = 0;
6847 return ret;
6866 int ret = 0;
6881 ret = btrfs_log_inode(trans, BTRFS_I(inode),
6884 if (ret)
6885 return ret;
6891 ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0);
6892 if (ret < 0)
6893 return ret;
6898 ret = btrfs_next_leaf(root, path);
6899 if (ret < 0)
6900 return ret;
6901 else if (ret > 0)
6923 int ret = 0;
6936 ret = btrfs_log_inode(trans, inode,
6938 if (ret)
6950 return ret;
6962 int ret;
6979 ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0);
6980 if (ret < 0)
6982 if (ret == 0)
6991 ret = btrfs_next_leaf(root, path);
6992 if (ret < 0)
6994 else if (ret > 0)
7012 ret = -EMLINK;
7024 ret = log_new_ancestors(trans, root, path, ctx);
7025 if (ret)
7030 ret = 0;
7033 return ret;
7050 int ret = 0;
7054 ret = BTRFS_LOG_FORCE_COMMIT;
7059 ret = BTRFS_LOG_FORCE_COMMIT;
7071 ret = BTRFS_NO_LOG_SYNC;
7075 ret = start_log_trans(trans, root, ctx);
7076 if (ret)
7079 ret = btrfs_log_inode(trans, inode, inode_only, ctx);
7080 if (ret)
7092 ret = 0;
7141 ret = btrfs_log_all_parents(trans, inode, ctx);
7142 if (ret)
7146 ret = log_all_new_ancestors(trans, inode, parent, ctx);
7147 if (ret)
7151 ret = log_new_dir_dentries(trans, inode, ctx);
7153 ret = 0;
7155 if (ret < 0) {
7157 ret = BTRFS_LOG_FORCE_COMMIT;
7160 if (ret)
7164 return ret;
7178 int ret;
7180 ret = btrfs_log_inode_parent(trans, BTRFS_I(d_inode(dentry)), parent,
7184 return ret;
7193 int ret;
7213 ret = PTR_ERR(trans);
7220 ret = walk_log_tree(trans, log_root_tree, &wc);
7221 if (ret) {
7222 btrfs_abort_transaction(trans, ret);
7232 ret = btrfs_search_slot(NULL, log_root_tree, &key, path, 0, 0);
7234 if (ret < 0) {
7235 btrfs_abort_transaction(trans, ret);
7238 if (ret > 0) {
7251 ret = PTR_ERR(log);
7252 btrfs_abort_transaction(trans, ret);
7259 ret = PTR_ERR(wc.replay_dest);
7272 if (ret == -ENOENT)
7273 ret = btrfs_pin_extent_for_log_replay(trans, log->node);
7276 if (!ret)
7278 btrfs_abort_transaction(trans, ret);
7283 ret = btrfs_record_root_in_trans(trans, wc.replay_dest);
7284 if (ret)
7286 btrfs_abort_transaction(trans, ret);
7288 ret = walk_log_tree(trans, log, &wc);
7290 if (!ret && wc.stage == LOG_WALK_REPLAY_ALL) {
7291 ret = fixup_inode_link_counts(trans, wc.replay_dest,
7293 if (ret)
7294 btrfs_abort_transaction(trans, ret);
7297 if (!ret && wc.stage == LOG_WALK_REPLAY_ALL) {
7310 ret = btrfs_init_root_free_objectid(root);
7311 if (ret)
7312 btrfs_abort_transaction(trans, ret);
7319 if (ret)
7344 ret = btrfs_commit_transaction(trans);
7345 if (ret)
7346 return ret;
7358 return ret;
7468 int ret;
7481 ret = inode_logged(trans, inode, NULL);
7482 if (ret < 0) {
7484 } else if (ret == 0) {
7492 ret = inode_logged(trans, old_dir, NULL);
7493 if (ret < 0)
7495 else if (ret == 0)
7498 ret = 0;
7514 ret = fscrypt_setup_filename(&old_dir->vfs_inode,
7516 if (ret)
7524 ret = join_running_log_trans(root);
7530 if (WARN_ON_ONCE(ret < 0)) {
7539 ret = -ENOMEM;
7555 ret = del_logged_dentry(trans, log, path, btrfs_ino(old_dir),
7557 if (ret > 0) {
7563 ret = insert_dir_log_key(trans, log, path,
7571 if (ret < 0)
7595 if (ret < 0)