1bbb1e54dSMiklos Szeredi /* 2bbb1e54dSMiklos Szeredi * Copyright (C) 2011 Novell Inc. 3bbb1e54dSMiklos Szeredi * Copyright (C) 2016 Red Hat, Inc. 4bbb1e54dSMiklos Szeredi * 5bbb1e54dSMiklos Szeredi * This program is free software; you can redistribute it and/or modify it 6bbb1e54dSMiklos Szeredi * under the terms of the GNU General Public License version 2 as published by 7bbb1e54dSMiklos Szeredi * the Free Software Foundation. 8bbb1e54dSMiklos Szeredi */ 9bbb1e54dSMiklos Szeredi 10bbb1e54dSMiklos Szeredi #include <linux/fs.h> 11bbb1e54dSMiklos Szeredi #include <linux/mount.h> 12bbb1e54dSMiklos Szeredi #include <linux/slab.h> 135b825c3aSIngo Molnar #include <linux/cred.h> 14bbb1e54dSMiklos Szeredi #include <linux/xattr.h> 1502bcd157SAmir Goldstein #include <linux/exportfs.h> 1602bcd157SAmir Goldstein #include <linux/uuid.h> 17caf70cb2SAmir Goldstein #include <linux/namei.h> 18caf70cb2SAmir Goldstein #include <linux/ratelimit.h> 19bbb1e54dSMiklos Szeredi #include "overlayfs.h" 20bbb1e54dSMiklos Szeredi 21bbb1e54dSMiklos Szeredi int ovl_want_write(struct dentry *dentry) 22bbb1e54dSMiklos Szeredi { 23bbb1e54dSMiklos Szeredi struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 24bbb1e54dSMiklos Szeredi return mnt_want_write(ofs->upper_mnt); 25bbb1e54dSMiklos Szeredi } 26bbb1e54dSMiklos Szeredi 27bbb1e54dSMiklos Szeredi void ovl_drop_write(struct dentry *dentry) 28bbb1e54dSMiklos Szeredi { 29bbb1e54dSMiklos Szeredi struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 30bbb1e54dSMiklos Szeredi mnt_drop_write(ofs->upper_mnt); 31bbb1e54dSMiklos Szeredi } 32bbb1e54dSMiklos Szeredi 33bbb1e54dSMiklos Szeredi struct dentry *ovl_workdir(struct dentry *dentry) 34bbb1e54dSMiklos Szeredi { 35bbb1e54dSMiklos Szeredi struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 36bbb1e54dSMiklos Szeredi return ofs->workdir; 37bbb1e54dSMiklos Szeredi } 38bbb1e54dSMiklos Szeredi 39bbb1e54dSMiklos Szeredi const struct cred *ovl_override_creds(struct super_block *sb) 40bbb1e54dSMiklos Szeredi { 41bbb1e54dSMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 42bbb1e54dSMiklos Szeredi 43bbb1e54dSMiklos Szeredi return override_creds(ofs->creator_cred); 44bbb1e54dSMiklos Szeredi } 45bbb1e54dSMiklos Szeredi 467bcd74b9SAmir Goldstein struct super_block *ovl_same_sb(struct super_block *sb) 477bcd74b9SAmir Goldstein { 487bcd74b9SAmir Goldstein struct ovl_fs *ofs = sb->s_fs_info; 497bcd74b9SAmir Goldstein 507bcd74b9SAmir Goldstein return ofs->same_sb; 517bcd74b9SAmir Goldstein } 527bcd74b9SAmir Goldstein 5302bcd157SAmir Goldstein bool ovl_can_decode_fh(struct super_block *sb) 5402bcd157SAmir Goldstein { 5502bcd157SAmir Goldstein return (sb->s_export_op && sb->s_export_op->fh_to_dentry && 5602bcd157SAmir Goldstein !uuid_is_null(&sb->s_uuid)); 5702bcd157SAmir Goldstein } 5802bcd157SAmir Goldstein 5902bcd157SAmir Goldstein struct dentry *ovl_indexdir(struct super_block *sb) 6002bcd157SAmir Goldstein { 6102bcd157SAmir Goldstein struct ovl_fs *ofs = sb->s_fs_info; 6202bcd157SAmir Goldstein 6302bcd157SAmir Goldstein return ofs->indexdir; 6402bcd157SAmir Goldstein } 6502bcd157SAmir Goldstein 66bbb1e54dSMiklos Szeredi struct ovl_entry *ovl_alloc_entry(unsigned int numlower) 67bbb1e54dSMiklos Szeredi { 68bbb1e54dSMiklos Szeredi size_t size = offsetof(struct ovl_entry, lowerstack[numlower]); 69bbb1e54dSMiklos Szeredi struct ovl_entry *oe = kzalloc(size, GFP_KERNEL); 70bbb1e54dSMiklos Szeredi 71bbb1e54dSMiklos Szeredi if (oe) 72bbb1e54dSMiklos Szeredi oe->numlower = numlower; 73bbb1e54dSMiklos Szeredi 74bbb1e54dSMiklos Szeredi return oe; 75bbb1e54dSMiklos Szeredi } 76bbb1e54dSMiklos Szeredi 77bbb1e54dSMiklos Szeredi bool ovl_dentry_remote(struct dentry *dentry) 78bbb1e54dSMiklos Szeredi { 79bbb1e54dSMiklos Szeredi return dentry->d_flags & 80bbb1e54dSMiklos Szeredi (DCACHE_OP_REVALIDATE | DCACHE_OP_WEAK_REVALIDATE | 81bbb1e54dSMiklos Szeredi DCACHE_OP_REAL); 82bbb1e54dSMiklos Szeredi } 83bbb1e54dSMiklos Szeredi 84bbb1e54dSMiklos Szeredi bool ovl_dentry_weird(struct dentry *dentry) 85bbb1e54dSMiklos Szeredi { 86bbb1e54dSMiklos Szeredi return dentry->d_flags & (DCACHE_NEED_AUTOMOUNT | 87bbb1e54dSMiklos Szeredi DCACHE_MANAGE_TRANSIT | 88bbb1e54dSMiklos Szeredi DCACHE_OP_HASH | 89bbb1e54dSMiklos Szeredi DCACHE_OP_COMPARE); 90bbb1e54dSMiklos Szeredi } 91bbb1e54dSMiklos Szeredi 92bbb1e54dSMiklos Szeredi enum ovl_path_type ovl_path_type(struct dentry *dentry) 93bbb1e54dSMiklos Szeredi { 94bbb1e54dSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 95bbb1e54dSMiklos Szeredi enum ovl_path_type type = 0; 96bbb1e54dSMiklos Szeredi 9709d8b586SMiklos Szeredi if (ovl_dentry_upper(dentry)) { 98bbb1e54dSMiklos Szeredi type = __OVL_PATH_UPPER; 99bbb1e54dSMiklos Szeredi 100bbb1e54dSMiklos Szeredi /* 10159548503SAmir Goldstein * Non-dir dentry can hold lower dentry of its copy up origin. 102bbb1e54dSMiklos Szeredi */ 10359548503SAmir Goldstein if (oe->numlower) { 10459548503SAmir Goldstein type |= __OVL_PATH_ORIGIN; 10559548503SAmir Goldstein if (d_is_dir(dentry)) 106bbb1e54dSMiklos Szeredi type |= __OVL_PATH_MERGE; 10759548503SAmir Goldstein } 108bbb1e54dSMiklos Szeredi } else { 109bbb1e54dSMiklos Szeredi if (oe->numlower > 1) 110bbb1e54dSMiklos Szeredi type |= __OVL_PATH_MERGE; 111bbb1e54dSMiklos Szeredi } 112bbb1e54dSMiklos Szeredi return type; 113bbb1e54dSMiklos Szeredi } 114bbb1e54dSMiklos Szeredi 115bbb1e54dSMiklos Szeredi void ovl_path_upper(struct dentry *dentry, struct path *path) 116bbb1e54dSMiklos Szeredi { 117bbb1e54dSMiklos Szeredi struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 118bbb1e54dSMiklos Szeredi 119bbb1e54dSMiklos Szeredi path->mnt = ofs->upper_mnt; 12009d8b586SMiklos Szeredi path->dentry = ovl_dentry_upper(dentry); 121bbb1e54dSMiklos Szeredi } 122bbb1e54dSMiklos Szeredi 123bbb1e54dSMiklos Szeredi void ovl_path_lower(struct dentry *dentry, struct path *path) 124bbb1e54dSMiklos Szeredi { 125bbb1e54dSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 126bbb1e54dSMiklos Szeredi 127b9343632SChandan Rajendra if (oe->numlower) { 128b9343632SChandan Rajendra path->mnt = oe->lowerstack[0].layer->mnt; 129b9343632SChandan Rajendra path->dentry = oe->lowerstack[0].dentry; 130b9343632SChandan Rajendra } else { 131b9343632SChandan Rajendra *path = (struct path) { }; 132b9343632SChandan Rajendra } 133bbb1e54dSMiklos Szeredi } 134bbb1e54dSMiklos Szeredi 135bbb1e54dSMiklos Szeredi enum ovl_path_type ovl_path_real(struct dentry *dentry, struct path *path) 136bbb1e54dSMiklos Szeredi { 137bbb1e54dSMiklos Szeredi enum ovl_path_type type = ovl_path_type(dentry); 138bbb1e54dSMiklos Szeredi 139bbb1e54dSMiklos Szeredi if (!OVL_TYPE_UPPER(type)) 140bbb1e54dSMiklos Szeredi ovl_path_lower(dentry, path); 141bbb1e54dSMiklos Szeredi else 142bbb1e54dSMiklos Szeredi ovl_path_upper(dentry, path); 143bbb1e54dSMiklos Szeredi 144bbb1e54dSMiklos Szeredi return type; 145bbb1e54dSMiklos Szeredi } 146bbb1e54dSMiklos Szeredi 147bbb1e54dSMiklos Szeredi struct dentry *ovl_dentry_upper(struct dentry *dentry) 148bbb1e54dSMiklos Szeredi { 14909d8b586SMiklos Szeredi return ovl_upperdentry_dereference(OVL_I(d_inode(dentry))); 150bbb1e54dSMiklos Szeredi } 151bbb1e54dSMiklos Szeredi 152bbb1e54dSMiklos Szeredi struct dentry *ovl_dentry_lower(struct dentry *dentry) 153bbb1e54dSMiklos Szeredi { 154bbb1e54dSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 155bbb1e54dSMiklos Szeredi 15609d8b586SMiklos Szeredi return oe->numlower ? oe->lowerstack[0].dentry : NULL; 157bbb1e54dSMiklos Szeredi } 158bbb1e54dSMiklos Szeredi 159bbb1e54dSMiklos Szeredi struct dentry *ovl_dentry_real(struct dentry *dentry) 160bbb1e54dSMiklos Szeredi { 16109d8b586SMiklos Szeredi return ovl_dentry_upper(dentry) ?: ovl_dentry_lower(dentry); 162bbb1e54dSMiklos Szeredi } 163bbb1e54dSMiklos Szeredi 1641d88f183SMiklos Szeredi struct dentry *ovl_i_dentry_upper(struct inode *inode) 1651d88f183SMiklos Szeredi { 1661d88f183SMiklos Szeredi return ovl_upperdentry_dereference(OVL_I(inode)); 1671d88f183SMiklos Szeredi } 1681d88f183SMiklos Szeredi 16909d8b586SMiklos Szeredi struct inode *ovl_inode_upper(struct inode *inode) 17025b7713aSMiklos Szeredi { 1711d88f183SMiklos Szeredi struct dentry *upperdentry = ovl_i_dentry_upper(inode); 17225b7713aSMiklos Szeredi 17309d8b586SMiklos Szeredi return upperdentry ? d_inode(upperdentry) : NULL; 17425b7713aSMiklos Szeredi } 17525b7713aSMiklos Szeredi 17609d8b586SMiklos Szeredi struct inode *ovl_inode_lower(struct inode *inode) 17709d8b586SMiklos Szeredi { 17809d8b586SMiklos Szeredi return OVL_I(inode)->lower; 17909d8b586SMiklos Szeredi } 18009d8b586SMiklos Szeredi 18109d8b586SMiklos Szeredi struct inode *ovl_inode_real(struct inode *inode) 18209d8b586SMiklos Szeredi { 18309d8b586SMiklos Szeredi return ovl_inode_upper(inode) ?: ovl_inode_lower(inode); 18409d8b586SMiklos Szeredi } 18509d8b586SMiklos Szeredi 18609d8b586SMiklos Szeredi 1874edb83bbSMiklos Szeredi struct ovl_dir_cache *ovl_dir_cache(struct inode *inode) 188bbb1e54dSMiklos Szeredi { 1894edb83bbSMiklos Szeredi return OVL_I(inode)->cache; 190bbb1e54dSMiklos Szeredi } 191bbb1e54dSMiklos Szeredi 1924edb83bbSMiklos Szeredi void ovl_set_dir_cache(struct inode *inode, struct ovl_dir_cache *cache) 193bbb1e54dSMiklos Szeredi { 1944edb83bbSMiklos Szeredi OVL_I(inode)->cache = cache; 195bbb1e54dSMiklos Szeredi } 196bbb1e54dSMiklos Szeredi 197bbb1e54dSMiklos Szeredi bool ovl_dentry_is_opaque(struct dentry *dentry) 198bbb1e54dSMiklos Szeredi { 199bbb1e54dSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 200bbb1e54dSMiklos Szeredi return oe->opaque; 201bbb1e54dSMiklos Szeredi } 202bbb1e54dSMiklos Szeredi 203bbb1e54dSMiklos Szeredi bool ovl_dentry_is_whiteout(struct dentry *dentry) 204bbb1e54dSMiklos Szeredi { 205bbb1e54dSMiklos Szeredi return !dentry->d_inode && ovl_dentry_is_opaque(dentry); 206bbb1e54dSMiklos Szeredi } 207bbb1e54dSMiklos Szeredi 2085cf5b477SMiklos Szeredi void ovl_dentry_set_opaque(struct dentry *dentry) 209bbb1e54dSMiklos Szeredi { 210bbb1e54dSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 2115cf5b477SMiklos Szeredi 2125cf5b477SMiklos Szeredi oe->opaque = true; 213bbb1e54dSMiklos Szeredi } 214bbb1e54dSMiklos Szeredi 21555acc661SMiklos Szeredi /* 21655acc661SMiklos Szeredi * For hard links it's possible for ovl_dentry_upper() to return positive, while 21755acc661SMiklos Szeredi * there's no actual upper alias for the inode. Copy up code needs to know 21855acc661SMiklos Szeredi * about the existence of the upper alias, so it can't use ovl_dentry_upper(). 21955acc661SMiklos Szeredi */ 22055acc661SMiklos Szeredi bool ovl_dentry_has_upper_alias(struct dentry *dentry) 22155acc661SMiklos Szeredi { 22255acc661SMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 22355acc661SMiklos Szeredi 22455acc661SMiklos Szeredi return oe->has_upper; 22555acc661SMiklos Szeredi } 22655acc661SMiklos Szeredi 22755acc661SMiklos Szeredi void ovl_dentry_set_upper_alias(struct dentry *dentry) 22855acc661SMiklos Szeredi { 22955acc661SMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 23055acc661SMiklos Szeredi 23155acc661SMiklos Szeredi oe->has_upper = true; 23255acc661SMiklos Szeredi } 23355acc661SMiklos Szeredi 234a6c60655SMiklos Szeredi bool ovl_redirect_dir(struct super_block *sb) 235a6c60655SMiklos Szeredi { 236a6c60655SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 237a6c60655SMiklos Szeredi 23821a22878SAmir Goldstein return ofs->config.redirect_dir && !ofs->noxattr; 239a6c60655SMiklos Szeredi } 240a6c60655SMiklos Szeredi 241a6c60655SMiklos Szeredi const char *ovl_dentry_get_redirect(struct dentry *dentry) 242a6c60655SMiklos Szeredi { 243cf31c463SMiklos Szeredi return OVL_I(d_inode(dentry))->redirect; 244a6c60655SMiklos Szeredi } 245a6c60655SMiklos Szeredi 246a6c60655SMiklos Szeredi void ovl_dentry_set_redirect(struct dentry *dentry, const char *redirect) 247a6c60655SMiklos Szeredi { 248cf31c463SMiklos Szeredi struct ovl_inode *oi = OVL_I(d_inode(dentry)); 249a6c60655SMiklos Szeredi 250cf31c463SMiklos Szeredi kfree(oi->redirect); 251cf31c463SMiklos Szeredi oi->redirect = redirect; 252a6c60655SMiklos Szeredi } 253a6c60655SMiklos Szeredi 25409d8b586SMiklos Szeredi void ovl_inode_init(struct inode *inode, struct dentry *upperdentry, 25509d8b586SMiklos Szeredi struct dentry *lowerdentry) 256bbb1e54dSMiklos Szeredi { 25709d8b586SMiklos Szeredi if (upperdentry) 25809d8b586SMiklos Szeredi OVL_I(inode)->__upperdentry = upperdentry; 25909d8b586SMiklos Szeredi if (lowerdentry) 26031747edaSAmir Goldstein OVL_I(inode)->lower = igrab(d_inode(lowerdentry)); 261bbb1e54dSMiklos Szeredi 26209d8b586SMiklos Szeredi ovl_copyattr(d_inode(upperdentry ?: lowerdentry), inode); 263bbb1e54dSMiklos Szeredi } 264bbb1e54dSMiklos Szeredi 26509d8b586SMiklos Szeredi void ovl_inode_update(struct inode *inode, struct dentry *upperdentry) 266bbb1e54dSMiklos Szeredi { 26709d8b586SMiklos Szeredi struct inode *upperinode = d_inode(upperdentry); 268e6d2ebddSMiklos Szeredi 26909d8b586SMiklos Szeredi WARN_ON(OVL_I(inode)->__upperdentry); 27009d8b586SMiklos Szeredi 27125b7713aSMiklos Szeredi /* 27209d8b586SMiklos Szeredi * Make sure upperdentry is consistent before making it visible 27325b7713aSMiklos Szeredi */ 27425b7713aSMiklos Szeredi smp_wmb(); 27509d8b586SMiklos Szeredi OVL_I(inode)->__upperdentry = upperdentry; 27631747edaSAmir Goldstein if (inode_unhashed(inode)) { 27725b7713aSMiklos Szeredi inode->i_private = upperinode; 278bbb1e54dSMiklos Szeredi __insert_inode_hash(inode, (unsigned long) upperinode); 279bbb1e54dSMiklos Szeredi } 28025b7713aSMiklos Szeredi } 281bbb1e54dSMiklos Szeredi 2824edb83bbSMiklos Szeredi void ovl_dentry_version_inc(struct dentry *dentry, bool impurity) 283bbb1e54dSMiklos Szeredi { 28404a01ac7SMiklos Szeredi struct inode *inode = d_inode(dentry); 285bbb1e54dSMiklos Szeredi 28604a01ac7SMiklos Szeredi WARN_ON(!inode_is_locked(inode)); 2874edb83bbSMiklos Szeredi /* 2884edb83bbSMiklos Szeredi * Version is used by readdir code to keep cache consistent. For merge 2894edb83bbSMiklos Szeredi * dirs all changes need to be noted. For non-merge dirs, cache only 2904edb83bbSMiklos Szeredi * contains impure (ones which have been copied up and have origins) 2914edb83bbSMiklos Szeredi * entries, so only need to note changes to impure entries. 2924edb83bbSMiklos Szeredi */ 2934edb83bbSMiklos Szeredi if (OVL_TYPE_MERGE(ovl_path_type(dentry)) || impurity) 29404a01ac7SMiklos Szeredi OVL_I(inode)->version++; 295bbb1e54dSMiklos Szeredi } 296bbb1e54dSMiklos Szeredi 297bbb1e54dSMiklos Szeredi u64 ovl_dentry_version_get(struct dentry *dentry) 298bbb1e54dSMiklos Szeredi { 29904a01ac7SMiklos Szeredi struct inode *inode = d_inode(dentry); 300bbb1e54dSMiklos Szeredi 30104a01ac7SMiklos Szeredi WARN_ON(!inode_is_locked(inode)); 30204a01ac7SMiklos Szeredi return OVL_I(inode)->version; 303bbb1e54dSMiklos Szeredi } 304bbb1e54dSMiklos Szeredi 305bbb1e54dSMiklos Szeredi bool ovl_is_whiteout(struct dentry *dentry) 306bbb1e54dSMiklos Szeredi { 307bbb1e54dSMiklos Szeredi struct inode *inode = dentry->d_inode; 308bbb1e54dSMiklos Szeredi 309bbb1e54dSMiklos Szeredi return inode && IS_WHITEOUT(inode); 310bbb1e54dSMiklos Szeredi } 311bbb1e54dSMiklos Szeredi 312bbb1e54dSMiklos Szeredi struct file *ovl_path_open(struct path *path, int flags) 313bbb1e54dSMiklos Szeredi { 314bbb1e54dSMiklos Szeredi return dentry_open(path, flags | O_NOATIME, current_cred()); 315bbb1e54dSMiklos Szeredi } 31639d3d60aSAmir Goldstein 31739d3d60aSAmir Goldstein int ovl_copy_up_start(struct dentry *dentry) 31839d3d60aSAmir Goldstein { 319a015dafcSAmir Goldstein struct ovl_inode *oi = OVL_I(d_inode(dentry)); 32039d3d60aSAmir Goldstein int err; 32139d3d60aSAmir Goldstein 322a015dafcSAmir Goldstein err = mutex_lock_interruptible(&oi->lock); 32359be0971SAmir Goldstein if (!err && ovl_dentry_has_upper_alias(dentry)) { 32439d3d60aSAmir Goldstein err = 1; /* Already copied up */ 325a015dafcSAmir Goldstein mutex_unlock(&oi->lock); 32639d3d60aSAmir Goldstein } 32739d3d60aSAmir Goldstein 32839d3d60aSAmir Goldstein return err; 32939d3d60aSAmir Goldstein } 33039d3d60aSAmir Goldstein 33139d3d60aSAmir Goldstein void ovl_copy_up_end(struct dentry *dentry) 33239d3d60aSAmir Goldstein { 333a015dafcSAmir Goldstein mutex_unlock(&OVL_I(d_inode(dentry))->lock); 33439d3d60aSAmir Goldstein } 33582b749b2SAmir Goldstein 336b79e05aaSAmir Goldstein bool ovl_check_origin_xattr(struct dentry *dentry) 337b79e05aaSAmir Goldstein { 338b79e05aaSAmir Goldstein int res; 339b79e05aaSAmir Goldstein 340b79e05aaSAmir Goldstein res = vfs_getxattr(dentry, OVL_XATTR_ORIGIN, NULL, 0); 341b79e05aaSAmir Goldstein 342b79e05aaSAmir Goldstein /* Zero size value means "copied up but origin unknown" */ 343b79e05aaSAmir Goldstein if (res >= 0) 344b79e05aaSAmir Goldstein return true; 345b79e05aaSAmir Goldstein 346b79e05aaSAmir Goldstein return false; 347b79e05aaSAmir Goldstein } 348b79e05aaSAmir Goldstein 349f3a15685SAmir Goldstein bool ovl_check_dir_xattr(struct dentry *dentry, const char *name) 350f3a15685SAmir Goldstein { 351f3a15685SAmir Goldstein int res; 352f3a15685SAmir Goldstein char val; 353f3a15685SAmir Goldstein 354f3a15685SAmir Goldstein if (!d_is_dir(dentry)) 355f3a15685SAmir Goldstein return false; 356f3a15685SAmir Goldstein 357f3a15685SAmir Goldstein res = vfs_getxattr(dentry, name, &val, 1); 358f3a15685SAmir Goldstein if (res == 1 && val == 'y') 359f3a15685SAmir Goldstein return true; 360f3a15685SAmir Goldstein 361f3a15685SAmir Goldstein return false; 362f3a15685SAmir Goldstein } 363f3a15685SAmir Goldstein 36482b749b2SAmir Goldstein int ovl_check_setxattr(struct dentry *dentry, struct dentry *upperdentry, 36582b749b2SAmir Goldstein const char *name, const void *value, size_t size, 36682b749b2SAmir Goldstein int xerr) 36782b749b2SAmir Goldstein { 36882b749b2SAmir Goldstein int err; 36982b749b2SAmir Goldstein struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 37082b749b2SAmir Goldstein 37182b749b2SAmir Goldstein if (ofs->noxattr) 37282b749b2SAmir Goldstein return xerr; 37382b749b2SAmir Goldstein 37482b749b2SAmir Goldstein err = ovl_do_setxattr(upperdentry, name, value, size, 0); 37582b749b2SAmir Goldstein 37682b749b2SAmir Goldstein if (err == -EOPNOTSUPP) { 37782b749b2SAmir Goldstein pr_warn("overlayfs: cannot set %s xattr on upper\n", name); 37882b749b2SAmir Goldstein ofs->noxattr = true; 37982b749b2SAmir Goldstein return xerr; 38082b749b2SAmir Goldstein } 38182b749b2SAmir Goldstein 38282b749b2SAmir Goldstein return err; 38382b749b2SAmir Goldstein } 384f3a15685SAmir Goldstein 385f3a15685SAmir Goldstein int ovl_set_impure(struct dentry *dentry, struct dentry *upperdentry) 386f3a15685SAmir Goldstein { 387f3a15685SAmir Goldstein int err; 388f3a15685SAmir Goldstein 38913c72075SMiklos Szeredi if (ovl_test_flag(OVL_IMPURE, d_inode(dentry))) 390f3a15685SAmir Goldstein return 0; 391f3a15685SAmir Goldstein 392f3a15685SAmir Goldstein /* 393f3a15685SAmir Goldstein * Do not fail when upper doesn't support xattrs. 394f3a15685SAmir Goldstein * Upper inodes won't have origin nor redirect xattr anyway. 395f3a15685SAmir Goldstein */ 396f3a15685SAmir Goldstein err = ovl_check_setxattr(dentry, upperdentry, OVL_XATTR_IMPURE, 397f3a15685SAmir Goldstein "y", 1, 0); 398f3a15685SAmir Goldstein if (!err) 39913c72075SMiklos Szeredi ovl_set_flag(OVL_IMPURE, d_inode(dentry)); 400f3a15685SAmir Goldstein 401f3a15685SAmir Goldstein return err; 402f3a15685SAmir Goldstein } 40313c72075SMiklos Szeredi 40413c72075SMiklos Szeredi void ovl_set_flag(unsigned long flag, struct inode *inode) 40513c72075SMiklos Szeredi { 40613c72075SMiklos Szeredi set_bit(flag, &OVL_I(inode)->flags); 40713c72075SMiklos Szeredi } 40813c72075SMiklos Szeredi 4094edb83bbSMiklos Szeredi void ovl_clear_flag(unsigned long flag, struct inode *inode) 4104edb83bbSMiklos Szeredi { 4114edb83bbSMiklos Szeredi clear_bit(flag, &OVL_I(inode)->flags); 4124edb83bbSMiklos Szeredi } 4134edb83bbSMiklos Szeredi 41413c72075SMiklos Szeredi bool ovl_test_flag(unsigned long flag, struct inode *inode) 41513c72075SMiklos Szeredi { 41613c72075SMiklos Szeredi return test_bit(flag, &OVL_I(inode)->flags); 41713c72075SMiklos Szeredi } 418ad0af710SAmir Goldstein 419ad0af710SAmir Goldstein /** 420ad0af710SAmir Goldstein * Caller must hold a reference to inode to prevent it from being freed while 421ad0af710SAmir Goldstein * it is marked inuse. 422ad0af710SAmir Goldstein */ 423ad0af710SAmir Goldstein bool ovl_inuse_trylock(struct dentry *dentry) 424ad0af710SAmir Goldstein { 425ad0af710SAmir Goldstein struct inode *inode = d_inode(dentry); 426ad0af710SAmir Goldstein bool locked = false; 427ad0af710SAmir Goldstein 428ad0af710SAmir Goldstein spin_lock(&inode->i_lock); 429ad0af710SAmir Goldstein if (!(inode->i_state & I_OVL_INUSE)) { 430ad0af710SAmir Goldstein inode->i_state |= I_OVL_INUSE; 431ad0af710SAmir Goldstein locked = true; 432ad0af710SAmir Goldstein } 433ad0af710SAmir Goldstein spin_unlock(&inode->i_lock); 434ad0af710SAmir Goldstein 435ad0af710SAmir Goldstein return locked; 436ad0af710SAmir Goldstein } 437ad0af710SAmir Goldstein 438ad0af710SAmir Goldstein void ovl_inuse_unlock(struct dentry *dentry) 439ad0af710SAmir Goldstein { 440ad0af710SAmir Goldstein if (dentry) { 441ad0af710SAmir Goldstein struct inode *inode = d_inode(dentry); 442ad0af710SAmir Goldstein 443ad0af710SAmir Goldstein spin_lock(&inode->i_lock); 444ad0af710SAmir Goldstein WARN_ON(!(inode->i_state & I_OVL_INUSE)); 445ad0af710SAmir Goldstein inode->i_state &= ~I_OVL_INUSE; 446ad0af710SAmir Goldstein spin_unlock(&inode->i_lock); 447ad0af710SAmir Goldstein } 448ad0af710SAmir Goldstein } 4495f8415d6SAmir Goldstein 4509f4ec904SAmir Goldstein /* Caller must hold OVL_I(inode)->lock */ 451caf70cb2SAmir Goldstein static void ovl_cleanup_index(struct dentry *dentry) 452caf70cb2SAmir Goldstein { 453caf70cb2SAmir Goldstein struct inode *dir = ovl_indexdir(dentry->d_sb)->d_inode; 454caf70cb2SAmir Goldstein struct dentry *lowerdentry = ovl_dentry_lower(dentry); 455caf70cb2SAmir Goldstein struct dentry *upperdentry = ovl_dentry_upper(dentry); 456caf70cb2SAmir Goldstein struct dentry *index = NULL; 457caf70cb2SAmir Goldstein struct inode *inode; 458caf70cb2SAmir Goldstein struct qstr name; 459caf70cb2SAmir Goldstein int err; 460caf70cb2SAmir Goldstein 461caf70cb2SAmir Goldstein err = ovl_get_index_name(lowerdentry, &name); 462caf70cb2SAmir Goldstein if (err) 463caf70cb2SAmir Goldstein goto fail; 464caf70cb2SAmir Goldstein 465caf70cb2SAmir Goldstein inode = d_inode(upperdentry); 466caf70cb2SAmir Goldstein if (inode->i_nlink != 1) { 467caf70cb2SAmir Goldstein pr_warn_ratelimited("overlayfs: cleanup linked index (%pd2, ino=%lu, nlink=%u)\n", 468caf70cb2SAmir Goldstein upperdentry, inode->i_ino, inode->i_nlink); 469caf70cb2SAmir Goldstein /* 470caf70cb2SAmir Goldstein * We either have a bug with persistent union nlink or a lower 471caf70cb2SAmir Goldstein * hardlink was added while overlay is mounted. Adding a lower 472caf70cb2SAmir Goldstein * hardlink and then unlinking all overlay hardlinks would drop 473caf70cb2SAmir Goldstein * overlay nlink to zero before all upper inodes are unlinked. 474caf70cb2SAmir Goldstein * As a safety measure, when that situation is detected, set 475caf70cb2SAmir Goldstein * the overlay nlink to the index inode nlink minus one for the 476caf70cb2SAmir Goldstein * index entry itself. 477caf70cb2SAmir Goldstein */ 478caf70cb2SAmir Goldstein set_nlink(d_inode(dentry), inode->i_nlink - 1); 479caf70cb2SAmir Goldstein ovl_set_nlink_upper(dentry); 480caf70cb2SAmir Goldstein goto out; 481caf70cb2SAmir Goldstein } 482caf70cb2SAmir Goldstein 483caf70cb2SAmir Goldstein inode_lock_nested(dir, I_MUTEX_PARENT); 484caf70cb2SAmir Goldstein /* TODO: whiteout instead of cleanup to block future open by handle */ 485caf70cb2SAmir Goldstein index = lookup_one_len(name.name, ovl_indexdir(dentry->d_sb), name.len); 486caf70cb2SAmir Goldstein err = PTR_ERR(index); 487caf70cb2SAmir Goldstein if (!IS_ERR(index)) 488caf70cb2SAmir Goldstein err = ovl_cleanup(dir, index); 4899f4ec904SAmir Goldstein else 4909f4ec904SAmir Goldstein index = NULL; 4919f4ec904SAmir Goldstein 492caf70cb2SAmir Goldstein inode_unlock(dir); 493caf70cb2SAmir Goldstein if (err) 494caf70cb2SAmir Goldstein goto fail; 495caf70cb2SAmir Goldstein 496caf70cb2SAmir Goldstein out: 497caf70cb2SAmir Goldstein dput(index); 498caf70cb2SAmir Goldstein return; 499caf70cb2SAmir Goldstein 500caf70cb2SAmir Goldstein fail: 501caf70cb2SAmir Goldstein pr_err("overlayfs: cleanup index of '%pd2' failed (%i)\n", dentry, err); 502caf70cb2SAmir Goldstein goto out; 503caf70cb2SAmir Goldstein } 504caf70cb2SAmir Goldstein 5055f8415d6SAmir Goldstein /* 5065f8415d6SAmir Goldstein * Operations that change overlay inode and upper inode nlink need to be 5075f8415d6SAmir Goldstein * synchronized with copy up for persistent nlink accounting. 5085f8415d6SAmir Goldstein */ 5095f8415d6SAmir Goldstein int ovl_nlink_start(struct dentry *dentry, bool *locked) 5105f8415d6SAmir Goldstein { 5115f8415d6SAmir Goldstein struct ovl_inode *oi = OVL_I(d_inode(dentry)); 5125f8415d6SAmir Goldstein const struct cred *old_cred; 5135f8415d6SAmir Goldstein int err; 5145f8415d6SAmir Goldstein 5155f8415d6SAmir Goldstein if (!d_inode(dentry) || d_is_dir(dentry)) 5165f8415d6SAmir Goldstein return 0; 5175f8415d6SAmir Goldstein 5185f8415d6SAmir Goldstein /* 5195f8415d6SAmir Goldstein * With inodes index is enabled, we store the union overlay nlink 5205f8415d6SAmir Goldstein * in an xattr on the index inode. When whiting out lower hardlinks 5215f8415d6SAmir Goldstein * we need to decrement the overlay persistent nlink, but before the 5225f8415d6SAmir Goldstein * first copy up, we have no upper index inode to store the xattr. 5235f8415d6SAmir Goldstein * 5245f8415d6SAmir Goldstein * As a workaround, before whiteout/rename over of a lower hardlink, 5255f8415d6SAmir Goldstein * copy up to create the upper index. Creating the upper index will 5265f8415d6SAmir Goldstein * initialize the overlay nlink, so it could be dropped if unlink 5275f8415d6SAmir Goldstein * or rename succeeds. 5285f8415d6SAmir Goldstein * 5295f8415d6SAmir Goldstein * TODO: implement metadata only index copy up when called with 5305f8415d6SAmir Goldstein * ovl_copy_up_flags(dentry, O_PATH). 5315f8415d6SAmir Goldstein */ 5325f8415d6SAmir Goldstein if (ovl_indexdir(dentry->d_sb) && !ovl_dentry_has_upper_alias(dentry) && 5335f8415d6SAmir Goldstein d_inode(ovl_dentry_lower(dentry))->i_nlink > 1) { 5345f8415d6SAmir Goldstein err = ovl_copy_up(dentry); 5355f8415d6SAmir Goldstein if (err) 5365f8415d6SAmir Goldstein return err; 5375f8415d6SAmir Goldstein } 5385f8415d6SAmir Goldstein 5395f8415d6SAmir Goldstein err = mutex_lock_interruptible(&oi->lock); 5405f8415d6SAmir Goldstein if (err) 5415f8415d6SAmir Goldstein return err; 5425f8415d6SAmir Goldstein 5435f8415d6SAmir Goldstein if (!ovl_test_flag(OVL_INDEX, d_inode(dentry))) 5445f8415d6SAmir Goldstein goto out; 5455f8415d6SAmir Goldstein 5465f8415d6SAmir Goldstein old_cred = ovl_override_creds(dentry->d_sb); 5475f8415d6SAmir Goldstein /* 5485f8415d6SAmir Goldstein * The overlay inode nlink should be incremented/decremented IFF the 5495f8415d6SAmir Goldstein * upper operation succeeds, along with nlink change of upper inode. 5505f8415d6SAmir Goldstein * Therefore, before link/unlink/rename, we store the union nlink 5515f8415d6SAmir Goldstein * value relative to the upper inode nlink in an upper inode xattr. 5525f8415d6SAmir Goldstein */ 5535f8415d6SAmir Goldstein err = ovl_set_nlink_upper(dentry); 5545f8415d6SAmir Goldstein revert_creds(old_cred); 5555f8415d6SAmir Goldstein 5565f8415d6SAmir Goldstein out: 5575f8415d6SAmir Goldstein if (err) 5585f8415d6SAmir Goldstein mutex_unlock(&oi->lock); 5595f8415d6SAmir Goldstein else 5605f8415d6SAmir Goldstein *locked = true; 5615f8415d6SAmir Goldstein 5625f8415d6SAmir Goldstein return err; 5635f8415d6SAmir Goldstein } 5645f8415d6SAmir Goldstein 5655f8415d6SAmir Goldstein void ovl_nlink_end(struct dentry *dentry, bool locked) 5665f8415d6SAmir Goldstein { 567caf70cb2SAmir Goldstein if (locked) { 568caf70cb2SAmir Goldstein if (ovl_test_flag(OVL_INDEX, d_inode(dentry)) && 569caf70cb2SAmir Goldstein d_inode(dentry)->i_nlink == 0) { 570caf70cb2SAmir Goldstein const struct cred *old_cred; 571caf70cb2SAmir Goldstein 572caf70cb2SAmir Goldstein old_cred = ovl_override_creds(dentry->d_sb); 573caf70cb2SAmir Goldstein ovl_cleanup_index(dentry); 574caf70cb2SAmir Goldstein revert_creds(old_cred); 575caf70cb2SAmir Goldstein } 576caf70cb2SAmir Goldstein 5775f8415d6SAmir Goldstein mutex_unlock(&OVL_I(d_inode(dentry))->lock); 5785f8415d6SAmir Goldstein } 579caf70cb2SAmir Goldstein } 5805820dc08SAmir Goldstein 5815820dc08SAmir Goldstein int ovl_lock_rename_workdir(struct dentry *workdir, struct dentry *upperdir) 5825820dc08SAmir Goldstein { 5835820dc08SAmir Goldstein /* Workdir should not be the same as upperdir */ 5845820dc08SAmir Goldstein if (workdir == upperdir) 5855820dc08SAmir Goldstein goto err; 5865820dc08SAmir Goldstein 5875820dc08SAmir Goldstein /* Workdir should not be subdir of upperdir and vice versa */ 5885820dc08SAmir Goldstein if (lock_rename(workdir, upperdir) != NULL) 5895820dc08SAmir Goldstein goto err_unlock; 5905820dc08SAmir Goldstein 5915820dc08SAmir Goldstein return 0; 5925820dc08SAmir Goldstein 5935820dc08SAmir Goldstein err_unlock: 5945820dc08SAmir Goldstein unlock_rename(workdir, upperdir); 5955820dc08SAmir Goldstein err: 5965820dc08SAmir Goldstein pr_err("overlayfs: failed to lock workdir+upperdir\n"); 5975820dc08SAmir Goldstein return -EIO; 5985820dc08SAmir Goldstein } 599