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 66f168f109SAmir Goldstein /* Index all files on copy up. For now only enabled for NFS export */ 67f168f109SAmir Goldstein bool ovl_index_all(struct super_block *sb) 68f168f109SAmir Goldstein { 69f168f109SAmir Goldstein struct ovl_fs *ofs = sb->s_fs_info; 70f168f109SAmir Goldstein 71f168f109SAmir Goldstein return ofs->config.nfs_export && ofs->config.index; 72f168f109SAmir Goldstein } 73f168f109SAmir Goldstein 74f168f109SAmir Goldstein /* Verify lower origin on lookup. For now only enabled for NFS export */ 75f168f109SAmir Goldstein bool ovl_verify_lower(struct super_block *sb) 76f168f109SAmir Goldstein { 77f168f109SAmir Goldstein struct ovl_fs *ofs = sb->s_fs_info; 78f168f109SAmir Goldstein 79f168f109SAmir Goldstein return ofs->config.nfs_export && ofs->config.index; 80f168f109SAmir Goldstein } 81f168f109SAmir Goldstein 82bbb1e54dSMiklos Szeredi struct ovl_entry *ovl_alloc_entry(unsigned int numlower) 83bbb1e54dSMiklos Szeredi { 84bbb1e54dSMiklos Szeredi size_t size = offsetof(struct ovl_entry, lowerstack[numlower]); 85bbb1e54dSMiklos Szeredi struct ovl_entry *oe = kzalloc(size, GFP_KERNEL); 86bbb1e54dSMiklos Szeredi 87bbb1e54dSMiklos Szeredi if (oe) 88bbb1e54dSMiklos Szeredi oe->numlower = numlower; 89bbb1e54dSMiklos Szeredi 90bbb1e54dSMiklos Szeredi return oe; 91bbb1e54dSMiklos Szeredi } 92bbb1e54dSMiklos Szeredi 93bbb1e54dSMiklos Szeredi bool ovl_dentry_remote(struct dentry *dentry) 94bbb1e54dSMiklos Szeredi { 95bbb1e54dSMiklos Szeredi return dentry->d_flags & 96bbb1e54dSMiklos Szeredi (DCACHE_OP_REVALIDATE | DCACHE_OP_WEAK_REVALIDATE | 97bbb1e54dSMiklos Szeredi DCACHE_OP_REAL); 98bbb1e54dSMiklos Szeredi } 99bbb1e54dSMiklos Szeredi 100bbb1e54dSMiklos Szeredi bool ovl_dentry_weird(struct dentry *dentry) 101bbb1e54dSMiklos Szeredi { 102bbb1e54dSMiklos Szeredi return dentry->d_flags & (DCACHE_NEED_AUTOMOUNT | 103bbb1e54dSMiklos Szeredi DCACHE_MANAGE_TRANSIT | 104bbb1e54dSMiklos Szeredi DCACHE_OP_HASH | 105bbb1e54dSMiklos Szeredi DCACHE_OP_COMPARE); 106bbb1e54dSMiklos Szeredi } 107bbb1e54dSMiklos Szeredi 108bbb1e54dSMiklos Szeredi enum ovl_path_type ovl_path_type(struct dentry *dentry) 109bbb1e54dSMiklos Szeredi { 110bbb1e54dSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 111bbb1e54dSMiklos Szeredi enum ovl_path_type type = 0; 112bbb1e54dSMiklos Szeredi 11309d8b586SMiklos Szeredi if (ovl_dentry_upper(dentry)) { 114bbb1e54dSMiklos Szeredi type = __OVL_PATH_UPPER; 115bbb1e54dSMiklos Szeredi 116bbb1e54dSMiklos Szeredi /* 11759548503SAmir Goldstein * Non-dir dentry can hold lower dentry of its copy up origin. 118bbb1e54dSMiklos Szeredi */ 11959548503SAmir Goldstein if (oe->numlower) { 12059548503SAmir Goldstein type |= __OVL_PATH_ORIGIN; 12159548503SAmir Goldstein if (d_is_dir(dentry)) 122bbb1e54dSMiklos Szeredi type |= __OVL_PATH_MERGE; 12359548503SAmir Goldstein } 124bbb1e54dSMiklos Szeredi } else { 125bbb1e54dSMiklos Szeredi if (oe->numlower > 1) 126bbb1e54dSMiklos Szeredi type |= __OVL_PATH_MERGE; 127bbb1e54dSMiklos Szeredi } 128bbb1e54dSMiklos Szeredi return type; 129bbb1e54dSMiklos Szeredi } 130bbb1e54dSMiklos Szeredi 131bbb1e54dSMiklos Szeredi void ovl_path_upper(struct dentry *dentry, struct path *path) 132bbb1e54dSMiklos Szeredi { 133bbb1e54dSMiklos Szeredi struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 134bbb1e54dSMiklos Szeredi 135bbb1e54dSMiklos Szeredi path->mnt = ofs->upper_mnt; 13609d8b586SMiklos Szeredi path->dentry = ovl_dentry_upper(dentry); 137bbb1e54dSMiklos Szeredi } 138bbb1e54dSMiklos Szeredi 139bbb1e54dSMiklos Szeredi void ovl_path_lower(struct dentry *dentry, struct path *path) 140bbb1e54dSMiklos Szeredi { 141bbb1e54dSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 142bbb1e54dSMiklos Szeredi 143b9343632SChandan Rajendra if (oe->numlower) { 144b9343632SChandan Rajendra path->mnt = oe->lowerstack[0].layer->mnt; 145b9343632SChandan Rajendra path->dentry = oe->lowerstack[0].dentry; 146b9343632SChandan Rajendra } else { 147b9343632SChandan Rajendra *path = (struct path) { }; 148b9343632SChandan Rajendra } 149bbb1e54dSMiklos Szeredi } 150bbb1e54dSMiklos Szeredi 151bbb1e54dSMiklos Szeredi enum ovl_path_type ovl_path_real(struct dentry *dentry, struct path *path) 152bbb1e54dSMiklos Szeredi { 153bbb1e54dSMiklos Szeredi enum ovl_path_type type = ovl_path_type(dentry); 154bbb1e54dSMiklos Szeredi 155bbb1e54dSMiklos Szeredi if (!OVL_TYPE_UPPER(type)) 156bbb1e54dSMiklos Szeredi ovl_path_lower(dentry, path); 157bbb1e54dSMiklos Szeredi else 158bbb1e54dSMiklos Szeredi ovl_path_upper(dentry, path); 159bbb1e54dSMiklos Szeredi 160bbb1e54dSMiklos Szeredi return type; 161bbb1e54dSMiklos Szeredi } 162bbb1e54dSMiklos Szeredi 163bbb1e54dSMiklos Szeredi struct dentry *ovl_dentry_upper(struct dentry *dentry) 164bbb1e54dSMiklos Szeredi { 16509d8b586SMiklos Szeredi return ovl_upperdentry_dereference(OVL_I(d_inode(dentry))); 166bbb1e54dSMiklos Szeredi } 167bbb1e54dSMiklos Szeredi 168bbb1e54dSMiklos Szeredi struct dentry *ovl_dentry_lower(struct dentry *dentry) 169bbb1e54dSMiklos Szeredi { 170bbb1e54dSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 171bbb1e54dSMiklos Szeredi 17209d8b586SMiklos Szeredi return oe->numlower ? oe->lowerstack[0].dentry : NULL; 173bbb1e54dSMiklos Szeredi } 174bbb1e54dSMiklos Szeredi 175bbb1e54dSMiklos Szeredi struct dentry *ovl_dentry_real(struct dentry *dentry) 176bbb1e54dSMiklos Szeredi { 17709d8b586SMiklos Szeredi return ovl_dentry_upper(dentry) ?: ovl_dentry_lower(dentry); 178bbb1e54dSMiklos Szeredi } 179bbb1e54dSMiklos Szeredi 1801d88f183SMiklos Szeredi struct dentry *ovl_i_dentry_upper(struct inode *inode) 1811d88f183SMiklos Szeredi { 1821d88f183SMiklos Szeredi return ovl_upperdentry_dereference(OVL_I(inode)); 1831d88f183SMiklos Szeredi } 1841d88f183SMiklos Szeredi 18509d8b586SMiklos Szeredi struct inode *ovl_inode_upper(struct inode *inode) 18625b7713aSMiklos Szeredi { 1871d88f183SMiklos Szeredi struct dentry *upperdentry = ovl_i_dentry_upper(inode); 18825b7713aSMiklos Szeredi 18909d8b586SMiklos Szeredi return upperdentry ? d_inode(upperdentry) : NULL; 19025b7713aSMiklos Szeredi } 19125b7713aSMiklos Szeredi 19209d8b586SMiklos Szeredi struct inode *ovl_inode_lower(struct inode *inode) 19309d8b586SMiklos Szeredi { 19409d8b586SMiklos Szeredi return OVL_I(inode)->lower; 19509d8b586SMiklos Szeredi } 19609d8b586SMiklos Szeredi 19709d8b586SMiklos Szeredi struct inode *ovl_inode_real(struct inode *inode) 19809d8b586SMiklos Szeredi { 19909d8b586SMiklos Szeredi return ovl_inode_upper(inode) ?: ovl_inode_lower(inode); 20009d8b586SMiklos Szeredi } 20109d8b586SMiklos Szeredi 20209d8b586SMiklos Szeredi 2034edb83bbSMiklos Szeredi struct ovl_dir_cache *ovl_dir_cache(struct inode *inode) 204bbb1e54dSMiklos Szeredi { 2054edb83bbSMiklos Szeredi return OVL_I(inode)->cache; 206bbb1e54dSMiklos Szeredi } 207bbb1e54dSMiklos Szeredi 2084edb83bbSMiklos Szeredi void ovl_set_dir_cache(struct inode *inode, struct ovl_dir_cache *cache) 209bbb1e54dSMiklos Szeredi { 2104edb83bbSMiklos Szeredi OVL_I(inode)->cache = cache; 211bbb1e54dSMiklos Szeredi } 212bbb1e54dSMiklos Szeredi 213bbb1e54dSMiklos Szeredi bool ovl_dentry_is_opaque(struct dentry *dentry) 214bbb1e54dSMiklos Szeredi { 215bbb1e54dSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 216bbb1e54dSMiklos Szeredi return oe->opaque; 217bbb1e54dSMiklos Szeredi } 218bbb1e54dSMiklos Szeredi 219bbb1e54dSMiklos Szeredi bool ovl_dentry_is_whiteout(struct dentry *dentry) 220bbb1e54dSMiklos Szeredi { 221bbb1e54dSMiklos Szeredi return !dentry->d_inode && ovl_dentry_is_opaque(dentry); 222bbb1e54dSMiklos Szeredi } 223bbb1e54dSMiklos Szeredi 2245cf5b477SMiklos Szeredi void ovl_dentry_set_opaque(struct dentry *dentry) 225bbb1e54dSMiklos Szeredi { 226bbb1e54dSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 2275cf5b477SMiklos Szeredi 2285cf5b477SMiklos Szeredi oe->opaque = true; 229bbb1e54dSMiklos Szeredi } 230bbb1e54dSMiklos Szeredi 23155acc661SMiklos Szeredi /* 232aa3ff3c1SAmir Goldstein * For hard links and decoded file handles, it's possible for ovl_dentry_upper() 233aa3ff3c1SAmir Goldstein * to return positive, while there's no actual upper alias for the inode. 234aa3ff3c1SAmir Goldstein * Copy up code needs to know about the existence of the upper alias, so it 235aa3ff3c1SAmir Goldstein * can't use ovl_dentry_upper(). 23655acc661SMiklos Szeredi */ 23755acc661SMiklos Szeredi bool ovl_dentry_has_upper_alias(struct dentry *dentry) 23855acc661SMiklos Szeredi { 23955acc661SMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 24055acc661SMiklos Szeredi 24155acc661SMiklos Szeredi return oe->has_upper; 24255acc661SMiklos Szeredi } 24355acc661SMiklos Szeredi 24455acc661SMiklos Szeredi void ovl_dentry_set_upper_alias(struct dentry *dentry) 24555acc661SMiklos Szeredi { 24655acc661SMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 24755acc661SMiklos Szeredi 24855acc661SMiklos Szeredi oe->has_upper = true; 24955acc661SMiklos Szeredi } 25055acc661SMiklos Szeredi 251a6c60655SMiklos Szeredi bool ovl_redirect_dir(struct super_block *sb) 252a6c60655SMiklos Szeredi { 253a6c60655SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 254a6c60655SMiklos Szeredi 25521a22878SAmir Goldstein return ofs->config.redirect_dir && !ofs->noxattr; 256a6c60655SMiklos Szeredi } 257a6c60655SMiklos Szeredi 258a6c60655SMiklos Szeredi const char *ovl_dentry_get_redirect(struct dentry *dentry) 259a6c60655SMiklos Szeredi { 260cf31c463SMiklos Szeredi return OVL_I(d_inode(dentry))->redirect; 261a6c60655SMiklos Szeredi } 262a6c60655SMiklos Szeredi 263a6c60655SMiklos Szeredi void ovl_dentry_set_redirect(struct dentry *dentry, const char *redirect) 264a6c60655SMiklos Szeredi { 265cf31c463SMiklos Szeredi struct ovl_inode *oi = OVL_I(d_inode(dentry)); 266a6c60655SMiklos Szeredi 267cf31c463SMiklos Szeredi kfree(oi->redirect); 268cf31c463SMiklos Szeredi oi->redirect = redirect; 269a6c60655SMiklos Szeredi } 270a6c60655SMiklos Szeredi 27109d8b586SMiklos Szeredi void ovl_inode_init(struct inode *inode, struct dentry *upperdentry, 27209d8b586SMiklos Szeredi struct dentry *lowerdentry) 273bbb1e54dSMiklos Szeredi { 27409d8b586SMiklos Szeredi if (upperdentry) 27509d8b586SMiklos Szeredi OVL_I(inode)->__upperdentry = upperdentry; 27609d8b586SMiklos Szeredi if (lowerdentry) 27731747edaSAmir Goldstein OVL_I(inode)->lower = igrab(d_inode(lowerdentry)); 278bbb1e54dSMiklos Szeredi 27909d8b586SMiklos Szeredi ovl_copyattr(d_inode(upperdentry ?: lowerdentry), inode); 280bbb1e54dSMiklos Szeredi } 281bbb1e54dSMiklos Szeredi 28209d8b586SMiklos Szeredi void ovl_inode_update(struct inode *inode, struct dentry *upperdentry) 283bbb1e54dSMiklos Szeredi { 28409d8b586SMiklos Szeredi struct inode *upperinode = d_inode(upperdentry); 285e6d2ebddSMiklos Szeredi 28609d8b586SMiklos Szeredi WARN_ON(OVL_I(inode)->__upperdentry); 28709d8b586SMiklos Szeredi 28825b7713aSMiklos Szeredi /* 28909d8b586SMiklos Szeredi * Make sure upperdentry is consistent before making it visible 29025b7713aSMiklos Szeredi */ 29125b7713aSMiklos Szeredi smp_wmb(); 29209d8b586SMiklos Szeredi OVL_I(inode)->__upperdentry = upperdentry; 29331747edaSAmir Goldstein if (inode_unhashed(inode)) { 29425b7713aSMiklos Szeredi inode->i_private = upperinode; 295bbb1e54dSMiklos Szeredi __insert_inode_hash(inode, (unsigned long) upperinode); 296bbb1e54dSMiklos Szeredi } 29725b7713aSMiklos Szeredi } 298bbb1e54dSMiklos Szeredi 2994edb83bbSMiklos Szeredi void ovl_dentry_version_inc(struct dentry *dentry, bool impurity) 300bbb1e54dSMiklos Szeredi { 30104a01ac7SMiklos Szeredi struct inode *inode = d_inode(dentry); 302bbb1e54dSMiklos Szeredi 30304a01ac7SMiklos Szeredi WARN_ON(!inode_is_locked(inode)); 3044edb83bbSMiklos Szeredi /* 3054edb83bbSMiklos Szeredi * Version is used by readdir code to keep cache consistent. For merge 3064edb83bbSMiklos Szeredi * dirs all changes need to be noted. For non-merge dirs, cache only 3074edb83bbSMiklos Szeredi * contains impure (ones which have been copied up and have origins) 3084edb83bbSMiklos Szeredi * entries, so only need to note changes to impure entries. 3094edb83bbSMiklos Szeredi */ 3104edb83bbSMiklos Szeredi if (OVL_TYPE_MERGE(ovl_path_type(dentry)) || impurity) 31104a01ac7SMiklos Szeredi OVL_I(inode)->version++; 312bbb1e54dSMiklos Szeredi } 313bbb1e54dSMiklos Szeredi 314bbb1e54dSMiklos Szeredi u64 ovl_dentry_version_get(struct dentry *dentry) 315bbb1e54dSMiklos Szeredi { 31604a01ac7SMiklos Szeredi struct inode *inode = d_inode(dentry); 317bbb1e54dSMiklos Szeredi 31804a01ac7SMiklos Szeredi WARN_ON(!inode_is_locked(inode)); 31904a01ac7SMiklos Szeredi return OVL_I(inode)->version; 320bbb1e54dSMiklos Szeredi } 321bbb1e54dSMiklos Szeredi 322bbb1e54dSMiklos Szeredi bool ovl_is_whiteout(struct dentry *dentry) 323bbb1e54dSMiklos Szeredi { 324bbb1e54dSMiklos Szeredi struct inode *inode = dentry->d_inode; 325bbb1e54dSMiklos Szeredi 326bbb1e54dSMiklos Szeredi return inode && IS_WHITEOUT(inode); 327bbb1e54dSMiklos Szeredi } 328bbb1e54dSMiklos Szeredi 329bbb1e54dSMiklos Szeredi struct file *ovl_path_open(struct path *path, int flags) 330bbb1e54dSMiklos Szeredi { 331bbb1e54dSMiklos Szeredi return dentry_open(path, flags | O_NOATIME, current_cred()); 332bbb1e54dSMiklos Szeredi } 33339d3d60aSAmir Goldstein 33439d3d60aSAmir Goldstein int ovl_copy_up_start(struct dentry *dentry) 33539d3d60aSAmir Goldstein { 336a015dafcSAmir Goldstein struct ovl_inode *oi = OVL_I(d_inode(dentry)); 33739d3d60aSAmir Goldstein int err; 33839d3d60aSAmir Goldstein 339a015dafcSAmir Goldstein err = mutex_lock_interruptible(&oi->lock); 34059be0971SAmir Goldstein if (!err && ovl_dentry_has_upper_alias(dentry)) { 34139d3d60aSAmir Goldstein err = 1; /* Already copied up */ 342a015dafcSAmir Goldstein mutex_unlock(&oi->lock); 34339d3d60aSAmir Goldstein } 34439d3d60aSAmir Goldstein 34539d3d60aSAmir Goldstein return err; 34639d3d60aSAmir Goldstein } 34739d3d60aSAmir Goldstein 34839d3d60aSAmir Goldstein void ovl_copy_up_end(struct dentry *dentry) 34939d3d60aSAmir Goldstein { 350a015dafcSAmir Goldstein mutex_unlock(&OVL_I(d_inode(dentry))->lock); 35139d3d60aSAmir Goldstein } 35282b749b2SAmir Goldstein 353b79e05aaSAmir Goldstein bool ovl_check_origin_xattr(struct dentry *dentry) 354b79e05aaSAmir Goldstein { 355b79e05aaSAmir Goldstein int res; 356b79e05aaSAmir Goldstein 357b79e05aaSAmir Goldstein res = vfs_getxattr(dentry, OVL_XATTR_ORIGIN, NULL, 0); 358b79e05aaSAmir Goldstein 359b79e05aaSAmir Goldstein /* Zero size value means "copied up but origin unknown" */ 360b79e05aaSAmir Goldstein if (res >= 0) 361b79e05aaSAmir Goldstein return true; 362b79e05aaSAmir Goldstein 363b79e05aaSAmir Goldstein return false; 364b79e05aaSAmir Goldstein } 365b79e05aaSAmir Goldstein 366f3a15685SAmir Goldstein bool ovl_check_dir_xattr(struct dentry *dentry, const char *name) 367f3a15685SAmir Goldstein { 368f3a15685SAmir Goldstein int res; 369f3a15685SAmir Goldstein char val; 370f3a15685SAmir Goldstein 371f3a15685SAmir Goldstein if (!d_is_dir(dentry)) 372f3a15685SAmir Goldstein return false; 373f3a15685SAmir Goldstein 374f3a15685SAmir Goldstein res = vfs_getxattr(dentry, name, &val, 1); 375f3a15685SAmir Goldstein if (res == 1 && val == 'y') 376f3a15685SAmir Goldstein return true; 377f3a15685SAmir Goldstein 378f3a15685SAmir Goldstein return false; 379f3a15685SAmir Goldstein } 380f3a15685SAmir Goldstein 38182b749b2SAmir Goldstein int ovl_check_setxattr(struct dentry *dentry, struct dentry *upperdentry, 38282b749b2SAmir Goldstein const char *name, const void *value, size_t size, 38382b749b2SAmir Goldstein int xerr) 38482b749b2SAmir Goldstein { 38582b749b2SAmir Goldstein int err; 38682b749b2SAmir Goldstein struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 38782b749b2SAmir Goldstein 38882b749b2SAmir Goldstein if (ofs->noxattr) 38982b749b2SAmir Goldstein return xerr; 39082b749b2SAmir Goldstein 39182b749b2SAmir Goldstein err = ovl_do_setxattr(upperdentry, name, value, size, 0); 39282b749b2SAmir Goldstein 39382b749b2SAmir Goldstein if (err == -EOPNOTSUPP) { 39482b749b2SAmir Goldstein pr_warn("overlayfs: cannot set %s xattr on upper\n", name); 39582b749b2SAmir Goldstein ofs->noxattr = true; 39682b749b2SAmir Goldstein return xerr; 39782b749b2SAmir Goldstein } 39882b749b2SAmir Goldstein 39982b749b2SAmir Goldstein return err; 40082b749b2SAmir Goldstein } 401f3a15685SAmir Goldstein 402f3a15685SAmir Goldstein int ovl_set_impure(struct dentry *dentry, struct dentry *upperdentry) 403f3a15685SAmir Goldstein { 404f3a15685SAmir Goldstein int err; 405f3a15685SAmir Goldstein 40613c72075SMiklos Szeredi if (ovl_test_flag(OVL_IMPURE, d_inode(dentry))) 407f3a15685SAmir Goldstein return 0; 408f3a15685SAmir Goldstein 409f3a15685SAmir Goldstein /* 410f3a15685SAmir Goldstein * Do not fail when upper doesn't support xattrs. 411f3a15685SAmir Goldstein * Upper inodes won't have origin nor redirect xattr anyway. 412f3a15685SAmir Goldstein */ 413f3a15685SAmir Goldstein err = ovl_check_setxattr(dentry, upperdentry, OVL_XATTR_IMPURE, 414f3a15685SAmir Goldstein "y", 1, 0); 415f3a15685SAmir Goldstein if (!err) 41613c72075SMiklos Szeredi ovl_set_flag(OVL_IMPURE, d_inode(dentry)); 417f3a15685SAmir Goldstein 418f3a15685SAmir Goldstein return err; 419f3a15685SAmir Goldstein } 42013c72075SMiklos Szeredi 42113c72075SMiklos Szeredi void ovl_set_flag(unsigned long flag, struct inode *inode) 42213c72075SMiklos Szeredi { 42313c72075SMiklos Szeredi set_bit(flag, &OVL_I(inode)->flags); 42413c72075SMiklos Szeredi } 42513c72075SMiklos Szeredi 4264edb83bbSMiklos Szeredi void ovl_clear_flag(unsigned long flag, struct inode *inode) 4274edb83bbSMiklos Szeredi { 4284edb83bbSMiklos Szeredi clear_bit(flag, &OVL_I(inode)->flags); 4294edb83bbSMiklos Szeredi } 4304edb83bbSMiklos Szeredi 43113c72075SMiklos Szeredi bool ovl_test_flag(unsigned long flag, struct inode *inode) 43213c72075SMiklos Szeredi { 43313c72075SMiklos Szeredi return test_bit(flag, &OVL_I(inode)->flags); 43413c72075SMiklos Szeredi } 435ad0af710SAmir Goldstein 436ad0af710SAmir Goldstein /** 437ad0af710SAmir Goldstein * Caller must hold a reference to inode to prevent it from being freed while 438ad0af710SAmir Goldstein * it is marked inuse. 439ad0af710SAmir Goldstein */ 440ad0af710SAmir Goldstein bool ovl_inuse_trylock(struct dentry *dentry) 441ad0af710SAmir Goldstein { 442ad0af710SAmir Goldstein struct inode *inode = d_inode(dentry); 443ad0af710SAmir Goldstein bool locked = false; 444ad0af710SAmir Goldstein 445ad0af710SAmir Goldstein spin_lock(&inode->i_lock); 446ad0af710SAmir Goldstein if (!(inode->i_state & I_OVL_INUSE)) { 447ad0af710SAmir Goldstein inode->i_state |= I_OVL_INUSE; 448ad0af710SAmir Goldstein locked = true; 449ad0af710SAmir Goldstein } 450ad0af710SAmir Goldstein spin_unlock(&inode->i_lock); 451ad0af710SAmir Goldstein 452ad0af710SAmir Goldstein return locked; 453ad0af710SAmir Goldstein } 454ad0af710SAmir Goldstein 455ad0af710SAmir Goldstein void ovl_inuse_unlock(struct dentry *dentry) 456ad0af710SAmir Goldstein { 457ad0af710SAmir Goldstein if (dentry) { 458ad0af710SAmir Goldstein struct inode *inode = d_inode(dentry); 459ad0af710SAmir Goldstein 460ad0af710SAmir Goldstein spin_lock(&inode->i_lock); 461ad0af710SAmir Goldstein WARN_ON(!(inode->i_state & I_OVL_INUSE)); 462ad0af710SAmir Goldstein inode->i_state &= ~I_OVL_INUSE; 463ad0af710SAmir Goldstein spin_unlock(&inode->i_lock); 464ad0af710SAmir Goldstein } 465ad0af710SAmir Goldstein } 4665f8415d6SAmir Goldstein 46724b33ee1SAmir Goldstein /* 46824b33ee1SAmir Goldstein * Does this overlay dentry need to be indexed on copy up? 46924b33ee1SAmir Goldstein */ 47024b33ee1SAmir Goldstein bool ovl_need_index(struct dentry *dentry) 47124b33ee1SAmir Goldstein { 47224b33ee1SAmir Goldstein struct dentry *lower = ovl_dentry_lower(dentry); 47324b33ee1SAmir Goldstein 47424b33ee1SAmir Goldstein if (!lower || !ovl_indexdir(dentry->d_sb)) 47524b33ee1SAmir Goldstein return false; 47624b33ee1SAmir Goldstein 477fbd2d207SAmir Goldstein /* Index all files for NFS export and consistency verification */ 478016b720fSAmir Goldstein if (ovl_index_all(dentry->d_sb)) 479fbd2d207SAmir Goldstein return true; 480fbd2d207SAmir Goldstein 48124b33ee1SAmir Goldstein /* Index only lower hardlinks on copy up */ 48224b33ee1SAmir Goldstein if (!d_is_dir(lower) && d_inode(lower)->i_nlink > 1) 48324b33ee1SAmir Goldstein return true; 48424b33ee1SAmir Goldstein 48524b33ee1SAmir Goldstein return false; 48624b33ee1SAmir Goldstein } 48724b33ee1SAmir Goldstein 4889f4ec904SAmir Goldstein /* Caller must hold OVL_I(inode)->lock */ 489caf70cb2SAmir Goldstein static void ovl_cleanup_index(struct dentry *dentry) 490caf70cb2SAmir Goldstein { 491e7dd0e71SAmir Goldstein struct dentry *indexdir = ovl_indexdir(dentry->d_sb); 492e7dd0e71SAmir Goldstein struct inode *dir = indexdir->d_inode; 493caf70cb2SAmir Goldstein struct dentry *lowerdentry = ovl_dentry_lower(dentry); 494caf70cb2SAmir Goldstein struct dentry *upperdentry = ovl_dentry_upper(dentry); 495caf70cb2SAmir Goldstein struct dentry *index = NULL; 496caf70cb2SAmir Goldstein struct inode *inode; 497caf70cb2SAmir Goldstein struct qstr name; 498caf70cb2SAmir Goldstein int err; 499caf70cb2SAmir Goldstein 500caf70cb2SAmir Goldstein err = ovl_get_index_name(lowerdentry, &name); 501caf70cb2SAmir Goldstein if (err) 502caf70cb2SAmir Goldstein goto fail; 503caf70cb2SAmir Goldstein 504caf70cb2SAmir Goldstein inode = d_inode(upperdentry); 50589a17556SAmir Goldstein if (!S_ISDIR(inode->i_mode) && inode->i_nlink != 1) { 506caf70cb2SAmir Goldstein pr_warn_ratelimited("overlayfs: cleanup linked index (%pd2, ino=%lu, nlink=%u)\n", 507caf70cb2SAmir Goldstein upperdentry, inode->i_ino, inode->i_nlink); 508caf70cb2SAmir Goldstein /* 509caf70cb2SAmir Goldstein * We either have a bug with persistent union nlink or a lower 510caf70cb2SAmir Goldstein * hardlink was added while overlay is mounted. Adding a lower 511caf70cb2SAmir Goldstein * hardlink and then unlinking all overlay hardlinks would drop 512caf70cb2SAmir Goldstein * overlay nlink to zero before all upper inodes are unlinked. 513caf70cb2SAmir Goldstein * As a safety measure, when that situation is detected, set 514caf70cb2SAmir Goldstein * the overlay nlink to the index inode nlink minus one for the 515caf70cb2SAmir Goldstein * index entry itself. 516caf70cb2SAmir Goldstein */ 517caf70cb2SAmir Goldstein set_nlink(d_inode(dentry), inode->i_nlink - 1); 518caf70cb2SAmir Goldstein ovl_set_nlink_upper(dentry); 519caf70cb2SAmir Goldstein goto out; 520caf70cb2SAmir Goldstein } 521caf70cb2SAmir Goldstein 522caf70cb2SAmir Goldstein inode_lock_nested(dir, I_MUTEX_PARENT); 523e7dd0e71SAmir Goldstein index = lookup_one_len(name.name, indexdir, name.len); 524caf70cb2SAmir Goldstein err = PTR_ERR(index); 525e7dd0e71SAmir Goldstein if (IS_ERR(index)) { 5269f4ec904SAmir Goldstein index = NULL; 527e7dd0e71SAmir Goldstein } else if (ovl_index_all(dentry->d_sb)) { 528e7dd0e71SAmir Goldstein /* Whiteout orphan index to block future open by handle */ 529e7dd0e71SAmir Goldstein err = ovl_cleanup_and_whiteout(indexdir, dir, index); 530e7dd0e71SAmir Goldstein } else { 531e7dd0e71SAmir Goldstein /* Cleanup orphan index entries */ 532e7dd0e71SAmir Goldstein err = ovl_cleanup(dir, index); 533e7dd0e71SAmir Goldstein } 5349f4ec904SAmir Goldstein 535caf70cb2SAmir Goldstein inode_unlock(dir); 536caf70cb2SAmir Goldstein if (err) 537caf70cb2SAmir Goldstein goto fail; 538caf70cb2SAmir Goldstein 539caf70cb2SAmir Goldstein out: 540caf70cb2SAmir Goldstein dput(index); 541caf70cb2SAmir Goldstein return; 542caf70cb2SAmir Goldstein 543caf70cb2SAmir Goldstein fail: 544caf70cb2SAmir Goldstein pr_err("overlayfs: cleanup index of '%pd2' failed (%i)\n", dentry, err); 545caf70cb2SAmir Goldstein goto out; 546caf70cb2SAmir Goldstein } 547caf70cb2SAmir Goldstein 5485f8415d6SAmir Goldstein /* 5495f8415d6SAmir Goldstein * Operations that change overlay inode and upper inode nlink need to be 5505f8415d6SAmir Goldstein * synchronized with copy up for persistent nlink accounting. 5515f8415d6SAmir Goldstein */ 5525f8415d6SAmir Goldstein int ovl_nlink_start(struct dentry *dentry, bool *locked) 5535f8415d6SAmir Goldstein { 5545f8415d6SAmir Goldstein struct ovl_inode *oi = OVL_I(d_inode(dentry)); 5555f8415d6SAmir Goldstein const struct cred *old_cred; 5565f8415d6SAmir Goldstein int err; 5575f8415d6SAmir Goldstein 55889a17556SAmir Goldstein if (!d_inode(dentry)) 5595f8415d6SAmir Goldstein return 0; 5605f8415d6SAmir Goldstein 5615f8415d6SAmir Goldstein /* 5625f8415d6SAmir Goldstein * With inodes index is enabled, we store the union overlay nlink 56324b33ee1SAmir Goldstein * in an xattr on the index inode. When whiting out an indexed lower, 5645f8415d6SAmir Goldstein * we need to decrement the overlay persistent nlink, but before the 5655f8415d6SAmir Goldstein * first copy up, we have no upper index inode to store the xattr. 5665f8415d6SAmir Goldstein * 56724b33ee1SAmir Goldstein * As a workaround, before whiteout/rename over an indexed lower, 5685f8415d6SAmir Goldstein * copy up to create the upper index. Creating the upper index will 5695f8415d6SAmir Goldstein * initialize the overlay nlink, so it could be dropped if unlink 5705f8415d6SAmir Goldstein * or rename succeeds. 5715f8415d6SAmir Goldstein * 5725f8415d6SAmir Goldstein * TODO: implement metadata only index copy up when called with 5735f8415d6SAmir Goldstein * ovl_copy_up_flags(dentry, O_PATH). 5745f8415d6SAmir Goldstein */ 57524b33ee1SAmir Goldstein if (ovl_need_index(dentry) && !ovl_dentry_has_upper_alias(dentry)) { 5765f8415d6SAmir Goldstein err = ovl_copy_up(dentry); 5775f8415d6SAmir Goldstein if (err) 5785f8415d6SAmir Goldstein return err; 5795f8415d6SAmir Goldstein } 5805f8415d6SAmir Goldstein 5815f8415d6SAmir Goldstein err = mutex_lock_interruptible(&oi->lock); 5825f8415d6SAmir Goldstein if (err) 5835f8415d6SAmir Goldstein return err; 5845f8415d6SAmir Goldstein 58589a17556SAmir Goldstein if (d_is_dir(dentry) || !ovl_test_flag(OVL_INDEX, d_inode(dentry))) 5865f8415d6SAmir Goldstein goto out; 5875f8415d6SAmir Goldstein 5885f8415d6SAmir Goldstein old_cred = ovl_override_creds(dentry->d_sb); 5895f8415d6SAmir Goldstein /* 5905f8415d6SAmir Goldstein * The overlay inode nlink should be incremented/decremented IFF the 5915f8415d6SAmir Goldstein * upper operation succeeds, along with nlink change of upper inode. 5925f8415d6SAmir Goldstein * Therefore, before link/unlink/rename, we store the union nlink 5935f8415d6SAmir Goldstein * value relative to the upper inode nlink in an upper inode xattr. 5945f8415d6SAmir Goldstein */ 5955f8415d6SAmir Goldstein err = ovl_set_nlink_upper(dentry); 5965f8415d6SAmir Goldstein revert_creds(old_cred); 5975f8415d6SAmir Goldstein 5985f8415d6SAmir Goldstein out: 5995f8415d6SAmir Goldstein if (err) 6005f8415d6SAmir Goldstein mutex_unlock(&oi->lock); 6015f8415d6SAmir Goldstein else 6025f8415d6SAmir Goldstein *locked = true; 6035f8415d6SAmir Goldstein 6045f8415d6SAmir Goldstein return err; 6055f8415d6SAmir Goldstein } 6065f8415d6SAmir Goldstein 6075f8415d6SAmir Goldstein void ovl_nlink_end(struct dentry *dentry, bool locked) 6085f8415d6SAmir Goldstein { 609caf70cb2SAmir Goldstein if (locked) { 610caf70cb2SAmir Goldstein if (ovl_test_flag(OVL_INDEX, d_inode(dentry)) && 611caf70cb2SAmir Goldstein d_inode(dentry)->i_nlink == 0) { 612caf70cb2SAmir Goldstein const struct cred *old_cred; 613caf70cb2SAmir Goldstein 614caf70cb2SAmir Goldstein old_cred = ovl_override_creds(dentry->d_sb); 615caf70cb2SAmir Goldstein ovl_cleanup_index(dentry); 616caf70cb2SAmir Goldstein revert_creds(old_cred); 617caf70cb2SAmir Goldstein } 618caf70cb2SAmir Goldstein 6195f8415d6SAmir Goldstein mutex_unlock(&OVL_I(d_inode(dentry))->lock); 6205f8415d6SAmir Goldstein } 621caf70cb2SAmir Goldstein } 6225820dc08SAmir Goldstein 6235820dc08SAmir Goldstein int ovl_lock_rename_workdir(struct dentry *workdir, struct dentry *upperdir) 6245820dc08SAmir Goldstein { 6255820dc08SAmir Goldstein /* Workdir should not be the same as upperdir */ 6265820dc08SAmir Goldstein if (workdir == upperdir) 6275820dc08SAmir Goldstein goto err; 6285820dc08SAmir Goldstein 6295820dc08SAmir Goldstein /* Workdir should not be subdir of upperdir and vice versa */ 6305820dc08SAmir Goldstein if (lock_rename(workdir, upperdir) != NULL) 6315820dc08SAmir Goldstein goto err_unlock; 6325820dc08SAmir Goldstein 6335820dc08SAmir Goldstein return 0; 6345820dc08SAmir Goldstein 6355820dc08SAmir Goldstein err_unlock: 6365820dc08SAmir Goldstein unlock_rename(workdir, upperdir); 6375820dc08SAmir Goldstein err: 6385820dc08SAmir Goldstein pr_err("overlayfs: failed to lock workdir+upperdir\n"); 6395820dc08SAmir Goldstein return -EIO; 6405820dc08SAmir Goldstein } 641