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 63e9be9d5eSMiklos Szeredi const char *ovl_opaque_xattr = "trusted.overlay.opaque"; 64e9be9d5eSMiklos 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 108e9be9d5eSMiklos Szeredi enum ovl_path_type type = ovl_path_type(dentry); 109e9be9d5eSMiklos Szeredi 1101afaba1eSMiklos Szeredi if (!OVL_TYPE_UPPER(type)) 111e9be9d5eSMiklos Szeredi ovl_path_lower(dentry, path); 112e9be9d5eSMiklos Szeredi else 113e9be9d5eSMiklos Szeredi ovl_path_upper(dentry, path); 114e9be9d5eSMiklos Szeredi 115e9be9d5eSMiklos Szeredi return type; 116e9be9d5eSMiklos Szeredi } 117e9be9d5eSMiklos Szeredi 118e9be9d5eSMiklos Szeredi struct dentry *ovl_dentry_upper(struct dentry *dentry) 119e9be9d5eSMiklos Szeredi { 120e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 121e9be9d5eSMiklos Szeredi 122e9be9d5eSMiklos Szeredi return ovl_upperdentry_dereference(oe); 123e9be9d5eSMiklos Szeredi } 124e9be9d5eSMiklos Szeredi 125e9be9d5eSMiklos Szeredi struct dentry *ovl_dentry_lower(struct dentry *dentry) 126e9be9d5eSMiklos Szeredi { 127e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 128e9be9d5eSMiklos Szeredi 129dd662667SMiklos Szeredi return __ovl_dentry_lower(oe); 130e9be9d5eSMiklos Szeredi } 131e9be9d5eSMiklos Szeredi 132e9be9d5eSMiklos Szeredi struct dentry *ovl_dentry_real(struct dentry *dentry) 133e9be9d5eSMiklos Szeredi { 134e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 135e9be9d5eSMiklos Szeredi struct dentry *realdentry; 136e9be9d5eSMiklos Szeredi 137e9be9d5eSMiklos Szeredi realdentry = ovl_upperdentry_dereference(oe); 138e9be9d5eSMiklos Szeredi if (!realdentry) 139dd662667SMiklos Szeredi realdentry = __ovl_dentry_lower(oe); 140e9be9d5eSMiklos Szeredi 141e9be9d5eSMiklos Szeredi return realdentry; 142e9be9d5eSMiklos Szeredi } 143e9be9d5eSMiklos Szeredi 144e9be9d5eSMiklos Szeredi struct dentry *ovl_entry_real(struct ovl_entry *oe, bool *is_upper) 145e9be9d5eSMiklos Szeredi { 146e9be9d5eSMiklos Szeredi struct dentry *realdentry; 147e9be9d5eSMiklos Szeredi 148e9be9d5eSMiklos Szeredi realdentry = ovl_upperdentry_dereference(oe); 149e9be9d5eSMiklos Szeredi if (realdentry) { 150e9be9d5eSMiklos Szeredi *is_upper = true; 151e9be9d5eSMiklos Szeredi } else { 152dd662667SMiklos Szeredi realdentry = __ovl_dentry_lower(oe); 153e9be9d5eSMiklos Szeredi *is_upper = false; 154e9be9d5eSMiklos Szeredi } 155e9be9d5eSMiklos Szeredi return realdentry; 156e9be9d5eSMiklos Szeredi } 157e9be9d5eSMiklos Szeredi 158e9be9d5eSMiklos Szeredi struct ovl_dir_cache *ovl_dir_cache(struct dentry *dentry) 159e9be9d5eSMiklos Szeredi { 160e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 161e9be9d5eSMiklos Szeredi 162e9be9d5eSMiklos Szeredi return oe->cache; 163e9be9d5eSMiklos Szeredi } 164e9be9d5eSMiklos Szeredi 165e9be9d5eSMiklos Szeredi void ovl_set_dir_cache(struct dentry *dentry, struct ovl_dir_cache *cache) 166e9be9d5eSMiklos Szeredi { 167e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 168e9be9d5eSMiklos Szeredi 169e9be9d5eSMiklos Szeredi oe->cache = cache; 170e9be9d5eSMiklos Szeredi } 171e9be9d5eSMiklos Szeredi 172e9be9d5eSMiklos Szeredi void ovl_path_lower(struct dentry *dentry, struct path *path) 173e9be9d5eSMiklos Szeredi { 174e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 175e9be9d5eSMiklos Szeredi 176dd662667SMiklos Szeredi *path = oe->numlower ? oe->lowerstack[0] : (struct path) { NULL, NULL }; 177e9be9d5eSMiklos Szeredi } 178e9be9d5eSMiklos Szeredi 179e9be9d5eSMiklos Szeredi int ovl_want_write(struct dentry *dentry) 180e9be9d5eSMiklos Szeredi { 181e9be9d5eSMiklos Szeredi struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 182e9be9d5eSMiklos Szeredi return mnt_want_write(ofs->upper_mnt); 183e9be9d5eSMiklos Szeredi } 184e9be9d5eSMiklos Szeredi 185e9be9d5eSMiklos Szeredi void ovl_drop_write(struct dentry *dentry) 186e9be9d5eSMiklos Szeredi { 187e9be9d5eSMiklos Szeredi struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 188e9be9d5eSMiklos Szeredi mnt_drop_write(ofs->upper_mnt); 189e9be9d5eSMiklos Szeredi } 190e9be9d5eSMiklos Szeredi 191e9be9d5eSMiklos Szeredi struct dentry *ovl_workdir(struct dentry *dentry) 192e9be9d5eSMiklos Szeredi { 193e9be9d5eSMiklos Szeredi struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 194e9be9d5eSMiklos Szeredi return ofs->workdir; 195e9be9d5eSMiklos Szeredi } 196e9be9d5eSMiklos Szeredi 197e9be9d5eSMiklos Szeredi bool ovl_dentry_is_opaque(struct dentry *dentry) 198e9be9d5eSMiklos Szeredi { 199e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 200e9be9d5eSMiklos Szeredi return oe->opaque; 201e9be9d5eSMiklos Szeredi } 202e9be9d5eSMiklos Szeredi 203e9be9d5eSMiklos Szeredi void ovl_dentry_set_opaque(struct dentry *dentry, bool opaque) 204e9be9d5eSMiklos Szeredi { 205e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 206e9be9d5eSMiklos Szeredi oe->opaque = opaque; 207e9be9d5eSMiklos Szeredi } 208e9be9d5eSMiklos Szeredi 209e9be9d5eSMiklos Szeredi void ovl_dentry_update(struct dentry *dentry, struct dentry *upperdentry) 210e9be9d5eSMiklos Szeredi { 211e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 212e9be9d5eSMiklos Szeredi 213e9be9d5eSMiklos Szeredi WARN_ON(!mutex_is_locked(&upperdentry->d_parent->d_inode->i_mutex)); 214e9be9d5eSMiklos Szeredi WARN_ON(oe->__upperdentry); 215e9be9d5eSMiklos Szeredi BUG_ON(!upperdentry->d_inode); 216e9be9d5eSMiklos Szeredi /* 217e9be9d5eSMiklos Szeredi * Make sure upperdentry is consistent before making it visible to 218e9be9d5eSMiklos Szeredi * ovl_upperdentry_dereference(). 219e9be9d5eSMiklos Szeredi */ 220e9be9d5eSMiklos Szeredi smp_wmb(); 221e9be9d5eSMiklos Szeredi oe->__upperdentry = upperdentry; 222e9be9d5eSMiklos Szeredi } 223e9be9d5eSMiklos Szeredi 224e9be9d5eSMiklos Szeredi void ovl_dentry_version_inc(struct dentry *dentry) 225e9be9d5eSMiklos Szeredi { 226e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 227e9be9d5eSMiklos Szeredi 228e9be9d5eSMiklos Szeredi WARN_ON(!mutex_is_locked(&dentry->d_inode->i_mutex)); 229e9be9d5eSMiklos Szeredi oe->version++; 230e9be9d5eSMiklos Szeredi } 231e9be9d5eSMiklos Szeredi 232e9be9d5eSMiklos Szeredi u64 ovl_dentry_version_get(struct dentry *dentry) 233e9be9d5eSMiklos Szeredi { 234e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 235e9be9d5eSMiklos Szeredi 236e9be9d5eSMiklos Szeredi WARN_ON(!mutex_is_locked(&dentry->d_inode->i_mutex)); 237e9be9d5eSMiklos Szeredi return oe->version; 238e9be9d5eSMiklos Szeredi } 239e9be9d5eSMiklos Szeredi 240e9be9d5eSMiklos Szeredi bool ovl_is_whiteout(struct dentry *dentry) 241e9be9d5eSMiklos Szeredi { 242e9be9d5eSMiklos Szeredi struct inode *inode = dentry->d_inode; 243e9be9d5eSMiklos Szeredi 244e9be9d5eSMiklos Szeredi return inode && IS_WHITEOUT(inode); 245e9be9d5eSMiklos Szeredi } 246e9be9d5eSMiklos Szeredi 247e9be9d5eSMiklos Szeredi static bool ovl_is_opaquedir(struct dentry *dentry) 248e9be9d5eSMiklos Szeredi { 249e9be9d5eSMiklos Szeredi int res; 250e9be9d5eSMiklos Szeredi char val; 251e9be9d5eSMiklos Szeredi struct inode *inode = dentry->d_inode; 252e9be9d5eSMiklos Szeredi 253e9be9d5eSMiklos Szeredi if (!S_ISDIR(inode->i_mode) || !inode->i_op->getxattr) 254e9be9d5eSMiklos Szeredi return false; 255e9be9d5eSMiklos Szeredi 256e9be9d5eSMiklos Szeredi res = inode->i_op->getxattr(dentry, ovl_opaque_xattr, &val, 1); 257e9be9d5eSMiklos Szeredi if (res == 1 && val == 'y') 258e9be9d5eSMiklos Szeredi return true; 259e9be9d5eSMiklos Szeredi 260e9be9d5eSMiklos Szeredi return false; 261e9be9d5eSMiklos Szeredi } 262e9be9d5eSMiklos Szeredi 263e9be9d5eSMiklos Szeredi static void ovl_dentry_release(struct dentry *dentry) 264e9be9d5eSMiklos Szeredi { 265e9be9d5eSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 266e9be9d5eSMiklos Szeredi 267e9be9d5eSMiklos Szeredi if (oe) { 268dd662667SMiklos Szeredi unsigned int i; 269dd662667SMiklos Szeredi 270e9be9d5eSMiklos Szeredi dput(oe->__upperdentry); 271dd662667SMiklos Szeredi for (i = 0; i < oe->numlower; i++) 272dd662667SMiklos Szeredi dput(oe->lowerstack[i].dentry); 273e9be9d5eSMiklos Szeredi kfree_rcu(oe, rcu); 274e9be9d5eSMiklos Szeredi } 275e9be9d5eSMiklos Szeredi } 276e9be9d5eSMiklos Szeredi 277e9be9d5eSMiklos Szeredi static const struct dentry_operations ovl_dentry_operations = { 278e9be9d5eSMiklos Szeredi .d_release = ovl_dentry_release, 279e9be9d5eSMiklos Szeredi }; 280e9be9d5eSMiklos Szeredi 281dd662667SMiklos Szeredi static struct ovl_entry *ovl_alloc_entry(unsigned int numlower) 282e9be9d5eSMiklos Szeredi { 283dd662667SMiklos Szeredi size_t size = offsetof(struct ovl_entry, lowerstack[numlower]); 284dd662667SMiklos Szeredi struct ovl_entry *oe = kzalloc(size, GFP_KERNEL); 285dd662667SMiklos Szeredi 286dd662667SMiklos Szeredi if (oe) 287dd662667SMiklos Szeredi oe->numlower = numlower; 288dd662667SMiklos Szeredi 289dd662667SMiklos Szeredi return oe; 290e9be9d5eSMiklos Szeredi } 291e9be9d5eSMiklos Szeredi 292e9be9d5eSMiklos Szeredi static inline struct dentry *ovl_lookup_real(struct dentry *dir, 293e9be9d5eSMiklos Szeredi struct qstr *name) 294e9be9d5eSMiklos Szeredi { 295e9be9d5eSMiklos Szeredi struct dentry *dentry; 296e9be9d5eSMiklos Szeredi 297e9be9d5eSMiklos Szeredi mutex_lock(&dir->d_inode->i_mutex); 298e9be9d5eSMiklos Szeredi dentry = lookup_one_len(name->name, dir, name->len); 299e9be9d5eSMiklos Szeredi mutex_unlock(&dir->d_inode->i_mutex); 300e9be9d5eSMiklos Szeredi 301e9be9d5eSMiklos Szeredi if (IS_ERR(dentry)) { 302e9be9d5eSMiklos Szeredi if (PTR_ERR(dentry) == -ENOENT) 303e9be9d5eSMiklos Szeredi dentry = NULL; 304e9be9d5eSMiklos Szeredi } else if (!dentry->d_inode) { 305e9be9d5eSMiklos Szeredi dput(dentry); 306e9be9d5eSMiklos Szeredi dentry = NULL; 307e9be9d5eSMiklos Szeredi } 308e9be9d5eSMiklos Szeredi return dentry; 309e9be9d5eSMiklos Szeredi } 310e9be9d5eSMiklos Szeredi 3115ef88da5SMiklos Szeredi /* 3125ef88da5SMiklos Szeredi * Returns next layer in stack starting from top. 3135ef88da5SMiklos Szeredi * Returns -1 if this is the last layer. 3145ef88da5SMiklos Szeredi */ 3155ef88da5SMiklos Szeredi int ovl_path_next(int idx, struct dentry *dentry, struct path *path) 3165ef88da5SMiklos Szeredi { 3175ef88da5SMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 3185ef88da5SMiklos Szeredi 3195ef88da5SMiklos Szeredi BUG_ON(idx < 0); 3205ef88da5SMiklos Szeredi if (idx == 0) { 3215ef88da5SMiklos Szeredi ovl_path_upper(dentry, path); 3225ef88da5SMiklos Szeredi if (path->dentry) 3235ef88da5SMiklos Szeredi return oe->numlower ? 1 : -1; 3245ef88da5SMiklos Szeredi idx++; 3255ef88da5SMiklos Szeredi } 3265ef88da5SMiklos Szeredi BUG_ON(idx > oe->numlower); 3275ef88da5SMiklos Szeredi *path = oe->lowerstack[idx - 1]; 3285ef88da5SMiklos Szeredi 3295ef88da5SMiklos Szeredi return (idx < oe->numlower) ? idx + 1 : -1; 3305ef88da5SMiklos Szeredi } 3315ef88da5SMiklos Szeredi 332e9be9d5eSMiklos Szeredi struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry, 333e9be9d5eSMiklos Szeredi unsigned int flags) 334e9be9d5eSMiklos Szeredi { 335e9be9d5eSMiklos Szeredi struct ovl_entry *oe; 3363d3c6b89SMiklos Szeredi struct ovl_entry *poe = dentry->d_parent->d_fsdata; 3373d3c6b89SMiklos Szeredi struct path *stack = NULL; 3383d3c6b89SMiklos Szeredi struct dentry *upperdir, *upperdentry = NULL; 3393d3c6b89SMiklos Szeredi unsigned int ctr = 0; 340e9be9d5eSMiklos Szeredi struct inode *inode = NULL; 3413d3c6b89SMiklos Szeredi bool upperopaque = false; 3423d3c6b89SMiklos Szeredi struct dentry *this, *prev = NULL; 3433d3c6b89SMiklos Szeredi unsigned int i; 344e9be9d5eSMiklos Szeredi int err; 345e9be9d5eSMiklos Szeredi 3463d3c6b89SMiklos Szeredi upperdir = ovl_upperdentry_dereference(poe); 3473d3c6b89SMiklos Szeredi if (upperdir) { 3483d3c6b89SMiklos Szeredi this = ovl_lookup_real(upperdir, &dentry->d_name); 3493d3c6b89SMiklos Szeredi err = PTR_ERR(this); 3503d3c6b89SMiklos Szeredi if (IS_ERR(this)) 351e9be9d5eSMiklos Szeredi goto out; 352e9be9d5eSMiklos Szeredi 3533e01cee3SMiklos Szeredi if (this) { 3543d3c6b89SMiklos Szeredi if (ovl_is_whiteout(this)) { 3553d3c6b89SMiklos Szeredi dput(this); 3563d3c6b89SMiklos Szeredi this = NULL; 3573d3c6b89SMiklos Szeredi upperopaque = true; 3583e01cee3SMiklos Szeredi } else if (poe->numlower && ovl_is_opaquedir(this)) { 3593d3c6b89SMiklos Szeredi upperopaque = true; 360e9be9d5eSMiklos Szeredi } 361e9be9d5eSMiklos Szeredi } 3623d3c6b89SMiklos Szeredi upperdentry = prev = this; 363e9be9d5eSMiklos Szeredi } 364e9be9d5eSMiklos Szeredi 3653d3c6b89SMiklos Szeredi if (!upperopaque && poe->numlower) { 3663d3c6b89SMiklos Szeredi err = -ENOMEM; 3673d3c6b89SMiklos Szeredi stack = kcalloc(poe->numlower, sizeof(struct path), GFP_KERNEL); 3683d3c6b89SMiklos Szeredi if (!stack) 3693d3c6b89SMiklos Szeredi goto out_put_upper; 370e9be9d5eSMiklos Szeredi } 371e9be9d5eSMiklos Szeredi 3723d3c6b89SMiklos Szeredi for (i = 0; !upperopaque && i < poe->numlower; i++) { 3733d3c6b89SMiklos Szeredi bool opaque = false; 3743d3c6b89SMiklos Szeredi struct path lowerpath = poe->lowerstack[i]; 3753d3c6b89SMiklos Szeredi 3763d3c6b89SMiklos Szeredi opaque = false; 3773d3c6b89SMiklos Szeredi this = ovl_lookup_real(lowerpath.dentry, &dentry->d_name); 3783d3c6b89SMiklos Szeredi err = PTR_ERR(this); 37909e10322SMiklos Szeredi if (IS_ERR(this)) { 38009e10322SMiklos Szeredi /* 38109e10322SMiklos Szeredi * If it's positive, then treat ENAMETOOLONG as ENOENT. 38209e10322SMiklos Szeredi */ 38309e10322SMiklos Szeredi if (err == -ENAMETOOLONG && (upperdentry || ctr)) 38409e10322SMiklos Szeredi continue; 3853d3c6b89SMiklos Szeredi goto out_put; 38609e10322SMiklos Szeredi } 3873d3c6b89SMiklos Szeredi if (!this) 3883d3c6b89SMiklos Szeredi continue; 3893d3c6b89SMiklos Szeredi if (ovl_is_whiteout(this)) { 3903d3c6b89SMiklos Szeredi dput(this); 3913d3c6b89SMiklos Szeredi break; 3923e01cee3SMiklos Szeredi } 3933e01cee3SMiklos Szeredi /* 3943e01cee3SMiklos Szeredi * Only makes sense to check opaque dir if this is not the 3953e01cee3SMiklos Szeredi * lowermost layer. 3963e01cee3SMiklos Szeredi */ 3973e01cee3SMiklos Szeredi if (i < poe->numlower - 1 && ovl_is_opaquedir(this)) 3983d3c6b89SMiklos Szeredi opaque = true; 3993d3c6b89SMiklos Szeredi /* 4003d3c6b89SMiklos Szeredi * If this is a non-directory then stop here. 4013d3c6b89SMiklos Szeredi * 4023d3c6b89SMiklos Szeredi * FIXME: check for opaqueness maybe better done in remove code. 4033d3c6b89SMiklos Szeredi */ 4043d3c6b89SMiklos Szeredi if (!S_ISDIR(this->d_inode->i_mode)) { 4053d3c6b89SMiklos Szeredi opaque = true; 4063d3c6b89SMiklos Szeredi } else if (prev && (!S_ISDIR(prev->d_inode->i_mode) || 4073d3c6b89SMiklos Szeredi !S_ISDIR(this->d_inode->i_mode))) { 4083d3c6b89SMiklos Szeredi if (prev == upperdentry) 4093d3c6b89SMiklos Szeredi upperopaque = true; 4103d3c6b89SMiklos Szeredi dput(this); 4113d3c6b89SMiklos Szeredi break; 4123d3c6b89SMiklos Szeredi } 4133d3c6b89SMiklos Szeredi stack[ctr].dentry = this; 4143d3c6b89SMiklos Szeredi stack[ctr].mnt = lowerpath.mnt; 4153d3c6b89SMiklos Szeredi ctr++; 4163d3c6b89SMiklos Szeredi prev = this; 4173d3c6b89SMiklos Szeredi if (opaque) 4183d3c6b89SMiklos Szeredi break; 4193d3c6b89SMiklos Szeredi } 4203d3c6b89SMiklos Szeredi 4213d3c6b89SMiklos Szeredi oe = ovl_alloc_entry(ctr); 4223d3c6b89SMiklos Szeredi err = -ENOMEM; 4233d3c6b89SMiklos Szeredi if (!oe) 4243d3c6b89SMiklos Szeredi goto out_put; 4253d3c6b89SMiklos Szeredi 4263d3c6b89SMiklos Szeredi if (upperdentry || ctr) { 427e9be9d5eSMiklos Szeredi struct dentry *realdentry; 428e9be9d5eSMiklos Szeredi 4293d3c6b89SMiklos Szeredi realdentry = upperdentry ? upperdentry : stack[0].dentry; 4303d3c6b89SMiklos Szeredi 431e9be9d5eSMiklos Szeredi err = -ENOMEM; 432e9be9d5eSMiklos Szeredi inode = ovl_new_inode(dentry->d_sb, realdentry->d_inode->i_mode, 433e9be9d5eSMiklos Szeredi oe); 434e9be9d5eSMiklos Szeredi if (!inode) 4353d3c6b89SMiklos Szeredi goto out_free_oe; 436e9be9d5eSMiklos Szeredi ovl_copyattr(realdentry->d_inode, inode); 437e9be9d5eSMiklos Szeredi } 438e9be9d5eSMiklos Szeredi 4393d3c6b89SMiklos Szeredi oe->opaque = upperopaque; 440e9be9d5eSMiklos Szeredi oe->__upperdentry = upperdentry; 4413d3c6b89SMiklos Szeredi memcpy(oe->lowerstack, stack, sizeof(struct path) * ctr); 4423d3c6b89SMiklos Szeredi kfree(stack); 443e9be9d5eSMiklos Szeredi dentry->d_fsdata = oe; 444e9be9d5eSMiklos Szeredi d_add(dentry, inode); 445e9be9d5eSMiklos Szeredi 446e9be9d5eSMiklos Szeredi return NULL; 447e9be9d5eSMiklos Szeredi 4483d3c6b89SMiklos Szeredi out_free_oe: 449e9be9d5eSMiklos Szeredi kfree(oe); 4503d3c6b89SMiklos Szeredi out_put: 4513d3c6b89SMiklos Szeredi for (i = 0; i < ctr; i++) 4523d3c6b89SMiklos Szeredi dput(stack[i].dentry); 4533d3c6b89SMiklos Szeredi kfree(stack); 4543d3c6b89SMiklos Szeredi out_put_upper: 4553d3c6b89SMiklos Szeredi dput(upperdentry); 456e9be9d5eSMiklos Szeredi out: 457e9be9d5eSMiklos Szeredi return ERR_PTR(err); 458e9be9d5eSMiklos Szeredi } 459e9be9d5eSMiklos Szeredi 460e9be9d5eSMiklos Szeredi struct file *ovl_path_open(struct path *path, int flags) 461e9be9d5eSMiklos Szeredi { 462e9be9d5eSMiklos Szeredi return dentry_open(path, flags, current_cred()); 463e9be9d5eSMiklos Szeredi } 464e9be9d5eSMiklos Szeredi 465e9be9d5eSMiklos Szeredi static void ovl_put_super(struct super_block *sb) 466e9be9d5eSMiklos Szeredi { 467e9be9d5eSMiklos Szeredi struct ovl_fs *ufs = sb->s_fs_info; 468dd662667SMiklos Szeredi unsigned i; 469e9be9d5eSMiklos Szeredi 470e9be9d5eSMiklos Szeredi dput(ufs->workdir); 471e9be9d5eSMiklos Szeredi mntput(ufs->upper_mnt); 472dd662667SMiklos Szeredi for (i = 0; i < ufs->numlower; i++) 473dd662667SMiklos Szeredi mntput(ufs->lower_mnt[i]); 474e9be9d5eSMiklos Szeredi 475f45827e8SErez Zadok kfree(ufs->config.lowerdir); 476f45827e8SErez Zadok kfree(ufs->config.upperdir); 477f45827e8SErez Zadok kfree(ufs->config.workdir); 478e9be9d5eSMiklos Szeredi kfree(ufs); 479e9be9d5eSMiklos Szeredi } 480e9be9d5eSMiklos Szeredi 481cc259639SAndy Whitcroft /** 482cc259639SAndy Whitcroft * ovl_statfs 483cc259639SAndy Whitcroft * @sb: The overlayfs super block 484cc259639SAndy Whitcroft * @buf: The struct kstatfs to fill in with stats 485cc259639SAndy Whitcroft * 486cc259639SAndy Whitcroft * Get the filesystem statistics. As writes always target the upper layer 4874ebc5818SMiklos Szeredi * filesystem pass the statfs to the upper filesystem (if it exists) 488cc259639SAndy Whitcroft */ 489cc259639SAndy Whitcroft static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf) 490cc259639SAndy Whitcroft { 491cc259639SAndy Whitcroft struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 492cc259639SAndy Whitcroft struct dentry *root_dentry = dentry->d_sb->s_root; 493cc259639SAndy Whitcroft struct path path; 494cc259639SAndy Whitcroft int err; 495cc259639SAndy Whitcroft 4964ebc5818SMiklos Szeredi ovl_path_real(root_dentry, &path); 497cc259639SAndy Whitcroft 498cc259639SAndy Whitcroft err = vfs_statfs(&path, buf); 499cc259639SAndy Whitcroft if (!err) { 500cc259639SAndy Whitcroft buf->f_namelen = max(buf->f_namelen, ofs->lower_namelen); 501cc259639SAndy Whitcroft buf->f_type = OVERLAYFS_SUPER_MAGIC; 502cc259639SAndy Whitcroft } 503cc259639SAndy Whitcroft 504cc259639SAndy Whitcroft return err; 505cc259639SAndy Whitcroft } 506cc259639SAndy Whitcroft 507f45827e8SErez Zadok /** 508f45827e8SErez Zadok * ovl_show_options 509f45827e8SErez Zadok * 510f45827e8SErez Zadok * Prints the mount options for a given superblock. 511f45827e8SErez Zadok * Returns zero; does not fail. 512f45827e8SErez Zadok */ 513f45827e8SErez Zadok static int ovl_show_options(struct seq_file *m, struct dentry *dentry) 514f45827e8SErez Zadok { 515f45827e8SErez Zadok struct super_block *sb = dentry->d_sb; 516f45827e8SErez Zadok struct ovl_fs *ufs = sb->s_fs_info; 517f45827e8SErez Zadok 518f45827e8SErez Zadok seq_printf(m, ",lowerdir=%s", ufs->config.lowerdir); 519f45827e8SErez Zadok seq_printf(m, ",upperdir=%s", ufs->config.upperdir); 520f45827e8SErez Zadok seq_printf(m, ",workdir=%s", ufs->config.workdir); 521f45827e8SErez Zadok return 0; 522f45827e8SErez Zadok } 523f45827e8SErez Zadok 524e9be9d5eSMiklos Szeredi static const struct super_operations ovl_super_operations = { 525e9be9d5eSMiklos Szeredi .put_super = ovl_put_super, 526cc259639SAndy Whitcroft .statfs = ovl_statfs, 527f45827e8SErez Zadok .show_options = ovl_show_options, 528e9be9d5eSMiklos Szeredi }; 529e9be9d5eSMiklos Szeredi 530e9be9d5eSMiklos Szeredi enum { 531e9be9d5eSMiklos Szeredi OPT_LOWERDIR, 532e9be9d5eSMiklos Szeredi OPT_UPPERDIR, 533e9be9d5eSMiklos Szeredi OPT_WORKDIR, 534e9be9d5eSMiklos Szeredi OPT_ERR, 535e9be9d5eSMiklos Szeredi }; 536e9be9d5eSMiklos Szeredi 537e9be9d5eSMiklos Szeredi static const match_table_t ovl_tokens = { 538e9be9d5eSMiklos Szeredi {OPT_LOWERDIR, "lowerdir=%s"}, 539e9be9d5eSMiklos Szeredi {OPT_UPPERDIR, "upperdir=%s"}, 540e9be9d5eSMiklos Szeredi {OPT_WORKDIR, "workdir=%s"}, 541e9be9d5eSMiklos Szeredi {OPT_ERR, NULL} 542e9be9d5eSMiklos Szeredi }; 543e9be9d5eSMiklos Szeredi 54491c77947SMiklos Szeredi static char *ovl_next_opt(char **s) 54591c77947SMiklos Szeredi { 54691c77947SMiklos Szeredi char *sbegin = *s; 54791c77947SMiklos Szeredi char *p; 54891c77947SMiklos Szeredi 54991c77947SMiklos Szeredi if (sbegin == NULL) 55091c77947SMiklos Szeredi return NULL; 55191c77947SMiklos Szeredi 55291c77947SMiklos Szeredi for (p = sbegin; *p; p++) { 55391c77947SMiklos Szeredi if (*p == '\\') { 55491c77947SMiklos Szeredi p++; 55591c77947SMiklos Szeredi if (!*p) 55691c77947SMiklos Szeredi break; 55791c77947SMiklos Szeredi } else if (*p == ',') { 55891c77947SMiklos Szeredi *p = '\0'; 55991c77947SMiklos Szeredi *s = p + 1; 56091c77947SMiklos Szeredi return sbegin; 56191c77947SMiklos Szeredi } 56291c77947SMiklos Szeredi } 56391c77947SMiklos Szeredi *s = NULL; 56491c77947SMiklos Szeredi return sbegin; 56591c77947SMiklos Szeredi } 56691c77947SMiklos Szeredi 567e9be9d5eSMiklos Szeredi static int ovl_parse_opt(char *opt, struct ovl_config *config) 568e9be9d5eSMiklos Szeredi { 569e9be9d5eSMiklos Szeredi char *p; 570e9be9d5eSMiklos Szeredi 57191c77947SMiklos Szeredi while ((p = ovl_next_opt(&opt)) != NULL) { 572e9be9d5eSMiklos Szeredi int token; 573e9be9d5eSMiklos Szeredi substring_t args[MAX_OPT_ARGS]; 574e9be9d5eSMiklos Szeredi 575e9be9d5eSMiklos Szeredi if (!*p) 576e9be9d5eSMiklos Szeredi continue; 577e9be9d5eSMiklos Szeredi 578e9be9d5eSMiklos Szeredi token = match_token(p, ovl_tokens, args); 579e9be9d5eSMiklos Szeredi switch (token) { 580e9be9d5eSMiklos Szeredi case OPT_UPPERDIR: 581e9be9d5eSMiklos Szeredi kfree(config->upperdir); 582e9be9d5eSMiklos Szeredi config->upperdir = match_strdup(&args[0]); 583e9be9d5eSMiklos Szeredi if (!config->upperdir) 584e9be9d5eSMiklos Szeredi return -ENOMEM; 585e9be9d5eSMiklos Szeredi break; 586e9be9d5eSMiklos Szeredi 587e9be9d5eSMiklos Szeredi case OPT_LOWERDIR: 588e9be9d5eSMiklos Szeredi kfree(config->lowerdir); 589e9be9d5eSMiklos Szeredi config->lowerdir = match_strdup(&args[0]); 590e9be9d5eSMiklos Szeredi if (!config->lowerdir) 591e9be9d5eSMiklos Szeredi return -ENOMEM; 592e9be9d5eSMiklos Szeredi break; 593e9be9d5eSMiklos Szeredi 594e9be9d5eSMiklos Szeredi case OPT_WORKDIR: 595e9be9d5eSMiklos Szeredi kfree(config->workdir); 596e9be9d5eSMiklos Szeredi config->workdir = match_strdup(&args[0]); 597e9be9d5eSMiklos Szeredi if (!config->workdir) 598e9be9d5eSMiklos Szeredi return -ENOMEM; 599e9be9d5eSMiklos Szeredi break; 600e9be9d5eSMiklos Szeredi 601e9be9d5eSMiklos Szeredi default: 602e9be9d5eSMiklos Szeredi return -EINVAL; 603e9be9d5eSMiklos Szeredi } 604e9be9d5eSMiklos Szeredi } 605e9be9d5eSMiklos Szeredi return 0; 606e9be9d5eSMiklos Szeredi } 607e9be9d5eSMiklos Szeredi 608e9be9d5eSMiklos Szeredi #define OVL_WORKDIR_NAME "work" 609e9be9d5eSMiklos Szeredi 610e9be9d5eSMiklos Szeredi static struct dentry *ovl_workdir_create(struct vfsmount *mnt, 611e9be9d5eSMiklos Szeredi struct dentry *dentry) 612e9be9d5eSMiklos Szeredi { 613e9be9d5eSMiklos Szeredi struct inode *dir = dentry->d_inode; 614e9be9d5eSMiklos Szeredi struct dentry *work; 615e9be9d5eSMiklos Szeredi int err; 616e9be9d5eSMiklos Szeredi bool retried = false; 617e9be9d5eSMiklos Szeredi 618e9be9d5eSMiklos Szeredi err = mnt_want_write(mnt); 619e9be9d5eSMiklos Szeredi if (err) 620e9be9d5eSMiklos Szeredi return ERR_PTR(err); 621e9be9d5eSMiklos Szeredi 622e9be9d5eSMiklos Szeredi mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT); 623e9be9d5eSMiklos Szeredi retry: 624e9be9d5eSMiklos Szeredi work = lookup_one_len(OVL_WORKDIR_NAME, dentry, 625e9be9d5eSMiklos Szeredi strlen(OVL_WORKDIR_NAME)); 626e9be9d5eSMiklos Szeredi 627e9be9d5eSMiklos Szeredi if (!IS_ERR(work)) { 628e9be9d5eSMiklos Szeredi struct kstat stat = { 629e9be9d5eSMiklos Szeredi .mode = S_IFDIR | 0, 630e9be9d5eSMiklos Szeredi }; 631e9be9d5eSMiklos Szeredi 632e9be9d5eSMiklos Szeredi if (work->d_inode) { 633e9be9d5eSMiklos Szeredi err = -EEXIST; 634e9be9d5eSMiklos Szeredi if (retried) 635e9be9d5eSMiklos Szeredi goto out_dput; 636e9be9d5eSMiklos Szeredi 637e9be9d5eSMiklos Szeredi retried = true; 638e9be9d5eSMiklos Szeredi ovl_cleanup(dir, work); 639e9be9d5eSMiklos Szeredi dput(work); 640e9be9d5eSMiklos Szeredi goto retry; 641e9be9d5eSMiklos Szeredi } 642e9be9d5eSMiklos Szeredi 643e9be9d5eSMiklos Szeredi err = ovl_create_real(dir, work, &stat, NULL, NULL, true); 644e9be9d5eSMiklos Szeredi if (err) 645e9be9d5eSMiklos Szeredi goto out_dput; 646e9be9d5eSMiklos Szeredi } 647e9be9d5eSMiklos Szeredi out_unlock: 648e9be9d5eSMiklos Szeredi mutex_unlock(&dir->i_mutex); 649e9be9d5eSMiklos Szeredi mnt_drop_write(mnt); 650e9be9d5eSMiklos Szeredi 651e9be9d5eSMiklos Szeredi return work; 652e9be9d5eSMiklos Szeredi 653e9be9d5eSMiklos Szeredi out_dput: 654e9be9d5eSMiklos Szeredi dput(work); 655e9be9d5eSMiklos Szeredi work = ERR_PTR(err); 656e9be9d5eSMiklos Szeredi goto out_unlock; 657e9be9d5eSMiklos Szeredi } 658e9be9d5eSMiklos Szeredi 65991c77947SMiklos Szeredi static void ovl_unescape(char *s) 66091c77947SMiklos Szeredi { 66191c77947SMiklos Szeredi char *d = s; 66291c77947SMiklos Szeredi 66391c77947SMiklos Szeredi for (;; s++, d++) { 66491c77947SMiklos Szeredi if (*s == '\\') 66591c77947SMiklos Szeredi s++; 66691c77947SMiklos Szeredi *d = *s; 66791c77947SMiklos Szeredi if (!*s) 66891c77947SMiklos Szeredi break; 66991c77947SMiklos Szeredi } 67091c77947SMiklos Szeredi } 67191c77947SMiklos Szeredi 672e9be9d5eSMiklos Szeredi static bool ovl_is_allowed_fs_type(struct dentry *root) 673e9be9d5eSMiklos Szeredi { 674e9be9d5eSMiklos Szeredi const struct dentry_operations *dop = root->d_op; 675e9be9d5eSMiklos Szeredi 676e9be9d5eSMiklos Szeredi /* 677e9be9d5eSMiklos Szeredi * We don't support: 678e9be9d5eSMiklos Szeredi * - automount filesystems 679e9be9d5eSMiklos Szeredi * - filesystems with revalidate (FIXME for lower layer) 680e9be9d5eSMiklos Szeredi * - filesystems with case insensitive names 681e9be9d5eSMiklos Szeredi */ 682e9be9d5eSMiklos Szeredi if (dop && 683e9be9d5eSMiklos Szeredi (dop->d_manage || dop->d_automount || 684e9be9d5eSMiklos Szeredi dop->d_revalidate || dop->d_weak_revalidate || 685e9be9d5eSMiklos Szeredi dop->d_compare || dop->d_hash)) { 686e9be9d5eSMiklos Szeredi return false; 687e9be9d5eSMiklos Szeredi } 688e9be9d5eSMiklos Szeredi return true; 689e9be9d5eSMiklos Szeredi } 690e9be9d5eSMiklos Szeredi 691ab508822SMiklos Szeredi static int ovl_mount_dir_noesc(const char *name, struct path *path) 692ab508822SMiklos Szeredi { 693ab508822SMiklos Szeredi int err; 694ab508822SMiklos Szeredi 695ab508822SMiklos Szeredi err = kern_path(name, LOOKUP_FOLLOW, path); 696ab508822SMiklos Szeredi if (err) { 697ab508822SMiklos Szeredi pr_err("overlayfs: failed to resolve '%s': %i\n", name, err); 698ab508822SMiklos Szeredi goto out; 699ab508822SMiklos Szeredi } 700ab508822SMiklos Szeredi err = -EINVAL; 701ab508822SMiklos Szeredi if (!ovl_is_allowed_fs_type(path->dentry)) { 702ab508822SMiklos Szeredi pr_err("overlayfs: filesystem on '%s' not supported\n", name); 703ab508822SMiklos Szeredi goto out_put; 704ab508822SMiklos Szeredi } 705ab508822SMiklos Szeredi if (!S_ISDIR(path->dentry->d_inode->i_mode)) { 706ab508822SMiklos Szeredi pr_err("overlayfs: '%s' not a directory\n", name); 707ab508822SMiklos Szeredi goto out_put; 708ab508822SMiklos Szeredi } 709ab508822SMiklos Szeredi return 0; 710ab508822SMiklos Szeredi 711ab508822SMiklos Szeredi out_put: 712ab508822SMiklos Szeredi path_put(path); 713ab508822SMiklos Szeredi out: 714ab508822SMiklos Szeredi return err; 715ab508822SMiklos Szeredi } 716ab508822SMiklos Szeredi 717ab508822SMiklos Szeredi static int ovl_mount_dir(const char *name, struct path *path) 718ab508822SMiklos Szeredi { 719ab508822SMiklos Szeredi int err = -ENOMEM; 720ab508822SMiklos Szeredi char *tmp = kstrdup(name, GFP_KERNEL); 721ab508822SMiklos Szeredi 722ab508822SMiklos Szeredi if (tmp) { 723ab508822SMiklos Szeredi ovl_unescape(tmp); 724ab508822SMiklos Szeredi err = ovl_mount_dir_noesc(tmp, path); 725ab508822SMiklos Szeredi kfree(tmp); 726ab508822SMiklos Szeredi } 727ab508822SMiklos Szeredi return err; 728ab508822SMiklos Szeredi } 729ab508822SMiklos Szeredi 730ab508822SMiklos Szeredi static int ovl_lower_dir(const char *name, struct path *path, long *namelen, 731ab508822SMiklos Szeredi int *stack_depth) 732ab508822SMiklos Szeredi { 733ab508822SMiklos Szeredi int err; 734ab508822SMiklos Szeredi struct kstatfs statfs; 735ab508822SMiklos Szeredi 736ab508822SMiklos Szeredi err = ovl_mount_dir(name, path); 737ab508822SMiklos Szeredi if (err) 738ab508822SMiklos Szeredi goto out; 739ab508822SMiklos Szeredi 740ab508822SMiklos Szeredi err = vfs_statfs(path, &statfs); 741ab508822SMiklos Szeredi if (err) { 742ab508822SMiklos Szeredi pr_err("overlayfs: statfs failed on '%s'\n", name); 743ab508822SMiklos Szeredi goto out_put; 744ab508822SMiklos Szeredi } 745ab508822SMiklos Szeredi *namelen = max(*namelen, statfs.f_namelen); 746ab508822SMiklos Szeredi *stack_depth = max(*stack_depth, path->mnt->mnt_sb->s_stack_depth); 747ab508822SMiklos Szeredi 748ab508822SMiklos Szeredi return 0; 749ab508822SMiklos Szeredi 750ab508822SMiklos Szeredi out_put: 751ab508822SMiklos Szeredi path_put(path); 752ab508822SMiklos Szeredi out: 753ab508822SMiklos Szeredi return err; 754ab508822SMiklos Szeredi } 755ab508822SMiklos Szeredi 756e9be9d5eSMiklos Szeredi /* Workdir should not be subdir of upperdir and vice versa */ 757e9be9d5eSMiklos Szeredi static bool ovl_workdir_ok(struct dentry *workdir, struct dentry *upperdir) 758e9be9d5eSMiklos Szeredi { 759e9be9d5eSMiklos Szeredi bool ok = false; 760e9be9d5eSMiklos Szeredi 761e9be9d5eSMiklos Szeredi if (workdir != upperdir) { 762e9be9d5eSMiklos Szeredi ok = (lock_rename(workdir, upperdir) == NULL); 763e9be9d5eSMiklos Szeredi unlock_rename(workdir, upperdir); 764e9be9d5eSMiklos Szeredi } 765e9be9d5eSMiklos Szeredi return ok; 766e9be9d5eSMiklos Szeredi } 767e9be9d5eSMiklos Szeredi 768e9be9d5eSMiklos Szeredi static int ovl_fill_super(struct super_block *sb, void *data, int silent) 769e9be9d5eSMiklos Szeredi { 770e9be9d5eSMiklos Szeredi struct path lowerpath; 771e9be9d5eSMiklos Szeredi struct path upperpath; 772e9be9d5eSMiklos Szeredi struct path workpath; 773e9be9d5eSMiklos Szeredi struct dentry *root_dentry; 774e9be9d5eSMiklos Szeredi struct ovl_entry *oe; 775e9be9d5eSMiklos Szeredi struct ovl_fs *ufs; 776dd662667SMiklos Szeredi struct vfsmount *mnt; 777dd662667SMiklos Szeredi unsigned int i; 778e9be9d5eSMiklos Szeredi int err; 779e9be9d5eSMiklos Szeredi 780f45827e8SErez Zadok err = -ENOMEM; 781f45827e8SErez Zadok ufs = kzalloc(sizeof(struct ovl_fs), GFP_KERNEL); 782f45827e8SErez Zadok if (!ufs) 783e9be9d5eSMiklos Szeredi goto out; 784e9be9d5eSMiklos Szeredi 785f45827e8SErez Zadok err = ovl_parse_opt((char *) data, &ufs->config); 786f45827e8SErez Zadok if (err) 787f45827e8SErez Zadok goto out_free_config; 788f45827e8SErez Zadok 789e9be9d5eSMiklos Szeredi /* FIXME: workdir is not needed for a R/O mount */ 790e9be9d5eSMiklos Szeredi err = -EINVAL; 791f45827e8SErez Zadok if (!ufs->config.upperdir || !ufs->config.lowerdir || 792f45827e8SErez Zadok !ufs->config.workdir) { 793e9be9d5eSMiklos Szeredi pr_err("overlayfs: missing upperdir or lowerdir or workdir\n"); 794e9be9d5eSMiklos Szeredi goto out_free_config; 795e9be9d5eSMiklos Szeredi } 796e9be9d5eSMiklos Szeredi 797f45827e8SErez Zadok err = ovl_mount_dir(ufs->config.upperdir, &upperpath); 798e9be9d5eSMiklos Szeredi if (err) 7993b7a9a24SMiklos Szeredi goto out_free_config; 800e9be9d5eSMiklos Szeredi 801f45827e8SErez Zadok err = ovl_mount_dir(ufs->config.workdir, &workpath); 802e9be9d5eSMiklos Szeredi if (err) 8033b7a9a24SMiklos Szeredi goto out_put_upperpath; 8043b7a9a24SMiklos Szeredi 805ab508822SMiklos Szeredi if (upperpath.mnt != workpath.mnt) { 806ab508822SMiklos Szeredi pr_err("overlayfs: workdir and upperdir must reside under the same mount\n"); 807ab508822SMiklos Szeredi goto out_put_workpath; 808ab508822SMiklos Szeredi } 809ab508822SMiklos Szeredi if (!ovl_workdir_ok(workpath.dentry, upperpath.dentry)) { 810ab508822SMiklos Szeredi pr_err("overlayfs: workdir and upperdir must be separate subtrees\n"); 811ab508822SMiklos Szeredi goto out_put_workpath; 812ab508822SMiklos Szeredi } 813ab508822SMiklos Szeredi sb->s_stack_depth = upperpath.mnt->mnt_sb->s_stack_depth; 814ab508822SMiklos Szeredi 815ab508822SMiklos Szeredi err = ovl_lower_dir(ufs->config.lowerdir, &lowerpath, 816ab508822SMiklos Szeredi &ufs->lower_namelen, &sb->s_stack_depth); 8173b7a9a24SMiklos Szeredi if (err) 8183b7a9a24SMiklos Szeredi goto out_put_workpath; 819e9be9d5eSMiklos Szeredi 820e9be9d5eSMiklos Szeredi err = -EINVAL; 821ab508822SMiklos Szeredi sb->s_stack_depth++; 82269c433edSMiklos Szeredi if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { 82369c433edSMiklos Szeredi pr_err("overlayfs: maximum fs stacking depth exceeded\n"); 8243b7a9a24SMiklos Szeredi goto out_put_lowerpath; 82569c433edSMiklos Szeredi } 82669c433edSMiklos Szeredi 827e9be9d5eSMiklos Szeredi ufs->upper_mnt = clone_private_mount(&upperpath); 828e9be9d5eSMiklos Szeredi err = PTR_ERR(ufs->upper_mnt); 829e9be9d5eSMiklos Szeredi if (IS_ERR(ufs->upper_mnt)) { 830e9be9d5eSMiklos Szeredi pr_err("overlayfs: failed to clone upperpath\n"); 8313b7a9a24SMiklos Szeredi goto out_put_lowerpath; 8323b7a9a24SMiklos Szeredi } 8333b7a9a24SMiklos Szeredi 8343b7a9a24SMiklos Szeredi ufs->workdir = ovl_workdir_create(ufs->upper_mnt, workpath.dentry); 8353b7a9a24SMiklos Szeredi err = PTR_ERR(ufs->workdir); 8363b7a9a24SMiklos Szeredi if (IS_ERR(ufs->workdir)) { 8373b7a9a24SMiklos Szeredi pr_err("overlayfs: failed to create directory %s/%s\n", 8383b7a9a24SMiklos Szeredi ufs->config.workdir, OVL_WORKDIR_NAME); 8393b7a9a24SMiklos Szeredi goto out_put_upper_mnt; 840e9be9d5eSMiklos Szeredi } 841e9be9d5eSMiklos Szeredi 842dd662667SMiklos Szeredi ufs->lower_mnt = kcalloc(1, sizeof(struct vfsmount *), GFP_KERNEL); 843dd662667SMiklos Szeredi if (ufs->lower_mnt == NULL) 8443b7a9a24SMiklos Szeredi goto out_put_workdir; 845dd662667SMiklos Szeredi 846dd662667SMiklos Szeredi mnt = clone_private_mount(&lowerpath); 847dd662667SMiklos Szeredi err = PTR_ERR(mnt); 848dd662667SMiklos Szeredi if (IS_ERR(mnt)) { 849dd662667SMiklos Szeredi pr_err("overlayfs: failed to clone lowerpath\n"); 850dd662667SMiklos Szeredi goto out_put_lower_mnt; 851e9be9d5eSMiklos Szeredi } 852dd662667SMiklos Szeredi /* 853dd662667SMiklos Szeredi * Make lower_mnt R/O. That way fchmod/fchown on lower file 854dd662667SMiklos Szeredi * will fail instead of modifying lower fs. 855dd662667SMiklos Szeredi */ 856dd662667SMiklos Szeredi mnt->mnt_flags |= MNT_READONLY; 857dd662667SMiklos Szeredi 858dd662667SMiklos Szeredi ufs->lower_mnt[0] = mnt; 859dd662667SMiklos Szeredi ufs->numlower = 1; 860e9be9d5eSMiklos Szeredi 861e9be9d5eSMiklos Szeredi /* If the upper fs is r/o, we mark overlayfs r/o too */ 862e9be9d5eSMiklos Szeredi if (ufs->upper_mnt->mnt_sb->s_flags & MS_RDONLY) 863e9be9d5eSMiklos Szeredi sb->s_flags |= MS_RDONLY; 864e9be9d5eSMiklos Szeredi 865e9be9d5eSMiklos Szeredi sb->s_d_op = &ovl_dentry_operations; 866e9be9d5eSMiklos Szeredi 867e9be9d5eSMiklos Szeredi err = -ENOMEM; 8683b7a9a24SMiklos Szeredi oe = ovl_alloc_entry(1); 8693b7a9a24SMiklos Szeredi if (!oe) 8703b7a9a24SMiklos Szeredi goto out_put_lower_mnt; 871e9be9d5eSMiklos Szeredi 8723b7a9a24SMiklos Szeredi root_dentry = d_make_root(ovl_new_inode(sb, S_IFDIR, oe)); 873e9be9d5eSMiklos Szeredi if (!root_dentry) 8743b7a9a24SMiklos Szeredi goto out_free_oe; 875e9be9d5eSMiklos Szeredi 876e9be9d5eSMiklos Szeredi mntput(upperpath.mnt); 877e9be9d5eSMiklos Szeredi mntput(lowerpath.mnt); 878e9be9d5eSMiklos Szeredi path_put(&workpath); 879e9be9d5eSMiklos Szeredi 880e9be9d5eSMiklos Szeredi oe->__upperdentry = upperpath.dentry; 881dd662667SMiklos Szeredi oe->lowerstack[0].dentry = lowerpath.dentry; 882dd662667SMiklos Szeredi oe->lowerstack[0].mnt = ufs->lower_mnt[0]; 883e9be9d5eSMiklos Szeredi 884e9be9d5eSMiklos Szeredi root_dentry->d_fsdata = oe; 885e9be9d5eSMiklos Szeredi 886cc259639SAndy Whitcroft sb->s_magic = OVERLAYFS_SUPER_MAGIC; 887e9be9d5eSMiklos Szeredi sb->s_op = &ovl_super_operations; 888e9be9d5eSMiklos Szeredi sb->s_root = root_dentry; 889e9be9d5eSMiklos Szeredi sb->s_fs_info = ufs; 890e9be9d5eSMiklos Szeredi 891e9be9d5eSMiklos Szeredi return 0; 892e9be9d5eSMiklos Szeredi 8933b7a9a24SMiklos Szeredi out_free_oe: 8943b7a9a24SMiklos Szeredi kfree(oe); 895e9be9d5eSMiklos Szeredi out_put_lower_mnt: 896dd662667SMiklos Szeredi for (i = 0; i < ufs->numlower; i++) 897dd662667SMiklos Szeredi mntput(ufs->lower_mnt[i]); 898dd662667SMiklos Szeredi kfree(ufs->lower_mnt); 8993b7a9a24SMiklos Szeredi out_put_workdir: 9003b7a9a24SMiklos Szeredi dput(ufs->workdir); 901e9be9d5eSMiklos Szeredi out_put_upper_mnt: 902e9be9d5eSMiklos Szeredi mntput(ufs->upper_mnt); 903e9be9d5eSMiklos Szeredi out_put_lowerpath: 904e9be9d5eSMiklos Szeredi path_put(&lowerpath); 9053b7a9a24SMiklos Szeredi out_put_workpath: 9063b7a9a24SMiklos Szeredi path_put(&workpath); 907e9be9d5eSMiklos Szeredi out_put_upperpath: 908e9be9d5eSMiklos Szeredi path_put(&upperpath); 909e9be9d5eSMiklos Szeredi out_free_config: 910f45827e8SErez Zadok kfree(ufs->config.lowerdir); 911f45827e8SErez Zadok kfree(ufs->config.upperdir); 912f45827e8SErez Zadok kfree(ufs->config.workdir); 913f45827e8SErez Zadok kfree(ufs); 914e9be9d5eSMiklos Szeredi out: 915e9be9d5eSMiklos Szeredi return err; 916e9be9d5eSMiklos Szeredi } 917e9be9d5eSMiklos Szeredi 918e9be9d5eSMiklos Szeredi static struct dentry *ovl_mount(struct file_system_type *fs_type, int flags, 919e9be9d5eSMiklos Szeredi const char *dev_name, void *raw_data) 920e9be9d5eSMiklos Szeredi { 921e9be9d5eSMiklos Szeredi return mount_nodev(fs_type, flags, raw_data, ovl_fill_super); 922e9be9d5eSMiklos Szeredi } 923e9be9d5eSMiklos Szeredi 924e9be9d5eSMiklos Szeredi static struct file_system_type ovl_fs_type = { 925e9be9d5eSMiklos Szeredi .owner = THIS_MODULE, 926ef94b186SMiklos Szeredi .name = "overlay", 927e9be9d5eSMiklos Szeredi .mount = ovl_mount, 928e9be9d5eSMiklos Szeredi .kill_sb = kill_anon_super, 929e9be9d5eSMiklos Szeredi }; 930ef94b186SMiklos Szeredi MODULE_ALIAS_FS("overlay"); 931e9be9d5eSMiklos Szeredi 932e9be9d5eSMiklos Szeredi static int __init ovl_init(void) 933e9be9d5eSMiklos Szeredi { 934e9be9d5eSMiklos Szeredi return register_filesystem(&ovl_fs_type); 935e9be9d5eSMiklos Szeredi } 936e9be9d5eSMiklos Szeredi 937e9be9d5eSMiklos Szeredi static void __exit ovl_exit(void) 938e9be9d5eSMiklos Szeredi { 939e9be9d5eSMiklos Szeredi unregister_filesystem(&ovl_fs_type); 940e9be9d5eSMiklos Szeredi } 941e9be9d5eSMiklos Szeredi 942e9be9d5eSMiklos Szeredi module_init(ovl_init); 943e9be9d5eSMiklos Szeredi module_exit(ovl_exit); 944