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
)
487 const struct cred
*old_cred
;
488 struct cred
*override_cred
;
490 err
= ovl_copy_up(dentry
->d_parent
);
494 old_cred
= ovl_override_creds(dentry
->d_sb
);
496 override_cred
= prepare_creds();
498 override_cred
->fsuid
= inode
->i_uid
;
499 override_cred
->fsgid
= inode
->i_gid
;
501 err
= security_dentry_create_files_as(dentry
,
502 attr
->mode
, &dentry
->d_name
, old_cred
,
505 put_cred(override_cred
);
506 goto out_revert_creds
;
509 put_cred(override_creds(override_cred
));
510 put_cred(override_cred
);
512 if (!ovl_dentry_is_whiteout(dentry
))
513 err
= ovl_create_upper(dentry
, inode
, attr
,
516 err
= ovl_create_over_whiteout(dentry
, inode
, attr
,
520 revert_creds(old_cred
);
522 struct inode
*realinode
= d_inode(ovl_dentry_upper(dentry
));
524 WARN_ON(inode
->i_mode
!= realinode
->i_mode
);
525 WARN_ON(!uid_eq(inode
->i_uid
, realinode
->i_uid
));
526 WARN_ON(!gid_eq(inode
->i_gid
, realinode
->i_gid
));
531 static int ovl_create_object(struct dentry
*dentry
, int mode
, dev_t rdev
,
536 struct cattr attr
= {
541 err
= ovl_want_write(dentry
);
546 inode
= ovl_new_inode(dentry
->d_sb
, mode
, rdev
);
550 inode_init_owner(inode
, dentry
->d_parent
->d_inode
, mode
);
551 attr
.mode
= inode
->i_mode
;
553 err
= ovl_create_or_link(dentry
, inode
, &attr
, NULL
);
558 ovl_drop_write(dentry
);
563 static int ovl_create(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
566 return ovl_create_object(dentry
, (mode
& 07777) | S_IFREG
, 0, NULL
);
569 static int ovl_mkdir(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
571 return ovl_create_object(dentry
, (mode
& 07777) | S_IFDIR
, 0, NULL
);
574 static int ovl_mknod(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
577 /* Don't allow creation of "whiteout" on overlay */
578 if (S_ISCHR(mode
) && rdev
== WHITEOUT_DEV
)
581 return ovl_create_object(dentry
, mode
, rdev
, NULL
);
584 static int ovl_symlink(struct inode
*dir
, struct dentry
*dentry
,
587 return ovl_create_object(dentry
, S_IFLNK
, 0, link
);
590 static int ovl_link(struct dentry
*old
, struct inode
*newdir
,
597 err
= ovl_want_write(old
);
601 err
= ovl_copy_up(old
);
605 err
= ovl_nlink_start(old
, &locked
);
609 inode
= d_inode(old
);
612 err
= ovl_create_or_link(new, inode
, NULL
, ovl_dentry_upper(old
));
616 ovl_nlink_end(old
, locked
);
623 static bool ovl_matches_upper(struct dentry
*dentry
, struct dentry
*upper
)
625 return d_inode(ovl_dentry_upper(dentry
)) == d_inode(upper
);
628 static int ovl_remove_and_whiteout(struct dentry
*dentry
, bool is_dir
)
630 struct dentry
*workdir
= ovl_workdir(dentry
);
631 struct inode
*wdir
= workdir
->d_inode
;
632 struct dentry
*upperdir
= ovl_dentry_upper(dentry
->d_parent
);
633 struct inode
*udir
= upperdir
->d_inode
;
634 struct dentry
*whiteout
;
635 struct dentry
*upper
;
636 struct dentry
*opaquedir
= NULL
;
640 if (WARN_ON(!workdir
))
644 opaquedir
= ovl_check_empty_and_clear(dentry
);
645 err
= PTR_ERR(opaquedir
);
646 if (IS_ERR(opaquedir
))
650 err
= ovl_lock_rename_workdir(workdir
, upperdir
);
654 upper
= lookup_one_len(dentry
->d_name
.name
, upperdir
,
656 err
= PTR_ERR(upper
);
661 if ((opaquedir
&& upper
!= opaquedir
) ||
662 (!opaquedir
&& ovl_dentry_upper(dentry
) &&
663 !ovl_matches_upper(dentry
, upper
))) {
667 whiteout
= ovl_whiteout(workdir
, dentry
);
668 err
= PTR_ERR(whiteout
);
669 if (IS_ERR(whiteout
))
673 flags
= RENAME_EXCHANGE
;
675 err
= ovl_do_rename(wdir
, whiteout
, udir
, upper
, flags
);
679 ovl_cleanup(wdir
, upper
);
681 ovl_dentry_version_inc(dentry
->d_parent
);
688 unlock_rename(workdir
, upperdir
);
695 ovl_cleanup(wdir
, whiteout
);
699 static int ovl_remove_upper(struct dentry
*dentry
, bool is_dir
)
701 struct dentry
*upperdir
= ovl_dentry_upper(dentry
->d_parent
);
702 struct inode
*dir
= upperdir
->d_inode
;
703 struct dentry
*upper
;
704 struct dentry
*opaquedir
= NULL
;
707 /* Redirect dir can be !ovl_lower_positive && OVL_TYPE_MERGE */
708 if (is_dir
&& ovl_dentry_get_redirect(dentry
)) {
709 opaquedir
= ovl_check_empty_and_clear(dentry
);
710 err
= PTR_ERR(opaquedir
);
711 if (IS_ERR(opaquedir
))
715 inode_lock_nested(dir
, I_MUTEX_PARENT
);
716 upper
= lookup_one_len(dentry
->d_name
.name
, upperdir
,
718 err
= PTR_ERR(upper
);
723 if ((opaquedir
&& upper
!= opaquedir
) ||
724 (!opaquedir
&& !ovl_matches_upper(dentry
, upper
)))
728 err
= vfs_rmdir(dir
, upper
);
730 err
= vfs_unlink(dir
, upper
, NULL
);
731 ovl_dentry_version_inc(dentry
->d_parent
);
734 * Keeping this dentry hashed would mean having to release
735 * upperpath/lowerpath, which could only be done if we are the
736 * sole user of this dentry. Too tricky... Just unhash for
750 static int ovl_do_remove(struct dentry
*dentry
, bool is_dir
)
754 const struct cred
*old_cred
;
756 err
= ovl_want_write(dentry
);
760 err
= ovl_copy_up(dentry
->d_parent
);
764 err
= ovl_nlink_start(dentry
, &locked
);
768 old_cred
= ovl_override_creds(dentry
->d_sb
);
769 if (!ovl_lower_positive(dentry
))
770 err
= ovl_remove_upper(dentry
, is_dir
);
772 err
= ovl_remove_and_whiteout(dentry
, is_dir
);
773 revert_creds(old_cred
);
776 clear_nlink(dentry
->d_inode
);
778 drop_nlink(dentry
->d_inode
);
780 ovl_nlink_end(dentry
, locked
);
782 ovl_drop_write(dentry
);
787 static int ovl_unlink(struct inode
*dir
, struct dentry
*dentry
)
789 return ovl_do_remove(dentry
, false);
792 static int ovl_rmdir(struct inode
*dir
, struct dentry
*dentry
)
794 return ovl_do_remove(dentry
, true);
797 static bool ovl_type_merge_or_lower(struct dentry
*dentry
)
799 enum ovl_path_type type
= ovl_path_type(dentry
);
801 return OVL_TYPE_MERGE(type
) || !OVL_TYPE_UPPER(type
);
804 static bool ovl_can_move(struct dentry
*dentry
)
806 return ovl_redirect_dir(dentry
->d_sb
) ||
807 !d_is_dir(dentry
) || !ovl_type_merge_or_lower(dentry
);
810 static char *ovl_get_redirect(struct dentry
*dentry
, bool samedir
)
813 struct dentry
*d
, *tmp
;
814 int buflen
= ovl_redirect_max
+ 1;
817 ret
= kstrndup(dentry
->d_name
.name
, dentry
->d_name
.len
,
822 buf
= ret
= kmalloc(buflen
, GFP_TEMPORARY
);
828 for (d
= dget(dentry
); !IS_ROOT(d
);) {
832 spin_lock(&d
->d_lock
);
833 name
= ovl_dentry_get_redirect(d
);
835 thislen
= strlen(name
);
837 name
= d
->d_name
.name
;
838 thislen
= d
->d_name
.len
;
841 /* If path is too long, fall back to userspace move */
842 if (thislen
+ (name
[0] != '/') > buflen
) {
843 ret
= ERR_PTR(-EXDEV
);
844 spin_unlock(&d
->d_lock
);
849 memcpy(&buf
[buflen
], name
, thislen
);
850 tmp
= dget_dlock(d
->d_parent
);
851 spin_unlock(&d
->d_lock
);
856 /* Absolute redirect: finished */
857 if (buf
[buflen
] == '/')
862 ret
= kstrdup(&buf
[buflen
], GFP_KERNEL
);
867 return ret
? ret
: ERR_PTR(-ENOMEM
);
870 static int ovl_set_redirect(struct dentry
*dentry
, bool samedir
)
873 const char *redirect
= ovl_dentry_get_redirect(dentry
);
875 if (redirect
&& (samedir
|| redirect
[0] == '/'))
878 redirect
= ovl_get_redirect(dentry
, samedir
);
879 if (IS_ERR(redirect
))
880 return PTR_ERR(redirect
);
882 err
= ovl_check_setxattr(dentry
, ovl_dentry_upper(dentry
),
884 redirect
, strlen(redirect
), -EXDEV
);
886 spin_lock(&dentry
->d_lock
);
887 ovl_dentry_set_redirect(dentry
, redirect
);
888 spin_unlock(&dentry
->d_lock
);
891 pr_warn_ratelimited("overlay: failed to set redirect (%i)\n", err
);
892 /* Fall back to userspace copy-up */
898 static int ovl_rename(struct inode
*olddir
, struct dentry
*old
,
899 struct inode
*newdir
, struct dentry
*new,
904 struct dentry
*old_upperdir
;
905 struct dentry
*new_upperdir
;
906 struct dentry
*olddentry
;
907 struct dentry
*newdentry
;
911 bool cleanup_whiteout
= false;
912 bool overwrite
= !(flags
& RENAME_EXCHANGE
);
913 bool is_dir
= d_is_dir(old
);
914 bool new_is_dir
= d_is_dir(new);
915 bool samedir
= olddir
== newdir
;
916 struct dentry
*opaquedir
= NULL
;
917 const struct cred
*old_cred
= NULL
;
920 if (flags
& ~(RENAME_EXCHANGE
| RENAME_NOREPLACE
))
923 flags
&= ~RENAME_NOREPLACE
;
925 /* Don't copy up directory trees */
927 if (!ovl_can_move(old
))
929 if (!overwrite
&& !ovl_can_move(new))
932 err
= ovl_want_write(old
);
936 err
= ovl_copy_up(old
);
940 err
= ovl_copy_up(new->d_parent
);
944 err
= ovl_copy_up(new);
948 err
= ovl_nlink_start(new, &locked
);
953 old_cred
= ovl_override_creds(old
->d_sb
);
955 if (overwrite
&& new_is_dir
&& ovl_type_merge_or_lower(new)) {
956 opaquedir
= ovl_check_empty_and_clear(new);
957 err
= PTR_ERR(opaquedir
);
958 if (IS_ERR(opaquedir
)) {
960 goto out_revert_creds
;
965 if (ovl_lower_positive(old
)) {
966 if (!ovl_dentry_is_whiteout(new)) {
967 /* Whiteout source */
968 flags
|= RENAME_WHITEOUT
;
970 /* Switch whiteouts */
971 flags
|= RENAME_EXCHANGE
;
973 } else if (is_dir
&& ovl_dentry_is_whiteout(new)) {
974 flags
|= RENAME_EXCHANGE
;
975 cleanup_whiteout
= true;
979 old_upperdir
= ovl_dentry_upper(old
->d_parent
);
980 new_upperdir
= ovl_dentry_upper(new->d_parent
);
984 * When moving a merge dir or non-dir with copy up origin into
985 * a new parent, we are marking the new parent dir "impure".
986 * When ovl_iterate() iterates an "impure" upper dir, it will
987 * lookup the origin inodes of the entries to fill d_ino.
989 if (ovl_type_origin(old
)) {
990 err
= ovl_set_impure(new->d_parent
, new_upperdir
);
992 goto out_revert_creds
;
994 if (!overwrite
&& ovl_type_origin(new)) {
995 err
= ovl_set_impure(old
->d_parent
, old_upperdir
);
997 goto out_revert_creds
;
1001 trap
= lock_rename(new_upperdir
, old_upperdir
);
1003 olddentry
= lookup_one_len(old
->d_name
.name
, old_upperdir
,
1005 err
= PTR_ERR(olddentry
);
1006 if (IS_ERR(olddentry
))
1010 if (!ovl_matches_upper(old
, olddentry
))
1013 newdentry
= lookup_one_len(new->d_name
.name
, new_upperdir
,
1015 err
= PTR_ERR(newdentry
);
1016 if (IS_ERR(newdentry
))
1019 old_opaque
= ovl_dentry_is_opaque(old
);
1020 new_opaque
= ovl_dentry_is_opaque(new);
1023 if (d_inode(new) && ovl_dentry_upper(new)) {
1025 if (newdentry
!= opaquedir
)
1028 if (!ovl_matches_upper(new, newdentry
))
1032 if (!d_is_negative(newdentry
) &&
1033 (!new_opaque
|| !ovl_is_whiteout(newdentry
)))
1037 if (olddentry
== trap
)
1039 if (newdentry
== trap
)
1042 if (WARN_ON(olddentry
->d_inode
== newdentry
->d_inode
))
1047 if (ovl_type_merge_or_lower(old
))
1048 err
= ovl_set_redirect(old
, samedir
);
1049 else if (!old_opaque
&& ovl_type_merge(new->d_parent
))
1050 err
= ovl_set_opaque_xerr(old
, olddentry
, -EXDEV
);
1054 if (!overwrite
&& new_is_dir
) {
1055 if (ovl_type_merge_or_lower(new))
1056 err
= ovl_set_redirect(new, samedir
);
1057 else if (!new_opaque
&& ovl_type_merge(old
->d_parent
))
1058 err
= ovl_set_opaque_xerr(new, newdentry
, -EXDEV
);
1063 err
= ovl_do_rename(old_upperdir
->d_inode
, olddentry
,
1064 new_upperdir
->d_inode
, newdentry
, flags
);
1068 if (cleanup_whiteout
)
1069 ovl_cleanup(old_upperdir
->d_inode
, newdentry
);
1071 if (overwrite
&& d_inode(new)) {
1073 clear_nlink(d_inode(new));
1075 drop_nlink(d_inode(new));
1078 ovl_dentry_version_inc(old
->d_parent
);
1079 ovl_dentry_version_inc(new->d_parent
);
1086 unlock_rename(new_upperdir
, old_upperdir
);
1088 revert_creds(old_cred
);
1089 ovl_nlink_end(new, locked
);
1091 ovl_drop_write(old
);
1097 const struct inode_operations ovl_dir_inode_operations
= {
1098 .lookup
= ovl_lookup
,
1100 .symlink
= ovl_symlink
,
1101 .unlink
= ovl_unlink
,
1103 .rename
= ovl_rename
,
1105 .setattr
= ovl_setattr
,
1106 .create
= ovl_create
,
1108 .permission
= ovl_permission
,
1109 .getattr
= ovl_getattr
,
1110 .listxattr
= ovl_listxattr
,
1111 .get_acl
= ovl_get_acl
,
1112 .update_time
= ovl_update_time
,