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 505148626bSAmir Goldstein if (!ofs->numlowerfs) 515148626bSAmir Goldstein return ofs->upper_mnt->mnt_sb; 525148626bSAmir Goldstein else if (ofs->numlowerfs == 1 && !ofs->upper_mnt) 535148626bSAmir Goldstein return ofs->lower_fs[0].sb; 545148626bSAmir Goldstein else 555148626bSAmir Goldstein return NULL; 567bcd74b9SAmir Goldstein } 577bcd74b9SAmir Goldstein 58e487d889SAmir Goldstein /* 59e487d889SAmir Goldstein * Check if underlying fs supports file handles and try to determine encoding 60e487d889SAmir Goldstein * type, in order to deduce maximum inode number used by fs. 61e487d889SAmir Goldstein * 62e487d889SAmir Goldstein * Return 0 if file handles are not supported. 63e487d889SAmir Goldstein * Return 1 (FILEID_INO32_GEN) if fs uses the default 32bit inode encoding. 64e487d889SAmir Goldstein * Return -1 if fs uses a non default encoding with unknown inode size. 65e487d889SAmir Goldstein */ 66e487d889SAmir Goldstein int ovl_can_decode_fh(struct super_block *sb) 6702bcd157SAmir Goldstein { 68e487d889SAmir Goldstein if (!sb->s_export_op || !sb->s_export_op->fh_to_dentry || 69e487d889SAmir Goldstein uuid_is_null(&sb->s_uuid)) 70e487d889SAmir Goldstein return 0; 71e487d889SAmir Goldstein 72e487d889SAmir Goldstein return sb->s_export_op->encode_fh ? -1 : FILEID_INO32_GEN; 7302bcd157SAmir Goldstein } 7402bcd157SAmir Goldstein 7502bcd157SAmir Goldstein struct dentry *ovl_indexdir(struct super_block *sb) 7602bcd157SAmir Goldstein { 7702bcd157SAmir Goldstein struct ovl_fs *ofs = sb->s_fs_info; 7802bcd157SAmir Goldstein 7902bcd157SAmir Goldstein return ofs->indexdir; 8002bcd157SAmir Goldstein } 8102bcd157SAmir Goldstein 82f168f109SAmir Goldstein /* Index all files on copy up. For now only enabled for NFS export */ 83f168f109SAmir Goldstein bool ovl_index_all(struct super_block *sb) 84f168f109SAmir Goldstein { 85f168f109SAmir Goldstein struct ovl_fs *ofs = sb->s_fs_info; 86f168f109SAmir Goldstein 87f168f109SAmir Goldstein return ofs->config.nfs_export && ofs->config.index; 88f168f109SAmir Goldstein } 89f168f109SAmir Goldstein 90f168f109SAmir Goldstein /* Verify lower origin on lookup. For now only enabled for NFS export */ 91f168f109SAmir Goldstein bool ovl_verify_lower(struct super_block *sb) 92f168f109SAmir Goldstein { 93f168f109SAmir Goldstein struct ovl_fs *ofs = sb->s_fs_info; 94f168f109SAmir Goldstein 95f168f109SAmir Goldstein return ofs->config.nfs_export && ofs->config.index; 96f168f109SAmir Goldstein } 97f168f109SAmir Goldstein 98bbb1e54dSMiklos Szeredi struct ovl_entry *ovl_alloc_entry(unsigned int numlower) 99bbb1e54dSMiklos Szeredi { 100bbb1e54dSMiklos Szeredi size_t size = offsetof(struct ovl_entry, lowerstack[numlower]); 101bbb1e54dSMiklos Szeredi struct ovl_entry *oe = kzalloc(size, GFP_KERNEL); 102bbb1e54dSMiklos Szeredi 103bbb1e54dSMiklos Szeredi if (oe) 104bbb1e54dSMiklos Szeredi oe->numlower = numlower; 105bbb1e54dSMiklos Szeredi 106bbb1e54dSMiklos Szeredi return oe; 107bbb1e54dSMiklos Szeredi } 108bbb1e54dSMiklos Szeredi 109bbb1e54dSMiklos Szeredi bool ovl_dentry_remote(struct dentry *dentry) 110bbb1e54dSMiklos Szeredi { 111bbb1e54dSMiklos Szeredi return dentry->d_flags & 112bbb1e54dSMiklos Szeredi (DCACHE_OP_REVALIDATE | DCACHE_OP_WEAK_REVALIDATE | 113bbb1e54dSMiklos Szeredi DCACHE_OP_REAL); 114bbb1e54dSMiklos Szeredi } 115bbb1e54dSMiklos Szeredi 116bbb1e54dSMiklos Szeredi bool ovl_dentry_weird(struct dentry *dentry) 117bbb1e54dSMiklos Szeredi { 118bbb1e54dSMiklos Szeredi return dentry->d_flags & (DCACHE_NEED_AUTOMOUNT | 119bbb1e54dSMiklos Szeredi DCACHE_MANAGE_TRANSIT | 120bbb1e54dSMiklos Szeredi DCACHE_OP_HASH | 121bbb1e54dSMiklos Szeredi DCACHE_OP_COMPARE); 122bbb1e54dSMiklos Szeredi } 123bbb1e54dSMiklos Szeredi 124bbb1e54dSMiklos Szeredi enum ovl_path_type ovl_path_type(struct dentry *dentry) 125bbb1e54dSMiklos Szeredi { 126bbb1e54dSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 127bbb1e54dSMiklos Szeredi enum ovl_path_type type = 0; 128bbb1e54dSMiklos Szeredi 12909d8b586SMiklos Szeredi if (ovl_dentry_upper(dentry)) { 130bbb1e54dSMiklos Szeredi type = __OVL_PATH_UPPER; 131bbb1e54dSMiklos Szeredi 132bbb1e54dSMiklos Szeredi /* 13359548503SAmir Goldstein * Non-dir dentry can hold lower dentry of its copy up origin. 134bbb1e54dSMiklos Szeredi */ 13559548503SAmir Goldstein if (oe->numlower) { 13659548503SAmir Goldstein type |= __OVL_PATH_ORIGIN; 13759548503SAmir Goldstein if (d_is_dir(dentry)) 138bbb1e54dSMiklos Szeredi type |= __OVL_PATH_MERGE; 13959548503SAmir Goldstein } 140bbb1e54dSMiklos Szeredi } else { 141bbb1e54dSMiklos Szeredi if (oe->numlower > 1) 142bbb1e54dSMiklos Szeredi type |= __OVL_PATH_MERGE; 143bbb1e54dSMiklos Szeredi } 144bbb1e54dSMiklos Szeredi return type; 145bbb1e54dSMiklos Szeredi } 146bbb1e54dSMiklos Szeredi 147bbb1e54dSMiklos Szeredi void ovl_path_upper(struct dentry *dentry, struct path *path) 148bbb1e54dSMiklos Szeredi { 149bbb1e54dSMiklos Szeredi struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 150bbb1e54dSMiklos Szeredi 151bbb1e54dSMiklos Szeredi path->mnt = ofs->upper_mnt; 15209d8b586SMiklos Szeredi path->dentry = ovl_dentry_upper(dentry); 153bbb1e54dSMiklos Szeredi } 154bbb1e54dSMiklos Szeredi 155bbb1e54dSMiklos Szeredi void ovl_path_lower(struct dentry *dentry, struct path *path) 156bbb1e54dSMiklos Szeredi { 157bbb1e54dSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 158bbb1e54dSMiklos Szeredi 159b9343632SChandan Rajendra if (oe->numlower) { 160b9343632SChandan Rajendra path->mnt = oe->lowerstack[0].layer->mnt; 161b9343632SChandan Rajendra path->dentry = oe->lowerstack[0].dentry; 162b9343632SChandan Rajendra } else { 163b9343632SChandan Rajendra *path = (struct path) { }; 164b9343632SChandan Rajendra } 165bbb1e54dSMiklos Szeredi } 166bbb1e54dSMiklos Szeredi 167bbb1e54dSMiklos Szeredi enum ovl_path_type ovl_path_real(struct dentry *dentry, struct path *path) 168bbb1e54dSMiklos Szeredi { 169bbb1e54dSMiklos Szeredi enum ovl_path_type type = ovl_path_type(dentry); 170bbb1e54dSMiklos Szeredi 171bbb1e54dSMiklos Szeredi if (!OVL_TYPE_UPPER(type)) 172bbb1e54dSMiklos Szeredi ovl_path_lower(dentry, path); 173bbb1e54dSMiklos Szeredi else 174bbb1e54dSMiklos Szeredi ovl_path_upper(dentry, path); 175bbb1e54dSMiklos Szeredi 176bbb1e54dSMiklos Szeredi return type; 177bbb1e54dSMiklos Szeredi } 178bbb1e54dSMiklos Szeredi 179bbb1e54dSMiklos Szeredi struct dentry *ovl_dentry_upper(struct dentry *dentry) 180bbb1e54dSMiklos Szeredi { 18109d8b586SMiklos Szeredi return ovl_upperdentry_dereference(OVL_I(d_inode(dentry))); 182bbb1e54dSMiklos Szeredi } 183bbb1e54dSMiklos Szeredi 184bbb1e54dSMiklos Szeredi struct dentry *ovl_dentry_lower(struct dentry *dentry) 185bbb1e54dSMiklos Szeredi { 186bbb1e54dSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 187bbb1e54dSMiklos Szeredi 18809d8b586SMiklos Szeredi return oe->numlower ? oe->lowerstack[0].dentry : NULL; 189bbb1e54dSMiklos Szeredi } 190bbb1e54dSMiklos Szeredi 191da309e8cSAmir Goldstein struct ovl_layer *ovl_layer_lower(struct dentry *dentry) 192da309e8cSAmir Goldstein { 193da309e8cSAmir Goldstein struct ovl_entry *oe = dentry->d_fsdata; 194da309e8cSAmir Goldstein 195da309e8cSAmir Goldstein return oe->numlower ? oe->lowerstack[0].layer : NULL; 196da309e8cSAmir Goldstein } 197da309e8cSAmir Goldstein 198bbb1e54dSMiklos Szeredi struct dentry *ovl_dentry_real(struct dentry *dentry) 199bbb1e54dSMiklos Szeredi { 20009d8b586SMiklos Szeredi return ovl_dentry_upper(dentry) ?: ovl_dentry_lower(dentry); 201bbb1e54dSMiklos Szeredi } 202bbb1e54dSMiklos Szeredi 2031d88f183SMiklos Szeredi struct dentry *ovl_i_dentry_upper(struct inode *inode) 2041d88f183SMiklos Szeredi { 2051d88f183SMiklos Szeredi return ovl_upperdentry_dereference(OVL_I(inode)); 2061d88f183SMiklos Szeredi } 2071d88f183SMiklos Szeredi 20809d8b586SMiklos Szeredi struct inode *ovl_inode_upper(struct inode *inode) 20925b7713aSMiklos Szeredi { 2101d88f183SMiklos Szeredi struct dentry *upperdentry = ovl_i_dentry_upper(inode); 21125b7713aSMiklos Szeredi 21209d8b586SMiklos Szeredi return upperdentry ? d_inode(upperdentry) : NULL; 21325b7713aSMiklos Szeredi } 21425b7713aSMiklos Szeredi 21509d8b586SMiklos Szeredi struct inode *ovl_inode_lower(struct inode *inode) 21609d8b586SMiklos Szeredi { 21709d8b586SMiklos Szeredi return OVL_I(inode)->lower; 21809d8b586SMiklos Szeredi } 21909d8b586SMiklos Szeredi 22009d8b586SMiklos Szeredi struct inode *ovl_inode_real(struct inode *inode) 22109d8b586SMiklos Szeredi { 22209d8b586SMiklos Szeredi return ovl_inode_upper(inode) ?: ovl_inode_lower(inode); 22309d8b586SMiklos Szeredi } 22409d8b586SMiklos Szeredi 22509d8b586SMiklos Szeredi 2264edb83bbSMiklos Szeredi struct ovl_dir_cache *ovl_dir_cache(struct inode *inode) 227bbb1e54dSMiklos Szeredi { 2284edb83bbSMiklos Szeredi return OVL_I(inode)->cache; 229bbb1e54dSMiklos Szeredi } 230bbb1e54dSMiklos Szeredi 2314edb83bbSMiklos Szeredi void ovl_set_dir_cache(struct inode *inode, struct ovl_dir_cache *cache) 232bbb1e54dSMiklos Szeredi { 2334edb83bbSMiklos Szeredi OVL_I(inode)->cache = cache; 234bbb1e54dSMiklos Szeredi } 235bbb1e54dSMiklos Szeredi 236c62520a8SAmir Goldstein void ovl_dentry_set_flag(unsigned long flag, struct dentry *dentry) 237c62520a8SAmir Goldstein { 238c62520a8SAmir Goldstein set_bit(flag, &OVL_E(dentry)->flags); 239c62520a8SAmir Goldstein } 240c62520a8SAmir Goldstein 241c62520a8SAmir Goldstein void ovl_dentry_clear_flag(unsigned long flag, struct dentry *dentry) 242c62520a8SAmir Goldstein { 243c62520a8SAmir Goldstein clear_bit(flag, &OVL_E(dentry)->flags); 244c62520a8SAmir Goldstein } 245c62520a8SAmir Goldstein 246c62520a8SAmir Goldstein bool ovl_dentry_test_flag(unsigned long flag, struct dentry *dentry) 247c62520a8SAmir Goldstein { 248c62520a8SAmir Goldstein return test_bit(flag, &OVL_E(dentry)->flags); 249c62520a8SAmir Goldstein } 250c62520a8SAmir Goldstein 251bbb1e54dSMiklos Szeredi bool ovl_dentry_is_opaque(struct dentry *dentry) 252bbb1e54dSMiklos Szeredi { 253c62520a8SAmir Goldstein return ovl_dentry_test_flag(OVL_E_OPAQUE, dentry); 254bbb1e54dSMiklos Szeredi } 255bbb1e54dSMiklos Szeredi 256bbb1e54dSMiklos Szeredi bool ovl_dentry_is_whiteout(struct dentry *dentry) 257bbb1e54dSMiklos Szeredi { 258bbb1e54dSMiklos Szeredi return !dentry->d_inode && ovl_dentry_is_opaque(dentry); 259bbb1e54dSMiklos Szeredi } 260bbb1e54dSMiklos Szeredi 2615cf5b477SMiklos Szeredi void ovl_dentry_set_opaque(struct dentry *dentry) 262bbb1e54dSMiklos Szeredi { 263c62520a8SAmir Goldstein ovl_dentry_set_flag(OVL_E_OPAQUE, dentry); 264bbb1e54dSMiklos Szeredi } 265bbb1e54dSMiklos Szeredi 26655acc661SMiklos Szeredi /* 267aa3ff3c1SAmir Goldstein * For hard links and decoded file handles, it's possible for ovl_dentry_upper() 268aa3ff3c1SAmir Goldstein * to return positive, while there's no actual upper alias for the inode. 269aa3ff3c1SAmir Goldstein * Copy up code needs to know about the existence of the upper alias, so it 270aa3ff3c1SAmir Goldstein * can't use ovl_dentry_upper(). 27155acc661SMiklos Szeredi */ 27255acc661SMiklos Szeredi bool ovl_dentry_has_upper_alias(struct dentry *dentry) 27355acc661SMiklos Szeredi { 274c62520a8SAmir Goldstein return ovl_dentry_test_flag(OVL_E_UPPER_ALIAS, dentry); 27555acc661SMiklos Szeredi } 27655acc661SMiklos Szeredi 27755acc661SMiklos Szeredi void ovl_dentry_set_upper_alias(struct dentry *dentry) 27855acc661SMiklos Szeredi { 279c62520a8SAmir Goldstein ovl_dentry_set_flag(OVL_E_UPPER_ALIAS, dentry); 28055acc661SMiklos Szeredi } 28155acc661SMiklos Szeredi 282a6c60655SMiklos Szeredi bool ovl_redirect_dir(struct super_block *sb) 283a6c60655SMiklos Szeredi { 284a6c60655SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 285a6c60655SMiklos Szeredi 28621a22878SAmir Goldstein return ofs->config.redirect_dir && !ofs->noxattr; 287a6c60655SMiklos Szeredi } 288a6c60655SMiklos Szeredi 289a6c60655SMiklos Szeredi const char *ovl_dentry_get_redirect(struct dentry *dentry) 290a6c60655SMiklos Szeredi { 291cf31c463SMiklos Szeredi return OVL_I(d_inode(dentry))->redirect; 292a6c60655SMiklos Szeredi } 293a6c60655SMiklos Szeredi 294a6c60655SMiklos Szeredi void ovl_dentry_set_redirect(struct dentry *dentry, const char *redirect) 295a6c60655SMiklos Szeredi { 296cf31c463SMiklos Szeredi struct ovl_inode *oi = OVL_I(d_inode(dentry)); 297a6c60655SMiklos Szeredi 298cf31c463SMiklos Szeredi kfree(oi->redirect); 299cf31c463SMiklos Szeredi oi->redirect = redirect; 300a6c60655SMiklos Szeredi } 301a6c60655SMiklos Szeredi 30209d8b586SMiklos Szeredi void ovl_inode_init(struct inode *inode, struct dentry *upperdentry, 30309d8b586SMiklos Szeredi struct dentry *lowerdentry) 304bbb1e54dSMiklos Szeredi { 305695b46e7SAmir Goldstein struct inode *realinode = d_inode(upperdentry ?: lowerdentry); 306695b46e7SAmir Goldstein 30709d8b586SMiklos Szeredi if (upperdentry) 30809d8b586SMiklos Szeredi OVL_I(inode)->__upperdentry = upperdentry; 30909d8b586SMiklos Szeredi if (lowerdentry) 31031747edaSAmir Goldstein OVL_I(inode)->lower = igrab(d_inode(lowerdentry)); 311bbb1e54dSMiklos Szeredi 312695b46e7SAmir Goldstein ovl_copyattr(realinode, inode); 313695b46e7SAmir Goldstein if (!inode->i_ino) 314695b46e7SAmir Goldstein inode->i_ino = realinode->i_ino; 315bbb1e54dSMiklos Szeredi } 316bbb1e54dSMiklos Szeredi 31709d8b586SMiklos Szeredi void ovl_inode_update(struct inode *inode, struct dentry *upperdentry) 318bbb1e54dSMiklos Szeredi { 31909d8b586SMiklos Szeredi struct inode *upperinode = d_inode(upperdentry); 320e6d2ebddSMiklos Szeredi 32109d8b586SMiklos Szeredi WARN_ON(OVL_I(inode)->__upperdentry); 32209d8b586SMiklos Szeredi 32325b7713aSMiklos Szeredi /* 32409d8b586SMiklos Szeredi * Make sure upperdentry is consistent before making it visible 32525b7713aSMiklos Szeredi */ 32625b7713aSMiklos Szeredi smp_wmb(); 32709d8b586SMiklos Szeredi OVL_I(inode)->__upperdentry = upperdentry; 32831747edaSAmir Goldstein if (inode_unhashed(inode)) { 329695b46e7SAmir Goldstein if (!inode->i_ino) 330695b46e7SAmir Goldstein inode->i_ino = upperinode->i_ino; 33125b7713aSMiklos Szeredi inode->i_private = upperinode; 332bbb1e54dSMiklos Szeredi __insert_inode_hash(inode, (unsigned long) upperinode); 333bbb1e54dSMiklos Szeredi } 33425b7713aSMiklos Szeredi } 335bbb1e54dSMiklos Szeredi 336d9854c87SMiklos Szeredi static void ovl_dentry_version_inc(struct dentry *dentry, bool impurity) 337bbb1e54dSMiklos Szeredi { 33804a01ac7SMiklos Szeredi struct inode *inode = d_inode(dentry); 339bbb1e54dSMiklos Szeredi 34004a01ac7SMiklos Szeredi WARN_ON(!inode_is_locked(inode)); 3414edb83bbSMiklos Szeredi /* 3424edb83bbSMiklos Szeredi * Version is used by readdir code to keep cache consistent. For merge 3434edb83bbSMiklos Szeredi * dirs all changes need to be noted. For non-merge dirs, cache only 3444edb83bbSMiklos Szeredi * contains impure (ones which have been copied up and have origins) 3454edb83bbSMiklos Szeredi * entries, so only need to note changes to impure entries. 3464edb83bbSMiklos Szeredi */ 3474edb83bbSMiklos Szeredi if (OVL_TYPE_MERGE(ovl_path_type(dentry)) || impurity) 34804a01ac7SMiklos Szeredi OVL_I(inode)->version++; 349bbb1e54dSMiklos Szeredi } 350bbb1e54dSMiklos Szeredi 351d9854c87SMiklos Szeredi void ovl_dir_modified(struct dentry *dentry, bool impurity) 352d9854c87SMiklos Szeredi { 353d9854c87SMiklos Szeredi /* Copy mtime/ctime */ 354d9854c87SMiklos Szeredi ovl_copyattr(d_inode(ovl_dentry_upper(dentry)), d_inode(dentry)); 355d9854c87SMiklos Szeredi 356d9854c87SMiklos Szeredi ovl_dentry_version_inc(dentry, impurity); 357d9854c87SMiklos Szeredi } 358d9854c87SMiklos Szeredi 359bbb1e54dSMiklos Szeredi u64 ovl_dentry_version_get(struct dentry *dentry) 360bbb1e54dSMiklos Szeredi { 36104a01ac7SMiklos Szeredi struct inode *inode = d_inode(dentry); 362bbb1e54dSMiklos Szeredi 36304a01ac7SMiklos Szeredi WARN_ON(!inode_is_locked(inode)); 36404a01ac7SMiklos Szeredi return OVL_I(inode)->version; 365bbb1e54dSMiklos Szeredi } 366bbb1e54dSMiklos Szeredi 367bbb1e54dSMiklos Szeredi bool ovl_is_whiteout(struct dentry *dentry) 368bbb1e54dSMiklos Szeredi { 369bbb1e54dSMiklos Szeredi struct inode *inode = dentry->d_inode; 370bbb1e54dSMiklos Szeredi 371bbb1e54dSMiklos Szeredi return inode && IS_WHITEOUT(inode); 372bbb1e54dSMiklos Szeredi } 373bbb1e54dSMiklos Szeredi 374bbb1e54dSMiklos Szeredi struct file *ovl_path_open(struct path *path, int flags) 375bbb1e54dSMiklos Szeredi { 376bbb1e54dSMiklos Szeredi return dentry_open(path, flags | O_NOATIME, current_cred()); 377bbb1e54dSMiklos Szeredi } 37839d3d60aSAmir Goldstein 37939d3d60aSAmir Goldstein int ovl_copy_up_start(struct dentry *dentry) 38039d3d60aSAmir Goldstein { 381a015dafcSAmir Goldstein struct ovl_inode *oi = OVL_I(d_inode(dentry)); 38239d3d60aSAmir Goldstein int err; 38339d3d60aSAmir Goldstein 384a015dafcSAmir Goldstein err = mutex_lock_interruptible(&oi->lock); 38559be0971SAmir Goldstein if (!err && ovl_dentry_has_upper_alias(dentry)) { 38639d3d60aSAmir Goldstein err = 1; /* Already copied up */ 387a015dafcSAmir Goldstein mutex_unlock(&oi->lock); 38839d3d60aSAmir Goldstein } 38939d3d60aSAmir Goldstein 39039d3d60aSAmir Goldstein return err; 39139d3d60aSAmir Goldstein } 39239d3d60aSAmir Goldstein 39339d3d60aSAmir Goldstein void ovl_copy_up_end(struct dentry *dentry) 39439d3d60aSAmir Goldstein { 395a015dafcSAmir Goldstein mutex_unlock(&OVL_I(d_inode(dentry))->lock); 39639d3d60aSAmir Goldstein } 39782b749b2SAmir Goldstein 398b79e05aaSAmir Goldstein bool ovl_check_origin_xattr(struct dentry *dentry) 399b79e05aaSAmir Goldstein { 400b79e05aaSAmir Goldstein int res; 401b79e05aaSAmir Goldstein 402b79e05aaSAmir Goldstein res = vfs_getxattr(dentry, OVL_XATTR_ORIGIN, NULL, 0); 403b79e05aaSAmir Goldstein 404b79e05aaSAmir Goldstein /* Zero size value means "copied up but origin unknown" */ 405b79e05aaSAmir Goldstein if (res >= 0) 406b79e05aaSAmir Goldstein return true; 407b79e05aaSAmir Goldstein 408b79e05aaSAmir Goldstein return false; 409b79e05aaSAmir Goldstein } 410b79e05aaSAmir Goldstein 411f3a15685SAmir Goldstein bool ovl_check_dir_xattr(struct dentry *dentry, const char *name) 412f3a15685SAmir Goldstein { 413f3a15685SAmir Goldstein int res; 414f3a15685SAmir Goldstein char val; 415f3a15685SAmir Goldstein 416f3a15685SAmir Goldstein if (!d_is_dir(dentry)) 417f3a15685SAmir Goldstein return false; 418f3a15685SAmir Goldstein 419f3a15685SAmir Goldstein res = vfs_getxattr(dentry, name, &val, 1); 420f3a15685SAmir Goldstein if (res == 1 && val == 'y') 421f3a15685SAmir Goldstein return true; 422f3a15685SAmir Goldstein 423f3a15685SAmir Goldstein return false; 424f3a15685SAmir Goldstein } 425f3a15685SAmir Goldstein 42682b749b2SAmir Goldstein int ovl_check_setxattr(struct dentry *dentry, struct dentry *upperdentry, 42782b749b2SAmir Goldstein const char *name, const void *value, size_t size, 42882b749b2SAmir Goldstein int xerr) 42982b749b2SAmir Goldstein { 43082b749b2SAmir Goldstein int err; 43182b749b2SAmir Goldstein struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 43282b749b2SAmir Goldstein 43382b749b2SAmir Goldstein if (ofs->noxattr) 43482b749b2SAmir Goldstein return xerr; 43582b749b2SAmir Goldstein 43682b749b2SAmir Goldstein err = ovl_do_setxattr(upperdentry, name, value, size, 0); 43782b749b2SAmir Goldstein 43882b749b2SAmir Goldstein if (err == -EOPNOTSUPP) { 43982b749b2SAmir Goldstein pr_warn("overlayfs: cannot set %s xattr on upper\n", name); 44082b749b2SAmir Goldstein ofs->noxattr = true; 44182b749b2SAmir Goldstein return xerr; 44282b749b2SAmir Goldstein } 44382b749b2SAmir Goldstein 44482b749b2SAmir Goldstein return err; 44582b749b2SAmir Goldstein } 446f3a15685SAmir Goldstein 447f3a15685SAmir Goldstein int ovl_set_impure(struct dentry *dentry, struct dentry *upperdentry) 448f3a15685SAmir Goldstein { 449f3a15685SAmir Goldstein int err; 450f3a15685SAmir Goldstein 45113c72075SMiklos Szeredi if (ovl_test_flag(OVL_IMPURE, d_inode(dentry))) 452f3a15685SAmir Goldstein return 0; 453f3a15685SAmir Goldstein 454f3a15685SAmir Goldstein /* 455f3a15685SAmir Goldstein * Do not fail when upper doesn't support xattrs. 456f3a15685SAmir Goldstein * Upper inodes won't have origin nor redirect xattr anyway. 457f3a15685SAmir Goldstein */ 458f3a15685SAmir Goldstein err = ovl_check_setxattr(dentry, upperdentry, OVL_XATTR_IMPURE, 459f3a15685SAmir Goldstein "y", 1, 0); 460f3a15685SAmir Goldstein if (!err) 46113c72075SMiklos Szeredi ovl_set_flag(OVL_IMPURE, d_inode(dentry)); 462f3a15685SAmir Goldstein 463f3a15685SAmir Goldstein return err; 464f3a15685SAmir Goldstein } 46513c72075SMiklos Szeredi 46613c72075SMiklos Szeredi void ovl_set_flag(unsigned long flag, struct inode *inode) 46713c72075SMiklos Szeredi { 46813c72075SMiklos Szeredi set_bit(flag, &OVL_I(inode)->flags); 46913c72075SMiklos Szeredi } 47013c72075SMiklos Szeredi 4714edb83bbSMiklos Szeredi void ovl_clear_flag(unsigned long flag, struct inode *inode) 4724edb83bbSMiklos Szeredi { 4734edb83bbSMiklos Szeredi clear_bit(flag, &OVL_I(inode)->flags); 4744edb83bbSMiklos Szeredi } 4754edb83bbSMiklos Szeredi 47613c72075SMiklos Szeredi bool ovl_test_flag(unsigned long flag, struct inode *inode) 47713c72075SMiklos Szeredi { 47813c72075SMiklos Szeredi return test_bit(flag, &OVL_I(inode)->flags); 47913c72075SMiklos Szeredi } 480ad0af710SAmir Goldstein 481ad0af710SAmir Goldstein /** 482ad0af710SAmir Goldstein * Caller must hold a reference to inode to prevent it from being freed while 483ad0af710SAmir Goldstein * it is marked inuse. 484ad0af710SAmir Goldstein */ 485ad0af710SAmir Goldstein bool ovl_inuse_trylock(struct dentry *dentry) 486ad0af710SAmir Goldstein { 487ad0af710SAmir Goldstein struct inode *inode = d_inode(dentry); 488ad0af710SAmir Goldstein bool locked = false; 489ad0af710SAmir Goldstein 490ad0af710SAmir Goldstein spin_lock(&inode->i_lock); 491ad0af710SAmir Goldstein if (!(inode->i_state & I_OVL_INUSE)) { 492ad0af710SAmir Goldstein inode->i_state |= I_OVL_INUSE; 493ad0af710SAmir Goldstein locked = true; 494ad0af710SAmir Goldstein } 495ad0af710SAmir Goldstein spin_unlock(&inode->i_lock); 496ad0af710SAmir Goldstein 497ad0af710SAmir Goldstein return locked; 498ad0af710SAmir Goldstein } 499ad0af710SAmir Goldstein 500ad0af710SAmir Goldstein void ovl_inuse_unlock(struct dentry *dentry) 501ad0af710SAmir Goldstein { 502ad0af710SAmir Goldstein if (dentry) { 503ad0af710SAmir Goldstein struct inode *inode = d_inode(dentry); 504ad0af710SAmir Goldstein 505ad0af710SAmir Goldstein spin_lock(&inode->i_lock); 506ad0af710SAmir Goldstein WARN_ON(!(inode->i_state & I_OVL_INUSE)); 507ad0af710SAmir Goldstein inode->i_state &= ~I_OVL_INUSE; 508ad0af710SAmir Goldstein spin_unlock(&inode->i_lock); 509ad0af710SAmir Goldstein } 510ad0af710SAmir Goldstein } 5115f8415d6SAmir Goldstein 51224b33ee1SAmir Goldstein /* 51324b33ee1SAmir Goldstein * Does this overlay dentry need to be indexed on copy up? 51424b33ee1SAmir Goldstein */ 51524b33ee1SAmir Goldstein bool ovl_need_index(struct dentry *dentry) 51624b33ee1SAmir Goldstein { 51724b33ee1SAmir Goldstein struct dentry *lower = ovl_dentry_lower(dentry); 51824b33ee1SAmir Goldstein 51924b33ee1SAmir Goldstein if (!lower || !ovl_indexdir(dentry->d_sb)) 52024b33ee1SAmir Goldstein return false; 52124b33ee1SAmir Goldstein 522fbd2d207SAmir Goldstein /* Index all files for NFS export and consistency verification */ 523016b720fSAmir Goldstein if (ovl_index_all(dentry->d_sb)) 524fbd2d207SAmir Goldstein return true; 525fbd2d207SAmir Goldstein 52624b33ee1SAmir Goldstein /* Index only lower hardlinks on copy up */ 52724b33ee1SAmir Goldstein if (!d_is_dir(lower) && d_inode(lower)->i_nlink > 1) 52824b33ee1SAmir Goldstein return true; 52924b33ee1SAmir Goldstein 53024b33ee1SAmir Goldstein return false; 53124b33ee1SAmir Goldstein } 53224b33ee1SAmir Goldstein 5339f4ec904SAmir Goldstein /* Caller must hold OVL_I(inode)->lock */ 534caf70cb2SAmir Goldstein static void ovl_cleanup_index(struct dentry *dentry) 535caf70cb2SAmir Goldstein { 536e7dd0e71SAmir Goldstein struct dentry *indexdir = ovl_indexdir(dentry->d_sb); 537e7dd0e71SAmir Goldstein struct inode *dir = indexdir->d_inode; 538caf70cb2SAmir Goldstein struct dentry *lowerdentry = ovl_dentry_lower(dentry); 539caf70cb2SAmir Goldstein struct dentry *upperdentry = ovl_dentry_upper(dentry); 540caf70cb2SAmir Goldstein struct dentry *index = NULL; 541caf70cb2SAmir Goldstein struct inode *inode; 542caf70cb2SAmir Goldstein struct qstr name; 543caf70cb2SAmir Goldstein int err; 544caf70cb2SAmir Goldstein 545caf70cb2SAmir Goldstein err = ovl_get_index_name(lowerdentry, &name); 546caf70cb2SAmir Goldstein if (err) 547caf70cb2SAmir Goldstein goto fail; 548caf70cb2SAmir Goldstein 549caf70cb2SAmir Goldstein inode = d_inode(upperdentry); 55089a17556SAmir Goldstein if (!S_ISDIR(inode->i_mode) && inode->i_nlink != 1) { 551caf70cb2SAmir Goldstein pr_warn_ratelimited("overlayfs: cleanup linked index (%pd2, ino=%lu, nlink=%u)\n", 552caf70cb2SAmir Goldstein upperdentry, inode->i_ino, inode->i_nlink); 553caf70cb2SAmir Goldstein /* 554caf70cb2SAmir Goldstein * We either have a bug with persistent union nlink or a lower 555caf70cb2SAmir Goldstein * hardlink was added while overlay is mounted. Adding a lower 556caf70cb2SAmir Goldstein * hardlink and then unlinking all overlay hardlinks would drop 557caf70cb2SAmir Goldstein * overlay nlink to zero before all upper inodes are unlinked. 558caf70cb2SAmir Goldstein * As a safety measure, when that situation is detected, set 559caf70cb2SAmir Goldstein * the overlay nlink to the index inode nlink minus one for the 560caf70cb2SAmir Goldstein * index entry itself. 561caf70cb2SAmir Goldstein */ 562caf70cb2SAmir Goldstein set_nlink(d_inode(dentry), inode->i_nlink - 1); 563caf70cb2SAmir Goldstein ovl_set_nlink_upper(dentry); 564caf70cb2SAmir Goldstein goto out; 565caf70cb2SAmir Goldstein } 566caf70cb2SAmir Goldstein 567caf70cb2SAmir Goldstein inode_lock_nested(dir, I_MUTEX_PARENT); 568e7dd0e71SAmir Goldstein index = lookup_one_len(name.name, indexdir, name.len); 569caf70cb2SAmir Goldstein err = PTR_ERR(index); 570e7dd0e71SAmir Goldstein if (IS_ERR(index)) { 5719f4ec904SAmir Goldstein index = NULL; 572e7dd0e71SAmir Goldstein } else if (ovl_index_all(dentry->d_sb)) { 573e7dd0e71SAmir Goldstein /* Whiteout orphan index to block future open by handle */ 574e7dd0e71SAmir Goldstein err = ovl_cleanup_and_whiteout(indexdir, dir, index); 575e7dd0e71SAmir Goldstein } else { 576e7dd0e71SAmir Goldstein /* Cleanup orphan index entries */ 577e7dd0e71SAmir Goldstein err = ovl_cleanup(dir, index); 578e7dd0e71SAmir Goldstein } 5799f4ec904SAmir Goldstein 580caf70cb2SAmir Goldstein inode_unlock(dir); 581caf70cb2SAmir Goldstein if (err) 582caf70cb2SAmir Goldstein goto fail; 583caf70cb2SAmir Goldstein 584caf70cb2SAmir Goldstein out: 585caf70cb2SAmir Goldstein dput(index); 586caf70cb2SAmir Goldstein return; 587caf70cb2SAmir Goldstein 588caf70cb2SAmir Goldstein fail: 589caf70cb2SAmir Goldstein pr_err("overlayfs: cleanup index of '%pd2' failed (%i)\n", dentry, err); 590caf70cb2SAmir Goldstein goto out; 591caf70cb2SAmir Goldstein } 592caf70cb2SAmir Goldstein 5935f8415d6SAmir Goldstein /* 5945f8415d6SAmir Goldstein * Operations that change overlay inode and upper inode nlink need to be 5955f8415d6SAmir Goldstein * synchronized with copy up for persistent nlink accounting. 5965f8415d6SAmir Goldstein */ 5975f8415d6SAmir Goldstein int ovl_nlink_start(struct dentry *dentry, bool *locked) 5985f8415d6SAmir Goldstein { 5995f8415d6SAmir Goldstein struct ovl_inode *oi = OVL_I(d_inode(dentry)); 6005f8415d6SAmir Goldstein const struct cred *old_cred; 6015f8415d6SAmir Goldstein int err; 6025f8415d6SAmir Goldstein 60389a17556SAmir Goldstein if (!d_inode(dentry)) 6045f8415d6SAmir Goldstein return 0; 6055f8415d6SAmir Goldstein 6065f8415d6SAmir Goldstein /* 6075f8415d6SAmir Goldstein * With inodes index is enabled, we store the union overlay nlink 60824b33ee1SAmir Goldstein * in an xattr on the index inode. When whiting out an indexed lower, 6095f8415d6SAmir Goldstein * we need to decrement the overlay persistent nlink, but before the 6105f8415d6SAmir Goldstein * first copy up, we have no upper index inode to store the xattr. 6115f8415d6SAmir Goldstein * 61224b33ee1SAmir Goldstein * As a workaround, before whiteout/rename over an indexed lower, 6135f8415d6SAmir Goldstein * copy up to create the upper index. Creating the upper index will 6145f8415d6SAmir Goldstein * initialize the overlay nlink, so it could be dropped if unlink 6155f8415d6SAmir Goldstein * or rename succeeds. 6165f8415d6SAmir Goldstein * 6175f8415d6SAmir Goldstein * TODO: implement metadata only index copy up when called with 6185f8415d6SAmir Goldstein * ovl_copy_up_flags(dentry, O_PATH). 6195f8415d6SAmir Goldstein */ 62024b33ee1SAmir Goldstein if (ovl_need_index(dentry) && !ovl_dentry_has_upper_alias(dentry)) { 6215f8415d6SAmir Goldstein err = ovl_copy_up(dentry); 6225f8415d6SAmir Goldstein if (err) 6235f8415d6SAmir Goldstein return err; 6245f8415d6SAmir Goldstein } 6255f8415d6SAmir Goldstein 6265f8415d6SAmir Goldstein err = mutex_lock_interruptible(&oi->lock); 6275f8415d6SAmir Goldstein if (err) 6285f8415d6SAmir Goldstein return err; 6295f8415d6SAmir Goldstein 63089a17556SAmir Goldstein if (d_is_dir(dentry) || !ovl_test_flag(OVL_INDEX, d_inode(dentry))) 6315f8415d6SAmir Goldstein goto out; 6325f8415d6SAmir Goldstein 6335f8415d6SAmir Goldstein old_cred = ovl_override_creds(dentry->d_sb); 6345f8415d6SAmir Goldstein /* 6355f8415d6SAmir Goldstein * The overlay inode nlink should be incremented/decremented IFF the 6365f8415d6SAmir Goldstein * upper operation succeeds, along with nlink change of upper inode. 6375f8415d6SAmir Goldstein * Therefore, before link/unlink/rename, we store the union nlink 6385f8415d6SAmir Goldstein * value relative to the upper inode nlink in an upper inode xattr. 6395f8415d6SAmir Goldstein */ 6405f8415d6SAmir Goldstein err = ovl_set_nlink_upper(dentry); 6415f8415d6SAmir Goldstein revert_creds(old_cred); 6425f8415d6SAmir Goldstein 6435f8415d6SAmir Goldstein out: 6445f8415d6SAmir Goldstein if (err) 6455f8415d6SAmir Goldstein mutex_unlock(&oi->lock); 6465f8415d6SAmir Goldstein else 6475f8415d6SAmir Goldstein *locked = true; 6485f8415d6SAmir Goldstein 6495f8415d6SAmir Goldstein return err; 6505f8415d6SAmir Goldstein } 6515f8415d6SAmir Goldstein 6525f8415d6SAmir Goldstein void ovl_nlink_end(struct dentry *dentry, bool locked) 6535f8415d6SAmir Goldstein { 654caf70cb2SAmir Goldstein if (locked) { 655caf70cb2SAmir Goldstein if (ovl_test_flag(OVL_INDEX, d_inode(dentry)) && 656caf70cb2SAmir Goldstein d_inode(dentry)->i_nlink == 0) { 657caf70cb2SAmir Goldstein const struct cred *old_cred; 658caf70cb2SAmir Goldstein 659caf70cb2SAmir Goldstein old_cred = ovl_override_creds(dentry->d_sb); 660caf70cb2SAmir Goldstein ovl_cleanup_index(dentry); 661caf70cb2SAmir Goldstein revert_creds(old_cred); 662caf70cb2SAmir Goldstein } 663caf70cb2SAmir Goldstein 6645f8415d6SAmir Goldstein mutex_unlock(&OVL_I(d_inode(dentry))->lock); 6655f8415d6SAmir Goldstein } 666caf70cb2SAmir Goldstein } 6675820dc08SAmir Goldstein 6685820dc08SAmir Goldstein int ovl_lock_rename_workdir(struct dentry *workdir, struct dentry *upperdir) 6695820dc08SAmir Goldstein { 6705820dc08SAmir Goldstein /* Workdir should not be the same as upperdir */ 6715820dc08SAmir Goldstein if (workdir == upperdir) 6725820dc08SAmir Goldstein goto err; 6735820dc08SAmir Goldstein 6745820dc08SAmir Goldstein /* Workdir should not be subdir of upperdir and vice versa */ 6755820dc08SAmir Goldstein if (lock_rename(workdir, upperdir) != NULL) 6765820dc08SAmir Goldstein goto err_unlock; 6775820dc08SAmir Goldstein 6785820dc08SAmir Goldstein return 0; 6795820dc08SAmir Goldstein 6805820dc08SAmir Goldstein err_unlock: 6815820dc08SAmir Goldstein unlock_rename(workdir, upperdir); 6825820dc08SAmir Goldstein err: 6835820dc08SAmir Goldstein pr_err("overlayfs: failed to lock workdir+upperdir\n"); 6845820dc08SAmir Goldstein return -EIO; 6855820dc08SAmir Goldstein } 686