Lines Matching refs:ret
204 int ret;
217 ret = mnt_want_write_file(file);
218 if (ret)
219 return ret;
225 ret = vfs_ioc_setflags_prepare(inode, old_fsflags, fsflags);
226 if (ret)
229 ret = check_fsflags(old_fsflags, fsflags);
230 if (ret)
295 ret = -ETXTBSY;
315 ret = PTR_ERR(trans);
320 ret = btrfs_set_prop(trans, inode, "btrfs.compression", comp,
322 if (ret) {
323 btrfs_abort_transaction(trans, ret);
327 ret = btrfs_set_prop(trans, inode, "btrfs.compression", NULL,
329 if (ret && ret != -ENODATA) {
330 btrfs_abort_transaction(trans, ret);
339 ret = btrfs_update_inode(trans, root, inode);
346 return ret;
418 int ret = 0;
429 ret = check_xflags(fa.fsx_xflags);
430 if (ret)
431 return ret;
436 ret = mnt_want_write_file(file);
437 if (ret)
438 return ret;
447 ret = vfs_ioc_fssetxattr_check(inode, &old_fa, &fa);
448 if (ret)
475 ret = PTR_ERR(trans);
482 ret = btrfs_update_inode(trans, root, inode);
487 if (ret) {
495 return ret;
513 int ret;
556 ret = btrfs_trim_fs(fs_info, &range);
557 if (ret < 0)
558 return ret;
593 int ret;
604 ret = btrfs_find_free_objectid(fs_info->tree_root, &objectid);
605 if (ret)
608 ret = get_anon_bdev(&anon_dev);
609 if (ret < 0)
617 ret = -ENOSPC;
626 ret = btrfs_subvolume_reserve_metadata(root, &block_rsv, 8, false);
627 if (ret)
632 ret = PTR_ERR(trans);
639 ret = btrfs_qgroup_inherit(trans, 0, objectid, inherit);
640 if (ret)
646 ret = PTR_ERR(leaf);
687 ret = btrfs_insert_root(trans, fs_info->tree_root, &key,
689 if (ret) {
710 ret = PTR_ERR(new_root);
711 btrfs_abort_transaction(trans, ret);
719 ret = btrfs_create_subvol_root(trans, new_root, root, new_dirid);
721 if (ret) {
723 btrfs_abort_transaction(trans, ret);
734 ret = btrfs_set_inode_index(BTRFS_I(dir), &index);
735 if (ret) {
736 btrfs_abort_transaction(trans, ret);
740 ret = btrfs_insert_dir_item(trans, name, namelen, BTRFS_I(dir), &key,
742 if (ret) {
743 btrfs_abort_transaction(trans, ret);
748 ret = btrfs_update_inode(trans, root, dir);
749 if (ret) {
750 btrfs_abort_transaction(trans, ret);
754 ret = btrfs_add_root_ref(trans, objectid, root->root_key.objectid,
756 if (ret) {
757 btrfs_abort_transaction(trans, ret);
761 ret = btrfs_uuid_tree_add(trans, root_item->uuid,
763 if (ret)
764 btrfs_abort_transaction(trans, ret);
773 if (err && !ret)
774 ret = err;
776 if (!ret) {
782 return ret;
788 return ret;
799 int ret;
817 ret = get_anon_bdev(&pending_snapshot->anon_dev);
818 if (ret < 0)
824 ret = -ENOMEM;
838 ret = btrfs_subvolume_reserve_metadata(BTRFS_I(dir)->root,
841 if (ret)
852 ret = PTR_ERR(trans);
861 ret = btrfs_commit_transaction(trans);
862 if (ret)
865 ret = pending_snapshot->error;
866 if (ret)
869 ret = btrfs_orphan_cleanup(pending_snapshot->snap);
870 if (ret)
875 ret = PTR_ERR(inode);
880 ret = 0;
884 if (ret && pending_snapshot->snap)
895 return ret;
1026 int ret;
1036 ret = btrfs_start_delalloc_snapshot(root);
1037 if (ret)
1050 ret = btrfs_mksubvol(parent, name, namelen,
1056 return ret;
1108 int ret;
1120 ret = btrfs_search_forward(root, &min_key, path, newer_than);
1121 if (ret != 0)
1193 bool ret = true;
1201 ret = false;
1204 ret = false;
1207 return ret;
1215 int ret = 1;
1234 ret = 0;
1248 ret = 0;
1258 if (ret) {
1267 return ret;
1294 int ret;
1309 ret = btrfs_delalloc_reserve_space(BTRFS_I(inode), &data_reserved,
1311 if (ret)
1312 return ret;
1358 ret = -EIO;
1372 if (!i_done || ret)
1411 ret = PTR_ERR(em);
1417 ret = 0;
1467 return ret;
1486 int ret;
1527 ret = -ENOMEM;
1540 ret = find_new_extents(root, inode, newer_than,
1542 if (!ret) {
1575 ret = -EAGAIN;
1610 ret = -ETXTBSY;
1614 ret = cluster_pages_for_defrag(inode, pages, i, cluster);
1616 if (ret < 0) {
1621 defrag_count += ret;
1629 if (ret > 0)
1630 i += ret;
1635 ret = find_new_extents(root, inode, newer_than,
1637 if (!ret) {
1644 if (ret > 0) {
1645 i += ret;
1646 last_len += ret << PAGE_SHIFT;
1667 ret = defrag_count;
1678 return ret;
1696 int ret = 0;
1702 ret = mnt_want_write_file(file);
1703 if (ret)
1704 return ret;
1713 ret = PTR_ERR(vol_args);
1725 ret = kstrtoull(devstr, 10, &devid);
1726 if (ret)
1729 ret = -EINVAL;
1739 ret = -ENODEV;
1747 ret = -EPERM;
1763 ret = -EINVAL;
1769 ret = -EPERM;
1777 ret = -EINVAL;
1783 ret = -ERANGE;
1790 ret = -EINVAL;
1794 ret = -EFBIG;
1803 ret = PTR_ERR(trans);
1806 ret = btrfs_grow_device(trans, device, new_size);
1809 ret = btrfs_shrink_device(device, new_size);
1812 if (ret == 0 && new_size != old_size)
1822 return ret;
1831 int ret = 0;
1836 ret = mnt_want_write_file(file);
1837 if (ret)
1842 ret = -EINVAL;
1848 ret = -EEXIST;
1853 ret = btrfs_mksubvol(&file->f_path, name, namelen,
1859 ret = -EINVAL;
1867 ret = -EXDEV;
1873 ret = -EPERM;
1882 ret = -EINVAL;
1884 ret = btrfs_mksnapshot(&file->f_path, name, namelen,
1893 return ret;
1900 int ret;
1910 ret = __btrfs_ioctl_snap_create(file, vol_args->name, vol_args->fd,
1914 return ret;
1921 int ret;
1934 ret = -EOPNOTSUPP;
1945 ret = -EINVAL;
1950 ret = PTR_ERR(inherit);
1957 ret = -EINVAL;
1964 ret = -EINVAL;
1969 ret = __btrfs_ioctl_snap_create(file, vol_args->name, vol_args->fd,
1971 if (ret)
1977 return ret;
1986 int ret = 0;
1998 ret = -EFAULT;
2000 return ret;
2012 int ret = 0;
2017 ret = mnt_want_write_file(file);
2018 if (ret)
2022 ret = -EINVAL;
2027 ret = -EFAULT;
2032 ret = -EOPNOTSUPP;
2061 ret = -EPERM;
2068 ret = PTR_ERR(trans);
2072 ret = btrfs_update_root(trans, fs_info->tree_root,
2074 if (ret < 0) {
2079 ret = btrfs_commit_transaction(trans);
2082 if (ret)
2089 return ret;
2096 int ret;
2102 ret = btrfs_comp_cpu_keys(key, &test);
2103 if (ret < 0)
2110 ret = btrfs_comp_cpu_keys(key, &test);
2111 if (ret > 0)
2133 int ret = 0;
2155 ret = 1;
2166 ret = -EOVERFLOW;
2170 ret = 1;
2187 ret = 0;
2201 ret = 0;
2210 if (ret) /* -EOVERFLOW from above */
2214 ret = 1;
2219 ret = 0;
2224 ret = 1;
2235 ret = 1;
2246 return ret;
2258 int ret;
2287 ret = fault_in_pages_writeable(ubuf + sk_offset,
2289 if (ret)
2292 ret = btrfs_search_forward(root, &key, path, sk->min_transid);
2293 if (ret != 0) {
2294 if (ret > 0)
2295 ret = 0;
2298 ret = copy_to_sk(path, &key, sk, buf_size, ubuf,
2301 if (ret)
2305 if (ret > 0)
2306 ret = 0;
2311 return ret;
2320 int ret;
2334 ret = search_ioctl(inode, &sk, &buf_size, uargs->buf);
2338 * search header with a len of zero, so reset ret.
2340 if (ret == -EOVERFLOW)
2341 ret = 0;
2343 if (ret == 0 && copy_to_user(&uargs->key, &sk, sizeof(sk)))
2344 ret = -EFAULT;
2345 return ret;
2354 int ret;
2373 ret = search_ioctl(inode, &args.key, &buf_size,
2375 if (ret == 0 && copy_to_user(&uarg->key, &args.key, sizeof(args.key)))
2376 ret = -EFAULT;
2377 else if (ret == -EOVERFLOW &&
2379 ret = -EFAULT;
2381 return ret;
2394 int ret = -1;
2415 ret = PTR_ERR(root);
2425 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
2426 if (ret < 0)
2428 else if (ret > 0) {
2429 ret = btrfs_previous_item(root, path, dirid,
2431 if (ret < 0)
2433 else if (ret > 0) {
2434 ret = -ENOENT;
2448 ret = -ENAMETOOLONG;
2465 ret = 0;
2469 return ret;
2493 int ret;
2508 ret = PTR_ERR(root);
2516 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
2517 if (ret < 0) {
2519 } else if (ret > 0) {
2520 ret = btrfs_previous_item(root, path, dirid,
2522 if (ret < 0) {
2524 } else if (ret > 0) {
2525 ret = -ENOENT;
2539 ret = -ENAMETOOLONG;
2548 ret = btrfs_previous_item(root, path, dirid,
2550 if (ret < 0) {
2552 } else if (ret > 0) {
2553 ret = -ENOENT;
2561 ret = -ENOENT;
2574 ret = PTR_ERR(temp_inode);
2577 ret = inode_permission(temp_inode, MAY_READ | MAY_EXEC);
2579 if (ret) {
2580 ret = -EACCES;
2587 ret = -EACCES;
2607 ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);
2608 if (ret < 0) {
2610 } else if (ret > 0) {
2611 ret = -ENOENT;
2624 ret = -EINVAL;
2638 return ret;
2646 int ret = 0;
2667 ret = -EPERM;
2671 ret = btrfs_search_path_in_tree(BTRFS_I(inode)->root->fs_info,
2676 if (ret == 0 && copy_to_user(argp, args, sizeof(*args)))
2677 ret = -EFAULT;
2680 return ret;
2699 int ret;
2717 ret = btrfs_search_path_in_tree_user(inode, args);
2719 if (ret == 0 && copy_to_user(argp, args, sizeof(*args)))
2720 ret = -EFAULT;
2723 return ret;
2741 int ret = 0;
2760 ret = PTR_ERR(root);
2796 ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);
2797 if (ret < 0) {
2801 ret = btrfs_next_leaf(fs_info->tree_root, path);
2802 if (ret < 0) {
2804 } else if (ret > 0) {
2805 ret = -EUCLEAN;
2827 ret = -ENOENT;
2835 ret = -EFAULT;
2842 return ret;
2860 int ret;
2882 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
2883 if (ret < 0) {
2887 ret = btrfs_next_leaf(root, path);
2888 if (ret < 0) {
2890 } else if (ret > 0) {
2891 ret = -EUCLEAN;
2901 ret = 0;
2906 ret = -EOVERFLOW;
2916 ret = btrfs_next_item(root, path);
2917 if (ret < 0) {
2919 } else if (ret > 0) {
2920 ret = -EUCLEAN;
2928 if (!ret || ret == -EOVERFLOW) {
2935 ret = -EFAULT;
2940 return ret;
3152 int ret;
3154 ret = mnt_want_write_file(file);
3155 if (ret)
3156 return ret;
3159 ret = -EROFS;
3166 ret = -EPERM;
3169 ret = btrfs_defrag_root(root);
3179 ret = -EPERM;
3185 ret = -ENOMEM;
3192 ret = -EFAULT;
3197 ret = -EOPNOTSUPP;
3209 ret = btrfs_defrag_file(file_inode(file), file,
3211 if (ret > 0)
3212 ret = 0;
3216 ret = -EINVAL;
3220 return ret;
3226 int ret;
3236 ret = PTR_ERR(vol_args);
3241 ret = btrfs_init_new_device(fs_info, vol_args->name);
3243 if (!ret)
3249 return ret;
3257 int ret;
3262 ret = mnt_want_write_file(file);
3263 if (ret)
3264 return ret;
3268 ret = PTR_ERR(vol_args);
3273 ret = -EOPNOTSUPP;
3278 ret = BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS;
3283 ret = btrfs_rm_device(fs_info, NULL, vol_args->devid);
3286 ret = btrfs_rm_device(fs_info, vol_args->name, 0);
3290 if (!ret) {
3302 return ret;
3310 int ret;
3315 ret = mnt_want_write_file(file);
3316 if (ret)
3317 return ret;
3320 ret = BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS;
3326 ret = PTR_ERR(vol_args);
3331 ret = btrfs_rm_device(fs_info, vol_args->name, 0);
3333 if (!ret)
3341 return ret;
3351 int ret = 0;
3392 ret = -EFAULT;
3395 return ret;
3403 int ret = 0;
3418 ret = -ENODEV;
3433 if (ret == 0 && copy_to_user(arg, di_args, sizeof(*di_args)))
3434 ret = -EFAULT;
3437 return ret;
3452 int ret;
3457 ret = mnt_want_write_file(file);
3458 if (ret)
3459 return ret;
3462 ret = -EFAULT;
3471 ret = PTR_ERR(new_root);
3475 ret = -ENOENT;
3481 ret = -ENOMEM;
3488 ret = PTR_ERR(trans);
3500 ret = -ENOENT;
3516 return ret;
3551 int ret = 0;
3661 ret = -EFAULT;
3665 if (ret == 0 && copy_to_user(arg, &space_args, sizeof(space_args)))
3666 ret = -EFAULT;
3668 return ret;
3676 int ret;
3688 ret = btrfs_commit_transaction_async(trans, 0);
3689 if (ret) {
3691 return ret;
3718 int ret;
3728 ret = -EOPNOTSUPP;
3733 ret = mnt_want_write_file(file);
3734 if (ret)
3738 ret = btrfs_scrub_dev(fs_info, sa->devid, sa->start, sa->end,
3755 ret = -EFAULT;
3761 return ret;
3776 int ret;
3785 ret = btrfs_scrub_progress(fs_info, sa->devid, &sa->progress);
3787 if (ret == 0 && copy_to_user(arg, sa, sizeof(*sa)))
3788 ret = -EFAULT;
3791 return ret;
3798 int ret;
3809 ret = btrfs_get_dev_stats(fs_info, sa);
3811 if (ret == 0 && copy_to_user(arg, sa, sizeof(*sa)))
3812 ret = -EFAULT;
3815 return ret;
3822 int ret;
3834 ret = -EROFS;
3838 ret = BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS;
3840 ret = btrfs_dev_replace_by_ioctl(fs_info, p);
3846 ret = 0;
3850 ret = 0;
3853 ret = -EINVAL;
3857 if ((ret == 0 || ret == -ECANCELED) && copy_to_user(arg, p, sizeof(*p)))
3858 ret = -EFAULT;
3861 return ret;
3866 int ret = 0;
3879 ret = -ENOMEM;
3885 ret = PTR_ERR(ipa);
3893 ret = PTR_ERR(ipath);
3898 ret = paths_from_inode(ipa->inum, ipath);
3899 if (ret < 0)
3910 ret = copy_to_user((void __user *)(unsigned long)ipa->fspath,
3912 if (ret) {
3913 ret = -EFAULT;
3922 return ret;
3928 int ret = 0;
3948 ret = -EINVAL;
3953 ret = -EINVAL;
3962 ret = PTR_ERR(inodes);
3968 ret = -ENOMEM;
3971 ret = iterate_inodes_from_logical(loi->logical, fs_info, path,
3974 if (ret == -EINVAL)
3975 ret = -ENOENT;
3976 if (ret < 0)
3979 ret = copy_to_user((void __user *)(unsigned long)loi->inodes, inodes,
3981 if (ret)
3982 ret = -EFAULT;
3989 return ret;
4022 int ret;
4027 ret = mnt_want_write_file(file);
4028 if (ret)
4029 return ret;
4067 ret = -EINPROGRESS;
4073 ret = BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS;
4082 ret = PTR_ERR(bargs);
4088 ret = -ENOTCONN;
4104 ret = -EINPROGRESS;
4110 ret = -ENOMEM;
4126 ret = -EINVAL;
4139 ret = btrfs_balance(fs_info, bctl, bargs);
4142 if ((ret == 0 || ret == -ECANCELED) && arg) {
4144 ret = -EFAULT;
4157 return ret;
4179 int ret = 0;
4186 ret = -ENOTCONN;
4192 ret = -ENOMEM;
4199 ret = -EFAULT;
4204 return ret;
4212 int ret;
4217 ret = mnt_want_write_file(file);
4218 if (ret)
4219 return ret;
4223 ret = PTR_ERR(sa);
4231 ret = btrfs_quota_enable(fs_info);
4234 ret = btrfs_quota_disable(fs_info);
4237 ret = -EINVAL;
4245 return ret;
4255 int ret;
4261 ret = mnt_want_write_file(file);
4262 if (ret)
4263 return ret;
4267 ret = PTR_ERR(sa);
4273 ret = PTR_ERR(trans);
4278 ret = btrfs_add_qgroup_relation(trans, sa->src, sa->dst);
4280 ret = btrfs_del_qgroup_relation(trans, sa->src, sa->dst);
4291 if (err && !ret)
4292 ret = err;
4298 return ret;
4307 int ret;
4313 ret = mnt_want_write_file(file);
4314 if (ret)
4315 return ret;
4319 ret = PTR_ERR(sa);
4324 ret = -EINVAL;
4329 ret = -EINVAL;
4335 ret = PTR_ERR(trans);
4340 ret = btrfs_create_qgroup(trans, sa->qgroupid);
4342 ret = btrfs_remove_qgroup(trans, sa->qgroupid);
4346 if (err && !ret)
4347 ret = err;
4353 return ret;
4362 int ret;
4369 ret = mnt_want_write_file(file);
4370 if (ret)
4371 return ret;
4375 ret = PTR_ERR(sa);
4381 ret = PTR_ERR(trans);
4391 ret = btrfs_limit_qgroup(trans, qgroupid, &sa->lim);
4394 if (err && !ret)
4395 ret = err;
4401 return ret;
4409 int ret;
4414 ret = mnt_want_write_file(file);
4415 if (ret)
4416 return ret;
4420 ret = PTR_ERR(qsa);
4425 ret = -EINVAL;
4429 ret = btrfs_qgroup_rescan(fs_info);
4435 return ret;
4442 int ret = 0;
4457 ret = -EFAULT;
4460 return ret;
4481 int ret = 0;
4487 ret = mnt_want_write_file(file);
4488 if (ret < 0)
4489 return ret;
4494 ret = -EINVAL;
4499 ret = -EROFS;
4509 ret = PTR_ERR(trans);
4522 ret = btrfs_uuid_tree_remove(trans, root_item->received_uuid,
4525 if (ret && ret != -ENOENT) {
4526 btrfs_abort_transaction(trans, ret);
4539 ret = btrfs_update_root(trans, fs_info->tree_root,
4541 if (ret < 0) {
4546 ret = btrfs_uuid_tree_add(trans, sa->uuid,
4549 if (ret < 0 && ret != -EEXIST) {
4550 btrfs_abort_transaction(trans, ret);
4555 ret = btrfs_commit_transaction(trans);
4559 return ret;
4568 int ret = 0;
4576 ret = -ENOMEM;
4589 ret = _btrfs_ioctl_set_received_subvol(file, args64);
4590 if (ret)
4602 ret = copy_to_user(arg, args32, sizeof(*args32));
4603 if (ret)
4604 ret = -EFAULT;
4609 return ret;
4617 int ret = 0;
4623 ret = _btrfs_ioctl_set_received_subvol(file, sa);
4625 if (ret)
4628 ret = copy_to_user(arg, sa, sizeof(*sa));
4629 if (ret)
4630 ret = -EFAULT;
4634 return ret;
4641 int ret;
4656 ret = copy_to_user(arg, label, len);
4658 return ret ? -EFAULT : 0;
4669 int ret;
4684 ret = mnt_want_write_file(file);
4685 if (ret)
4686 return ret;
4690 ret = PTR_ERR(trans);
4697 ret = btrfs_commit_transaction(trans);
4701 return ret;
4813 int ret;
4826 ret = check_feature(fs_info, flags[0].compat_flags,
4828 if (ret)
4829 return ret;
4831 ret = check_feature(fs_info, flags[0].compat_ro_flags,
4833 if (ret)
4834 return ret;
4836 ret = check_feature(fs_info, flags[0].incompat_flags,
4838 if (ret)
4839 return ret;
4841 ret = mnt_want_write_file(file);
4842 if (ret)
4843 return ret;
4847 ret = PTR_ERR(trans);
4868 ret = btrfs_commit_transaction(trans);
4872 return ret;
4878 int ret;
4884 ret = copy_from_user(&args32, argp, sizeof(args32));
4885 if (ret)
4905 ret = btrfs_ioctl_send(file, arg);
4907 return ret;
4982 int ret;
4984 ret = btrfs_start_delalloc_roots(fs_info, U64_MAX, false);
4985 if (ret)
4986 return ret;
4987 ret = btrfs_sync_fs(inode->i_sb, 1);
4994 return ret;