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 #include "ovl_entry.h" 21bbb1e54dSMiklos Szeredi 22bbb1e54dSMiklos Szeredi int ovl_want_write(struct dentry *dentry) 23bbb1e54dSMiklos Szeredi { 24bbb1e54dSMiklos Szeredi struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 25bbb1e54dSMiklos Szeredi return mnt_want_write(ofs->upper_mnt); 26bbb1e54dSMiklos Szeredi } 27bbb1e54dSMiklos Szeredi 28bbb1e54dSMiklos Szeredi void ovl_drop_write(struct dentry *dentry) 29bbb1e54dSMiklos Szeredi { 30bbb1e54dSMiklos Szeredi struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 31bbb1e54dSMiklos Szeredi mnt_drop_write(ofs->upper_mnt); 32bbb1e54dSMiklos Szeredi } 33bbb1e54dSMiklos Szeredi 34bbb1e54dSMiklos Szeredi struct dentry *ovl_workdir(struct dentry *dentry) 35bbb1e54dSMiklos Szeredi { 36bbb1e54dSMiklos Szeredi struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 37bbb1e54dSMiklos Szeredi return ofs->workdir; 38bbb1e54dSMiklos Szeredi } 39bbb1e54dSMiklos Szeredi 40bbb1e54dSMiklos Szeredi const struct cred *ovl_override_creds(struct super_block *sb) 41bbb1e54dSMiklos Szeredi { 42bbb1e54dSMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 43bbb1e54dSMiklos Szeredi 44bbb1e54dSMiklos Szeredi return override_creds(ofs->creator_cred); 45bbb1e54dSMiklos Szeredi } 46bbb1e54dSMiklos Szeredi 477bcd74b9SAmir Goldstein struct super_block *ovl_same_sb(struct super_block *sb) 487bcd74b9SAmir Goldstein { 497bcd74b9SAmir Goldstein struct ovl_fs *ofs = sb->s_fs_info; 507bcd74b9SAmir Goldstein 517bcd74b9SAmir Goldstein return ofs->same_sb; 527bcd74b9SAmir Goldstein } 537bcd74b9SAmir Goldstein 5402bcd157SAmir Goldstein bool ovl_can_decode_fh(struct super_block *sb) 5502bcd157SAmir Goldstein { 5602bcd157SAmir Goldstein return (sb->s_export_op && sb->s_export_op->fh_to_dentry && 5702bcd157SAmir Goldstein !uuid_is_null(&sb->s_uuid)); 5802bcd157SAmir Goldstein } 5902bcd157SAmir Goldstein 6002bcd157SAmir Goldstein struct dentry *ovl_indexdir(struct super_block *sb) 6102bcd157SAmir Goldstein { 6202bcd157SAmir Goldstein struct ovl_fs *ofs = sb->s_fs_info; 6302bcd157SAmir Goldstein 6402bcd157SAmir Goldstein return ofs->indexdir; 6502bcd157SAmir Goldstein } 6602bcd157SAmir Goldstein 67bbb1e54dSMiklos Szeredi struct ovl_entry *ovl_alloc_entry(unsigned int numlower) 68bbb1e54dSMiklos Szeredi { 69bbb1e54dSMiklos Szeredi size_t size = offsetof(struct ovl_entry, lowerstack[numlower]); 70bbb1e54dSMiklos Szeredi struct ovl_entry *oe = kzalloc(size, GFP_KERNEL); 71bbb1e54dSMiklos Szeredi 72bbb1e54dSMiklos Szeredi if (oe) 73bbb1e54dSMiklos Szeredi oe->numlower = numlower; 74bbb1e54dSMiklos Szeredi 75bbb1e54dSMiklos Szeredi return oe; 76bbb1e54dSMiklos Szeredi } 77bbb1e54dSMiklos Szeredi 78bbb1e54dSMiklos Szeredi bool ovl_dentry_remote(struct dentry *dentry) 79bbb1e54dSMiklos Szeredi { 80bbb1e54dSMiklos Szeredi return dentry->d_flags & 81bbb1e54dSMiklos Szeredi (DCACHE_OP_REVALIDATE | DCACHE_OP_WEAK_REVALIDATE | 82bbb1e54dSMiklos Szeredi DCACHE_OP_REAL); 83bbb1e54dSMiklos Szeredi } 84bbb1e54dSMiklos Szeredi 85bbb1e54dSMiklos Szeredi bool ovl_dentry_weird(struct dentry *dentry) 86bbb1e54dSMiklos Szeredi { 87bbb1e54dSMiklos Szeredi return dentry->d_flags & (DCACHE_NEED_AUTOMOUNT | 88bbb1e54dSMiklos Szeredi DCACHE_MANAGE_TRANSIT | 89bbb1e54dSMiklos Szeredi DCACHE_OP_HASH | 90bbb1e54dSMiklos Szeredi DCACHE_OP_COMPARE); 91bbb1e54dSMiklos Szeredi } 92bbb1e54dSMiklos Szeredi 93bbb1e54dSMiklos Szeredi enum ovl_path_type ovl_path_type(struct dentry *dentry) 94bbb1e54dSMiklos Szeredi { 95bbb1e54dSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 96bbb1e54dSMiklos Szeredi enum ovl_path_type type = 0; 97bbb1e54dSMiklos Szeredi 9809d8b586SMiklos Szeredi if (ovl_dentry_upper(dentry)) { 99bbb1e54dSMiklos Szeredi type = __OVL_PATH_UPPER; 100bbb1e54dSMiklos Szeredi 101bbb1e54dSMiklos Szeredi /* 10259548503SAmir Goldstein * Non-dir dentry can hold lower dentry of its copy up origin. 103bbb1e54dSMiklos Szeredi */ 10459548503SAmir Goldstein if (oe->numlower) { 10559548503SAmir Goldstein type |= __OVL_PATH_ORIGIN; 10659548503SAmir Goldstein if (d_is_dir(dentry)) 107bbb1e54dSMiklos Szeredi type |= __OVL_PATH_MERGE; 10859548503SAmir Goldstein } 109bbb1e54dSMiklos Szeredi } else { 110bbb1e54dSMiklos Szeredi if (oe->numlower > 1) 111bbb1e54dSMiklos Szeredi type |= __OVL_PATH_MERGE; 112bbb1e54dSMiklos Szeredi } 113bbb1e54dSMiklos Szeredi return type; 114bbb1e54dSMiklos Szeredi } 115bbb1e54dSMiklos Szeredi 116bbb1e54dSMiklos Szeredi void ovl_path_upper(struct dentry *dentry, struct path *path) 117bbb1e54dSMiklos Szeredi { 118bbb1e54dSMiklos Szeredi struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 119bbb1e54dSMiklos Szeredi 120bbb1e54dSMiklos Szeredi path->mnt = ofs->upper_mnt; 12109d8b586SMiklos Szeredi path->dentry = ovl_dentry_upper(dentry); 122bbb1e54dSMiklos Szeredi } 123bbb1e54dSMiklos Szeredi 124bbb1e54dSMiklos Szeredi void ovl_path_lower(struct dentry *dentry, struct path *path) 125bbb1e54dSMiklos Szeredi { 126bbb1e54dSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 127bbb1e54dSMiklos Szeredi 12833006cdfSKees Cook *path = oe->numlower ? oe->lowerstack[0] : (struct path) { }; 129bbb1e54dSMiklos Szeredi } 130bbb1e54dSMiklos Szeredi 131bbb1e54dSMiklos Szeredi enum ovl_path_type ovl_path_real(struct dentry *dentry, struct path *path) 132bbb1e54dSMiklos Szeredi { 133bbb1e54dSMiklos Szeredi enum ovl_path_type type = ovl_path_type(dentry); 134bbb1e54dSMiklos Szeredi 135bbb1e54dSMiklos Szeredi if (!OVL_TYPE_UPPER(type)) 136bbb1e54dSMiklos Szeredi ovl_path_lower(dentry, path); 137bbb1e54dSMiklos Szeredi else 138bbb1e54dSMiklos Szeredi ovl_path_upper(dentry, path); 139bbb1e54dSMiklos Szeredi 140bbb1e54dSMiklos Szeredi return type; 141bbb1e54dSMiklos Szeredi } 142bbb1e54dSMiklos Szeredi 143bbb1e54dSMiklos Szeredi struct dentry *ovl_dentry_upper(struct dentry *dentry) 144bbb1e54dSMiklos Szeredi { 14509d8b586SMiklos Szeredi return ovl_upperdentry_dereference(OVL_I(d_inode(dentry))); 146bbb1e54dSMiklos Szeredi } 147bbb1e54dSMiklos Szeredi 148bbb1e54dSMiklos Szeredi struct dentry *ovl_dentry_lower(struct dentry *dentry) 149bbb1e54dSMiklos Szeredi { 150bbb1e54dSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 151bbb1e54dSMiklos Szeredi 15209d8b586SMiklos Szeredi return oe->numlower ? oe->lowerstack[0].dentry : NULL; 153bbb1e54dSMiklos Szeredi } 154bbb1e54dSMiklos Szeredi 155bbb1e54dSMiklos Szeredi struct dentry *ovl_dentry_real(struct dentry *dentry) 156bbb1e54dSMiklos Szeredi { 15709d8b586SMiklos Szeredi return ovl_dentry_upper(dentry) ?: ovl_dentry_lower(dentry); 158bbb1e54dSMiklos Szeredi } 159bbb1e54dSMiklos Szeredi 1601d88f183SMiklos Szeredi struct dentry *ovl_i_dentry_upper(struct inode *inode) 1611d88f183SMiklos Szeredi { 1621d88f183SMiklos Szeredi return ovl_upperdentry_dereference(OVL_I(inode)); 1631d88f183SMiklos Szeredi } 1641d88f183SMiklos Szeredi 16509d8b586SMiklos Szeredi struct inode *ovl_inode_upper(struct inode *inode) 16625b7713aSMiklos Szeredi { 1671d88f183SMiklos Szeredi struct dentry *upperdentry = ovl_i_dentry_upper(inode); 16825b7713aSMiklos Szeredi 16909d8b586SMiklos Szeredi return upperdentry ? d_inode(upperdentry) : NULL; 17025b7713aSMiklos Szeredi } 17125b7713aSMiklos Szeredi 17209d8b586SMiklos Szeredi struct inode *ovl_inode_lower(struct inode *inode) 17309d8b586SMiklos Szeredi { 17409d8b586SMiklos Szeredi return OVL_I(inode)->lower; 17509d8b586SMiklos Szeredi } 17609d8b586SMiklos Szeredi 17709d8b586SMiklos Szeredi struct inode *ovl_inode_real(struct inode *inode) 17809d8b586SMiklos Szeredi { 17909d8b586SMiklos Szeredi return ovl_inode_upper(inode) ?: ovl_inode_lower(inode); 18009d8b586SMiklos Szeredi } 18109d8b586SMiklos Szeredi 18209d8b586SMiklos Szeredi 1834edb83bbSMiklos Szeredi struct ovl_dir_cache *ovl_dir_cache(struct inode *inode) 184bbb1e54dSMiklos Szeredi { 1854edb83bbSMiklos Szeredi return OVL_I(inode)->cache; 186bbb1e54dSMiklos Szeredi } 187bbb1e54dSMiklos Szeredi 1884edb83bbSMiklos Szeredi void ovl_set_dir_cache(struct inode *inode, struct ovl_dir_cache *cache) 189bbb1e54dSMiklos Szeredi { 1904edb83bbSMiklos Szeredi OVL_I(inode)->cache = cache; 191bbb1e54dSMiklos Szeredi } 192bbb1e54dSMiklos Szeredi 193bbb1e54dSMiklos Szeredi bool ovl_dentry_is_opaque(struct dentry *dentry) 194bbb1e54dSMiklos Szeredi { 195bbb1e54dSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 196bbb1e54dSMiklos Szeredi return oe->opaque; 197bbb1e54dSMiklos Szeredi } 198bbb1e54dSMiklos Szeredi 199bbb1e54dSMiklos Szeredi bool ovl_dentry_is_whiteout(struct dentry *dentry) 200bbb1e54dSMiklos Szeredi { 201bbb1e54dSMiklos Szeredi return !dentry->d_inode && ovl_dentry_is_opaque(dentry); 202bbb1e54dSMiklos Szeredi } 203bbb1e54dSMiklos Szeredi 2045cf5b477SMiklos Szeredi void ovl_dentry_set_opaque(struct dentry *dentry) 205bbb1e54dSMiklos Szeredi { 206bbb1e54dSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 2075cf5b477SMiklos Szeredi 2085cf5b477SMiklos Szeredi oe->opaque = true; 209bbb1e54dSMiklos Szeredi } 210bbb1e54dSMiklos Szeredi 21155acc661SMiklos Szeredi /* 21255acc661SMiklos Szeredi * For hard links it's possible for ovl_dentry_upper() to return positive, while 21355acc661SMiklos Szeredi * there's no actual upper alias for the inode. Copy up code needs to know 21455acc661SMiklos Szeredi * about the existence of the upper alias, so it can't use ovl_dentry_upper(). 21555acc661SMiklos Szeredi */ 21655acc661SMiklos Szeredi bool ovl_dentry_has_upper_alias(struct dentry *dentry) 21755acc661SMiklos Szeredi { 21855acc661SMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 21955acc661SMiklos Szeredi 22055acc661SMiklos Szeredi return oe->has_upper; 22155acc661SMiklos Szeredi } 22255acc661SMiklos Szeredi 22355acc661SMiklos Szeredi void ovl_dentry_set_upper_alias(struct dentry *dentry) 22455acc661SMiklos Szeredi { 22555acc661SMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 22655acc661SMiklos Szeredi 22755acc661SMiklos Szeredi oe->has_upper = true; 22855acc661SMiklos Szeredi } 22955acc661SMiklos Szeredi 230a6c60655SMiklos Szeredi bool ovl_redirect_dir(struct super_block *sb) 231a6c60655SMiklos Szeredi { 232a6c60655SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 233a6c60655SMiklos Szeredi 23421a22878SAmir Goldstein return ofs->config.redirect_dir && !ofs->noxattr; 235a6c60655SMiklos Szeredi } 236a6c60655SMiklos Szeredi 237a6c60655SMiklos Szeredi const char *ovl_dentry_get_redirect(struct dentry *dentry) 238a6c60655SMiklos Szeredi { 239cf31c463SMiklos Szeredi return OVL_I(d_inode(dentry))->redirect; 240a6c60655SMiklos Szeredi } 241a6c60655SMiklos Szeredi 242a6c60655SMiklos Szeredi void ovl_dentry_set_redirect(struct dentry *dentry, const char *redirect) 243a6c60655SMiklos Szeredi { 244cf31c463SMiklos Szeredi struct ovl_inode *oi = OVL_I(d_inode(dentry)); 245a6c60655SMiklos Szeredi 246cf31c463SMiklos Szeredi kfree(oi->redirect); 247cf31c463SMiklos Szeredi oi->redirect = redirect; 248a6c60655SMiklos Szeredi } 249a6c60655SMiklos Szeredi 25009d8b586SMiklos Szeredi void ovl_inode_init(struct inode *inode, struct dentry *upperdentry, 25109d8b586SMiklos Szeredi struct dentry *lowerdentry) 252bbb1e54dSMiklos Szeredi { 25309d8b586SMiklos Szeredi if (upperdentry) 25409d8b586SMiklos Szeredi OVL_I(inode)->__upperdentry = upperdentry; 25509d8b586SMiklos Szeredi if (lowerdentry) 25609d8b586SMiklos Szeredi OVL_I(inode)->lower = d_inode(lowerdentry); 257bbb1e54dSMiklos Szeredi 25809d8b586SMiklos Szeredi ovl_copyattr(d_inode(upperdentry ?: lowerdentry), inode); 259bbb1e54dSMiklos Szeredi } 260bbb1e54dSMiklos Szeredi 26109d8b586SMiklos Szeredi void ovl_inode_update(struct inode *inode, struct dentry *upperdentry) 262bbb1e54dSMiklos Szeredi { 26309d8b586SMiklos Szeredi struct inode *upperinode = d_inode(upperdentry); 264e6d2ebddSMiklos Szeredi 26509d8b586SMiklos Szeredi WARN_ON(OVL_I(inode)->__upperdentry); 26609d8b586SMiklos Szeredi 26725b7713aSMiklos Szeredi /* 26809d8b586SMiklos Szeredi * Make sure upperdentry is consistent before making it visible 26925b7713aSMiklos Szeredi */ 27025b7713aSMiklos Szeredi smp_wmb(); 27109d8b586SMiklos Szeredi OVL_I(inode)->__upperdentry = upperdentry; 272b9ac5c27SMiklos Szeredi if (!S_ISDIR(upperinode->i_mode) && inode_unhashed(inode)) { 27325b7713aSMiklos Szeredi inode->i_private = upperinode; 274bbb1e54dSMiklos Szeredi __insert_inode_hash(inode, (unsigned long) upperinode); 275bbb1e54dSMiklos Szeredi } 27625b7713aSMiklos Szeredi } 277bbb1e54dSMiklos Szeredi 2784edb83bbSMiklos Szeredi void ovl_dentry_version_inc(struct dentry *dentry, bool impurity) 279bbb1e54dSMiklos Szeredi { 28004a01ac7SMiklos Szeredi struct inode *inode = d_inode(dentry); 281bbb1e54dSMiklos Szeredi 28204a01ac7SMiklos Szeredi WARN_ON(!inode_is_locked(inode)); 2834edb83bbSMiklos Szeredi /* 2844edb83bbSMiklos Szeredi * Version is used by readdir code to keep cache consistent. For merge 2854edb83bbSMiklos Szeredi * dirs all changes need to be noted. For non-merge dirs, cache only 2864edb83bbSMiklos Szeredi * contains impure (ones which have been copied up and have origins) 2874edb83bbSMiklos Szeredi * entries, so only need to note changes to impure entries. 2884edb83bbSMiklos Szeredi */ 2894edb83bbSMiklos Szeredi if (OVL_TYPE_MERGE(ovl_path_type(dentry)) || impurity) 29004a01ac7SMiklos Szeredi OVL_I(inode)->version++; 291bbb1e54dSMiklos Szeredi } 292bbb1e54dSMiklos Szeredi 293bbb1e54dSMiklos Szeredi u64 ovl_dentry_version_get(struct dentry *dentry) 294bbb1e54dSMiklos Szeredi { 29504a01ac7SMiklos Szeredi struct inode *inode = d_inode(dentry); 296bbb1e54dSMiklos Szeredi 29704a01ac7SMiklos Szeredi WARN_ON(!inode_is_locked(inode)); 29804a01ac7SMiklos Szeredi return OVL_I(inode)->version; 299bbb1e54dSMiklos Szeredi } 300bbb1e54dSMiklos Szeredi 301bbb1e54dSMiklos Szeredi bool ovl_is_whiteout(struct dentry *dentry) 302bbb1e54dSMiklos Szeredi { 303bbb1e54dSMiklos Szeredi struct inode *inode = dentry->d_inode; 304bbb1e54dSMiklos Szeredi 305bbb1e54dSMiklos Szeredi return inode && IS_WHITEOUT(inode); 306bbb1e54dSMiklos Szeredi } 307bbb1e54dSMiklos Szeredi 308bbb1e54dSMiklos Szeredi struct file *ovl_path_open(struct path *path, int flags) 309bbb1e54dSMiklos Szeredi { 310bbb1e54dSMiklos Szeredi return dentry_open(path, flags | O_NOATIME, current_cred()); 311bbb1e54dSMiklos Szeredi } 31239d3d60aSAmir Goldstein 31339d3d60aSAmir Goldstein int ovl_copy_up_start(struct dentry *dentry) 31439d3d60aSAmir Goldstein { 315a015dafcSAmir Goldstein struct ovl_inode *oi = OVL_I(d_inode(dentry)); 31639d3d60aSAmir Goldstein int err; 31739d3d60aSAmir Goldstein 318a015dafcSAmir Goldstein err = mutex_lock_interruptible(&oi->lock); 31959be0971SAmir Goldstein if (!err && ovl_dentry_has_upper_alias(dentry)) { 32039d3d60aSAmir Goldstein err = 1; /* Already copied up */ 321a015dafcSAmir Goldstein mutex_unlock(&oi->lock); 32239d3d60aSAmir Goldstein } 32339d3d60aSAmir Goldstein 32439d3d60aSAmir Goldstein return err; 32539d3d60aSAmir Goldstein } 32639d3d60aSAmir Goldstein 32739d3d60aSAmir Goldstein void ovl_copy_up_end(struct dentry *dentry) 32839d3d60aSAmir Goldstein { 329a015dafcSAmir Goldstein mutex_unlock(&OVL_I(d_inode(dentry))->lock); 33039d3d60aSAmir Goldstein } 33182b749b2SAmir Goldstein 332f3a15685SAmir Goldstein bool ovl_check_dir_xattr(struct dentry *dentry, const char *name) 333f3a15685SAmir Goldstein { 334f3a15685SAmir Goldstein int res; 335f3a15685SAmir Goldstein char val; 336f3a15685SAmir Goldstein 337f3a15685SAmir Goldstein if (!d_is_dir(dentry)) 338f3a15685SAmir Goldstein return false; 339f3a15685SAmir Goldstein 340f3a15685SAmir Goldstein res = vfs_getxattr(dentry, name, &val, 1); 341f3a15685SAmir Goldstein if (res == 1 && val == 'y') 342f3a15685SAmir Goldstein return true; 343f3a15685SAmir Goldstein 344f3a15685SAmir Goldstein return false; 345f3a15685SAmir Goldstein } 346f3a15685SAmir Goldstein 34782b749b2SAmir Goldstein int ovl_check_setxattr(struct dentry *dentry, struct dentry *upperdentry, 34882b749b2SAmir Goldstein const char *name, const void *value, size_t size, 34982b749b2SAmir Goldstein int xerr) 35082b749b2SAmir Goldstein { 35182b749b2SAmir Goldstein int err; 35282b749b2SAmir Goldstein struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 35382b749b2SAmir Goldstein 35482b749b2SAmir Goldstein if (ofs->noxattr) 35582b749b2SAmir Goldstein return xerr; 35682b749b2SAmir Goldstein 35782b749b2SAmir Goldstein err = ovl_do_setxattr(upperdentry, name, value, size, 0); 35882b749b2SAmir Goldstein 35982b749b2SAmir Goldstein if (err == -EOPNOTSUPP) { 36082b749b2SAmir Goldstein pr_warn("overlayfs: cannot set %s xattr on upper\n", name); 36182b749b2SAmir Goldstein ofs->noxattr = true; 36282b749b2SAmir Goldstein return xerr; 36382b749b2SAmir Goldstein } 36482b749b2SAmir Goldstein 36582b749b2SAmir Goldstein return err; 36682b749b2SAmir Goldstein } 367f3a15685SAmir Goldstein 368f3a15685SAmir Goldstein int ovl_set_impure(struct dentry *dentry, struct dentry *upperdentry) 369f3a15685SAmir Goldstein { 370f3a15685SAmir Goldstein int err; 371f3a15685SAmir Goldstein 37213c72075SMiklos Szeredi if (ovl_test_flag(OVL_IMPURE, d_inode(dentry))) 373f3a15685SAmir Goldstein return 0; 374f3a15685SAmir Goldstein 375f3a15685SAmir Goldstein /* 376f3a15685SAmir Goldstein * Do not fail when upper doesn't support xattrs. 377f3a15685SAmir Goldstein * Upper inodes won't have origin nor redirect xattr anyway. 378f3a15685SAmir Goldstein */ 379f3a15685SAmir Goldstein err = ovl_check_setxattr(dentry, upperdentry, OVL_XATTR_IMPURE, 380f3a15685SAmir Goldstein "y", 1, 0); 381f3a15685SAmir Goldstein if (!err) 38213c72075SMiklos Szeredi ovl_set_flag(OVL_IMPURE, d_inode(dentry)); 383f3a15685SAmir Goldstein 384f3a15685SAmir Goldstein return err; 385f3a15685SAmir Goldstein } 38613c72075SMiklos Szeredi 38713c72075SMiklos Szeredi void ovl_set_flag(unsigned long flag, struct inode *inode) 38813c72075SMiklos Szeredi { 38913c72075SMiklos Szeredi set_bit(flag, &OVL_I(inode)->flags); 39013c72075SMiklos Szeredi } 39113c72075SMiklos Szeredi 3924edb83bbSMiklos Szeredi void ovl_clear_flag(unsigned long flag, struct inode *inode) 3934edb83bbSMiklos Szeredi { 3944edb83bbSMiklos Szeredi clear_bit(flag, &OVL_I(inode)->flags); 3954edb83bbSMiklos Szeredi } 3964edb83bbSMiklos Szeredi 39713c72075SMiklos Szeredi bool ovl_test_flag(unsigned long flag, struct inode *inode) 39813c72075SMiklos Szeredi { 39913c72075SMiklos Szeredi return test_bit(flag, &OVL_I(inode)->flags); 40013c72075SMiklos Szeredi } 401ad0af710SAmir Goldstein 402ad0af710SAmir Goldstein /** 403ad0af710SAmir Goldstein * Caller must hold a reference to inode to prevent it from being freed while 404ad0af710SAmir Goldstein * it is marked inuse. 405ad0af710SAmir Goldstein */ 406ad0af710SAmir Goldstein bool ovl_inuse_trylock(struct dentry *dentry) 407ad0af710SAmir Goldstein { 408ad0af710SAmir Goldstein struct inode *inode = d_inode(dentry); 409ad0af710SAmir Goldstein bool locked = false; 410ad0af710SAmir Goldstein 411ad0af710SAmir Goldstein spin_lock(&inode->i_lock); 412ad0af710SAmir Goldstein if (!(inode->i_state & I_OVL_INUSE)) { 413ad0af710SAmir Goldstein inode->i_state |= I_OVL_INUSE; 414ad0af710SAmir Goldstein locked = true; 415ad0af710SAmir Goldstein } 416ad0af710SAmir Goldstein spin_unlock(&inode->i_lock); 417ad0af710SAmir Goldstein 418ad0af710SAmir Goldstein return locked; 419ad0af710SAmir Goldstein } 420ad0af710SAmir Goldstein 421ad0af710SAmir Goldstein void ovl_inuse_unlock(struct dentry *dentry) 422ad0af710SAmir Goldstein { 423ad0af710SAmir Goldstein if (dentry) { 424ad0af710SAmir Goldstein struct inode *inode = d_inode(dentry); 425ad0af710SAmir Goldstein 426ad0af710SAmir Goldstein spin_lock(&inode->i_lock); 427ad0af710SAmir Goldstein WARN_ON(!(inode->i_state & I_OVL_INUSE)); 428ad0af710SAmir Goldstein inode->i_state &= ~I_OVL_INUSE; 429ad0af710SAmir Goldstein spin_unlock(&inode->i_lock); 430ad0af710SAmir Goldstein } 431ad0af710SAmir Goldstein } 4325f8415d6SAmir Goldstein 4339f4ec904SAmir Goldstein /* Caller must hold OVL_I(inode)->lock */ 434caf70cb2SAmir Goldstein static void ovl_cleanup_index(struct dentry *dentry) 435caf70cb2SAmir Goldstein { 436caf70cb2SAmir Goldstein struct inode *dir = ovl_indexdir(dentry->d_sb)->d_inode; 437caf70cb2SAmir Goldstein struct dentry *lowerdentry = ovl_dentry_lower(dentry); 438caf70cb2SAmir Goldstein struct dentry *upperdentry = ovl_dentry_upper(dentry); 439caf70cb2SAmir Goldstein struct dentry *index = NULL; 440caf70cb2SAmir Goldstein struct inode *inode; 441caf70cb2SAmir Goldstein struct qstr name; 442caf70cb2SAmir Goldstein int err; 443caf70cb2SAmir Goldstein 444caf70cb2SAmir Goldstein err = ovl_get_index_name(lowerdentry, &name); 445caf70cb2SAmir Goldstein if (err) 446caf70cb2SAmir Goldstein goto fail; 447caf70cb2SAmir Goldstein 448caf70cb2SAmir Goldstein inode = d_inode(upperdentry); 449caf70cb2SAmir Goldstein if (inode->i_nlink != 1) { 450caf70cb2SAmir Goldstein pr_warn_ratelimited("overlayfs: cleanup linked index (%pd2, ino=%lu, nlink=%u)\n", 451caf70cb2SAmir Goldstein upperdentry, inode->i_ino, inode->i_nlink); 452caf70cb2SAmir Goldstein /* 453caf70cb2SAmir Goldstein * We either have a bug with persistent union nlink or a lower 454caf70cb2SAmir Goldstein * hardlink was added while overlay is mounted. Adding a lower 455caf70cb2SAmir Goldstein * hardlink and then unlinking all overlay hardlinks would drop 456caf70cb2SAmir Goldstein * overlay nlink to zero before all upper inodes are unlinked. 457caf70cb2SAmir Goldstein * As a safety measure, when that situation is detected, set 458caf70cb2SAmir Goldstein * the overlay nlink to the index inode nlink minus one for the 459caf70cb2SAmir Goldstein * index entry itself. 460caf70cb2SAmir Goldstein */ 461caf70cb2SAmir Goldstein set_nlink(d_inode(dentry), inode->i_nlink - 1); 462caf70cb2SAmir Goldstein ovl_set_nlink_upper(dentry); 463caf70cb2SAmir Goldstein goto out; 464caf70cb2SAmir Goldstein } 465caf70cb2SAmir Goldstein 466caf70cb2SAmir Goldstein inode_lock_nested(dir, I_MUTEX_PARENT); 467caf70cb2SAmir Goldstein /* TODO: whiteout instead of cleanup to block future open by handle */ 468caf70cb2SAmir Goldstein index = lookup_one_len(name.name, ovl_indexdir(dentry->d_sb), name.len); 469caf70cb2SAmir Goldstein err = PTR_ERR(index); 470caf70cb2SAmir Goldstein if (!IS_ERR(index)) 471caf70cb2SAmir Goldstein err = ovl_cleanup(dir, index); 4729f4ec904SAmir Goldstein else 4739f4ec904SAmir Goldstein index = NULL; 4749f4ec904SAmir Goldstein 475caf70cb2SAmir Goldstein inode_unlock(dir); 476caf70cb2SAmir Goldstein if (err) 477caf70cb2SAmir Goldstein goto fail; 478caf70cb2SAmir Goldstein 479caf70cb2SAmir Goldstein out: 480caf70cb2SAmir Goldstein dput(index); 481caf70cb2SAmir Goldstein return; 482caf70cb2SAmir Goldstein 483caf70cb2SAmir Goldstein fail: 484caf70cb2SAmir Goldstein pr_err("overlayfs: cleanup index of '%pd2' failed (%i)\n", dentry, err); 485caf70cb2SAmir Goldstein goto out; 486caf70cb2SAmir Goldstein } 487caf70cb2SAmir Goldstein 4885f8415d6SAmir Goldstein /* 4895f8415d6SAmir Goldstein * Operations that change overlay inode and upper inode nlink need to be 4905f8415d6SAmir Goldstein * synchronized with copy up for persistent nlink accounting. 4915f8415d6SAmir Goldstein */ 4925f8415d6SAmir Goldstein int ovl_nlink_start(struct dentry *dentry, bool *locked) 4935f8415d6SAmir Goldstein { 4945f8415d6SAmir Goldstein struct ovl_inode *oi = OVL_I(d_inode(dentry)); 4955f8415d6SAmir Goldstein const struct cred *old_cred; 4965f8415d6SAmir Goldstein int err; 4975f8415d6SAmir Goldstein 4985f8415d6SAmir Goldstein if (!d_inode(dentry) || d_is_dir(dentry)) 4995f8415d6SAmir Goldstein return 0; 5005f8415d6SAmir Goldstein 5015f8415d6SAmir Goldstein /* 5025f8415d6SAmir Goldstein * With inodes index is enabled, we store the union overlay nlink 5035f8415d6SAmir Goldstein * in an xattr on the index inode. When whiting out lower hardlinks 5045f8415d6SAmir Goldstein * we need to decrement the overlay persistent nlink, but before the 5055f8415d6SAmir Goldstein * first copy up, we have no upper index inode to store the xattr. 5065f8415d6SAmir Goldstein * 5075f8415d6SAmir Goldstein * As a workaround, before whiteout/rename over of a lower hardlink, 5085f8415d6SAmir Goldstein * copy up to create the upper index. Creating the upper index will 5095f8415d6SAmir Goldstein * initialize the overlay nlink, so it could be dropped if unlink 5105f8415d6SAmir Goldstein * or rename succeeds. 5115f8415d6SAmir Goldstein * 5125f8415d6SAmir Goldstein * TODO: implement metadata only index copy up when called with 5135f8415d6SAmir Goldstein * ovl_copy_up_flags(dentry, O_PATH). 5145f8415d6SAmir Goldstein */ 5155f8415d6SAmir Goldstein if (ovl_indexdir(dentry->d_sb) && !ovl_dentry_has_upper_alias(dentry) && 5165f8415d6SAmir Goldstein d_inode(ovl_dentry_lower(dentry))->i_nlink > 1) { 5175f8415d6SAmir Goldstein err = ovl_copy_up(dentry); 5185f8415d6SAmir Goldstein if (err) 5195f8415d6SAmir Goldstein return err; 5205f8415d6SAmir Goldstein } 5215f8415d6SAmir Goldstein 5225f8415d6SAmir Goldstein err = mutex_lock_interruptible(&oi->lock); 5235f8415d6SAmir Goldstein if (err) 5245f8415d6SAmir Goldstein return err; 5255f8415d6SAmir Goldstein 5265f8415d6SAmir Goldstein if (!ovl_test_flag(OVL_INDEX, d_inode(dentry))) 5275f8415d6SAmir Goldstein goto out; 5285f8415d6SAmir Goldstein 5295f8415d6SAmir Goldstein old_cred = ovl_override_creds(dentry->d_sb); 5305f8415d6SAmir Goldstein /* 5315f8415d6SAmir Goldstein * The overlay inode nlink should be incremented/decremented IFF the 5325f8415d6SAmir Goldstein * upper operation succeeds, along with nlink change of upper inode. 5335f8415d6SAmir Goldstein * Therefore, before link/unlink/rename, we store the union nlink 5345f8415d6SAmir Goldstein * value relative to the upper inode nlink in an upper inode xattr. 5355f8415d6SAmir Goldstein */ 5365f8415d6SAmir Goldstein err = ovl_set_nlink_upper(dentry); 5375f8415d6SAmir Goldstein revert_creds(old_cred); 5385f8415d6SAmir Goldstein 5395f8415d6SAmir Goldstein out: 5405f8415d6SAmir Goldstein if (err) 5415f8415d6SAmir Goldstein mutex_unlock(&oi->lock); 5425f8415d6SAmir Goldstein else 5435f8415d6SAmir Goldstein *locked = true; 5445f8415d6SAmir Goldstein 5455f8415d6SAmir Goldstein return err; 5465f8415d6SAmir Goldstein } 5475f8415d6SAmir Goldstein 5485f8415d6SAmir Goldstein void ovl_nlink_end(struct dentry *dentry, bool locked) 5495f8415d6SAmir Goldstein { 550caf70cb2SAmir Goldstein if (locked) { 551caf70cb2SAmir Goldstein if (ovl_test_flag(OVL_INDEX, d_inode(dentry)) && 552caf70cb2SAmir Goldstein d_inode(dentry)->i_nlink == 0) { 553caf70cb2SAmir Goldstein const struct cred *old_cred; 554caf70cb2SAmir Goldstein 555caf70cb2SAmir Goldstein old_cred = ovl_override_creds(dentry->d_sb); 556caf70cb2SAmir Goldstein ovl_cleanup_index(dentry); 557caf70cb2SAmir Goldstein revert_creds(old_cred); 558caf70cb2SAmir Goldstein } 559caf70cb2SAmir Goldstein 5605f8415d6SAmir Goldstein mutex_unlock(&OVL_I(d_inode(dentry))->lock); 5615f8415d6SAmir Goldstein } 562caf70cb2SAmir Goldstein } 563