3 * Copyright (C) 2011 Novell Inc.
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 as published by
7 * the Free Software Foundation.
11 #include <linux/namei.h>
12 #include <linux/xattr.h>
13 #include <linux/security.h>
14 #include <linux/cred.h>
15 #include <linux/module.h>
16 #include <linux/posix_acl.h>
17 #include <linux/posix_acl_xattr.h>
18 #include <linux/atomic.h>
19 #include <linux/ratelimit.h>
20 #include "overlayfs.h"
22 static unsigned short ovl_redirect_max
= 256;
23 module_param_named(redirect_max
, ovl_redirect_max
, ushort
, 0644);
24 MODULE_PARM_DESC(ovl_redirect_max
,
25 "Maximum length of absolute redirect xattr value");
27 void ovl_cleanup(struct inode
*wdir
, struct dentry
*wdentry
)
32 if (d_is_dir(wdentry
))
33 err
= ovl_do_rmdir(wdir
, wdentry
);
35 err
= ovl_do_unlink(wdir
, wdentry
);
39 pr_err("overlayfs: cleanup of '%pd2' failed (%i)\n",
44 struct dentry
*ovl_lookup_temp(struct dentry
*workdir
)
48 static atomic_t temp_id
= ATOMIC_INIT(0);
50 /* counter is allowed to wrap, since temp dentries are ephemeral */
51 snprintf(name
, sizeof(name
), "#%x", atomic_inc_return(&temp_id
));
53 temp
= lookup_one_len(name
, workdir
, strlen(name
));
54 if (!IS_ERR(temp
) && temp
->d_inode
) {
55 pr_err("overlayfs: workdir/%s already exists\n", name
);
63 /* caller holds i_mutex on workdir */
64 static struct dentry
*ovl_whiteout(struct dentry
*workdir
,
65 struct dentry
*dentry
)
68 struct dentry
*whiteout
;
69 struct inode
*wdir
= workdir
->d_inode
;
71 whiteout
= ovl_lookup_temp(workdir
);
75 err
= ovl_do_whiteout(wdir
, whiteout
);
78 whiteout
= ERR_PTR(err
);
84 int ovl_create_real(struct inode
*dir
, struct dentry
*newdentry
,
85 struct cattr
*attr
, struct dentry
*hardlink
, bool debug
)
89 if (newdentry
->d_inode
)
93 err
= ovl_do_link(hardlink
, dir
, newdentry
, debug
);
95 switch (attr
->mode
& S_IFMT
) {
97 err
= ovl_do_create(dir
, newdentry
, attr
->mode
, debug
);
101 err
= ovl_do_mkdir(dir
, newdentry
, attr
->mode
, debug
);
108 err
= ovl_do_mknod(dir
, newdentry
,
109 attr
->mode
, attr
->rdev
, debug
);
113 err
= ovl_do_symlink(dir
, newdentry
, attr
->link
, debug
);
120 if (!err
&& WARN_ON(!newdentry
->d_inode
)) {
122 * Not quite sure if non-instantiated dentry is legal or not.
123 * VFS doesn't seem to care so check and warn here.
130 static int ovl_set_opaque_xerr(struct dentry
*dentry
, struct dentry
*upper
,
135 err
= ovl_check_setxattr(dentry
, upper
, OVL_XATTR_OPAQUE
, "y", 1, xerr
);
137 ovl_dentry_set_opaque(dentry
);
142 static int ovl_set_opaque(struct dentry
*dentry
, struct dentry
*upperdentry
)
145 * Fail with -EIO when trying to create opaque dir and upper doesn't
146 * support xattrs. ovl_rename() calls ovl_set_opaque_xerr(-EXDEV) to
147 * return a specific error for noxattr case.
149 return ovl_set_opaque_xerr(dentry
, upperdentry
, -EIO
);
152 /* Common operations required to be done after creation of file on upper */
153 static void ovl_instantiate(struct dentry
*dentry
, struct inode
*inode
,
154 struct dentry
*newdentry
, bool hardlink
)
156 ovl_dentry_version_inc(dentry
->d_parent
);
157 ovl_dentry_update(dentry
, newdentry
);
159 ovl_inode_update(inode
, d_inode(newdentry
));
160 ovl_copyattr(newdentry
->d_inode
, inode
);
162 WARN_ON(ovl_inode_real(inode
, NULL
) != d_inode(newdentry
));
165 d_instantiate(dentry
, inode
);
166 /* Force lookup of new upper hardlink to find its lower */
171 static bool ovl_type_merge(struct dentry
*dentry
)
173 return OVL_TYPE_MERGE(ovl_path_type(dentry
));
176 static bool ovl_type_origin(struct dentry
*dentry
)
178 return OVL_TYPE_ORIGIN(ovl_path_type(dentry
));
181 static int ovl_create_upper(struct dentry
*dentry
, struct inode
*inode
,
182 struct cattr
*attr
, struct dentry
*hardlink
)
184 struct dentry
*upperdir
= ovl_dentry_upper(dentry
->d_parent
);
185 struct inode
*udir
= upperdir
->d_inode
;
186 struct dentry
*newdentry
;
189 if (!hardlink
&& !IS_POSIXACL(udir
))
190 attr
->mode
&= ~current_umask();
192 inode_lock_nested(udir
, I_MUTEX_PARENT
);
193 newdentry
= lookup_one_len(dentry
->d_name
.name
, upperdir
,
195 err
= PTR_ERR(newdentry
);
196 if (IS_ERR(newdentry
))
198 err
= ovl_create_real(udir
, newdentry
, attr
, hardlink
, false);
202 if (ovl_type_merge(dentry
->d_parent
) && d_is_dir(newdentry
)) {
203 /* Setting opaque here is just an optimization, allow to fail */
204 ovl_set_opaque(dentry
, newdentry
);
207 ovl_instantiate(dentry
, inode
, newdentry
, !!hardlink
);
216 static int ovl_lock_rename_workdir(struct dentry
*workdir
,
217 struct dentry
*upperdir
)
219 /* Workdir should not be the same as upperdir */
220 if (workdir
== upperdir
)
223 /* Workdir should not be subdir of upperdir and vice versa */
224 if (lock_rename(workdir
, upperdir
) != NULL
)
230 unlock_rename(workdir
, upperdir
);
232 pr_err("overlayfs: failed to lock workdir+upperdir\n");
236 static struct dentry
*ovl_clear_empty(struct dentry
*dentry
,
237 struct list_head
*list
)
239 struct dentry
*workdir
= ovl_workdir(dentry
);
240 struct inode
*wdir
= workdir
->d_inode
;
241 struct dentry
*upperdir
= ovl_dentry_upper(dentry
->d_parent
);
242 struct inode
*udir
= upperdir
->d_inode
;
243 struct path upperpath
;
244 struct dentry
*upper
;
245 struct dentry
*opaquedir
;
249 if (WARN_ON(!workdir
))
250 return ERR_PTR(-EROFS
);
252 err
= ovl_lock_rename_workdir(workdir
, upperdir
);
256 ovl_path_upper(dentry
, &upperpath
);
257 err
= vfs_getattr(&upperpath
, &stat
,
258 STATX_BASIC_STATS
, AT_STATX_SYNC_AS_STAT
);
263 if (!S_ISDIR(stat
.mode
))
265 upper
= upperpath
.dentry
;
266 if (upper
->d_parent
->d_inode
!= udir
)
269 opaquedir
= ovl_lookup_temp(workdir
);
270 err
= PTR_ERR(opaquedir
);
271 if (IS_ERR(opaquedir
))
274 err
= ovl_create_real(wdir
, opaquedir
,
275 &(struct cattr
){.mode
= stat
.mode
}, NULL
, true);
279 err
= ovl_copy_xattr(upper
, opaquedir
);
283 err
= ovl_set_opaque(dentry
, opaquedir
);
287 inode_lock(opaquedir
->d_inode
);
288 err
= ovl_set_attr(opaquedir
, &stat
);
289 inode_unlock(opaquedir
->d_inode
);
293 err
= ovl_do_rename(wdir
, opaquedir
, udir
, upper
, RENAME_EXCHANGE
);
297 ovl_cleanup_whiteouts(upper
, list
);
298 ovl_cleanup(wdir
, upper
);
299 unlock_rename(workdir
, upperdir
);
301 /* dentry's upper doesn't match now, get rid of it */
307 ovl_cleanup(wdir
, opaquedir
);
311 unlock_rename(workdir
, upperdir
);
316 static struct dentry
*ovl_check_empty_and_clear(struct dentry
*dentry
)
319 struct dentry
*ret
= NULL
;
320 enum ovl_path_type type
= ovl_path_type(dentry
);
323 err
= ovl_check_empty_dir(dentry
, &list
);
330 * When removing an empty opaque directory, then it makes no sense to
331 * replace it with an exact replica of itself.
333 * If no upperdentry then skip clearing whiteouts.
335 * Can race with copy-up, since we don't hold the upperdir mutex.
336 * Doesn't matter, since copy-up can't create a non-empty directory
339 if (OVL_TYPE_UPPER(type
) && OVL_TYPE_MERGE(type
))
340 ret
= ovl_clear_empty(dentry
, &list
);
343 ovl_cache_free(&list
);
348 static int ovl_set_upper_acl(struct dentry
*upperdentry
, const char *name
,
349 const struct posix_acl
*acl
)
355 if (!IS_ENABLED(CONFIG_FS_POSIX_ACL
) || !acl
)
358 size
= posix_acl_to_xattr(NULL
, acl
, NULL
, 0);
359 buffer
= kmalloc(size
, GFP_KERNEL
);
363 size
= posix_acl_to_xattr(&init_user_ns
, acl
, buffer
, size
);
368 err
= vfs_setxattr(upperdentry
, name
, buffer
, size
, XATTR_CREATE
);
374 static int ovl_create_over_whiteout(struct dentry
*dentry
, struct inode
*inode
,
376 struct dentry
*hardlink
)
378 struct dentry
*workdir
= ovl_workdir(dentry
);
379 struct inode
*wdir
= workdir
->d_inode
;
380 struct dentry
*upperdir
= ovl_dentry_upper(dentry
->d_parent
);
381 struct inode
*udir
= upperdir
->d_inode
;
382 struct dentry
*upper
;
383 struct dentry
*newdentry
;
385 struct posix_acl
*acl
, *default_acl
;
387 if (WARN_ON(!workdir
))
391 err
= posix_acl_create(dentry
->d_parent
->d_inode
,
392 &cattr
->mode
, &default_acl
, &acl
);
397 err
= ovl_lock_rename_workdir(workdir
, upperdir
);
401 newdentry
= ovl_lookup_temp(workdir
);
402 err
= PTR_ERR(newdentry
);
403 if (IS_ERR(newdentry
))
406 upper
= lookup_one_len(dentry
->d_name
.name
, upperdir
,
408 err
= PTR_ERR(upper
);
412 err
= ovl_create_real(wdir
, newdentry
, cattr
, hardlink
, true);
417 * mode could have been mutilated due to umask (e.g. sgid directory)
420 !S_ISLNK(cattr
->mode
) &&
421 newdentry
->d_inode
->i_mode
!= cattr
->mode
) {
422 struct iattr attr
= {
423 .ia_valid
= ATTR_MODE
,
424 .ia_mode
= cattr
->mode
,
426 inode_lock(newdentry
->d_inode
);
427 err
= notify_change(newdentry
, &attr
, NULL
);
428 inode_unlock(newdentry
->d_inode
);
433 err
= ovl_set_upper_acl(newdentry
, XATTR_NAME_POSIX_ACL_ACCESS
,
438 err
= ovl_set_upper_acl(newdentry
, XATTR_NAME_POSIX_ACL_DEFAULT
,
444 if (!hardlink
&& S_ISDIR(cattr
->mode
)) {
445 err
= ovl_set_opaque(dentry
, newdentry
);
449 err
= ovl_do_rename(wdir
, newdentry
, udir
, upper
,
454 ovl_cleanup(wdir
, upper
);
456 err
= ovl_do_rename(wdir
, newdentry
, udir
, upper
, 0);
460 ovl_instantiate(dentry
, inode
, newdentry
, !!hardlink
);
467 unlock_rename(workdir
, upperdir
);
470 posix_acl_release(acl
);
471 posix_acl_release(default_acl
);
476 ovl_cleanup(wdir
, newdentry
);
480 static int ovl_create_or_link(struct dentry
*dentry
, struct inode
*inode
,
481 struct cattr
*attr
, struct dentry
*hardlink
)
484 const struct cred
*old_cred
;
485 struct cred
*override_cred
;
487 err
= ovl_copy_up(dentry
->d_parent
);
491 old_cred
= ovl_override_creds(dentry
->d_sb
);
493 override_cred
= prepare_creds();
495 override_cred
->fsuid
= inode
->i_uid
;
496 override_cred
->fsgid
= inode
->i_gid
;
498 err
= security_dentry_create_files_as(dentry
,
499 attr
->mode
, &dentry
->d_name
, old_cred
,
502 put_cred(override_cred
);
503 goto out_revert_creds
;
506 put_cred(override_creds(override_cred
));
507 put_cred(override_cred
);
509 if (!ovl_dentry_is_whiteout(dentry
))
510 err
= ovl_create_upper(dentry
, inode
, attr
,
513 err
= ovl_create_over_whiteout(dentry
, inode
, attr
,
517 revert_creds(old_cred
);
519 struct inode
*realinode
= d_inode(ovl_dentry_upper(dentry
));
521 WARN_ON(inode
->i_mode
!= realinode
->i_mode
);
522 WARN_ON(!uid_eq(inode
->i_uid
, realinode
->i_uid
));
523 WARN_ON(!gid_eq(inode
->i_gid
, realinode
->i_gid
));
528 static int ovl_create_object(struct dentry
*dentry
, int mode
, dev_t rdev
,
533 struct cattr attr
= {
538 err
= ovl_want_write(dentry
);
543 inode
= ovl_new_inode(dentry
->d_sb
, mode
, rdev
);
547 inode_init_owner(inode
, dentry
->d_parent
->d_inode
, mode
);
548 attr
.mode
= inode
->i_mode
;
550 err
= ovl_create_or_link(dentry
, inode
, &attr
, NULL
);
555 ovl_drop_write(dentry
);
560 static int ovl_create(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
563 return ovl_create_object(dentry
, (mode
& 07777) | S_IFREG
, 0, NULL
);
566 static int ovl_mkdir(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
568 return ovl_create_object(dentry
, (mode
& 07777) | S_IFDIR
, 0, NULL
);
571 static int ovl_mknod(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
574 /* Don't allow creation of "whiteout" on overlay */
575 if (S_ISCHR(mode
) && rdev
== WHITEOUT_DEV
)
578 return ovl_create_object(dentry
, mode
, rdev
, NULL
);
581 static int ovl_symlink(struct inode
*dir
, struct dentry
*dentry
,
584 return ovl_create_object(dentry
, S_IFLNK
, 0, link
);
587 static int ovl_link(struct dentry
*old
, struct inode
*newdir
,
593 err
= ovl_want_write(old
);
597 err
= ovl_copy_up(old
);
601 inode
= d_inode(old
);
604 err
= ovl_create_or_link(new, inode
, NULL
, ovl_dentry_upper(old
));
614 static int ovl_remove_and_whiteout(struct dentry
*dentry
, bool is_dir
)
616 struct dentry
*workdir
= ovl_workdir(dentry
);
617 struct inode
*wdir
= workdir
->d_inode
;
618 struct dentry
*upperdir
= ovl_dentry_upper(dentry
->d_parent
);
619 struct inode
*udir
= upperdir
->d_inode
;
620 struct dentry
*whiteout
;
621 struct dentry
*upper
;
622 struct dentry
*opaquedir
= NULL
;
626 if (WARN_ON(!workdir
))
630 opaquedir
= ovl_check_empty_and_clear(dentry
);
631 err
= PTR_ERR(opaquedir
);
632 if (IS_ERR(opaquedir
))
636 err
= ovl_lock_rename_workdir(workdir
, upperdir
);
640 upper
= lookup_one_len(dentry
->d_name
.name
, upperdir
,
642 err
= PTR_ERR(upper
);
647 if ((opaquedir
&& upper
!= opaquedir
) ||
648 (!opaquedir
&& ovl_dentry_upper(dentry
) &&
649 upper
!= ovl_dentry_upper(dentry
))) {
653 whiteout
= ovl_whiteout(workdir
, dentry
);
654 err
= PTR_ERR(whiteout
);
655 if (IS_ERR(whiteout
))
659 flags
= RENAME_EXCHANGE
;
661 err
= ovl_do_rename(wdir
, whiteout
, udir
, upper
, flags
);
665 ovl_cleanup(wdir
, upper
);
667 ovl_dentry_version_inc(dentry
->d_parent
);
674 unlock_rename(workdir
, upperdir
);
681 ovl_cleanup(wdir
, whiteout
);
685 static int ovl_remove_upper(struct dentry
*dentry
, bool is_dir
)
687 struct dentry
*upperdir
= ovl_dentry_upper(dentry
->d_parent
);
688 struct inode
*dir
= upperdir
->d_inode
;
689 struct dentry
*upper
;
690 struct dentry
*opaquedir
= NULL
;
693 /* Redirect dir can be !ovl_lower_positive && OVL_TYPE_MERGE */
694 if (is_dir
&& ovl_dentry_get_redirect(dentry
)) {
695 opaquedir
= ovl_check_empty_and_clear(dentry
);
696 err
= PTR_ERR(opaquedir
);
697 if (IS_ERR(opaquedir
))
701 inode_lock_nested(dir
, I_MUTEX_PARENT
);
702 upper
= lookup_one_len(dentry
->d_name
.name
, upperdir
,
704 err
= PTR_ERR(upper
);
709 if ((opaquedir
&& upper
!= opaquedir
) ||
710 (!opaquedir
&& upper
!= ovl_dentry_upper(dentry
)))
714 err
= vfs_rmdir(dir
, upper
);
716 err
= vfs_unlink(dir
, upper
, NULL
);
717 ovl_dentry_version_inc(dentry
->d_parent
);
720 * Keeping this dentry hashed would mean having to release
721 * upperpath/lowerpath, which could only be done if we are the
722 * sole user of this dentry. Too tricky... Just unhash for
736 static int ovl_do_remove(struct dentry
*dentry
, bool is_dir
)
738 enum ovl_path_type type
;
740 const struct cred
*old_cred
;
742 err
= ovl_want_write(dentry
);
746 err
= ovl_copy_up(dentry
->d_parent
);
750 type
= ovl_path_type(dentry
);
752 old_cred
= ovl_override_creds(dentry
->d_sb
);
753 if (!ovl_lower_positive(dentry
))
754 err
= ovl_remove_upper(dentry
, is_dir
);
756 err
= ovl_remove_and_whiteout(dentry
, is_dir
);
757 revert_creds(old_cred
);
760 clear_nlink(dentry
->d_inode
);
762 drop_nlink(dentry
->d_inode
);
765 ovl_drop_write(dentry
);
770 static int ovl_unlink(struct inode
*dir
, struct dentry
*dentry
)
772 return ovl_do_remove(dentry
, false);
775 static int ovl_rmdir(struct inode
*dir
, struct dentry
*dentry
)
777 return ovl_do_remove(dentry
, true);
780 static bool ovl_type_merge_or_lower(struct dentry
*dentry
)
782 enum ovl_path_type type
= ovl_path_type(dentry
);
784 return OVL_TYPE_MERGE(type
) || !OVL_TYPE_UPPER(type
);
787 static bool ovl_can_move(struct dentry
*dentry
)
789 return ovl_redirect_dir(dentry
->d_sb
) ||
790 !d_is_dir(dentry
) || !ovl_type_merge_or_lower(dentry
);
793 static char *ovl_get_redirect(struct dentry
*dentry
, bool samedir
)
796 struct dentry
*d
, *tmp
;
797 int buflen
= ovl_redirect_max
+ 1;
800 ret
= kstrndup(dentry
->d_name
.name
, dentry
->d_name
.len
,
805 buf
= ret
= kmalloc(buflen
, GFP_TEMPORARY
);
811 for (d
= dget(dentry
); !IS_ROOT(d
);) {
815 spin_lock(&d
->d_lock
);
816 name
= ovl_dentry_get_redirect(d
);
818 thislen
= strlen(name
);
820 name
= d
->d_name
.name
;
821 thislen
= d
->d_name
.len
;
824 /* If path is too long, fall back to userspace move */
825 if (thislen
+ (name
[0] != '/') > buflen
) {
826 ret
= ERR_PTR(-EXDEV
);
827 spin_unlock(&d
->d_lock
);
832 memcpy(&buf
[buflen
], name
, thislen
);
833 tmp
= dget_dlock(d
->d_parent
);
834 spin_unlock(&d
->d_lock
);
839 /* Absolute redirect: finished */
840 if (buf
[buflen
] == '/')
845 ret
= kstrdup(&buf
[buflen
], GFP_KERNEL
);
850 return ret
? ret
: ERR_PTR(-ENOMEM
);
853 static int ovl_set_redirect(struct dentry
*dentry
, bool samedir
)
856 const char *redirect
= ovl_dentry_get_redirect(dentry
);
858 if (redirect
&& (samedir
|| redirect
[0] == '/'))
861 redirect
= ovl_get_redirect(dentry
, samedir
);
862 if (IS_ERR(redirect
))
863 return PTR_ERR(redirect
);
865 err
= ovl_check_setxattr(dentry
, ovl_dentry_upper(dentry
),
867 redirect
, strlen(redirect
), -EXDEV
);
869 spin_lock(&dentry
->d_lock
);
870 ovl_dentry_set_redirect(dentry
, redirect
);
871 spin_unlock(&dentry
->d_lock
);
874 pr_warn_ratelimited("overlay: failed to set redirect (%i)\n", err
);
875 /* Fall back to userspace copy-up */
881 static int ovl_rename(struct inode
*olddir
, struct dentry
*old
,
882 struct inode
*newdir
, struct dentry
*new,
886 struct dentry
*old_upperdir
;
887 struct dentry
*new_upperdir
;
888 struct dentry
*olddentry
;
889 struct dentry
*newdentry
;
893 bool cleanup_whiteout
= false;
894 bool overwrite
= !(flags
& RENAME_EXCHANGE
);
895 bool is_dir
= d_is_dir(old
);
896 bool new_is_dir
= d_is_dir(new);
897 bool samedir
= olddir
== newdir
;
898 struct dentry
*opaquedir
= NULL
;
899 const struct cred
*old_cred
= NULL
;
902 if (flags
& ~(RENAME_EXCHANGE
| RENAME_NOREPLACE
))
905 flags
&= ~RENAME_NOREPLACE
;
907 /* Don't copy up directory trees */
909 if (!ovl_can_move(old
))
911 if (!overwrite
&& !ovl_can_move(new))
914 err
= ovl_want_write(old
);
918 err
= ovl_copy_up(old
);
922 err
= ovl_copy_up(new->d_parent
);
926 err
= ovl_copy_up(new);
931 old_cred
= ovl_override_creds(old
->d_sb
);
933 if (overwrite
&& new_is_dir
&& ovl_type_merge_or_lower(new)) {
934 opaquedir
= ovl_check_empty_and_clear(new);
935 err
= PTR_ERR(opaquedir
);
936 if (IS_ERR(opaquedir
)) {
938 goto out_revert_creds
;
943 if (ovl_lower_positive(old
)) {
944 if (!ovl_dentry_is_whiteout(new)) {
945 /* Whiteout source */
946 flags
|= RENAME_WHITEOUT
;
948 /* Switch whiteouts */
949 flags
|= RENAME_EXCHANGE
;
951 } else if (is_dir
&& ovl_dentry_is_whiteout(new)) {
952 flags
|= RENAME_EXCHANGE
;
953 cleanup_whiteout
= true;
957 old_upperdir
= ovl_dentry_upper(old
->d_parent
);
958 new_upperdir
= ovl_dentry_upper(new->d_parent
);
962 * When moving a merge dir or non-dir with copy up origin into
963 * a new parent, we are marking the new parent dir "impure".
964 * When ovl_iterate() iterates an "impure" upper dir, it will
965 * lookup the origin inodes of the entries to fill d_ino.
967 if (ovl_type_origin(old
)) {
968 err
= ovl_set_impure(new->d_parent
, new_upperdir
);
970 goto out_revert_creds
;
972 if (!overwrite
&& ovl_type_origin(new)) {
973 err
= ovl_set_impure(old
->d_parent
, old_upperdir
);
975 goto out_revert_creds
;
979 trap
= lock_rename(new_upperdir
, old_upperdir
);
981 olddentry
= lookup_one_len(old
->d_name
.name
, old_upperdir
,
983 err
= PTR_ERR(olddentry
);
984 if (IS_ERR(olddentry
))
988 if (olddentry
!= ovl_dentry_upper(old
))
991 newdentry
= lookup_one_len(new->d_name
.name
, new_upperdir
,
993 err
= PTR_ERR(newdentry
);
994 if (IS_ERR(newdentry
))
997 old_opaque
= ovl_dentry_is_opaque(old
);
998 new_opaque
= ovl_dentry_is_opaque(new);
1001 if (ovl_dentry_upper(new)) {
1003 if (newdentry
!= opaquedir
)
1006 if (newdentry
!= ovl_dentry_upper(new))
1010 if (!d_is_negative(newdentry
) &&
1011 (!new_opaque
|| !ovl_is_whiteout(newdentry
)))
1015 if (olddentry
== trap
)
1017 if (newdentry
== trap
)
1020 if (WARN_ON(olddentry
->d_inode
== newdentry
->d_inode
))
1025 if (ovl_type_merge_or_lower(old
))
1026 err
= ovl_set_redirect(old
, samedir
);
1027 else if (!old_opaque
&& ovl_type_merge(new->d_parent
))
1028 err
= ovl_set_opaque_xerr(old
, olddentry
, -EXDEV
);
1032 if (!overwrite
&& new_is_dir
) {
1033 if (ovl_type_merge_or_lower(new))
1034 err
= ovl_set_redirect(new, samedir
);
1035 else if (!new_opaque
&& ovl_type_merge(old
->d_parent
))
1036 err
= ovl_set_opaque_xerr(new, newdentry
, -EXDEV
);
1041 err
= ovl_do_rename(old_upperdir
->d_inode
, olddentry
,
1042 new_upperdir
->d_inode
, newdentry
, flags
);
1046 if (cleanup_whiteout
)
1047 ovl_cleanup(old_upperdir
->d_inode
, newdentry
);
1049 ovl_dentry_version_inc(old
->d_parent
);
1050 ovl_dentry_version_inc(new->d_parent
);
1057 unlock_rename(new_upperdir
, old_upperdir
);
1059 revert_creds(old_cred
);
1061 ovl_drop_write(old
);
1067 const struct inode_operations ovl_dir_inode_operations
= {
1068 .lookup
= ovl_lookup
,
1070 .symlink
= ovl_symlink
,
1071 .unlink
= ovl_unlink
,
1073 .rename
= ovl_rename
,
1075 .setattr
= ovl_setattr
,
1076 .create
= ovl_create
,
1078 .permission
= ovl_permission
,
1079 .getattr
= ovl_getattr
,
1080 .listxattr
= ovl_listxattr
,
1081 .get_acl
= ovl_get_acl
,
1082 .update_time
= ovl_update_time
,