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 "overlayfs.h"
17 void ovl_cleanup(struct inode
*wdir
, struct dentry
*wdentry
)
22 if (d_is_dir(wdentry
))
23 err
= ovl_do_rmdir(wdir
, wdentry
);
25 err
= ovl_do_unlink(wdir
, wdentry
);
29 pr_err("overlayfs: cleanup of '%pd2' failed (%i)\n",
34 struct dentry
*ovl_lookup_temp(struct dentry
*workdir
, struct dentry
*dentry
)
39 snprintf(name
, sizeof(name
), "#%lx", (unsigned long) dentry
);
41 temp
= lookup_one_len(name
, workdir
, strlen(name
));
42 if (!IS_ERR(temp
) && temp
->d_inode
) {
43 pr_err("overlayfs: workdir/%s already exists\n", name
);
51 /* caller holds i_mutex on workdir */
52 static struct dentry
*ovl_whiteout(struct dentry
*workdir
,
53 struct dentry
*dentry
)
56 struct dentry
*whiteout
;
57 struct inode
*wdir
= workdir
->d_inode
;
59 whiteout
= ovl_lookup_temp(workdir
, dentry
);
63 err
= ovl_do_whiteout(wdir
, whiteout
);
66 whiteout
= ERR_PTR(err
);
72 int ovl_create_real(struct inode
*dir
, struct dentry
*newdentry
,
73 struct kstat
*stat
, const char *link
,
74 struct dentry
*hardlink
, bool debug
)
78 if (newdentry
->d_inode
)
82 err
= ovl_do_link(hardlink
, dir
, newdentry
, debug
);
84 switch (stat
->mode
& S_IFMT
) {
86 err
= ovl_do_create(dir
, newdentry
, stat
->mode
, debug
);
90 err
= ovl_do_mkdir(dir
, newdentry
, stat
->mode
, debug
);
97 err
= ovl_do_mknod(dir
, newdentry
,
98 stat
->mode
, stat
->rdev
, debug
);
102 err
= ovl_do_symlink(dir
, newdentry
, link
, debug
);
109 if (!err
&& WARN_ON(!newdentry
->d_inode
)) {
111 * Not quite sure if non-instantiated dentry is legal or not.
112 * VFS doesn't seem to care so check and warn here.
119 static int ovl_set_opaque(struct dentry
*upperdentry
)
121 return ovl_do_setxattr(upperdentry
, OVL_XATTR_OPAQUE
, "y", 1, 0);
124 static void ovl_remove_opaque(struct dentry
*upperdentry
)
128 err
= ovl_do_removexattr(upperdentry
, OVL_XATTR_OPAQUE
);
130 pr_warn("overlayfs: failed to remove opaque from '%s' (%i)\n",
131 upperdentry
->d_name
.name
, err
);
135 static int ovl_dir_getattr(struct vfsmount
*mnt
, struct dentry
*dentry
,
139 enum ovl_path_type type
;
140 struct path realpath
;
141 const struct cred
*old_cred
;
143 type
= ovl_path_real(dentry
, &realpath
);
144 old_cred
= ovl_override_creds(dentry
->d_sb
);
145 err
= vfs_getattr(&realpath
, stat
);
146 revert_creds(old_cred
);
150 stat
->dev
= dentry
->d_sb
->s_dev
;
151 stat
->ino
= dentry
->d_inode
->i_ino
;
154 * It's probably not worth it to count subdirs to get the
155 * correct link count. nlink=1 seems to pacify 'find' and
158 if (OVL_TYPE_MERGE(type
))
164 /* Common operations required to be done after creation of file on upper */
165 static void ovl_instantiate(struct dentry
*dentry
, struct inode
*inode
,
166 struct dentry
*newdentry
, bool hardlink
)
168 ovl_dentry_version_inc(dentry
->d_parent
);
169 ovl_dentry_update(dentry
, newdentry
);
171 ovl_inode_update(inode
, d_inode(newdentry
));
172 ovl_copyattr(newdentry
->d_inode
, inode
);
174 WARN_ON(ovl_inode_real(inode
, NULL
) != d_inode(newdentry
));
177 d_instantiate(dentry
, inode
);
180 static int ovl_create_upper(struct dentry
*dentry
, struct inode
*inode
,
181 struct kstat
*stat
, const char *link
,
182 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 inode_lock_nested(udir
, I_MUTEX_PARENT
);
190 newdentry
= lookup_one_len(dentry
->d_name
.name
, upperdir
,
192 err
= PTR_ERR(newdentry
);
193 if (IS_ERR(newdentry
))
195 err
= ovl_create_real(udir
, newdentry
, stat
, link
, hardlink
, false);
199 ovl_instantiate(dentry
, inode
, newdentry
, !!hardlink
);
208 static int ovl_lock_rename_workdir(struct dentry
*workdir
,
209 struct dentry
*upperdir
)
211 /* Workdir should not be the same as upperdir */
212 if (workdir
== upperdir
)
215 /* Workdir should not be subdir of upperdir and vice versa */
216 if (lock_rename(workdir
, upperdir
) != NULL
)
222 unlock_rename(workdir
, upperdir
);
224 pr_err("overlayfs: failed to lock workdir+upperdir\n");
228 static struct dentry
*ovl_clear_empty(struct dentry
*dentry
,
229 struct list_head
*list
)
231 struct dentry
*workdir
= ovl_workdir(dentry
);
232 struct inode
*wdir
= workdir
->d_inode
;
233 struct dentry
*upperdir
= ovl_dentry_upper(dentry
->d_parent
);
234 struct inode
*udir
= upperdir
->d_inode
;
235 struct path upperpath
;
236 struct dentry
*upper
;
237 struct dentry
*opaquedir
;
241 if (WARN_ON(!workdir
))
242 return ERR_PTR(-EROFS
);
244 err
= ovl_lock_rename_workdir(workdir
, upperdir
);
248 ovl_path_upper(dentry
, &upperpath
);
249 err
= vfs_getattr(&upperpath
, &stat
);
254 if (!S_ISDIR(stat
.mode
))
256 upper
= upperpath
.dentry
;
257 if (upper
->d_parent
->d_inode
!= udir
)
260 opaquedir
= ovl_lookup_temp(workdir
, dentry
);
261 err
= PTR_ERR(opaquedir
);
262 if (IS_ERR(opaquedir
))
265 err
= ovl_create_real(wdir
, opaquedir
, &stat
, NULL
, NULL
, true);
269 err
= ovl_copy_xattr(upper
, opaquedir
);
273 err
= ovl_set_opaque(opaquedir
);
277 inode_lock(opaquedir
->d_inode
);
278 err
= ovl_set_attr(opaquedir
, &stat
);
279 inode_unlock(opaquedir
->d_inode
);
283 err
= ovl_do_rename(wdir
, opaquedir
, udir
, upper
, RENAME_EXCHANGE
);
287 ovl_cleanup_whiteouts(upper
, list
);
288 ovl_cleanup(wdir
, upper
);
289 unlock_rename(workdir
, upperdir
);
291 /* dentry's upper doesn't match now, get rid of it */
297 ovl_cleanup(wdir
, opaquedir
);
301 unlock_rename(workdir
, upperdir
);
306 static struct dentry
*ovl_check_empty_and_clear(struct dentry
*dentry
)
309 struct dentry
*ret
= NULL
;
310 enum ovl_path_type type
= ovl_path_type(dentry
);
313 err
= ovl_check_empty_dir(dentry
, &list
);
320 * When removing an empty opaque directory, then it makes no sense to
321 * replace it with an exact replica of itself.
323 * If no upperdentry then skip clearing whiteouts.
325 * Can race with copy-up, since we don't hold the upperdir mutex.
326 * Doesn't matter, since copy-up can't create a non-empty directory
329 if (OVL_TYPE_UPPER(type
) && OVL_TYPE_MERGE(type
))
330 ret
= ovl_clear_empty(dentry
, &list
);
333 ovl_cache_free(&list
);
338 static int ovl_create_over_whiteout(struct dentry
*dentry
, struct inode
*inode
,
339 struct kstat
*stat
, const char *link
,
340 struct dentry
*hardlink
)
342 struct dentry
*workdir
= ovl_workdir(dentry
);
343 struct inode
*wdir
= workdir
->d_inode
;
344 struct dentry
*upperdir
= ovl_dentry_upper(dentry
->d_parent
);
345 struct inode
*udir
= upperdir
->d_inode
;
346 struct dentry
*upper
;
347 struct dentry
*newdentry
;
350 if (WARN_ON(!workdir
))
353 err
= ovl_lock_rename_workdir(workdir
, upperdir
);
357 newdentry
= ovl_lookup_temp(workdir
, dentry
);
358 err
= PTR_ERR(newdentry
);
359 if (IS_ERR(newdentry
))
362 upper
= lookup_one_len(dentry
->d_name
.name
, upperdir
,
364 err
= PTR_ERR(upper
);
368 err
= ovl_create_real(wdir
, newdentry
, stat
, link
, hardlink
, true);
373 * mode could have been mutilated due to umask (e.g. sgid directory)
376 !S_ISLNK(stat
->mode
) && newdentry
->d_inode
->i_mode
!= stat
->mode
) {
377 struct iattr attr
= {
378 .ia_valid
= ATTR_MODE
,
379 .ia_mode
= stat
->mode
,
381 inode_lock(newdentry
->d_inode
);
382 err
= notify_change(newdentry
, &attr
, NULL
);
383 inode_unlock(newdentry
->d_inode
);
388 if (!hardlink
&& S_ISDIR(stat
->mode
)) {
389 err
= ovl_set_opaque(newdentry
);
393 err
= ovl_do_rename(wdir
, newdentry
, udir
, upper
,
398 ovl_cleanup(wdir
, upper
);
400 err
= ovl_do_rename(wdir
, newdentry
, udir
, upper
, 0);
404 ovl_instantiate(dentry
, inode
, newdentry
, !!hardlink
);
411 unlock_rename(workdir
, upperdir
);
416 ovl_cleanup(wdir
, newdentry
);
420 static int ovl_create_or_link(struct dentry
*dentry
, struct inode
*inode
,
421 struct kstat
*stat
, const char *link
,
422 struct dentry
*hardlink
)
425 const struct cred
*old_cred
;
426 struct cred
*override_cred
;
428 err
= ovl_copy_up(dentry
->d_parent
);
432 old_cred
= ovl_override_creds(dentry
->d_sb
);
434 override_cred
= prepare_creds();
436 override_cred
->fsuid
= inode
->i_uid
;
437 override_cred
->fsgid
= inode
->i_gid
;
438 put_cred(override_creds(override_cred
));
439 put_cred(override_cred
);
441 if (!ovl_dentry_is_opaque(dentry
))
442 err
= ovl_create_upper(dentry
, inode
, stat
, link
,
445 err
= ovl_create_over_whiteout(dentry
, inode
, stat
,
448 revert_creds(old_cred
);
450 struct inode
*realinode
= d_inode(ovl_dentry_upper(dentry
));
452 WARN_ON(inode
->i_mode
!= realinode
->i_mode
);
453 WARN_ON(!uid_eq(inode
->i_uid
, realinode
->i_uid
));
454 WARN_ON(!gid_eq(inode
->i_gid
, realinode
->i_gid
));
459 static int ovl_create_object(struct dentry
*dentry
, int mode
, dev_t rdev
,
464 struct kstat stat
= {
468 err
= ovl_want_write(dentry
);
473 inode
= ovl_new_inode(dentry
->d_sb
, mode
);
477 inode_init_owner(inode
, dentry
->d_parent
->d_inode
, mode
);
478 stat
.mode
= inode
->i_mode
;
480 err
= ovl_create_or_link(dentry
, inode
, &stat
, link
, NULL
);
485 ovl_drop_write(dentry
);
490 static int ovl_create(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
493 return ovl_create_object(dentry
, (mode
& 07777) | S_IFREG
, 0, NULL
);
496 static int ovl_mkdir(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
498 return ovl_create_object(dentry
, (mode
& 07777) | S_IFDIR
, 0, NULL
);
501 static int ovl_mknod(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
504 /* Don't allow creation of "whiteout" on overlay */
505 if (S_ISCHR(mode
) && rdev
== WHITEOUT_DEV
)
508 return ovl_create_object(dentry
, mode
, rdev
, NULL
);
511 static int ovl_symlink(struct inode
*dir
, struct dentry
*dentry
,
514 return ovl_create_object(dentry
, S_IFLNK
, 0, link
);
517 static int ovl_link(struct dentry
*old
, struct inode
*newdir
,
523 err
= ovl_want_write(old
);
527 err
= ovl_copy_up(old
);
531 inode
= d_inode(old
);
534 err
= ovl_create_or_link(new, inode
, NULL
, NULL
, ovl_dentry_upper(old
));
544 static int ovl_remove_and_whiteout(struct dentry
*dentry
, bool is_dir
)
546 struct dentry
*workdir
= ovl_workdir(dentry
);
547 struct inode
*wdir
= workdir
->d_inode
;
548 struct dentry
*upperdir
= ovl_dentry_upper(dentry
->d_parent
);
549 struct inode
*udir
= upperdir
->d_inode
;
550 struct dentry
*whiteout
;
551 struct dentry
*upper
;
552 struct dentry
*opaquedir
= NULL
;
556 if (WARN_ON(!workdir
))
560 opaquedir
= ovl_check_empty_and_clear(dentry
);
561 err
= PTR_ERR(opaquedir
);
562 if (IS_ERR(opaquedir
))
566 err
= ovl_lock_rename_workdir(workdir
, upperdir
);
570 upper
= lookup_one_len(dentry
->d_name
.name
, upperdir
,
572 err
= PTR_ERR(upper
);
577 if ((opaquedir
&& upper
!= opaquedir
) ||
578 (!opaquedir
&& ovl_dentry_upper(dentry
) &&
579 upper
!= ovl_dentry_upper(dentry
))) {
583 whiteout
= ovl_whiteout(workdir
, dentry
);
584 err
= PTR_ERR(whiteout
);
585 if (IS_ERR(whiteout
))
589 flags
= RENAME_EXCHANGE
;
591 err
= ovl_do_rename(wdir
, whiteout
, udir
, upper
, flags
);
595 ovl_cleanup(wdir
, upper
);
597 ovl_dentry_version_inc(dentry
->d_parent
);
604 unlock_rename(workdir
, upperdir
);
611 ovl_cleanup(wdir
, whiteout
);
615 static int ovl_remove_upper(struct dentry
*dentry
, bool is_dir
)
617 struct dentry
*upperdir
= ovl_dentry_upper(dentry
->d_parent
);
618 struct inode
*dir
= upperdir
->d_inode
;
619 struct dentry
*upper
;
622 inode_lock_nested(dir
, I_MUTEX_PARENT
);
623 upper
= lookup_one_len(dentry
->d_name
.name
, upperdir
,
625 err
= PTR_ERR(upper
);
630 if (upper
== ovl_dentry_upper(dentry
)) {
632 err
= vfs_rmdir(dir
, upper
);
634 err
= vfs_unlink(dir
, upper
, NULL
);
635 ovl_dentry_version_inc(dentry
->d_parent
);
640 * Keeping this dentry hashed would mean having to release
641 * upperpath/lowerpath, which could only be done if we are the
642 * sole user of this dentry. Too tricky... Just unhash for
653 static inline int ovl_check_sticky(struct dentry
*dentry
)
655 struct inode
*dir
= ovl_dentry_real(dentry
->d_parent
)->d_inode
;
656 struct inode
*inode
= ovl_dentry_real(dentry
)->d_inode
;
658 if (check_sticky(dir
, inode
))
664 static int ovl_do_remove(struct dentry
*dentry
, bool is_dir
)
666 enum ovl_path_type type
;
668 const struct cred
*old_cred
;
671 err
= ovl_check_sticky(dentry
);
675 err
= ovl_want_write(dentry
);
679 err
= ovl_copy_up(dentry
->d_parent
);
683 type
= ovl_path_type(dentry
);
685 old_cred
= ovl_override_creds(dentry
->d_sb
);
686 if (OVL_TYPE_PURE_UPPER(type
))
687 err
= ovl_remove_upper(dentry
, is_dir
);
689 err
= ovl_remove_and_whiteout(dentry
, is_dir
);
690 revert_creds(old_cred
);
693 clear_nlink(dentry
->d_inode
);
695 drop_nlink(dentry
->d_inode
);
698 ovl_drop_write(dentry
);
703 static int ovl_unlink(struct inode
*dir
, struct dentry
*dentry
)
705 return ovl_do_remove(dentry
, false);
708 static int ovl_rmdir(struct inode
*dir
, struct dentry
*dentry
)
710 return ovl_do_remove(dentry
, true);
713 static int ovl_rename2(struct inode
*olddir
, struct dentry
*old
,
714 struct inode
*newdir
, struct dentry
*new,
718 enum ovl_path_type old_type
;
719 enum ovl_path_type new_type
;
720 struct dentry
*old_upperdir
;
721 struct dentry
*new_upperdir
;
722 struct dentry
*olddentry
;
723 struct dentry
*newdentry
;
727 bool cleanup_whiteout
= false;
728 bool overwrite
= !(flags
& RENAME_EXCHANGE
);
729 bool is_dir
= d_is_dir(old
);
730 bool new_is_dir
= false;
731 struct dentry
*opaquedir
= NULL
;
732 const struct cred
*old_cred
= NULL
;
735 if (flags
& ~(RENAME_EXCHANGE
| RENAME_NOREPLACE
))
738 flags
&= ~RENAME_NOREPLACE
;
740 err
= ovl_check_sticky(old
);
744 /* Don't copy up directory trees */
745 old_type
= ovl_path_type(old
);
747 if (OVL_TYPE_MERGE_OR_LOWER(old_type
) && is_dir
)
751 err
= ovl_check_sticky(new);
758 new_type
= ovl_path_type(new);
760 if (!overwrite
&& OVL_TYPE_MERGE_OR_LOWER(new_type
) && new_is_dir
)
764 if (!OVL_TYPE_UPPER(new_type
) && !OVL_TYPE_UPPER(old_type
)) {
765 if (ovl_dentry_lower(old
)->d_inode
==
766 ovl_dentry_lower(new)->d_inode
)
769 if (OVL_TYPE_UPPER(new_type
) && OVL_TYPE_UPPER(old_type
)) {
770 if (ovl_dentry_upper(old
)->d_inode
==
771 ovl_dentry_upper(new)->d_inode
)
775 if (ovl_dentry_is_opaque(new))
776 new_type
= __OVL_PATH_UPPER
;
778 new_type
= __OVL_PATH_UPPER
| __OVL_PATH_PURE
;
781 err
= ovl_want_write(old
);
785 err
= ovl_copy_up(old
);
789 err
= ovl_copy_up(new->d_parent
);
793 err
= ovl_copy_up(new);
798 old_opaque
= !OVL_TYPE_PURE_UPPER(old_type
);
799 new_opaque
= !OVL_TYPE_PURE_UPPER(new_type
);
801 old_cred
= ovl_override_creds(old
->d_sb
);
803 if (overwrite
&& OVL_TYPE_MERGE_OR_LOWER(new_type
) && new_is_dir
) {
804 opaquedir
= ovl_check_empty_and_clear(new);
805 err
= PTR_ERR(opaquedir
);
806 if (IS_ERR(opaquedir
)) {
808 goto out_revert_creds
;
814 if (new->d_inode
|| !new_opaque
) {
815 /* Whiteout source */
816 flags
|= RENAME_WHITEOUT
;
818 /* Switch whiteouts */
819 flags
|= RENAME_EXCHANGE
;
821 } else if (is_dir
&& !new->d_inode
&& new_opaque
) {
822 flags
|= RENAME_EXCHANGE
;
823 cleanup_whiteout
= true;
827 old_upperdir
= ovl_dentry_upper(old
->d_parent
);
828 new_upperdir
= ovl_dentry_upper(new->d_parent
);
830 trap
= lock_rename(new_upperdir
, old_upperdir
);
833 olddentry
= lookup_one_len(old
->d_name
.name
, old_upperdir
,
835 err
= PTR_ERR(olddentry
);
836 if (IS_ERR(olddentry
))
840 if (olddentry
!= ovl_dentry_upper(old
))
843 newdentry
= lookup_one_len(new->d_name
.name
, new_upperdir
,
845 err
= PTR_ERR(newdentry
);
846 if (IS_ERR(newdentry
))
850 if (ovl_dentry_upper(new)) {
852 if (newdentry
!= opaquedir
)
855 if (newdentry
!= ovl_dentry_upper(new))
859 if (!d_is_negative(newdentry
) &&
860 (!new_opaque
|| !ovl_is_whiteout(newdentry
)))
864 if (olddentry
== trap
)
866 if (newdentry
== trap
)
869 if (is_dir
&& !old_opaque
&& new_opaque
) {
870 err
= ovl_set_opaque(olddentry
);
874 if (!overwrite
&& new_is_dir
&& old_opaque
&& !new_opaque
) {
875 err
= ovl_set_opaque(newdentry
);
880 if (old_opaque
|| new_opaque
) {
881 err
= ovl_do_rename(old_upperdir
->d_inode
, olddentry
,
882 new_upperdir
->d_inode
, newdentry
,
885 /* No debug for the plain case */
886 BUG_ON(flags
& ~RENAME_EXCHANGE
);
887 err
= vfs_rename(old_upperdir
->d_inode
, olddentry
,
888 new_upperdir
->d_inode
, newdentry
,
893 if (is_dir
&& !old_opaque
&& new_opaque
)
894 ovl_remove_opaque(olddentry
);
895 if (!overwrite
&& new_is_dir
&& old_opaque
&& !new_opaque
)
896 ovl_remove_opaque(newdentry
);
900 if (is_dir
&& old_opaque
&& !new_opaque
)
901 ovl_remove_opaque(olddentry
);
902 if (!overwrite
&& new_is_dir
&& !old_opaque
&& new_opaque
)
903 ovl_remove_opaque(newdentry
);
906 * Old dentry now lives in different location. Dentries in
907 * lowerstack are stale. We cannot drop them here because
908 * access to them is lockless. This could be only pure upper
909 * or opaque directory - numlower is zero. Or upper non-dir
910 * entry - its pureness is tracked by flag opaque.
912 if (old_opaque
!= new_opaque
) {
913 ovl_dentry_set_opaque(old
, new_opaque
);
915 ovl_dentry_set_opaque(new, old_opaque
);
918 if (cleanup_whiteout
)
919 ovl_cleanup(old_upperdir
->d_inode
, newdentry
);
921 ovl_dentry_version_inc(old
->d_parent
);
922 ovl_dentry_version_inc(new->d_parent
);
929 unlock_rename(new_upperdir
, old_upperdir
);
931 revert_creds(old_cred
);
939 const struct inode_operations ovl_dir_inode_operations
= {
940 .lookup
= ovl_lookup
,
942 .symlink
= ovl_symlink
,
943 .unlink
= ovl_unlink
,
945 .rename2
= ovl_rename2
,
947 .setattr
= ovl_setattr
,
948 .create
= ovl_create
,
950 .permission
= ovl_permission
,
951 .getattr
= ovl_dir_getattr
,
952 .setxattr
= generic_setxattr
,
953 .getxattr
= ovl_getxattr
,
954 .listxattr
= ovl_listxattr
,
955 .removexattr
= ovl_removexattr
,
956 .get_acl
= ovl_get_acl
,
957 .update_time
= ovl_update_time
,