Lines Matching refs:ret
158 int ret;
162 ret = PTR_ERR(local_root);
171 ret = btrfs_search_slot(NULL, local_root, &key, &warn->path, 0, 0);
172 if (ret) {
188 ret = PTR_ERR(ipath);
197 return ret;
199 ret = paths_from_inode(inum, ipath);
200 if (ret < 0)
221 "checksum error at logical %llu mirror %u root %llu inode %llu offset %llu, path resolving failed with ret=%d",
222 warn->logical, warn->mirror_num, root, inum, offset, ret);
225 return ret;
247 int ret;
273 ret = extent_from_logical(fs_info, logical, &path, &found_key, &flags);
274 if (ret < 0) {
276 logical, ret);
288 ret = tree_backref_for_extent(&ptr, eb, &found_key, ei,
291 if (ret < 0) {
294 logical, ret);
297 if (ret > 0)
525 int ret;
557 ret = btrfs_insert_empty_item(trans, root, path, &key,
559 if (ret)
594 ret = btrfs_inode_set_file_extent_range(inode, 0,
596 if (ret)
614 return ret;
679 int ret;
699 ret = btrfs_drop_extents(trans, root, inode, &drop_args);
700 if (ret) {
701 btrfs_abort_transaction(trans, ret);
705 ret = insert_inline_extent(trans, path, inode, drop_args.extent_inserted,
708 if (ret && ret != -ENOSPC) {
709 btrfs_abort_transaction(trans, ret);
711 } else if (ret == -ENOSPC) {
712 ret = 1;
717 ret = btrfs_update_inode(trans, inode);
718 if (ret && ret != -ENOSPC) {
719 btrfs_abort_transaction(trans, ret);
721 } else if (ret == -ENOSPC) {
722 ret = 1;
737 return ret;
751 int ret;
757 ret = __cow_file_range_inline(inode, offset, size, compressed_size,
760 if (ret > 0) {
762 return ret;
769 return ret;
918 int ret = 0;
991 ret = 0;
1016 ret = btrfs_compress_folios(compress_type | (fs_info->compress_level << 4),
1019 if (ret)
1040 ret = cow_file_range_inline(inode, start, end, 0,
1043 ret = cow_file_range_inline(inode, start, end, total_compressed,
1045 if (ret <= 0) {
1046 if (ret < 0)
1070 ret = add_async_extent(async_chunk, start, total_in, total_compressed, folios,
1072 BUG_ON(ret);
1084 ret = add_async_extent(async_chunk, start, end - start + 1, 0, NULL, 0,
1086 BUG_ON(ret);
1119 int ret;
1128 ret = run_delalloc_cow(inode, locked_page, start, end, &wbc, false);
1130 if (ret < 0) {
1139 !ret);
1140 mapping_set_error(locked_page->mapping, ret);
1159 int ret = 0;
1183 ret = btrfs_reserve_extent(root, async_extent->ram_size,
1187 if (ret) {
1211 ret = PTR_ERR(em);
1226 ret = PTR_ERR(ordered);
1261 "async extent submission failed root=%lld inode=%llu start=%llu len=%llu ret=%d",
1263 async_extent->ram_size, ret);
1347 int ret = 0;
1350 ret = -EINVAL;
1362 ret = cow_file_range_inline(inode, start, end, 0,
1364 if (ret <= 0) {
1372 if (ret == 0)
1373 ret = 1;
1400 ret = btrfs_reserve_extent(root, cur_alloc_size, cur_alloc_size,
1403 if (ret == -EAGAIN) {
1426 ret = -ENOSPC;
1428 if (ret < 0)
1449 ret = PTR_ERR(em);
1461 ret = PTR_ERR(ordered);
1466 ret = btrfs_reloc_clone_csums(ordered);
1479 if (ret)
1516 if (ret)
1522 return ret;
1557 mapping_set_error(inode->vfs_inode.i_mapping, ret);
1599 return ret;
1748 int ret;
1751 ret = cow_file_range(inode, locked_page, start, end, &done_offset,
1753 if (ret)
1754 return ret;
1773 int ret;
1833 ret = cow_file_range(inode, locked_page, start, end, NULL, false, true);
1834 ASSERT(ret != 1);
1835 return ret;
1884 int ret = 0;
1931 ret = btrfs_cross_ref_exist(root, btrfs_ino(inode),
1934 WARN_ON_ONCE(ret > 0 && is_freespace_inode);
1935 if (ret != 0)
1964 ret = btrfs_lookup_csums_list(csum_root, args->disk_bytenr,
1967 WARN_ON_ONCE(ret > 0 && is_freespace_inode);
1968 if (ret != 0)
1976 return ret < 0 ? ret : can_nocow;
1995 int ret;
2009 ret = -ENOMEM;
2029 ret = btrfs_lookup_file_extent(NULL, root, path, ino,
2031 if (ret < 0)
2039 if (ret > 0 && path->slots[0] > 0 && check_prev) {
2052 ret = btrfs_next_leaf(root, path);
2053 if (ret < 0)
2055 if (ret > 0)
2100 ret = -EUCLEAN;
2116 ret = can_nocow_file_extent(path, &found_key, inode, &nocow_args);
2117 if (ret < 0)
2119 if (ret == 0)
2122 ret = 0;
2150 ret = fallback_to_cow(inode, locked_page,
2153 if (ret) {
2178 ret = PTR_ERR(em);
2199 ret = PTR_ERR(ordered);
2209 ret = btrfs_reloc_clone_csums(ordered);
2225 if (ret)
2235 ret = fallback_to_cow(inode, locked_page, cow_start, end);
2237 if (ret)
2270 return ret;
2292 int ret;
2302 ret = run_delalloc_nocow(inode, locked_page, start, end);
2312 ret = run_delalloc_cow(inode, locked_page, start, end, wbc,
2315 ret = cow_file_range(inode, locked_page, start, end, NULL,
2319 if (ret < 0)
2322 return ret;
2610 int ret;
2628 ret = split_extent_map(bbio->inode, bbio->file_offset,
2631 if (ret)
2632 return ret;
2651 int ret;
2658 ret = btrfs_csum_file_blocks(trans, csum_root, sum);
2660 if (ret)
2661 return ret;
2678 int ret = 0;
2693 ret = set_extent_bit(&inode->io_tree, search_start,
2699 if (ret)
2700 return ret;
2719 int ret;
2721 ret = btrfs_find_new_delalloc_bytes(inode, start,
2724 if (ret)
2725 return ret;
2751 int ret = 0;
2758 ret = btrfs_delalloc_reserve_space(inode, &data_reserved, page_start,
2773 * we reserved our space, thus ret == 0, so we need to just
2782 * ret to 0. This is why we have this check _before_ the ret
2786 if (!ret) {
2792 ret = 0;
2800 if (ret)
2819 ret = btrfs_set_extent_delalloc(inode, page_start, page_end, 0,
2821 if (ret)
2840 if (ret) {
2845 mapping_set_error(page->mapping, ret);
2847 PAGE_SIZE, !ret);
2932 int ret;
2952 ret = btrfs_drop_extents(trans, root, inode, &drop_args);
2953 if (ret)
2961 ret = btrfs_insert_empty_item(trans, root, path, &ins,
2963 if (ret)
2998 ret = btrfs_inode_set_file_extent_range(inode, file_pos, ram_bytes);
2999 if (ret)
3002 ret = btrfs_alloc_reserved_file_extent(trans, root, btrfs_ino(inode),
3008 return ret;
3079 int ret = 0;
3100 ret = -EIO;
3125 ret = PTR_ERR(trans);
3130 ret = btrfs_update_inode_fallback(trans, inode);
3131 if (ret) /* -ENOMEM or corruption */
3132 btrfs_abort_transaction(trans, ret);
3144 ret = PTR_ERR(trans);
3151 ret = btrfs_insert_raid_extent(trans, ordered_extent);
3152 if (ret)
3159 ret = btrfs_mark_extent_written(trans, inode,
3167 ret = insert_ordered_extent_file_extent(trans, ordered_extent);
3168 if (!ret) {
3175 if (ret < 0) {
3176 btrfs_abort_transaction(trans, ret);
3180 ret = unpin_extent_cache(inode, ordered_extent->file_offset,
3182 if (ret < 0) {
3183 btrfs_abort_transaction(trans, ret);
3187 ret = add_pending_csums(trans, &ordered_extent->list);
3188 if (ret) {
3189 btrfs_abort_transaction(trans, ret);
3205 ret = btrfs_update_inode_fallback(trans, inode);
3206 if (ret) { /* -ENOMEM or corruption */
3207 btrfs_abort_transaction(trans, ret);
3217 if (ret || truncated) {
3228 if (ret)
3263 if ((ret || !logical_len) &&
3271 if (ret && btrfs_test_opt(fs_info, DISCARD_SYNC))
3300 return ret;
3480 int ret = wait_event_killable(fs_info->delayed_iputs_wait,
3482 if (ret)
3494 int ret;
3496 ret = btrfs_insert_orphan_item(trans, inode->root, btrfs_ino(inode));
3497 if (ret && ret != -EEXIST) {
3498 btrfs_abort_transaction(trans, ret);
3499 return ret;
3528 int ret = 0, nr_unlink = 0;
3535 ret = -ENOMEM;
3545 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
3546 if (ret < 0)
3550 * if ret == 0 means we found what we were searching for, which
3554 if (ret > 0) {
3555 ret = 0;
3590 ret = BTRFS_FS_ERROR(fs_info) ?: -EINVAL;
3601 ret = PTR_ERR(inode);
3603 if (ret != -ENOENT)
3670 ret = btrfs_drop_verity_items(BTRFS_I(inode));
3673 if (ret)
3678 ret = PTR_ERR(trans);
3683 ret = btrfs_del_orphan_item(trans, root,
3686 if (ret)
3709 if (ret)
3710 btrfs_err(fs_info, "could not do orphan cleanup %d", ret);
3712 return ret;
3799 int ret;
3803 ret = btrfs_fill_inode(inode, &rdev);
3804 if (!ret)
3815 ret = btrfs_lookup_inode(NULL, root, path, &location, 0);
3816 if (ret) {
3819 return ret;
3945 ret = btrfs_load_inode_props(inode, path);
3946 if (ret)
3950 btrfs_root_id(root), ret);
4041 int ret;
4047 ret = btrfs_lookup_inode(trans, inode->root, path, &inode->location, 1);
4048 if (ret) {
4049 if (ret > 0)
4050 ret = -ENOENT;
4061 ret = 0;
4064 return ret;
4075 int ret;
4089 ret = btrfs_delayed_update_inode(trans, inode);
4090 if (!ret)
4092 return ret;
4101 int ret;
4103 ret = btrfs_update_inode(trans, inode);
4104 if (ret == -ENOSPC)
4106 return ret;
4123 int ret = 0;
4131 ret = -ENOMEM;
4137 ret = di ? PTR_ERR(di) : -ENOENT;
4140 ret = btrfs_delete_one_dir_name(trans, root, path, di);
4141 if (ret)
4156 ret = btrfs_delayed_delete_inode_ref(inode);
4157 if (!ret) {
4163 ret = btrfs_del_inode_ref(trans, root, name, ino, dir_ino, &index);
4164 if (ret) {
4168 btrfs_abort_transaction(trans, ret);
4175 ret = btrfs_delete_delayed_dir_index(trans, dir, index);
4176 if (ret) {
4177 btrfs_abort_transaction(trans, ret);
4204 if (ret)
4211 ret = btrfs_update_inode(trans, dir);
4213 return ret;
4220 int ret;
4222 ret = __btrfs_unlink_inode(trans, dir, inode, name, NULL);
4223 if (!ret) {
4225 ret = btrfs_update_inode(trans, inode);
4227 return ret;
4250 int ret;
4253 ret = fscrypt_setup_filename(dir, &dentry->d_name, 1, &fname);
4254 if (ret)
4255 return ret;
4261 ret = PTR_ERR(trans);
4268 ret = btrfs_unlink_inode(trans, BTRFS_I(dir), BTRFS_I(d_inode(dentry)),
4270 if (ret)
4274 ret = btrfs_orphan_add(trans, BTRFS_I(inode));
4275 if (ret)
4284 return ret;
4297 int ret;
4302 ret = fscrypt_setup_filename(&dir->vfs_inode, &dentry->d_name, 1, &fname);
4303 if (ret)
4304 return ret;
4320 ret = -ENOMEM;
4327 ret = di ? PTR_ERR(di) : -ENOENT;
4334 ret = btrfs_delete_one_dir_name(trans, root, path, di);
4335 if (ret) {
4336 btrfs_abort_transaction(trans, ret);
4354 ret = -ENOENT;
4356 ret = PTR_ERR(di);
4357 btrfs_abort_transaction(trans, ret);
4366 ret = btrfs_del_root_ref(trans, objectid,
4369 if (ret) {
4370 btrfs_abort_transaction(trans, ret);
4375 ret = btrfs_delete_delayed_dir_index(trans, dir, index);
4376 if (ret) {
4377 btrfs_abort_transaction(trans, ret);
4384 ret = btrfs_update_inode_fallback(trans, dir);
4385 if (ret)
4386 btrfs_abort_transaction(trans, ret);
4390 return ret;
4405 int ret;
4418 ret = -EPERM;
4431 ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);
4432 if (ret < 0)
4434 if (ret == 0) {
4439 ret = -EUCLEAN;
4443 ret = 0;
4448 ret = -ENOTEMPTY;
4452 return ret;
4491 int ret;
4506 ret = -EPERM;
4514 ret = -EPERM;
4522 ret = may_destroy_subvol(dest);
4523 if (ret)
4532 ret = btrfs_subvolume_reserve_metadata(root, &block_rsv, 5, true);
4533 if (ret)
4539 ret = PTR_ERR(trans);
4542 ret = btrfs_record_root_in_trans(trans, root);
4543 if (ret) {
4544 btrfs_abort_transaction(trans, ret);
4554 ret = btrfs_unlink_subvol(trans, dir, dentry);
4555 if (ret) {
4556 btrfs_abort_transaction(trans, ret);
4560 ret = btrfs_record_root_in_trans(trans, dest);
4561 if (ret) {
4562 btrfs_abort_transaction(trans, ret);
4572 ret = btrfs_insert_orphan_item(trans,
4575 if (ret) {
4576 btrfs_abort_transaction(trans, ret);
4581 ret = btrfs_uuid_tree_remove(trans, dest->root_item.uuid,
4583 if (ret && ret != -ENOENT) {
4584 btrfs_abort_transaction(trans, ret);
4588 ret = btrfs_uuid_tree_remove(trans,
4592 if (ret && ret != -ENOENT) {
4593 btrfs_abort_transaction(trans, ret);
4603 ret = btrfs_end_transaction(trans);
4610 if (ret) {
4619 if (!ret) {
4625 return ret;
4632 int ret = 0;
4648 ret = fscrypt_setup_filename(dir, &dentry->d_name, 1, &fname);
4649 if (ret)
4650 return ret;
4656 ret = PTR_ERR(trans);
4661 ret = btrfs_unlink_subvol(trans, BTRFS_I(dir), dentry);
4665 ret = btrfs_orphan_add(trans, BTRFS_I(inode));
4666 if (ret)
4672 ret = btrfs_unlink_inode(trans, BTRFS_I(dir), BTRFS_I(d_inode(dentry)),
4674 if (!ret) {
4696 return ret;
4727 int ret = 0;
4738 ret = btrfs_check_data_free_space(inode, &data_reserved, block_start,
4740 if (ret < 0) {
4748 ret = btrfs_delalloc_reserve_metadata(inode, blocksize, blocksize, false);
4749 if (ret < 0) {
4762 ret = -ENOMEM;
4767 ret = btrfs_read_folio(NULL, folio);
4775 ret = -EIO;
4786 ret = set_folio_extent_mapped(folio);
4787 if (ret < 0)
4808 ret = btrfs_set_extent_delalloc(inode, block_start, block_end, 0,
4810 if (ret) {
4837 if (ret) {
4851 return ret;
4860 int ret;
4884 ret = btrfs_drop_extents(trans, root, inode, &drop_args);
4885 if (ret) {
4886 btrfs_abort_transaction(trans, ret);
4888 return ret;
4891 ret = btrfs_insert_hole_extent(trans, root, btrfs_ino(inode), offset, len);
4892 if (ret) {
4893 btrfs_abort_transaction(trans, ret);
4899 return ret;
4920 int ret = 0;
4927 ret = btrfs_truncate_block(inode, oldsize, 0, 0);
4928 if (ret)
4929 return ret;
4940 ret = PTR_ERR(em);
4951 ret = maybe_insert_hole(inode, cur_offset, hole_size);
4952 if (ret)
4955 ret = btrfs_inode_set_file_extent_range(inode,
4957 if (ret)
4978 ret = btrfs_replace_extent_map_range(inode, hole_em, true);
4981 ret = btrfs_inode_set_file_extent_range(inode,
4983 if (ret)
4995 return ret;
5005 int ret;
5030 ret = btrfs_cont_expand(BTRFS_I(inode), oldsize, newsize);
5031 if (ret) {
5033 return ret;
5045 ret = btrfs_update_inode(trans, BTRFS_I(inode));
5052 ret = btrfs_wait_ordered_range(inode,
5055 if (ret)
5056 return ret;
5072 ret = btrfs_truncate(BTRFS_I(inode), newsize == oldsize);
5073 if (ret && inode->i_nlink) {
5089 return ret;
5208 int ret;
5224 ret = btrfs_block_rsv_refill(fs_info, rsv, rsv->size + delayed_refs_extra,
5226 if (ret) {
5227 ret = btrfs_block_rsv_refill(fs_info, rsv, rsv->size,
5229 if (ret) {
5256 int ret;
5291 ret = btrfs_commit_inode_delayed_inode(BTRFS_I(inode));
5292 if (ret)
5325 ret = btrfs_truncate_inode_items(trans, root, &control);
5334 if (ret && ret != -ENOSPC && ret != -EAGAIN)
5336 else if (!ret)
5382 int ret = 0;
5389 ret = fscrypt_setup_filename(&dir->vfs_inode, &dentry->d_name, 1, &fname);
5390 if (ret < 0)
5396 ASSERT(ret == 0);
5403 ret = di ? PTR_ERR(di) : -ENOENT;
5410 ret = -EUCLEAN;
5416 if (!ret)
5421 return ret;
5440 int ret;
5444 ret = fscrypt_setup_filename(&dir->vfs_inode, &dentry->d_name, 0, &fname);
5445 if (ret)
5446 return ret;
5459 ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);
5460 if (ret) {
5461 if (ret < 0)
5462 err = ret;
5472 ret = memcmp_extent_buffer(leaf, fname.disk_name.name,
5474 if (ret)
5612 int ret;
5614 ret = btrfs_read_locked_inode(inode, path);
5615 if (!ret) {
5621 * ret > 0 can come from btrfs_search_slot called by
5625 if (ret > 0)
5626 ret = -ENOENT;
5627 inode = ERR_PTR(ret);
5697 int ret = 0;
5702 ret = btrfs_inode_by_name(BTRFS_I(dir), dentry, &location, &di_type);
5703 if (ret < 0)
5704 return ERR_PTR(ret);
5723 ret = fixup_tree_root_location(fs_info, BTRFS_I(dir), dentry,
5725 if (ret < 0) {
5726 if (ret != -ENOENT)
5727 inode = ERR_PTR(ret);
5739 ret = btrfs_orphan_cleanup(sub_root);
5741 if (ret) {
5743 inode = ERR_PTR(ret);
5789 int ret;
5799 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5800 if (ret < 0)
5803 if (ret == 0)
5805 ret = 0;
5826 return ret;
5831 int ret = 0;
5835 ret = btrfs_inode_delayed_dir_index_count(dir);
5836 if (ret) {
5837 ret = btrfs_set_inode_index_count(dir);
5838 if (ret)
5848 return ret;
5864 int ret;
5866 ret = btrfs_get_dir_last_index(BTRFS_I(inode), &last_index);
5867 if (ret)
5868 return ret;
5886 int ret;
5888 ret = btrfs_get_dir_last_index(BTRFS_I(file_inode(file)),
5890 if (ret)
5891 return ret;
5933 int ret;
5959 btrfs_for_each_slot(root, &key, &found_key, path, ret) {
5979 ret = btrfs_filldir(private->filldir_buf, entries, ctx);
5980 if (ret)
6003 if (ret < 0)
6008 ret = btrfs_filldir(private->filldir_buf, entries, ctx);
6009 if (ret)
6012 ret = btrfs_readdir_delayed_dir_index(ctx, &ins_list);
6013 if (ret)
6038 ret = 0;
6043 return ret;
6057 int ret;
6066 ret = btrfs_update_inode(trans, inode);
6067 if (ret == -ENOSPC || ret == -EDQUOT) {
6074 ret = btrfs_update_inode(trans, inode);
6080 return ret;
6105 int ret = 0;
6108 ret = btrfs_inode_delayed_dir_index_count(dir);
6109 if (ret) {
6110 ret = btrfs_set_inode_index_count(dir);
6111 if (ret)
6112 return ret;
6119 return ret;
6139 int ret;
6142 ret = fscrypt_setup_filename(dir, &args->dentry->d_name, 0,
6144 if (ret)
6145 return ret;
6148 ret = posix_acl_create(dir, &inode->i_mode, &args->default_acl, &args->acl);
6149 if (ret) {
6151 return ret;
6241 int ret;
6251 ret = btrfs_get_free_objectid(root, &objectid);
6252 if (ret)
6265 ret = btrfs_set_inode_index(BTRFS_I(dir), &BTRFS_I(inode)->dir_index);
6266 if (ret)
6302 ret = btrfs_insert_inode_locked(inode);
6303 if (ret < 0) {
6345 ret = btrfs_insert_empty_items(trans, root, path, &batch);
6346 if (ret != 0) {
6347 btrfs_abort_transaction(trans, ret);
6403 ret = PTR_ERR(parent);
6405 ret = btrfs_inode_inherit_props(trans, inode, parent);
6409 ret = btrfs_inode_inherit_props(trans, inode, dir);
6411 if (ret) {
6414 btrfs_ino(BTRFS_I(inode)), btrfs_root_id(root), ret);
6422 ret = btrfs_init_inode_security(trans, args);
6423 if (ret) {
6424 btrfs_abort_transaction(trans, ret);
6437 ret = btrfs_orphan_add(trans, BTRFS_I(inode));
6439 ret = btrfs_add_link(trans, BTRFS_I(dir), BTRFS_I(inode), name,
6442 if (ret) {
6443 btrfs_abort_transaction(trans, ret);
6458 return ret;
6471 int ret = 0;
6486 ret = btrfs_add_root_ref(trans, key.objectid,
6490 ret = btrfs_insert_inode_ref(trans, root, name,
6495 if (ret)
6496 return ret;
6498 ret = btrfs_insert_dir_item(trans, name, parent_inode, &key,
6500 if (ret == -EEXIST || ret == -EOVERFLOW)
6502 else if (ret) {
6503 btrfs_abort_transaction(trans, ret);
6504 return ret;
6520 ret = btrfs_update_inode(trans, parent_inode);
6521 if (ret)
6522 btrfs_abort_transaction(trans, ret);
6523 return ret;
6545 return ret;
6717 int ret;
6736 ret = btrfs_decompress(compress_type, tmp, page, 0, inline_size, max_size);
6749 return ret;
6801 int ret = 0;
6828 ret = -ENOMEM;
6838 ret = -ENOMEM;
6855 ret = btrfs_lookup_file_extent(NULL, root, path, objectid, start, 0);
6856 if (ret < 0) {
6858 } else if (ret > 0) {
6862 ret = 0;
6888 ret = -EUCLEAN;
6905 ret = btrfs_next_leaf(root, path);
6906 if (ret < 0)
6908 else if (ret > 0)
6953 ret = read_inline_extent(inode, path, page);
6954 if (ret < 0)
6964 ret = 0;
6970 ret = -EIO;
6975 ret = btrfs_add_extent_mapping(inode, &em, start, len);
6982 if (ret) {
6984 return ERR_PTR(ret);
7041 int ret;
7045 ret = btrfs_reserve_extent(root, len, len, fs_info->sectorsize,
7047 if (ret == -EAGAIN) {
7053 if (ret)
7054 return ERR_PTR(ret);
7107 int ret;
7120 ret = btrfs_lookup_file_extent(NULL, root, path,
7122 if (ret < 0)
7125 if (ret == 1) {
7128 ret = 0;
7133 ret = 0;
7160 ret = can_nocow_file_extent(path, &key, BTRFS_I(inode), &nocow_args);
7164 if (ret != 1) {
7166 ret = 0;
7170 ret = 0;
7180 ret = test_range_bit_exists(io_tree, offset, range_end, EXTENT_DELALLOC);
7181 if (ret) {
7182 ret = -EAGAIN;
7193 ret = 1;
7196 return ret;
7207 int ret = 0;
7242 ret = -EAGAIN;
7264 ret = nowait ? -EAGAIN : -ENOTBLK;
7280 ret = nowait ? -EAGAIN : -ENOTBLK;
7283 if (ret)
7289 return ret;
7300 int ret;
7361 ret = btrfs_replace_extent_map_range(inode, em, true);
7362 if (ret) {
7364 return ERR_PTR(ret);
7388 int ret = 0;
7422 ret = btrfs_delalloc_reserve_metadata(BTRFS_I(inode), len, len,
7424 if (ret < 0) {
7429 if (nowait && (ret == -ENOSPC || ret == -EDQUOT))
7430 ret = -EAGAIN;
7447 ret = PTR_ERR(em2);
7458 ret = -EAGAIN;
7467 ret = -ENOSPC;
7475 ret = btrfs_delalloc_reserve_metadata(BTRFS_I(inode), len, len,
7477 if (ret < 0)
7483 ret = PTR_ERR(em);
7506 if (ret && space_reserved) {
7511 return ret;
7525 int ret = 0;
7579 ret = filemap_fdatawrite_range(inode->i_mapping, start,
7581 if (ret)
7582 return ret;
7598 ret = btrfs_check_data_free_space(BTRFS_I(inode),
7601 if (!ret)
7603 else if (ret && !(BTRFS_I(inode)->flags &
7613 ret = lock_extent_direct(inode, lockstart, lockend, &cached_state, flags);
7614 if (ret < 0)
7619 ret = PTR_ERR(em);
7652 ret = (flags & IOMAP_NOWAIT) ? -EAGAIN : -ENOTBLK;
7681 ret = -EAGAIN;
7686 ret = btrfs_get_blocks_direct_write(&em, inode, dio_data,
7688 if (ret < 0)
7758 return ret;
7768 int ret = 0;
7786 ret = -ENOTBLK;
7795 return ret;
7851 int ret;
7853 ret = btrfs_extract_ordered_extent(bbio, dio_data->ordered);
7854 if (ret) {
7857 !ret);
7858 bio->bi_status = errno_to_blk_status(ret);
7898 int ret;
7900 ret = fiemap_prep(inode, fieinfo, start, &len, 0);
7901 if (ret)
7902 return ret;
7918 ret = btrfs_wait_ordered_range(inode, 0, LLONG_MAX);
7919 if (ret)
7920 return ret;
7932 ret = btrfs_wait_ordered_range(inode, 0, LLONG_MAX);
7933 if (ret) {
7935 return ret;
7939 ret = extent_fiemap(btrfs_inode, fieinfo, start, len);
7942 return ret;
8001 int ret = filemap_migrate_folio(mapping, dst, src, mode);
8003 if (ret != MIGRATEPAGE_SUCCESS)
8004 return ret;
8195 int ret;
8201 ret = btrfs_wait_ordered_range(&inode->vfs_inode,
8204 if (ret)
8205 return ret;
8248 ret = PTR_ERR(trans);
8253 ret = btrfs_block_rsv_migrate(&fs_info->trans_block_rsv, rsv,
8260 if (WARN_ON(ret)) {
8283 ret = btrfs_truncate_inode_items(trans, root, &control);
8291 if (ret != -ENOSPC && ret != -EAGAIN)
8294 ret = btrfs_update_inode(trans, inode);
8295 if (ret)
8303 ret = PTR_ERR(trans);
8309 ret = btrfs_block_rsv_migrate(&fs_info->trans_block_rsv,
8316 if (WARN_ON(ret))
8328 if (ret == BTRFS_NEED_TRUNCATE_BLOCK) {
8332 ret = btrfs_truncate_block(inode, inode->vfs_inode.i_size, 0, 0);
8333 if (ret)
8337 ret = PTR_ERR(trans);
8348 if (ret2 && !ret)
8349 ret = ret2;
8352 if (ret2 && !ret)
8353 ret = ret2;
8375 return ret;
8662 int ret;
8678 ret = fscrypt_setup_filename(old_dir, &old_dentry->d_name, 0, &old_fname);
8679 if (ret)
8680 return ret;
8682 ret = fscrypt_setup_filename(new_dir, &new_dentry->d_name, 0, &new_fname);
8683 if (ret) {
8685 return ret;
8729 ret = PTR_ERR(trans);
8734 ret = btrfs_record_root_in_trans(trans, dest);
8735 if (ret)
8743 ret = btrfs_set_inode_index(BTRFS_I(new_dir), &old_idx);
8744 if (ret)
8746 ret = btrfs_set_inode_index(BTRFS_I(old_dir), &new_idx);
8747 if (ret)
8758 ret = btrfs_insert_inode_ref(trans, dest, new_name, old_ino,
8761 if (ret)
8771 ret = btrfs_insert_inode_ref(trans, root, old_name, new_ino,
8774 if (ret) {
8776 btrfs_abort_transaction(trans, ret);
8797 ret = btrfs_unlink_subvol(trans, BTRFS_I(old_dir), old_dentry);
8799 ret = __btrfs_unlink_inode(trans, BTRFS_I(old_dir),
8802 if (!ret)
8803 ret = btrfs_update_inode(trans, BTRFS_I(old_inode));
8805 if (ret) {
8806 btrfs_abort_transaction(trans, ret);
8812 ret = btrfs_unlink_subvol(trans, BTRFS_I(new_dir), new_dentry);
8814 ret = __btrfs_unlink_inode(trans, BTRFS_I(new_dir),
8817 if (!ret)
8818 ret = btrfs_update_inode(trans, BTRFS_I(new_inode));
8820 if (ret) {
8821 btrfs_abort_transaction(trans, ret);
8825 ret = btrfs_add_link(trans, BTRFS_I(new_dir), BTRFS_I(old_inode),
8827 if (ret) {
8828 btrfs_abort_transaction(trans, ret);
8832 ret = btrfs_add_link(trans, BTRFS_I(old_dir), BTRFS_I(new_inode),
8834 if (ret) {
8835 btrfs_abort_transaction(trans, ret);
8870 ret = ret ? ret : ret2;
8878 return ret;
8914 int ret;
8934 ret = fscrypt_setup_filename(old_dir, &old_dentry->d_name, 0, &old_fname);
8935 if (ret)
8936 return ret;
8938 ret = fscrypt_setup_filename(new_dir, &new_dentry->d_name, 0, &new_fname);
8939 if (ret) {
8941 return ret;
8945 ret = btrfs_check_dir_item_collision(dest, new_dir->i_ino, &new_fname.disk_name);
8946 if (ret) {
8947 if (ret == -EEXIST) {
8958 ret = 0;
8970 ret = -ENOMEM;
8973 ret = btrfs_new_inode_prepare(&whiteout_args, &trans_num_items);
8974 if (ret)
9021 ret = PTR_ERR(trans);
9026 ret = btrfs_record_root_in_trans(trans, dest);
9027 if (ret)
9031 ret = btrfs_set_inode_index(BTRFS_I(new_dir), &index);
9032 if (ret)
9040 ret = btrfs_insert_inode_ref(trans, dest, &new_fname.disk_name,
9043 if (ret)
9057 ret = btrfs_unlink_subvol(trans, BTRFS_I(old_dir), old_dentry);
9059 ret = __btrfs_unlink_inode(trans, BTRFS_I(old_dir),
9062 if (!ret)
9063 ret = btrfs_update_inode(trans, BTRFS_I(old_inode));
9065 if (ret) {
9066 btrfs_abort_transaction(trans, ret);
9074 ret = btrfs_unlink_subvol(trans, BTRFS_I(new_dir), new_dentry);
9077 ret = btrfs_unlink_inode(trans, BTRFS_I(new_dir),
9081 if (!ret && new_inode->i_nlink == 0)
9082 ret = btrfs_orphan_add(trans,
9084 if (ret) {
9085 btrfs_abort_transaction(trans, ret);
9090 ret = btrfs_add_link(trans, BTRFS_I(new_dir), BTRFS_I(old_inode),
9092 if (ret) {
9093 btrfs_abort_transaction(trans, ret);
9105 ret = btrfs_create_new_inode(trans, &whiteout_args);
9106 if (ret) {
9107 btrfs_abort_transaction(trans, ret);
9117 ret = ret ? ret : ret2;
9129 return ret;
9136 int ret;
9142 ret = btrfs_rename_exchange(old_dir, old_dentry, new_dir,
9145 ret = btrfs_rename(idmap, old_dir, old_dentry, new_dir,
9150 return ret;
9206 int ret = 0;
9237 ret = -ENOMEM;
9244 ret = filemap_fdatawrite_wbc(inode->i_mapping, wbc);
9246 if (ret || wbc->nr_to_write <= 0)
9267 return ret;
9297 int ret;
9321 ret = start_delalloc_inodes(root, &wbc, false, in_reclaim_context);
9323 if (ret < 0 || wbc.nr_to_write <= 0)
9329 ret = 0;
9337 return ret;
9455 int ret;
9467 ret = btrfs_qgroup_release_data(inode, file_offset, len, &qgroup_released);
9468 if (ret < 0)
9469 return ERR_PTR(ret);
9472 ret = insert_reserved_file_extent(trans, inode,
9475 if (ret)
9493 ret = -ENOMEM;
9497 ret = btrfs_replace_file_extents(inode, path, file_offset,
9501 if (ret)
9516 return ERR_PTR(ret);
9533 int ret = 0;
9549 ret = btrfs_reserve_extent(root, cur_bytes, cur_bytes,
9551 if (ret)
9574 ret = PTR_ERR(trans);
9598 ret = btrfs_replace_extent_map_range(BTRFS_I(inode), em, true);
9619 ret = btrfs_update_inode(trans, BTRFS_I(inode));
9621 if (ret) {
9622 btrfs_abort_transaction(trans, ret);
9636 return ret;
9686 int ret;
9697 ret = btrfs_new_inode_prepare(&new_inode_args, &trans_num_items);
9698 if (ret)
9703 ret = PTR_ERR(trans);
9707 ret = btrfs_create_new_inode(trans, &new_inode_args);
9718 if (!ret) {
9729 if (ret)
9731 return finish_open_simple(file, ret);
9799 ssize_t ret;
9803 ret = -ENOMEM;
9806 ret = btrfs_lookup_file_extent(NULL, root, path, btrfs_ino(inode),
9808 if (ret) {
9809 if (ret > 0) {
9811 ret = -EIO;
9823 ret = btrfs_encoded_io_compression_from_extent(fs_info,
9825 if (ret < 0)
9827 encoded->compression = ret;
9834 ret = -ENOBUFS;
9849 ret = -ENOMEM;
9858 ret = copy_to_iter(tmp, count, iter);
9859 if (ret != count)
9860 ret = -EFAULT;
9864 return ret;
9953 ssize_t ret;
9959 ret = btrfs_alloc_page_array(nr_pages, pages, 0);
9960 if (ret) {
9961 ret = -ENOMEM;
9965 ret = btrfs_encoded_read_regular_fill_pages(inode, start, disk_bytenr,
9967 if (ret)
9988 ret = -EFAULT;
9995 ret = count;
10002 return ret;
10011 ssize_t ret;
10036 ret = btrfs_wait_ordered_range(&inode->vfs_inode, start,
10038 if (ret)
10052 ret = PTR_ERR(em);
10065 ret = btrfs_encoded_read_inline(iocb, iter, start, lockend,
10090 ret = -ENOBUFS;
10097 ret = btrfs_encoded_io_compression_from_extent(fs_info,
10099 if (ret < 0)
10101 encoded->compression = ret;
10123 ret = iov_iter_zero(count, iter);
10124 if (ret != count)
10125 ret = -EFAULT;
10127 ret = btrfs_encoded_read_regular(iocb, iter, start, lockend,
10135 if (ret >= 0)
10145 return ret;
10167 ssize_t ret;
10262 ret = -ENOMEM;
10268 ret = -EFAULT;
10279 ret = btrfs_wait_ordered_range(&inode->vfs_inode, start, num_bytes);
10280 if (ret)
10282 ret = invalidate_inode_pages2_range(inode->vfs_inode.i_mapping,
10285 if (ret)
10302 ret = btrfs_alloc_data_chunk_ondemand(inode, disk_num_bytes);
10303 if (ret)
10305 ret = btrfs_qgroup_reserve_data(inode, &data_reserved, start, num_bytes);
10306 if (ret)
10308 ret = btrfs_delalloc_reserve_metadata(inode, num_bytes, disk_num_bytes,
10310 if (ret)
10317 ret = __cow_file_range_inline(inode, start, encoded->len,
10320 if (ret <= 0) {
10321 if (ret == 0)
10322 ret = orig_count;
10327 ret = btrfs_reserve_extent(root, disk_num_bytes, disk_num_bytes,
10329 if (ret)
10338 ret = PTR_ERR(em);
10351 ret = PTR_ERR(ordered);
10364 ret = orig_count;
10372 btrfs_delalloc_release_metadata(inode, disk_num_bytes, ret < 0);
10374 if (ret < 0)
10392 if (ret >= 0)
10394 return ret;
10486 int ret;
10513 ret = add_swap_extent(sis, bsi->nr_pages, nr_pages, first_ppage);
10514 if (ret < 0)
10515 return ret;
10516 bsi->nr_extents += ret;
10543 int ret = 0;
10552 ret = btrfs_wait_ordered_range(inode, 0, (u64)-1);
10553 if (ret)
10554 return ret;
10634 ret = PTR_ERR(em);
10640 ret = -EINVAL;
10652 ret = -EINVAL;
10657 ret = -EINVAL;
10666 ret = can_nocow_extent(inode, start, &len, NULL, NULL, NULL, false, true);
10667 if (ret < 0) {
10669 } else if (ret) {
10670 ret = 0;
10674 ret = -EINVAL;
10680 ret = PTR_ERR(map);
10687 ret = -EINVAL;
10693 ret = btrfs_add_swapfile_pin(inode, device, false);
10694 if (ret == 1)
10695 ret = 0;
10696 else if (ret)
10700 ret = -EINVAL;
10714 ret = -EINVAL;
10725 ret = -EINVAL;
10729 ret = btrfs_add_swapfile_pin(inode, bg, true);
10730 if (ret) {
10732 if (ret == 1)
10733 ret = 0;
10743 ret = btrfs_add_swap_extent(sis, &bsi);
10744 if (ret)
10756 ret = btrfs_add_swap_extent(sis, &bsi);
10766 if (ret)
10773 if (ret)
10774 return ret;