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
, struct dentry
*dentry
)
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
, dentry
);
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(struct dentry
*dentry
, struct dentry
*upperdentry
)
134 err
= ovl_do_setxattr(upperdentry
, OVL_XATTR_OPAQUE
, "y", 1, 0);
136 ovl_dentry_set_opaque(dentry
);
141 static int ovl_dir_getattr(struct vfsmount
*mnt
, struct dentry
*dentry
,
145 enum ovl_path_type type
;
146 struct path realpath
;
147 const struct cred
*old_cred
;
149 type
= ovl_path_real(dentry
, &realpath
);
150 old_cred
= ovl_override_creds(dentry
->d_sb
);
151 err
= vfs_getattr(&realpath
, stat
);
152 revert_creds(old_cred
);
156 stat
->dev
= dentry
->d_sb
->s_dev
;
157 stat
->ino
= dentry
->d_inode
->i_ino
;
160 * It's probably not worth it to count subdirs to get the
161 * correct link count. nlink=1 seems to pacify 'find' and
164 if (OVL_TYPE_MERGE(type
))
170 /* Common operations required to be done after creation of file on upper */
171 static void ovl_instantiate(struct dentry
*dentry
, struct inode
*inode
,
172 struct dentry
*newdentry
, bool hardlink
)
174 ovl_dentry_version_inc(dentry
->d_parent
);
175 ovl_dentry_update(dentry
, newdentry
);
177 ovl_inode_update(inode
, d_inode(newdentry
));
178 ovl_copyattr(newdentry
->d_inode
, inode
);
180 WARN_ON(ovl_inode_real(inode
, NULL
) != d_inode(newdentry
));
183 d_instantiate(dentry
, inode
);
186 static bool ovl_type_merge(struct dentry
*dentry
)
188 return OVL_TYPE_MERGE(ovl_path_type(dentry
));
191 static int ovl_create_upper(struct dentry
*dentry
, struct inode
*inode
,
192 struct cattr
*attr
, struct dentry
*hardlink
)
194 struct dentry
*upperdir
= ovl_dentry_upper(dentry
->d_parent
);
195 struct inode
*udir
= upperdir
->d_inode
;
196 struct dentry
*newdentry
;
199 if (!hardlink
&& !IS_POSIXACL(udir
))
200 attr
->mode
&= ~current_umask();
202 inode_lock_nested(udir
, I_MUTEX_PARENT
);
203 newdentry
= lookup_one_len(dentry
->d_name
.name
, upperdir
,
205 err
= PTR_ERR(newdentry
);
206 if (IS_ERR(newdentry
))
208 err
= ovl_create_real(udir
, newdentry
, attr
, hardlink
, false);
212 if (ovl_type_merge(dentry
->d_parent
)) {
213 /* Setting opaque here is just an optimization, allow to fail */
214 ovl_set_opaque(dentry
, newdentry
);
217 ovl_instantiate(dentry
, inode
, newdentry
, !!hardlink
);
226 static int ovl_lock_rename_workdir(struct dentry
*workdir
,
227 struct dentry
*upperdir
)
229 /* Workdir should not be the same as upperdir */
230 if (workdir
== upperdir
)
233 /* Workdir should not be subdir of upperdir and vice versa */
234 if (lock_rename(workdir
, upperdir
) != NULL
)
240 unlock_rename(workdir
, upperdir
);
242 pr_err("overlayfs: failed to lock workdir+upperdir\n");
246 static struct dentry
*ovl_clear_empty(struct dentry
*dentry
,
247 struct list_head
*list
)
249 struct dentry
*workdir
= ovl_workdir(dentry
);
250 struct inode
*wdir
= workdir
->d_inode
;
251 struct dentry
*upperdir
= ovl_dentry_upper(dentry
->d_parent
);
252 struct inode
*udir
= upperdir
->d_inode
;
253 struct path upperpath
;
254 struct dentry
*upper
;
255 struct dentry
*opaquedir
;
259 if (WARN_ON(!workdir
))
260 return ERR_PTR(-EROFS
);
262 err
= ovl_lock_rename_workdir(workdir
, upperdir
);
266 ovl_path_upper(dentry
, &upperpath
);
267 err
= vfs_getattr(&upperpath
, &stat
);
272 if (!S_ISDIR(stat
.mode
))
274 upper
= upperpath
.dentry
;
275 if (upper
->d_parent
->d_inode
!= udir
)
278 opaquedir
= ovl_lookup_temp(workdir
, dentry
);
279 err
= PTR_ERR(opaquedir
);
280 if (IS_ERR(opaquedir
))
283 err
= ovl_create_real(wdir
, opaquedir
,
284 &(struct cattr
){.mode
= stat
.mode
}, NULL
, true);
288 err
= ovl_copy_xattr(upper
, opaquedir
);
292 err
= ovl_set_opaque(dentry
, opaquedir
);
296 inode_lock(opaquedir
->d_inode
);
297 err
= ovl_set_attr(opaquedir
, &stat
);
298 inode_unlock(opaquedir
->d_inode
);
302 err
= ovl_do_rename(wdir
, opaquedir
, udir
, upper
, RENAME_EXCHANGE
);
306 ovl_cleanup_whiteouts(upper
, list
);
307 ovl_cleanup(wdir
, upper
);
308 unlock_rename(workdir
, upperdir
);
310 /* dentry's upper doesn't match now, get rid of it */
316 ovl_cleanup(wdir
, opaquedir
);
320 unlock_rename(workdir
, upperdir
);
325 static struct dentry
*ovl_check_empty_and_clear(struct dentry
*dentry
)
328 struct dentry
*ret
= NULL
;
329 enum ovl_path_type type
= ovl_path_type(dentry
);
332 err
= ovl_check_empty_dir(dentry
, &list
);
339 * When removing an empty opaque directory, then it makes no sense to
340 * replace it with an exact replica of itself.
342 * If no upperdentry then skip clearing whiteouts.
344 * Can race with copy-up, since we don't hold the upperdir mutex.
345 * Doesn't matter, since copy-up can't create a non-empty directory
348 if (OVL_TYPE_UPPER(type
) && OVL_TYPE_MERGE(type
))
349 ret
= ovl_clear_empty(dentry
, &list
);
352 ovl_cache_free(&list
);
357 static int ovl_set_upper_acl(struct dentry
*upperdentry
, const char *name
,
358 const struct posix_acl
*acl
)
364 if (!IS_ENABLED(CONFIG_FS_POSIX_ACL
) || !acl
)
367 size
= posix_acl_to_xattr(NULL
, acl
, NULL
, 0);
368 buffer
= kmalloc(size
, GFP_KERNEL
);
372 size
= posix_acl_to_xattr(&init_user_ns
, acl
, buffer
, size
);
377 err
= vfs_setxattr(upperdentry
, name
, buffer
, size
, XATTR_CREATE
);
383 static int ovl_create_over_whiteout(struct dentry
*dentry
, struct inode
*inode
,
385 struct dentry
*hardlink
)
387 struct dentry
*workdir
= ovl_workdir(dentry
);
388 struct inode
*wdir
= workdir
->d_inode
;
389 struct dentry
*upperdir
= ovl_dentry_upper(dentry
->d_parent
);
390 struct inode
*udir
= upperdir
->d_inode
;
391 struct dentry
*upper
;
392 struct dentry
*newdentry
;
394 struct posix_acl
*acl
, *default_acl
;
396 if (WARN_ON(!workdir
))
400 err
= posix_acl_create(dentry
->d_parent
->d_inode
,
401 &cattr
->mode
, &default_acl
, &acl
);
406 err
= ovl_lock_rename_workdir(workdir
, upperdir
);
410 newdentry
= ovl_lookup_temp(workdir
, dentry
);
411 err
= PTR_ERR(newdentry
);
412 if (IS_ERR(newdentry
))
415 upper
= lookup_one_len(dentry
->d_name
.name
, upperdir
,
417 err
= PTR_ERR(upper
);
421 err
= ovl_create_real(wdir
, newdentry
, cattr
, hardlink
, true);
426 * mode could have been mutilated due to umask (e.g. sgid directory)
429 !S_ISLNK(cattr
->mode
) &&
430 newdentry
->d_inode
->i_mode
!= cattr
->mode
) {
431 struct iattr attr
= {
432 .ia_valid
= ATTR_MODE
,
433 .ia_mode
= cattr
->mode
,
435 inode_lock(newdentry
->d_inode
);
436 err
= notify_change(newdentry
, &attr
, NULL
);
437 inode_unlock(newdentry
->d_inode
);
442 err
= ovl_set_upper_acl(newdentry
, XATTR_NAME_POSIX_ACL_ACCESS
,
447 err
= ovl_set_upper_acl(newdentry
, XATTR_NAME_POSIX_ACL_DEFAULT
,
453 if (!hardlink
&& S_ISDIR(cattr
->mode
)) {
454 err
= ovl_set_opaque(dentry
, newdentry
);
458 err
= ovl_do_rename(wdir
, newdentry
, udir
, upper
,
463 ovl_cleanup(wdir
, upper
);
465 err
= ovl_do_rename(wdir
, newdentry
, udir
, upper
, 0);
469 ovl_instantiate(dentry
, inode
, newdentry
, !!hardlink
);
476 unlock_rename(workdir
, upperdir
);
479 posix_acl_release(acl
);
480 posix_acl_release(default_acl
);
485 ovl_cleanup(wdir
, newdentry
);
489 static int ovl_create_or_link(struct dentry
*dentry
, struct inode
*inode
,
490 struct cattr
*attr
, struct dentry
*hardlink
)
493 const struct cred
*old_cred
;
494 struct cred
*override_cred
;
496 err
= ovl_copy_up(dentry
->d_parent
);
500 old_cred
= ovl_override_creds(dentry
->d_sb
);
502 override_cred
= prepare_creds();
504 override_cred
->fsuid
= inode
->i_uid
;
505 override_cred
->fsgid
= inode
->i_gid
;
507 err
= security_dentry_create_files_as(dentry
,
508 attr
->mode
, &dentry
->d_name
, old_cred
,
511 put_cred(override_cred
);
512 goto out_revert_creds
;
515 put_cred(override_creds(override_cred
));
516 put_cred(override_cred
);
518 if (!ovl_dentry_is_whiteout(dentry
))
519 err
= ovl_create_upper(dentry
, inode
, attr
,
522 err
= ovl_create_over_whiteout(dentry
, inode
, attr
,
526 revert_creds(old_cred
);
528 struct inode
*realinode
= d_inode(ovl_dentry_upper(dentry
));
530 WARN_ON(inode
->i_mode
!= realinode
->i_mode
);
531 WARN_ON(!uid_eq(inode
->i_uid
, realinode
->i_uid
));
532 WARN_ON(!gid_eq(inode
->i_gid
, realinode
->i_gid
));
537 static int ovl_create_object(struct dentry
*dentry
, int mode
, dev_t rdev
,
542 struct cattr attr
= {
547 err
= ovl_want_write(dentry
);
552 inode
= ovl_new_inode(dentry
->d_sb
, mode
, rdev
);
556 inode_init_owner(inode
, dentry
->d_parent
->d_inode
, mode
);
557 attr
.mode
= inode
->i_mode
;
559 err
= ovl_create_or_link(dentry
, inode
, &attr
, NULL
);
564 ovl_drop_write(dentry
);
569 static int ovl_create(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
572 return ovl_create_object(dentry
, (mode
& 07777) | S_IFREG
, 0, NULL
);
575 static int ovl_mkdir(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
577 return ovl_create_object(dentry
, (mode
& 07777) | S_IFDIR
, 0, NULL
);
580 static int ovl_mknod(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
583 /* Don't allow creation of "whiteout" on overlay */
584 if (S_ISCHR(mode
) && rdev
== WHITEOUT_DEV
)
587 return ovl_create_object(dentry
, mode
, rdev
, NULL
);
590 static int ovl_symlink(struct inode
*dir
, struct dentry
*dentry
,
593 return ovl_create_object(dentry
, S_IFLNK
, 0, link
);
596 static int ovl_link(struct dentry
*old
, struct inode
*newdir
,
602 err
= ovl_want_write(old
);
606 err
= ovl_copy_up(old
);
610 inode
= d_inode(old
);
613 err
= ovl_create_or_link(new, inode
, NULL
, ovl_dentry_upper(old
));
623 static int ovl_remove_and_whiteout(struct dentry
*dentry
, bool is_dir
)
625 struct dentry
*workdir
= ovl_workdir(dentry
);
626 struct inode
*wdir
= workdir
->d_inode
;
627 struct dentry
*upperdir
= ovl_dentry_upper(dentry
->d_parent
);
628 struct inode
*udir
= upperdir
->d_inode
;
629 struct dentry
*whiteout
;
630 struct dentry
*upper
;
631 struct dentry
*opaquedir
= NULL
;
635 if (WARN_ON(!workdir
))
639 opaquedir
= ovl_check_empty_and_clear(dentry
);
640 err
= PTR_ERR(opaquedir
);
641 if (IS_ERR(opaquedir
))
645 err
= ovl_lock_rename_workdir(workdir
, upperdir
);
649 upper
= lookup_one_len(dentry
->d_name
.name
, upperdir
,
651 err
= PTR_ERR(upper
);
656 if ((opaquedir
&& upper
!= opaquedir
) ||
657 (!opaquedir
&& ovl_dentry_upper(dentry
) &&
658 upper
!= ovl_dentry_upper(dentry
))) {
662 whiteout
= ovl_whiteout(workdir
, dentry
);
663 err
= PTR_ERR(whiteout
);
664 if (IS_ERR(whiteout
))
668 flags
= RENAME_EXCHANGE
;
670 err
= ovl_do_rename(wdir
, whiteout
, udir
, upper
, flags
);
674 ovl_cleanup(wdir
, upper
);
676 ovl_dentry_version_inc(dentry
->d_parent
);
683 unlock_rename(workdir
, upperdir
);
690 ovl_cleanup(wdir
, whiteout
);
694 static int ovl_remove_upper(struct dentry
*dentry
, bool is_dir
)
696 struct dentry
*upperdir
= ovl_dentry_upper(dentry
->d_parent
);
697 struct inode
*dir
= upperdir
->d_inode
;
698 struct dentry
*upper
;
699 struct dentry
*opaquedir
= NULL
;
702 /* Redirect dir can be !ovl_lower_positive && OVL_TYPE_MERGE */
703 if (is_dir
&& ovl_dentry_get_redirect(dentry
)) {
704 opaquedir
= ovl_check_empty_and_clear(dentry
);
705 err
= PTR_ERR(opaquedir
);
706 if (IS_ERR(opaquedir
))
710 inode_lock_nested(dir
, I_MUTEX_PARENT
);
711 upper
= lookup_one_len(dentry
->d_name
.name
, upperdir
,
713 err
= PTR_ERR(upper
);
718 if ((opaquedir
&& upper
!= opaquedir
) ||
719 (!opaquedir
&& upper
!= ovl_dentry_upper(dentry
)))
723 err
= vfs_rmdir(dir
, upper
);
725 err
= vfs_unlink(dir
, upper
, NULL
);
726 ovl_dentry_version_inc(dentry
->d_parent
);
729 * Keeping this dentry hashed would mean having to release
730 * upperpath/lowerpath, which could only be done if we are the
731 * sole user of this dentry. Too tricky... Just unhash for
745 static int ovl_do_remove(struct dentry
*dentry
, bool is_dir
)
747 enum ovl_path_type type
;
749 const struct cred
*old_cred
;
751 err
= ovl_want_write(dentry
);
755 err
= ovl_copy_up(dentry
->d_parent
);
759 type
= ovl_path_type(dentry
);
761 old_cred
= ovl_override_creds(dentry
->d_sb
);
762 if (!ovl_lower_positive(dentry
))
763 err
= ovl_remove_upper(dentry
, is_dir
);
765 err
= ovl_remove_and_whiteout(dentry
, is_dir
);
766 revert_creds(old_cred
);
769 clear_nlink(dentry
->d_inode
);
771 drop_nlink(dentry
->d_inode
);
774 ovl_drop_write(dentry
);
779 static int ovl_unlink(struct inode
*dir
, struct dentry
*dentry
)
781 return ovl_do_remove(dentry
, false);
784 static int ovl_rmdir(struct inode
*dir
, struct dentry
*dentry
)
786 return ovl_do_remove(dentry
, true);
789 static bool ovl_type_merge_or_lower(struct dentry
*dentry
)
791 enum ovl_path_type type
= ovl_path_type(dentry
);
793 return OVL_TYPE_MERGE(type
) || !OVL_TYPE_UPPER(type
);
796 static bool ovl_can_move(struct dentry
*dentry
)
798 return ovl_redirect_dir(dentry
->d_sb
) ||
799 !d_is_dir(dentry
) || !ovl_type_merge_or_lower(dentry
);
802 static char *ovl_get_redirect(struct dentry
*dentry
, bool samedir
)
805 struct dentry
*d
, *tmp
;
806 int buflen
= ovl_redirect_max
+ 1;
809 ret
= kstrndup(dentry
->d_name
.name
, dentry
->d_name
.len
,
814 buf
= ret
= kmalloc(buflen
, GFP_TEMPORARY
);
820 for (d
= dget(dentry
); !IS_ROOT(d
);) {
824 spin_lock(&d
->d_lock
);
825 name
= ovl_dentry_get_redirect(d
);
827 thislen
= strlen(name
);
829 name
= d
->d_name
.name
;
830 thislen
= d
->d_name
.len
;
833 /* If path is too long, fall back to userspace move */
834 if (thislen
+ (name
[0] != '/') > buflen
) {
835 ret
= ERR_PTR(-EXDEV
);
836 spin_unlock(&d
->d_lock
);
841 memcpy(&buf
[buflen
], name
, thislen
);
842 tmp
= dget_dlock(d
->d_parent
);
843 spin_unlock(&d
->d_lock
);
848 /* Absolute redirect: finished */
849 if (buf
[buflen
] == '/')
854 ret
= kstrdup(&buf
[buflen
], GFP_KERNEL
);
859 return ret
? ret
: ERR_PTR(-ENOMEM
);
862 static int ovl_set_redirect(struct dentry
*dentry
, bool samedir
)
865 const char *redirect
= ovl_dentry_get_redirect(dentry
);
867 if (redirect
&& (samedir
|| redirect
[0] == '/'))
870 redirect
= ovl_get_redirect(dentry
, samedir
);
871 if (IS_ERR(redirect
))
872 return PTR_ERR(redirect
);
874 err
= ovl_do_setxattr(ovl_dentry_upper(dentry
), OVL_XATTR_REDIRECT
,
875 redirect
, strlen(redirect
), 0);
877 spin_lock(&dentry
->d_lock
);
878 ovl_dentry_set_redirect(dentry
, redirect
);
879 spin_unlock(&dentry
->d_lock
);
882 if (err
== -EOPNOTSUPP
)
883 ovl_clear_redirect_dir(dentry
->d_sb
);
885 pr_warn_ratelimited("overlay: failed to set redirect (%i)\n", err
);
886 /* Fall back to userspace copy-up */
892 static int ovl_rename(struct inode
*olddir
, struct dentry
*old
,
893 struct inode
*newdir
, struct dentry
*new,
897 struct dentry
*old_upperdir
;
898 struct dentry
*new_upperdir
;
899 struct dentry
*olddentry
;
900 struct dentry
*newdentry
;
904 bool cleanup_whiteout
= false;
905 bool overwrite
= !(flags
& RENAME_EXCHANGE
);
906 bool is_dir
= d_is_dir(old
);
907 bool new_is_dir
= d_is_dir(new);
908 bool samedir
= olddir
== newdir
;
909 struct dentry
*opaquedir
= NULL
;
910 const struct cred
*old_cred
= NULL
;
913 if (flags
& ~(RENAME_EXCHANGE
| RENAME_NOREPLACE
))
916 flags
&= ~RENAME_NOREPLACE
;
918 /* Don't copy up directory trees */
920 if (!ovl_can_move(old
))
922 if (!overwrite
&& !ovl_can_move(new))
925 err
= ovl_want_write(old
);
929 err
= ovl_copy_up(old
);
933 err
= ovl_copy_up(new->d_parent
);
937 err
= ovl_copy_up(new);
942 old_cred
= ovl_override_creds(old
->d_sb
);
944 if (overwrite
&& new_is_dir
&& ovl_type_merge_or_lower(new)) {
945 opaquedir
= ovl_check_empty_and_clear(new);
946 err
= PTR_ERR(opaquedir
);
947 if (IS_ERR(opaquedir
)) {
949 goto out_revert_creds
;
954 if (ovl_lower_positive(old
)) {
955 if (!ovl_dentry_is_whiteout(new)) {
956 /* Whiteout source */
957 flags
|= RENAME_WHITEOUT
;
959 /* Switch whiteouts */
960 flags
|= RENAME_EXCHANGE
;
962 } else if (is_dir
&& ovl_dentry_is_whiteout(new)) {
963 flags
|= RENAME_EXCHANGE
;
964 cleanup_whiteout
= true;
968 old_upperdir
= ovl_dentry_upper(old
->d_parent
);
969 new_upperdir
= ovl_dentry_upper(new->d_parent
);
971 trap
= lock_rename(new_upperdir
, old_upperdir
);
973 olddentry
= lookup_one_len(old
->d_name
.name
, old_upperdir
,
975 err
= PTR_ERR(olddentry
);
976 if (IS_ERR(olddentry
))
980 if (olddentry
!= ovl_dentry_upper(old
))
983 newdentry
= lookup_one_len(new->d_name
.name
, new_upperdir
,
985 err
= PTR_ERR(newdentry
);
986 if (IS_ERR(newdentry
))
989 old_opaque
= ovl_dentry_is_opaque(old
);
990 new_opaque
= ovl_dentry_is_opaque(new);
993 if (ovl_dentry_upper(new)) {
995 if (newdentry
!= opaquedir
)
998 if (newdentry
!= ovl_dentry_upper(new))
1002 if (!d_is_negative(newdentry
) &&
1003 (!new_opaque
|| !ovl_is_whiteout(newdentry
)))
1007 if (olddentry
== trap
)
1009 if (newdentry
== trap
)
1012 if (WARN_ON(olddentry
->d_inode
== newdentry
->d_inode
))
1017 if (ovl_type_merge_or_lower(old
))
1018 err
= ovl_set_redirect(old
, samedir
);
1019 else if (!old_opaque
&& ovl_type_merge(new->d_parent
))
1020 err
= ovl_set_opaque(old
, olddentry
);
1024 if (!overwrite
&& new_is_dir
) {
1025 if (ovl_type_merge_or_lower(new))
1026 err
= ovl_set_redirect(new, samedir
);
1027 else if (!new_opaque
&& ovl_type_merge(old
->d_parent
))
1028 err
= ovl_set_opaque(new, newdentry
);
1033 err
= ovl_do_rename(old_upperdir
->d_inode
, olddentry
,
1034 new_upperdir
->d_inode
, newdentry
, flags
);
1038 if (cleanup_whiteout
)
1039 ovl_cleanup(old_upperdir
->d_inode
, newdentry
);
1041 ovl_dentry_version_inc(old
->d_parent
);
1042 ovl_dentry_version_inc(new->d_parent
);
1049 unlock_rename(new_upperdir
, old_upperdir
);
1051 revert_creds(old_cred
);
1053 ovl_drop_write(old
);
1059 const struct inode_operations ovl_dir_inode_operations
= {
1060 .lookup
= ovl_lookup
,
1062 .symlink
= ovl_symlink
,
1063 .unlink
= ovl_unlink
,
1065 .rename
= ovl_rename
,
1067 .setattr
= ovl_setattr
,
1068 .create
= ovl_create
,
1070 .permission
= ovl_permission
,
1071 .getattr
= ovl_dir_getattr
,
1072 .listxattr
= ovl_listxattr
,
1073 .get_acl
= ovl_get_acl
,
1074 .update_time
= ovl_update_time
,