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> 1310c5db28SChristoph Hellwig #include <linux/fiemap.h> 1466dbfabfSMiklos Szeredi #include <linux/fileattr.h> 1566dbfabfSMiklos Szeredi #include <linux/security.h> 16332f606bSMiklos Szeredi #include <linux/namei.h> 17*6c0a8bfbSChristian Brauner #include <linux/posix_acl.h> 18*6c0a8bfbSChristian Brauner #include <linux/posix_acl_xattr.h> 19e9be9d5eSMiklos Szeredi #include "overlayfs.h" 20e9be9d5eSMiklos Szeredi 21ba1e563cSChandan Rajendra 22549c7297SChristian Brauner int ovl_setattr(struct user_namespace *mnt_userns, struct dentry *dentry, 23549c7297SChristian Brauner struct iattr *attr) 24e9be9d5eSMiklos Szeredi { 25e9be9d5eSMiklos Szeredi int err; 26a15506eaSChristian Brauner struct ovl_fs *ofs = OVL_FS(dentry->d_sb); 27997336f2SVivek Goyal bool full_copy_up = false; 28e9be9d5eSMiklos Szeredi struct dentry *upperdentry; 291175b6b8SVivek Goyal const struct cred *old_cred; 30e9be9d5eSMiklos Szeredi 312f221d6fSChristian Brauner err = setattr_prepare(&init_user_ns, dentry, attr); 32cf9a6784SMiklos Szeredi if (err) 33cf9a6784SMiklos Szeredi return err; 34cf9a6784SMiklos Szeredi 35e9be9d5eSMiklos Szeredi err = ovl_want_write(dentry); 36e9be9d5eSMiklos Szeredi if (err) 37e9be9d5eSMiklos Szeredi goto out; 38e9be9d5eSMiklos Szeredi 395812160eSMiklos Szeredi if (attr->ia_valid & ATTR_SIZE) { 40997336f2SVivek Goyal /* Truncate should trigger data copy up as well */ 41997336f2SVivek Goyal full_copy_up = true; 425812160eSMiklos Szeredi } 435812160eSMiklos Szeredi 44997336f2SVivek Goyal if (!full_copy_up) 45acff81ecSMiklos Szeredi err = ovl_copy_up(dentry); 46997336f2SVivek Goyal else 47997336f2SVivek Goyal err = ovl_copy_up_with_data(dentry); 48acff81ecSMiklos Szeredi if (!err) { 495812160eSMiklos Szeredi struct inode *winode = NULL; 505812160eSMiklos Szeredi 51e9be9d5eSMiklos Szeredi upperdentry = ovl_dentry_upper(dentry); 52acff81ecSMiklos Szeredi 535812160eSMiklos Szeredi if (attr->ia_valid & ATTR_SIZE) { 545812160eSMiklos Szeredi winode = d_inode(upperdentry); 555812160eSMiklos Szeredi err = get_write_access(winode); 565812160eSMiklos Szeredi if (err) 575812160eSMiklos Szeredi goto out_drop_write; 585812160eSMiklos Szeredi } 595812160eSMiklos Szeredi 60b99c2d91SMiklos Szeredi if (attr->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID)) 61b99c2d91SMiklos Szeredi attr->ia_valid &= ~ATTR_MODE; 62b99c2d91SMiklos Szeredi 63e67f0216SVivek Goyal /* 6415fd2ea9SVivek Goyal * We might have to translate ovl file into real file object 6515fd2ea9SVivek Goyal * once use cases emerge. For now, simply don't let underlying 6615fd2ea9SVivek Goyal * filesystem rely on attr->ia_file 67e67f0216SVivek Goyal */ 68e67f0216SVivek Goyal attr->ia_valid &= ~ATTR_FILE; 69e67f0216SVivek Goyal 7015fd2ea9SVivek Goyal /* 7115fd2ea9SVivek Goyal * If open(O_TRUNC) is done, VFS calls ->setattr with ATTR_OPEN 7215fd2ea9SVivek Goyal * set. Overlayfs does not pass O_TRUNC flag to underlying 7315fd2ea9SVivek Goyal * filesystem during open -> do not pass ATTR_OPEN. This 7415fd2ea9SVivek Goyal * disables optimization in fuse which assumes open(O_TRUNC) 7515fd2ea9SVivek Goyal * already set file size to 0. But we never passed O_TRUNC to 7615fd2ea9SVivek Goyal * fuse. So by clearing ATTR_OPEN, fuse will be forced to send 7715fd2ea9SVivek Goyal * setattr request to server. 7815fd2ea9SVivek Goyal */ 7915fd2ea9SVivek Goyal attr->ia_valid &= ~ATTR_OPEN; 8015fd2ea9SVivek Goyal 815955102cSAl Viro inode_lock(upperdentry->d_inode); 821175b6b8SVivek Goyal old_cred = ovl_override_creds(dentry->d_sb); 83a15506eaSChristian Brauner err = ovl_do_notify_change(ofs, upperdentry, attr); 841175b6b8SVivek Goyal revert_creds(old_cred); 85b81de061SKonstantin Khlebnikov if (!err) 862878dffcSChristian Brauner ovl_copyattr(dentry->d_inode); 875955102cSAl Viro inode_unlock(upperdentry->d_inode); 885812160eSMiklos Szeredi 895812160eSMiklos Szeredi if (winode) 905812160eSMiklos Szeredi put_write_access(winode); 91e9be9d5eSMiklos Szeredi } 925812160eSMiklos Szeredi out_drop_write: 93e9be9d5eSMiklos Szeredi ovl_drop_write(dentry); 94e9be9d5eSMiklos Szeredi out: 95e9be9d5eSMiklos Szeredi return err; 96e9be9d5eSMiklos Szeredi } 97e9be9d5eSMiklos Szeredi 98c68e7ec5Syoungjun static void ovl_map_dev_ino(struct dentry *dentry, struct kstat *stat, int fsid) 99da309e8cSAmir Goldstein { 1000f831ec8SAmir Goldstein bool samefs = ovl_same_fs(dentry->d_sb); 101e487d889SAmir Goldstein unsigned int xinobits = ovl_xino_bits(dentry->d_sb); 102dfe51d47SAmir Goldstein unsigned int xinoshift = 64 - xinobits; 103da309e8cSAmir Goldstein 104da309e8cSAmir Goldstein if (samefs) { 105da309e8cSAmir Goldstein /* 106da309e8cSAmir Goldstein * When all layers are on the same fs, all real inode 107da309e8cSAmir Goldstein * number are unique, so we use the overlay st_dev, 108da309e8cSAmir Goldstein * which is friendly to du -x. 109da309e8cSAmir Goldstein */ 110da309e8cSAmir Goldstein stat->dev = dentry->d_sb->s_dev; 111c68e7ec5Syoungjun return; 112e487d889SAmir Goldstein } else if (xinobits) { 113e487d889SAmir Goldstein /* 114e487d889SAmir Goldstein * All inode numbers of underlying fs should not be using the 115e487d889SAmir Goldstein * high xinobits, so we use high xinobits to partition the 116e487d889SAmir Goldstein * overlay st_ino address space. The high bits holds the fsid 117dfe51d47SAmir Goldstein * (upper fsid is 0). The lowest xinobit is reserved for mapping 118f48bbfb2SBhaskar Chowdhury * the non-persistent inode numbers range in case of overflow. 119dfe51d47SAmir Goldstein * This way all overlay inode numbers are unique and use the 120dfe51d47SAmir Goldstein * overlay st_dev. 121e487d889SAmir Goldstein */ 122926e94d7SAmir Goldstein if (likely(!(stat->ino >> xinoshift))) { 123dfe51d47SAmir Goldstein stat->ino |= ((u64)fsid) << (xinoshift + 1); 124e487d889SAmir Goldstein stat->dev = dentry->d_sb->s_dev; 125c68e7ec5Syoungjun return; 126926e94d7SAmir Goldstein } else if (ovl_xino_warn(dentry->d_sb)) { 127926e94d7SAmir Goldstein pr_warn_ratelimited("inode number too big (%pd2, ino=%llu, xinobits=%d)\n", 128926e94d7SAmir Goldstein dentry, stat->ino, xinobits); 129e487d889SAmir Goldstein } 130e487d889SAmir Goldstein } 131e487d889SAmir Goldstein 132e487d889SAmir Goldstein /* The inode could not be mapped to a unified st_ino address space */ 133e487d889SAmir Goldstein if (S_ISDIR(dentry->d_inode->i_mode)) { 134da309e8cSAmir Goldstein /* 135da309e8cSAmir Goldstein * Always use the overlay st_dev for directories, so 'find 136da309e8cSAmir Goldstein * -xdev' will scan the entire overlay mount and won't cross the 137da309e8cSAmir Goldstein * overlay mount boundaries. 138da309e8cSAmir Goldstein * 139da309e8cSAmir Goldstein * If not all layers are on the same fs the pair {real st_ino; 140da309e8cSAmir Goldstein * overlay st_dev} is not unique, so use the non persistent 141da309e8cSAmir Goldstein * overlay st_ino for directories. 142da309e8cSAmir Goldstein */ 143da309e8cSAmir Goldstein stat->dev = dentry->d_sb->s_dev; 144da309e8cSAmir Goldstein stat->ino = dentry->d_inode->i_ino; 145b7bf9908SAmir Goldstein } else { 146da309e8cSAmir Goldstein /* 147da309e8cSAmir Goldstein * For non-samefs setup, if we cannot map all layers st_ino 148da309e8cSAmir Goldstein * to a unified address space, we need to make sure that st_dev 149b7bf9908SAmir Goldstein * is unique per underlying fs, so we use the unique anonymous 150b7bf9908SAmir Goldstein * bdev assigned to the underlying fs. 151da309e8cSAmir Goldstein */ 15207f1e596SAmir Goldstein stat->dev = OVL_FS(dentry->d_sb)->fs[fsid].pseudo_dev; 153da309e8cSAmir Goldstein } 154da309e8cSAmir Goldstein } 155da309e8cSAmir Goldstein 156549c7297SChristian Brauner int ovl_getattr(struct user_namespace *mnt_userns, const struct path *path, 157549c7297SChristian Brauner struct kstat *stat, u32 request_mask, unsigned int flags) 158e9be9d5eSMiklos Szeredi { 159a528d35eSDavid Howells struct dentry *dentry = path->dentry; 16072b608f0SAmir Goldstein enum ovl_path_type type; 161e9be9d5eSMiklos Szeredi struct path realpath; 1621175b6b8SVivek Goyal const struct cred *old_cred; 163096a218aSAmir Goldstein struct inode *inode = d_inode(dentry); 164096a218aSAmir Goldstein bool is_dir = S_ISDIR(inode->i_mode); 16507f1e596SAmir Goldstein int fsid = 0; 1661175b6b8SVivek Goyal int err; 16767d756c2SVivek Goyal bool metacopy_blocks = false; 16867d756c2SVivek Goyal 16967d756c2SVivek Goyal metacopy_blocks = ovl_is_metacopy_dentry(dentry); 170e9be9d5eSMiklos Szeredi 17172b608f0SAmir Goldstein type = ovl_path_real(dentry, &realpath); 1721175b6b8SVivek Goyal old_cred = ovl_override_creds(dentry->d_sb); 173a528d35eSDavid Howells err = vfs_getattr(&realpath, stat, request_mask, flags); 17472b608f0SAmir Goldstein if (err) 17572b608f0SAmir Goldstein goto out; 17672b608f0SAmir Goldstein 177096a218aSAmir Goldstein /* Report the effective immutable/append-only STATX flags */ 178096a218aSAmir Goldstein generic_fill_statx_attr(inode, stat); 179096a218aSAmir Goldstein 18072b608f0SAmir Goldstein /* 181da309e8cSAmir Goldstein * For non-dir or same fs, we use st_ino of the copy up origin. 182da309e8cSAmir Goldstein * This guaranties constant st_dev/st_ino across copy up. 183e487d889SAmir Goldstein * With xino feature and non-samefs, we use st_ino of the copy up 184e487d889SAmir Goldstein * origin masked with high bits that represent the layer id. 18572b608f0SAmir Goldstein * 186da309e8cSAmir Goldstein * If lower filesystem supports NFS file handles, this also guaranties 18772b608f0SAmir Goldstein * persistent st_ino across mount cycle. 18872b608f0SAmir Goldstein */ 1890f831ec8SAmir Goldstein if (!is_dir || ovl_same_dev(dentry->d_sb)) { 190da309e8cSAmir Goldstein if (!OVL_TYPE_UPPER(type)) { 19107f1e596SAmir Goldstein fsid = ovl_layer_lower(dentry)->fsid; 192da309e8cSAmir Goldstein } else if (OVL_TYPE_ORIGIN(type)) { 19372b608f0SAmir Goldstein struct kstat lowerstat; 19467d756c2SVivek Goyal u32 lowermask = STATX_INO | STATX_BLOCKS | 19567d756c2SVivek Goyal (!is_dir ? STATX_NLINK : 0); 19672b608f0SAmir Goldstein 19772b608f0SAmir Goldstein ovl_path_lower(dentry, &realpath); 19872b608f0SAmir Goldstein err = vfs_getattr(&realpath, &lowerstat, 1995b712091SMiklos Szeredi lowermask, flags); 20072b608f0SAmir Goldstein if (err) 20172b608f0SAmir Goldstein goto out; 20272b608f0SAmir Goldstein 20372b608f0SAmir Goldstein /* 204359f392cSAmir Goldstein * Lower hardlinks may be broken on copy up to different 20572b608f0SAmir Goldstein * upper files, so we cannot use the lower origin st_ino 20672b608f0SAmir Goldstein * for those different files, even for the same fs case. 20786eaa130SAmir Goldstein * 20886eaa130SAmir Goldstein * Similarly, several redirected dirs can point to the 20986eaa130SAmir Goldstein * same dir on a lower layer. With the "verify_lower" 21086eaa130SAmir Goldstein * feature, we do not use the lower origin st_ino, if 21186eaa130SAmir Goldstein * we haven't verified that this redirect is unique. 21286eaa130SAmir Goldstein * 213359f392cSAmir Goldstein * With inodes index enabled, it is safe to use st_ino 21486eaa130SAmir Goldstein * of an indexed origin. The index validates that the 21586eaa130SAmir Goldstein * upper hardlink is not broken and that a redirected 21686eaa130SAmir Goldstein * dir is the only redirect to that origin. 21772b608f0SAmir Goldstein */ 21886eaa130SAmir Goldstein if (ovl_test_flag(OVL_INDEX, d_inode(dentry)) || 21986eaa130SAmir Goldstein (!ovl_verify_lower(dentry->d_sb) && 2209f99e50dSAmir Goldstein (is_dir || lowerstat.nlink == 1))) { 22107f1e596SAmir Goldstein fsid = ovl_layer_lower(dentry)->fsid; 2229c6d8f13SAmir Goldstein stat->ino = lowerstat.ino; 22372b608f0SAmir Goldstein } 22467d756c2SVivek Goyal 22567d756c2SVivek Goyal /* 22667d756c2SVivek Goyal * If we are querying a metacopy dentry and lower 22767d756c2SVivek Goyal * dentry is data dentry, then use the blocks we 22867d756c2SVivek Goyal * queried just now. We don't have to do additional 22967d756c2SVivek Goyal * vfs_getattr(). If lower itself is metacopy, then 23067d756c2SVivek Goyal * additional vfs_getattr() is unavoidable. 23167d756c2SVivek Goyal */ 23267d756c2SVivek Goyal if (metacopy_blocks && 23367d756c2SVivek Goyal realpath.dentry == ovl_dentry_lowerdata(dentry)) { 23467d756c2SVivek Goyal stat->blocks = lowerstat.blocks; 23567d756c2SVivek Goyal metacopy_blocks = false; 23667d756c2SVivek Goyal } 23767d756c2SVivek Goyal } 23867d756c2SVivek Goyal 23967d756c2SVivek Goyal if (metacopy_blocks) { 24067d756c2SVivek Goyal /* 24167d756c2SVivek Goyal * If lower is not same as lowerdata or if there was 24267d756c2SVivek Goyal * no origin on upper, we can end up here. 24367d756c2SVivek Goyal */ 24467d756c2SVivek Goyal struct kstat lowerdatastat; 24567d756c2SVivek Goyal u32 lowermask = STATX_BLOCKS; 24667d756c2SVivek Goyal 24767d756c2SVivek Goyal ovl_path_lowerdata(dentry, &realpath); 24867d756c2SVivek Goyal err = vfs_getattr(&realpath, &lowerdatastat, 24967d756c2SVivek Goyal lowermask, flags); 25067d756c2SVivek Goyal if (err) 25167d756c2SVivek Goyal goto out; 25267d756c2SVivek Goyal stat->blocks = lowerdatastat.blocks; 2539f99e50dSAmir Goldstein } 254a0c5ad30SAmir Goldstein } 255da309e8cSAmir Goldstein 256c68e7ec5Syoungjun ovl_map_dev_ino(dentry, stat, fsid); 2575b712091SMiklos Szeredi 2585b712091SMiklos Szeredi /* 2595b712091SMiklos Szeredi * It's probably not worth it to count subdirs to get the 2605b712091SMiklos Szeredi * correct link count. nlink=1 seems to pacify 'find' and 2615b712091SMiklos Szeredi * other utilities. 2625b712091SMiklos Szeredi */ 2635b712091SMiklos Szeredi if (is_dir && OVL_TYPE_MERGE(type)) 2645b712091SMiklos Szeredi stat->nlink = 1; 2655b712091SMiklos Szeredi 2665f8415d6SAmir Goldstein /* 2675f8415d6SAmir Goldstein * Return the overlay inode nlinks for indexed upper inodes. 2685f8415d6SAmir Goldstein * Overlay inode nlink counts the union of the upper hardlinks 2695f8415d6SAmir Goldstein * and non-covered lower hardlinks. It does not include the upper 2705f8415d6SAmir Goldstein * index hardlink. 2715f8415d6SAmir Goldstein */ 2725f8415d6SAmir Goldstein if (!is_dir && ovl_test_flag(OVL_INDEX, d_inode(dentry))) 2735f8415d6SAmir Goldstein stat->nlink = dentry->d_inode->i_nlink; 2745f8415d6SAmir Goldstein 27572b608f0SAmir Goldstein out: 2761175b6b8SVivek Goyal revert_creds(old_cred); 27772b608f0SAmir Goldstein 2781175b6b8SVivek Goyal return err; 279e9be9d5eSMiklos Szeredi } 280e9be9d5eSMiklos Szeredi 281549c7297SChristian Brauner int ovl_permission(struct user_namespace *mnt_userns, 282549c7297SChristian Brauner struct inode *inode, int mask) 283e9be9d5eSMiklos Szeredi { 28409d8b586SMiklos Szeredi struct inode *upperinode = ovl_inode_upper(inode); 2854b7791b2SChristian Brauner struct inode *realinode; 2864b7791b2SChristian Brauner struct path realpath; 287c0ca3d70SVivek Goyal const struct cred *old_cred; 288e9be9d5eSMiklos Szeredi int err; 289e9be9d5eSMiklos Szeredi 290e9be9d5eSMiklos Szeredi /* Careful in RCU walk mode */ 2914b7791b2SChristian Brauner ovl_i_path_real(inode, &realpath); 2924b7791b2SChristian Brauner if (!realpath.dentry) { 293e9be9d5eSMiklos Szeredi WARN_ON(!(mask & MAY_NOT_BLOCK)); 294a999d7e1SMiklos Szeredi return -ECHILD; 295e9be9d5eSMiklos Szeredi } 296e9be9d5eSMiklos Szeredi 297c0ca3d70SVivek Goyal /* 298c0ca3d70SVivek Goyal * Check overlay inode with the creds of task and underlying inode 299c0ca3d70SVivek Goyal * with creds of mounter 300c0ca3d70SVivek Goyal */ 30147291baaSChristian Brauner err = generic_permission(&init_user_ns, inode, mask); 302c0ca3d70SVivek Goyal if (err) 303c0ca3d70SVivek Goyal return err; 304c0ca3d70SVivek Goyal 3054b7791b2SChristian Brauner realinode = d_inode(realpath.dentry); 306ec7ba118SMiklos Szeredi old_cred = ovl_override_creds(inode->i_sb); 307ec7ba118SMiklos Szeredi if (!upperinode && 308ec7ba118SMiklos Szeredi !special_file(realinode->i_mode) && mask & MAY_WRITE) { 309754f8cb7SVivek Goyal mask &= ~(MAY_WRITE | MAY_APPEND); 310ec7ba118SMiklos Szeredi /* Make sure mounter can read file for copy up later */ 311500cac3cSVivek Goyal mask |= MAY_READ; 312500cac3cSVivek Goyal } 3134b7791b2SChristian Brauner err = inode_permission(mnt_user_ns(realpath.mnt), realinode, mask); 314c0ca3d70SVivek Goyal revert_creds(old_cred); 315c0ca3d70SVivek Goyal 316c0ca3d70SVivek Goyal return err; 317e9be9d5eSMiklos Szeredi } 318e9be9d5eSMiklos Szeredi 3196b255391SAl Viro static const char *ovl_get_link(struct dentry *dentry, 320fceef393SAl Viro struct inode *inode, 321fceef393SAl Viro struct delayed_call *done) 322e9be9d5eSMiklos Szeredi { 3231175b6b8SVivek Goyal const struct cred *old_cred; 3241175b6b8SVivek Goyal const char *p; 325e9be9d5eSMiklos Szeredi 3266b255391SAl Viro if (!dentry) 3276b255391SAl Viro return ERR_PTR(-ECHILD); 3286b255391SAl Viro 3291175b6b8SVivek Goyal old_cred = ovl_override_creds(dentry->d_sb); 3307764235bSMiklos Szeredi p = vfs_get_link(ovl_dentry_real(dentry), done); 3311175b6b8SVivek Goyal revert_creds(old_cred); 3321175b6b8SVivek Goyal return p; 333e9be9d5eSMiklos Szeredi } 334e9be9d5eSMiklos Szeredi 335610afc0bSMiklos Szeredi bool ovl_is_private_xattr(struct super_block *sb, const char *name) 336e9be9d5eSMiklos Szeredi { 3372d2f2d73SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 3382d2f2d73SMiklos Szeredi 3392d2f2d73SMiklos Szeredi if (ofs->config.userxattr) 3402d2f2d73SMiklos Szeredi return strncmp(name, OVL_XATTR_USER_PREFIX, 3412d2f2d73SMiklos Szeredi sizeof(OVL_XATTR_USER_PREFIX) - 1) == 0; 3422d2f2d73SMiklos Szeredi else 3432d2f2d73SMiklos Szeredi return strncmp(name, OVL_XATTR_TRUSTED_PREFIX, 3442d2f2d73SMiklos Szeredi sizeof(OVL_XATTR_TRUSTED_PREFIX) - 1) == 0; 345e9be9d5eSMiklos Szeredi } 346e9be9d5eSMiklos Szeredi 3471d88f183SMiklos Szeredi int ovl_xattr_set(struct dentry *dentry, struct inode *inode, const char *name, 3481d88f183SMiklos Szeredi const void *value, size_t size, int flags) 349e9be9d5eSMiklos Szeredi { 350e9be9d5eSMiklos Szeredi int err; 351c914c0e2SAmir Goldstein struct ovl_fs *ofs = OVL_FS(dentry->d_sb); 3521d88f183SMiklos Szeredi struct dentry *upperdentry = ovl_i_dentry_upper(inode); 3531d88f183SMiklos Szeredi struct dentry *realdentry = upperdentry ?: ovl_dentry_lower(dentry); 3548bc0095dSChristian Brauner struct path realpath; 3551175b6b8SVivek Goyal const struct cred *old_cred; 356e9be9d5eSMiklos Szeredi 357e9be9d5eSMiklos Szeredi err = ovl_want_write(dentry); 358e9be9d5eSMiklos Szeredi if (err) 359e9be9d5eSMiklos Szeredi goto out; 360e9be9d5eSMiklos Szeredi 3611d88f183SMiklos Szeredi if (!value && !upperdentry) { 3628bc0095dSChristian Brauner ovl_path_lower(dentry, &realpath); 363554677b9SMiklos Szeredi old_cred = ovl_override_creds(dentry->d_sb); 3648bc0095dSChristian Brauner err = vfs_getxattr(mnt_user_ns(realpath.mnt), realdentry, name, NULL, 0); 365554677b9SMiklos Szeredi revert_creds(old_cred); 3660e585cccSAndreas Gruenbacher if (err < 0) 3670e585cccSAndreas Gruenbacher goto out_drop_write; 3680e585cccSAndreas Gruenbacher } 3690e585cccSAndreas Gruenbacher 3701d88f183SMiklos Szeredi if (!upperdentry) { 371e9be9d5eSMiklos Szeredi err = ovl_copy_up(dentry); 372e9be9d5eSMiklos Szeredi if (err) 373e9be9d5eSMiklos Szeredi goto out_drop_write; 374e9be9d5eSMiklos Szeredi 3751d88f183SMiklos Szeredi realdentry = ovl_dentry_upper(dentry); 3761d88f183SMiklos Szeredi } 3770e585cccSAndreas Gruenbacher 3781175b6b8SVivek Goyal old_cred = ovl_override_creds(dentry->d_sb); 379c914c0e2SAmir Goldstein if (value) { 380c914c0e2SAmir Goldstein err = ovl_do_setxattr(ofs, realdentry, name, value, size, 381c7c7a1a1STycho Andersen flags); 382c914c0e2SAmir Goldstein } else { 3830e585cccSAndreas Gruenbacher WARN_ON(flags != XATTR_REPLACE); 384c914c0e2SAmir Goldstein err = ovl_do_removexattr(ofs, realdentry, name); 3850e585cccSAndreas Gruenbacher } 3861175b6b8SVivek Goyal revert_creds(old_cred); 387e9be9d5eSMiklos Szeredi 388d9854c87SMiklos Szeredi /* copy c/mtime */ 3892878dffcSChristian Brauner ovl_copyattr(inode); 390d9854c87SMiklos Szeredi 391e9be9d5eSMiklos Szeredi out_drop_write: 392e9be9d5eSMiklos Szeredi ovl_drop_write(dentry); 393e9be9d5eSMiklos Szeredi out: 394e9be9d5eSMiklos Szeredi return err; 395e9be9d5eSMiklos Szeredi } 396e9be9d5eSMiklos Szeredi 3971d88f183SMiklos Szeredi int ovl_xattr_get(struct dentry *dentry, struct inode *inode, const char *name, 3980eb45fc3SAndreas Gruenbacher void *value, size_t size) 399e9be9d5eSMiklos Szeredi { 4001175b6b8SVivek Goyal ssize_t res; 4011175b6b8SVivek Goyal const struct cred *old_cred; 4028bc0095dSChristian Brauner struct path realpath; 40352148463SMiklos Szeredi 4048bc0095dSChristian Brauner ovl_i_path_real(inode, &realpath); 4051175b6b8SVivek Goyal old_cred = ovl_override_creds(dentry->d_sb); 4068bc0095dSChristian Brauner res = vfs_getxattr(mnt_user_ns(realpath.mnt), realpath.dentry, name, value, size); 4071175b6b8SVivek Goyal revert_creds(old_cred); 4081175b6b8SVivek Goyal return res; 409e9be9d5eSMiklos Szeredi } 410e9be9d5eSMiklos Szeredi 411610afc0bSMiklos Szeredi static bool ovl_can_list(struct super_block *sb, const char *s) 412a082c6f6SMiklos Szeredi { 4138f6ee74cSMiklos Szeredi /* Never list private (.overlay) */ 4148f6ee74cSMiklos Szeredi if (ovl_is_private_xattr(sb, s)) 4158f6ee74cSMiklos Szeredi return false; 4168f6ee74cSMiklos Szeredi 417f48bbfb2SBhaskar Chowdhury /* List all non-trusted xattrs */ 418a082c6f6SMiklos Szeredi if (strncmp(s, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) != 0) 419a082c6f6SMiklos Szeredi return true; 420a082c6f6SMiklos Szeredi 4218f6ee74cSMiklos Szeredi /* list other trusted for superuser only */ 4228f6ee74cSMiklos Szeredi return ns_capable_noaudit(&init_user_ns, CAP_SYS_ADMIN); 423a082c6f6SMiklos Szeredi } 424a082c6f6SMiklos Szeredi 425e9be9d5eSMiklos Szeredi ssize_t ovl_listxattr(struct dentry *dentry, char *list, size_t size) 426e9be9d5eSMiklos Szeredi { 427b581755bSMiklos Szeredi struct dentry *realdentry = ovl_dentry_real(dentry); 428e9be9d5eSMiklos Szeredi ssize_t res; 4297cb35119SMiklos Szeredi size_t len; 4307cb35119SMiklos Szeredi char *s; 4311175b6b8SVivek Goyal const struct cred *old_cred; 432e9be9d5eSMiklos Szeredi 4331175b6b8SVivek Goyal old_cred = ovl_override_creds(dentry->d_sb); 434b581755bSMiklos Szeredi res = vfs_listxattr(realdentry, list, size); 4351175b6b8SVivek Goyal revert_creds(old_cred); 436e9be9d5eSMiklos Szeredi if (res <= 0 || size == 0) 437e9be9d5eSMiklos Szeredi return res; 438e9be9d5eSMiklos Szeredi 439e9be9d5eSMiklos Szeredi /* filter out private xattrs */ 4407cb35119SMiklos Szeredi for (s = list, len = res; len;) { 4417cb35119SMiklos Szeredi size_t slen = strnlen(s, len) + 1; 442e9be9d5eSMiklos Szeredi 4437cb35119SMiklos Szeredi /* underlying fs providing us with an broken xattr list? */ 4447cb35119SMiklos Szeredi if (WARN_ON(slen > len)) 4457cb35119SMiklos Szeredi return -EIO; 446e9be9d5eSMiklos Szeredi 4477cb35119SMiklos Szeredi len -= slen; 448610afc0bSMiklos Szeredi if (!ovl_can_list(dentry->d_sb, s)) { 449e9be9d5eSMiklos Szeredi res -= slen; 4507cb35119SMiklos Szeredi memmove(s, s + slen, len); 451e9be9d5eSMiklos Szeredi } else { 4527cb35119SMiklos Szeredi s += slen; 453e9be9d5eSMiklos Szeredi } 454e9be9d5eSMiklos Szeredi } 455e9be9d5eSMiklos Szeredi 456e9be9d5eSMiklos Szeredi return res; 457e9be9d5eSMiklos Szeredi } 458e9be9d5eSMiklos Szeredi 459ded53656SYang Xu #ifdef CONFIG_FS_POSIX_ACL 4601aa5fef5SChristian Brauner /* 4611aa5fef5SChristian Brauner * Apply the idmapping of the layer to POSIX ACLs. The caller must pass a clone 4621aa5fef5SChristian Brauner * of the POSIX ACLs retrieved from the lower layer to this function to not 4631aa5fef5SChristian Brauner * alter the POSIX ACLs for the underlying filesystem. 4641aa5fef5SChristian Brauner */ 465*6c0a8bfbSChristian Brauner static void ovl_idmap_posix_acl(const struct inode *realinode, 466abfcf55dSChristian Brauner struct user_namespace *mnt_userns, 4671aa5fef5SChristian Brauner struct posix_acl *acl) 4681aa5fef5SChristian Brauner { 469abfcf55dSChristian Brauner struct user_namespace *fs_userns = i_user_ns(realinode); 470abfcf55dSChristian Brauner 4711aa5fef5SChristian Brauner for (unsigned int i = 0; i < acl->a_count; i++) { 4721aa5fef5SChristian Brauner vfsuid_t vfsuid; 4731aa5fef5SChristian Brauner vfsgid_t vfsgid; 4741aa5fef5SChristian Brauner 4751aa5fef5SChristian Brauner struct posix_acl_entry *e = &acl->a_entries[i]; 4761aa5fef5SChristian Brauner switch (e->e_tag) { 4771aa5fef5SChristian Brauner case ACL_USER: 478abfcf55dSChristian Brauner vfsuid = make_vfsuid(mnt_userns, fs_userns, e->e_uid); 4791aa5fef5SChristian Brauner e->e_uid = vfsuid_into_kuid(vfsuid); 4801aa5fef5SChristian Brauner break; 4811aa5fef5SChristian Brauner case ACL_GROUP: 482abfcf55dSChristian Brauner vfsgid = make_vfsgid(mnt_userns, fs_userns, e->e_gid); 4831aa5fef5SChristian Brauner e->e_gid = vfsgid_into_kgid(vfsgid); 4841aa5fef5SChristian Brauner break; 4851aa5fef5SChristian Brauner } 4861aa5fef5SChristian Brauner } 4871aa5fef5SChristian Brauner } 4881aa5fef5SChristian Brauner 4891aa5fef5SChristian Brauner /* 490*6c0a8bfbSChristian Brauner * The @noperm argument is used to skip permission checking and is a temporary 491*6c0a8bfbSChristian Brauner * measure. Quoting Miklos from an earlier discussion: 492*6c0a8bfbSChristian Brauner * 493*6c0a8bfbSChristian Brauner * > So there are two paths to getting an acl: 494*6c0a8bfbSChristian Brauner * > 1) permission checking and 2) retrieving the value via getxattr(2). 495*6c0a8bfbSChristian Brauner * > This is a similar situation as reading a symlink vs. following it. 496*6c0a8bfbSChristian Brauner * > When following a symlink overlayfs always reads the link on the 497*6c0a8bfbSChristian Brauner * > underlying fs just as if it was a readlink(2) call, calling 498*6c0a8bfbSChristian Brauner * > security_inode_readlink() instead of security_inode_follow_link(). 499*6c0a8bfbSChristian Brauner * > This is logical: we are reading the link from the underlying storage, 500*6c0a8bfbSChristian Brauner * > and following it on overlayfs. 501*6c0a8bfbSChristian Brauner * > 502*6c0a8bfbSChristian Brauner * > Applying the same logic to acl: we do need to call the 503*6c0a8bfbSChristian Brauner * > security_inode_getxattr() on the underlying fs, even if just want to 504*6c0a8bfbSChristian Brauner * > check permissions on overlay. This is currently not done, which is an 505*6c0a8bfbSChristian Brauner * > inconsistency. 506*6c0a8bfbSChristian Brauner * > 507*6c0a8bfbSChristian Brauner * > Maybe adding the check to ovl_get_acl() is the right way to go, but 508*6c0a8bfbSChristian Brauner * > I'm a little afraid of a performance regression. Will look into that. 509*6c0a8bfbSChristian Brauner * 510*6c0a8bfbSChristian Brauner * Until we have made a decision allow this helper to take the @noperm 511*6c0a8bfbSChristian Brauner * argument. We should hopefully be able to remove it soon. 512*6c0a8bfbSChristian Brauner */ 513*6c0a8bfbSChristian Brauner static struct posix_acl *ovl_get_acl_path(const struct path *path, 514*6c0a8bfbSChristian Brauner const char *acl_name, bool noperm) 515*6c0a8bfbSChristian Brauner { 516*6c0a8bfbSChristian Brauner struct posix_acl *real_acl, *clone; 517*6c0a8bfbSChristian Brauner struct user_namespace *mnt_userns; 518*6c0a8bfbSChristian Brauner struct inode *realinode = d_inode(path->dentry); 519*6c0a8bfbSChristian Brauner 520*6c0a8bfbSChristian Brauner mnt_userns = mnt_user_ns(path->mnt); 521*6c0a8bfbSChristian Brauner 522*6c0a8bfbSChristian Brauner if (noperm) 523*6c0a8bfbSChristian Brauner real_acl = get_inode_acl(realinode, posix_acl_type(acl_name)); 524*6c0a8bfbSChristian Brauner else 525*6c0a8bfbSChristian Brauner real_acl = vfs_get_acl(mnt_userns, path->dentry, acl_name); 526*6c0a8bfbSChristian Brauner if (IS_ERR_OR_NULL(real_acl)) 527*6c0a8bfbSChristian Brauner return real_acl; 528*6c0a8bfbSChristian Brauner 529*6c0a8bfbSChristian Brauner if (!is_idmapped_mnt(path->mnt)) 530*6c0a8bfbSChristian Brauner return real_acl; 531*6c0a8bfbSChristian Brauner 532*6c0a8bfbSChristian Brauner /* 533*6c0a8bfbSChristian Brauner * We cannot alter the ACLs returned from the relevant layer as that 534*6c0a8bfbSChristian Brauner * would alter the cached values filesystem wide for the lower 535*6c0a8bfbSChristian Brauner * filesystem. Instead we can clone the ACLs and then apply the 536*6c0a8bfbSChristian Brauner * relevant idmapping of the layer. 537*6c0a8bfbSChristian Brauner */ 538*6c0a8bfbSChristian Brauner clone = posix_acl_clone(real_acl, GFP_KERNEL); 539*6c0a8bfbSChristian Brauner posix_acl_release(real_acl); /* release original acl */ 540*6c0a8bfbSChristian Brauner if (!clone) 541*6c0a8bfbSChristian Brauner return ERR_PTR(-ENOMEM); 542*6c0a8bfbSChristian Brauner 543*6c0a8bfbSChristian Brauner ovl_idmap_posix_acl(realinode, mnt_userns, clone); 544*6c0a8bfbSChristian Brauner return clone; 545*6c0a8bfbSChristian Brauner } 546*6c0a8bfbSChristian Brauner 547*6c0a8bfbSChristian Brauner /* 5481aa5fef5SChristian Brauner * When the relevant layer is an idmapped mount we need to take the idmapping 5491aa5fef5SChristian Brauner * of the layer into account and translate any ACL_{GROUP,USER} values 5501aa5fef5SChristian Brauner * according to the idmapped mount. 5511aa5fef5SChristian Brauner * 5521aa5fef5SChristian Brauner * We cannot alter the ACLs returned from the relevant layer as that would 5531aa5fef5SChristian Brauner * alter the cached values filesystem wide for the lower filesystem. Instead we 5541aa5fef5SChristian Brauner * can clone the ACLs and then apply the relevant idmapping of the layer. 5551aa5fef5SChristian Brauner * 5561aa5fef5SChristian Brauner * This is obviously only relevant when idmapped layers are used. 5571aa5fef5SChristian Brauner */ 558*6c0a8bfbSChristian Brauner struct posix_acl *do_ovl_get_acl(struct user_namespace *mnt_userns, 559*6c0a8bfbSChristian Brauner struct inode *inode, int type, 560*6c0a8bfbSChristian Brauner bool rcu, bool noperm) 56139a25b2bSVivek Goyal { 56209d8b586SMiklos Szeredi struct inode *realinode = ovl_inode_real(inode); 563*6c0a8bfbSChristian Brauner struct posix_acl *acl; 5641aa5fef5SChristian Brauner struct path realpath; 56539a25b2bSVivek Goyal 566ded53656SYang Xu if (!IS_POSIXACL(realinode)) 56739a25b2bSVivek Goyal return NULL; 56839a25b2bSVivek Goyal 5691aa5fef5SChristian Brauner /* Careful in RCU walk mode */ 5701aa5fef5SChristian Brauner ovl_i_path_real(inode, &realpath); 5711aa5fef5SChristian Brauner if (!realpath.dentry) { 5721aa5fef5SChristian Brauner WARN_ON(!rcu); 5731aa5fef5SChristian Brauner return ERR_PTR(-ECHILD); 5741aa5fef5SChristian Brauner } 5751aa5fef5SChristian Brauner 5761aa5fef5SChristian Brauner if (rcu) { 577*6c0a8bfbSChristian Brauner /* 578*6c0a8bfbSChristian Brauner * If the layer is idmapped drop out of RCU path walk 579*6c0a8bfbSChristian Brauner * so we can clone the ACLs. 580*6c0a8bfbSChristian Brauner */ 581*6c0a8bfbSChristian Brauner if (is_idmapped_mnt(realpath.mnt)) 582*6c0a8bfbSChristian Brauner return ERR_PTR(-ECHILD); 583*6c0a8bfbSChristian Brauner 5841aa5fef5SChristian Brauner acl = get_cached_acl_rcu(realinode, type); 5851aa5fef5SChristian Brauner } else { 5861aa5fef5SChristian Brauner const struct cred *old_cred; 587332f606bSMiklos Szeredi 5881175b6b8SVivek Goyal old_cred = ovl_override_creds(inode->i_sb); 589*6c0a8bfbSChristian Brauner acl = ovl_get_acl_path(&realpath, posix_acl_xattr_name(type), noperm); 5901175b6b8SVivek Goyal revert_creds(old_cred); 5911aa5fef5SChristian Brauner } 592*6c0a8bfbSChristian Brauner 5931175b6b8SVivek Goyal return acl; 59439a25b2bSVivek Goyal } 595ded53656SYang Xu #endif 59639a25b2bSVivek Goyal 59795582b00SDeepa Dinamani int ovl_update_time(struct inode *inode, struct timespec64 *ts, int flags) 598d719e8f2SMiklos Szeredi { 5998f35cf51SMiklos Szeredi if (flags & S_ATIME) { 6008f35cf51SMiklos Szeredi struct ovl_fs *ofs = inode->i_sb->s_fs_info; 6018f35cf51SMiklos Szeredi struct path upperpath = { 60208f4c7c8SMiklos Szeredi .mnt = ovl_upper_mnt(ofs), 6038f35cf51SMiklos Szeredi .dentry = ovl_upperdentry_dereference(OVL_I(inode)), 6048f35cf51SMiklos Szeredi }; 605d719e8f2SMiklos Szeredi 606d719e8f2SMiklos Szeredi if (upperpath.dentry) { 607d719e8f2SMiklos Szeredi touch_atime(&upperpath); 608d719e8f2SMiklos Szeredi inode->i_atime = d_inode(upperpath.dentry)->i_atime; 609d719e8f2SMiklos Szeredi } 6108f35cf51SMiklos Szeredi } 611d719e8f2SMiklos Szeredi return 0; 612d719e8f2SMiklos Szeredi } 613d719e8f2SMiklos Szeredi 6149e142c41SMiklos Szeredi static int ovl_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, 6159e142c41SMiklos Szeredi u64 start, u64 len) 6169e142c41SMiklos Szeredi { 6179e142c41SMiklos Szeredi int err; 618c11faf32SChengguang Xu struct inode *realinode = ovl_inode_realdata(inode); 6199e142c41SMiklos Szeredi const struct cred *old_cred; 6209e142c41SMiklos Szeredi 6219e142c41SMiklos Szeredi if (!realinode->i_op->fiemap) 6229e142c41SMiklos Szeredi return -EOPNOTSUPP; 6239e142c41SMiklos Szeredi 6249e142c41SMiklos Szeredi old_cred = ovl_override_creds(inode->i_sb); 6259e142c41SMiklos Szeredi err = realinode->i_op->fiemap(realinode, fieinfo, start, len); 6269e142c41SMiklos Szeredi revert_creds(old_cred); 6279e142c41SMiklos Szeredi 6289e142c41SMiklos Szeredi return err; 6299e142c41SMiklos Szeredi } 6309e142c41SMiklos Szeredi 63166dbfabfSMiklos Szeredi /* 63266dbfabfSMiklos Szeredi * Work around the fact that security_file_ioctl() takes a file argument. 63366dbfabfSMiklos Szeredi * Introducing security_inode_fileattr_get/set() hooks would solve this issue 63466dbfabfSMiklos Szeredi * properly. 63566dbfabfSMiklos Szeredi */ 6362d343087SAl Viro static int ovl_security_fileattr(const struct path *realpath, struct fileattr *fa, 63766dbfabfSMiklos Szeredi bool set) 63866dbfabfSMiklos Szeredi { 63966dbfabfSMiklos Szeredi struct file *file; 64066dbfabfSMiklos Szeredi unsigned int cmd; 64166dbfabfSMiklos Szeredi int err; 64266dbfabfSMiklos Szeredi 64372db8211SAmir Goldstein file = dentry_open(realpath, O_RDONLY, current_cred()); 64466dbfabfSMiklos Szeredi if (IS_ERR(file)) 64566dbfabfSMiklos Szeredi return PTR_ERR(file); 64666dbfabfSMiklos Szeredi 64766dbfabfSMiklos Szeredi if (set) 64866dbfabfSMiklos Szeredi cmd = fa->fsx_valid ? FS_IOC_FSSETXATTR : FS_IOC_SETFLAGS; 64966dbfabfSMiklos Szeredi else 65066dbfabfSMiklos Szeredi cmd = fa->fsx_valid ? FS_IOC_FSGETXATTR : FS_IOC_GETFLAGS; 65166dbfabfSMiklos Szeredi 65266dbfabfSMiklos Szeredi err = security_file_ioctl(file, cmd, 0); 65366dbfabfSMiklos Szeredi fput(file); 65466dbfabfSMiklos Szeredi 65566dbfabfSMiklos Szeredi return err; 65666dbfabfSMiklos Szeredi } 65766dbfabfSMiklos Szeredi 6582d343087SAl Viro int ovl_real_fileattr_set(const struct path *realpath, struct fileattr *fa) 65972db8211SAmir Goldstein { 66072db8211SAmir Goldstein int err; 66172db8211SAmir Goldstein 66272db8211SAmir Goldstein err = ovl_security_fileattr(realpath, fa, true); 66372db8211SAmir Goldstein if (err) 66472db8211SAmir Goldstein return err; 66572db8211SAmir Goldstein 66650db8d02SChristian Brauner return vfs_fileattr_set(mnt_user_ns(realpath->mnt), realpath->dentry, fa); 66772db8211SAmir Goldstein } 66872db8211SAmir Goldstein 66966dbfabfSMiklos Szeredi int ovl_fileattr_set(struct user_namespace *mnt_userns, 67066dbfabfSMiklos Szeredi struct dentry *dentry, struct fileattr *fa) 67166dbfabfSMiklos Szeredi { 67266dbfabfSMiklos Szeredi struct inode *inode = d_inode(dentry); 67372db8211SAmir Goldstein struct path upperpath; 67466dbfabfSMiklos Szeredi const struct cred *old_cred; 675096a218aSAmir Goldstein unsigned int flags; 67666dbfabfSMiklos Szeredi int err; 67766dbfabfSMiklos Szeredi 67866dbfabfSMiklos Szeredi err = ovl_want_write(dentry); 67966dbfabfSMiklos Szeredi if (err) 68066dbfabfSMiklos Szeredi goto out; 68166dbfabfSMiklos Szeredi 68266dbfabfSMiklos Szeredi err = ovl_copy_up(dentry); 68366dbfabfSMiklos Szeredi if (!err) { 68472db8211SAmir Goldstein ovl_path_real(dentry, &upperpath); 68566dbfabfSMiklos Szeredi 68666dbfabfSMiklos Szeredi old_cred = ovl_override_creds(inode->i_sb); 687096a218aSAmir Goldstein /* 688096a218aSAmir Goldstein * Store immutable/append-only flags in xattr and clear them 689096a218aSAmir Goldstein * in upper fileattr (in case they were set by older kernel) 690096a218aSAmir Goldstein * so children of "ovl-immutable" directories lower aliases of 691096a218aSAmir Goldstein * "ovl-immutable" hardlinks could be copied up. 692096a218aSAmir Goldstein * Clear xattr when flags are cleared. 693096a218aSAmir Goldstein */ 694096a218aSAmir Goldstein err = ovl_set_protattr(inode, upperpath.dentry, fa); 695096a218aSAmir Goldstein if (!err) 69672db8211SAmir Goldstein err = ovl_real_fileattr_set(&upperpath, fa); 69766dbfabfSMiklos Szeredi revert_creds(old_cred); 698096a218aSAmir Goldstein 699096a218aSAmir Goldstein /* 700096a218aSAmir Goldstein * Merge real inode flags with inode flags read from 701096a218aSAmir Goldstein * overlay.protattr xattr 702096a218aSAmir Goldstein */ 703096a218aSAmir Goldstein flags = ovl_inode_real(inode)->i_flags & OVL_COPY_I_FLAGS_MASK; 704096a218aSAmir Goldstein 705096a218aSAmir Goldstein BUILD_BUG_ON(OVL_PROT_I_FLAGS_MASK & ~OVL_COPY_I_FLAGS_MASK); 706096a218aSAmir Goldstein flags |= inode->i_flags & OVL_PROT_I_FLAGS_MASK; 707096a218aSAmir Goldstein inode_set_flags(inode, flags, OVL_COPY_I_FLAGS_MASK); 708d8991e86SChengguang Xu 709d8991e86SChengguang Xu /* Update ctime */ 7102878dffcSChristian Brauner ovl_copyattr(inode); 71166dbfabfSMiklos Szeredi } 71266dbfabfSMiklos Szeredi ovl_drop_write(dentry); 71366dbfabfSMiklos Szeredi out: 71466dbfabfSMiklos Szeredi return err; 71566dbfabfSMiklos Szeredi } 71666dbfabfSMiklos Szeredi 717096a218aSAmir Goldstein /* Convert inode protection flags to fileattr flags */ 718096a218aSAmir Goldstein static void ovl_fileattr_prot_flags(struct inode *inode, struct fileattr *fa) 719096a218aSAmir Goldstein { 720096a218aSAmir Goldstein BUILD_BUG_ON(OVL_PROT_FS_FLAGS_MASK & ~FS_COMMON_FL); 721096a218aSAmir Goldstein BUILD_BUG_ON(OVL_PROT_FSX_FLAGS_MASK & ~FS_XFLAG_COMMON); 722096a218aSAmir Goldstein 723096a218aSAmir Goldstein if (inode->i_flags & S_APPEND) { 724096a218aSAmir Goldstein fa->flags |= FS_APPEND_FL; 725096a218aSAmir Goldstein fa->fsx_xflags |= FS_XFLAG_APPEND; 726096a218aSAmir Goldstein } 727096a218aSAmir Goldstein if (inode->i_flags & S_IMMUTABLE) { 728096a218aSAmir Goldstein fa->flags |= FS_IMMUTABLE_FL; 729096a218aSAmir Goldstein fa->fsx_xflags |= FS_XFLAG_IMMUTABLE; 730096a218aSAmir Goldstein } 731096a218aSAmir Goldstein } 732096a218aSAmir Goldstein 7332d343087SAl Viro int ovl_real_fileattr_get(const struct path *realpath, struct fileattr *fa) 73472db8211SAmir Goldstein { 73572db8211SAmir Goldstein int err; 73672db8211SAmir Goldstein 73772db8211SAmir Goldstein err = ovl_security_fileattr(realpath, fa, false); 73872db8211SAmir Goldstein if (err) 73972db8211SAmir Goldstein return err; 74072db8211SAmir Goldstein 7415b0a414dSMiklos Szeredi err = vfs_fileattr_get(realpath->dentry, fa); 7425b0a414dSMiklos Szeredi if (err == -ENOIOCTLCMD) 7435b0a414dSMiklos Szeredi err = -ENOTTY; 7445b0a414dSMiklos Szeredi return err; 74572db8211SAmir Goldstein } 74672db8211SAmir Goldstein 74766dbfabfSMiklos Szeredi int ovl_fileattr_get(struct dentry *dentry, struct fileattr *fa) 74866dbfabfSMiklos Szeredi { 74966dbfabfSMiklos Szeredi struct inode *inode = d_inode(dentry); 75072db8211SAmir Goldstein struct path realpath; 75166dbfabfSMiklos Szeredi const struct cred *old_cred; 75266dbfabfSMiklos Szeredi int err; 75366dbfabfSMiklos Szeredi 75472db8211SAmir Goldstein ovl_path_real(dentry, &realpath); 75572db8211SAmir Goldstein 75666dbfabfSMiklos Szeredi old_cred = ovl_override_creds(inode->i_sb); 75772db8211SAmir Goldstein err = ovl_real_fileattr_get(&realpath, fa); 758096a218aSAmir Goldstein ovl_fileattr_prot_flags(inode, fa); 75966dbfabfSMiklos Szeredi revert_creds(old_cred); 76066dbfabfSMiklos Szeredi 76166dbfabfSMiklos Szeredi return err; 76266dbfabfSMiklos Szeredi } 76366dbfabfSMiklos Szeredi 764e9be9d5eSMiklos Szeredi static const struct inode_operations ovl_file_inode_operations = { 765e9be9d5eSMiklos Szeredi .setattr = ovl_setattr, 766e9be9d5eSMiklos Szeredi .permission = ovl_permission, 767e9be9d5eSMiklos Szeredi .getattr = ovl_getattr, 768e9be9d5eSMiklos Szeredi .listxattr = ovl_listxattr, 769*6c0a8bfbSChristian Brauner .get_inode_acl = ovl_get_inode_acl, 770*6c0a8bfbSChristian Brauner .get_acl = ovl_get_acl, 771d719e8f2SMiklos Szeredi .update_time = ovl_update_time, 7729e142c41SMiklos Szeredi .fiemap = ovl_fiemap, 77366dbfabfSMiklos Szeredi .fileattr_get = ovl_fileattr_get, 77466dbfabfSMiklos Szeredi .fileattr_set = ovl_fileattr_set, 775e9be9d5eSMiklos Szeredi }; 776e9be9d5eSMiklos Szeredi 777e9be9d5eSMiklos Szeredi static const struct inode_operations ovl_symlink_inode_operations = { 778e9be9d5eSMiklos Szeredi .setattr = ovl_setattr, 7796b255391SAl Viro .get_link = ovl_get_link, 780e9be9d5eSMiklos Szeredi .getattr = ovl_getattr, 781e9be9d5eSMiklos Szeredi .listxattr = ovl_listxattr, 782d719e8f2SMiklos Szeredi .update_time = ovl_update_time, 783e9be9d5eSMiklos Szeredi }; 784e9be9d5eSMiklos Szeredi 7859e142c41SMiklos Szeredi static const struct inode_operations ovl_special_inode_operations = { 7869e142c41SMiklos Szeredi .setattr = ovl_setattr, 7879e142c41SMiklos Szeredi .permission = ovl_permission, 7889e142c41SMiklos Szeredi .getattr = ovl_getattr, 7899e142c41SMiklos Szeredi .listxattr = ovl_listxattr, 790*6c0a8bfbSChristian Brauner .get_inode_acl = ovl_get_inode_acl, 791*6c0a8bfbSChristian Brauner .get_acl = ovl_get_acl, 7929e142c41SMiklos Szeredi .update_time = ovl_update_time, 7939e142c41SMiklos Szeredi }; 7949e142c41SMiklos Szeredi 79569383c59SWei Yongjun static const struct address_space_operations ovl_aops = { 7965b910bd6SAmir Goldstein /* For O_DIRECT dentry_open() checks f_mapping->a_ops->direct_IO */ 7975b910bd6SAmir Goldstein .direct_IO = noop_direct_IO, 7985b910bd6SAmir Goldstein }; 7995b910bd6SAmir Goldstein 800b1eaa950SAmir Goldstein /* 801b1eaa950SAmir Goldstein * It is possible to stack overlayfs instance on top of another 802a5a84682SChengguang Xu * overlayfs instance as lower layer. We need to annotate the 803b1eaa950SAmir Goldstein * stackable i_mutex locks according to stack level of the super 804b1eaa950SAmir Goldstein * block instance. An overlayfs instance can never be in stack 805b1eaa950SAmir Goldstein * depth 0 (there is always a real fs below it). An overlayfs 806f48bbfb2SBhaskar Chowdhury * inode lock will use the lockdep annotation ovl_i_mutex_key[depth]. 807b1eaa950SAmir Goldstein * 808b1eaa950SAmir Goldstein * For example, here is a snip from /proc/lockdep_chains after 809b1eaa950SAmir Goldstein * dir_iterate of nested overlayfs: 810b1eaa950SAmir Goldstein * 811b1eaa950SAmir Goldstein * [...] &ovl_i_mutex_dir_key[depth] (stack_depth=2) 812b1eaa950SAmir Goldstein * [...] &ovl_i_mutex_dir_key[depth]#2 (stack_depth=1) 813b1eaa950SAmir Goldstein * [...] &type->i_mutex_dir_key (stack_depth=0) 814b1f9d385SAmir Goldstein * 815b1f9d385SAmir Goldstein * Locking order w.r.t ovl_want_write() is important for nested overlayfs. 816b1f9d385SAmir Goldstein * 817b1f9d385SAmir Goldstein * This chain is valid: 818b1f9d385SAmir Goldstein * - inode->i_rwsem (inode_lock[2]) 819b1f9d385SAmir Goldstein * - upper_mnt->mnt_sb->s_writers (ovl_want_write[0]) 820b1f9d385SAmir Goldstein * - OVL_I(inode)->lock (ovl_inode_lock[2]) 821b1f9d385SAmir Goldstein * - OVL_I(lowerinode)->lock (ovl_inode_lock[1]) 822b1f9d385SAmir Goldstein * 823b1f9d385SAmir Goldstein * And this chain is valid: 824b1f9d385SAmir Goldstein * - inode->i_rwsem (inode_lock[2]) 825b1f9d385SAmir Goldstein * - OVL_I(inode)->lock (ovl_inode_lock[2]) 826b1f9d385SAmir Goldstein * - lowerinode->i_rwsem (inode_lock[1]) 827b1f9d385SAmir Goldstein * - OVL_I(lowerinode)->lock (ovl_inode_lock[1]) 828b1f9d385SAmir Goldstein * 829b1f9d385SAmir Goldstein * But lowerinode->i_rwsem SHOULD NOT be acquired while ovl_want_write() is 830b1f9d385SAmir Goldstein * held, because it is in reverse order of the non-nested case using the same 831b1f9d385SAmir Goldstein * upper fs: 832b1f9d385SAmir Goldstein * - inode->i_rwsem (inode_lock[1]) 833b1f9d385SAmir Goldstein * - upper_mnt->mnt_sb->s_writers (ovl_want_write[0]) 834b1f9d385SAmir Goldstein * - OVL_I(inode)->lock (ovl_inode_lock[1]) 835b1eaa950SAmir Goldstein */ 836b1eaa950SAmir Goldstein #define OVL_MAX_NESTING FILESYSTEM_MAX_STACK_DEPTH 837b1eaa950SAmir Goldstein 838b1eaa950SAmir Goldstein static inline void ovl_lockdep_annotate_inode_mutex_key(struct inode *inode) 839b1eaa950SAmir Goldstein { 840b1eaa950SAmir Goldstein #ifdef CONFIG_LOCKDEP 841b1eaa950SAmir Goldstein static struct lock_class_key ovl_i_mutex_key[OVL_MAX_NESTING]; 842b1eaa950SAmir Goldstein static struct lock_class_key ovl_i_mutex_dir_key[OVL_MAX_NESTING]; 8434eae06deSAmir Goldstein static struct lock_class_key ovl_i_lock_key[OVL_MAX_NESTING]; 844b1eaa950SAmir Goldstein 845b1eaa950SAmir Goldstein int depth = inode->i_sb->s_stack_depth - 1; 846b1eaa950SAmir Goldstein 847b1eaa950SAmir Goldstein if (WARN_ON_ONCE(depth < 0 || depth >= OVL_MAX_NESTING)) 848b1eaa950SAmir Goldstein depth = 0; 849b1eaa950SAmir Goldstein 850b1eaa950SAmir Goldstein if (S_ISDIR(inode->i_mode)) 851b1eaa950SAmir Goldstein lockdep_set_class(&inode->i_rwsem, &ovl_i_mutex_dir_key[depth]); 852b1eaa950SAmir Goldstein else 853b1eaa950SAmir Goldstein lockdep_set_class(&inode->i_rwsem, &ovl_i_mutex_key[depth]); 8544eae06deSAmir Goldstein 8554eae06deSAmir Goldstein lockdep_set_class(&OVL_I(inode)->lock, &ovl_i_lock_key[depth]); 856b1eaa950SAmir Goldstein #endif 857b1eaa950SAmir Goldstein } 858b1eaa950SAmir Goldstein 8594d314f78SAmir Goldstein static void ovl_next_ino(struct inode *inode) 8604d314f78SAmir Goldstein { 8614d314f78SAmir Goldstein struct ovl_fs *ofs = inode->i_sb->s_fs_info; 8624d314f78SAmir Goldstein 8634d314f78SAmir Goldstein inode->i_ino = atomic_long_inc_return(&ofs->last_ino); 8644d314f78SAmir Goldstein if (unlikely(!inode->i_ino)) 8654d314f78SAmir Goldstein inode->i_ino = atomic_long_inc_return(&ofs->last_ino); 8664d314f78SAmir Goldstein } 8674d314f78SAmir Goldstein 86862c832edSAmir Goldstein static void ovl_map_ino(struct inode *inode, unsigned long ino, int fsid) 869e9be9d5eSMiklos Szeredi { 87012574a9fSAmir Goldstein int xinobits = ovl_xino_bits(inode->i_sb); 871dfe51d47SAmir Goldstein unsigned int xinoshift = 64 - xinobits; 87212574a9fSAmir Goldstein 873695b46e7SAmir Goldstein /* 8746dde1e42SAmir Goldstein * When d_ino is consistent with st_ino (samefs or i_ino has enough 8756dde1e42SAmir Goldstein * bits to encode layer), set the same value used for st_ino to i_ino, 8766dde1e42SAmir Goldstein * so inode number exposed via /proc/locks and a like will be 8776dde1e42SAmir Goldstein * consistent with d_ino and st_ino values. An i_ino value inconsistent 878735c907dSAmir Goldstein * with d_ino also causes nfsd readdirplus to fail. 879695b46e7SAmir Goldstein */ 880695b46e7SAmir Goldstein inode->i_ino = ino; 881dfe51d47SAmir Goldstein if (ovl_same_fs(inode->i_sb)) { 882dfe51d47SAmir Goldstein return; 883dfe51d47SAmir Goldstein } else if (xinobits && likely(!(ino >> xinoshift))) { 884dfe51d47SAmir Goldstein inode->i_ino |= (unsigned long)fsid << (xinoshift + 1); 885dfe51d47SAmir Goldstein return; 886dfe51d47SAmir Goldstein } 887dfe51d47SAmir Goldstein 888dfe51d47SAmir Goldstein /* 889dfe51d47SAmir Goldstein * For directory inodes on non-samefs with xino disabled or xino 890dfe51d47SAmir Goldstein * overflow, we allocate a non-persistent inode number, to be used for 891dfe51d47SAmir Goldstein * resolving st_ino collisions in ovl_map_dev_ino(). 892dfe51d47SAmir Goldstein * 893dfe51d47SAmir Goldstein * To avoid ino collision with legitimate xino values from upper 894dfe51d47SAmir Goldstein * layer (fsid 0), use the lowest xinobit to map the non 895dfe51d47SAmir Goldstein * persistent inode numbers to the unified st_ino address space. 896dfe51d47SAmir Goldstein */ 897dfe51d47SAmir Goldstein if (S_ISDIR(inode->i_mode)) { 8984d314f78SAmir Goldstein ovl_next_ino(inode); 899dfe51d47SAmir Goldstein if (xinobits) { 900dfe51d47SAmir Goldstein inode->i_ino &= ~0UL >> xinobits; 901dfe51d47SAmir Goldstein inode->i_ino |= 1UL << xinoshift; 902dfe51d47SAmir Goldstein } 90312574a9fSAmir Goldstein } 90462c832edSAmir Goldstein } 90562c832edSAmir Goldstein 90662c832edSAmir Goldstein void ovl_inode_init(struct inode *inode, struct ovl_inode_params *oip, 90762c832edSAmir Goldstein unsigned long ino, int fsid) 90862c832edSAmir Goldstein { 90962c832edSAmir Goldstein struct inode *realinode; 910ffa5723cSAmir Goldstein struct ovl_inode *oi = OVL_I(inode); 91162c832edSAmir Goldstein 91262c832edSAmir Goldstein if (oip->upperdentry) 913ffa5723cSAmir Goldstein oi->__upperdentry = oip->upperdentry; 914ffa5723cSAmir Goldstein if (oip->lowerpath && oip->lowerpath->dentry) { 915ffa5723cSAmir Goldstein oi->lowerpath.dentry = dget(oip->lowerpath->dentry); 916ffa5723cSAmir Goldstein oi->lowerpath.layer = oip->lowerpath->layer; 917ffa5723cSAmir Goldstein } 91862c832edSAmir Goldstein if (oip->lowerdata) 919ffa5723cSAmir Goldstein oi->lowerdata = igrab(d_inode(oip->lowerdata)); 92062c832edSAmir Goldstein 92162c832edSAmir Goldstein realinode = ovl_inode_real(inode); 9222878dffcSChristian Brauner ovl_copyattr(inode); 92362c832edSAmir Goldstein ovl_copyflags(realinode, inode); 92462c832edSAmir Goldstein ovl_map_ino(inode, ino, fsid); 92562c832edSAmir Goldstein } 92662c832edSAmir Goldstein 92762c832edSAmir Goldstein static void ovl_fill_inode(struct inode *inode, umode_t mode, dev_t rdev) 92862c832edSAmir Goldstein { 929e9be9d5eSMiklos Szeredi inode->i_mode = mode; 930d719e8f2SMiklos Szeredi inode->i_flags |= S_NOCMTIME; 9312a3a2a3fSMiklos Szeredi #ifdef CONFIG_FS_POSIX_ACL 9322a3a2a3fSMiklos Szeredi inode->i_acl = inode->i_default_acl = ACL_DONT_CACHE; 9332a3a2a3fSMiklos Szeredi #endif 934e9be9d5eSMiklos Szeredi 935b1eaa950SAmir Goldstein ovl_lockdep_annotate_inode_mutex_key(inode); 936b1eaa950SAmir Goldstein 937ca4c8a3aSMiklos Szeredi switch (mode & S_IFMT) { 938ca4c8a3aSMiklos Szeredi case S_IFREG: 939ca4c8a3aSMiklos Szeredi inode->i_op = &ovl_file_inode_operations; 940d1d04ef8SMiklos Szeredi inode->i_fop = &ovl_file_operations; 9415b910bd6SAmir Goldstein inode->i_mapping->a_ops = &ovl_aops; 942ca4c8a3aSMiklos Szeredi break; 943ca4c8a3aSMiklos Szeredi 944e9be9d5eSMiklos Szeredi case S_IFDIR: 945e9be9d5eSMiklos Szeredi inode->i_op = &ovl_dir_inode_operations; 946e9be9d5eSMiklos Szeredi inode->i_fop = &ovl_dir_operations; 947e9be9d5eSMiklos Szeredi break; 948e9be9d5eSMiklos Szeredi 949e9be9d5eSMiklos Szeredi case S_IFLNK: 950e9be9d5eSMiklos Szeredi inode->i_op = &ovl_symlink_inode_operations; 951e9be9d5eSMiklos Szeredi break; 952e9be9d5eSMiklos Szeredi 95351f7e52dSMiklos Szeredi default: 9549e142c41SMiklos Szeredi inode->i_op = &ovl_special_inode_operations; 955ca4c8a3aSMiklos Szeredi init_special_inode(inode, mode, rdev); 956e9be9d5eSMiklos Szeredi break; 95751f7e52dSMiklos Szeredi } 95851f7e52dSMiklos Szeredi } 959e9be9d5eSMiklos Szeredi 9605f8415d6SAmir Goldstein /* 9615f8415d6SAmir Goldstein * With inodes index enabled, an overlay inode nlink counts the union of upper 9625f8415d6SAmir Goldstein * hardlinks and non-covered lower hardlinks. During the lifetime of a non-pure 9635f8415d6SAmir Goldstein * upper inode, the following nlink modifying operations can happen: 9645f8415d6SAmir Goldstein * 9655f8415d6SAmir Goldstein * 1. Lower hardlink copy up 9665f8415d6SAmir Goldstein * 2. Upper hardlink created, unlinked or renamed over 9675f8415d6SAmir Goldstein * 3. Lower hardlink whiteout or renamed over 9685f8415d6SAmir Goldstein * 9695f8415d6SAmir Goldstein * For the first, copy up case, the union nlink does not change, whether the 9705f8415d6SAmir Goldstein * operation succeeds or fails, but the upper inode nlink may change. 9715f8415d6SAmir Goldstein * Therefore, before copy up, we store the union nlink value relative to the 9722d2f2d73SMiklos Szeredi * lower inode nlink in the index inode xattr .overlay.nlink. 9735f8415d6SAmir Goldstein * 9745f8415d6SAmir Goldstein * For the second, upper hardlink case, the union nlink should be incremented 9755f8415d6SAmir Goldstein * or decremented IFF the operation succeeds, aligned with nlink change of the 9765f8415d6SAmir Goldstein * upper inode. Therefore, before link/unlink/rename, we store the union nlink 9775f8415d6SAmir Goldstein * value relative to the upper inode nlink in the index inode. 9785f8415d6SAmir Goldstein * 9795f8415d6SAmir Goldstein * For the last, lower cover up case, we simplify things by preceding the 9805f8415d6SAmir Goldstein * whiteout or cover up with copy up. This makes sure that there is an index 9815f8415d6SAmir Goldstein * upper inode where the nlink xattr can be stored before the copied up upper 9825f8415d6SAmir Goldstein * entry is unlink. 9835f8415d6SAmir Goldstein */ 9845f8415d6SAmir Goldstein #define OVL_NLINK_ADD_UPPER (1 << 0) 9855f8415d6SAmir Goldstein 9865f8415d6SAmir Goldstein /* 9875f8415d6SAmir Goldstein * On-disk format for indexed nlink: 9885f8415d6SAmir Goldstein * 9895f8415d6SAmir Goldstein * nlink relative to the upper inode - "U[+-]NUM" 9905f8415d6SAmir Goldstein * nlink relative to the lower inode - "L[+-]NUM" 9915f8415d6SAmir Goldstein */ 9925f8415d6SAmir Goldstein 9935f8415d6SAmir Goldstein static int ovl_set_nlink_common(struct dentry *dentry, 9945f8415d6SAmir Goldstein struct dentry *realdentry, const char *format) 9955f8415d6SAmir Goldstein { 9965f8415d6SAmir Goldstein struct inode *inode = d_inode(dentry); 9975f8415d6SAmir Goldstein struct inode *realinode = d_inode(realdentry); 9985f8415d6SAmir Goldstein char buf[13]; 9995f8415d6SAmir Goldstein int len; 10005f8415d6SAmir Goldstein 10015f8415d6SAmir Goldstein len = snprintf(buf, sizeof(buf), format, 10025f8415d6SAmir Goldstein (int) (inode->i_nlink - realinode->i_nlink)); 10035f8415d6SAmir Goldstein 10046787341aSMiklos Szeredi if (WARN_ON(len >= sizeof(buf))) 10056787341aSMiklos Szeredi return -EIO; 10066787341aSMiklos Szeredi 1007c914c0e2SAmir Goldstein return ovl_setxattr(OVL_FS(inode->i_sb), ovl_dentry_upper(dentry), 100826150ab5SMiklos Szeredi OVL_XATTR_NLINK, buf, len); 10095f8415d6SAmir Goldstein } 10105f8415d6SAmir Goldstein 10115f8415d6SAmir Goldstein int ovl_set_nlink_upper(struct dentry *dentry) 10125f8415d6SAmir Goldstein { 10135f8415d6SAmir Goldstein return ovl_set_nlink_common(dentry, ovl_dentry_upper(dentry), "U%+i"); 10145f8415d6SAmir Goldstein } 10155f8415d6SAmir Goldstein 10165f8415d6SAmir Goldstein int ovl_set_nlink_lower(struct dentry *dentry) 10175f8415d6SAmir Goldstein { 10185f8415d6SAmir Goldstein return ovl_set_nlink_common(dentry, ovl_dentry_lower(dentry), "L%+i"); 10195f8415d6SAmir Goldstein } 10205f8415d6SAmir Goldstein 1021610afc0bSMiklos Szeredi unsigned int ovl_get_nlink(struct ovl_fs *ofs, struct dentry *lowerdentry, 10225f8415d6SAmir Goldstein struct dentry *upperdentry, 10235f8415d6SAmir Goldstein unsigned int fallback) 10245f8415d6SAmir Goldstein { 10255f8415d6SAmir Goldstein int nlink_diff; 10265f8415d6SAmir Goldstein int nlink; 10275f8415d6SAmir Goldstein char buf[13]; 10285f8415d6SAmir Goldstein int err; 10295f8415d6SAmir Goldstein 10305f8415d6SAmir Goldstein if (!lowerdentry || !upperdentry || d_inode(lowerdentry)->i_nlink == 1) 10315f8415d6SAmir Goldstein return fallback; 10325f8415d6SAmir Goldstein 1033dad7017aSChristian Brauner err = ovl_getxattr_upper(ofs, upperdentry, OVL_XATTR_NLINK, 1034d5dc7486SMiklos Szeredi &buf, sizeof(buf) - 1); 10355f8415d6SAmir Goldstein if (err < 0) 10365f8415d6SAmir Goldstein goto fail; 10375f8415d6SAmir Goldstein 10385f8415d6SAmir Goldstein buf[err] = '\0'; 10395f8415d6SAmir Goldstein if ((buf[0] != 'L' && buf[0] != 'U') || 10405f8415d6SAmir Goldstein (buf[1] != '+' && buf[1] != '-')) 10415f8415d6SAmir Goldstein goto fail; 10425f8415d6SAmir Goldstein 10435f8415d6SAmir Goldstein err = kstrtoint(buf + 1, 10, &nlink_diff); 10445f8415d6SAmir Goldstein if (err < 0) 10455f8415d6SAmir Goldstein goto fail; 10465f8415d6SAmir Goldstein 10475f8415d6SAmir Goldstein nlink = d_inode(buf[0] == 'L' ? lowerdentry : upperdentry)->i_nlink; 10485f8415d6SAmir Goldstein nlink += nlink_diff; 10495f8415d6SAmir Goldstein 10505f8415d6SAmir Goldstein if (nlink <= 0) 10515f8415d6SAmir Goldstein goto fail; 10525f8415d6SAmir Goldstein 10535f8415d6SAmir Goldstein return nlink; 10545f8415d6SAmir Goldstein 10555f8415d6SAmir Goldstein fail: 10561bd0a3aeSlijiazi pr_warn_ratelimited("failed to get index nlink (%pd2, err=%i)\n", 10575f8415d6SAmir Goldstein upperdentry, err); 10585f8415d6SAmir Goldstein return fallback; 10595f8415d6SAmir Goldstein } 10605f8415d6SAmir Goldstein 1061ca4c8a3aSMiklos Szeredi struct inode *ovl_new_inode(struct super_block *sb, umode_t mode, dev_t rdev) 106251f7e52dSMiklos Szeredi { 106351f7e52dSMiklos Szeredi struct inode *inode; 106451f7e52dSMiklos Szeredi 106551f7e52dSMiklos Szeredi inode = new_inode(sb); 106651f7e52dSMiklos Szeredi if (inode) 106762c832edSAmir Goldstein ovl_fill_inode(inode, mode, rdev); 106851f7e52dSMiklos Szeredi 106951f7e52dSMiklos Szeredi return inode; 107051f7e52dSMiklos Szeredi } 107151f7e52dSMiklos Szeredi 107251f7e52dSMiklos Szeredi static int ovl_inode_test(struct inode *inode, void *data) 107351f7e52dSMiklos Szeredi { 107425b7713aSMiklos Szeredi return inode->i_private == data; 107551f7e52dSMiklos Szeredi } 107651f7e52dSMiklos Szeredi 107751f7e52dSMiklos Szeredi static int ovl_inode_set(struct inode *inode, void *data) 107851f7e52dSMiklos Szeredi { 107925b7713aSMiklos Szeredi inode->i_private = data; 108051f7e52dSMiklos Szeredi return 0; 108151f7e52dSMiklos Szeredi } 108251f7e52dSMiklos Szeredi 1083b9ac5c27SMiklos Szeredi static bool ovl_verify_inode(struct inode *inode, struct dentry *lowerdentry, 10844b91c30aSAmir Goldstein struct dentry *upperdentry, bool strict) 1085b9ac5c27SMiklos Szeredi { 10864b91c30aSAmir Goldstein /* 10874b91c30aSAmir Goldstein * For directories, @strict verify from lookup path performs consistency 10884b91c30aSAmir Goldstein * checks, so NULL lower/upper in dentry must match NULL lower/upper in 10894b91c30aSAmir Goldstein * inode. Non @strict verify from NFS handle decode path passes NULL for 10904b91c30aSAmir Goldstein * 'unknown' lower/upper. 10914b91c30aSAmir Goldstein */ 10924b91c30aSAmir Goldstein if (S_ISDIR(inode->i_mode) && strict) { 109331747edaSAmir Goldstein /* Real lower dir moved to upper layer under us? */ 109431747edaSAmir Goldstein if (!lowerdentry && ovl_inode_lower(inode)) 109531747edaSAmir Goldstein return false; 109631747edaSAmir Goldstein 109731747edaSAmir Goldstein /* Lookup of an uncovered redirect origin? */ 109831747edaSAmir Goldstein if (!upperdentry && ovl_inode_upper(inode)) 109931747edaSAmir Goldstein return false; 110031747edaSAmir Goldstein } 110131747edaSAmir Goldstein 1102939ae4efSAmir Goldstein /* 1103939ae4efSAmir Goldstein * Allow non-NULL lower inode in ovl_inode even if lowerdentry is NULL. 1104939ae4efSAmir Goldstein * This happens when finding a copied up overlay inode for a renamed 1105939ae4efSAmir Goldstein * or hardlinked overlay dentry and lower dentry cannot be followed 1106939ae4efSAmir Goldstein * by origin because lower fs does not support file handles. 1107939ae4efSAmir Goldstein */ 1108939ae4efSAmir Goldstein if (lowerdentry && ovl_inode_lower(inode) != d_inode(lowerdentry)) 1109b9ac5c27SMiklos Szeredi return false; 1110b9ac5c27SMiklos Szeredi 1111b9ac5c27SMiklos Szeredi /* 1112b9ac5c27SMiklos Szeredi * Allow non-NULL __upperdentry in inode even if upperdentry is NULL. 1113b9ac5c27SMiklos Szeredi * This happens when finding a lower alias for a copied up hard link. 1114b9ac5c27SMiklos Szeredi */ 1115b9ac5c27SMiklos Szeredi if (upperdentry && ovl_inode_upper(inode) != d_inode(upperdentry)) 1116b9ac5c27SMiklos Szeredi return false; 1117b9ac5c27SMiklos Szeredi 1118b9ac5c27SMiklos Szeredi return true; 1119b9ac5c27SMiklos Szeredi } 1120b9ac5c27SMiklos Szeredi 11214b91c30aSAmir Goldstein struct inode *ovl_lookup_inode(struct super_block *sb, struct dentry *real, 11224b91c30aSAmir Goldstein bool is_upper) 11239436a1a3SAmir Goldstein { 11244b91c30aSAmir Goldstein struct inode *inode, *key = d_inode(real); 11259436a1a3SAmir Goldstein 11269436a1a3SAmir Goldstein inode = ilookup5(sb, (unsigned long) key, ovl_inode_test, key); 11279436a1a3SAmir Goldstein if (!inode) 11289436a1a3SAmir Goldstein return NULL; 11299436a1a3SAmir Goldstein 11304b91c30aSAmir Goldstein if (!ovl_verify_inode(inode, is_upper ? NULL : real, 11314b91c30aSAmir Goldstein is_upper ? real : NULL, false)) { 11329436a1a3SAmir Goldstein iput(inode); 11339436a1a3SAmir Goldstein return ERR_PTR(-ESTALE); 11349436a1a3SAmir Goldstein } 11359436a1a3SAmir Goldstein 11369436a1a3SAmir Goldstein return inode; 11379436a1a3SAmir Goldstein } 11389436a1a3SAmir Goldstein 1139146d62e5SAmir Goldstein bool ovl_lookup_trap_inode(struct super_block *sb, struct dentry *dir) 1140146d62e5SAmir Goldstein { 1141146d62e5SAmir Goldstein struct inode *key = d_inode(dir); 1142146d62e5SAmir Goldstein struct inode *trap; 1143146d62e5SAmir Goldstein bool res; 1144146d62e5SAmir Goldstein 1145146d62e5SAmir Goldstein trap = ilookup5(sb, (unsigned long) key, ovl_inode_test, key); 1146146d62e5SAmir Goldstein if (!trap) 1147146d62e5SAmir Goldstein return false; 1148146d62e5SAmir Goldstein 1149146d62e5SAmir Goldstein res = IS_DEADDIR(trap) && !ovl_inode_upper(trap) && 1150146d62e5SAmir Goldstein !ovl_inode_lower(trap); 1151146d62e5SAmir Goldstein 1152146d62e5SAmir Goldstein iput(trap); 1153146d62e5SAmir Goldstein return res; 1154146d62e5SAmir Goldstein } 1155146d62e5SAmir Goldstein 1156146d62e5SAmir Goldstein /* 1157146d62e5SAmir Goldstein * Create an inode cache entry for layer root dir, that will intentionally 1158146d62e5SAmir Goldstein * fail ovl_verify_inode(), so any lookup that will find some layer root 1159146d62e5SAmir Goldstein * will fail. 1160146d62e5SAmir Goldstein */ 1161146d62e5SAmir Goldstein struct inode *ovl_get_trap_inode(struct super_block *sb, struct dentry *dir) 1162146d62e5SAmir Goldstein { 1163146d62e5SAmir Goldstein struct inode *key = d_inode(dir); 1164146d62e5SAmir Goldstein struct inode *trap; 1165146d62e5SAmir Goldstein 1166146d62e5SAmir Goldstein if (!d_is_dir(dir)) 1167146d62e5SAmir Goldstein return ERR_PTR(-ENOTDIR); 1168146d62e5SAmir Goldstein 1169146d62e5SAmir Goldstein trap = iget5_locked(sb, (unsigned long) key, ovl_inode_test, 1170146d62e5SAmir Goldstein ovl_inode_set, key); 1171146d62e5SAmir Goldstein if (!trap) 1172146d62e5SAmir Goldstein return ERR_PTR(-ENOMEM); 1173146d62e5SAmir Goldstein 1174146d62e5SAmir Goldstein if (!(trap->i_state & I_NEW)) { 1175146d62e5SAmir Goldstein /* Conflicting layer roots? */ 1176146d62e5SAmir Goldstein iput(trap); 1177146d62e5SAmir Goldstein return ERR_PTR(-ELOOP); 1178146d62e5SAmir Goldstein } 1179146d62e5SAmir Goldstein 1180146d62e5SAmir Goldstein trap->i_mode = S_IFDIR; 1181146d62e5SAmir Goldstein trap->i_flags = S_DEAD; 1182146d62e5SAmir Goldstein unlock_new_inode(trap); 1183146d62e5SAmir Goldstein 1184146d62e5SAmir Goldstein return trap; 1185146d62e5SAmir Goldstein } 1186146d62e5SAmir Goldstein 1187764baba8SAmir Goldstein /* 1188764baba8SAmir Goldstein * Does overlay inode need to be hashed by lower inode? 1189764baba8SAmir Goldstein */ 1190764baba8SAmir Goldstein static bool ovl_hash_bylower(struct super_block *sb, struct dentry *upper, 119174c6e384SMiklos Szeredi struct dentry *lower, bool index) 1192764baba8SAmir Goldstein { 1193764baba8SAmir Goldstein struct ovl_fs *ofs = sb->s_fs_info; 1194764baba8SAmir Goldstein 1195764baba8SAmir Goldstein /* No, if pure upper */ 1196764baba8SAmir Goldstein if (!lower) 1197764baba8SAmir Goldstein return false; 1198764baba8SAmir Goldstein 1199764baba8SAmir Goldstein /* Yes, if already indexed */ 1200764baba8SAmir Goldstein if (index) 1201764baba8SAmir Goldstein return true; 1202764baba8SAmir Goldstein 1203764baba8SAmir Goldstein /* Yes, if won't be copied up */ 120408f4c7c8SMiklos Szeredi if (!ovl_upper_mnt(ofs)) 1205764baba8SAmir Goldstein return true; 1206764baba8SAmir Goldstein 1207764baba8SAmir Goldstein /* No, if lower hardlink is or will be broken on copy up */ 1208764baba8SAmir Goldstein if ((upper || !ovl_indexdir(sb)) && 1209764baba8SAmir Goldstein !d_is_dir(lower) && d_inode(lower)->i_nlink > 1) 1210764baba8SAmir Goldstein return false; 1211764baba8SAmir Goldstein 1212764baba8SAmir Goldstein /* No, if non-indexed upper with NFS export */ 1213764baba8SAmir Goldstein if (sb->s_export_op && upper) 1214764baba8SAmir Goldstein return false; 1215764baba8SAmir Goldstein 1216764baba8SAmir Goldstein /* Otherwise, hash by lower inode for fsnotify */ 1217764baba8SAmir Goldstein return true; 1218764baba8SAmir Goldstein } 1219764baba8SAmir Goldstein 122001b39dccSAmir Goldstein static struct inode *ovl_iget5(struct super_block *sb, struct inode *newinode, 122101b39dccSAmir Goldstein struct inode *key) 122201b39dccSAmir Goldstein { 122301b39dccSAmir Goldstein return newinode ? inode_insert5(newinode, (unsigned long) key, 122401b39dccSAmir Goldstein ovl_inode_test, ovl_inode_set, key) : 122501b39dccSAmir Goldstein iget5_locked(sb, (unsigned long) key, 122601b39dccSAmir Goldstein ovl_inode_test, ovl_inode_set, key); 122701b39dccSAmir Goldstein } 122801b39dccSAmir Goldstein 1229ac6a52ebSVivek Goyal struct inode *ovl_get_inode(struct super_block *sb, 1230ac6a52ebSVivek Goyal struct ovl_inode_params *oip) 123151f7e52dSMiklos Szeredi { 1232610afc0bSMiklos Szeredi struct ovl_fs *ofs = OVL_FS(sb); 1233ac6a52ebSVivek Goyal struct dentry *upperdentry = oip->upperdentry; 1234ac6a52ebSVivek Goyal struct ovl_path *lowerpath = oip->lowerpath; 123509d8b586SMiklos Szeredi struct inode *realinode = upperdentry ? d_inode(upperdentry) : NULL; 123651f7e52dSMiklos Szeredi struct inode *inode; 123712574a9fSAmir Goldstein struct dentry *lowerdentry = lowerpath ? lowerpath->dentry : NULL; 1238dad7017aSChristian Brauner struct path realpath = { 1239dad7017aSChristian Brauner .dentry = upperdentry ?: lowerdentry, 1240dad7017aSChristian Brauner .mnt = upperdentry ? ovl_upper_mnt(ofs) : lowerpath->layer->mnt, 1241dad7017aSChristian Brauner }; 1242ac6a52ebSVivek Goyal bool bylower = ovl_hash_bylower(sb, upperdentry, lowerdentry, 1243ac6a52ebSVivek Goyal oip->index); 1244300b124fSAmir Goldstein int fsid = bylower ? lowerpath->layer->fsid : 0; 124528166ab3SVivek Goyal bool is_dir; 1246695b46e7SAmir Goldstein unsigned long ino = 0; 1247acf3062aSAmir Goldstein int err = oip->newinode ? -EEXIST : -ENOMEM; 12486eaf0111SAmir Goldstein 124909d8b586SMiklos Szeredi if (!realinode) 125009d8b586SMiklos Szeredi realinode = d_inode(lowerdentry); 125109d8b586SMiklos Szeredi 12526eaf0111SAmir Goldstein /* 1253764baba8SAmir Goldstein * Copy up origin (lower) may exist for non-indexed upper, but we must 1254764baba8SAmir Goldstein * not use lower as hash key if this is a broken hardlink. 12556eaf0111SAmir Goldstein */ 125631747edaSAmir Goldstein is_dir = S_ISDIR(realinode->i_mode); 1257764baba8SAmir Goldstein if (upperdentry || bylower) { 1258764baba8SAmir Goldstein struct inode *key = d_inode(bylower ? lowerdentry : 1259764baba8SAmir Goldstein upperdentry); 126031747edaSAmir Goldstein unsigned int nlink = is_dir ? 1 : realinode->i_nlink; 1261b9ac5c27SMiklos Szeredi 126201b39dccSAmir Goldstein inode = ovl_iget5(sb, oip->newinode, key); 126309d8b586SMiklos Szeredi if (!inode) 1264027065b7SVivek Goyal goto out_err; 126509d8b586SMiklos Szeredi if (!(inode->i_state & I_NEW)) { 1266b9ac5c27SMiklos Szeredi /* 1267b9ac5c27SMiklos Szeredi * Verify that the underlying files stored in the inode 1268b9ac5c27SMiklos Szeredi * match those in the dentry. 1269b9ac5c27SMiklos Szeredi */ 12704b91c30aSAmir Goldstein if (!ovl_verify_inode(inode, lowerdentry, upperdentry, 12714b91c30aSAmir Goldstein true)) { 1272b9ac5c27SMiklos Szeredi iput(inode); 1273027065b7SVivek Goyal err = -ESTALE; 1274027065b7SVivek Goyal goto out_err; 1275b9ac5c27SMiklos Szeredi } 1276b9ac5c27SMiklos Szeredi 127709d8b586SMiklos Szeredi dput(upperdentry); 12789cec54c8SVivek Goyal kfree(oip->redirect); 127909d8b586SMiklos Szeredi goto out; 128009d8b586SMiklos Szeredi } 1281e9be9d5eSMiklos Szeredi 128231747edaSAmir Goldstein /* Recalculate nlink for non-dir due to indexing */ 128331747edaSAmir Goldstein if (!is_dir) 1284610afc0bSMiklos Szeredi nlink = ovl_get_nlink(ofs, lowerdentry, upperdentry, 1285610afc0bSMiklos Szeredi nlink); 12865f8415d6SAmir Goldstein set_nlink(inode, nlink); 1287695b46e7SAmir Goldstein ino = key->i_ino; 1288e6d2ebddSMiklos Szeredi } else { 1289764baba8SAmir Goldstein /* Lower hardlink that will be broken on copy up */ 12900aceb53eSAmir Goldstein inode = new_inode(sb); 1291027065b7SVivek Goyal if (!inode) { 1292027065b7SVivek Goyal err = -ENOMEM; 1293027065b7SVivek Goyal goto out_err; 1294027065b7SVivek Goyal } 1295300b124fSAmir Goldstein ino = realinode->i_ino; 1296300b124fSAmir Goldstein fsid = lowerpath->layer->fsid; 1297e6d2ebddSMiklos Szeredi } 129862c832edSAmir Goldstein ovl_fill_inode(inode, realinode->i_mode, realinode->i_rdev); 129962c832edSAmir Goldstein ovl_inode_init(inode, oip, ino, fsid); 130013c72075SMiklos Szeredi 1301610afc0bSMiklos Szeredi if (upperdentry && ovl_is_impuredir(sb, upperdentry)) 130213c72075SMiklos Szeredi ovl_set_flag(OVL_IMPURE, inode); 130313c72075SMiklos Szeredi 1304ac6a52ebSVivek Goyal if (oip->index) 13050471a9cdSVivek Goyal ovl_set_flag(OVL_INDEX, inode); 13060471a9cdSVivek Goyal 13079cec54c8SVivek Goyal OVL_I(inode)->redirect = oip->redirect; 13089cec54c8SVivek Goyal 1309a00c2d59SVivek Goyal if (bylower) 1310a00c2d59SVivek Goyal ovl_set_flag(OVL_CONST_INO, inode); 1311a00c2d59SVivek Goyal 1312b79e05aaSAmir Goldstein /* Check for non-merge dir that may have whiteouts */ 131331747edaSAmir Goldstein if (is_dir) { 1314ac6a52ebSVivek Goyal if (((upperdentry && lowerdentry) || oip->numlower > 1) || 1315dad7017aSChristian Brauner ovl_path_check_origin_xattr(ofs, &realpath)) { 1316b79e05aaSAmir Goldstein ovl_set_flag(OVL_WHITEOUTS, inode); 1317b79e05aaSAmir Goldstein } 1318b79e05aaSAmir Goldstein } 1319b79e05aaSAmir Goldstein 1320096a218aSAmir Goldstein /* Check for immutable/append-only inode flags in xattr */ 1321096a218aSAmir Goldstein if (upperdentry) 1322096a218aSAmir Goldstein ovl_check_protattr(inode, upperdentry); 1323096a218aSAmir Goldstein 1324e6d2ebddSMiklos Szeredi if (inode->i_state & I_NEW) 1325e6d2ebddSMiklos Szeredi unlock_new_inode(inode); 1326e6d2ebddSMiklos Szeredi out: 1327e9be9d5eSMiklos Szeredi return inode; 1328b9ac5c27SMiklos Szeredi 1329027065b7SVivek Goyal out_err: 13301bd0a3aeSlijiazi pr_warn_ratelimited("failed to get inode (%i)\n", err); 1331027065b7SVivek Goyal inode = ERR_PTR(err); 1332b9ac5c27SMiklos Szeredi goto out; 1333e9be9d5eSMiklos Szeredi } 1334