Lines Matching refs:error
281 int error = posix_acl_permission(inode, acl, mask);
283 return error;
309 int error = check_acl(inode, mask);
310 if (error != -EAGAIN)
311 return error;
794 * success, -error on failure. In case of failure caller does not
889 int error = set_root(nd);
890 if (error)
891 return error;
917 int error = -ELOOP;
923 error = -EXDEV;
940 return error;
969 * Returns 0 if following the symlink is allowed, -ve on error.
1041 * Returns 0 if successful, -ve on error.
1083 * Returns 0 if the open is allowed, -ve on error.
1427 int error = d_revalidate(dentry, flags);
1428 if (unlikely(error <= 0)) {
1429 if (!error)
1432 return ERR_PTR(error);
1551 int error = d_revalidate(dentry, flags);
1552 if (unlikely(error <= 0)) {
1553 if (!error) {
1559 dentry = ERR_PTR(error);
1627 int error = reserve_stack(nd, link, seq);
1629 if (unlikely(error)) {
1632 return ERR_PTR(error);
1640 error = may_follow_link(nd, inode);
1641 if (unlikely(error))
1642 return ERR_PTR(error);
1658 error = security_inode_follow_link(link->dentry, inode,
1660 if (unlikely(error))
1661 return ERR_PTR(error);
1681 error = nd_jump_root(nd);
1682 if (unlikely(error))
1683 return ERR_PTR(error);
1813 const char *error = NULL;
1819 error = ERR_PTR(set_root(nd));
1820 if (error)
1821 return error;
1830 error = step_into(nd, WALK_NOFOLLOW,
1833 error = step_into(nd, WALK_NOFOLLOW,
1835 if (unlikely(error))
1836 return error;
2117 * Returns error and drops reference to input namei data on failure.
2220 int error;
2260 error = nd_jump_root(nd);
2261 if (unlikely(error))
2262 return ERR_PTR(error);
2337 /* Returns 0 and nd will be valid on success; Retuns error, otherwise. */
2397 /* Returns 0 and nd will be valid on success; Retuns error, otherwise. */
2703 int error;
2717 error = inode_permission(dir, MAY_WRITE | MAY_EXEC);
2718 if (error)
2719 return error;
2862 int error = may_create(dir, dentry);
2863 if (error)
2864 return error;
2870 error = security_inode_create(dir, dentry, mode);
2871 if (error)
2872 return error;
2873 error = dir->i_op->create(dir, dentry, mode, want_excl);
2874 if (!error)
2876 return error;
2885 int error = may_create(dir, dentry);
2886 if (error)
2887 return error;
2891 error = security_inode_create(dir, dentry, mode);
2892 if (error)
2893 return error;
2894 error = f(dentry, mode, arg);
2895 if (!error)
2897 return error;
2911 int error;
2942 error = inode_permission(inode, MAY_OPEN | acc_mode);
2943 if (error)
2944 return error;
2967 int error = get_write_access(inode);
2968 if (error)
2969 return error;
2973 error = locks_verify_locked(filp);
2974 if (!error)
2975 error = security_path_truncate(path);
2976 if (!error) {
2977 error = do_truncate(path->dentry, 0,
2982 return error;
2995 int error = security_path_mknod(dir, dentry, mode, 0);
2996 if (error)
2997 return error;
3004 error = inode_permission(dir->dentry->d_inode, MAY_WRITE | MAY_EXEC);
3005 if (error)
3006 return error;
3022 * Returns an error code otherwise.
3030 int error;
3037 error = dir->i_op->atomic_open(dir, dentry, file,
3040 if (!error) {
3047 error = -EIO;
3054 error = -ENOENT;
3057 if (error) {
3059 dentry = ERR_PTR(error);
3077 * An error code is returned on failure.
3087 int error, create_error = 0;
3105 error = d_revalidate(dentry, nd->flags);
3106 if (likely(error > 0))
3108 if (error)
3125 * Another problem is returing the "right" error value (e.g. for an
3154 error = PTR_ERR(res);
3167 error = -EACCES;
3170 error = dir_inode->i_op->create(dir_inode, dentry, mode,
3172 if (error)
3176 error = create_error;
3183 return ERR_PTR(error);
3232 * a different error; let lookup_open() decide; we'll be
3278 int error;
3281 error = complete_walk(nd);
3282 if (error)
3283 return error;
3292 error = may_create_in_sticky(nd->dir_mode, nd->dir_uid,
3294 if (unlikely(error))
3295 return error;
3307 error = mnt_want_write(nd->path.mnt);
3308 if (error)
3309 return error;
3312 error = may_open(&nd->path, acc_mode, open_flag);
3313 if (!error && !(file->f_mode & FMODE_OPENED))
3314 error = vfs_open(&nd->path, file);
3315 if (!error)
3316 error = ima_file_check(file, op->acc_mode);
3317 if (!error && do_truncate)
3318 error = handle_truncate(file);
3319 if (unlikely(error > 0)) {
3321 error = -EINVAL;
3325 return error;
3333 int error;
3336 error = inode_permission(dir, MAY_WRITE | MAY_EXEC);
3337 if (error)
3339 error = -EOPNOTSUPP;
3342 error = -ENOMEM;
3347 error = dir->i_op->tmpfile(dir, child, mode);
3348 if (error)
3350 error = -ENOENT;
3364 return ERR_PTR(error);
3374 int error = path_lookupat(nd, flags | LOOKUP_DIRECTORY, &path);
3375 if (unlikely(error))
3376 return error;
3377 error = mnt_want_write(path.mnt);
3378 if (unlikely(error))
3381 error = PTR_ERR(child);
3388 error = may_open(&path, 0, op->open_flag);
3389 if (error)
3392 error = finish_open(file, child, NULL);
3397 return error;
3403 int error = path_lookupat(nd, flags, &path);
3404 if (!error) {
3406 error = vfs_open(&path, file);
3409 return error;
3416 int error;
3423 error = do_tmpfile(nd, flags, op, file);
3425 error = do_o_path(nd, flags, file);
3428 while (!(error = link_path_walk(s, nd)) &&
3431 if (!error)
3432 error = do_open(nd, file, op);
3435 if (likely(!error)) {
3439 error = -EINVAL;
3442 if (error == -EOPENSTALE) {
3444 error = -ECHILD;
3446 error = -ESTALE;
3448 return ERR_PTR(error);
3503 int error;
3534 error = -EEXIST;
3545 error = -ENOENT;
3549 error = err2;
3556 dentry = ERR_PTR(error);
3594 int error = may_create(dir, dentry);
3596 if (error)
3597 return error;
3607 error = devcgroup_inode_mknod(mode, dev);
3608 if (error)
3609 return error;
3611 error = security_inode_mknod(dir, dentry, mode, dev);
3612 if (error)
3613 return error;
3615 error = dir->i_op->mknod(dir, dentry, mode, dev);
3616 if (!error)
3618 return error;
3644 int error;
3647 error = may_mknod(mode);
3648 if (error)
3649 return error;
3655 error = security_path_mknod(&path, dentry,
3657 if (error)
3661 error = vfs_create(path.dentry->d_inode,dentry,mode,true);
3662 if (!error)
3666 error = vfs_mknod(path.dentry->d_inode,dentry,mode,
3670 error = vfs_mknod(path.dentry->d_inode,dentry,mode,0);
3675 if (retry_estale(error, lookup_flags)) {
3679 return error;
3695 int error = may_create(dir, dentry);
3698 if (error)
3699 return error;
3705 error = security_inode_mkdir(dir, dentry, mode);
3706 if (error)
3707 return error;
3712 error = dir->i_op->mkdir(dir, dentry, mode);
3713 if (!error)
3715 return error;
3723 int error;
3731 error = security_path_mkdir(&path, dentry,
3733 if (!error)
3734 error = vfs_mkdir(path.dentry->d_inode, dentry, mode);
3736 if (retry_estale(error, lookup_flags)) {
3740 return error;
3755 int error = may_delete(dir, dentry, 1);
3757 if (error)
3758 return error;
3766 error = -EBUSY;
3770 error = security_inode_rmdir(dir, dentry);
3771 if (error)
3774 error = dir->i_op->rmdir(dir, dentry);
3775 if (error)
3786 if (!error)
3788 return error;
3794 int error = 0;
3808 error = -ENOTEMPTY;
3811 error = -EINVAL;
3814 error = -EBUSY;
3818 error = mnt_want_write(path.mnt);
3819 if (error)
3824 error = PTR_ERR(dentry);
3828 error = -ENOENT;
3831 error = security_path_rmdir(&path, dentry);
3832 if (error)
3834 error = vfs_rmdir(path.dentry->d_inode, dentry);
3842 if (retry_estale(error, lookup_flags)) {
3847 return error;
3876 int error = may_delete(dir, dentry, 0);
3878 if (error)
3879 return error;
3886 error = -EBUSY;
3888 error = security_inode_unlink(dir, dentry);
3889 if (!error) {
3890 error = try_break_deleg(target, delegated_inode);
3891 if (error)
3893 error = dir->i_op->unlink(dir, dentry);
3894 if (!error) {
3904 if (!error && dentry->d_flags & DCACHE_NFSFS_RENAMED) {
3906 } else if (!error) {
3911 return error;
3923 int error;
3936 error = -EISDIR;
3940 error = mnt_want_write(path.mnt);
3941 if (error)
3946 error = PTR_ERR(dentry);
3948 /* Why not before? Because we want correct error value */
3955 error = security_path_unlink(&path, dentry);
3956 if (error)
3958 error = vfs_unlink(path.dentry->d_inode, dentry, &delegated_inode);
3967 error = break_deleg_wait(&delegated_inode);
3968 if (!error)
3974 if (retry_estale(error, lookup_flags)) {
3980 return error;
3984 error = -ENOENT;
3986 error = -EISDIR;
3988 error = -ENOTDIR;
4009 int error = may_create(dir, dentry);
4011 if (error)
4012 return error;
4017 error = security_inode_symlink(dir, dentry, oldname);
4018 if (error)
4019 return error;
4021 error = dir->i_op->symlink(dir, dentry, oldname);
4022 if (!error)
4024 return error;
4031 int error;
4042 error = PTR_ERR(dentry);
4046 error = security_path_symlink(&path, dentry, from->name);
4047 if (!error)
4048 error = vfs_symlink(path.dentry->d_inode, dentry, from->name);
4050 if (retry_estale(error, lookup_flags)) {
4056 return error;
4093 int error;
4098 error = may_create(dir, new_dentry);
4099 if (error)
4100 return error;
4122 error = security_inode_link(old_dentry, dir, new_dentry);
4123 if (error)
4124 return error;
4129 error = -ENOENT;
4131 error = -EMLINK;
4133 error = try_break_deleg(inode, delegated_inode);
4134 if (!error)
4135 error = dir->i_op->link(old_dentry, dir, new_dentry);
4138 if (!error && (inode->i_state & I_LINKABLE)) {
4144 if (!error)
4146 return error;
4166 int error;
4184 error = user_path_at(olddfd, oldname, how, &old_path);
4185 if (error)
4186 return error;
4190 error = PTR_ERR(new_dentry);
4194 error = -EXDEV;
4197 error = may_linkat(&old_path);
4198 if (unlikely(error))
4200 error = security_path_link(old_path.dentry, &new_path, new_dentry);
4201 if (error)
4203 error = vfs_link(old_path.dentry, new_path.dentry->d_inode, new_dentry, &delegated_inode);
4207 error = break_deleg_wait(&delegated_inode);
4208 if (!error) {
4213 if (retry_estale(error, how)) {
4221 return error;
4290 int error;
4302 error = may_delete(old_dir, old_dentry, is_dir);
4303 if (error)
4304 return error;
4307 error = may_create(new_dir, new_dentry);
4312 error = may_delete(new_dir, new_dentry, is_dir);
4314 error = may_delete(new_dir, new_dentry, new_is_dir);
4316 if (error)
4317 return error;
4328 error = inode_permission(source, MAY_WRITE);
4329 if (error)
4330 return error;
4333 error = inode_permission(target, MAY_WRITE);
4334 if (error)
4335 return error;
4339 error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry,
4341 if (error)
4342 return error;
4374 error = -EBUSY;
4379 error = -EMLINK;
4387 error = try_break_deleg(source, delegated_inode);
4388 if (error)
4392 error = try_break_deleg(target, delegated_inode);
4393 if (error)
4396 error = old_dir->i_op->rename(old_dir, old_dentry,
4398 if (error)
4421 if (!error) {
4431 return error;
4446 int error = -EINVAL;
4462 error = PTR_ERR(from);
4469 error = PTR_ERR(to);
4473 error = -EXDEV;
4477 error = -EBUSY;
4482 error = -EEXIST;
4486 error = mnt_want_write(old_path.mnt);
4487 if (error)
4494 error = PTR_ERR(old_dentry);
4498 error = -ENOENT;
4502 error = PTR_ERR(new_dentry);
4505 error = -EEXIST;
4509 error = -ENOENT;
4514 error = -ENOTDIR;
4521 error = -ENOTDIR;
4528 error = -EINVAL;
4533 error = -ENOTEMPTY;
4537 error = security_path_rename(&old_path, old_dentry,
4539 if (error)
4541 error = vfs_rename(old_path.dentry->d_inode, old_dentry,
4551 error = break_deleg_wait(&delegated_inode);
4552 if (!error)
4557 if (retry_estale(error, lookup_flags))
4573 return error;