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/mount.h>
14 #include <linux/parser.h>
15 #include <linux/module.h>
16 #include <linux/statfs.h>
17 #include <linux/seq_file.h>
18 #include <linux/posix_acl_xattr.h>
19 #include "overlayfs.h"
20 #include "ovl_entry.h"
22 MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>");
23 MODULE_DESCRIPTION("Overlay filesystem");
24 MODULE_LICENSE("GPL");
29 #define OVL_MAX_STACK 500
31 static bool ovl_redirect_dir_def
= IS_ENABLED(CONFIG_OVERLAY_FS_REDIRECT_DIR
);
32 module_param_named(redirect_dir
, ovl_redirect_dir_def
, bool, 0644);
33 MODULE_PARM_DESC(ovl_redirect_dir_def
,
34 "Default to on or off for the redirect_dir feature");
36 static void ovl_dentry_release(struct dentry
*dentry
)
38 struct ovl_entry
*oe
= dentry
->d_fsdata
;
43 dput(oe
->__upperdentry
);
45 for (i
= 0; i
< oe
->numlower
; i
++)
46 dput(oe
->lowerstack
[i
].dentry
);
51 static struct dentry
*ovl_d_real(struct dentry
*dentry
,
52 const struct inode
*inode
,
53 unsigned int open_flags
)
57 if (!d_is_reg(dentry
)) {
58 if (!inode
|| inode
== d_inode(dentry
))
63 if (d_is_negative(dentry
))
67 int err
= ovl_open_maybe_copy_up(dentry
, open_flags
);
73 real
= ovl_dentry_upper(dentry
);
74 if (real
&& (!inode
|| inode
== d_inode(real
)))
77 real
= ovl_dentry_lower(dentry
);
81 /* Handle recursion */
82 real
= d_real(real
, inode
, open_flags
);
84 if (!inode
|| inode
== d_inode(real
))
87 WARN(1, "ovl_d_real(%pd4, %s:%lu): real dentry not found\n", dentry
,
88 inode
? inode
->i_sb
->s_id
: "NULL", inode
? inode
->i_ino
: 0);
92 static int ovl_dentry_revalidate(struct dentry
*dentry
, unsigned int flags
)
94 struct ovl_entry
*oe
= dentry
->d_fsdata
;
98 for (i
= 0; i
< oe
->numlower
; i
++) {
99 struct dentry
*d
= oe
->lowerstack
[i
].dentry
;
101 if (d
->d_flags
& DCACHE_OP_REVALIDATE
) {
102 ret
= d
->d_op
->d_revalidate(d
, flags
);
106 if (!(flags
& LOOKUP_RCU
))
115 static int ovl_dentry_weak_revalidate(struct dentry
*dentry
, unsigned int flags
)
117 struct ovl_entry
*oe
= dentry
->d_fsdata
;
121 for (i
= 0; i
< oe
->numlower
; i
++) {
122 struct dentry
*d
= oe
->lowerstack
[i
].dentry
;
124 if (d
->d_flags
& DCACHE_OP_WEAK_REVALIDATE
) {
125 ret
= d
->d_op
->d_weak_revalidate(d
, flags
);
133 static const struct dentry_operations ovl_dentry_operations
= {
134 .d_release
= ovl_dentry_release
,
135 .d_real
= ovl_d_real
,
138 static const struct dentry_operations ovl_reval_dentry_operations
= {
139 .d_release
= ovl_dentry_release
,
140 .d_real
= ovl_d_real
,
141 .d_revalidate
= ovl_dentry_revalidate
,
142 .d_weak_revalidate
= ovl_dentry_weak_revalidate
,
145 static void ovl_put_super(struct super_block
*sb
)
147 struct ovl_fs
*ufs
= sb
->s_fs_info
;
151 mntput(ufs
->upper_mnt
);
152 for (i
= 0; i
< ufs
->numlower
; i
++)
153 mntput(ufs
->lower_mnt
[i
]);
154 kfree(ufs
->lower_mnt
);
156 kfree(ufs
->config
.lowerdir
);
157 kfree(ufs
->config
.upperdir
);
158 kfree(ufs
->config
.workdir
);
159 put_cred(ufs
->creator_cred
);
165 * @sb: The overlayfs super block
166 * @buf: The struct kstatfs to fill in with stats
168 * Get the filesystem statistics. As writes always target the upper layer
169 * filesystem pass the statfs to the upper filesystem (if it exists)
171 static int ovl_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
173 struct ovl_fs
*ofs
= dentry
->d_sb
->s_fs_info
;
174 struct dentry
*root_dentry
= dentry
->d_sb
->s_root
;
178 ovl_path_real(root_dentry
, &path
);
180 err
= vfs_statfs(&path
, buf
);
182 buf
->f_namelen
= ofs
->namelen
;
183 buf
->f_type
= OVERLAYFS_SUPER_MAGIC
;
192 * Prints the mount options for a given superblock.
193 * Returns zero; does not fail.
195 static int ovl_show_options(struct seq_file
*m
, struct dentry
*dentry
)
197 struct super_block
*sb
= dentry
->d_sb
;
198 struct ovl_fs
*ufs
= sb
->s_fs_info
;
200 seq_show_option(m
, "lowerdir", ufs
->config
.lowerdir
);
201 if (ufs
->config
.upperdir
) {
202 seq_show_option(m
, "upperdir", ufs
->config
.upperdir
);
203 seq_show_option(m
, "workdir", ufs
->config
.workdir
);
205 if (ufs
->config
.default_permissions
)
206 seq_puts(m
, ",default_permissions");
207 if (ufs
->config
.redirect_dir
!= ovl_redirect_dir_def
)
208 seq_printf(m
, ",redirect_dir=%s",
209 ufs
->config
.redirect_dir
? "on" : "off");
213 static int ovl_remount(struct super_block
*sb
, int *flags
, char *data
)
215 struct ovl_fs
*ufs
= sb
->s_fs_info
;
217 if (!(*flags
& MS_RDONLY
) && (!ufs
->upper_mnt
|| !ufs
->workdir
))
223 static const struct super_operations ovl_super_operations
= {
224 .put_super
= ovl_put_super
,
225 .statfs
= ovl_statfs
,
226 .show_options
= ovl_show_options
,
227 .remount_fs
= ovl_remount
,
228 .drop_inode
= generic_delete_inode
,
235 OPT_DEFAULT_PERMISSIONS
,
237 OPT_REDIRECT_DIR_OFF
,
241 static const match_table_t ovl_tokens
= {
242 {OPT_LOWERDIR
, "lowerdir=%s"},
243 {OPT_UPPERDIR
, "upperdir=%s"},
244 {OPT_WORKDIR
, "workdir=%s"},
245 {OPT_DEFAULT_PERMISSIONS
, "default_permissions"},
246 {OPT_REDIRECT_DIR_ON
, "redirect_dir=on"},
247 {OPT_REDIRECT_DIR_OFF
, "redirect_dir=off"},
251 static char *ovl_next_opt(char **s
)
259 for (p
= sbegin
; *p
; p
++) {
264 } else if (*p
== ',') {
274 static int ovl_parse_opt(char *opt
, struct ovl_config
*config
)
278 while ((p
= ovl_next_opt(&opt
)) != NULL
) {
280 substring_t args
[MAX_OPT_ARGS
];
285 token
= match_token(p
, ovl_tokens
, args
);
288 kfree(config
->upperdir
);
289 config
->upperdir
= match_strdup(&args
[0]);
290 if (!config
->upperdir
)
295 kfree(config
->lowerdir
);
296 config
->lowerdir
= match_strdup(&args
[0]);
297 if (!config
->lowerdir
)
302 kfree(config
->workdir
);
303 config
->workdir
= match_strdup(&args
[0]);
304 if (!config
->workdir
)
308 case OPT_DEFAULT_PERMISSIONS
:
309 config
->default_permissions
= true;
312 case OPT_REDIRECT_DIR_ON
:
313 config
->redirect_dir
= true;
316 case OPT_REDIRECT_DIR_OFF
:
317 config
->redirect_dir
= false;
321 pr_err("overlayfs: unrecognized mount option \"%s\" or missing value\n", p
);
326 /* Workdir is useless in non-upper mount */
327 if (!config
->upperdir
&& config
->workdir
) {
328 pr_info("overlayfs: option \"workdir=%s\" is useless in a non-upper mount, ignore\n",
330 kfree(config
->workdir
);
331 config
->workdir
= NULL
;
337 #define OVL_WORKDIR_NAME "work"
339 static struct dentry
*ovl_workdir_create(struct vfsmount
*mnt
,
340 struct dentry
*dentry
)
342 struct inode
*dir
= dentry
->d_inode
;
345 bool retried
= false;
347 err
= mnt_want_write(mnt
);
351 inode_lock_nested(dir
, I_MUTEX_PARENT
);
353 work
= lookup_one_len(OVL_WORKDIR_NAME
, dentry
,
354 strlen(OVL_WORKDIR_NAME
));
357 struct iattr attr
= {
358 .ia_valid
= ATTR_MODE
,
359 .ia_mode
= S_IFDIR
| 0,
368 ovl_workdir_cleanup(dir
, mnt
, work
, 0);
373 err
= ovl_create_real(dir
, work
,
374 &(struct cattr
){.mode
= S_IFDIR
| 0},
380 * Try to remove POSIX ACL xattrs from workdir. We are good if:
382 * a) success (there was a POSIX ACL xattr and was removed)
383 * b) -ENODATA (there was no POSIX ACL xattr)
384 * c) -EOPNOTSUPP (POSIX ACL xattrs are not supported)
386 * There are various other error values that could effectively
387 * mean that the xattr doesn't exist (e.g. -ERANGE is returned
388 * if the xattr name is too long), but the set of filesystems
389 * allowed as upper are limited to "normal" ones, where checking
390 * for the above two errors is sufficient.
392 err
= vfs_removexattr(work
, XATTR_NAME_POSIX_ACL_DEFAULT
);
393 if (err
&& err
!= -ENODATA
&& err
!= -EOPNOTSUPP
)
396 err
= vfs_removexattr(work
, XATTR_NAME_POSIX_ACL_ACCESS
);
397 if (err
&& err
!= -ENODATA
&& err
!= -EOPNOTSUPP
)
400 /* Clear any inherited mode bits */
401 inode_lock(work
->d_inode
);
402 err
= notify_change(work
, &attr
, NULL
);
403 inode_unlock(work
->d_inode
);
419 static void ovl_unescape(char *s
)
432 static int ovl_mount_dir_noesc(const char *name
, struct path
*path
)
437 pr_err("overlayfs: empty lowerdir\n");
440 err
= kern_path(name
, LOOKUP_FOLLOW
, path
);
442 pr_err("overlayfs: failed to resolve '%s': %i\n", name
, err
);
446 if (ovl_dentry_weird(path
->dentry
)) {
447 pr_err("overlayfs: filesystem on '%s' not supported\n", name
);
450 if (!d_is_dir(path
->dentry
)) {
451 pr_err("overlayfs: '%s' not a directory\n", name
);
462 static int ovl_mount_dir(const char *name
, struct path
*path
)
465 char *tmp
= kstrdup(name
, GFP_KERNEL
);
469 err
= ovl_mount_dir_noesc(tmp
, path
);
472 if (ovl_dentry_remote(path
->dentry
)) {
473 pr_err("overlayfs: filesystem on '%s' not supported as upperdir\n",
483 static int ovl_check_namelen(struct path
*path
, struct ovl_fs
*ofs
,
486 struct kstatfs statfs
;
487 int err
= vfs_statfs(path
, &statfs
);
490 pr_err("overlayfs: statfs failed on '%s'\n", name
);
492 ofs
->namelen
= max(ofs
->namelen
, statfs
.f_namelen
);
497 static int ovl_lower_dir(const char *name
, struct path
*path
,
498 struct ovl_fs
*ofs
, int *stack_depth
, bool *remote
)
502 err
= ovl_mount_dir_noesc(name
, path
);
506 err
= ovl_check_namelen(path
, ofs
, name
);
510 *stack_depth
= max(*stack_depth
, path
->mnt
->mnt_sb
->s_stack_depth
);
512 if (ovl_dentry_remote(path
->dentry
))
523 /* Workdir should not be subdir of upperdir and vice versa */
524 static bool ovl_workdir_ok(struct dentry
*workdir
, struct dentry
*upperdir
)
528 if (workdir
!= upperdir
) {
529 ok
= (lock_rename(workdir
, upperdir
) == NULL
);
530 unlock_rename(workdir
, upperdir
);
535 static unsigned int ovl_split_lowerdirs(char *str
)
537 unsigned int ctr
= 1;
540 for (s
= d
= str
;; s
++, d
++) {
543 } else if (*s
== ':') {
555 static int __maybe_unused
556 ovl_posix_acl_xattr_get(const struct xattr_handler
*handler
,
557 struct dentry
*dentry
, struct inode
*inode
,
558 const char *name
, void *buffer
, size_t size
)
560 return ovl_xattr_get(dentry
, handler
->name
, buffer
, size
);
563 static int __maybe_unused
564 ovl_posix_acl_xattr_set(const struct xattr_handler
*handler
,
565 struct dentry
*dentry
, struct inode
*inode
,
566 const char *name
, const void *value
,
567 size_t size
, int flags
)
569 struct dentry
*workdir
= ovl_workdir(dentry
);
570 struct inode
*realinode
= ovl_inode_real(inode
, NULL
);
571 struct posix_acl
*acl
= NULL
;
574 /* Check that everything is OK before copy-up */
576 acl
= posix_acl_from_xattr(&init_user_ns
, value
, size
);
581 if (!IS_POSIXACL(d_inode(workdir
)))
582 goto out_acl_release
;
583 if (!realinode
->i_op
->set_acl
)
584 goto out_acl_release
;
585 if (handler
->flags
== ACL_TYPE_DEFAULT
&& !S_ISDIR(inode
->i_mode
)) {
586 err
= acl
? -EACCES
: 0;
587 goto out_acl_release
;
590 if (!inode_owner_or_capable(inode
))
591 goto out_acl_release
;
593 posix_acl_release(acl
);
596 * Check if sgid bit needs to be cleared (actual setacl operation will
597 * be done with mounter's capabilities and so that won't do it for us).
599 if (unlikely(inode
->i_mode
& S_ISGID
) &&
600 handler
->flags
== ACL_TYPE_ACCESS
&&
601 !in_group_p(inode
->i_gid
) &&
602 !capable_wrt_inode_uidgid(inode
, CAP_FSETID
)) {
603 struct iattr iattr
= { .ia_valid
= ATTR_KILL_SGID
};
605 err
= ovl_setattr(dentry
, &iattr
);
610 err
= ovl_xattr_set(dentry
, handler
->name
, value
, size
, flags
);
612 ovl_copyattr(ovl_inode_real(inode
, NULL
), inode
);
617 posix_acl_release(acl
);
621 static int ovl_own_xattr_get(const struct xattr_handler
*handler
,
622 struct dentry
*dentry
, struct inode
*inode
,
623 const char *name
, void *buffer
, size_t size
)
628 static int ovl_own_xattr_set(const struct xattr_handler
*handler
,
629 struct dentry
*dentry
, struct inode
*inode
,
630 const char *name
, const void *value
,
631 size_t size
, int flags
)
636 static int ovl_other_xattr_get(const struct xattr_handler
*handler
,
637 struct dentry
*dentry
, struct inode
*inode
,
638 const char *name
, void *buffer
, size_t size
)
640 return ovl_xattr_get(dentry
, name
, buffer
, size
);
643 static int ovl_other_xattr_set(const struct xattr_handler
*handler
,
644 struct dentry
*dentry
, struct inode
*inode
,
645 const char *name
, const void *value
,
646 size_t size
, int flags
)
648 return ovl_xattr_set(dentry
, name
, value
, size
, flags
);
651 static const struct xattr_handler __maybe_unused
652 ovl_posix_acl_access_xattr_handler
= {
653 .name
= XATTR_NAME_POSIX_ACL_ACCESS
,
654 .flags
= ACL_TYPE_ACCESS
,
655 .get
= ovl_posix_acl_xattr_get
,
656 .set
= ovl_posix_acl_xattr_set
,
659 static const struct xattr_handler __maybe_unused
660 ovl_posix_acl_default_xattr_handler
= {
661 .name
= XATTR_NAME_POSIX_ACL_DEFAULT
,
662 .flags
= ACL_TYPE_DEFAULT
,
663 .get
= ovl_posix_acl_xattr_get
,
664 .set
= ovl_posix_acl_xattr_set
,
667 static const struct xattr_handler ovl_own_xattr_handler
= {
668 .prefix
= OVL_XATTR_PREFIX
,
669 .get
= ovl_own_xattr_get
,
670 .set
= ovl_own_xattr_set
,
673 static const struct xattr_handler ovl_other_xattr_handler
= {
674 .prefix
= "", /* catch all */
675 .get
= ovl_other_xattr_get
,
676 .set
= ovl_other_xattr_set
,
679 static const struct xattr_handler
*ovl_xattr_handlers
[] = {
680 #ifdef CONFIG_FS_POSIX_ACL
681 &ovl_posix_acl_access_xattr_handler
,
682 &ovl_posix_acl_default_xattr_handler
,
684 &ovl_own_xattr_handler
,
685 &ovl_other_xattr_handler
,
689 static int ovl_fill_super(struct super_block
*sb
, void *data
, int silent
)
691 struct path upperpath
= { NULL
, NULL
};
692 struct path workpath
= { NULL
, NULL
};
693 struct dentry
*root_dentry
;
694 struct inode
*realinode
;
695 struct ovl_entry
*oe
;
697 struct path
*stack
= NULL
;
700 unsigned int numlower
;
701 unsigned int stacklen
= 0;
707 ufs
= kzalloc(sizeof(struct ovl_fs
), GFP_KERNEL
);
711 ufs
->config
.redirect_dir
= ovl_redirect_dir_def
;
712 err
= ovl_parse_opt((char *) data
, &ufs
->config
);
714 goto out_free_config
;
717 if (!ufs
->config
.lowerdir
) {
719 pr_err("overlayfs: missing 'lowerdir'\n");
720 goto out_free_config
;
723 sb
->s_stack_depth
= 0;
724 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
725 if (ufs
->config
.upperdir
) {
726 if (!ufs
->config
.workdir
) {
727 pr_err("overlayfs: missing 'workdir'\n");
728 goto out_free_config
;
731 err
= ovl_mount_dir(ufs
->config
.upperdir
, &upperpath
);
733 goto out_free_config
;
735 /* Upper fs should not be r/o */
736 if (upperpath
.mnt
->mnt_sb
->s_flags
& MS_RDONLY
) {
737 pr_err("overlayfs: upper fs is r/o, try multi-lower layers mount\n");
739 goto out_put_upperpath
;
742 err
= ovl_check_namelen(&upperpath
, ufs
, ufs
->config
.upperdir
);
744 goto out_put_upperpath
;
746 err
= ovl_mount_dir(ufs
->config
.workdir
, &workpath
);
748 goto out_put_upperpath
;
751 if (upperpath
.mnt
!= workpath
.mnt
) {
752 pr_err("overlayfs: workdir and upperdir must reside under the same mount\n");
753 goto out_put_workpath
;
755 if (!ovl_workdir_ok(workpath
.dentry
, upperpath
.dentry
)) {
756 pr_err("overlayfs: workdir and upperdir must be separate subtrees\n");
757 goto out_put_workpath
;
759 sb
->s_stack_depth
= upperpath
.mnt
->mnt_sb
->s_stack_depth
;
762 lowertmp
= kstrdup(ufs
->config
.lowerdir
, GFP_KERNEL
);
764 goto out_put_workpath
;
767 stacklen
= ovl_split_lowerdirs(lowertmp
);
768 if (stacklen
> OVL_MAX_STACK
) {
769 pr_err("overlayfs: too many lower directories, limit is %d\n",
771 goto out_free_lowertmp
;
772 } else if (!ufs
->config
.upperdir
&& stacklen
== 1) {
773 pr_err("overlayfs: at least 2 lowerdir are needed while upperdir nonexistent\n");
774 goto out_free_lowertmp
;
778 stack
= kcalloc(stacklen
, sizeof(struct path
), GFP_KERNEL
);
780 goto out_free_lowertmp
;
784 for (numlower
= 0; numlower
< stacklen
; numlower
++) {
785 err
= ovl_lower_dir(lower
, &stack
[numlower
], ufs
,
786 &sb
->s_stack_depth
, &remote
);
788 goto out_put_lowerpath
;
790 lower
= strchr(lower
, '\0') + 1;
795 if (sb
->s_stack_depth
> FILESYSTEM_MAX_STACK_DEPTH
) {
796 pr_err("overlayfs: maximum fs stacking depth exceeded\n");
797 goto out_put_lowerpath
;
800 if (ufs
->config
.upperdir
) {
801 ufs
->upper_mnt
= clone_private_mount(&upperpath
);
802 err
= PTR_ERR(ufs
->upper_mnt
);
803 if (IS_ERR(ufs
->upper_mnt
)) {
804 pr_err("overlayfs: failed to clone upperpath\n");
805 goto out_put_lowerpath
;
807 /* Don't inherit atime flags */
808 ufs
->upper_mnt
->mnt_flags
&= ~(MNT_NOATIME
| MNT_NODIRATIME
| MNT_RELATIME
);
810 sb
->s_time_gran
= ufs
->upper_mnt
->mnt_sb
->s_time_gran
;
812 ufs
->workdir
= ovl_workdir_create(ufs
->upper_mnt
, workpath
.dentry
);
813 err
= PTR_ERR(ufs
->workdir
);
814 if (IS_ERR(ufs
->workdir
)) {
815 pr_warn("overlayfs: failed to create directory %s/%s (errno: %i); mounting read-only\n",
816 ufs
->config
.workdir
, OVL_WORKDIR_NAME
, -err
);
817 sb
->s_flags
|= MS_RDONLY
;
822 * Upper should support d_type, else whiteouts are visible.
823 * Given workdir and upper are on same fs, we can do
824 * iterate_dir() on workdir. This check requires successful
825 * creation of workdir in previous step.
828 err
= ovl_check_d_type_supported(&workpath
);
830 goto out_put_workdir
;
833 * We allowed this configuration and don't want to
834 * break users over kernel upgrade. So warn instead
838 pr_warn("overlayfs: upper fs needs to support d_type.\n");
843 ufs
->lower_mnt
= kcalloc(numlower
, sizeof(struct vfsmount
*), GFP_KERNEL
);
844 if (ufs
->lower_mnt
== NULL
)
845 goto out_put_workdir
;
846 for (i
= 0; i
< numlower
; i
++) {
847 struct vfsmount
*mnt
= clone_private_mount(&stack
[i
]);
851 pr_err("overlayfs: failed to clone lowerpath\n");
852 goto out_put_lower_mnt
;
855 * Make lower_mnt R/O. That way fchmod/fchown on lower file
856 * will fail instead of modifying lower fs.
858 mnt
->mnt_flags
|= MNT_READONLY
| MNT_NOATIME
;
860 ufs
->lower_mnt
[ufs
->numlower
] = mnt
;
864 /* If the upper fs is nonexistent, we mark overlayfs r/o too */
866 sb
->s_flags
|= MS_RDONLY
;
869 sb
->s_d_op
= &ovl_reval_dentry_operations
;
871 sb
->s_d_op
= &ovl_dentry_operations
;
873 ufs
->creator_cred
= prepare_creds();
874 if (!ufs
->creator_cred
)
875 goto out_put_lower_mnt
;
878 oe
= ovl_alloc_entry(numlower
);
882 sb
->s_magic
= OVERLAYFS_SUPER_MAGIC
;
883 sb
->s_op
= &ovl_super_operations
;
884 sb
->s_xattr
= ovl_xattr_handlers
;
886 sb
->s_flags
|= MS_POSIXACL
| MS_NOREMOTELOCK
;
888 root_dentry
= d_make_root(ovl_new_inode(sb
, S_IFDIR
, 0));
892 mntput(upperpath
.mnt
);
893 for (i
= 0; i
< numlower
; i
++)
894 mntput(stack
[i
].mnt
);
898 oe
->__upperdentry
= upperpath
.dentry
;
899 for (i
= 0; i
< numlower
; i
++) {
900 oe
->lowerstack
[i
].dentry
= stack
[i
].dentry
;
901 oe
->lowerstack
[i
].mnt
= ufs
->lower_mnt
[i
];
905 root_dentry
->d_fsdata
= oe
;
907 realinode
= d_inode(ovl_dentry_real(root_dentry
));
908 ovl_inode_init(d_inode(root_dentry
), realinode
, !!upperpath
.dentry
);
909 ovl_copyattr(realinode
, d_inode(root_dentry
));
911 sb
->s_root
= root_dentry
;
918 put_cred(ufs
->creator_cred
);
920 for (i
= 0; i
< ufs
->numlower
; i
++)
921 mntput(ufs
->lower_mnt
[i
]);
922 kfree(ufs
->lower_mnt
);
925 mntput(ufs
->upper_mnt
);
927 for (i
= 0; i
< numlower
; i
++)
935 path_put(&upperpath
);
937 kfree(ufs
->config
.lowerdir
);
938 kfree(ufs
->config
.upperdir
);
939 kfree(ufs
->config
.workdir
);
945 static struct dentry
*ovl_mount(struct file_system_type
*fs_type
, int flags
,
946 const char *dev_name
, void *raw_data
)
948 return mount_nodev(fs_type
, flags
, raw_data
, ovl_fill_super
);
951 static struct file_system_type ovl_fs_type
= {
952 .owner
= THIS_MODULE
,
955 .kill_sb
= kill_anon_super
,
957 MODULE_ALIAS_FS("overlay");
959 static int __init
ovl_init(void)
961 return register_filesystem(&ovl_fs_type
);
964 static void __exit
ovl_exit(void)
966 unregister_filesystem(&ovl_fs_type
);
969 module_init(ovl_init
);
970 module_exit(ovl_exit
);