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/posix_acl.h>
16 #include <linux/posix_acl_xattr.h>
17 #include "overlayfs.h"
19 void ovl_cleanup(struct inode
*wdir
, struct dentry
*wdentry
)
24 if (d_is_dir(wdentry
))
25 err
= ovl_do_rmdir(wdir
, wdentry
);
27 err
= ovl_do_unlink(wdir
, wdentry
);
31 pr_err("overlayfs: cleanup of '%pd2' failed (%i)\n",
36 struct dentry
*ovl_lookup_temp(struct dentry
*workdir
, struct dentry
*dentry
)
41 snprintf(name
, sizeof(name
), "#%lx", (unsigned long) dentry
);
43 temp
= lookup_one_len(name
, workdir
, strlen(name
));
44 if (!IS_ERR(temp
) && temp
->d_inode
) {
45 pr_err("overlayfs: workdir/%s already exists\n", name
);
53 /* caller holds i_mutex on workdir */
54 static struct dentry
*ovl_whiteout(struct dentry
*workdir
,
55 struct dentry
*dentry
)
58 struct dentry
*whiteout
;
59 struct inode
*wdir
= workdir
->d_inode
;
61 whiteout
= ovl_lookup_temp(workdir
, dentry
);
65 err
= ovl_do_whiteout(wdir
, whiteout
);
68 whiteout
= ERR_PTR(err
);
74 int ovl_create_real(struct inode
*dir
, struct dentry
*newdentry
,
75 struct kstat
*stat
, const char *link
,
76 struct dentry
*hardlink
, bool debug
)
80 if (newdentry
->d_inode
)
84 err
= ovl_do_link(hardlink
, dir
, newdentry
, debug
);
86 switch (stat
->mode
& S_IFMT
) {
88 err
= ovl_do_create(dir
, newdentry
, stat
->mode
, debug
);
92 err
= ovl_do_mkdir(dir
, newdentry
, stat
->mode
, debug
);
99 err
= ovl_do_mknod(dir
, newdentry
,
100 stat
->mode
, stat
->rdev
, debug
);
104 err
= ovl_do_symlink(dir
, newdentry
, link
, debug
);
111 if (!err
&& WARN_ON(!newdentry
->d_inode
)) {
113 * Not quite sure if non-instantiated dentry is legal or not.
114 * VFS doesn't seem to care so check and warn here.
121 static int ovl_set_opaque(struct dentry
*upperdentry
)
123 return ovl_do_setxattr(upperdentry
, OVL_XATTR_OPAQUE
, "y", 1, 0);
126 static void ovl_remove_opaque(struct dentry
*upperdentry
)
130 err
= ovl_do_removexattr(upperdentry
, OVL_XATTR_OPAQUE
);
132 pr_warn("overlayfs: failed to remove opaque from '%s' (%i)\n",
133 upperdentry
->d_name
.name
, err
);
137 static int ovl_dir_getattr(struct vfsmount
*mnt
, struct dentry
*dentry
,
141 enum ovl_path_type type
;
142 struct path realpath
;
143 const struct cred
*old_cred
;
145 type
= ovl_path_real(dentry
, &realpath
);
146 old_cred
= ovl_override_creds(dentry
->d_sb
);
147 err
= vfs_getattr(&realpath
, stat
);
148 revert_creds(old_cred
);
152 stat
->dev
= dentry
->d_sb
->s_dev
;
153 stat
->ino
= dentry
->d_inode
->i_ino
;
156 * It's probably not worth it to count subdirs to get the
157 * correct link count. nlink=1 seems to pacify 'find' and
160 if (OVL_TYPE_MERGE(type
))
166 /* Common operations required to be done after creation of file on upper */
167 static void ovl_instantiate(struct dentry
*dentry
, struct inode
*inode
,
168 struct dentry
*newdentry
, bool hardlink
)
170 ovl_dentry_version_inc(dentry
->d_parent
);
171 ovl_dentry_update(dentry
, newdentry
);
173 ovl_inode_update(inode
, d_inode(newdentry
));
174 ovl_copyattr(newdentry
->d_inode
, inode
);
176 WARN_ON(ovl_inode_real(inode
, NULL
) != d_inode(newdentry
));
179 d_instantiate(dentry
, inode
);
182 static int ovl_create_upper(struct dentry
*dentry
, struct inode
*inode
,
183 struct kstat
*stat
, const char *link
,
184 struct dentry
*hardlink
)
186 struct dentry
*upperdir
= ovl_dentry_upper(dentry
->d_parent
);
187 struct inode
*udir
= upperdir
->d_inode
;
188 struct dentry
*newdentry
;
191 if (!hardlink
&& !IS_POSIXACL(udir
))
192 stat
->mode
&= ~current_umask();
194 inode_lock_nested(udir
, I_MUTEX_PARENT
);
195 newdentry
= lookup_one_len(dentry
->d_name
.name
, upperdir
,
197 err
= PTR_ERR(newdentry
);
198 if (IS_ERR(newdentry
))
200 err
= ovl_create_real(udir
, newdentry
, stat
, link
, hardlink
, false);
204 ovl_instantiate(dentry
, inode
, newdentry
, !!hardlink
);
213 static int ovl_lock_rename_workdir(struct dentry
*workdir
,
214 struct dentry
*upperdir
)
216 /* Workdir should not be the same as upperdir */
217 if (workdir
== upperdir
)
220 /* Workdir should not be subdir of upperdir and vice versa */
221 if (lock_rename(workdir
, upperdir
) != NULL
)
227 unlock_rename(workdir
, upperdir
);
229 pr_err("overlayfs: failed to lock workdir+upperdir\n");
233 static struct dentry
*ovl_clear_empty(struct dentry
*dentry
,
234 struct list_head
*list
)
236 struct dentry
*workdir
= ovl_workdir(dentry
);
237 struct inode
*wdir
= workdir
->d_inode
;
238 struct dentry
*upperdir
= ovl_dentry_upper(dentry
->d_parent
);
239 struct inode
*udir
= upperdir
->d_inode
;
240 struct path upperpath
;
241 struct dentry
*upper
;
242 struct dentry
*opaquedir
;
246 if (WARN_ON(!workdir
))
247 return ERR_PTR(-EROFS
);
249 err
= ovl_lock_rename_workdir(workdir
, upperdir
);
253 ovl_path_upper(dentry
, &upperpath
);
254 err
= vfs_getattr(&upperpath
, &stat
);
259 if (!S_ISDIR(stat
.mode
))
261 upper
= upperpath
.dentry
;
262 if (upper
->d_parent
->d_inode
!= udir
)
265 opaquedir
= ovl_lookup_temp(workdir
, dentry
);
266 err
= PTR_ERR(opaquedir
);
267 if (IS_ERR(opaquedir
))
270 err
= ovl_create_real(wdir
, opaquedir
, &stat
, NULL
, NULL
, true);
274 err
= ovl_copy_xattr(upper
, opaquedir
);
278 err
= ovl_set_opaque(opaquedir
);
282 inode_lock(opaquedir
->d_inode
);
283 err
= ovl_set_attr(opaquedir
, &stat
);
284 inode_unlock(opaquedir
->d_inode
);
288 err
= ovl_do_rename(wdir
, opaquedir
, udir
, upper
, RENAME_EXCHANGE
);
292 ovl_cleanup_whiteouts(upper
, list
);
293 ovl_cleanup(wdir
, upper
);
294 unlock_rename(workdir
, upperdir
);
296 /* dentry's upper doesn't match now, get rid of it */
302 ovl_cleanup(wdir
, opaquedir
);
306 unlock_rename(workdir
, upperdir
);
311 static struct dentry
*ovl_check_empty_and_clear(struct dentry
*dentry
)
314 struct dentry
*ret
= NULL
;
315 enum ovl_path_type type
= ovl_path_type(dentry
);
318 err
= ovl_check_empty_dir(dentry
, &list
);
325 * When removing an empty opaque directory, then it makes no sense to
326 * replace it with an exact replica of itself.
328 * If no upperdentry then skip clearing whiteouts.
330 * Can race with copy-up, since we don't hold the upperdir mutex.
331 * Doesn't matter, since copy-up can't create a non-empty directory
334 if (OVL_TYPE_UPPER(type
) && OVL_TYPE_MERGE(type
))
335 ret
= ovl_clear_empty(dentry
, &list
);
338 ovl_cache_free(&list
);
343 static int ovl_set_upper_acl(struct dentry
*upperdentry
, const char *name
,
344 const struct posix_acl
*acl
)
350 if (!IS_ENABLED(CONFIG_FS_POSIX_ACL
) || !acl
)
353 size
= posix_acl_to_xattr(NULL
, acl
, NULL
, 0);
354 buffer
= kmalloc(size
, GFP_KERNEL
);
358 size
= posix_acl_to_xattr(&init_user_ns
, acl
, buffer
, size
);
363 err
= vfs_setxattr(upperdentry
, name
, buffer
, size
, XATTR_CREATE
);
369 static int ovl_create_over_whiteout(struct dentry
*dentry
, struct inode
*inode
,
370 struct kstat
*stat
, const char *link
,
371 struct dentry
*hardlink
)
373 struct dentry
*workdir
= ovl_workdir(dentry
);
374 struct inode
*wdir
= workdir
->d_inode
;
375 struct dentry
*upperdir
= ovl_dentry_upper(dentry
->d_parent
);
376 struct inode
*udir
= upperdir
->d_inode
;
377 struct dentry
*upper
;
378 struct dentry
*newdentry
;
380 struct posix_acl
*acl
, *default_acl
;
382 if (WARN_ON(!workdir
))
386 err
= posix_acl_create(dentry
->d_parent
->d_inode
,
387 &stat
->mode
, &default_acl
, &acl
);
392 err
= ovl_lock_rename_workdir(workdir
, upperdir
);
396 newdentry
= ovl_lookup_temp(workdir
, dentry
);
397 err
= PTR_ERR(newdentry
);
398 if (IS_ERR(newdentry
))
401 upper
= lookup_one_len(dentry
->d_name
.name
, upperdir
,
403 err
= PTR_ERR(upper
);
407 err
= ovl_create_real(wdir
, newdentry
, stat
, link
, hardlink
, true);
412 * mode could have been mutilated due to umask (e.g. sgid directory)
415 !S_ISLNK(stat
->mode
) && newdentry
->d_inode
->i_mode
!= stat
->mode
) {
416 struct iattr attr
= {
417 .ia_valid
= ATTR_MODE
,
418 .ia_mode
= stat
->mode
,
420 inode_lock(newdentry
->d_inode
);
421 err
= notify_change(newdentry
, &attr
, NULL
);
422 inode_unlock(newdentry
->d_inode
);
427 err
= ovl_set_upper_acl(newdentry
, XATTR_NAME_POSIX_ACL_ACCESS
,
432 err
= ovl_set_upper_acl(newdentry
, XATTR_NAME_POSIX_ACL_DEFAULT
,
438 if (!hardlink
&& S_ISDIR(stat
->mode
)) {
439 err
= ovl_set_opaque(newdentry
);
443 err
= ovl_do_rename(wdir
, newdentry
, udir
, upper
,
448 ovl_cleanup(wdir
, upper
);
450 err
= ovl_do_rename(wdir
, newdentry
, udir
, upper
, 0);
454 ovl_instantiate(dentry
, inode
, newdentry
, !!hardlink
);
461 unlock_rename(workdir
, upperdir
);
464 posix_acl_release(acl
);
465 posix_acl_release(default_acl
);
470 ovl_cleanup(wdir
, newdentry
);
474 static int ovl_create_or_link(struct dentry
*dentry
, struct inode
*inode
,
475 struct kstat
*stat
, const char *link
,
476 struct dentry
*hardlink
)
479 const struct cred
*old_cred
;
480 struct cred
*override_cred
;
482 err
= ovl_copy_up(dentry
->d_parent
);
486 old_cred
= ovl_override_creds(dentry
->d_sb
);
488 override_cred
= prepare_creds();
490 override_cred
->fsuid
= inode
->i_uid
;
491 override_cred
->fsgid
= inode
->i_gid
;
493 err
= security_dentry_create_files_as(dentry
,
494 stat
->mode
, &dentry
->d_name
, old_cred
,
497 put_cred(override_cred
);
498 goto out_revert_creds
;
501 put_cred(override_creds(override_cred
));
502 put_cred(override_cred
);
504 if (!ovl_dentry_is_opaque(dentry
))
505 err
= ovl_create_upper(dentry
, inode
, stat
, link
,
508 err
= ovl_create_over_whiteout(dentry
, inode
, stat
,
512 revert_creds(old_cred
);
514 struct inode
*realinode
= d_inode(ovl_dentry_upper(dentry
));
516 WARN_ON(inode
->i_mode
!= realinode
->i_mode
);
517 WARN_ON(!uid_eq(inode
->i_uid
, realinode
->i_uid
));
518 WARN_ON(!gid_eq(inode
->i_gid
, realinode
->i_gid
));
523 static int ovl_create_object(struct dentry
*dentry
, int mode
, dev_t rdev
,
528 struct kstat stat
= {
532 err
= ovl_want_write(dentry
);
537 inode
= ovl_new_inode(dentry
->d_sb
, mode
);
541 inode_init_owner(inode
, dentry
->d_parent
->d_inode
, mode
);
542 stat
.mode
= inode
->i_mode
;
544 err
= ovl_create_or_link(dentry
, inode
, &stat
, link
, NULL
);
549 ovl_drop_write(dentry
);
554 static int ovl_create(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
557 return ovl_create_object(dentry
, (mode
& 07777) | S_IFREG
, 0, NULL
);
560 static int ovl_mkdir(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
562 return ovl_create_object(dentry
, (mode
& 07777) | S_IFDIR
, 0, NULL
);
565 static int ovl_mknod(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
568 /* Don't allow creation of "whiteout" on overlay */
569 if (S_ISCHR(mode
) && rdev
== WHITEOUT_DEV
)
572 return ovl_create_object(dentry
, mode
, rdev
, NULL
);
575 static int ovl_symlink(struct inode
*dir
, struct dentry
*dentry
,
578 return ovl_create_object(dentry
, S_IFLNK
, 0, link
);
581 static int ovl_link(struct dentry
*old
, struct inode
*newdir
,
587 err
= ovl_want_write(old
);
591 err
= ovl_copy_up(old
);
595 inode
= d_inode(old
);
598 err
= ovl_create_or_link(new, inode
, NULL
, NULL
, ovl_dentry_upper(old
));
608 static int ovl_remove_and_whiteout(struct dentry
*dentry
, bool is_dir
)
610 struct dentry
*workdir
= ovl_workdir(dentry
);
611 struct inode
*wdir
= workdir
->d_inode
;
612 struct dentry
*upperdir
= ovl_dentry_upper(dentry
->d_parent
);
613 struct inode
*udir
= upperdir
->d_inode
;
614 struct dentry
*whiteout
;
615 struct dentry
*upper
;
616 struct dentry
*opaquedir
= NULL
;
620 if (WARN_ON(!workdir
))
624 opaquedir
= ovl_check_empty_and_clear(dentry
);
625 err
= PTR_ERR(opaquedir
);
626 if (IS_ERR(opaquedir
))
630 err
= ovl_lock_rename_workdir(workdir
, upperdir
);
634 upper
= lookup_one_len(dentry
->d_name
.name
, upperdir
,
636 err
= PTR_ERR(upper
);
641 if ((opaquedir
&& upper
!= opaquedir
) ||
642 (!opaquedir
&& ovl_dentry_upper(dentry
) &&
643 upper
!= ovl_dentry_upper(dentry
))) {
647 whiteout
= ovl_whiteout(workdir
, dentry
);
648 err
= PTR_ERR(whiteout
);
649 if (IS_ERR(whiteout
))
653 flags
= RENAME_EXCHANGE
;
655 err
= ovl_do_rename(wdir
, whiteout
, udir
, upper
, flags
);
659 ovl_cleanup(wdir
, upper
);
661 ovl_dentry_version_inc(dentry
->d_parent
);
668 unlock_rename(workdir
, upperdir
);
675 ovl_cleanup(wdir
, whiteout
);
679 static int ovl_remove_upper(struct dentry
*dentry
, bool is_dir
)
681 struct dentry
*upperdir
= ovl_dentry_upper(dentry
->d_parent
);
682 struct inode
*dir
= upperdir
->d_inode
;
683 struct dentry
*upper
;
686 inode_lock_nested(dir
, I_MUTEX_PARENT
);
687 upper
= lookup_one_len(dentry
->d_name
.name
, upperdir
,
689 err
= PTR_ERR(upper
);
694 if (upper
== ovl_dentry_upper(dentry
)) {
696 err
= vfs_rmdir(dir
, upper
);
698 err
= vfs_unlink(dir
, upper
, NULL
);
699 ovl_dentry_version_inc(dentry
->d_parent
);
704 * Keeping this dentry hashed would mean having to release
705 * upperpath/lowerpath, which could only be done if we are the
706 * sole user of this dentry. Too tricky... Just unhash for
717 static inline int ovl_check_sticky(struct dentry
*dentry
)
719 struct inode
*dir
= ovl_dentry_real(dentry
->d_parent
)->d_inode
;
720 struct inode
*inode
= ovl_dentry_real(dentry
)->d_inode
;
722 if (check_sticky(dir
, inode
))
728 static int ovl_do_remove(struct dentry
*dentry
, bool is_dir
)
730 enum ovl_path_type type
;
732 const struct cred
*old_cred
;
735 err
= ovl_check_sticky(dentry
);
739 err
= ovl_want_write(dentry
);
743 err
= ovl_copy_up(dentry
->d_parent
);
747 type
= ovl_path_type(dentry
);
749 old_cred
= ovl_override_creds(dentry
->d_sb
);
750 if (OVL_TYPE_PURE_UPPER(type
))
751 err
= ovl_remove_upper(dentry
, is_dir
);
753 err
= ovl_remove_and_whiteout(dentry
, is_dir
);
754 revert_creds(old_cred
);
757 clear_nlink(dentry
->d_inode
);
759 drop_nlink(dentry
->d_inode
);
762 ovl_drop_write(dentry
);
767 static int ovl_unlink(struct inode
*dir
, struct dentry
*dentry
)
769 return ovl_do_remove(dentry
, false);
772 static int ovl_rmdir(struct inode
*dir
, struct dentry
*dentry
)
774 return ovl_do_remove(dentry
, true);
777 static int ovl_rename2(struct inode
*olddir
, struct dentry
*old
,
778 struct inode
*newdir
, struct dentry
*new,
782 enum ovl_path_type old_type
;
783 enum ovl_path_type new_type
;
784 struct dentry
*old_upperdir
;
785 struct dentry
*new_upperdir
;
786 struct dentry
*olddentry
;
787 struct dentry
*newdentry
;
791 bool cleanup_whiteout
= false;
792 bool overwrite
= !(flags
& RENAME_EXCHANGE
);
793 bool is_dir
= d_is_dir(old
);
794 bool new_is_dir
= false;
795 struct dentry
*opaquedir
= NULL
;
796 const struct cred
*old_cred
= NULL
;
799 if (flags
& ~(RENAME_EXCHANGE
| RENAME_NOREPLACE
))
802 flags
&= ~RENAME_NOREPLACE
;
804 err
= ovl_check_sticky(old
);
808 /* Don't copy up directory trees */
809 old_type
= ovl_path_type(old
);
811 if (OVL_TYPE_MERGE_OR_LOWER(old_type
) && is_dir
)
815 err
= ovl_check_sticky(new);
822 new_type
= ovl_path_type(new);
824 if (!overwrite
&& OVL_TYPE_MERGE_OR_LOWER(new_type
) && new_is_dir
)
828 if (!OVL_TYPE_UPPER(new_type
) && !OVL_TYPE_UPPER(old_type
)) {
829 if (ovl_dentry_lower(old
)->d_inode
==
830 ovl_dentry_lower(new)->d_inode
)
833 if (OVL_TYPE_UPPER(new_type
) && OVL_TYPE_UPPER(old_type
)) {
834 if (ovl_dentry_upper(old
)->d_inode
==
835 ovl_dentry_upper(new)->d_inode
)
839 if (ovl_dentry_is_opaque(new))
840 new_type
= __OVL_PATH_UPPER
;
842 new_type
= __OVL_PATH_UPPER
| __OVL_PATH_PURE
;
845 err
= ovl_want_write(old
);
849 err
= ovl_copy_up(old
);
853 err
= ovl_copy_up(new->d_parent
);
857 err
= ovl_copy_up(new);
862 old_opaque
= !OVL_TYPE_PURE_UPPER(old_type
);
863 new_opaque
= !OVL_TYPE_PURE_UPPER(new_type
);
865 old_cred
= ovl_override_creds(old
->d_sb
);
867 if (overwrite
&& OVL_TYPE_MERGE_OR_LOWER(new_type
) && new_is_dir
) {
868 opaquedir
= ovl_check_empty_and_clear(new);
869 err
= PTR_ERR(opaquedir
);
870 if (IS_ERR(opaquedir
)) {
872 goto out_revert_creds
;
878 if (new->d_inode
|| !new_opaque
) {
879 /* Whiteout source */
880 flags
|= RENAME_WHITEOUT
;
882 /* Switch whiteouts */
883 flags
|= RENAME_EXCHANGE
;
885 } else if (is_dir
&& !new->d_inode
&& new_opaque
) {
886 flags
|= RENAME_EXCHANGE
;
887 cleanup_whiteout
= true;
891 old_upperdir
= ovl_dentry_upper(old
->d_parent
);
892 new_upperdir
= ovl_dentry_upper(new->d_parent
);
894 trap
= lock_rename(new_upperdir
, old_upperdir
);
897 olddentry
= lookup_one_len(old
->d_name
.name
, old_upperdir
,
899 err
= PTR_ERR(olddentry
);
900 if (IS_ERR(olddentry
))
904 if (olddentry
!= ovl_dentry_upper(old
))
907 newdentry
= lookup_one_len(new->d_name
.name
, new_upperdir
,
909 err
= PTR_ERR(newdentry
);
910 if (IS_ERR(newdentry
))
914 if (ovl_dentry_upper(new)) {
916 if (newdentry
!= opaquedir
)
919 if (newdentry
!= ovl_dentry_upper(new))
923 if (!d_is_negative(newdentry
) &&
924 (!new_opaque
|| !ovl_is_whiteout(newdentry
)))
928 if (olddentry
== trap
)
930 if (newdentry
== trap
)
933 if (is_dir
&& !old_opaque
&& new_opaque
) {
934 err
= ovl_set_opaque(olddentry
);
938 if (!overwrite
&& new_is_dir
&& old_opaque
&& !new_opaque
) {
939 err
= ovl_set_opaque(newdentry
);
944 if (old_opaque
|| new_opaque
) {
945 err
= ovl_do_rename(old_upperdir
->d_inode
, olddentry
,
946 new_upperdir
->d_inode
, newdentry
,
949 /* No debug for the plain case */
950 BUG_ON(flags
& ~RENAME_EXCHANGE
);
951 err
= vfs_rename(old_upperdir
->d_inode
, olddentry
,
952 new_upperdir
->d_inode
, newdentry
,
957 if (is_dir
&& !old_opaque
&& new_opaque
)
958 ovl_remove_opaque(olddentry
);
959 if (!overwrite
&& new_is_dir
&& old_opaque
&& !new_opaque
)
960 ovl_remove_opaque(newdentry
);
964 if (is_dir
&& old_opaque
&& !new_opaque
)
965 ovl_remove_opaque(olddentry
);
966 if (!overwrite
&& new_is_dir
&& !old_opaque
&& new_opaque
)
967 ovl_remove_opaque(newdentry
);
970 * Old dentry now lives in different location. Dentries in
971 * lowerstack are stale. We cannot drop them here because
972 * access to them is lockless. This could be only pure upper
973 * or opaque directory - numlower is zero. Or upper non-dir
974 * entry - its pureness is tracked by flag opaque.
976 if (old_opaque
!= new_opaque
) {
977 ovl_dentry_set_opaque(old
, new_opaque
);
979 ovl_dentry_set_opaque(new, old_opaque
);
982 if (cleanup_whiteout
)
983 ovl_cleanup(old_upperdir
->d_inode
, newdentry
);
985 ovl_dentry_version_inc(old
->d_parent
);
986 ovl_dentry_version_inc(new->d_parent
);
993 unlock_rename(new_upperdir
, old_upperdir
);
995 revert_creds(old_cred
);
1003 const struct inode_operations ovl_dir_inode_operations
= {
1004 .lookup
= ovl_lookup
,
1006 .symlink
= ovl_symlink
,
1007 .unlink
= ovl_unlink
,
1009 .rename
= ovl_rename2
,
1011 .setattr
= ovl_setattr
,
1012 .create
= ovl_create
,
1014 .permission
= ovl_permission
,
1015 .getattr
= ovl_dir_getattr
,
1016 .listxattr
= ovl_listxattr
,
1017 .get_acl
= ovl_get_acl
,
1018 .update_time
= ovl_update_time
,