1e9be9d5eSMiklos Szeredi /* 2e9be9d5eSMiklos Szeredi * 3e9be9d5eSMiklos Szeredi * Copyright (C) 2011 Novell Inc. 4e9be9d5eSMiklos Szeredi * 5e9be9d5eSMiklos Szeredi * This program is free software; you can redistribute it and/or modify it 6e9be9d5eSMiklos Szeredi * under the terms of the GNU General Public License version 2 as published by 7e9be9d5eSMiklos Szeredi * the Free Software Foundation. 8e9be9d5eSMiklos Szeredi */ 9e9be9d5eSMiklos Szeredi 10e9be9d5eSMiklos Szeredi #include <linux/fs.h> 11e9be9d5eSMiklos Szeredi #include <linux/namei.h> 12e9be9d5eSMiklos Szeredi #include <linux/xattr.h> 13e9be9d5eSMiklos Szeredi #include <linux/security.h> 14e9be9d5eSMiklos Szeredi #include <linux/mount.h> 15e9be9d5eSMiklos Szeredi #include <linux/slab.h> 16e9be9d5eSMiklos Szeredi #include <linux/parser.h> 17e9be9d5eSMiklos Szeredi #include <linux/module.h> 18e9be9d5eSMiklos Szeredi #include <linux/sched.h> 19cc259639SAndy Whitcroft #include <linux/statfs.h> 20f45827e8SErez Zadok #include <linux/seq_file.h> 21e9be9d5eSMiklos Szeredi #include "overlayfs.h" 22e9be9d5eSMiklos Szeredi 23e9be9d5eSMiklos Szeredi MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>"); 24e9be9d5eSMiklos Szeredi MODULE_DESCRIPTION("Overlay filesystem"); 25e9be9d5eSMiklos Szeredi MODULE_LICENSE("GPL"); 26e9be9d5eSMiklos Szeredi 27ef94b186SMiklos Szeredi #define OVERLAYFS_SUPER_MAGIC 0x794c7630 28cc259639SAndy Whitcroft 29f45827e8SErez Zadok struct ovl_config { 30f45827e8SErez Zadok char *lowerdir; 31f45827e8SErez Zadok char *upperdir; 32f45827e8SErez Zadok char *workdir; 33f45827e8SErez Zadok }; 34f45827e8SErez Zadok 35e9be9d5eSMiklos Szeredi /* private information held for overlayfs's superblock */ 36e9be9d5eSMiklos Szeredi struct ovl_fs { 37e9be9d5eSMiklos Szeredi struct vfsmount *upper_mnt; 38dd662667SMiklos Szeredi unsigned numlower; 39dd662667SMiklos Szeredi struct vfsmount **lower_mnt; 40e9be9d5eSMiklos Szeredi struct dentry *workdir; 41cc259639SAndy Whitcroft long lower_namelen; 42f45827e8SErez Zadok /* pathnames of lower and upper dirs, for show_options */ 43f45827e8SErez Zadok struct ovl_config config; 44e9be9d5eSMiklos Szeredi }; 45e9be9d5eSMiklos Szeredi 46e9be9d5eSMiklos Szeredi struct ovl_dir_cache; 47e9be9d5eSMiklos Szeredi 48e9be9d5eSMiklos Szeredi /* private information held for every overlayfs dentry */ 49e9be9d5eSMiklos Szeredi struct ovl_entry { 50e9be9d5eSMiklos Szeredi struct dentry *__upperdentry; 51e9be9d5eSMiklos Szeredi struct ovl_dir_cache *cache; 52e9be9d5eSMiklos Szeredi union { 53e9be9d5eSMiklos Szeredi struct { 54e9be9d5eSMiklos Szeredi u64 version; 55e9be9d5eSMiklos Szeredi bool opaque; 56e9be9d5eSMiklos Szeredi }; 57e9be9d5eSMiklos Szeredi struct rcu_head rcu; 58e9be9d5eSMiklos Szeredi }; 59dd662667SMiklos Szeredi unsigned numlower; 60dd662667SMiklos Szeredi struct path lowerstack[]; 61e9be9d5eSMiklos Szeredi }; 62e9be9d5eSMiklos Szeredi 63a78d9f0dSMiklos Szeredi #define OVL_MAX_STACK 500 64a78d9f0dSMiklos Szeredi 65dd662667SMiklos Szeredi static struct dentry *__ovl_dentry_lower(struct ovl_entry *oe) 66dd662667SMiklos Szeredi { 67dd662667SMiklos Szeredi return oe->numlower ? oe->lowerstack[0].dentry : NULL; 68dd662667SMiklos Szeredi } 69e9be9d5eSMiklos Szeredi 70e9be9d5eSMiklos Szeredi enum ovl_path_type ovl_path_type(struct dentry *dentry) 71e9be9d5eSMiklos Szeredi { 72e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 731afaba1eSMiklos Szeredi enum ovl_path_type type = 0; 74e9be9d5eSMiklos Szeredi 75e9be9d5eSMiklos Szeredi if (oe->__upperdentry) { 761afaba1eSMiklos Szeredi type = __OVL_PATH_UPPER; 771afaba1eSMiklos Szeredi 78dd662667SMiklos Szeredi if (oe->numlower) { 79e9be9d5eSMiklos Szeredi if (S_ISDIR(dentry->d_inode->i_mode)) 801afaba1eSMiklos Szeredi type |= __OVL_PATH_MERGE; 811afaba1eSMiklos Szeredi } else if (!oe->opaque) { 821afaba1eSMiklos Szeredi type |= __OVL_PATH_PURE; 83e9be9d5eSMiklos Szeredi } 849d7459d8SMiklos Szeredi } else { 859d7459d8SMiklos Szeredi if (oe->numlower > 1) 869d7459d8SMiklos Szeredi type |= __OVL_PATH_MERGE; 87e9be9d5eSMiklos Szeredi } 881afaba1eSMiklos Szeredi return type; 89e9be9d5eSMiklos Szeredi } 90e9be9d5eSMiklos Szeredi 91e9be9d5eSMiklos Szeredi static struct dentry *ovl_upperdentry_dereference(struct ovl_entry *oe) 92e9be9d5eSMiklos Szeredi { 9371d50928SMiklos Szeredi return lockless_dereference(oe->__upperdentry); 94e9be9d5eSMiklos Szeredi } 95e9be9d5eSMiklos Szeredi 96e9be9d5eSMiklos Szeredi void ovl_path_upper(struct dentry *dentry, struct path *path) 97e9be9d5eSMiklos Szeredi { 98e9be9d5eSMiklos Szeredi struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 99e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 100e9be9d5eSMiklos Szeredi 101e9be9d5eSMiklos Szeredi path->mnt = ofs->upper_mnt; 102e9be9d5eSMiklos Szeredi path->dentry = ovl_upperdentry_dereference(oe); 103e9be9d5eSMiklos Szeredi } 104e9be9d5eSMiklos Szeredi 105e9be9d5eSMiklos Szeredi enum ovl_path_type ovl_path_real(struct dentry *dentry, struct path *path) 106e9be9d5eSMiklos Szeredi { 107e9be9d5eSMiklos Szeredi enum ovl_path_type type = ovl_path_type(dentry); 108e9be9d5eSMiklos Szeredi 1091afaba1eSMiklos Szeredi if (!OVL_TYPE_UPPER(type)) 110e9be9d5eSMiklos Szeredi ovl_path_lower(dentry, path); 111e9be9d5eSMiklos Szeredi else 112e9be9d5eSMiklos Szeredi ovl_path_upper(dentry, path); 113e9be9d5eSMiklos Szeredi 114e9be9d5eSMiklos Szeredi return type; 115e9be9d5eSMiklos Szeredi } 116e9be9d5eSMiklos Szeredi 117e9be9d5eSMiklos Szeredi struct dentry *ovl_dentry_upper(struct dentry *dentry) 118e9be9d5eSMiklos Szeredi { 119e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 120e9be9d5eSMiklos Szeredi 121e9be9d5eSMiklos Szeredi return ovl_upperdentry_dereference(oe); 122e9be9d5eSMiklos Szeredi } 123e9be9d5eSMiklos Szeredi 124e9be9d5eSMiklos Szeredi struct dentry *ovl_dentry_lower(struct dentry *dentry) 125e9be9d5eSMiklos Szeredi { 126e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 127e9be9d5eSMiklos Szeredi 128dd662667SMiklos Szeredi return __ovl_dentry_lower(oe); 129e9be9d5eSMiklos Szeredi } 130e9be9d5eSMiklos Szeredi 131e9be9d5eSMiklos Szeredi struct dentry *ovl_dentry_real(struct dentry *dentry) 132e9be9d5eSMiklos Szeredi { 133e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 134e9be9d5eSMiklos Szeredi struct dentry *realdentry; 135e9be9d5eSMiklos Szeredi 136e9be9d5eSMiklos Szeredi realdentry = ovl_upperdentry_dereference(oe); 137e9be9d5eSMiklos Szeredi if (!realdentry) 138dd662667SMiklos Szeredi realdentry = __ovl_dentry_lower(oe); 139e9be9d5eSMiklos Szeredi 140e9be9d5eSMiklos Szeredi return realdentry; 141e9be9d5eSMiklos Szeredi } 142e9be9d5eSMiklos Szeredi 143e9be9d5eSMiklos Szeredi struct dentry *ovl_entry_real(struct ovl_entry *oe, bool *is_upper) 144e9be9d5eSMiklos Szeredi { 145e9be9d5eSMiklos Szeredi struct dentry *realdentry; 146e9be9d5eSMiklos Szeredi 147e9be9d5eSMiklos Szeredi realdentry = ovl_upperdentry_dereference(oe); 148e9be9d5eSMiklos Szeredi if (realdentry) { 149e9be9d5eSMiklos Szeredi *is_upper = true; 150e9be9d5eSMiklos Szeredi } else { 151dd662667SMiklos Szeredi realdentry = __ovl_dentry_lower(oe); 152e9be9d5eSMiklos Szeredi *is_upper = false; 153e9be9d5eSMiklos Szeredi } 154e9be9d5eSMiklos Szeredi return realdentry; 155e9be9d5eSMiklos Szeredi } 156e9be9d5eSMiklos Szeredi 157e9be9d5eSMiklos Szeredi struct ovl_dir_cache *ovl_dir_cache(struct dentry *dentry) 158e9be9d5eSMiklos Szeredi { 159e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 160e9be9d5eSMiklos Szeredi 161e9be9d5eSMiklos Szeredi return oe->cache; 162e9be9d5eSMiklos Szeredi } 163e9be9d5eSMiklos Szeredi 164e9be9d5eSMiklos Szeredi void ovl_set_dir_cache(struct dentry *dentry, struct ovl_dir_cache *cache) 165e9be9d5eSMiklos Szeredi { 166e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 167e9be9d5eSMiklos Szeredi 168e9be9d5eSMiklos Szeredi oe->cache = cache; 169e9be9d5eSMiklos Szeredi } 170e9be9d5eSMiklos Szeredi 171e9be9d5eSMiklos Szeredi void ovl_path_lower(struct dentry *dentry, struct path *path) 172e9be9d5eSMiklos Szeredi { 173e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 174e9be9d5eSMiklos Szeredi 175dd662667SMiklos Szeredi *path = oe->numlower ? oe->lowerstack[0] : (struct path) { NULL, NULL }; 176e9be9d5eSMiklos Szeredi } 177e9be9d5eSMiklos Szeredi 178e9be9d5eSMiklos Szeredi int ovl_want_write(struct dentry *dentry) 179e9be9d5eSMiklos Szeredi { 180e9be9d5eSMiklos Szeredi struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 181e9be9d5eSMiklos Szeredi return mnt_want_write(ofs->upper_mnt); 182e9be9d5eSMiklos Szeredi } 183e9be9d5eSMiklos Szeredi 184e9be9d5eSMiklos Szeredi void ovl_drop_write(struct dentry *dentry) 185e9be9d5eSMiklos Szeredi { 186e9be9d5eSMiklos Szeredi struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 187e9be9d5eSMiklos Szeredi mnt_drop_write(ofs->upper_mnt); 188e9be9d5eSMiklos Szeredi } 189e9be9d5eSMiklos Szeredi 190e9be9d5eSMiklos Szeredi struct dentry *ovl_workdir(struct dentry *dentry) 191e9be9d5eSMiklos Szeredi { 192e9be9d5eSMiklos Szeredi struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 193e9be9d5eSMiklos Szeredi return ofs->workdir; 194e9be9d5eSMiklos Szeredi } 195e9be9d5eSMiklos Szeredi 196e9be9d5eSMiklos Szeredi bool ovl_dentry_is_opaque(struct dentry *dentry) 197e9be9d5eSMiklos Szeredi { 198e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 199e9be9d5eSMiklos Szeredi return oe->opaque; 200e9be9d5eSMiklos Szeredi } 201e9be9d5eSMiklos Szeredi 202e9be9d5eSMiklos Szeredi void ovl_dentry_set_opaque(struct dentry *dentry, bool opaque) 203e9be9d5eSMiklos Szeredi { 204e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 205e9be9d5eSMiklos Szeredi oe->opaque = opaque; 206e9be9d5eSMiklos Szeredi } 207e9be9d5eSMiklos Szeredi 208e9be9d5eSMiklos Szeredi void ovl_dentry_update(struct dentry *dentry, struct dentry *upperdentry) 209e9be9d5eSMiklos Szeredi { 210e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 211e9be9d5eSMiklos Szeredi 212e9be9d5eSMiklos Szeredi WARN_ON(!mutex_is_locked(&upperdentry->d_parent->d_inode->i_mutex)); 213e9be9d5eSMiklos Szeredi WARN_ON(oe->__upperdentry); 214e9be9d5eSMiklos Szeredi BUG_ON(!upperdentry->d_inode); 215e9be9d5eSMiklos Szeredi /* 216e9be9d5eSMiklos Szeredi * Make sure upperdentry is consistent before making it visible to 217e9be9d5eSMiklos Szeredi * ovl_upperdentry_dereference(). 218e9be9d5eSMiklos Szeredi */ 219e9be9d5eSMiklos Szeredi smp_wmb(); 220e9be9d5eSMiklos Szeredi oe->__upperdentry = upperdentry; 221e9be9d5eSMiklos Szeredi } 222e9be9d5eSMiklos Szeredi 223e9be9d5eSMiklos Szeredi void ovl_dentry_version_inc(struct dentry *dentry) 224e9be9d5eSMiklos Szeredi { 225e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 226e9be9d5eSMiklos Szeredi 227e9be9d5eSMiklos Szeredi WARN_ON(!mutex_is_locked(&dentry->d_inode->i_mutex)); 228e9be9d5eSMiklos Szeredi oe->version++; 229e9be9d5eSMiklos Szeredi } 230e9be9d5eSMiklos Szeredi 231e9be9d5eSMiklos Szeredi u64 ovl_dentry_version_get(struct dentry *dentry) 232e9be9d5eSMiklos Szeredi { 233e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 234e9be9d5eSMiklos Szeredi 235e9be9d5eSMiklos Szeredi WARN_ON(!mutex_is_locked(&dentry->d_inode->i_mutex)); 236e9be9d5eSMiklos Szeredi return oe->version; 237e9be9d5eSMiklos Szeredi } 238e9be9d5eSMiklos Szeredi 239e9be9d5eSMiklos Szeredi bool ovl_is_whiteout(struct dentry *dentry) 240e9be9d5eSMiklos Szeredi { 241e9be9d5eSMiklos Szeredi struct inode *inode = dentry->d_inode; 242e9be9d5eSMiklos Szeredi 243e9be9d5eSMiklos Szeredi return inode && IS_WHITEOUT(inode); 244e9be9d5eSMiklos Szeredi } 245e9be9d5eSMiklos Szeredi 246e9be9d5eSMiklos Szeredi static bool ovl_is_opaquedir(struct dentry *dentry) 247e9be9d5eSMiklos Szeredi { 248e9be9d5eSMiklos Szeredi int res; 249e9be9d5eSMiklos Szeredi char val; 250e9be9d5eSMiklos Szeredi struct inode *inode = dentry->d_inode; 251e9be9d5eSMiklos Szeredi 252e9be9d5eSMiklos Szeredi if (!S_ISDIR(inode->i_mode) || !inode->i_op->getxattr) 253e9be9d5eSMiklos Szeredi return false; 254e9be9d5eSMiklos Szeredi 255cead89bbShujianyang res = inode->i_op->getxattr(dentry, OVL_XATTR_OPAQUE, &val, 1); 256e9be9d5eSMiklos Szeredi if (res == 1 && val == 'y') 257e9be9d5eSMiklos Szeredi return true; 258e9be9d5eSMiklos Szeredi 259e9be9d5eSMiklos Szeredi return false; 260e9be9d5eSMiklos Szeredi } 261e9be9d5eSMiklos Szeredi 262e9be9d5eSMiklos Szeredi static void ovl_dentry_release(struct dentry *dentry) 263e9be9d5eSMiklos Szeredi { 264e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 265e9be9d5eSMiklos Szeredi 266e9be9d5eSMiklos Szeredi if (oe) { 267dd662667SMiklos Szeredi unsigned int i; 268dd662667SMiklos Szeredi 269e9be9d5eSMiklos Szeredi dput(oe->__upperdentry); 270dd662667SMiklos Szeredi for (i = 0; i < oe->numlower; i++) 271dd662667SMiklos Szeredi dput(oe->lowerstack[i].dentry); 272e9be9d5eSMiklos Szeredi kfree_rcu(oe, rcu); 273e9be9d5eSMiklos Szeredi } 274e9be9d5eSMiklos Szeredi } 275e9be9d5eSMiklos Szeredi 2767c03b5d4SMiklos Szeredi static int ovl_dentry_revalidate(struct dentry *dentry, unsigned int flags) 2777c03b5d4SMiklos Szeredi { 2787c03b5d4SMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 2797c03b5d4SMiklos Szeredi unsigned int i; 2807c03b5d4SMiklos Szeredi int ret = 1; 2817c03b5d4SMiklos Szeredi 2827c03b5d4SMiklos Szeredi for (i = 0; i < oe->numlower; i++) { 2837c03b5d4SMiklos Szeredi struct dentry *d = oe->lowerstack[i].dentry; 2847c03b5d4SMiklos Szeredi 2857c03b5d4SMiklos Szeredi if (d->d_flags & DCACHE_OP_REVALIDATE) { 2867c03b5d4SMiklos Szeredi ret = d->d_op->d_revalidate(d, flags); 2877c03b5d4SMiklos Szeredi if (ret < 0) 2887c03b5d4SMiklos Szeredi return ret; 2897c03b5d4SMiklos Szeredi if (!ret) { 2907c03b5d4SMiklos Szeredi if (!(flags & LOOKUP_RCU)) 2917c03b5d4SMiklos Szeredi d_invalidate(d); 2927c03b5d4SMiklos Szeredi return -ESTALE; 2937c03b5d4SMiklos Szeredi } 2947c03b5d4SMiklos Szeredi } 2957c03b5d4SMiklos Szeredi } 2967c03b5d4SMiklos Szeredi return 1; 2977c03b5d4SMiklos Szeredi } 2987c03b5d4SMiklos Szeredi 2997c03b5d4SMiklos Szeredi static int ovl_dentry_weak_revalidate(struct dentry *dentry, unsigned int flags) 3007c03b5d4SMiklos Szeredi { 3017c03b5d4SMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 3027c03b5d4SMiklos Szeredi unsigned int i; 3037c03b5d4SMiklos Szeredi int ret = 1; 3047c03b5d4SMiklos Szeredi 3057c03b5d4SMiklos Szeredi for (i = 0; i < oe->numlower; i++) { 3067c03b5d4SMiklos Szeredi struct dentry *d = oe->lowerstack[i].dentry; 3077c03b5d4SMiklos Szeredi 3087c03b5d4SMiklos Szeredi if (d->d_flags & DCACHE_OP_WEAK_REVALIDATE) { 3097c03b5d4SMiklos Szeredi ret = d->d_op->d_weak_revalidate(d, flags); 3107c03b5d4SMiklos Szeredi if (ret <= 0) 3117c03b5d4SMiklos Szeredi break; 3127c03b5d4SMiklos Szeredi } 3137c03b5d4SMiklos Szeredi } 3147c03b5d4SMiklos Szeredi return ret; 3157c03b5d4SMiklos Szeredi } 3167c03b5d4SMiklos Szeredi 317e9be9d5eSMiklos Szeredi static const struct dentry_operations ovl_dentry_operations = { 318e9be9d5eSMiklos Szeredi .d_release = ovl_dentry_release, 319e9be9d5eSMiklos Szeredi }; 320e9be9d5eSMiklos Szeredi 3217c03b5d4SMiklos Szeredi static const struct dentry_operations ovl_reval_dentry_operations = { 3227c03b5d4SMiklos Szeredi .d_release = ovl_dentry_release, 3237c03b5d4SMiklos Szeredi .d_revalidate = ovl_dentry_revalidate, 3247c03b5d4SMiklos Szeredi .d_weak_revalidate = ovl_dentry_weak_revalidate, 3257c03b5d4SMiklos Szeredi }; 3267c03b5d4SMiklos Szeredi 327dd662667SMiklos Szeredi static struct ovl_entry *ovl_alloc_entry(unsigned int numlower) 328e9be9d5eSMiklos Szeredi { 329dd662667SMiklos Szeredi size_t size = offsetof(struct ovl_entry, lowerstack[numlower]); 330dd662667SMiklos Szeredi struct ovl_entry *oe = kzalloc(size, GFP_KERNEL); 331dd662667SMiklos Szeredi 332dd662667SMiklos Szeredi if (oe) 333dd662667SMiklos Szeredi oe->numlower = numlower; 334dd662667SMiklos Szeredi 335dd662667SMiklos Szeredi return oe; 336e9be9d5eSMiklos Szeredi } 337e9be9d5eSMiklos Szeredi 3387c03b5d4SMiklos Szeredi static bool ovl_dentry_remote(struct dentry *dentry) 3397c03b5d4SMiklos Szeredi { 3407c03b5d4SMiklos Szeredi return dentry->d_flags & 3417c03b5d4SMiklos Szeredi (DCACHE_OP_REVALIDATE | DCACHE_OP_WEAK_REVALIDATE); 3427c03b5d4SMiklos Szeredi } 3437c03b5d4SMiklos Szeredi 3447c03b5d4SMiklos Szeredi static bool ovl_dentry_weird(struct dentry *dentry) 3457c03b5d4SMiklos Szeredi { 3467c03b5d4SMiklos Szeredi return dentry->d_flags & (DCACHE_NEED_AUTOMOUNT | 3477c03b5d4SMiklos Szeredi DCACHE_MANAGE_TRANSIT | 3487c03b5d4SMiklos Szeredi DCACHE_OP_HASH | 3497c03b5d4SMiklos Szeredi DCACHE_OP_COMPARE); 3507c03b5d4SMiklos Szeredi } 3517c03b5d4SMiklos Szeredi 352e9be9d5eSMiklos Szeredi static inline struct dentry *ovl_lookup_real(struct dentry *dir, 353e9be9d5eSMiklos Szeredi struct qstr *name) 354e9be9d5eSMiklos Szeredi { 355e9be9d5eSMiklos Szeredi struct dentry *dentry; 356e9be9d5eSMiklos Szeredi 357e9be9d5eSMiklos Szeredi mutex_lock(&dir->d_inode->i_mutex); 358e9be9d5eSMiklos Szeredi dentry = lookup_one_len(name->name, dir, name->len); 359e9be9d5eSMiklos Szeredi mutex_unlock(&dir->d_inode->i_mutex); 360e9be9d5eSMiklos Szeredi 361e9be9d5eSMiklos Szeredi if (IS_ERR(dentry)) { 362e9be9d5eSMiklos Szeredi if (PTR_ERR(dentry) == -ENOENT) 363e9be9d5eSMiklos Szeredi dentry = NULL; 364e9be9d5eSMiklos Szeredi } else if (!dentry->d_inode) { 365e9be9d5eSMiklos Szeredi dput(dentry); 366e9be9d5eSMiklos Szeredi dentry = NULL; 3677c03b5d4SMiklos Szeredi } else if (ovl_dentry_weird(dentry)) { 368a6f15d9aSMiklos Szeredi dput(dentry); 3697c03b5d4SMiklos Szeredi /* Don't support traversing automounts and other weirdness */ 370a6f15d9aSMiklos Szeredi dentry = ERR_PTR(-EREMOTE); 371e9be9d5eSMiklos Szeredi } 372e9be9d5eSMiklos Szeredi return dentry; 373e9be9d5eSMiklos Szeredi } 374e9be9d5eSMiklos Szeredi 3755ef88da5SMiklos Szeredi /* 3765ef88da5SMiklos Szeredi * Returns next layer in stack starting from top. 3775ef88da5SMiklos Szeredi * Returns -1 if this is the last layer. 3785ef88da5SMiklos Szeredi */ 3795ef88da5SMiklos Szeredi int ovl_path_next(int idx, struct dentry *dentry, struct path *path) 3805ef88da5SMiklos Szeredi { 3815ef88da5SMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 3825ef88da5SMiklos Szeredi 3835ef88da5SMiklos Szeredi BUG_ON(idx < 0); 3845ef88da5SMiklos Szeredi if (idx == 0) { 3855ef88da5SMiklos Szeredi ovl_path_upper(dentry, path); 3865ef88da5SMiklos Szeredi if (path->dentry) 3875ef88da5SMiklos Szeredi return oe->numlower ? 1 : -1; 3885ef88da5SMiklos Szeredi idx++; 3895ef88da5SMiklos Szeredi } 3905ef88da5SMiklos Szeredi BUG_ON(idx > oe->numlower); 3915ef88da5SMiklos Szeredi *path = oe->lowerstack[idx - 1]; 3925ef88da5SMiklos Szeredi 3935ef88da5SMiklos Szeredi return (idx < oe->numlower) ? idx + 1 : -1; 3945ef88da5SMiklos Szeredi } 3955ef88da5SMiklos Szeredi 396e9be9d5eSMiklos Szeredi struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry, 397e9be9d5eSMiklos Szeredi unsigned int flags) 398e9be9d5eSMiklos Szeredi { 399e9be9d5eSMiklos Szeredi struct ovl_entry *oe; 4003d3c6b89SMiklos Szeredi struct ovl_entry *poe = dentry->d_parent->d_fsdata; 4013d3c6b89SMiklos Szeredi struct path *stack = NULL; 4023d3c6b89SMiklos Szeredi struct dentry *upperdir, *upperdentry = NULL; 4033d3c6b89SMiklos Szeredi unsigned int ctr = 0; 404e9be9d5eSMiklos Szeredi struct inode *inode = NULL; 4053d3c6b89SMiklos Szeredi bool upperopaque = false; 4063d3c6b89SMiklos Szeredi struct dentry *this, *prev = NULL; 4073d3c6b89SMiklos Szeredi unsigned int i; 408e9be9d5eSMiklos Szeredi int err; 409e9be9d5eSMiklos Szeredi 4103d3c6b89SMiklos Szeredi upperdir = ovl_upperdentry_dereference(poe); 4113d3c6b89SMiklos Szeredi if (upperdir) { 4123d3c6b89SMiklos Szeredi this = ovl_lookup_real(upperdir, &dentry->d_name); 4133d3c6b89SMiklos Szeredi err = PTR_ERR(this); 4143d3c6b89SMiklos Szeredi if (IS_ERR(this)) 415e9be9d5eSMiklos Szeredi goto out; 416e9be9d5eSMiklos Szeredi 4173e01cee3SMiklos Szeredi if (this) { 4187c03b5d4SMiklos Szeredi if (unlikely(ovl_dentry_remote(this))) { 4197c03b5d4SMiklos Szeredi dput(this); 4207c03b5d4SMiklos Szeredi err = -EREMOTE; 4217c03b5d4SMiklos Szeredi goto out; 4227c03b5d4SMiklos Szeredi } 4233d3c6b89SMiklos Szeredi if (ovl_is_whiteout(this)) { 4243d3c6b89SMiklos Szeredi dput(this); 4253d3c6b89SMiklos Szeredi this = NULL; 4263d3c6b89SMiklos Szeredi upperopaque = true; 4273e01cee3SMiklos Szeredi } else if (poe->numlower && ovl_is_opaquedir(this)) { 4283d3c6b89SMiklos Szeredi upperopaque = true; 429e9be9d5eSMiklos Szeredi } 430e9be9d5eSMiklos Szeredi } 4313d3c6b89SMiklos Szeredi upperdentry = prev = this; 432e9be9d5eSMiklos Szeredi } 433e9be9d5eSMiklos Szeredi 4343d3c6b89SMiklos Szeredi if (!upperopaque && poe->numlower) { 4353d3c6b89SMiklos Szeredi err = -ENOMEM; 4363d3c6b89SMiklos Szeredi stack = kcalloc(poe->numlower, sizeof(struct path), GFP_KERNEL); 4373d3c6b89SMiklos Szeredi if (!stack) 4383d3c6b89SMiklos Szeredi goto out_put_upper; 439e9be9d5eSMiklos Szeredi } 440e9be9d5eSMiklos Szeredi 4413d3c6b89SMiklos Szeredi for (i = 0; !upperopaque && i < poe->numlower; i++) { 4423d3c6b89SMiklos Szeredi bool opaque = false; 4433d3c6b89SMiklos Szeredi struct path lowerpath = poe->lowerstack[i]; 4443d3c6b89SMiklos Szeredi 4453d3c6b89SMiklos Szeredi this = ovl_lookup_real(lowerpath.dentry, &dentry->d_name); 4463d3c6b89SMiklos Szeredi err = PTR_ERR(this); 44709e10322SMiklos Szeredi if (IS_ERR(this)) { 44809e10322SMiklos Szeredi /* 44909e10322SMiklos Szeredi * If it's positive, then treat ENAMETOOLONG as ENOENT. 45009e10322SMiklos Szeredi */ 45109e10322SMiklos Szeredi if (err == -ENAMETOOLONG && (upperdentry || ctr)) 45209e10322SMiklos Szeredi continue; 4533d3c6b89SMiklos Szeredi goto out_put; 45409e10322SMiklos Szeredi } 4553d3c6b89SMiklos Szeredi if (!this) 4563d3c6b89SMiklos Szeredi continue; 4573d3c6b89SMiklos Szeredi if (ovl_is_whiteout(this)) { 4583d3c6b89SMiklos Szeredi dput(this); 4593d3c6b89SMiklos Szeredi break; 4603e01cee3SMiklos Szeredi } 4613e01cee3SMiklos Szeredi /* 4623e01cee3SMiklos Szeredi * Only makes sense to check opaque dir if this is not the 4633e01cee3SMiklos Szeredi * lowermost layer. 4643e01cee3SMiklos Szeredi */ 4653e01cee3SMiklos Szeredi if (i < poe->numlower - 1 && ovl_is_opaquedir(this)) 4663d3c6b89SMiklos Szeredi opaque = true; 467a425c037Shujianyang 468a425c037Shujianyang if (prev && (!S_ISDIR(prev->d_inode->i_mode) || 4693d3c6b89SMiklos Szeredi !S_ISDIR(this->d_inode->i_mode))) { 470a425c037Shujianyang /* 471a425c037Shujianyang * FIXME: check for upper-opaqueness maybe better done 472a425c037Shujianyang * in remove code. 473a425c037Shujianyang */ 4743d3c6b89SMiklos Szeredi if (prev == upperdentry) 4753d3c6b89SMiklos Szeredi upperopaque = true; 4763d3c6b89SMiklos Szeredi dput(this); 4773d3c6b89SMiklos Szeredi break; 4783d3c6b89SMiklos Szeredi } 479a425c037Shujianyang /* 480a425c037Shujianyang * If this is a non-directory then stop here. 481a425c037Shujianyang */ 482a425c037Shujianyang if (!S_ISDIR(this->d_inode->i_mode)) 483a425c037Shujianyang opaque = true; 484a425c037Shujianyang 4853d3c6b89SMiklos Szeredi stack[ctr].dentry = this; 4863d3c6b89SMiklos Szeredi stack[ctr].mnt = lowerpath.mnt; 4873d3c6b89SMiklos Szeredi ctr++; 4883d3c6b89SMiklos Szeredi prev = this; 4893d3c6b89SMiklos Szeredi if (opaque) 4903d3c6b89SMiklos Szeredi break; 4913d3c6b89SMiklos Szeredi } 4923d3c6b89SMiklos Szeredi 4933d3c6b89SMiklos Szeredi oe = ovl_alloc_entry(ctr); 4943d3c6b89SMiklos Szeredi err = -ENOMEM; 4953d3c6b89SMiklos Szeredi if (!oe) 4963d3c6b89SMiklos Szeredi goto out_put; 4973d3c6b89SMiklos Szeredi 4983d3c6b89SMiklos Szeredi if (upperdentry || ctr) { 499e9be9d5eSMiklos Szeredi struct dentry *realdentry; 500e9be9d5eSMiklos Szeredi 5013d3c6b89SMiklos Szeredi realdentry = upperdentry ? upperdentry : stack[0].dentry; 5023d3c6b89SMiklos Szeredi 503e9be9d5eSMiklos Szeredi err = -ENOMEM; 504e9be9d5eSMiklos Szeredi inode = ovl_new_inode(dentry->d_sb, realdentry->d_inode->i_mode, 505e9be9d5eSMiklos Szeredi oe); 506e9be9d5eSMiklos Szeredi if (!inode) 5073d3c6b89SMiklos Szeredi goto out_free_oe; 508e9be9d5eSMiklos Szeredi ovl_copyattr(realdentry->d_inode, inode); 509e9be9d5eSMiklos Szeredi } 510e9be9d5eSMiklos Szeredi 5113d3c6b89SMiklos Szeredi oe->opaque = upperopaque; 512e9be9d5eSMiklos Szeredi oe->__upperdentry = upperdentry; 5133d3c6b89SMiklos Szeredi memcpy(oe->lowerstack, stack, sizeof(struct path) * ctr); 5143d3c6b89SMiklos Szeredi kfree(stack); 515e9be9d5eSMiklos Szeredi dentry->d_fsdata = oe; 516e9be9d5eSMiklos Szeredi d_add(dentry, inode); 517e9be9d5eSMiklos Szeredi 518e9be9d5eSMiklos Szeredi return NULL; 519e9be9d5eSMiklos Szeredi 5203d3c6b89SMiklos Szeredi out_free_oe: 521e9be9d5eSMiklos Szeredi kfree(oe); 5223d3c6b89SMiklos Szeredi out_put: 5233d3c6b89SMiklos Szeredi for (i = 0; i < ctr; i++) 5243d3c6b89SMiklos Szeredi dput(stack[i].dentry); 5253d3c6b89SMiklos Szeredi kfree(stack); 5263d3c6b89SMiklos Szeredi out_put_upper: 5273d3c6b89SMiklos Szeredi dput(upperdentry); 528e9be9d5eSMiklos Szeredi out: 529e9be9d5eSMiklos Szeredi return ERR_PTR(err); 530e9be9d5eSMiklos Szeredi } 531e9be9d5eSMiklos Szeredi 532e9be9d5eSMiklos Szeredi struct file *ovl_path_open(struct path *path, int flags) 533e9be9d5eSMiklos Szeredi { 534e9be9d5eSMiklos Szeredi return dentry_open(path, flags, current_cred()); 535e9be9d5eSMiklos Szeredi } 536e9be9d5eSMiklos Szeredi 537e9be9d5eSMiklos Szeredi static void ovl_put_super(struct super_block *sb) 538e9be9d5eSMiklos Szeredi { 539e9be9d5eSMiklos Szeredi struct ovl_fs *ufs = sb->s_fs_info; 540dd662667SMiklos Szeredi unsigned i; 541e9be9d5eSMiklos Szeredi 542e9be9d5eSMiklos Szeredi dput(ufs->workdir); 543e9be9d5eSMiklos Szeredi mntput(ufs->upper_mnt); 544dd662667SMiklos Szeredi for (i = 0; i < ufs->numlower; i++) 545dd662667SMiklos Szeredi mntput(ufs->lower_mnt[i]); 546e9be9d5eSMiklos Szeredi 547f45827e8SErez Zadok kfree(ufs->config.lowerdir); 548f45827e8SErez Zadok kfree(ufs->config.upperdir); 549f45827e8SErez Zadok kfree(ufs->config.workdir); 550e9be9d5eSMiklos Szeredi kfree(ufs); 551e9be9d5eSMiklos Szeredi } 552e9be9d5eSMiklos Szeredi 553cc259639SAndy Whitcroft /** 554cc259639SAndy Whitcroft * ovl_statfs 555cc259639SAndy Whitcroft * @sb: The overlayfs super block 556cc259639SAndy Whitcroft * @buf: The struct kstatfs to fill in with stats 557cc259639SAndy Whitcroft * 558cc259639SAndy Whitcroft * Get the filesystem statistics. As writes always target the upper layer 5594ebc5818SMiklos Szeredi * filesystem pass the statfs to the upper filesystem (if it exists) 560cc259639SAndy Whitcroft */ 561cc259639SAndy Whitcroft static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf) 562cc259639SAndy Whitcroft { 563cc259639SAndy Whitcroft struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 564cc259639SAndy Whitcroft struct dentry *root_dentry = dentry->d_sb->s_root; 565cc259639SAndy Whitcroft struct path path; 566cc259639SAndy Whitcroft int err; 567cc259639SAndy Whitcroft 5684ebc5818SMiklos Szeredi ovl_path_real(root_dentry, &path); 569cc259639SAndy Whitcroft 570cc259639SAndy Whitcroft err = vfs_statfs(&path, buf); 571cc259639SAndy Whitcroft if (!err) { 572cc259639SAndy Whitcroft buf->f_namelen = max(buf->f_namelen, ofs->lower_namelen); 573cc259639SAndy Whitcroft buf->f_type = OVERLAYFS_SUPER_MAGIC; 574cc259639SAndy Whitcroft } 575cc259639SAndy Whitcroft 576cc259639SAndy Whitcroft return err; 577cc259639SAndy Whitcroft } 578cc259639SAndy Whitcroft 579f45827e8SErez Zadok /** 580f45827e8SErez Zadok * ovl_show_options 581f45827e8SErez Zadok * 582f45827e8SErez Zadok * Prints the mount options for a given superblock. 583f45827e8SErez Zadok * Returns zero; does not fail. 584f45827e8SErez Zadok */ 585f45827e8SErez Zadok static int ovl_show_options(struct seq_file *m, struct dentry *dentry) 586f45827e8SErez Zadok { 587f45827e8SErez Zadok struct super_block *sb = dentry->d_sb; 588f45827e8SErez Zadok struct ovl_fs *ufs = sb->s_fs_info; 589f45827e8SErez Zadok 590f45827e8SErez Zadok seq_printf(m, ",lowerdir=%s", ufs->config.lowerdir); 59153a08cb9SMiklos Szeredi if (ufs->config.upperdir) { 592f45827e8SErez Zadok seq_printf(m, ",upperdir=%s", ufs->config.upperdir); 593f45827e8SErez Zadok seq_printf(m, ",workdir=%s", ufs->config.workdir); 59453a08cb9SMiklos Szeredi } 595f45827e8SErez Zadok return 0; 596f45827e8SErez Zadok } 597f45827e8SErez Zadok 5983cdf6fe9SSeunghun Lee static int ovl_remount(struct super_block *sb, int *flags, char *data) 5993cdf6fe9SSeunghun Lee { 6003cdf6fe9SSeunghun Lee struct ovl_fs *ufs = sb->s_fs_info; 6013cdf6fe9SSeunghun Lee 602cc6f67bcSMiklos Szeredi if (!(*flags & MS_RDONLY) && (!ufs->upper_mnt || !ufs->workdir)) 6033cdf6fe9SSeunghun Lee return -EROFS; 6043cdf6fe9SSeunghun Lee 6053cdf6fe9SSeunghun Lee return 0; 6063cdf6fe9SSeunghun Lee } 6073cdf6fe9SSeunghun Lee 608e9be9d5eSMiklos Szeredi static const struct super_operations ovl_super_operations = { 609e9be9d5eSMiklos Szeredi .put_super = ovl_put_super, 610cc259639SAndy Whitcroft .statfs = ovl_statfs, 611f45827e8SErez Zadok .show_options = ovl_show_options, 6123cdf6fe9SSeunghun Lee .remount_fs = ovl_remount, 613e9be9d5eSMiklos Szeredi }; 614e9be9d5eSMiklos Szeredi 615e9be9d5eSMiklos Szeredi enum { 616e9be9d5eSMiklos Szeredi OPT_LOWERDIR, 617e9be9d5eSMiklos Szeredi OPT_UPPERDIR, 618e9be9d5eSMiklos Szeredi OPT_WORKDIR, 619e9be9d5eSMiklos Szeredi OPT_ERR, 620e9be9d5eSMiklos Szeredi }; 621e9be9d5eSMiklos Szeredi 622e9be9d5eSMiklos Szeredi static const match_table_t ovl_tokens = { 623e9be9d5eSMiklos Szeredi {OPT_LOWERDIR, "lowerdir=%s"}, 624e9be9d5eSMiklos Szeredi {OPT_UPPERDIR, "upperdir=%s"}, 625e9be9d5eSMiklos Szeredi {OPT_WORKDIR, "workdir=%s"}, 626e9be9d5eSMiklos Szeredi {OPT_ERR, NULL} 627e9be9d5eSMiklos Szeredi }; 628e9be9d5eSMiklos Szeredi 62991c77947SMiklos Szeredi static char *ovl_next_opt(char **s) 63091c77947SMiklos Szeredi { 63191c77947SMiklos Szeredi char *sbegin = *s; 63291c77947SMiklos Szeredi char *p; 63391c77947SMiklos Szeredi 63491c77947SMiklos Szeredi if (sbegin == NULL) 63591c77947SMiklos Szeredi return NULL; 63691c77947SMiklos Szeredi 63791c77947SMiklos Szeredi for (p = sbegin; *p; p++) { 63891c77947SMiklos Szeredi if (*p == '\\') { 63991c77947SMiklos Szeredi p++; 64091c77947SMiklos Szeredi if (!*p) 64191c77947SMiklos Szeredi break; 64291c77947SMiklos Szeredi } else if (*p == ',') { 64391c77947SMiklos Szeredi *p = '\0'; 64491c77947SMiklos Szeredi *s = p + 1; 64591c77947SMiklos Szeredi return sbegin; 64691c77947SMiklos Szeredi } 64791c77947SMiklos Szeredi } 64891c77947SMiklos Szeredi *s = NULL; 64991c77947SMiklos Szeredi return sbegin; 65091c77947SMiklos Szeredi } 65191c77947SMiklos Szeredi 652e9be9d5eSMiklos Szeredi static int ovl_parse_opt(char *opt, struct ovl_config *config) 653e9be9d5eSMiklos Szeredi { 654e9be9d5eSMiklos Szeredi char *p; 655e9be9d5eSMiklos Szeredi 65691c77947SMiklos Szeredi while ((p = ovl_next_opt(&opt)) != NULL) { 657e9be9d5eSMiklos Szeredi int token; 658e9be9d5eSMiklos Szeredi substring_t args[MAX_OPT_ARGS]; 659e9be9d5eSMiklos Szeredi 660e9be9d5eSMiklos Szeredi if (!*p) 661e9be9d5eSMiklos Szeredi continue; 662e9be9d5eSMiklos Szeredi 663e9be9d5eSMiklos Szeredi token = match_token(p, ovl_tokens, args); 664e9be9d5eSMiklos Szeredi switch (token) { 665e9be9d5eSMiklos Szeredi case OPT_UPPERDIR: 666e9be9d5eSMiklos Szeredi kfree(config->upperdir); 667e9be9d5eSMiklos Szeredi config->upperdir = match_strdup(&args[0]); 668e9be9d5eSMiklos Szeredi if (!config->upperdir) 669e9be9d5eSMiklos Szeredi return -ENOMEM; 670e9be9d5eSMiklos Szeredi break; 671e9be9d5eSMiklos Szeredi 672e9be9d5eSMiklos Szeredi case OPT_LOWERDIR: 673e9be9d5eSMiklos Szeredi kfree(config->lowerdir); 674e9be9d5eSMiklos Szeredi config->lowerdir = match_strdup(&args[0]); 675e9be9d5eSMiklos Szeredi if (!config->lowerdir) 676e9be9d5eSMiklos Szeredi return -ENOMEM; 677e9be9d5eSMiklos Szeredi break; 678e9be9d5eSMiklos Szeredi 679e9be9d5eSMiklos Szeredi case OPT_WORKDIR: 680e9be9d5eSMiklos Szeredi kfree(config->workdir); 681e9be9d5eSMiklos Szeredi config->workdir = match_strdup(&args[0]); 682e9be9d5eSMiklos Szeredi if (!config->workdir) 683e9be9d5eSMiklos Szeredi return -ENOMEM; 684e9be9d5eSMiklos Szeredi break; 685e9be9d5eSMiklos Szeredi 686e9be9d5eSMiklos Szeredi default: 687bead55efShujianyang pr_err("overlayfs: unrecognized mount option \"%s\" or missing value\n", p); 688e9be9d5eSMiklos Szeredi return -EINVAL; 689e9be9d5eSMiklos Szeredi } 690e9be9d5eSMiklos Szeredi } 69171cbad7eShujianyang 69271cbad7eShujianyang /* Workdir is useless in non-upper mount */ 69371cbad7eShujianyang if (!config->upperdir && config->workdir) { 69471cbad7eShujianyang pr_info("overlayfs: option \"workdir=%s\" is useless in a non-upper mount, ignore\n", 69571cbad7eShujianyang config->workdir); 69671cbad7eShujianyang kfree(config->workdir); 69771cbad7eShujianyang config->workdir = NULL; 69871cbad7eShujianyang } 69971cbad7eShujianyang 700e9be9d5eSMiklos Szeredi return 0; 701e9be9d5eSMiklos Szeredi } 702e9be9d5eSMiklos Szeredi 703e9be9d5eSMiklos Szeredi #define OVL_WORKDIR_NAME "work" 704e9be9d5eSMiklos Szeredi 705e9be9d5eSMiklos Szeredi static struct dentry *ovl_workdir_create(struct vfsmount *mnt, 706e9be9d5eSMiklos Szeredi struct dentry *dentry) 707e9be9d5eSMiklos Szeredi { 708e9be9d5eSMiklos Szeredi struct inode *dir = dentry->d_inode; 709e9be9d5eSMiklos Szeredi struct dentry *work; 710e9be9d5eSMiklos Szeredi int err; 711e9be9d5eSMiklos Szeredi bool retried = false; 712e9be9d5eSMiklos Szeredi 713e9be9d5eSMiklos Szeredi err = mnt_want_write(mnt); 714e9be9d5eSMiklos Szeredi if (err) 715e9be9d5eSMiklos Szeredi return ERR_PTR(err); 716e9be9d5eSMiklos Szeredi 717e9be9d5eSMiklos Szeredi mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT); 718e9be9d5eSMiklos Szeredi retry: 719e9be9d5eSMiklos Szeredi work = lookup_one_len(OVL_WORKDIR_NAME, dentry, 720e9be9d5eSMiklos Szeredi strlen(OVL_WORKDIR_NAME)); 721e9be9d5eSMiklos Szeredi 722e9be9d5eSMiklos Szeredi if (!IS_ERR(work)) { 723e9be9d5eSMiklos Szeredi struct kstat stat = { 724e9be9d5eSMiklos Szeredi .mode = S_IFDIR | 0, 725e9be9d5eSMiklos Szeredi }; 726e9be9d5eSMiklos Szeredi 727e9be9d5eSMiklos Szeredi if (work->d_inode) { 728e9be9d5eSMiklos Szeredi err = -EEXIST; 729e9be9d5eSMiklos Szeredi if (retried) 730e9be9d5eSMiklos Szeredi goto out_dput; 731e9be9d5eSMiklos Szeredi 732e9be9d5eSMiklos Szeredi retried = true; 733e9be9d5eSMiklos Szeredi ovl_cleanup(dir, work); 734e9be9d5eSMiklos Szeredi dput(work); 735e9be9d5eSMiklos Szeredi goto retry; 736e9be9d5eSMiklos Szeredi } 737e9be9d5eSMiklos Szeredi 738e9be9d5eSMiklos Szeredi err = ovl_create_real(dir, work, &stat, NULL, NULL, true); 739e9be9d5eSMiklos Szeredi if (err) 740e9be9d5eSMiklos Szeredi goto out_dput; 741e9be9d5eSMiklos Szeredi } 742e9be9d5eSMiklos Szeredi out_unlock: 743e9be9d5eSMiklos Szeredi mutex_unlock(&dir->i_mutex); 744e9be9d5eSMiklos Szeredi mnt_drop_write(mnt); 745e9be9d5eSMiklos Szeredi 746e9be9d5eSMiklos Szeredi return work; 747e9be9d5eSMiklos Szeredi 748e9be9d5eSMiklos Szeredi out_dput: 749e9be9d5eSMiklos Szeredi dput(work); 750e9be9d5eSMiklos Szeredi work = ERR_PTR(err); 751e9be9d5eSMiklos Szeredi goto out_unlock; 752e9be9d5eSMiklos Szeredi } 753e9be9d5eSMiklos Szeredi 75491c77947SMiklos Szeredi static void ovl_unescape(char *s) 75591c77947SMiklos Szeredi { 75691c77947SMiklos Szeredi char *d = s; 75791c77947SMiklos Szeredi 75891c77947SMiklos Szeredi for (;; s++, d++) { 75991c77947SMiklos Szeredi if (*s == '\\') 76091c77947SMiklos Szeredi s++; 76191c77947SMiklos Szeredi *d = *s; 76291c77947SMiklos Szeredi if (!*s) 76391c77947SMiklos Szeredi break; 76491c77947SMiklos Szeredi } 76591c77947SMiklos Szeredi } 76691c77947SMiklos Szeredi 767ab508822SMiklos Szeredi static int ovl_mount_dir_noesc(const char *name, struct path *path) 768ab508822SMiklos Szeredi { 769a78d9f0dSMiklos Szeredi int err = -EINVAL; 770ab508822SMiklos Szeredi 771a78d9f0dSMiklos Szeredi if (!*name) { 772a78d9f0dSMiklos Szeredi pr_err("overlayfs: empty lowerdir\n"); 773a78d9f0dSMiklos Szeredi goto out; 774a78d9f0dSMiklos Szeredi } 775ab508822SMiklos Szeredi err = kern_path(name, LOOKUP_FOLLOW, path); 776ab508822SMiklos Szeredi if (err) { 777ab508822SMiklos Szeredi pr_err("overlayfs: failed to resolve '%s': %i\n", name, err); 778ab508822SMiklos Szeredi goto out; 779ab508822SMiklos Szeredi } 780ab508822SMiklos Szeredi err = -EINVAL; 7817c03b5d4SMiklos Szeredi if (ovl_dentry_weird(path->dentry)) { 782ab508822SMiklos Szeredi pr_err("overlayfs: filesystem on '%s' not supported\n", name); 783ab508822SMiklos Szeredi goto out_put; 784ab508822SMiklos Szeredi } 785ab508822SMiklos Szeredi if (!S_ISDIR(path->dentry->d_inode->i_mode)) { 786ab508822SMiklos Szeredi pr_err("overlayfs: '%s' not a directory\n", name); 787ab508822SMiklos Szeredi goto out_put; 788ab508822SMiklos Szeredi } 789ab508822SMiklos Szeredi return 0; 790ab508822SMiklos Szeredi 791ab508822SMiklos Szeredi out_put: 792ab508822SMiklos Szeredi path_put(path); 793ab508822SMiklos Szeredi out: 794ab508822SMiklos Szeredi return err; 795ab508822SMiklos Szeredi } 796ab508822SMiklos Szeredi 797ab508822SMiklos Szeredi static int ovl_mount_dir(const char *name, struct path *path) 798ab508822SMiklos Szeredi { 799ab508822SMiklos Szeredi int err = -ENOMEM; 800ab508822SMiklos Szeredi char *tmp = kstrdup(name, GFP_KERNEL); 801ab508822SMiklos Szeredi 802ab508822SMiklos Szeredi if (tmp) { 803ab508822SMiklos Szeredi ovl_unescape(tmp); 804ab508822SMiklos Szeredi err = ovl_mount_dir_noesc(tmp, path); 8057c03b5d4SMiklos Szeredi 8067c03b5d4SMiklos Szeredi if (!err) 8077c03b5d4SMiklos Szeredi if (ovl_dentry_remote(path->dentry)) { 8087c03b5d4SMiklos Szeredi pr_err("overlayfs: filesystem on '%s' not supported as upperdir\n", 8097c03b5d4SMiklos Szeredi tmp); 8107c03b5d4SMiklos Szeredi path_put(path); 8117c03b5d4SMiklos Szeredi err = -EINVAL; 8127c03b5d4SMiklos Szeredi } 813ab508822SMiklos Szeredi kfree(tmp); 814ab508822SMiklos Szeredi } 815ab508822SMiklos Szeredi return err; 816ab508822SMiklos Szeredi } 817ab508822SMiklos Szeredi 818ab508822SMiklos Szeredi static int ovl_lower_dir(const char *name, struct path *path, long *namelen, 8197c03b5d4SMiklos Szeredi int *stack_depth, bool *remote) 820ab508822SMiklos Szeredi { 821ab508822SMiklos Szeredi int err; 822ab508822SMiklos Szeredi struct kstatfs statfs; 823ab508822SMiklos Szeredi 824a78d9f0dSMiklos Szeredi err = ovl_mount_dir_noesc(name, path); 825ab508822SMiklos Szeredi if (err) 826ab508822SMiklos Szeredi goto out; 827ab508822SMiklos Szeredi 828ab508822SMiklos Szeredi err = vfs_statfs(path, &statfs); 829ab508822SMiklos Szeredi if (err) { 830ab508822SMiklos Szeredi pr_err("overlayfs: statfs failed on '%s'\n", name); 831ab508822SMiklos Szeredi goto out_put; 832ab508822SMiklos Szeredi } 833ab508822SMiklos Szeredi *namelen = max(*namelen, statfs.f_namelen); 834ab508822SMiklos Szeredi *stack_depth = max(*stack_depth, path->mnt->mnt_sb->s_stack_depth); 835ab508822SMiklos Szeredi 8367c03b5d4SMiklos Szeredi if (ovl_dentry_remote(path->dentry)) 8377c03b5d4SMiklos Szeredi *remote = true; 8387c03b5d4SMiklos Szeredi 839ab508822SMiklos Szeredi return 0; 840ab508822SMiklos Szeredi 841ab508822SMiklos Szeredi out_put: 842ab508822SMiklos Szeredi path_put(path); 843ab508822SMiklos Szeredi out: 844ab508822SMiklos Szeredi return err; 845ab508822SMiklos Szeredi } 846ab508822SMiklos Szeredi 847e9be9d5eSMiklos Szeredi /* Workdir should not be subdir of upperdir and vice versa */ 848e9be9d5eSMiklos Szeredi static bool ovl_workdir_ok(struct dentry *workdir, struct dentry *upperdir) 849e9be9d5eSMiklos Szeredi { 850e9be9d5eSMiklos Szeredi bool ok = false; 851e9be9d5eSMiklos Szeredi 852e9be9d5eSMiklos Szeredi if (workdir != upperdir) { 853e9be9d5eSMiklos Szeredi ok = (lock_rename(workdir, upperdir) == NULL); 854e9be9d5eSMiklos Szeredi unlock_rename(workdir, upperdir); 855e9be9d5eSMiklos Szeredi } 856e9be9d5eSMiklos Szeredi return ok; 857e9be9d5eSMiklos Szeredi } 858e9be9d5eSMiklos Szeredi 859a78d9f0dSMiklos Szeredi static unsigned int ovl_split_lowerdirs(char *str) 860a78d9f0dSMiklos Szeredi { 861a78d9f0dSMiklos Szeredi unsigned int ctr = 1; 862a78d9f0dSMiklos Szeredi char *s, *d; 863a78d9f0dSMiklos Szeredi 864a78d9f0dSMiklos Szeredi for (s = d = str;; s++, d++) { 865a78d9f0dSMiklos Szeredi if (*s == '\\') { 866a78d9f0dSMiklos Szeredi s++; 867a78d9f0dSMiklos Szeredi } else if (*s == ':') { 868a78d9f0dSMiklos Szeredi *d = '\0'; 869a78d9f0dSMiklos Szeredi ctr++; 870a78d9f0dSMiklos Szeredi continue; 871a78d9f0dSMiklos Szeredi } 872a78d9f0dSMiklos Szeredi *d = *s; 873a78d9f0dSMiklos Szeredi if (!*s) 874a78d9f0dSMiklos Szeredi break; 875a78d9f0dSMiklos Szeredi } 876a78d9f0dSMiklos Szeredi return ctr; 877a78d9f0dSMiklos Szeredi } 878a78d9f0dSMiklos Szeredi 879e9be9d5eSMiklos Szeredi static int ovl_fill_super(struct super_block *sb, void *data, int silent) 880e9be9d5eSMiklos Szeredi { 88153a08cb9SMiklos Szeredi struct path upperpath = { NULL, NULL }; 88253a08cb9SMiklos Szeredi struct path workpath = { NULL, NULL }; 883e9be9d5eSMiklos Szeredi struct dentry *root_dentry; 884e9be9d5eSMiklos Szeredi struct ovl_entry *oe; 885e9be9d5eSMiklos Szeredi struct ovl_fs *ufs; 886a78d9f0dSMiklos Szeredi struct path *stack = NULL; 887a78d9f0dSMiklos Szeredi char *lowertmp; 888a78d9f0dSMiklos Szeredi char *lower; 889a78d9f0dSMiklos Szeredi unsigned int numlower; 890a78d9f0dSMiklos Szeredi unsigned int stacklen = 0; 891dd662667SMiklos Szeredi unsigned int i; 8927c03b5d4SMiklos Szeredi bool remote = false; 893e9be9d5eSMiklos Szeredi int err; 894e9be9d5eSMiklos Szeredi 895f45827e8SErez Zadok err = -ENOMEM; 896f45827e8SErez Zadok ufs = kzalloc(sizeof(struct ovl_fs), GFP_KERNEL); 897f45827e8SErez Zadok if (!ufs) 898e9be9d5eSMiklos Szeredi goto out; 899e9be9d5eSMiklos Szeredi 900f45827e8SErez Zadok err = ovl_parse_opt((char *) data, &ufs->config); 901f45827e8SErez Zadok if (err) 902f45827e8SErez Zadok goto out_free_config; 903f45827e8SErez Zadok 904e9be9d5eSMiklos Szeredi err = -EINVAL; 90553a08cb9SMiklos Szeredi if (!ufs->config.lowerdir) { 90653a08cb9SMiklos Szeredi pr_err("overlayfs: missing 'lowerdir'\n"); 90753a08cb9SMiklos Szeredi goto out_free_config; 90853a08cb9SMiklos Szeredi } 90953a08cb9SMiklos Szeredi 91053a08cb9SMiklos Szeredi sb->s_stack_depth = 0; 91153a08cb9SMiklos Szeredi if (ufs->config.upperdir) { 91253a08cb9SMiklos Szeredi if (!ufs->config.workdir) { 91353a08cb9SMiklos Szeredi pr_err("overlayfs: missing 'workdir'\n"); 914e9be9d5eSMiklos Szeredi goto out_free_config; 915e9be9d5eSMiklos Szeredi } 916e9be9d5eSMiklos Szeredi 917f45827e8SErez Zadok err = ovl_mount_dir(ufs->config.upperdir, &upperpath); 918e9be9d5eSMiklos Szeredi if (err) 9193b7a9a24SMiklos Szeredi goto out_free_config; 920e9be9d5eSMiklos Szeredi 92171cbad7eShujianyang /* Upper fs should not be r/o */ 92271cbad7eShujianyang if (upperpath.mnt->mnt_sb->s_flags & MS_RDONLY) { 92371cbad7eShujianyang pr_err("overlayfs: upper fs is r/o, try multi-lower layers mount\n"); 92471cbad7eShujianyang err = -EINVAL; 92571cbad7eShujianyang goto out_put_upperpath; 92671cbad7eShujianyang } 92771cbad7eShujianyang 928f45827e8SErez Zadok err = ovl_mount_dir(ufs->config.workdir, &workpath); 929e9be9d5eSMiklos Szeredi if (err) 9303b7a9a24SMiklos Szeredi goto out_put_upperpath; 9313b7a9a24SMiklos Szeredi 9322f83fd8cShujianyang err = -EINVAL; 933ab508822SMiklos Szeredi if (upperpath.mnt != workpath.mnt) { 934ab508822SMiklos Szeredi pr_err("overlayfs: workdir and upperdir must reside under the same mount\n"); 935ab508822SMiklos Szeredi goto out_put_workpath; 936ab508822SMiklos Szeredi } 937ab508822SMiklos Szeredi if (!ovl_workdir_ok(workpath.dentry, upperpath.dentry)) { 938ab508822SMiklos Szeredi pr_err("overlayfs: workdir and upperdir must be separate subtrees\n"); 939ab508822SMiklos Szeredi goto out_put_workpath; 940ab508822SMiklos Szeredi } 941ab508822SMiklos Szeredi sb->s_stack_depth = upperpath.mnt->mnt_sb->s_stack_depth; 94253a08cb9SMiklos Szeredi } 943a78d9f0dSMiklos Szeredi err = -ENOMEM; 944a78d9f0dSMiklos Szeredi lowertmp = kstrdup(ufs->config.lowerdir, GFP_KERNEL); 945a78d9f0dSMiklos Szeredi if (!lowertmp) 946a78d9f0dSMiklos Szeredi goto out_put_workpath; 947ab508822SMiklos Szeredi 948a78d9f0dSMiklos Szeredi err = -EINVAL; 949a78d9f0dSMiklos Szeredi stacklen = ovl_split_lowerdirs(lowertmp); 9506be4506eShujianyang if (stacklen > OVL_MAX_STACK) { 9516be4506eShujianyang pr_err("overlayfs: too many lower directries, limit is %d\n", 9526be4506eShujianyang OVL_MAX_STACK); 953a78d9f0dSMiklos Szeredi goto out_free_lowertmp; 9546be4506eShujianyang } else if (!ufs->config.upperdir && stacklen == 1) { 9556be4506eShujianyang pr_err("overlayfs: at least 2 lowerdir are needed while upperdir nonexistent\n"); 9566be4506eShujianyang goto out_free_lowertmp; 9576be4506eShujianyang } 958a78d9f0dSMiklos Szeredi 959a78d9f0dSMiklos Szeredi stack = kcalloc(stacklen, sizeof(struct path), GFP_KERNEL); 960a78d9f0dSMiklos Szeredi if (!stack) 961a78d9f0dSMiklos Szeredi goto out_free_lowertmp; 962a78d9f0dSMiklos Szeredi 963a78d9f0dSMiklos Szeredi lower = lowertmp; 964a78d9f0dSMiklos Szeredi for (numlower = 0; numlower < stacklen; numlower++) { 965a78d9f0dSMiklos Szeredi err = ovl_lower_dir(lower, &stack[numlower], 9667c03b5d4SMiklos Szeredi &ufs->lower_namelen, &sb->s_stack_depth, 9677c03b5d4SMiklos Szeredi &remote); 9683b7a9a24SMiklos Szeredi if (err) 969a78d9f0dSMiklos Szeredi goto out_put_lowerpath; 970a78d9f0dSMiklos Szeredi 971a78d9f0dSMiklos Szeredi lower = strchr(lower, '\0') + 1; 972a78d9f0dSMiklos Szeredi } 973e9be9d5eSMiklos Szeredi 974e9be9d5eSMiklos Szeredi err = -EINVAL; 975ab508822SMiklos Szeredi sb->s_stack_depth++; 97669c433edSMiklos Szeredi if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { 97769c433edSMiklos Szeredi pr_err("overlayfs: maximum fs stacking depth exceeded\n"); 9783b7a9a24SMiklos Szeredi goto out_put_lowerpath; 97969c433edSMiklos Szeredi } 98069c433edSMiklos Szeredi 98153a08cb9SMiklos Szeredi if (ufs->config.upperdir) { 982e9be9d5eSMiklos Szeredi ufs->upper_mnt = clone_private_mount(&upperpath); 983e9be9d5eSMiklos Szeredi err = PTR_ERR(ufs->upper_mnt); 984e9be9d5eSMiklos Szeredi if (IS_ERR(ufs->upper_mnt)) { 985e9be9d5eSMiklos Szeredi pr_err("overlayfs: failed to clone upperpath\n"); 9863b7a9a24SMiklos Szeredi goto out_put_lowerpath; 9873b7a9a24SMiklos Szeredi } 9883b7a9a24SMiklos Szeredi 9893b7a9a24SMiklos Szeredi ufs->workdir = ovl_workdir_create(ufs->upper_mnt, workpath.dentry); 9903b7a9a24SMiklos Szeredi err = PTR_ERR(ufs->workdir); 9913b7a9a24SMiklos Szeredi if (IS_ERR(ufs->workdir)) { 992cc6f67bcSMiklos Szeredi pr_warn("overlayfs: failed to create directory %s/%s (errno: %i); mounting read-only\n", 993cc6f67bcSMiklos Szeredi ufs->config.workdir, OVL_WORKDIR_NAME, -err); 994cc6f67bcSMiklos Szeredi sb->s_flags |= MS_RDONLY; 995cc6f67bcSMiklos Szeredi ufs->workdir = NULL; 996e9be9d5eSMiklos Szeredi } 99753a08cb9SMiklos Szeredi } 998e9be9d5eSMiklos Szeredi 9992f83fd8cShujianyang err = -ENOMEM; 1000a78d9f0dSMiklos Szeredi ufs->lower_mnt = kcalloc(numlower, sizeof(struct vfsmount *), GFP_KERNEL); 1001dd662667SMiklos Szeredi if (ufs->lower_mnt == NULL) 10023b7a9a24SMiklos Szeredi goto out_put_workdir; 1003a78d9f0dSMiklos Szeredi for (i = 0; i < numlower; i++) { 1004a78d9f0dSMiklos Szeredi struct vfsmount *mnt = clone_private_mount(&stack[i]); 1005dd662667SMiklos Szeredi 10062f83fd8cShujianyang err = PTR_ERR(mnt); 1007dd662667SMiklos Szeredi if (IS_ERR(mnt)) { 1008dd662667SMiklos Szeredi pr_err("overlayfs: failed to clone lowerpath\n"); 1009dd662667SMiklos Szeredi goto out_put_lower_mnt; 1010e9be9d5eSMiklos Szeredi } 1011dd662667SMiklos Szeredi /* 1012dd662667SMiklos Szeredi * Make lower_mnt R/O. That way fchmod/fchown on lower file 1013dd662667SMiklos Szeredi * will fail instead of modifying lower fs. 1014dd662667SMiklos Szeredi */ 1015dd662667SMiklos Szeredi mnt->mnt_flags |= MNT_READONLY; 1016dd662667SMiklos Szeredi 1017a78d9f0dSMiklos Szeredi ufs->lower_mnt[ufs->numlower] = mnt; 1018a78d9f0dSMiklos Szeredi ufs->numlower++; 1019a78d9f0dSMiklos Szeredi } 1020e9be9d5eSMiklos Szeredi 102171cbad7eShujianyang /* If the upper fs is nonexistent, we mark overlayfs r/o too */ 102271cbad7eShujianyang if (!ufs->upper_mnt) 1023e9be9d5eSMiklos Szeredi sb->s_flags |= MS_RDONLY; 1024e9be9d5eSMiklos Szeredi 10257c03b5d4SMiklos Szeredi if (remote) 10267c03b5d4SMiklos Szeredi sb->s_d_op = &ovl_reval_dentry_operations; 10277c03b5d4SMiklos Szeredi else 1028e9be9d5eSMiklos Szeredi sb->s_d_op = &ovl_dentry_operations; 1029e9be9d5eSMiklos Szeredi 1030e9be9d5eSMiklos Szeredi err = -ENOMEM; 1031a78d9f0dSMiklos Szeredi oe = ovl_alloc_entry(numlower); 10323b7a9a24SMiklos Szeredi if (!oe) 10333b7a9a24SMiklos Szeredi goto out_put_lower_mnt; 1034e9be9d5eSMiklos Szeredi 10353b7a9a24SMiklos Szeredi root_dentry = d_make_root(ovl_new_inode(sb, S_IFDIR, oe)); 1036e9be9d5eSMiklos Szeredi if (!root_dentry) 10373b7a9a24SMiklos Szeredi goto out_free_oe; 1038e9be9d5eSMiklos Szeredi 1039e9be9d5eSMiklos Szeredi mntput(upperpath.mnt); 1040a78d9f0dSMiklos Szeredi for (i = 0; i < numlower; i++) 1041a78d9f0dSMiklos Szeredi mntput(stack[i].mnt); 1042e9be9d5eSMiklos Szeredi path_put(&workpath); 1043a78d9f0dSMiklos Szeredi kfree(lowertmp); 1044e9be9d5eSMiklos Szeredi 1045e9be9d5eSMiklos Szeredi oe->__upperdentry = upperpath.dentry; 1046a78d9f0dSMiklos Szeredi for (i = 0; i < numlower; i++) { 1047a78d9f0dSMiklos Szeredi oe->lowerstack[i].dentry = stack[i].dentry; 1048a78d9f0dSMiklos Szeredi oe->lowerstack[i].mnt = ufs->lower_mnt[i]; 1049a78d9f0dSMiklos Szeredi } 1050e9be9d5eSMiklos Szeredi 1051e9be9d5eSMiklos Szeredi root_dentry->d_fsdata = oe; 1052e9be9d5eSMiklos Szeredi 1053cc259639SAndy Whitcroft sb->s_magic = OVERLAYFS_SUPER_MAGIC; 1054e9be9d5eSMiklos Szeredi sb->s_op = &ovl_super_operations; 1055e9be9d5eSMiklos Szeredi sb->s_root = root_dentry; 1056e9be9d5eSMiklos Szeredi sb->s_fs_info = ufs; 1057e9be9d5eSMiklos Szeredi 1058e9be9d5eSMiklos Szeredi return 0; 1059e9be9d5eSMiklos Szeredi 10603b7a9a24SMiklos Szeredi out_free_oe: 10613b7a9a24SMiklos Szeredi kfree(oe); 1062e9be9d5eSMiklos Szeredi out_put_lower_mnt: 1063dd662667SMiklos Szeredi for (i = 0; i < ufs->numlower; i++) 1064dd662667SMiklos Szeredi mntput(ufs->lower_mnt[i]); 1065dd662667SMiklos Szeredi kfree(ufs->lower_mnt); 10663b7a9a24SMiklos Szeredi out_put_workdir: 10673b7a9a24SMiklos Szeredi dput(ufs->workdir); 1068e9be9d5eSMiklos Szeredi mntput(ufs->upper_mnt); 1069e9be9d5eSMiklos Szeredi out_put_lowerpath: 1070a78d9f0dSMiklos Szeredi for (i = 0; i < numlower; i++) 1071a78d9f0dSMiklos Szeredi path_put(&stack[i]); 1072a78d9f0dSMiklos Szeredi kfree(stack); 1073a78d9f0dSMiklos Szeredi out_free_lowertmp: 1074a78d9f0dSMiklos Szeredi kfree(lowertmp); 10753b7a9a24SMiklos Szeredi out_put_workpath: 10763b7a9a24SMiklos Szeredi path_put(&workpath); 1077e9be9d5eSMiklos Szeredi out_put_upperpath: 1078e9be9d5eSMiklos Szeredi path_put(&upperpath); 1079e9be9d5eSMiklos Szeredi out_free_config: 1080f45827e8SErez Zadok kfree(ufs->config.lowerdir); 1081f45827e8SErez Zadok kfree(ufs->config.upperdir); 1082f45827e8SErez Zadok kfree(ufs->config.workdir); 1083f45827e8SErez Zadok kfree(ufs); 1084e9be9d5eSMiklos Szeredi out: 1085e9be9d5eSMiklos Szeredi return err; 1086e9be9d5eSMiklos Szeredi } 1087e9be9d5eSMiklos Szeredi 1088e9be9d5eSMiklos Szeredi static struct dentry *ovl_mount(struct file_system_type *fs_type, int flags, 1089e9be9d5eSMiklos Szeredi const char *dev_name, void *raw_data) 1090e9be9d5eSMiklos Szeredi { 1091e9be9d5eSMiklos Szeredi return mount_nodev(fs_type, flags, raw_data, ovl_fill_super); 1092e9be9d5eSMiklos Szeredi } 1093e9be9d5eSMiklos Szeredi 1094e9be9d5eSMiklos Szeredi static struct file_system_type ovl_fs_type = { 1095e9be9d5eSMiklos Szeredi .owner = THIS_MODULE, 1096ef94b186SMiklos Szeredi .name = "overlay", 1097e9be9d5eSMiklos Szeredi .mount = ovl_mount, 1098e9be9d5eSMiklos Szeredi .kill_sb = kill_anon_super, 1099e9be9d5eSMiklos Szeredi }; 1100ef94b186SMiklos Szeredi MODULE_ALIAS_FS("overlay"); 1101e9be9d5eSMiklos Szeredi 1102e9be9d5eSMiklos Szeredi static int __init ovl_init(void) 1103e9be9d5eSMiklos Szeredi { 1104e9be9d5eSMiklos Szeredi return register_filesystem(&ovl_fs_type); 1105e9be9d5eSMiklos Szeredi } 1106e9be9d5eSMiklos Szeredi 1107e9be9d5eSMiklos Szeredi static void __exit ovl_exit(void) 1108e9be9d5eSMiklos Szeredi { 1109e9be9d5eSMiklos Szeredi unregister_filesystem(&ovl_fs_type); 1110e9be9d5eSMiklos Szeredi } 1111e9be9d5eSMiklos Szeredi 1112e9be9d5eSMiklos Szeredi module_init(ovl_init); 1113e9be9d5eSMiklos Szeredi module_exit(ovl_exit); 1114