1d2912cb1SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only 2e9be9d5eSMiklos Szeredi /* 3e9be9d5eSMiklos Szeredi * 4e9be9d5eSMiklos Szeredi * Copyright (C) 2011 Novell Inc. 5e9be9d5eSMiklos Szeredi */ 6e9be9d5eSMiklos Szeredi 7e9be9d5eSMiklos Szeredi #include <linux/fs.h> 8e9be9d5eSMiklos Szeredi #include <linux/slab.h> 95b825c3aSIngo Molnar #include <linux/cred.h> 10e9be9d5eSMiklos Szeredi #include <linux/xattr.h> 115201dc44SMiklos Szeredi #include <linux/posix_acl.h> 125f8415d6SAmir Goldstein #include <linux/ratelimit.h> 13e9be9d5eSMiklos Szeredi #include "overlayfs.h" 14e9be9d5eSMiklos Szeredi 15ba1e563cSChandan Rajendra 16e9be9d5eSMiklos Szeredi int ovl_setattr(struct dentry *dentry, struct iattr *attr) 17e9be9d5eSMiklos Szeredi { 18e9be9d5eSMiklos Szeredi int err; 19997336f2SVivek Goyal bool full_copy_up = false; 20e9be9d5eSMiklos Szeredi struct dentry *upperdentry; 211175b6b8SVivek Goyal const struct cred *old_cred; 22e9be9d5eSMiklos Szeredi 2331051c85SJan Kara err = setattr_prepare(dentry, attr); 24cf9a6784SMiklos Szeredi if (err) 25cf9a6784SMiklos Szeredi return err; 26cf9a6784SMiklos Szeredi 27e9be9d5eSMiklos Szeredi err = ovl_want_write(dentry); 28e9be9d5eSMiklos Szeredi if (err) 29e9be9d5eSMiklos Szeredi goto out; 30e9be9d5eSMiklos Szeredi 315812160eSMiklos Szeredi if (attr->ia_valid & ATTR_SIZE) { 325812160eSMiklos Szeredi struct inode *realinode = d_inode(ovl_dentry_real(dentry)); 335812160eSMiklos Szeredi 345812160eSMiklos Szeredi err = -ETXTBSY; 355812160eSMiklos Szeredi if (atomic_read(&realinode->i_writecount) < 0) 365812160eSMiklos Szeredi goto out_drop_write; 37997336f2SVivek Goyal 38997336f2SVivek Goyal /* Truncate should trigger data copy up as well */ 39997336f2SVivek Goyal full_copy_up = true; 405812160eSMiklos Szeredi } 415812160eSMiklos Szeredi 42997336f2SVivek Goyal if (!full_copy_up) 43acff81ecSMiklos Szeredi err = ovl_copy_up(dentry); 44997336f2SVivek Goyal else 45997336f2SVivek Goyal err = ovl_copy_up_with_data(dentry); 46acff81ecSMiklos Szeredi if (!err) { 475812160eSMiklos Szeredi struct inode *winode = NULL; 485812160eSMiklos Szeredi 49e9be9d5eSMiklos Szeredi upperdentry = ovl_dentry_upper(dentry); 50acff81ecSMiklos Szeredi 515812160eSMiklos Szeredi if (attr->ia_valid & ATTR_SIZE) { 525812160eSMiklos Szeredi winode = d_inode(upperdentry); 535812160eSMiklos Szeredi err = get_write_access(winode); 545812160eSMiklos Szeredi if (err) 555812160eSMiklos Szeredi goto out_drop_write; 565812160eSMiklos Szeredi } 575812160eSMiklos Szeredi 58b99c2d91SMiklos Szeredi if (attr->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID)) 59b99c2d91SMiklos Szeredi attr->ia_valid &= ~ATTR_MODE; 60b99c2d91SMiklos Szeredi 615955102cSAl Viro inode_lock(upperdentry->d_inode); 621175b6b8SVivek Goyal old_cred = ovl_override_creds(dentry->d_sb); 63e9be9d5eSMiklos Szeredi err = notify_change(upperdentry, attr, NULL); 641175b6b8SVivek Goyal revert_creds(old_cred); 65b81de061SKonstantin Khlebnikov if (!err) 66b81de061SKonstantin Khlebnikov ovl_copyattr(upperdentry->d_inode, dentry->d_inode); 675955102cSAl Viro inode_unlock(upperdentry->d_inode); 685812160eSMiklos Szeredi 695812160eSMiklos Szeredi if (winode) 705812160eSMiklos Szeredi put_write_access(winode); 71e9be9d5eSMiklos Szeredi } 725812160eSMiklos Szeredi out_drop_write: 73e9be9d5eSMiklos Szeredi ovl_drop_write(dentry); 74e9be9d5eSMiklos Szeredi out: 75e9be9d5eSMiklos Szeredi return err; 76e9be9d5eSMiklos Szeredi } 77e9be9d5eSMiklos Szeredi 78da309e8cSAmir Goldstein static int ovl_map_dev_ino(struct dentry *dentry, struct kstat *stat, 79da309e8cSAmir Goldstein struct ovl_layer *lower_layer) 80da309e8cSAmir Goldstein { 81da309e8cSAmir Goldstein bool samefs = ovl_same_sb(dentry->d_sb); 82e487d889SAmir Goldstein unsigned int xinobits = ovl_xino_bits(dentry->d_sb); 83da309e8cSAmir Goldstein 84da309e8cSAmir Goldstein if (samefs) { 85da309e8cSAmir Goldstein /* 86da309e8cSAmir Goldstein * When all layers are on the same fs, all real inode 87da309e8cSAmir Goldstein * number are unique, so we use the overlay st_dev, 88da309e8cSAmir Goldstein * which is friendly to du -x. 89da309e8cSAmir Goldstein */ 90da309e8cSAmir Goldstein stat->dev = dentry->d_sb->s_dev; 91e487d889SAmir Goldstein return 0; 92e487d889SAmir Goldstein } else if (xinobits) { 93e487d889SAmir Goldstein unsigned int shift = 64 - xinobits; 94e487d889SAmir Goldstein /* 95e487d889SAmir Goldstein * All inode numbers of underlying fs should not be using the 96e487d889SAmir Goldstein * high xinobits, so we use high xinobits to partition the 97e487d889SAmir Goldstein * overlay st_ino address space. The high bits holds the fsid 98e487d889SAmir Goldstein * (upper fsid is 0). This way overlay inode numbers are unique 99e487d889SAmir Goldstein * and all inodes use overlay st_dev. Inode numbers are also 100e487d889SAmir Goldstein * persistent for a given layer configuration. 101e487d889SAmir Goldstein */ 102e487d889SAmir Goldstein if (stat->ino >> shift) { 1031bd0a3aeSlijiazi pr_warn_ratelimited("inode number too big (%pd2, ino=%llu, xinobits=%d)\n", 104e487d889SAmir Goldstein dentry, stat->ino, xinobits); 105e487d889SAmir Goldstein } else { 106e487d889SAmir Goldstein if (lower_layer) 107e487d889SAmir Goldstein stat->ino |= ((u64)lower_layer->fsid) << shift; 108e487d889SAmir Goldstein 109e487d889SAmir Goldstein stat->dev = dentry->d_sb->s_dev; 110e487d889SAmir Goldstein return 0; 111e487d889SAmir Goldstein } 112e487d889SAmir Goldstein } 113e487d889SAmir Goldstein 114e487d889SAmir Goldstein /* The inode could not be mapped to a unified st_ino address space */ 115e487d889SAmir Goldstein if (S_ISDIR(dentry->d_inode->i_mode)) { 116da309e8cSAmir Goldstein /* 117da309e8cSAmir Goldstein * Always use the overlay st_dev for directories, so 'find 118da309e8cSAmir Goldstein * -xdev' will scan the entire overlay mount and won't cross the 119da309e8cSAmir Goldstein * overlay mount boundaries. 120da309e8cSAmir Goldstein * 121da309e8cSAmir Goldstein * If not all layers are on the same fs the pair {real st_ino; 122da309e8cSAmir Goldstein * overlay st_dev} is not unique, so use the non persistent 123da309e8cSAmir Goldstein * overlay st_ino for directories. 124da309e8cSAmir Goldstein */ 125da309e8cSAmir Goldstein stat->dev = dentry->d_sb->s_dev; 126da309e8cSAmir Goldstein stat->ino = dentry->d_inode->i_ino; 1275148626bSAmir Goldstein } else if (lower_layer && lower_layer->fsid) { 128da309e8cSAmir Goldstein /* 129da309e8cSAmir Goldstein * For non-samefs setup, if we cannot map all layers st_ino 130da309e8cSAmir Goldstein * to a unified address space, we need to make sure that st_dev 1315148626bSAmir Goldstein * is unique per lower fs. Upper layer uses real st_dev and 1325148626bSAmir Goldstein * lower layers use the unique anonymous bdev assigned to the 1335148626bSAmir Goldstein * lower fs. 134da309e8cSAmir Goldstein */ 1355148626bSAmir Goldstein stat->dev = lower_layer->fs->pseudo_dev; 136da309e8cSAmir Goldstein } 137da309e8cSAmir Goldstein 138da309e8cSAmir Goldstein return 0; 139da309e8cSAmir Goldstein } 140da309e8cSAmir Goldstein 1415b712091SMiklos Szeredi int ovl_getattr(const struct path *path, struct kstat *stat, 142a528d35eSDavid Howells u32 request_mask, unsigned int flags) 143e9be9d5eSMiklos Szeredi { 144a528d35eSDavid Howells struct dentry *dentry = path->dentry; 14572b608f0SAmir Goldstein enum ovl_path_type type; 146e9be9d5eSMiklos Szeredi struct path realpath; 1471175b6b8SVivek Goyal const struct cred *old_cred; 1485b712091SMiklos Szeredi bool is_dir = S_ISDIR(dentry->d_inode->i_mode); 149a0c5ad30SAmir Goldstein bool samefs = ovl_same_sb(dentry->d_sb); 150da309e8cSAmir Goldstein struct ovl_layer *lower_layer = NULL; 1511175b6b8SVivek Goyal int err; 15267d756c2SVivek Goyal bool metacopy_blocks = false; 15367d756c2SVivek Goyal 15467d756c2SVivek Goyal metacopy_blocks = ovl_is_metacopy_dentry(dentry); 155e9be9d5eSMiklos Szeredi 15672b608f0SAmir Goldstein type = ovl_path_real(dentry, &realpath); 1571175b6b8SVivek Goyal old_cred = ovl_override_creds(dentry->d_sb); 158a528d35eSDavid Howells err = vfs_getattr(&realpath, stat, request_mask, flags); 15972b608f0SAmir Goldstein if (err) 16072b608f0SAmir Goldstein goto out; 16172b608f0SAmir Goldstein 16272b608f0SAmir Goldstein /* 163da309e8cSAmir Goldstein * For non-dir or same fs, we use st_ino of the copy up origin. 164da309e8cSAmir Goldstein * This guaranties constant st_dev/st_ino across copy up. 165e487d889SAmir Goldstein * With xino feature and non-samefs, we use st_ino of the copy up 166e487d889SAmir Goldstein * origin masked with high bits that represent the layer id. 16772b608f0SAmir Goldstein * 168da309e8cSAmir Goldstein * If lower filesystem supports NFS file handles, this also guaranties 16972b608f0SAmir Goldstein * persistent st_ino across mount cycle. 17072b608f0SAmir Goldstein */ 171e487d889SAmir Goldstein if (!is_dir || samefs || ovl_xino_bits(dentry->d_sb)) { 172da309e8cSAmir Goldstein if (!OVL_TYPE_UPPER(type)) { 173da309e8cSAmir Goldstein lower_layer = ovl_layer_lower(dentry); 174da309e8cSAmir Goldstein } else if (OVL_TYPE_ORIGIN(type)) { 17572b608f0SAmir Goldstein struct kstat lowerstat; 17667d756c2SVivek Goyal u32 lowermask = STATX_INO | STATX_BLOCKS | 17767d756c2SVivek Goyal (!is_dir ? STATX_NLINK : 0); 17872b608f0SAmir Goldstein 17972b608f0SAmir Goldstein ovl_path_lower(dentry, &realpath); 18072b608f0SAmir Goldstein err = vfs_getattr(&realpath, &lowerstat, 1815b712091SMiklos Szeredi lowermask, flags); 18272b608f0SAmir Goldstein if (err) 18372b608f0SAmir Goldstein goto out; 18472b608f0SAmir Goldstein 18572b608f0SAmir Goldstein /* 186359f392cSAmir Goldstein * Lower hardlinks may be broken on copy up to different 18772b608f0SAmir Goldstein * upper files, so we cannot use the lower origin st_ino 18872b608f0SAmir Goldstein * for those different files, even for the same fs case. 18986eaa130SAmir Goldstein * 19086eaa130SAmir Goldstein * Similarly, several redirected dirs can point to the 19186eaa130SAmir Goldstein * same dir on a lower layer. With the "verify_lower" 19286eaa130SAmir Goldstein * feature, we do not use the lower origin st_ino, if 19386eaa130SAmir Goldstein * we haven't verified that this redirect is unique. 19486eaa130SAmir Goldstein * 195359f392cSAmir Goldstein * With inodes index enabled, it is safe to use st_ino 19686eaa130SAmir Goldstein * of an indexed origin. The index validates that the 19786eaa130SAmir Goldstein * upper hardlink is not broken and that a redirected 19886eaa130SAmir Goldstein * dir is the only redirect to that origin. 19972b608f0SAmir Goldstein */ 20086eaa130SAmir Goldstein if (ovl_test_flag(OVL_INDEX, d_inode(dentry)) || 20186eaa130SAmir Goldstein (!ovl_verify_lower(dentry->d_sb) && 2029f99e50dSAmir Goldstein (is_dir || lowerstat.nlink == 1))) { 203da309e8cSAmir Goldstein lower_layer = ovl_layer_lower(dentry); 2049c6d8f13SAmir Goldstein /* 2059c6d8f13SAmir Goldstein * Cannot use origin st_dev;st_ino because 2069c6d8f13SAmir Goldstein * origin inode content may differ from overlay 2079c6d8f13SAmir Goldstein * inode content. 2089c6d8f13SAmir Goldstein */ 2099c6d8f13SAmir Goldstein if (samefs || lower_layer->fsid) 2109c6d8f13SAmir Goldstein stat->ino = lowerstat.ino; 21172b608f0SAmir Goldstein } 21267d756c2SVivek Goyal 21367d756c2SVivek Goyal /* 21467d756c2SVivek Goyal * If we are querying a metacopy dentry and lower 21567d756c2SVivek Goyal * dentry is data dentry, then use the blocks we 21667d756c2SVivek Goyal * queried just now. We don't have to do additional 21767d756c2SVivek Goyal * vfs_getattr(). If lower itself is metacopy, then 21867d756c2SVivek Goyal * additional vfs_getattr() is unavoidable. 21967d756c2SVivek Goyal */ 22067d756c2SVivek Goyal if (metacopy_blocks && 22167d756c2SVivek Goyal realpath.dentry == ovl_dentry_lowerdata(dentry)) { 22267d756c2SVivek Goyal stat->blocks = lowerstat.blocks; 22367d756c2SVivek Goyal metacopy_blocks = false; 22467d756c2SVivek Goyal } 22567d756c2SVivek Goyal } 22667d756c2SVivek Goyal 22767d756c2SVivek Goyal if (metacopy_blocks) { 22867d756c2SVivek Goyal /* 22967d756c2SVivek Goyal * If lower is not same as lowerdata or if there was 23067d756c2SVivek Goyal * no origin on upper, we can end up here. 23167d756c2SVivek Goyal */ 23267d756c2SVivek Goyal struct kstat lowerdatastat; 23367d756c2SVivek Goyal u32 lowermask = STATX_BLOCKS; 23467d756c2SVivek Goyal 23567d756c2SVivek Goyal ovl_path_lowerdata(dentry, &realpath); 23667d756c2SVivek Goyal err = vfs_getattr(&realpath, &lowerdatastat, 23767d756c2SVivek Goyal lowermask, flags); 23867d756c2SVivek Goyal if (err) 23967d756c2SVivek Goyal goto out; 24067d756c2SVivek Goyal stat->blocks = lowerdatastat.blocks; 2419f99e50dSAmir Goldstein } 242a0c5ad30SAmir Goldstein } 243da309e8cSAmir Goldstein 244da309e8cSAmir Goldstein err = ovl_map_dev_ino(dentry, stat, lower_layer); 245da309e8cSAmir Goldstein if (err) 246da309e8cSAmir Goldstein goto out; 2475b712091SMiklos Szeredi 2485b712091SMiklos Szeredi /* 2495b712091SMiklos Szeredi * It's probably not worth it to count subdirs to get the 2505b712091SMiklos Szeredi * correct link count. nlink=1 seems to pacify 'find' and 2515b712091SMiklos Szeredi * other utilities. 2525b712091SMiklos Szeredi */ 2535b712091SMiklos Szeredi if (is_dir && OVL_TYPE_MERGE(type)) 2545b712091SMiklos Szeredi stat->nlink = 1; 2555b712091SMiklos Szeredi 2565f8415d6SAmir Goldstein /* 2575f8415d6SAmir Goldstein * Return the overlay inode nlinks for indexed upper inodes. 2585f8415d6SAmir Goldstein * Overlay inode nlink counts the union of the upper hardlinks 2595f8415d6SAmir Goldstein * and non-covered lower hardlinks. It does not include the upper 2605f8415d6SAmir Goldstein * index hardlink. 2615f8415d6SAmir Goldstein */ 2625f8415d6SAmir Goldstein if (!is_dir && ovl_test_flag(OVL_INDEX, d_inode(dentry))) 2635f8415d6SAmir Goldstein stat->nlink = dentry->d_inode->i_nlink; 2645f8415d6SAmir Goldstein 26572b608f0SAmir Goldstein out: 2661175b6b8SVivek Goyal revert_creds(old_cred); 26772b608f0SAmir Goldstein 2681175b6b8SVivek Goyal return err; 269e9be9d5eSMiklos Szeredi } 270e9be9d5eSMiklos Szeredi 271e9be9d5eSMiklos Szeredi int ovl_permission(struct inode *inode, int mask) 272e9be9d5eSMiklos Szeredi { 27309d8b586SMiklos Szeredi struct inode *upperinode = ovl_inode_upper(inode); 27409d8b586SMiklos Szeredi struct inode *realinode = upperinode ?: ovl_inode_lower(inode); 275c0ca3d70SVivek Goyal const struct cred *old_cred; 276e9be9d5eSMiklos Szeredi int err; 277e9be9d5eSMiklos Szeredi 278e9be9d5eSMiklos Szeredi /* Careful in RCU walk mode */ 279e9be9d5eSMiklos Szeredi if (!realinode) { 280e9be9d5eSMiklos Szeredi WARN_ON(!(mask & MAY_NOT_BLOCK)); 281a999d7e1SMiklos Szeredi return -ECHILD; 282e9be9d5eSMiklos Szeredi } 283e9be9d5eSMiklos Szeredi 284c0ca3d70SVivek Goyal /* 285c0ca3d70SVivek Goyal * Check overlay inode with the creds of task and underlying inode 286c0ca3d70SVivek Goyal * with creds of mounter 287c0ca3d70SVivek Goyal */ 288c0ca3d70SVivek Goyal err = generic_permission(inode, mask); 289c0ca3d70SVivek Goyal if (err) 290c0ca3d70SVivek Goyal return err; 291c0ca3d70SVivek Goyal 292ec7ba118SMiklos Szeredi old_cred = ovl_override_creds(inode->i_sb); 293ec7ba118SMiklos Szeredi if (!upperinode && 294ec7ba118SMiklos Szeredi !special_file(realinode->i_mode) && mask & MAY_WRITE) { 295754f8cb7SVivek Goyal mask &= ~(MAY_WRITE | MAY_APPEND); 296ec7ba118SMiklos Szeredi /* Make sure mounter can read file for copy up later */ 297500cac3cSVivek Goyal mask |= MAY_READ; 298500cac3cSVivek Goyal } 2999c630ebeSMiklos Szeredi err = inode_permission(realinode, mask); 300c0ca3d70SVivek Goyal revert_creds(old_cred); 301c0ca3d70SVivek Goyal 302c0ca3d70SVivek Goyal return err; 303e9be9d5eSMiklos Szeredi } 304e9be9d5eSMiklos Szeredi 3056b255391SAl Viro static const char *ovl_get_link(struct dentry *dentry, 306fceef393SAl Viro struct inode *inode, 307fceef393SAl Viro struct delayed_call *done) 308e9be9d5eSMiklos Szeredi { 3091175b6b8SVivek Goyal const struct cred *old_cred; 3101175b6b8SVivek Goyal const char *p; 311e9be9d5eSMiklos Szeredi 3126b255391SAl Viro if (!dentry) 3136b255391SAl Viro return ERR_PTR(-ECHILD); 3146b255391SAl Viro 3151175b6b8SVivek Goyal old_cred = ovl_override_creds(dentry->d_sb); 3167764235bSMiklos Szeredi p = vfs_get_link(ovl_dentry_real(dentry), done); 3171175b6b8SVivek Goyal revert_creds(old_cred); 3181175b6b8SVivek Goyal return p; 319e9be9d5eSMiklos Szeredi } 320e9be9d5eSMiklos Szeredi 3210956254aSMiklos Szeredi bool ovl_is_private_xattr(const char *name) 322e9be9d5eSMiklos Szeredi { 323fe2b7595SAndreas Gruenbacher return strncmp(name, OVL_XATTR_PREFIX, 324fe2b7595SAndreas Gruenbacher sizeof(OVL_XATTR_PREFIX) - 1) == 0; 325e9be9d5eSMiklos Szeredi } 326e9be9d5eSMiklos Szeredi 3271d88f183SMiklos Szeredi int ovl_xattr_set(struct dentry *dentry, struct inode *inode, const char *name, 3281d88f183SMiklos Szeredi const void *value, size_t size, int flags) 329e9be9d5eSMiklos Szeredi { 330e9be9d5eSMiklos Szeredi int err; 3311d88f183SMiklos Szeredi struct dentry *upperdentry = ovl_i_dentry_upper(inode); 3321d88f183SMiklos Szeredi struct dentry *realdentry = upperdentry ?: ovl_dentry_lower(dentry); 3331175b6b8SVivek Goyal const struct cred *old_cred; 334e9be9d5eSMiklos Szeredi 335e9be9d5eSMiklos Szeredi err = ovl_want_write(dentry); 336e9be9d5eSMiklos Szeredi if (err) 337e9be9d5eSMiklos Szeredi goto out; 338e9be9d5eSMiklos Szeredi 3391d88f183SMiklos Szeredi if (!value && !upperdentry) { 3401d88f183SMiklos Szeredi err = vfs_getxattr(realdentry, name, NULL, 0); 3410e585cccSAndreas Gruenbacher if (err < 0) 3420e585cccSAndreas Gruenbacher goto out_drop_write; 3430e585cccSAndreas Gruenbacher } 3440e585cccSAndreas Gruenbacher 3451d88f183SMiklos Szeredi if (!upperdentry) { 346e9be9d5eSMiklos Szeredi err = ovl_copy_up(dentry); 347e9be9d5eSMiklos Szeredi if (err) 348e9be9d5eSMiklos Szeredi goto out_drop_write; 349e9be9d5eSMiklos Szeredi 3501d88f183SMiklos Szeredi realdentry = ovl_dentry_upper(dentry); 3511d88f183SMiklos Szeredi } 3520e585cccSAndreas Gruenbacher 3531175b6b8SVivek Goyal old_cred = ovl_override_creds(dentry->d_sb); 3540e585cccSAndreas Gruenbacher if (value) 3551d88f183SMiklos Szeredi err = vfs_setxattr(realdentry, name, value, size, flags); 3560e585cccSAndreas Gruenbacher else { 3570e585cccSAndreas Gruenbacher WARN_ON(flags != XATTR_REPLACE); 3581d88f183SMiklos Szeredi err = vfs_removexattr(realdentry, name); 3590e585cccSAndreas Gruenbacher } 3601175b6b8SVivek Goyal revert_creds(old_cred); 361e9be9d5eSMiklos Szeredi 362d9854c87SMiklos Szeredi /* copy c/mtime */ 363d9854c87SMiklos Szeredi ovl_copyattr(d_inode(realdentry), inode); 364d9854c87SMiklos Szeredi 365e9be9d5eSMiklos Szeredi out_drop_write: 366e9be9d5eSMiklos Szeredi ovl_drop_write(dentry); 367e9be9d5eSMiklos Szeredi out: 368e9be9d5eSMiklos Szeredi return err; 369e9be9d5eSMiklos Szeredi } 370e9be9d5eSMiklos Szeredi 3711d88f183SMiklos Szeredi int ovl_xattr_get(struct dentry *dentry, struct inode *inode, const char *name, 3720eb45fc3SAndreas Gruenbacher void *value, size_t size) 373e9be9d5eSMiklos Szeredi { 3741175b6b8SVivek Goyal ssize_t res; 3751175b6b8SVivek Goyal const struct cred *old_cred; 3761d88f183SMiklos Szeredi struct dentry *realdentry = 3771d88f183SMiklos Szeredi ovl_i_dentry_upper(inode) ?: ovl_dentry_lower(dentry); 37852148463SMiklos Szeredi 3791175b6b8SVivek Goyal old_cred = ovl_override_creds(dentry->d_sb); 3801175b6b8SVivek Goyal res = vfs_getxattr(realdentry, name, value, size); 3811175b6b8SVivek Goyal revert_creds(old_cred); 3821175b6b8SVivek Goyal return res; 383e9be9d5eSMiklos Szeredi } 384e9be9d5eSMiklos Szeredi 385a082c6f6SMiklos Szeredi static bool ovl_can_list(const char *s) 386a082c6f6SMiklos Szeredi { 387a082c6f6SMiklos Szeredi /* List all non-trusted xatts */ 388a082c6f6SMiklos Szeredi if (strncmp(s, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) != 0) 389a082c6f6SMiklos Szeredi return true; 390a082c6f6SMiklos Szeredi 391a082c6f6SMiklos Szeredi /* Never list trusted.overlay, list other trusted for superuser only */ 3925c2e9f34SMark Salyzyn return !ovl_is_private_xattr(s) && 3935c2e9f34SMark Salyzyn ns_capable_noaudit(&init_user_ns, CAP_SYS_ADMIN); 394a082c6f6SMiklos Szeredi } 395a082c6f6SMiklos Szeredi 396e9be9d5eSMiklos Szeredi ssize_t ovl_listxattr(struct dentry *dentry, char *list, size_t size) 397e9be9d5eSMiklos Szeredi { 398b581755bSMiklos Szeredi struct dentry *realdentry = ovl_dentry_real(dentry); 399e9be9d5eSMiklos Szeredi ssize_t res; 4007cb35119SMiklos Szeredi size_t len; 4017cb35119SMiklos Szeredi char *s; 4021175b6b8SVivek Goyal const struct cred *old_cred; 403e9be9d5eSMiklos Szeredi 4041175b6b8SVivek Goyal old_cred = ovl_override_creds(dentry->d_sb); 405b581755bSMiklos Szeredi res = vfs_listxattr(realdentry, list, size); 4061175b6b8SVivek Goyal revert_creds(old_cred); 407e9be9d5eSMiklos Szeredi if (res <= 0 || size == 0) 408e9be9d5eSMiklos Szeredi return res; 409e9be9d5eSMiklos Szeredi 410e9be9d5eSMiklos Szeredi /* filter out private xattrs */ 4117cb35119SMiklos Szeredi for (s = list, len = res; len;) { 4127cb35119SMiklos Szeredi size_t slen = strnlen(s, len) + 1; 413e9be9d5eSMiklos Szeredi 4147cb35119SMiklos Szeredi /* underlying fs providing us with an broken xattr list? */ 4157cb35119SMiklos Szeredi if (WARN_ON(slen > len)) 4167cb35119SMiklos Szeredi return -EIO; 417e9be9d5eSMiklos Szeredi 4187cb35119SMiklos Szeredi len -= slen; 419a082c6f6SMiklos Szeredi if (!ovl_can_list(s)) { 420e9be9d5eSMiklos Szeredi res -= slen; 4217cb35119SMiklos Szeredi memmove(s, s + slen, len); 422e9be9d5eSMiklos Szeredi } else { 4237cb35119SMiklos Szeredi s += slen; 424e9be9d5eSMiklos Szeredi } 425e9be9d5eSMiklos Szeredi } 426e9be9d5eSMiklos Szeredi 427e9be9d5eSMiklos Szeredi return res; 428e9be9d5eSMiklos Szeredi } 429e9be9d5eSMiklos Szeredi 43039a25b2bSVivek Goyal struct posix_acl *ovl_get_acl(struct inode *inode, int type) 43139a25b2bSVivek Goyal { 43209d8b586SMiklos Szeredi struct inode *realinode = ovl_inode_real(inode); 4331175b6b8SVivek Goyal const struct cred *old_cred; 4341175b6b8SVivek Goyal struct posix_acl *acl; 43539a25b2bSVivek Goyal 4365201dc44SMiklos Szeredi if (!IS_ENABLED(CONFIG_FS_POSIX_ACL) || !IS_POSIXACL(realinode)) 43739a25b2bSVivek Goyal return NULL; 43839a25b2bSVivek Goyal 4391175b6b8SVivek Goyal old_cred = ovl_override_creds(inode->i_sb); 4405201dc44SMiklos Szeredi acl = get_acl(realinode, type); 4411175b6b8SVivek Goyal revert_creds(old_cred); 4421175b6b8SVivek Goyal 4431175b6b8SVivek Goyal return acl; 44439a25b2bSVivek Goyal } 44539a25b2bSVivek Goyal 44695582b00SDeepa Dinamani int ovl_update_time(struct inode *inode, struct timespec64 *ts, int flags) 447d719e8f2SMiklos Szeredi { 4488f35cf51SMiklos Szeredi if (flags & S_ATIME) { 4498f35cf51SMiklos Szeredi struct ovl_fs *ofs = inode->i_sb->s_fs_info; 4508f35cf51SMiklos Szeredi struct path upperpath = { 4518f35cf51SMiklos Szeredi .mnt = ofs->upper_mnt, 4528f35cf51SMiklos Szeredi .dentry = ovl_upperdentry_dereference(OVL_I(inode)), 4538f35cf51SMiklos Szeredi }; 454d719e8f2SMiklos Szeredi 455d719e8f2SMiklos Szeredi if (upperpath.dentry) { 456d719e8f2SMiklos Szeredi touch_atime(&upperpath); 457d719e8f2SMiklos Szeredi inode->i_atime = d_inode(upperpath.dentry)->i_atime; 458d719e8f2SMiklos Szeredi } 4598f35cf51SMiklos Szeredi } 460d719e8f2SMiklos Szeredi return 0; 461d719e8f2SMiklos Szeredi } 462d719e8f2SMiklos Szeredi 4639e142c41SMiklos Szeredi static int ovl_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, 4649e142c41SMiklos Szeredi u64 start, u64 len) 4659e142c41SMiklos Szeredi { 4669e142c41SMiklos Szeredi int err; 4679e142c41SMiklos Szeredi struct inode *realinode = ovl_inode_real(inode); 4689e142c41SMiklos Szeredi const struct cred *old_cred; 4699e142c41SMiklos Szeredi 4709e142c41SMiklos Szeredi if (!realinode->i_op->fiemap) 4719e142c41SMiklos Szeredi return -EOPNOTSUPP; 4729e142c41SMiklos Szeredi 4739e142c41SMiklos Szeredi old_cred = ovl_override_creds(inode->i_sb); 47480d34810SAmir Goldstein 47580d34810SAmir Goldstein if (fieinfo->fi_flags & FIEMAP_FLAG_SYNC) 47680d34810SAmir Goldstein filemap_write_and_wait(realinode->i_mapping); 47780d34810SAmir Goldstein 4789e142c41SMiklos Szeredi err = realinode->i_op->fiemap(realinode, fieinfo, start, len); 4799e142c41SMiklos Szeredi revert_creds(old_cred); 4809e142c41SMiklos Szeredi 4819e142c41SMiklos Szeredi return err; 4829e142c41SMiklos Szeredi } 4839e142c41SMiklos Szeredi 484e9be9d5eSMiklos Szeredi static const struct inode_operations ovl_file_inode_operations = { 485e9be9d5eSMiklos Szeredi .setattr = ovl_setattr, 486e9be9d5eSMiklos Szeredi .permission = ovl_permission, 487e9be9d5eSMiklos Szeredi .getattr = ovl_getattr, 488e9be9d5eSMiklos Szeredi .listxattr = ovl_listxattr, 48939a25b2bSVivek Goyal .get_acl = ovl_get_acl, 490d719e8f2SMiklos Szeredi .update_time = ovl_update_time, 4919e142c41SMiklos Szeredi .fiemap = ovl_fiemap, 492e9be9d5eSMiklos Szeredi }; 493e9be9d5eSMiklos Szeredi 494e9be9d5eSMiklos Szeredi static const struct inode_operations ovl_symlink_inode_operations = { 495e9be9d5eSMiklos Szeredi .setattr = ovl_setattr, 4966b255391SAl Viro .get_link = ovl_get_link, 497e9be9d5eSMiklos Szeredi .getattr = ovl_getattr, 498e9be9d5eSMiklos Szeredi .listxattr = ovl_listxattr, 499d719e8f2SMiklos Szeredi .update_time = ovl_update_time, 500e9be9d5eSMiklos Szeredi }; 501e9be9d5eSMiklos Szeredi 5029e142c41SMiklos Szeredi static const struct inode_operations ovl_special_inode_operations = { 5039e142c41SMiklos Szeredi .setattr = ovl_setattr, 5049e142c41SMiklos Szeredi .permission = ovl_permission, 5059e142c41SMiklos Szeredi .getattr = ovl_getattr, 5069e142c41SMiklos Szeredi .listxattr = ovl_listxattr, 5079e142c41SMiklos Szeredi .get_acl = ovl_get_acl, 5089e142c41SMiklos Szeredi .update_time = ovl_update_time, 5099e142c41SMiklos Szeredi }; 5109e142c41SMiklos Szeredi 51169383c59SWei Yongjun static const struct address_space_operations ovl_aops = { 5125b910bd6SAmir Goldstein /* For O_DIRECT dentry_open() checks f_mapping->a_ops->direct_IO */ 5135b910bd6SAmir Goldstein .direct_IO = noop_direct_IO, 5145b910bd6SAmir Goldstein }; 5155b910bd6SAmir Goldstein 516b1eaa950SAmir Goldstein /* 517b1eaa950SAmir Goldstein * It is possible to stack overlayfs instance on top of another 518b1eaa950SAmir Goldstein * overlayfs instance as lower layer. We need to annonate the 519b1eaa950SAmir Goldstein * stackable i_mutex locks according to stack level of the super 520b1eaa950SAmir Goldstein * block instance. An overlayfs instance can never be in stack 521b1eaa950SAmir Goldstein * depth 0 (there is always a real fs below it). An overlayfs 522b1eaa950SAmir Goldstein * inode lock will use the lockdep annotaion ovl_i_mutex_key[depth]. 523b1eaa950SAmir Goldstein * 524b1eaa950SAmir Goldstein * For example, here is a snip from /proc/lockdep_chains after 525b1eaa950SAmir Goldstein * dir_iterate of nested overlayfs: 526b1eaa950SAmir Goldstein * 527b1eaa950SAmir Goldstein * [...] &ovl_i_mutex_dir_key[depth] (stack_depth=2) 528b1eaa950SAmir Goldstein * [...] &ovl_i_mutex_dir_key[depth]#2 (stack_depth=1) 529b1eaa950SAmir Goldstein * [...] &type->i_mutex_dir_key (stack_depth=0) 530b1eaa950SAmir Goldstein */ 531b1eaa950SAmir Goldstein #define OVL_MAX_NESTING FILESYSTEM_MAX_STACK_DEPTH 532b1eaa950SAmir Goldstein 533b1eaa950SAmir Goldstein static inline void ovl_lockdep_annotate_inode_mutex_key(struct inode *inode) 534b1eaa950SAmir Goldstein { 535b1eaa950SAmir Goldstein #ifdef CONFIG_LOCKDEP 536b1eaa950SAmir Goldstein static struct lock_class_key ovl_i_mutex_key[OVL_MAX_NESTING]; 537b1eaa950SAmir Goldstein static struct lock_class_key ovl_i_mutex_dir_key[OVL_MAX_NESTING]; 5384eae06deSAmir Goldstein static struct lock_class_key ovl_i_lock_key[OVL_MAX_NESTING]; 539b1eaa950SAmir Goldstein 540b1eaa950SAmir Goldstein int depth = inode->i_sb->s_stack_depth - 1; 541b1eaa950SAmir Goldstein 542b1eaa950SAmir Goldstein if (WARN_ON_ONCE(depth < 0 || depth >= OVL_MAX_NESTING)) 543b1eaa950SAmir Goldstein depth = 0; 544b1eaa950SAmir Goldstein 545b1eaa950SAmir Goldstein if (S_ISDIR(inode->i_mode)) 546b1eaa950SAmir Goldstein lockdep_set_class(&inode->i_rwsem, &ovl_i_mutex_dir_key[depth]); 547b1eaa950SAmir Goldstein else 548b1eaa950SAmir Goldstein lockdep_set_class(&inode->i_rwsem, &ovl_i_mutex_key[depth]); 5494eae06deSAmir Goldstein 5504eae06deSAmir Goldstein lockdep_set_class(&OVL_I(inode)->lock, &ovl_i_lock_key[depth]); 551b1eaa950SAmir Goldstein #endif 552b1eaa950SAmir Goldstein } 553b1eaa950SAmir Goldstein 554695b46e7SAmir Goldstein static void ovl_fill_inode(struct inode *inode, umode_t mode, dev_t rdev, 55512574a9fSAmir Goldstein unsigned long ino, int fsid) 556e9be9d5eSMiklos Szeredi { 55712574a9fSAmir Goldstein int xinobits = ovl_xino_bits(inode->i_sb); 55812574a9fSAmir Goldstein 559695b46e7SAmir Goldstein /* 5606dde1e42SAmir Goldstein * When d_ino is consistent with st_ino (samefs or i_ino has enough 5616dde1e42SAmir Goldstein * bits to encode layer), set the same value used for st_ino to i_ino, 5626dde1e42SAmir Goldstein * so inode number exposed via /proc/locks and a like will be 5636dde1e42SAmir Goldstein * consistent with d_ino and st_ino values. An i_ino value inconsistent 5646dde1e42SAmir Goldstein * with d_ino also causes nfsd readdirplus to fail. When called from 56512574a9fSAmir Goldstein * ovl_new_inode(), ino arg is 0, so i_ino will be updated to real 566695b46e7SAmir Goldstein * upper inode i_ino on ovl_inode_init() or ovl_inode_update(). 567695b46e7SAmir Goldstein */ 5686dde1e42SAmir Goldstein if (ovl_same_sb(inode->i_sb) || xinobits) { 569695b46e7SAmir Goldstein inode->i_ino = ino; 57012574a9fSAmir Goldstein if (xinobits && fsid && !(ino >> (64 - xinobits))) 57112574a9fSAmir Goldstein inode->i_ino |= (unsigned long)fsid << (64 - xinobits); 57212574a9fSAmir Goldstein } else { 573e9be9d5eSMiklos Szeredi inode->i_ino = get_next_ino(); 57412574a9fSAmir Goldstein } 575e9be9d5eSMiklos Szeredi inode->i_mode = mode; 576d719e8f2SMiklos Szeredi inode->i_flags |= S_NOCMTIME; 5772a3a2a3fSMiklos Szeredi #ifdef CONFIG_FS_POSIX_ACL 5782a3a2a3fSMiklos Szeredi inode->i_acl = inode->i_default_acl = ACL_DONT_CACHE; 5792a3a2a3fSMiklos Szeredi #endif 580e9be9d5eSMiklos Szeredi 581b1eaa950SAmir Goldstein ovl_lockdep_annotate_inode_mutex_key(inode); 582b1eaa950SAmir Goldstein 583ca4c8a3aSMiklos Szeredi switch (mode & S_IFMT) { 584ca4c8a3aSMiklos Szeredi case S_IFREG: 585ca4c8a3aSMiklos Szeredi inode->i_op = &ovl_file_inode_operations; 586d1d04ef8SMiklos Szeredi inode->i_fop = &ovl_file_operations; 5875b910bd6SAmir Goldstein inode->i_mapping->a_ops = &ovl_aops; 588ca4c8a3aSMiklos Szeredi break; 589ca4c8a3aSMiklos Szeredi 590e9be9d5eSMiklos Szeredi case S_IFDIR: 591e9be9d5eSMiklos Szeredi inode->i_op = &ovl_dir_inode_operations; 592e9be9d5eSMiklos Szeredi inode->i_fop = &ovl_dir_operations; 593e9be9d5eSMiklos Szeredi break; 594e9be9d5eSMiklos Szeredi 595e9be9d5eSMiklos Szeredi case S_IFLNK: 596e9be9d5eSMiklos Szeredi inode->i_op = &ovl_symlink_inode_operations; 597e9be9d5eSMiklos Szeredi break; 598e9be9d5eSMiklos Szeredi 59951f7e52dSMiklos Szeredi default: 6009e142c41SMiklos Szeredi inode->i_op = &ovl_special_inode_operations; 601ca4c8a3aSMiklos Szeredi init_special_inode(inode, mode, rdev); 602e9be9d5eSMiklos Szeredi break; 60351f7e52dSMiklos Szeredi } 60451f7e52dSMiklos Szeredi } 605e9be9d5eSMiklos Szeredi 6065f8415d6SAmir Goldstein /* 6075f8415d6SAmir Goldstein * With inodes index enabled, an overlay inode nlink counts the union of upper 6085f8415d6SAmir Goldstein * hardlinks and non-covered lower hardlinks. During the lifetime of a non-pure 6095f8415d6SAmir Goldstein * upper inode, the following nlink modifying operations can happen: 6105f8415d6SAmir Goldstein * 6115f8415d6SAmir Goldstein * 1. Lower hardlink copy up 6125f8415d6SAmir Goldstein * 2. Upper hardlink created, unlinked or renamed over 6135f8415d6SAmir Goldstein * 3. Lower hardlink whiteout or renamed over 6145f8415d6SAmir Goldstein * 6155f8415d6SAmir Goldstein * For the first, copy up case, the union nlink does not change, whether the 6165f8415d6SAmir Goldstein * operation succeeds or fails, but the upper inode nlink may change. 6175f8415d6SAmir Goldstein * Therefore, before copy up, we store the union nlink value relative to the 6185f8415d6SAmir Goldstein * lower inode nlink in the index inode xattr trusted.overlay.nlink. 6195f8415d6SAmir Goldstein * 6205f8415d6SAmir Goldstein * For the second, upper hardlink case, the union nlink should be incremented 6215f8415d6SAmir Goldstein * or decremented IFF the operation succeeds, aligned with nlink change of the 6225f8415d6SAmir Goldstein * upper inode. Therefore, before link/unlink/rename, we store the union nlink 6235f8415d6SAmir Goldstein * value relative to the upper inode nlink in the index inode. 6245f8415d6SAmir Goldstein * 6255f8415d6SAmir Goldstein * For the last, lower cover up case, we simplify things by preceding the 6265f8415d6SAmir Goldstein * whiteout or cover up with copy up. This makes sure that there is an index 6275f8415d6SAmir Goldstein * upper inode where the nlink xattr can be stored before the copied up upper 6285f8415d6SAmir Goldstein * entry is unlink. 6295f8415d6SAmir Goldstein */ 6305f8415d6SAmir Goldstein #define OVL_NLINK_ADD_UPPER (1 << 0) 6315f8415d6SAmir Goldstein 6325f8415d6SAmir Goldstein /* 6335f8415d6SAmir Goldstein * On-disk format for indexed nlink: 6345f8415d6SAmir Goldstein * 6355f8415d6SAmir Goldstein * nlink relative to the upper inode - "U[+-]NUM" 6365f8415d6SAmir Goldstein * nlink relative to the lower inode - "L[+-]NUM" 6375f8415d6SAmir Goldstein */ 6385f8415d6SAmir Goldstein 6395f8415d6SAmir Goldstein static int ovl_set_nlink_common(struct dentry *dentry, 6405f8415d6SAmir Goldstein struct dentry *realdentry, const char *format) 6415f8415d6SAmir Goldstein { 6425f8415d6SAmir Goldstein struct inode *inode = d_inode(dentry); 6435f8415d6SAmir Goldstein struct inode *realinode = d_inode(realdentry); 6445f8415d6SAmir Goldstein char buf[13]; 6455f8415d6SAmir Goldstein int len; 6465f8415d6SAmir Goldstein 6475f8415d6SAmir Goldstein len = snprintf(buf, sizeof(buf), format, 6485f8415d6SAmir Goldstein (int) (inode->i_nlink - realinode->i_nlink)); 6495f8415d6SAmir Goldstein 6506787341aSMiklos Szeredi if (WARN_ON(len >= sizeof(buf))) 6516787341aSMiklos Szeredi return -EIO; 6526787341aSMiklos Szeredi 6535f8415d6SAmir Goldstein return ovl_do_setxattr(ovl_dentry_upper(dentry), 6545f8415d6SAmir Goldstein OVL_XATTR_NLINK, buf, len, 0); 6555f8415d6SAmir Goldstein } 6565f8415d6SAmir Goldstein 6575f8415d6SAmir Goldstein int ovl_set_nlink_upper(struct dentry *dentry) 6585f8415d6SAmir Goldstein { 6595f8415d6SAmir Goldstein return ovl_set_nlink_common(dentry, ovl_dentry_upper(dentry), "U%+i"); 6605f8415d6SAmir Goldstein } 6615f8415d6SAmir Goldstein 6625f8415d6SAmir Goldstein int ovl_set_nlink_lower(struct dentry *dentry) 6635f8415d6SAmir Goldstein { 6645f8415d6SAmir Goldstein return ovl_set_nlink_common(dentry, ovl_dentry_lower(dentry), "L%+i"); 6655f8415d6SAmir Goldstein } 6665f8415d6SAmir Goldstein 667caf70cb2SAmir Goldstein unsigned int ovl_get_nlink(struct dentry *lowerdentry, 6685f8415d6SAmir Goldstein struct dentry *upperdentry, 6695f8415d6SAmir Goldstein unsigned int fallback) 6705f8415d6SAmir Goldstein { 6715f8415d6SAmir Goldstein int nlink_diff; 6725f8415d6SAmir Goldstein int nlink; 6735f8415d6SAmir Goldstein char buf[13]; 6745f8415d6SAmir Goldstein int err; 6755f8415d6SAmir Goldstein 6765f8415d6SAmir Goldstein if (!lowerdentry || !upperdentry || d_inode(lowerdentry)->i_nlink == 1) 6775f8415d6SAmir Goldstein return fallback; 6785f8415d6SAmir Goldstein 6795f8415d6SAmir Goldstein err = vfs_getxattr(upperdentry, OVL_XATTR_NLINK, &buf, sizeof(buf) - 1); 6805f8415d6SAmir Goldstein if (err < 0) 6815f8415d6SAmir Goldstein goto fail; 6825f8415d6SAmir Goldstein 6835f8415d6SAmir Goldstein buf[err] = '\0'; 6845f8415d6SAmir Goldstein if ((buf[0] != 'L' && buf[0] != 'U') || 6855f8415d6SAmir Goldstein (buf[1] != '+' && buf[1] != '-')) 6865f8415d6SAmir Goldstein goto fail; 6875f8415d6SAmir Goldstein 6885f8415d6SAmir Goldstein err = kstrtoint(buf + 1, 10, &nlink_diff); 6895f8415d6SAmir Goldstein if (err < 0) 6905f8415d6SAmir Goldstein goto fail; 6915f8415d6SAmir Goldstein 6925f8415d6SAmir Goldstein nlink = d_inode(buf[0] == 'L' ? lowerdentry : upperdentry)->i_nlink; 6935f8415d6SAmir Goldstein nlink += nlink_diff; 6945f8415d6SAmir Goldstein 6955f8415d6SAmir Goldstein if (nlink <= 0) 6965f8415d6SAmir Goldstein goto fail; 6975f8415d6SAmir Goldstein 6985f8415d6SAmir Goldstein return nlink; 6995f8415d6SAmir Goldstein 7005f8415d6SAmir Goldstein fail: 7011bd0a3aeSlijiazi pr_warn_ratelimited("failed to get index nlink (%pd2, err=%i)\n", 7025f8415d6SAmir Goldstein upperdentry, err); 7035f8415d6SAmir Goldstein return fallback; 7045f8415d6SAmir Goldstein } 7055f8415d6SAmir Goldstein 706ca4c8a3aSMiklos Szeredi struct inode *ovl_new_inode(struct super_block *sb, umode_t mode, dev_t rdev) 70751f7e52dSMiklos Szeredi { 70851f7e52dSMiklos Szeredi struct inode *inode; 70951f7e52dSMiklos Szeredi 71051f7e52dSMiklos Szeredi inode = new_inode(sb); 71151f7e52dSMiklos Szeredi if (inode) 71212574a9fSAmir Goldstein ovl_fill_inode(inode, mode, rdev, 0, 0); 71351f7e52dSMiklos Szeredi 71451f7e52dSMiklos Szeredi return inode; 71551f7e52dSMiklos Szeredi } 71651f7e52dSMiklos Szeredi 71751f7e52dSMiklos Szeredi static int ovl_inode_test(struct inode *inode, void *data) 71851f7e52dSMiklos Szeredi { 71925b7713aSMiklos Szeredi return inode->i_private == data; 72051f7e52dSMiklos Szeredi } 72151f7e52dSMiklos Szeredi 72251f7e52dSMiklos Szeredi static int ovl_inode_set(struct inode *inode, void *data) 72351f7e52dSMiklos Szeredi { 72425b7713aSMiklos Szeredi inode->i_private = data; 72551f7e52dSMiklos Szeredi return 0; 72651f7e52dSMiklos Szeredi } 72751f7e52dSMiklos Szeredi 728b9ac5c27SMiklos Szeredi static bool ovl_verify_inode(struct inode *inode, struct dentry *lowerdentry, 7294b91c30aSAmir Goldstein struct dentry *upperdentry, bool strict) 730b9ac5c27SMiklos Szeredi { 7314b91c30aSAmir Goldstein /* 7324b91c30aSAmir Goldstein * For directories, @strict verify from lookup path performs consistency 7334b91c30aSAmir Goldstein * checks, so NULL lower/upper in dentry must match NULL lower/upper in 7344b91c30aSAmir Goldstein * inode. Non @strict verify from NFS handle decode path passes NULL for 7354b91c30aSAmir Goldstein * 'unknown' lower/upper. 7364b91c30aSAmir Goldstein */ 7374b91c30aSAmir Goldstein if (S_ISDIR(inode->i_mode) && strict) { 73831747edaSAmir Goldstein /* Real lower dir moved to upper layer under us? */ 73931747edaSAmir Goldstein if (!lowerdentry && ovl_inode_lower(inode)) 74031747edaSAmir Goldstein return false; 74131747edaSAmir Goldstein 74231747edaSAmir Goldstein /* Lookup of an uncovered redirect origin? */ 74331747edaSAmir Goldstein if (!upperdentry && ovl_inode_upper(inode)) 74431747edaSAmir Goldstein return false; 74531747edaSAmir Goldstein } 74631747edaSAmir Goldstein 747939ae4efSAmir Goldstein /* 748939ae4efSAmir Goldstein * Allow non-NULL lower inode in ovl_inode even if lowerdentry is NULL. 749939ae4efSAmir Goldstein * This happens when finding a copied up overlay inode for a renamed 750939ae4efSAmir Goldstein * or hardlinked overlay dentry and lower dentry cannot be followed 751939ae4efSAmir Goldstein * by origin because lower fs does not support file handles. 752939ae4efSAmir Goldstein */ 753939ae4efSAmir Goldstein if (lowerdentry && ovl_inode_lower(inode) != d_inode(lowerdentry)) 754b9ac5c27SMiklos Szeredi return false; 755b9ac5c27SMiklos Szeredi 756b9ac5c27SMiklos Szeredi /* 757b9ac5c27SMiklos Szeredi * Allow non-NULL __upperdentry in inode even if upperdentry is NULL. 758b9ac5c27SMiklos Szeredi * This happens when finding a lower alias for a copied up hard link. 759b9ac5c27SMiklos Szeredi */ 760b9ac5c27SMiklos Szeredi if (upperdentry && ovl_inode_upper(inode) != d_inode(upperdentry)) 761b9ac5c27SMiklos Szeredi return false; 762b9ac5c27SMiklos Szeredi 763b9ac5c27SMiklos Szeredi return true; 764b9ac5c27SMiklos Szeredi } 765b9ac5c27SMiklos Szeredi 7664b91c30aSAmir Goldstein struct inode *ovl_lookup_inode(struct super_block *sb, struct dentry *real, 7674b91c30aSAmir Goldstein bool is_upper) 7689436a1a3SAmir Goldstein { 7694b91c30aSAmir Goldstein struct inode *inode, *key = d_inode(real); 7709436a1a3SAmir Goldstein 7719436a1a3SAmir Goldstein inode = ilookup5(sb, (unsigned long) key, ovl_inode_test, key); 7729436a1a3SAmir Goldstein if (!inode) 7739436a1a3SAmir Goldstein return NULL; 7749436a1a3SAmir Goldstein 7754b91c30aSAmir Goldstein if (!ovl_verify_inode(inode, is_upper ? NULL : real, 7764b91c30aSAmir Goldstein is_upper ? real : NULL, false)) { 7779436a1a3SAmir Goldstein iput(inode); 7789436a1a3SAmir Goldstein return ERR_PTR(-ESTALE); 7799436a1a3SAmir Goldstein } 7809436a1a3SAmir Goldstein 7819436a1a3SAmir Goldstein return inode; 7829436a1a3SAmir Goldstein } 7839436a1a3SAmir Goldstein 784146d62e5SAmir Goldstein bool ovl_lookup_trap_inode(struct super_block *sb, struct dentry *dir) 785146d62e5SAmir Goldstein { 786146d62e5SAmir Goldstein struct inode *key = d_inode(dir); 787146d62e5SAmir Goldstein struct inode *trap; 788146d62e5SAmir Goldstein bool res; 789146d62e5SAmir Goldstein 790146d62e5SAmir Goldstein trap = ilookup5(sb, (unsigned long) key, ovl_inode_test, key); 791146d62e5SAmir Goldstein if (!trap) 792146d62e5SAmir Goldstein return false; 793146d62e5SAmir Goldstein 794146d62e5SAmir Goldstein res = IS_DEADDIR(trap) && !ovl_inode_upper(trap) && 795146d62e5SAmir Goldstein !ovl_inode_lower(trap); 796146d62e5SAmir Goldstein 797146d62e5SAmir Goldstein iput(trap); 798146d62e5SAmir Goldstein return res; 799146d62e5SAmir Goldstein } 800146d62e5SAmir Goldstein 801146d62e5SAmir Goldstein /* 802146d62e5SAmir Goldstein * Create an inode cache entry for layer root dir, that will intentionally 803146d62e5SAmir Goldstein * fail ovl_verify_inode(), so any lookup that will find some layer root 804146d62e5SAmir Goldstein * will fail. 805146d62e5SAmir Goldstein */ 806146d62e5SAmir Goldstein struct inode *ovl_get_trap_inode(struct super_block *sb, struct dentry *dir) 807146d62e5SAmir Goldstein { 808146d62e5SAmir Goldstein struct inode *key = d_inode(dir); 809146d62e5SAmir Goldstein struct inode *trap; 810146d62e5SAmir Goldstein 811146d62e5SAmir Goldstein if (!d_is_dir(dir)) 812146d62e5SAmir Goldstein return ERR_PTR(-ENOTDIR); 813146d62e5SAmir Goldstein 814146d62e5SAmir Goldstein trap = iget5_locked(sb, (unsigned long) key, ovl_inode_test, 815146d62e5SAmir Goldstein ovl_inode_set, key); 816146d62e5SAmir Goldstein if (!trap) 817146d62e5SAmir Goldstein return ERR_PTR(-ENOMEM); 818146d62e5SAmir Goldstein 819146d62e5SAmir Goldstein if (!(trap->i_state & I_NEW)) { 820146d62e5SAmir Goldstein /* Conflicting layer roots? */ 821146d62e5SAmir Goldstein iput(trap); 822146d62e5SAmir Goldstein return ERR_PTR(-ELOOP); 823146d62e5SAmir Goldstein } 824146d62e5SAmir Goldstein 825146d62e5SAmir Goldstein trap->i_mode = S_IFDIR; 826146d62e5SAmir Goldstein trap->i_flags = S_DEAD; 827146d62e5SAmir Goldstein unlock_new_inode(trap); 828146d62e5SAmir Goldstein 829146d62e5SAmir Goldstein return trap; 830146d62e5SAmir Goldstein } 831146d62e5SAmir Goldstein 832764baba8SAmir Goldstein /* 833764baba8SAmir Goldstein * Does overlay inode need to be hashed by lower inode? 834764baba8SAmir Goldstein */ 835764baba8SAmir Goldstein static bool ovl_hash_bylower(struct super_block *sb, struct dentry *upper, 836764baba8SAmir Goldstein struct dentry *lower, struct dentry *index) 837764baba8SAmir Goldstein { 838764baba8SAmir Goldstein struct ovl_fs *ofs = sb->s_fs_info; 839764baba8SAmir Goldstein 840764baba8SAmir Goldstein /* No, if pure upper */ 841764baba8SAmir Goldstein if (!lower) 842764baba8SAmir Goldstein return false; 843764baba8SAmir Goldstein 844764baba8SAmir Goldstein /* Yes, if already indexed */ 845764baba8SAmir Goldstein if (index) 846764baba8SAmir Goldstein return true; 847764baba8SAmir Goldstein 848764baba8SAmir Goldstein /* Yes, if won't be copied up */ 849764baba8SAmir Goldstein if (!ofs->upper_mnt) 850764baba8SAmir Goldstein return true; 851764baba8SAmir Goldstein 852764baba8SAmir Goldstein /* No, if lower hardlink is or will be broken on copy up */ 853764baba8SAmir Goldstein if ((upper || !ovl_indexdir(sb)) && 854764baba8SAmir Goldstein !d_is_dir(lower) && d_inode(lower)->i_nlink > 1) 855764baba8SAmir Goldstein return false; 856764baba8SAmir Goldstein 857764baba8SAmir Goldstein /* No, if non-indexed upper with NFS export */ 858764baba8SAmir Goldstein if (sb->s_export_op && upper) 859764baba8SAmir Goldstein return false; 860764baba8SAmir Goldstein 861764baba8SAmir Goldstein /* Otherwise, hash by lower inode for fsnotify */ 862764baba8SAmir Goldstein return true; 863764baba8SAmir Goldstein } 864764baba8SAmir Goldstein 86501b39dccSAmir Goldstein static struct inode *ovl_iget5(struct super_block *sb, struct inode *newinode, 86601b39dccSAmir Goldstein struct inode *key) 86701b39dccSAmir Goldstein { 86801b39dccSAmir Goldstein return newinode ? inode_insert5(newinode, (unsigned long) key, 86901b39dccSAmir Goldstein ovl_inode_test, ovl_inode_set, key) : 87001b39dccSAmir Goldstein iget5_locked(sb, (unsigned long) key, 87101b39dccSAmir Goldstein ovl_inode_test, ovl_inode_set, key); 87201b39dccSAmir Goldstein } 87301b39dccSAmir Goldstein 874ac6a52ebSVivek Goyal struct inode *ovl_get_inode(struct super_block *sb, 875ac6a52ebSVivek Goyal struct ovl_inode_params *oip) 87651f7e52dSMiklos Szeredi { 877ac6a52ebSVivek Goyal struct dentry *upperdentry = oip->upperdentry; 878ac6a52ebSVivek Goyal struct ovl_path *lowerpath = oip->lowerpath; 87909d8b586SMiklos Szeredi struct inode *realinode = upperdentry ? d_inode(upperdentry) : NULL; 88051f7e52dSMiklos Szeredi struct inode *inode; 88112574a9fSAmir Goldstein struct dentry *lowerdentry = lowerpath ? lowerpath->dentry : NULL; 882ac6a52ebSVivek Goyal bool bylower = ovl_hash_bylower(sb, upperdentry, lowerdentry, 883ac6a52ebSVivek Goyal oip->index); 884ac6a52ebSVivek Goyal int fsid = bylower ? oip->lowerpath->layer->fsid : 0; 8859d3dfea3SVivek Goyal bool is_dir, metacopy = false; 886695b46e7SAmir Goldstein unsigned long ino = 0; 887acf3062aSAmir Goldstein int err = oip->newinode ? -EEXIST : -ENOMEM; 8886eaf0111SAmir Goldstein 88909d8b586SMiklos Szeredi if (!realinode) 89009d8b586SMiklos Szeredi realinode = d_inode(lowerdentry); 89109d8b586SMiklos Szeredi 8926eaf0111SAmir Goldstein /* 893764baba8SAmir Goldstein * Copy up origin (lower) may exist for non-indexed upper, but we must 894764baba8SAmir Goldstein * not use lower as hash key if this is a broken hardlink. 8956eaf0111SAmir Goldstein */ 89631747edaSAmir Goldstein is_dir = S_ISDIR(realinode->i_mode); 897764baba8SAmir Goldstein if (upperdentry || bylower) { 898764baba8SAmir Goldstein struct inode *key = d_inode(bylower ? lowerdentry : 899764baba8SAmir Goldstein upperdentry); 90031747edaSAmir Goldstein unsigned int nlink = is_dir ? 1 : realinode->i_nlink; 901b9ac5c27SMiklos Szeredi 90201b39dccSAmir Goldstein inode = ovl_iget5(sb, oip->newinode, key); 90309d8b586SMiklos Szeredi if (!inode) 904027065b7SVivek Goyal goto out_err; 90509d8b586SMiklos Szeredi if (!(inode->i_state & I_NEW)) { 906b9ac5c27SMiklos Szeredi /* 907b9ac5c27SMiklos Szeredi * Verify that the underlying files stored in the inode 908b9ac5c27SMiklos Szeredi * match those in the dentry. 909b9ac5c27SMiklos Szeredi */ 9104b91c30aSAmir Goldstein if (!ovl_verify_inode(inode, lowerdentry, upperdentry, 9114b91c30aSAmir Goldstein true)) { 912b9ac5c27SMiklos Szeredi iput(inode); 913027065b7SVivek Goyal err = -ESTALE; 914027065b7SVivek Goyal goto out_err; 915b9ac5c27SMiklos Szeredi } 916b9ac5c27SMiklos Szeredi 91709d8b586SMiklos Szeredi dput(upperdentry); 9189cec54c8SVivek Goyal kfree(oip->redirect); 91909d8b586SMiklos Szeredi goto out; 92009d8b586SMiklos Szeredi } 921e9be9d5eSMiklos Szeredi 92231747edaSAmir Goldstein /* Recalculate nlink for non-dir due to indexing */ 92331747edaSAmir Goldstein if (!is_dir) 92431747edaSAmir Goldstein nlink = ovl_get_nlink(lowerdentry, upperdentry, nlink); 9255f8415d6SAmir Goldstein set_nlink(inode, nlink); 926695b46e7SAmir Goldstein ino = key->i_ino; 927e6d2ebddSMiklos Szeredi } else { 928764baba8SAmir Goldstein /* Lower hardlink that will be broken on copy up */ 9290aceb53eSAmir Goldstein inode = new_inode(sb); 930027065b7SVivek Goyal if (!inode) { 931027065b7SVivek Goyal err = -ENOMEM; 932027065b7SVivek Goyal goto out_err; 933027065b7SVivek Goyal } 934e6d2ebddSMiklos Szeredi } 93512574a9fSAmir Goldstein ovl_fill_inode(inode, realinode->i_mode, realinode->i_rdev, ino, fsid); 9362664bd08SVivek Goyal ovl_inode_init(inode, upperdentry, lowerdentry, oip->lowerdata); 93713c72075SMiklos Szeredi 93813c72075SMiklos Szeredi if (upperdentry && ovl_is_impuredir(upperdentry)) 93913c72075SMiklos Szeredi ovl_set_flag(OVL_IMPURE, inode); 94013c72075SMiklos Szeredi 941ac6a52ebSVivek Goyal if (oip->index) 9420471a9cdSVivek Goyal ovl_set_flag(OVL_INDEX, inode); 9430471a9cdSVivek Goyal 9449d3dfea3SVivek Goyal if (upperdentry) { 9459d3dfea3SVivek Goyal err = ovl_check_metacopy_xattr(upperdentry); 9469d3dfea3SVivek Goyal if (err < 0) 9479d3dfea3SVivek Goyal goto out_err; 9489d3dfea3SVivek Goyal metacopy = err; 9499d3dfea3SVivek Goyal if (!metacopy) 9509d3dfea3SVivek Goyal ovl_set_flag(OVL_UPPERDATA, inode); 9519d3dfea3SVivek Goyal } 9529d3dfea3SVivek Goyal 9539cec54c8SVivek Goyal OVL_I(inode)->redirect = oip->redirect; 9549cec54c8SVivek Goyal 955a00c2d59SVivek Goyal if (bylower) 956a00c2d59SVivek Goyal ovl_set_flag(OVL_CONST_INO, inode); 957a00c2d59SVivek Goyal 958b79e05aaSAmir Goldstein /* Check for non-merge dir that may have whiteouts */ 95931747edaSAmir Goldstein if (is_dir) { 960ac6a52ebSVivek Goyal if (((upperdentry && lowerdentry) || oip->numlower > 1) || 961b79e05aaSAmir Goldstein ovl_check_origin_xattr(upperdentry ?: lowerdentry)) { 962b79e05aaSAmir Goldstein ovl_set_flag(OVL_WHITEOUTS, inode); 963b79e05aaSAmir Goldstein } 964b79e05aaSAmir Goldstein } 965b79e05aaSAmir Goldstein 966e6d2ebddSMiklos Szeredi if (inode->i_state & I_NEW) 967e6d2ebddSMiklos Szeredi unlock_new_inode(inode); 968e6d2ebddSMiklos Szeredi out: 969e9be9d5eSMiklos Szeredi return inode; 970b9ac5c27SMiklos Szeredi 971027065b7SVivek Goyal out_err: 9721bd0a3aeSlijiazi pr_warn_ratelimited("failed to get inode (%i)\n", err); 973027065b7SVivek Goyal inode = ERR_PTR(err); 974b9ac5c27SMiklos Szeredi goto out; 975e9be9d5eSMiklos Szeredi } 976