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 int 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",
46 struct dentry
*ovl_lookup_temp(struct dentry
*workdir
)
50 static atomic_t temp_id
= ATOMIC_INIT(0);
52 /* counter is allowed to wrap, since temp dentries are ephemeral */
53 snprintf(name
, sizeof(name
), "#%x", atomic_inc_return(&temp_id
));
55 temp
= lookup_one_len(name
, workdir
, strlen(name
));
56 if (!IS_ERR(temp
) && temp
->d_inode
) {
57 pr_err("overlayfs: workdir/%s already exists\n", name
);
65 /* caller holds i_mutex on workdir */
66 static struct dentry
*ovl_whiteout(struct dentry
*workdir
,
67 struct dentry
*dentry
)
70 struct dentry
*whiteout
;
71 struct inode
*wdir
= workdir
->d_inode
;
73 whiteout
= ovl_lookup_temp(workdir
);
77 err
= ovl_do_whiteout(wdir
, whiteout
);
80 whiteout
= ERR_PTR(err
);
86 int ovl_create_real(struct inode
*dir
, struct dentry
*newdentry
,
87 struct cattr
*attr
, struct dentry
*hardlink
, bool debug
)
91 if (newdentry
->d_inode
)
95 err
= ovl_do_link(hardlink
, dir
, newdentry
, debug
);
97 switch (attr
->mode
& S_IFMT
) {
99 err
= ovl_do_create(dir
, newdentry
, attr
->mode
, debug
);
103 err
= ovl_do_mkdir(dir
, newdentry
, attr
->mode
, debug
);
110 err
= ovl_do_mknod(dir
, newdentry
,
111 attr
->mode
, attr
->rdev
, debug
);
115 err
= ovl_do_symlink(dir
, newdentry
, attr
->link
, debug
);
122 if (!err
&& WARN_ON(!newdentry
->d_inode
)) {
124 * Not quite sure if non-instantiated dentry is legal or not.
125 * VFS doesn't seem to care so check and warn here.
132 static int ovl_set_opaque_xerr(struct dentry
*dentry
, struct dentry
*upper
,
137 err
= ovl_check_setxattr(dentry
, upper
, OVL_XATTR_OPAQUE
, "y", 1, xerr
);
139 ovl_dentry_set_opaque(dentry
);
144 static int ovl_set_opaque(struct dentry
*dentry
, struct dentry
*upperdentry
)
147 * Fail with -EIO when trying to create opaque dir and upper doesn't
148 * support xattrs. ovl_rename() calls ovl_set_opaque_xerr(-EXDEV) to
149 * return a specific error for noxattr case.
151 return ovl_set_opaque_xerr(dentry
, upperdentry
, -EIO
);
154 /* Common operations required to be done after creation of file on upper */
155 static void ovl_instantiate(struct dentry
*dentry
, struct inode
*inode
,
156 struct dentry
*newdentry
, bool hardlink
)
158 ovl_dentry_version_inc(dentry
->d_parent
);
159 ovl_dentry_set_upper_alias(dentry
);
161 ovl_inode_update(inode
, newdentry
);
162 ovl_copyattr(newdentry
->d_inode
, inode
);
164 WARN_ON(ovl_inode_real(inode
) != d_inode(newdentry
));
168 d_instantiate(dentry
, inode
);
169 /* Force lookup of new upper hardlink to find its lower */
174 static bool ovl_type_merge(struct dentry
*dentry
)
176 return OVL_TYPE_MERGE(ovl_path_type(dentry
));
179 static bool ovl_type_origin(struct dentry
*dentry
)
181 return OVL_TYPE_ORIGIN(ovl_path_type(dentry
));
184 static int ovl_create_upper(struct dentry
*dentry
, struct inode
*inode
,
185 struct cattr
*attr
, struct dentry
*hardlink
)
187 struct dentry
*upperdir
= ovl_dentry_upper(dentry
->d_parent
);
188 struct inode
*udir
= upperdir
->d_inode
;
189 struct dentry
*newdentry
;
192 if (!hardlink
&& !IS_POSIXACL(udir
))
193 attr
->mode
&= ~current_umask();
195 inode_lock_nested(udir
, I_MUTEX_PARENT
);
196 newdentry
= lookup_one_len(dentry
->d_name
.name
, upperdir
,
198 err
= PTR_ERR(newdentry
);
199 if (IS_ERR(newdentry
))
201 err
= ovl_create_real(udir
, newdentry
, attr
, hardlink
, false);
205 if (ovl_type_merge(dentry
->d_parent
) && d_is_dir(newdentry
)) {
206 /* Setting opaque here is just an optimization, allow to fail */
207 ovl_set_opaque(dentry
, newdentry
);
210 ovl_instantiate(dentry
, inode
, newdentry
, !!hardlink
);
219 static int ovl_lock_rename_workdir(struct dentry
*workdir
,
220 struct dentry
*upperdir
)
222 /* Workdir should not be the same as upperdir */
223 if (workdir
== upperdir
)
226 /* Workdir should not be subdir of upperdir and vice versa */
227 if (lock_rename(workdir
, upperdir
) != NULL
)
233 unlock_rename(workdir
, upperdir
);
235 pr_err("overlayfs: failed to lock workdir+upperdir\n");
239 static struct dentry
*ovl_clear_empty(struct dentry
*dentry
,
240 struct list_head
*list
)
242 struct dentry
*workdir
= ovl_workdir(dentry
);
243 struct inode
*wdir
= workdir
->d_inode
;
244 struct dentry
*upperdir
= ovl_dentry_upper(dentry
->d_parent
);
245 struct inode
*udir
= upperdir
->d_inode
;
246 struct path upperpath
;
247 struct dentry
*upper
;
248 struct dentry
*opaquedir
;
252 if (WARN_ON(!workdir
))
253 return ERR_PTR(-EROFS
);
255 err
= ovl_lock_rename_workdir(workdir
, upperdir
);
259 ovl_path_upper(dentry
, &upperpath
);
260 err
= vfs_getattr(&upperpath
, &stat
,
261 STATX_BASIC_STATS
, AT_STATX_SYNC_AS_STAT
);
266 if (!S_ISDIR(stat
.mode
))
268 upper
= upperpath
.dentry
;
269 if (upper
->d_parent
->d_inode
!= udir
)
272 opaquedir
= ovl_lookup_temp(workdir
);
273 err
= PTR_ERR(opaquedir
);
274 if (IS_ERR(opaquedir
))
277 err
= ovl_create_real(wdir
, opaquedir
,
278 &(struct cattr
){.mode
= stat
.mode
}, NULL
, true);
282 err
= ovl_copy_xattr(upper
, opaquedir
);
286 err
= ovl_set_opaque(dentry
, opaquedir
);
290 inode_lock(opaquedir
->d_inode
);
291 err
= ovl_set_attr(opaquedir
, &stat
);
292 inode_unlock(opaquedir
->d_inode
);
296 err
= ovl_do_rename(wdir
, opaquedir
, udir
, upper
, RENAME_EXCHANGE
);
300 ovl_cleanup_whiteouts(upper
, list
);
301 ovl_cleanup(wdir
, upper
);
302 unlock_rename(workdir
, upperdir
);
304 /* dentry's upper doesn't match now, get rid of it */
310 ovl_cleanup(wdir
, opaquedir
);
314 unlock_rename(workdir
, upperdir
);
319 static struct dentry
*ovl_check_empty_and_clear(struct dentry
*dentry
)
322 struct dentry
*ret
= NULL
;
323 enum ovl_path_type type
= ovl_path_type(dentry
);
326 err
= ovl_check_empty_dir(dentry
, &list
);
333 * When removing an empty opaque directory, then it makes no sense to
334 * replace it with an exact replica of itself.
336 * If no upperdentry then skip clearing whiteouts.
338 * Can race with copy-up, since we don't hold the upperdir mutex.
339 * Doesn't matter, since copy-up can't create a non-empty directory
342 if (OVL_TYPE_UPPER(type
) && OVL_TYPE_MERGE(type
))
343 ret
= ovl_clear_empty(dentry
, &list
);
346 ovl_cache_free(&list
);
351 static int ovl_set_upper_acl(struct dentry
*upperdentry
, const char *name
,
352 const struct posix_acl
*acl
)
358 if (!IS_ENABLED(CONFIG_FS_POSIX_ACL
) || !acl
)
361 size
= posix_acl_to_xattr(NULL
, acl
, NULL
, 0);
362 buffer
= kmalloc(size
, GFP_KERNEL
);
366 size
= posix_acl_to_xattr(&init_user_ns
, acl
, buffer
, size
);
371 err
= vfs_setxattr(upperdentry
, name
, buffer
, size
, XATTR_CREATE
);
377 static int ovl_create_over_whiteout(struct dentry
*dentry
, struct inode
*inode
,
379 struct dentry
*hardlink
)
381 struct dentry
*workdir
= ovl_workdir(dentry
);
382 struct inode
*wdir
= workdir
->d_inode
;
383 struct dentry
*upperdir
= ovl_dentry_upper(dentry
->d_parent
);
384 struct inode
*udir
= upperdir
->d_inode
;
385 struct dentry
*upper
;
386 struct dentry
*newdentry
;
388 struct posix_acl
*acl
, *default_acl
;
390 if (WARN_ON(!workdir
))
394 err
= posix_acl_create(dentry
->d_parent
->d_inode
,
395 &cattr
->mode
, &default_acl
, &acl
);
400 err
= ovl_lock_rename_workdir(workdir
, upperdir
);
404 newdentry
= ovl_lookup_temp(workdir
);
405 err
= PTR_ERR(newdentry
);
406 if (IS_ERR(newdentry
))
409 upper
= lookup_one_len(dentry
->d_name
.name
, upperdir
,
411 err
= PTR_ERR(upper
);
415 err
= ovl_create_real(wdir
, newdentry
, cattr
, hardlink
, true);
420 * mode could have been mutilated due to umask (e.g. sgid directory)
423 !S_ISLNK(cattr
->mode
) &&
424 newdentry
->d_inode
->i_mode
!= cattr
->mode
) {
425 struct iattr attr
= {
426 .ia_valid
= ATTR_MODE
,
427 .ia_mode
= cattr
->mode
,
429 inode_lock(newdentry
->d_inode
);
430 err
= notify_change(newdentry
, &attr
, NULL
);
431 inode_unlock(newdentry
->d_inode
);
436 err
= ovl_set_upper_acl(newdentry
, XATTR_NAME_POSIX_ACL_ACCESS
,
441 err
= ovl_set_upper_acl(newdentry
, XATTR_NAME_POSIX_ACL_DEFAULT
,
447 if (!hardlink
&& S_ISDIR(cattr
->mode
)) {
448 err
= ovl_set_opaque(dentry
, newdentry
);
452 err
= ovl_do_rename(wdir
, newdentry
, udir
, upper
,
457 ovl_cleanup(wdir
, upper
);
459 err
= ovl_do_rename(wdir
, newdentry
, udir
, upper
, 0);
463 ovl_instantiate(dentry
, inode
, newdentry
, !!hardlink
);
470 unlock_rename(workdir
, upperdir
);
473 posix_acl_release(acl
);
474 posix_acl_release(default_acl
);
479 ovl_cleanup(wdir
, newdentry
);
483 static int ovl_create_or_link(struct dentry
*dentry
, struct inode
*inode
,
484 struct cattr
*attr
, struct dentry
*hardlink
,
488 const struct cred
*old_cred
;
489 struct cred
*override_cred
;
490 struct dentry
*parent
= dentry
->d_parent
;
492 err
= ovl_copy_up(parent
);
496 old_cred
= ovl_override_creds(dentry
->d_sb
);
499 * When linking a file with copy up origin into a new parent, mark the
500 * new parent dir "impure".
503 err
= ovl_set_impure(parent
, ovl_dentry_upper(parent
));
505 goto out_revert_creds
;
509 override_cred
= prepare_creds();
511 override_cred
->fsuid
= inode
->i_uid
;
512 override_cred
->fsgid
= inode
->i_gid
;
514 err
= security_dentry_create_files_as(dentry
,
515 attr
->mode
, &dentry
->d_name
, old_cred
,
518 put_cred(override_cred
);
519 goto out_revert_creds
;
522 put_cred(override_creds(override_cred
));
523 put_cred(override_cred
);
525 if (!ovl_dentry_is_whiteout(dentry
))
526 err
= ovl_create_upper(dentry
, inode
, attr
,
529 err
= ovl_create_over_whiteout(dentry
, inode
, attr
,
533 revert_creds(old_cred
);
535 struct inode
*realinode
= d_inode(ovl_dentry_upper(dentry
));
537 WARN_ON(inode
->i_mode
!= realinode
->i_mode
);
538 WARN_ON(!uid_eq(inode
->i_uid
, realinode
->i_uid
));
539 WARN_ON(!gid_eq(inode
->i_gid
, realinode
->i_gid
));
544 static int ovl_create_object(struct dentry
*dentry
, int mode
, dev_t rdev
,
549 struct cattr attr
= {
554 err
= ovl_want_write(dentry
);
559 inode
= ovl_new_inode(dentry
->d_sb
, mode
, rdev
);
563 inode_init_owner(inode
, dentry
->d_parent
->d_inode
, mode
);
564 attr
.mode
= inode
->i_mode
;
566 err
= ovl_create_or_link(dentry
, inode
, &attr
, NULL
, false);
571 ovl_drop_write(dentry
);
576 static int ovl_create(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
579 return ovl_create_object(dentry
, (mode
& 07777) | S_IFREG
, 0, NULL
);
582 static int ovl_mkdir(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
584 return ovl_create_object(dentry
, (mode
& 07777) | S_IFDIR
, 0, NULL
);
587 static int ovl_mknod(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
590 /* Don't allow creation of "whiteout" on overlay */
591 if (S_ISCHR(mode
) && rdev
== WHITEOUT_DEV
)
594 return ovl_create_object(dentry
, mode
, rdev
, NULL
);
597 static int ovl_symlink(struct inode
*dir
, struct dentry
*dentry
,
600 return ovl_create_object(dentry
, S_IFLNK
, 0, link
);
603 static int ovl_link(struct dentry
*old
, struct inode
*newdir
,
610 err
= ovl_want_write(old
);
614 err
= ovl_copy_up(old
);
618 err
= ovl_nlink_start(old
, &locked
);
622 inode
= d_inode(old
);
625 err
= ovl_create_or_link(new, inode
, NULL
, ovl_dentry_upper(old
),
626 ovl_type_origin(old
));
630 ovl_nlink_end(old
, locked
);
637 static bool ovl_matches_upper(struct dentry
*dentry
, struct dentry
*upper
)
639 return d_inode(ovl_dentry_upper(dentry
)) == d_inode(upper
);
642 static int ovl_remove_and_whiteout(struct dentry
*dentry
, bool is_dir
)
644 struct dentry
*workdir
= ovl_workdir(dentry
);
645 struct inode
*wdir
= workdir
->d_inode
;
646 struct dentry
*upperdir
= ovl_dentry_upper(dentry
->d_parent
);
647 struct inode
*udir
= upperdir
->d_inode
;
648 struct dentry
*whiteout
;
649 struct dentry
*upper
;
650 struct dentry
*opaquedir
= NULL
;
654 if (WARN_ON(!workdir
))
658 opaquedir
= ovl_check_empty_and_clear(dentry
);
659 err
= PTR_ERR(opaquedir
);
660 if (IS_ERR(opaquedir
))
664 err
= ovl_lock_rename_workdir(workdir
, upperdir
);
668 upper
= lookup_one_len(dentry
->d_name
.name
, upperdir
,
670 err
= PTR_ERR(upper
);
675 if ((opaquedir
&& upper
!= opaquedir
) ||
676 (!opaquedir
&& ovl_dentry_upper(dentry
) &&
677 !ovl_matches_upper(dentry
, upper
))) {
681 whiteout
= ovl_whiteout(workdir
, dentry
);
682 err
= PTR_ERR(whiteout
);
683 if (IS_ERR(whiteout
))
687 flags
= RENAME_EXCHANGE
;
689 err
= ovl_do_rename(wdir
, whiteout
, udir
, upper
, flags
);
693 ovl_cleanup(wdir
, upper
);
695 ovl_dentry_version_inc(dentry
->d_parent
);
702 unlock_rename(workdir
, upperdir
);
709 ovl_cleanup(wdir
, whiteout
);
713 static int ovl_remove_upper(struct dentry
*dentry
, bool is_dir
)
715 struct dentry
*upperdir
= ovl_dentry_upper(dentry
->d_parent
);
716 struct inode
*dir
= upperdir
->d_inode
;
717 struct dentry
*upper
;
718 struct dentry
*opaquedir
= NULL
;
721 /* Redirect dir can be !ovl_lower_positive && OVL_TYPE_MERGE */
722 if (is_dir
&& ovl_dentry_get_redirect(dentry
)) {
723 opaquedir
= ovl_check_empty_and_clear(dentry
);
724 err
= PTR_ERR(opaquedir
);
725 if (IS_ERR(opaquedir
))
729 inode_lock_nested(dir
, I_MUTEX_PARENT
);
730 upper
= lookup_one_len(dentry
->d_name
.name
, upperdir
,
732 err
= PTR_ERR(upper
);
737 if ((opaquedir
&& upper
!= opaquedir
) ||
738 (!opaquedir
&& !ovl_matches_upper(dentry
, upper
)))
742 err
= vfs_rmdir(dir
, upper
);
744 err
= vfs_unlink(dir
, upper
, NULL
);
745 ovl_dentry_version_inc(dentry
->d_parent
);
748 * Keeping this dentry hashed would mean having to release
749 * upperpath/lowerpath, which could only be done if we are the
750 * sole user of this dentry. Too tricky... Just unhash for
764 static int ovl_do_remove(struct dentry
*dentry
, bool is_dir
)
768 const struct cred
*old_cred
;
770 err
= ovl_want_write(dentry
);
774 err
= ovl_copy_up(dentry
->d_parent
);
778 err
= ovl_nlink_start(dentry
, &locked
);
782 old_cred
= ovl_override_creds(dentry
->d_sb
);
783 if (!ovl_lower_positive(dentry
))
784 err
= ovl_remove_upper(dentry
, is_dir
);
786 err
= ovl_remove_and_whiteout(dentry
, is_dir
);
787 revert_creds(old_cred
);
790 clear_nlink(dentry
->d_inode
);
792 drop_nlink(dentry
->d_inode
);
794 ovl_nlink_end(dentry
, locked
);
796 ovl_drop_write(dentry
);
801 static int ovl_unlink(struct inode
*dir
, struct dentry
*dentry
)
803 return ovl_do_remove(dentry
, false);
806 static int ovl_rmdir(struct inode
*dir
, struct dentry
*dentry
)
808 return ovl_do_remove(dentry
, true);
811 static bool ovl_type_merge_or_lower(struct dentry
*dentry
)
813 enum ovl_path_type type
= ovl_path_type(dentry
);
815 return OVL_TYPE_MERGE(type
) || !OVL_TYPE_UPPER(type
);
818 static bool ovl_can_move(struct dentry
*dentry
)
820 return ovl_redirect_dir(dentry
->d_sb
) ||
821 !d_is_dir(dentry
) || !ovl_type_merge_or_lower(dentry
);
824 static char *ovl_get_redirect(struct dentry
*dentry
, bool samedir
)
827 struct dentry
*d
, *tmp
;
828 int buflen
= ovl_redirect_max
+ 1;
831 ret
= kstrndup(dentry
->d_name
.name
, dentry
->d_name
.len
,
836 buf
= ret
= kmalloc(buflen
, GFP_TEMPORARY
);
842 for (d
= dget(dentry
); !IS_ROOT(d
);) {
846 spin_lock(&d
->d_lock
);
847 name
= ovl_dentry_get_redirect(d
);
849 thislen
= strlen(name
);
851 name
= d
->d_name
.name
;
852 thislen
= d
->d_name
.len
;
855 /* If path is too long, fall back to userspace move */
856 if (thislen
+ (name
[0] != '/') > buflen
) {
857 ret
= ERR_PTR(-EXDEV
);
858 spin_unlock(&d
->d_lock
);
863 memcpy(&buf
[buflen
], name
, thislen
);
864 tmp
= dget_dlock(d
->d_parent
);
865 spin_unlock(&d
->d_lock
);
870 /* Absolute redirect: finished */
871 if (buf
[buflen
] == '/')
876 ret
= kstrdup(&buf
[buflen
], GFP_KERNEL
);
881 return ret
? ret
: ERR_PTR(-ENOMEM
);
884 static int ovl_set_redirect(struct dentry
*dentry
, bool samedir
)
887 const char *redirect
= ovl_dentry_get_redirect(dentry
);
889 if (redirect
&& (samedir
|| redirect
[0] == '/'))
892 redirect
= ovl_get_redirect(dentry
, samedir
);
893 if (IS_ERR(redirect
))
894 return PTR_ERR(redirect
);
896 err
= ovl_check_setxattr(dentry
, ovl_dentry_upper(dentry
),
898 redirect
, strlen(redirect
), -EXDEV
);
900 spin_lock(&dentry
->d_lock
);
901 ovl_dentry_set_redirect(dentry
, redirect
);
902 spin_unlock(&dentry
->d_lock
);
905 pr_warn_ratelimited("overlay: failed to set redirect (%i)\n", err
);
906 /* Fall back to userspace copy-up */
912 static int ovl_rename(struct inode
*olddir
, struct dentry
*old
,
913 struct inode
*newdir
, struct dentry
*new,
918 struct dentry
*old_upperdir
;
919 struct dentry
*new_upperdir
;
920 struct dentry
*olddentry
;
921 struct dentry
*newdentry
;
925 bool cleanup_whiteout
= false;
926 bool overwrite
= !(flags
& RENAME_EXCHANGE
);
927 bool is_dir
= d_is_dir(old
);
928 bool new_is_dir
= d_is_dir(new);
929 bool samedir
= olddir
== newdir
;
930 struct dentry
*opaquedir
= NULL
;
931 const struct cred
*old_cred
= NULL
;
934 if (flags
& ~(RENAME_EXCHANGE
| RENAME_NOREPLACE
))
937 flags
&= ~RENAME_NOREPLACE
;
939 /* Don't copy up directory trees */
941 if (!ovl_can_move(old
))
943 if (!overwrite
&& !ovl_can_move(new))
946 err
= ovl_want_write(old
);
950 err
= ovl_copy_up(old
);
954 err
= ovl_copy_up(new->d_parent
);
958 err
= ovl_copy_up(new);
962 err
= ovl_nlink_start(new, &locked
);
967 old_cred
= ovl_override_creds(old
->d_sb
);
969 if (overwrite
&& new_is_dir
&& ovl_type_merge_or_lower(new)) {
970 opaquedir
= ovl_check_empty_and_clear(new);
971 err
= PTR_ERR(opaquedir
);
972 if (IS_ERR(opaquedir
)) {
974 goto out_revert_creds
;
979 if (ovl_lower_positive(old
)) {
980 if (!ovl_dentry_is_whiteout(new)) {
981 /* Whiteout source */
982 flags
|= RENAME_WHITEOUT
;
984 /* Switch whiteouts */
985 flags
|= RENAME_EXCHANGE
;
987 } else if (is_dir
&& ovl_dentry_is_whiteout(new)) {
988 flags
|= RENAME_EXCHANGE
;
989 cleanup_whiteout
= true;
993 old_upperdir
= ovl_dentry_upper(old
->d_parent
);
994 new_upperdir
= ovl_dentry_upper(new->d_parent
);
998 * When moving a merge dir or non-dir with copy up origin into
999 * a new parent, we are marking the new parent dir "impure".
1000 * When ovl_iterate() iterates an "impure" upper dir, it will
1001 * lookup the origin inodes of the entries to fill d_ino.
1003 if (ovl_type_origin(old
)) {
1004 err
= ovl_set_impure(new->d_parent
, new_upperdir
);
1006 goto out_revert_creds
;
1008 if (!overwrite
&& ovl_type_origin(new)) {
1009 err
= ovl_set_impure(old
->d_parent
, old_upperdir
);
1011 goto out_revert_creds
;
1015 trap
= lock_rename(new_upperdir
, old_upperdir
);
1017 olddentry
= lookup_one_len(old
->d_name
.name
, old_upperdir
,
1019 err
= PTR_ERR(olddentry
);
1020 if (IS_ERR(olddentry
))
1024 if (!ovl_matches_upper(old
, olddentry
))
1027 newdentry
= lookup_one_len(new->d_name
.name
, new_upperdir
,
1029 err
= PTR_ERR(newdentry
);
1030 if (IS_ERR(newdentry
))
1033 old_opaque
= ovl_dentry_is_opaque(old
);
1034 new_opaque
= ovl_dentry_is_opaque(new);
1037 if (d_inode(new) && ovl_dentry_upper(new)) {
1039 if (newdentry
!= opaquedir
)
1042 if (!ovl_matches_upper(new, newdentry
))
1046 if (!d_is_negative(newdentry
) &&
1047 (!new_opaque
|| !ovl_is_whiteout(newdentry
)))
1051 if (olddentry
== trap
)
1053 if (newdentry
== trap
)
1056 if (WARN_ON(olddentry
->d_inode
== newdentry
->d_inode
))
1061 if (ovl_type_merge_or_lower(old
))
1062 err
= ovl_set_redirect(old
, samedir
);
1063 else if (!old_opaque
&& ovl_type_merge(new->d_parent
))
1064 err
= ovl_set_opaque_xerr(old
, olddentry
, -EXDEV
);
1068 if (!overwrite
&& new_is_dir
) {
1069 if (ovl_type_merge_or_lower(new))
1070 err
= ovl_set_redirect(new, samedir
);
1071 else if (!new_opaque
&& ovl_type_merge(old
->d_parent
))
1072 err
= ovl_set_opaque_xerr(new, newdentry
, -EXDEV
);
1077 err
= ovl_do_rename(old_upperdir
->d_inode
, olddentry
,
1078 new_upperdir
->d_inode
, newdentry
, flags
);
1082 if (cleanup_whiteout
)
1083 ovl_cleanup(old_upperdir
->d_inode
, newdentry
);
1085 if (overwrite
&& d_inode(new)) {
1087 clear_nlink(d_inode(new));
1089 drop_nlink(d_inode(new));
1092 ovl_dentry_version_inc(old
->d_parent
);
1093 ovl_dentry_version_inc(new->d_parent
);
1100 unlock_rename(new_upperdir
, old_upperdir
);
1102 revert_creds(old_cred
);
1103 ovl_nlink_end(new, locked
);
1105 ovl_drop_write(old
);
1111 const struct inode_operations ovl_dir_inode_operations
= {
1112 .lookup
= ovl_lookup
,
1114 .symlink
= ovl_symlink
,
1115 .unlink
= ovl_unlink
,
1117 .rename
= ovl_rename
,
1119 .setattr
= ovl_setattr
,
1120 .create
= ovl_create
,
1122 .permission
= ovl_permission
,
1123 .getattr
= ovl_getattr
,
1124 .listxattr
= ovl_listxattr
,
1125 .get_acl
= ovl_get_acl
,
1126 .update_time
= ovl_update_time
,