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> 17e9be9d5eSMiklos Szeredi #include "overlayfs.h" 18e9be9d5eSMiklos Szeredi 19ba1e563cSChandan Rajendra 20549c7297SChristian Brauner int ovl_setattr(struct user_namespace *mnt_userns, struct dentry *dentry, 21549c7297SChristian Brauner struct iattr *attr) 22e9be9d5eSMiklos Szeredi { 23e9be9d5eSMiklos Szeredi int err; 24a15506eaSChristian Brauner struct ovl_fs *ofs = OVL_FS(dentry->d_sb); 25997336f2SVivek Goyal bool full_copy_up = false; 26e9be9d5eSMiklos Szeredi struct dentry *upperdentry; 271175b6b8SVivek Goyal const struct cred *old_cred; 28e9be9d5eSMiklos Szeredi 292f221d6fSChristian Brauner err = setattr_prepare(&init_user_ns, dentry, attr); 30cf9a6784SMiklos Szeredi if (err) 31cf9a6784SMiklos Szeredi return err; 32cf9a6784SMiklos Szeredi 33e9be9d5eSMiklos Szeredi err = ovl_want_write(dentry); 34e9be9d5eSMiklos Szeredi if (err) 35e9be9d5eSMiklos Szeredi goto out; 36e9be9d5eSMiklos Szeredi 375812160eSMiklos Szeredi if (attr->ia_valid & ATTR_SIZE) { 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 61e67f0216SVivek Goyal /* 6215fd2ea9SVivek Goyal * We might have to translate ovl file into real file object 6315fd2ea9SVivek Goyal * once use cases emerge. For now, simply don't let underlying 6415fd2ea9SVivek Goyal * filesystem rely on attr->ia_file 65e67f0216SVivek Goyal */ 66e67f0216SVivek Goyal attr->ia_valid &= ~ATTR_FILE; 67e67f0216SVivek Goyal 6815fd2ea9SVivek Goyal /* 6915fd2ea9SVivek Goyal * If open(O_TRUNC) is done, VFS calls ->setattr with ATTR_OPEN 7015fd2ea9SVivek Goyal * set. Overlayfs does not pass O_TRUNC flag to underlying 7115fd2ea9SVivek Goyal * filesystem during open -> do not pass ATTR_OPEN. This 7215fd2ea9SVivek Goyal * disables optimization in fuse which assumes open(O_TRUNC) 7315fd2ea9SVivek Goyal * already set file size to 0. But we never passed O_TRUNC to 7415fd2ea9SVivek Goyal * fuse. So by clearing ATTR_OPEN, fuse will be forced to send 7515fd2ea9SVivek Goyal * setattr request to server. 7615fd2ea9SVivek Goyal */ 7715fd2ea9SVivek Goyal attr->ia_valid &= ~ATTR_OPEN; 7815fd2ea9SVivek Goyal 795955102cSAl Viro inode_lock(upperdentry->d_inode); 801175b6b8SVivek Goyal old_cred = ovl_override_creds(dentry->d_sb); 81a15506eaSChristian Brauner err = ovl_do_notify_change(ofs, upperdentry, attr); 821175b6b8SVivek Goyal revert_creds(old_cred); 83b81de061SKonstantin Khlebnikov if (!err) 842878dffcSChristian Brauner ovl_copyattr(dentry->d_inode); 855955102cSAl Viro inode_unlock(upperdentry->d_inode); 865812160eSMiklos Szeredi 875812160eSMiklos Szeredi if (winode) 885812160eSMiklos Szeredi put_write_access(winode); 89e9be9d5eSMiklos Szeredi } 905812160eSMiklos Szeredi out_drop_write: 91e9be9d5eSMiklos Szeredi ovl_drop_write(dentry); 92e9be9d5eSMiklos Szeredi out: 93e9be9d5eSMiklos Szeredi return err; 94e9be9d5eSMiklos Szeredi } 95e9be9d5eSMiklos Szeredi 96c68e7ec5Syoungjun static void ovl_map_dev_ino(struct dentry *dentry, struct kstat *stat, int fsid) 97da309e8cSAmir Goldstein { 980f831ec8SAmir Goldstein bool samefs = ovl_same_fs(dentry->d_sb); 99e487d889SAmir Goldstein unsigned int xinobits = ovl_xino_bits(dentry->d_sb); 100dfe51d47SAmir Goldstein unsigned int xinoshift = 64 - xinobits; 101da309e8cSAmir Goldstein 102da309e8cSAmir Goldstein if (samefs) { 103da309e8cSAmir Goldstein /* 104da309e8cSAmir Goldstein * When all layers are on the same fs, all real inode 105da309e8cSAmir Goldstein * number are unique, so we use the overlay st_dev, 106da309e8cSAmir Goldstein * which is friendly to du -x. 107da309e8cSAmir Goldstein */ 108da309e8cSAmir Goldstein stat->dev = dentry->d_sb->s_dev; 109c68e7ec5Syoungjun return; 110e487d889SAmir Goldstein } else if (xinobits) { 111e487d889SAmir Goldstein /* 112e487d889SAmir Goldstein * All inode numbers of underlying fs should not be using the 113e487d889SAmir Goldstein * high xinobits, so we use high xinobits to partition the 114e487d889SAmir Goldstein * overlay st_ino address space. The high bits holds the fsid 115dfe51d47SAmir Goldstein * (upper fsid is 0). The lowest xinobit is reserved for mapping 116f48bbfb2SBhaskar Chowdhury * the non-persistent inode numbers range in case of overflow. 117dfe51d47SAmir Goldstein * This way all overlay inode numbers are unique and use the 118dfe51d47SAmir Goldstein * overlay st_dev. 119e487d889SAmir Goldstein */ 120926e94d7SAmir Goldstein if (likely(!(stat->ino >> xinoshift))) { 121dfe51d47SAmir Goldstein stat->ino |= ((u64)fsid) << (xinoshift + 1); 122e487d889SAmir Goldstein stat->dev = dentry->d_sb->s_dev; 123c68e7ec5Syoungjun return; 124926e94d7SAmir Goldstein } else if (ovl_xino_warn(dentry->d_sb)) { 125926e94d7SAmir Goldstein pr_warn_ratelimited("inode number too big (%pd2, ino=%llu, xinobits=%d)\n", 126926e94d7SAmir Goldstein dentry, stat->ino, xinobits); 127e487d889SAmir Goldstein } 128e487d889SAmir Goldstein } 129e487d889SAmir Goldstein 130e487d889SAmir Goldstein /* The inode could not be mapped to a unified st_ino address space */ 131e487d889SAmir Goldstein if (S_ISDIR(dentry->d_inode->i_mode)) { 132da309e8cSAmir Goldstein /* 133da309e8cSAmir Goldstein * Always use the overlay st_dev for directories, so 'find 134da309e8cSAmir Goldstein * -xdev' will scan the entire overlay mount and won't cross the 135da309e8cSAmir Goldstein * overlay mount boundaries. 136da309e8cSAmir Goldstein * 137da309e8cSAmir Goldstein * If not all layers are on the same fs the pair {real st_ino; 138da309e8cSAmir Goldstein * overlay st_dev} is not unique, so use the non persistent 139da309e8cSAmir Goldstein * overlay st_ino for directories. 140da309e8cSAmir Goldstein */ 141da309e8cSAmir Goldstein stat->dev = dentry->d_sb->s_dev; 142da309e8cSAmir Goldstein stat->ino = dentry->d_inode->i_ino; 143b7bf9908SAmir Goldstein } else { 144da309e8cSAmir Goldstein /* 145da309e8cSAmir Goldstein * For non-samefs setup, if we cannot map all layers st_ino 146da309e8cSAmir Goldstein * to a unified address space, we need to make sure that st_dev 147b7bf9908SAmir Goldstein * is unique per underlying fs, so we use the unique anonymous 148b7bf9908SAmir Goldstein * bdev assigned to the underlying fs. 149da309e8cSAmir Goldstein */ 15007f1e596SAmir Goldstein stat->dev = OVL_FS(dentry->d_sb)->fs[fsid].pseudo_dev; 151da309e8cSAmir Goldstein } 152da309e8cSAmir Goldstein } 153da309e8cSAmir Goldstein 154549c7297SChristian Brauner int ovl_getattr(struct user_namespace *mnt_userns, const struct path *path, 155549c7297SChristian Brauner struct kstat *stat, u32 request_mask, unsigned int flags) 156e9be9d5eSMiklos Szeredi { 157a528d35eSDavid Howells struct dentry *dentry = path->dentry; 15872b608f0SAmir Goldstein enum ovl_path_type type; 159e9be9d5eSMiklos Szeredi struct path realpath; 1601175b6b8SVivek Goyal const struct cred *old_cred; 161096a218aSAmir Goldstein struct inode *inode = d_inode(dentry); 162096a218aSAmir Goldstein bool is_dir = S_ISDIR(inode->i_mode); 16307f1e596SAmir Goldstein int fsid = 0; 1641175b6b8SVivek Goyal int err; 16567d756c2SVivek Goyal bool metacopy_blocks = false; 16667d756c2SVivek Goyal 16767d756c2SVivek Goyal metacopy_blocks = ovl_is_metacopy_dentry(dentry); 168e9be9d5eSMiklos Szeredi 16972b608f0SAmir Goldstein type = ovl_path_real(dentry, &realpath); 1701175b6b8SVivek Goyal old_cred = ovl_override_creds(dentry->d_sb); 171a528d35eSDavid Howells err = vfs_getattr(&realpath, stat, request_mask, flags); 17272b608f0SAmir Goldstein if (err) 17372b608f0SAmir Goldstein goto out; 17472b608f0SAmir Goldstein 175096a218aSAmir Goldstein /* Report the effective immutable/append-only STATX flags */ 176096a218aSAmir Goldstein generic_fill_statx_attr(inode, stat); 177096a218aSAmir Goldstein 17872b608f0SAmir Goldstein /* 179da309e8cSAmir Goldstein * For non-dir or same fs, we use st_ino of the copy up origin. 180da309e8cSAmir Goldstein * This guaranties constant st_dev/st_ino across copy up. 181e487d889SAmir Goldstein * With xino feature and non-samefs, we use st_ino of the copy up 182e487d889SAmir Goldstein * origin masked with high bits that represent the layer id. 18372b608f0SAmir Goldstein * 184da309e8cSAmir Goldstein * If lower filesystem supports NFS file handles, this also guaranties 18572b608f0SAmir Goldstein * persistent st_ino across mount cycle. 18672b608f0SAmir Goldstein */ 1870f831ec8SAmir Goldstein if (!is_dir || ovl_same_dev(dentry->d_sb)) { 188da309e8cSAmir Goldstein if (!OVL_TYPE_UPPER(type)) { 18907f1e596SAmir Goldstein fsid = ovl_layer_lower(dentry)->fsid; 190da309e8cSAmir Goldstein } else if (OVL_TYPE_ORIGIN(type)) { 19172b608f0SAmir Goldstein struct kstat lowerstat; 19267d756c2SVivek Goyal u32 lowermask = STATX_INO | STATX_BLOCKS | 19367d756c2SVivek Goyal (!is_dir ? STATX_NLINK : 0); 19472b608f0SAmir Goldstein 19572b608f0SAmir Goldstein ovl_path_lower(dentry, &realpath); 19672b608f0SAmir Goldstein err = vfs_getattr(&realpath, &lowerstat, 1975b712091SMiklos Szeredi lowermask, flags); 19872b608f0SAmir Goldstein if (err) 19972b608f0SAmir Goldstein goto out; 20072b608f0SAmir Goldstein 20172b608f0SAmir Goldstein /* 202359f392cSAmir Goldstein * Lower hardlinks may be broken on copy up to different 20372b608f0SAmir Goldstein * upper files, so we cannot use the lower origin st_ino 20472b608f0SAmir Goldstein * for those different files, even for the same fs case. 20586eaa130SAmir Goldstein * 20686eaa130SAmir Goldstein * Similarly, several redirected dirs can point to the 20786eaa130SAmir Goldstein * same dir on a lower layer. With the "verify_lower" 20886eaa130SAmir Goldstein * feature, we do not use the lower origin st_ino, if 20986eaa130SAmir Goldstein * we haven't verified that this redirect is unique. 21086eaa130SAmir Goldstein * 211359f392cSAmir Goldstein * With inodes index enabled, it is safe to use st_ino 21286eaa130SAmir Goldstein * of an indexed origin. The index validates that the 21386eaa130SAmir Goldstein * upper hardlink is not broken and that a redirected 21486eaa130SAmir Goldstein * dir is the only redirect to that origin. 21572b608f0SAmir Goldstein */ 21686eaa130SAmir Goldstein if (ovl_test_flag(OVL_INDEX, d_inode(dentry)) || 21786eaa130SAmir Goldstein (!ovl_verify_lower(dentry->d_sb) && 2189f99e50dSAmir Goldstein (is_dir || lowerstat.nlink == 1))) { 21907f1e596SAmir Goldstein fsid = ovl_layer_lower(dentry)->fsid; 2209c6d8f13SAmir Goldstein stat->ino = lowerstat.ino; 22172b608f0SAmir Goldstein } 22267d756c2SVivek Goyal 22367d756c2SVivek Goyal /* 22467d756c2SVivek Goyal * If we are querying a metacopy dentry and lower 22567d756c2SVivek Goyal * dentry is data dentry, then use the blocks we 22667d756c2SVivek Goyal * queried just now. We don't have to do additional 22767d756c2SVivek Goyal * vfs_getattr(). If lower itself is metacopy, then 22867d756c2SVivek Goyal * additional vfs_getattr() is unavoidable. 22967d756c2SVivek Goyal */ 23067d756c2SVivek Goyal if (metacopy_blocks && 23167d756c2SVivek Goyal realpath.dentry == ovl_dentry_lowerdata(dentry)) { 23267d756c2SVivek Goyal stat->blocks = lowerstat.blocks; 23367d756c2SVivek Goyal metacopy_blocks = false; 23467d756c2SVivek Goyal } 23567d756c2SVivek Goyal } 23667d756c2SVivek Goyal 23767d756c2SVivek Goyal if (metacopy_blocks) { 23867d756c2SVivek Goyal /* 23967d756c2SVivek Goyal * If lower is not same as lowerdata or if there was 24067d756c2SVivek Goyal * no origin on upper, we can end up here. 24167d756c2SVivek Goyal */ 24267d756c2SVivek Goyal struct kstat lowerdatastat; 24367d756c2SVivek Goyal u32 lowermask = STATX_BLOCKS; 24467d756c2SVivek Goyal 24567d756c2SVivek Goyal ovl_path_lowerdata(dentry, &realpath); 24667d756c2SVivek Goyal err = vfs_getattr(&realpath, &lowerdatastat, 24767d756c2SVivek Goyal lowermask, flags); 24867d756c2SVivek Goyal if (err) 24967d756c2SVivek Goyal goto out; 25067d756c2SVivek Goyal stat->blocks = lowerdatastat.blocks; 2519f99e50dSAmir Goldstein } 252a0c5ad30SAmir Goldstein } 253da309e8cSAmir Goldstein 254c68e7ec5Syoungjun ovl_map_dev_ino(dentry, stat, fsid); 2555b712091SMiklos Szeredi 2565b712091SMiklos Szeredi /* 2575b712091SMiklos Szeredi * It's probably not worth it to count subdirs to get the 2585b712091SMiklos Szeredi * correct link count. nlink=1 seems to pacify 'find' and 2595b712091SMiklos Szeredi * other utilities. 2605b712091SMiklos Szeredi */ 2615b712091SMiklos Szeredi if (is_dir && OVL_TYPE_MERGE(type)) 2625b712091SMiklos Szeredi stat->nlink = 1; 2635b712091SMiklos Szeredi 2645f8415d6SAmir Goldstein /* 2655f8415d6SAmir Goldstein * Return the overlay inode nlinks for indexed upper inodes. 2665f8415d6SAmir Goldstein * Overlay inode nlink counts the union of the upper hardlinks 2675f8415d6SAmir Goldstein * and non-covered lower hardlinks. It does not include the upper 2685f8415d6SAmir Goldstein * index hardlink. 2695f8415d6SAmir Goldstein */ 2705f8415d6SAmir Goldstein if (!is_dir && ovl_test_flag(OVL_INDEX, d_inode(dentry))) 2715f8415d6SAmir Goldstein stat->nlink = dentry->d_inode->i_nlink; 2725f8415d6SAmir Goldstein 27372b608f0SAmir Goldstein out: 2741175b6b8SVivek Goyal revert_creds(old_cred); 27572b608f0SAmir Goldstein 2761175b6b8SVivek Goyal return err; 277e9be9d5eSMiklos Szeredi } 278e9be9d5eSMiklos Szeredi 279549c7297SChristian Brauner int ovl_permission(struct user_namespace *mnt_userns, 280549c7297SChristian Brauner struct inode *inode, int mask) 281e9be9d5eSMiklos Szeredi { 28209d8b586SMiklos Szeredi struct inode *upperinode = ovl_inode_upper(inode); 2834b7791b2SChristian Brauner struct inode *realinode; 2844b7791b2SChristian Brauner struct path realpath; 285c0ca3d70SVivek Goyal const struct cred *old_cred; 286e9be9d5eSMiklos Szeredi int err; 287e9be9d5eSMiklos Szeredi 288e9be9d5eSMiklos Szeredi /* Careful in RCU walk mode */ 2894b7791b2SChristian Brauner ovl_i_path_real(inode, &realpath); 2904b7791b2SChristian Brauner if (!realpath.dentry) { 291e9be9d5eSMiklos Szeredi WARN_ON(!(mask & MAY_NOT_BLOCK)); 292a999d7e1SMiklos Szeredi return -ECHILD; 293e9be9d5eSMiklos Szeredi } 294e9be9d5eSMiklos Szeredi 295c0ca3d70SVivek Goyal /* 296c0ca3d70SVivek Goyal * Check overlay inode with the creds of task and underlying inode 297c0ca3d70SVivek Goyal * with creds of mounter 298c0ca3d70SVivek Goyal */ 29947291baaSChristian Brauner err = generic_permission(&init_user_ns, inode, mask); 300c0ca3d70SVivek Goyal if (err) 301c0ca3d70SVivek Goyal return err; 302c0ca3d70SVivek Goyal 3034b7791b2SChristian Brauner realinode = d_inode(realpath.dentry); 304ec7ba118SMiklos Szeredi old_cred = ovl_override_creds(inode->i_sb); 305ec7ba118SMiklos Szeredi if (!upperinode && 306ec7ba118SMiklos Szeredi !special_file(realinode->i_mode) && mask & MAY_WRITE) { 307754f8cb7SVivek Goyal mask &= ~(MAY_WRITE | MAY_APPEND); 308ec7ba118SMiklos Szeredi /* Make sure mounter can read file for copy up later */ 309500cac3cSVivek Goyal mask |= MAY_READ; 310500cac3cSVivek Goyal } 3114b7791b2SChristian Brauner err = inode_permission(mnt_user_ns(realpath.mnt), realinode, mask); 312c0ca3d70SVivek Goyal revert_creds(old_cred); 313c0ca3d70SVivek Goyal 314c0ca3d70SVivek Goyal return err; 315e9be9d5eSMiklos Szeredi } 316e9be9d5eSMiklos Szeredi 3176b255391SAl Viro static const char *ovl_get_link(struct dentry *dentry, 318fceef393SAl Viro struct inode *inode, 319fceef393SAl Viro struct delayed_call *done) 320e9be9d5eSMiklos Szeredi { 3211175b6b8SVivek Goyal const struct cred *old_cred; 3221175b6b8SVivek Goyal const char *p; 323e9be9d5eSMiklos Szeredi 3246b255391SAl Viro if (!dentry) 3256b255391SAl Viro return ERR_PTR(-ECHILD); 3266b255391SAl Viro 3271175b6b8SVivek Goyal old_cred = ovl_override_creds(dentry->d_sb); 3287764235bSMiklos Szeredi p = vfs_get_link(ovl_dentry_real(dentry), done); 3291175b6b8SVivek Goyal revert_creds(old_cred); 3301175b6b8SVivek Goyal return p; 331e9be9d5eSMiklos Szeredi } 332e9be9d5eSMiklos Szeredi 333610afc0bSMiklos Szeredi bool ovl_is_private_xattr(struct super_block *sb, const char *name) 334e9be9d5eSMiklos Szeredi { 3352d2f2d73SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 3362d2f2d73SMiklos Szeredi 3372d2f2d73SMiklos Szeredi if (ofs->config.userxattr) 3382d2f2d73SMiklos Szeredi return strncmp(name, OVL_XATTR_USER_PREFIX, 3392d2f2d73SMiklos Szeredi sizeof(OVL_XATTR_USER_PREFIX) - 1) == 0; 3402d2f2d73SMiklos Szeredi else 3412d2f2d73SMiklos Szeredi return strncmp(name, OVL_XATTR_TRUSTED_PREFIX, 3422d2f2d73SMiklos Szeredi sizeof(OVL_XATTR_TRUSTED_PREFIX) - 1) == 0; 343e9be9d5eSMiklos Szeredi } 344e9be9d5eSMiklos Szeredi 3451d88f183SMiklos Szeredi int ovl_xattr_set(struct dentry *dentry, struct inode *inode, const char *name, 3461d88f183SMiklos Szeredi const void *value, size_t size, int flags) 347e9be9d5eSMiklos Szeredi { 348e9be9d5eSMiklos Szeredi int err; 349c914c0e2SAmir Goldstein struct ovl_fs *ofs = OVL_FS(dentry->d_sb); 3501d88f183SMiklos Szeredi struct dentry *upperdentry = ovl_i_dentry_upper(inode); 3511d88f183SMiklos Szeredi struct dentry *realdentry = upperdentry ?: ovl_dentry_lower(dentry); 3528bc0095dSChristian Brauner struct path realpath; 3531175b6b8SVivek Goyal const struct cred *old_cred; 354e9be9d5eSMiklos Szeredi 355e9be9d5eSMiklos Szeredi err = ovl_want_write(dentry); 356e9be9d5eSMiklos Szeredi if (err) 357e9be9d5eSMiklos Szeredi goto out; 358e9be9d5eSMiklos Szeredi 3591d88f183SMiklos Szeredi if (!value && !upperdentry) { 3608bc0095dSChristian Brauner ovl_path_lower(dentry, &realpath); 361554677b9SMiklos Szeredi old_cred = ovl_override_creds(dentry->d_sb); 3628bc0095dSChristian Brauner err = vfs_getxattr(mnt_user_ns(realpath.mnt), realdentry, name, NULL, 0); 363554677b9SMiklos Szeredi revert_creds(old_cred); 3640e585cccSAndreas Gruenbacher if (err < 0) 3650e585cccSAndreas Gruenbacher goto out_drop_write; 3660e585cccSAndreas Gruenbacher } 3670e585cccSAndreas Gruenbacher 3681d88f183SMiklos Szeredi if (!upperdentry) { 369e9be9d5eSMiklos Szeredi err = ovl_copy_up(dentry); 370e9be9d5eSMiklos Szeredi if (err) 371e9be9d5eSMiklos Szeredi goto out_drop_write; 372e9be9d5eSMiklos Szeredi 3731d88f183SMiklos Szeredi realdentry = ovl_dentry_upper(dentry); 3741d88f183SMiklos Szeredi } 3750e585cccSAndreas Gruenbacher 3761175b6b8SVivek Goyal old_cred = ovl_override_creds(dentry->d_sb); 377c914c0e2SAmir Goldstein if (value) { 378c914c0e2SAmir Goldstein err = ovl_do_setxattr(ofs, realdentry, name, value, size, 379c7c7a1a1STycho Andersen flags); 380c914c0e2SAmir Goldstein } else { 3810e585cccSAndreas Gruenbacher WARN_ON(flags != XATTR_REPLACE); 382c914c0e2SAmir Goldstein err = ovl_do_removexattr(ofs, realdentry, name); 3830e585cccSAndreas Gruenbacher } 3841175b6b8SVivek Goyal revert_creds(old_cred); 385e9be9d5eSMiklos Szeredi 386d9854c87SMiklos Szeredi /* copy c/mtime */ 3872878dffcSChristian Brauner ovl_copyattr(inode); 388d9854c87SMiklos Szeredi 389e9be9d5eSMiklos Szeredi out_drop_write: 390e9be9d5eSMiklos Szeredi ovl_drop_write(dentry); 391e9be9d5eSMiklos Szeredi out: 392e9be9d5eSMiklos Szeredi return err; 393e9be9d5eSMiklos Szeredi } 394e9be9d5eSMiklos Szeredi 3951d88f183SMiklos Szeredi int ovl_xattr_get(struct dentry *dentry, struct inode *inode, const char *name, 3960eb45fc3SAndreas Gruenbacher void *value, size_t size) 397e9be9d5eSMiklos Szeredi { 3981175b6b8SVivek Goyal ssize_t res; 3991175b6b8SVivek Goyal const struct cred *old_cred; 4008bc0095dSChristian Brauner struct path realpath; 40152148463SMiklos Szeredi 4028bc0095dSChristian Brauner ovl_i_path_real(inode, &realpath); 4031175b6b8SVivek Goyal old_cred = ovl_override_creds(dentry->d_sb); 4048bc0095dSChristian Brauner res = vfs_getxattr(mnt_user_ns(realpath.mnt), realpath.dentry, name, value, size); 4051175b6b8SVivek Goyal revert_creds(old_cred); 4061175b6b8SVivek Goyal return res; 407e9be9d5eSMiklos Szeredi } 408e9be9d5eSMiklos Szeredi 409610afc0bSMiklos Szeredi static bool ovl_can_list(struct super_block *sb, const char *s) 410a082c6f6SMiklos Szeredi { 4118f6ee74cSMiklos Szeredi /* Never list private (.overlay) */ 4128f6ee74cSMiklos Szeredi if (ovl_is_private_xattr(sb, s)) 4138f6ee74cSMiklos Szeredi return false; 4148f6ee74cSMiklos Szeredi 415f48bbfb2SBhaskar Chowdhury /* List all non-trusted xattrs */ 416a082c6f6SMiklos Szeredi if (strncmp(s, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) != 0) 417a082c6f6SMiklos Szeredi return true; 418a082c6f6SMiklos Szeredi 4198f6ee74cSMiklos Szeredi /* list other trusted for superuser only */ 4208f6ee74cSMiklos Szeredi return ns_capable_noaudit(&init_user_ns, CAP_SYS_ADMIN); 421a082c6f6SMiklos Szeredi } 422a082c6f6SMiklos Szeredi 423e9be9d5eSMiklos Szeredi ssize_t ovl_listxattr(struct dentry *dentry, char *list, size_t size) 424e9be9d5eSMiklos Szeredi { 425b581755bSMiklos Szeredi struct dentry *realdentry = ovl_dentry_real(dentry); 426e9be9d5eSMiklos Szeredi ssize_t res; 4277cb35119SMiklos Szeredi size_t len; 4287cb35119SMiklos Szeredi char *s; 4291175b6b8SVivek Goyal const struct cred *old_cred; 430e9be9d5eSMiklos Szeredi 4311175b6b8SVivek Goyal old_cred = ovl_override_creds(dentry->d_sb); 432b581755bSMiklos Szeredi res = vfs_listxattr(realdentry, list, size); 4331175b6b8SVivek Goyal revert_creds(old_cred); 434e9be9d5eSMiklos Szeredi if (res <= 0 || size == 0) 435e9be9d5eSMiklos Szeredi return res; 436e9be9d5eSMiklos Szeredi 437e9be9d5eSMiklos Szeredi /* filter out private xattrs */ 4387cb35119SMiklos Szeredi for (s = list, len = res; len;) { 4397cb35119SMiklos Szeredi size_t slen = strnlen(s, len) + 1; 440e9be9d5eSMiklos Szeredi 4417cb35119SMiklos Szeredi /* underlying fs providing us with an broken xattr list? */ 4427cb35119SMiklos Szeredi if (WARN_ON(slen > len)) 4437cb35119SMiklos Szeredi return -EIO; 444e9be9d5eSMiklos Szeredi 4457cb35119SMiklos Szeredi len -= slen; 446610afc0bSMiklos Szeredi if (!ovl_can_list(dentry->d_sb, s)) { 447e9be9d5eSMiklos Szeredi res -= slen; 4487cb35119SMiklos Szeredi memmove(s, s + slen, len); 449e9be9d5eSMiklos Szeredi } else { 4507cb35119SMiklos Szeredi s += slen; 451e9be9d5eSMiklos Szeredi } 452e9be9d5eSMiklos Szeredi } 453e9be9d5eSMiklos Szeredi 454e9be9d5eSMiklos Szeredi return res; 455e9be9d5eSMiklos Szeredi } 456e9be9d5eSMiklos Szeredi 457*ded53656SYang Xu #ifdef CONFIG_FS_POSIX_ACL 4580cad6246SMiklos Szeredi struct posix_acl *ovl_get_acl(struct inode *inode, int type, bool rcu) 45939a25b2bSVivek Goyal { 46009d8b586SMiklos Szeredi struct inode *realinode = ovl_inode_real(inode); 4611175b6b8SVivek Goyal const struct cred *old_cred; 4621175b6b8SVivek Goyal struct posix_acl *acl; 46339a25b2bSVivek Goyal 464*ded53656SYang Xu if (!IS_POSIXACL(realinode)) 46539a25b2bSVivek Goyal return NULL; 46639a25b2bSVivek Goyal 467332f606bSMiklos Szeredi if (rcu) 468332f606bSMiklos Szeredi return get_cached_acl_rcu(realinode, type); 469332f606bSMiklos Szeredi 4701175b6b8SVivek Goyal old_cred = ovl_override_creds(inode->i_sb); 4715201dc44SMiklos Szeredi acl = get_acl(realinode, type); 4721175b6b8SVivek Goyal revert_creds(old_cred); 4731175b6b8SVivek Goyal 4741175b6b8SVivek Goyal return acl; 47539a25b2bSVivek Goyal } 476*ded53656SYang Xu #endif 47739a25b2bSVivek Goyal 47895582b00SDeepa Dinamani int ovl_update_time(struct inode *inode, struct timespec64 *ts, int flags) 479d719e8f2SMiklos Szeredi { 4808f35cf51SMiklos Szeredi if (flags & S_ATIME) { 4818f35cf51SMiklos Szeredi struct ovl_fs *ofs = inode->i_sb->s_fs_info; 4828f35cf51SMiklos Szeredi struct path upperpath = { 48308f4c7c8SMiklos Szeredi .mnt = ovl_upper_mnt(ofs), 4848f35cf51SMiklos Szeredi .dentry = ovl_upperdentry_dereference(OVL_I(inode)), 4858f35cf51SMiklos Szeredi }; 486d719e8f2SMiklos Szeredi 487d719e8f2SMiklos Szeredi if (upperpath.dentry) { 488d719e8f2SMiklos Szeredi touch_atime(&upperpath); 489d719e8f2SMiklos Szeredi inode->i_atime = d_inode(upperpath.dentry)->i_atime; 490d719e8f2SMiklos Szeredi } 4918f35cf51SMiklos Szeredi } 492d719e8f2SMiklos Szeredi return 0; 493d719e8f2SMiklos Szeredi } 494d719e8f2SMiklos Szeredi 4959e142c41SMiklos Szeredi static int ovl_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, 4969e142c41SMiklos Szeredi u64 start, u64 len) 4979e142c41SMiklos Szeredi { 4989e142c41SMiklos Szeredi int err; 499c11faf32SChengguang Xu struct inode *realinode = ovl_inode_realdata(inode); 5009e142c41SMiklos Szeredi const struct cred *old_cred; 5019e142c41SMiklos Szeredi 5029e142c41SMiklos Szeredi if (!realinode->i_op->fiemap) 5039e142c41SMiklos Szeredi return -EOPNOTSUPP; 5049e142c41SMiklos Szeredi 5059e142c41SMiklos Szeredi old_cred = ovl_override_creds(inode->i_sb); 5069e142c41SMiklos Szeredi err = realinode->i_op->fiemap(realinode, fieinfo, start, len); 5079e142c41SMiklos Szeredi revert_creds(old_cred); 5089e142c41SMiklos Szeredi 5099e142c41SMiklos Szeredi return err; 5109e142c41SMiklos Szeredi } 5119e142c41SMiklos Szeredi 51266dbfabfSMiklos Szeredi /* 51366dbfabfSMiklos Szeredi * Work around the fact that security_file_ioctl() takes a file argument. 51466dbfabfSMiklos Szeredi * Introducing security_inode_fileattr_get/set() hooks would solve this issue 51566dbfabfSMiklos Szeredi * properly. 51666dbfabfSMiklos Szeredi */ 51772db8211SAmir Goldstein static int ovl_security_fileattr(struct path *realpath, struct fileattr *fa, 51866dbfabfSMiklos Szeredi bool set) 51966dbfabfSMiklos Szeredi { 52066dbfabfSMiklos Szeredi struct file *file; 52166dbfabfSMiklos Szeredi unsigned int cmd; 52266dbfabfSMiklos Szeredi int err; 52366dbfabfSMiklos Szeredi 52472db8211SAmir Goldstein file = dentry_open(realpath, O_RDONLY, current_cred()); 52566dbfabfSMiklos Szeredi if (IS_ERR(file)) 52666dbfabfSMiklos Szeredi return PTR_ERR(file); 52766dbfabfSMiklos Szeredi 52866dbfabfSMiklos Szeredi if (set) 52966dbfabfSMiklos Szeredi cmd = fa->fsx_valid ? FS_IOC_FSSETXATTR : FS_IOC_SETFLAGS; 53066dbfabfSMiklos Szeredi else 53166dbfabfSMiklos Szeredi cmd = fa->fsx_valid ? FS_IOC_FSGETXATTR : FS_IOC_GETFLAGS; 53266dbfabfSMiklos Szeredi 53366dbfabfSMiklos Szeredi err = security_file_ioctl(file, cmd, 0); 53466dbfabfSMiklos Szeredi fput(file); 53566dbfabfSMiklos Szeredi 53666dbfabfSMiklos Szeredi return err; 53766dbfabfSMiklos Szeredi } 53866dbfabfSMiklos Szeredi 53972db8211SAmir Goldstein int ovl_real_fileattr_set(struct path *realpath, struct fileattr *fa) 54072db8211SAmir Goldstein { 54172db8211SAmir Goldstein int err; 54272db8211SAmir Goldstein 54372db8211SAmir Goldstein err = ovl_security_fileattr(realpath, fa, true); 54472db8211SAmir Goldstein if (err) 54572db8211SAmir Goldstein return err; 54672db8211SAmir Goldstein 54750db8d02SChristian Brauner return vfs_fileattr_set(mnt_user_ns(realpath->mnt), realpath->dentry, fa); 54872db8211SAmir Goldstein } 54972db8211SAmir Goldstein 55066dbfabfSMiklos Szeredi int ovl_fileattr_set(struct user_namespace *mnt_userns, 55166dbfabfSMiklos Szeredi struct dentry *dentry, struct fileattr *fa) 55266dbfabfSMiklos Szeredi { 55366dbfabfSMiklos Szeredi struct inode *inode = d_inode(dentry); 55472db8211SAmir Goldstein struct path upperpath; 55566dbfabfSMiklos Szeredi const struct cred *old_cred; 556096a218aSAmir Goldstein unsigned int flags; 55766dbfabfSMiklos Szeredi int err; 55866dbfabfSMiklos Szeredi 55966dbfabfSMiklos Szeredi err = ovl_want_write(dentry); 56066dbfabfSMiklos Szeredi if (err) 56166dbfabfSMiklos Szeredi goto out; 56266dbfabfSMiklos Szeredi 56366dbfabfSMiklos Szeredi err = ovl_copy_up(dentry); 56466dbfabfSMiklos Szeredi if (!err) { 56572db8211SAmir Goldstein ovl_path_real(dentry, &upperpath); 56666dbfabfSMiklos Szeredi 56766dbfabfSMiklos Szeredi old_cred = ovl_override_creds(inode->i_sb); 568096a218aSAmir Goldstein /* 569096a218aSAmir Goldstein * Store immutable/append-only flags in xattr and clear them 570096a218aSAmir Goldstein * in upper fileattr (in case they were set by older kernel) 571096a218aSAmir Goldstein * so children of "ovl-immutable" directories lower aliases of 572096a218aSAmir Goldstein * "ovl-immutable" hardlinks could be copied up. 573096a218aSAmir Goldstein * Clear xattr when flags are cleared. 574096a218aSAmir Goldstein */ 575096a218aSAmir Goldstein err = ovl_set_protattr(inode, upperpath.dentry, fa); 576096a218aSAmir Goldstein if (!err) 57772db8211SAmir Goldstein err = ovl_real_fileattr_set(&upperpath, fa); 57866dbfabfSMiklos Szeredi revert_creds(old_cred); 579096a218aSAmir Goldstein 580096a218aSAmir Goldstein /* 581096a218aSAmir Goldstein * Merge real inode flags with inode flags read from 582096a218aSAmir Goldstein * overlay.protattr xattr 583096a218aSAmir Goldstein */ 584096a218aSAmir Goldstein flags = ovl_inode_real(inode)->i_flags & OVL_COPY_I_FLAGS_MASK; 585096a218aSAmir Goldstein 586096a218aSAmir Goldstein BUILD_BUG_ON(OVL_PROT_I_FLAGS_MASK & ~OVL_COPY_I_FLAGS_MASK); 587096a218aSAmir Goldstein flags |= inode->i_flags & OVL_PROT_I_FLAGS_MASK; 588096a218aSAmir Goldstein inode_set_flags(inode, flags, OVL_COPY_I_FLAGS_MASK); 589d8991e86SChengguang Xu 590d8991e86SChengguang Xu /* Update ctime */ 5912878dffcSChristian Brauner ovl_copyattr(inode); 59266dbfabfSMiklos Szeredi } 59366dbfabfSMiklos Szeredi ovl_drop_write(dentry); 59466dbfabfSMiklos Szeredi out: 59566dbfabfSMiklos Szeredi return err; 59666dbfabfSMiklos Szeredi } 59766dbfabfSMiklos Szeredi 598096a218aSAmir Goldstein /* Convert inode protection flags to fileattr flags */ 599096a218aSAmir Goldstein static void ovl_fileattr_prot_flags(struct inode *inode, struct fileattr *fa) 600096a218aSAmir Goldstein { 601096a218aSAmir Goldstein BUILD_BUG_ON(OVL_PROT_FS_FLAGS_MASK & ~FS_COMMON_FL); 602096a218aSAmir Goldstein BUILD_BUG_ON(OVL_PROT_FSX_FLAGS_MASK & ~FS_XFLAG_COMMON); 603096a218aSAmir Goldstein 604096a218aSAmir Goldstein if (inode->i_flags & S_APPEND) { 605096a218aSAmir Goldstein fa->flags |= FS_APPEND_FL; 606096a218aSAmir Goldstein fa->fsx_xflags |= FS_XFLAG_APPEND; 607096a218aSAmir Goldstein } 608096a218aSAmir Goldstein if (inode->i_flags & S_IMMUTABLE) { 609096a218aSAmir Goldstein fa->flags |= FS_IMMUTABLE_FL; 610096a218aSAmir Goldstein fa->fsx_xflags |= FS_XFLAG_IMMUTABLE; 611096a218aSAmir Goldstein } 612096a218aSAmir Goldstein } 613096a218aSAmir Goldstein 61472db8211SAmir Goldstein int ovl_real_fileattr_get(struct path *realpath, struct fileattr *fa) 61572db8211SAmir Goldstein { 61672db8211SAmir Goldstein int err; 61772db8211SAmir Goldstein 61872db8211SAmir Goldstein err = ovl_security_fileattr(realpath, fa, false); 61972db8211SAmir Goldstein if (err) 62072db8211SAmir Goldstein return err; 62172db8211SAmir Goldstein 6225b0a414dSMiklos Szeredi err = vfs_fileattr_get(realpath->dentry, fa); 6235b0a414dSMiklos Szeredi if (err == -ENOIOCTLCMD) 6245b0a414dSMiklos Szeredi err = -ENOTTY; 6255b0a414dSMiklos Szeredi return err; 62672db8211SAmir Goldstein } 62772db8211SAmir Goldstein 62866dbfabfSMiklos Szeredi int ovl_fileattr_get(struct dentry *dentry, struct fileattr *fa) 62966dbfabfSMiklos Szeredi { 63066dbfabfSMiklos Szeredi struct inode *inode = d_inode(dentry); 63172db8211SAmir Goldstein struct path realpath; 63266dbfabfSMiklos Szeredi const struct cred *old_cred; 63366dbfabfSMiklos Szeredi int err; 63466dbfabfSMiklos Szeredi 63572db8211SAmir Goldstein ovl_path_real(dentry, &realpath); 63672db8211SAmir Goldstein 63766dbfabfSMiklos Szeredi old_cred = ovl_override_creds(inode->i_sb); 63872db8211SAmir Goldstein err = ovl_real_fileattr_get(&realpath, fa); 639096a218aSAmir Goldstein ovl_fileattr_prot_flags(inode, fa); 64066dbfabfSMiklos Szeredi revert_creds(old_cred); 64166dbfabfSMiklos Szeredi 64266dbfabfSMiklos Szeredi return err; 64366dbfabfSMiklos Szeredi } 64466dbfabfSMiklos Szeredi 645e9be9d5eSMiklos Szeredi static const struct inode_operations ovl_file_inode_operations = { 646e9be9d5eSMiklos Szeredi .setattr = ovl_setattr, 647e9be9d5eSMiklos Szeredi .permission = ovl_permission, 648e9be9d5eSMiklos Szeredi .getattr = ovl_getattr, 649e9be9d5eSMiklos Szeredi .listxattr = ovl_listxattr, 65039a25b2bSVivek Goyal .get_acl = ovl_get_acl, 651d719e8f2SMiklos Szeredi .update_time = ovl_update_time, 6529e142c41SMiklos Szeredi .fiemap = ovl_fiemap, 65366dbfabfSMiklos Szeredi .fileattr_get = ovl_fileattr_get, 65466dbfabfSMiklos Szeredi .fileattr_set = ovl_fileattr_set, 655e9be9d5eSMiklos Szeredi }; 656e9be9d5eSMiklos Szeredi 657e9be9d5eSMiklos Szeredi static const struct inode_operations ovl_symlink_inode_operations = { 658e9be9d5eSMiklos Szeredi .setattr = ovl_setattr, 6596b255391SAl Viro .get_link = ovl_get_link, 660e9be9d5eSMiklos Szeredi .getattr = ovl_getattr, 661e9be9d5eSMiklos Szeredi .listxattr = ovl_listxattr, 662d719e8f2SMiklos Szeredi .update_time = ovl_update_time, 663e9be9d5eSMiklos Szeredi }; 664e9be9d5eSMiklos Szeredi 6659e142c41SMiklos Szeredi static const struct inode_operations ovl_special_inode_operations = { 6669e142c41SMiklos Szeredi .setattr = ovl_setattr, 6679e142c41SMiklos Szeredi .permission = ovl_permission, 6689e142c41SMiklos Szeredi .getattr = ovl_getattr, 6699e142c41SMiklos Szeredi .listxattr = ovl_listxattr, 6709e142c41SMiklos Szeredi .get_acl = ovl_get_acl, 6719e142c41SMiklos Szeredi .update_time = ovl_update_time, 6729e142c41SMiklos Szeredi }; 6739e142c41SMiklos Szeredi 67469383c59SWei Yongjun static const struct address_space_operations ovl_aops = { 6755b910bd6SAmir Goldstein /* For O_DIRECT dentry_open() checks f_mapping->a_ops->direct_IO */ 6765b910bd6SAmir Goldstein .direct_IO = noop_direct_IO, 6775b910bd6SAmir Goldstein }; 6785b910bd6SAmir Goldstein 679b1eaa950SAmir Goldstein /* 680b1eaa950SAmir Goldstein * It is possible to stack overlayfs instance on top of another 681a5a84682SChengguang Xu * overlayfs instance as lower layer. We need to annotate the 682b1eaa950SAmir Goldstein * stackable i_mutex locks according to stack level of the super 683b1eaa950SAmir Goldstein * block instance. An overlayfs instance can never be in stack 684b1eaa950SAmir Goldstein * depth 0 (there is always a real fs below it). An overlayfs 685f48bbfb2SBhaskar Chowdhury * inode lock will use the lockdep annotation ovl_i_mutex_key[depth]. 686b1eaa950SAmir Goldstein * 687b1eaa950SAmir Goldstein * For example, here is a snip from /proc/lockdep_chains after 688b1eaa950SAmir Goldstein * dir_iterate of nested overlayfs: 689b1eaa950SAmir Goldstein * 690b1eaa950SAmir Goldstein * [...] &ovl_i_mutex_dir_key[depth] (stack_depth=2) 691b1eaa950SAmir Goldstein * [...] &ovl_i_mutex_dir_key[depth]#2 (stack_depth=1) 692b1eaa950SAmir Goldstein * [...] &type->i_mutex_dir_key (stack_depth=0) 693b1f9d385SAmir Goldstein * 694b1f9d385SAmir Goldstein * Locking order w.r.t ovl_want_write() is important for nested overlayfs. 695b1f9d385SAmir Goldstein * 696b1f9d385SAmir Goldstein * This chain is valid: 697b1f9d385SAmir Goldstein * - inode->i_rwsem (inode_lock[2]) 698b1f9d385SAmir Goldstein * - upper_mnt->mnt_sb->s_writers (ovl_want_write[0]) 699b1f9d385SAmir Goldstein * - OVL_I(inode)->lock (ovl_inode_lock[2]) 700b1f9d385SAmir Goldstein * - OVL_I(lowerinode)->lock (ovl_inode_lock[1]) 701b1f9d385SAmir Goldstein * 702b1f9d385SAmir Goldstein * And this chain is valid: 703b1f9d385SAmir Goldstein * - inode->i_rwsem (inode_lock[2]) 704b1f9d385SAmir Goldstein * - OVL_I(inode)->lock (ovl_inode_lock[2]) 705b1f9d385SAmir Goldstein * - lowerinode->i_rwsem (inode_lock[1]) 706b1f9d385SAmir Goldstein * - OVL_I(lowerinode)->lock (ovl_inode_lock[1]) 707b1f9d385SAmir Goldstein * 708b1f9d385SAmir Goldstein * But lowerinode->i_rwsem SHOULD NOT be acquired while ovl_want_write() is 709b1f9d385SAmir Goldstein * held, because it is in reverse order of the non-nested case using the same 710b1f9d385SAmir Goldstein * upper fs: 711b1f9d385SAmir Goldstein * - inode->i_rwsem (inode_lock[1]) 712b1f9d385SAmir Goldstein * - upper_mnt->mnt_sb->s_writers (ovl_want_write[0]) 713b1f9d385SAmir Goldstein * - OVL_I(inode)->lock (ovl_inode_lock[1]) 714b1eaa950SAmir Goldstein */ 715b1eaa950SAmir Goldstein #define OVL_MAX_NESTING FILESYSTEM_MAX_STACK_DEPTH 716b1eaa950SAmir Goldstein 717b1eaa950SAmir Goldstein static inline void ovl_lockdep_annotate_inode_mutex_key(struct inode *inode) 718b1eaa950SAmir Goldstein { 719b1eaa950SAmir Goldstein #ifdef CONFIG_LOCKDEP 720b1eaa950SAmir Goldstein static struct lock_class_key ovl_i_mutex_key[OVL_MAX_NESTING]; 721b1eaa950SAmir Goldstein static struct lock_class_key ovl_i_mutex_dir_key[OVL_MAX_NESTING]; 7224eae06deSAmir Goldstein static struct lock_class_key ovl_i_lock_key[OVL_MAX_NESTING]; 723b1eaa950SAmir Goldstein 724b1eaa950SAmir Goldstein int depth = inode->i_sb->s_stack_depth - 1; 725b1eaa950SAmir Goldstein 726b1eaa950SAmir Goldstein if (WARN_ON_ONCE(depth < 0 || depth >= OVL_MAX_NESTING)) 727b1eaa950SAmir Goldstein depth = 0; 728b1eaa950SAmir Goldstein 729b1eaa950SAmir Goldstein if (S_ISDIR(inode->i_mode)) 730b1eaa950SAmir Goldstein lockdep_set_class(&inode->i_rwsem, &ovl_i_mutex_dir_key[depth]); 731b1eaa950SAmir Goldstein else 732b1eaa950SAmir Goldstein lockdep_set_class(&inode->i_rwsem, &ovl_i_mutex_key[depth]); 7334eae06deSAmir Goldstein 7344eae06deSAmir Goldstein lockdep_set_class(&OVL_I(inode)->lock, &ovl_i_lock_key[depth]); 735b1eaa950SAmir Goldstein #endif 736b1eaa950SAmir Goldstein } 737b1eaa950SAmir Goldstein 7384d314f78SAmir Goldstein static void ovl_next_ino(struct inode *inode) 7394d314f78SAmir Goldstein { 7404d314f78SAmir Goldstein struct ovl_fs *ofs = inode->i_sb->s_fs_info; 7414d314f78SAmir Goldstein 7424d314f78SAmir Goldstein inode->i_ino = atomic_long_inc_return(&ofs->last_ino); 7434d314f78SAmir Goldstein if (unlikely(!inode->i_ino)) 7444d314f78SAmir Goldstein inode->i_ino = atomic_long_inc_return(&ofs->last_ino); 7454d314f78SAmir Goldstein } 7464d314f78SAmir Goldstein 74762c832edSAmir Goldstein static void ovl_map_ino(struct inode *inode, unsigned long ino, int fsid) 748e9be9d5eSMiklos Szeredi { 74912574a9fSAmir Goldstein int xinobits = ovl_xino_bits(inode->i_sb); 750dfe51d47SAmir Goldstein unsigned int xinoshift = 64 - xinobits; 75112574a9fSAmir Goldstein 752695b46e7SAmir Goldstein /* 7536dde1e42SAmir Goldstein * When d_ino is consistent with st_ino (samefs or i_ino has enough 7546dde1e42SAmir Goldstein * bits to encode layer), set the same value used for st_ino to i_ino, 7556dde1e42SAmir Goldstein * so inode number exposed via /proc/locks and a like will be 7566dde1e42SAmir Goldstein * consistent with d_ino and st_ino values. An i_ino value inconsistent 757735c907dSAmir Goldstein * with d_ino also causes nfsd readdirplus to fail. 758695b46e7SAmir Goldstein */ 759695b46e7SAmir Goldstein inode->i_ino = ino; 760dfe51d47SAmir Goldstein if (ovl_same_fs(inode->i_sb)) { 761dfe51d47SAmir Goldstein return; 762dfe51d47SAmir Goldstein } else if (xinobits && likely(!(ino >> xinoshift))) { 763dfe51d47SAmir Goldstein inode->i_ino |= (unsigned long)fsid << (xinoshift + 1); 764dfe51d47SAmir Goldstein return; 765dfe51d47SAmir Goldstein } 766dfe51d47SAmir Goldstein 767dfe51d47SAmir Goldstein /* 768dfe51d47SAmir Goldstein * For directory inodes on non-samefs with xino disabled or xino 769dfe51d47SAmir Goldstein * overflow, we allocate a non-persistent inode number, to be used for 770dfe51d47SAmir Goldstein * resolving st_ino collisions in ovl_map_dev_ino(). 771dfe51d47SAmir Goldstein * 772dfe51d47SAmir Goldstein * To avoid ino collision with legitimate xino values from upper 773dfe51d47SAmir Goldstein * layer (fsid 0), use the lowest xinobit to map the non 774dfe51d47SAmir Goldstein * persistent inode numbers to the unified st_ino address space. 775dfe51d47SAmir Goldstein */ 776dfe51d47SAmir Goldstein if (S_ISDIR(inode->i_mode)) { 7774d314f78SAmir Goldstein ovl_next_ino(inode); 778dfe51d47SAmir Goldstein if (xinobits) { 779dfe51d47SAmir Goldstein inode->i_ino &= ~0UL >> xinobits; 780dfe51d47SAmir Goldstein inode->i_ino |= 1UL << xinoshift; 781dfe51d47SAmir Goldstein } 78212574a9fSAmir Goldstein } 78362c832edSAmir Goldstein } 78462c832edSAmir Goldstein 78562c832edSAmir Goldstein void ovl_inode_init(struct inode *inode, struct ovl_inode_params *oip, 78662c832edSAmir Goldstein unsigned long ino, int fsid) 78762c832edSAmir Goldstein { 78862c832edSAmir Goldstein struct inode *realinode; 789ffa5723cSAmir Goldstein struct ovl_inode *oi = OVL_I(inode); 79062c832edSAmir Goldstein 79162c832edSAmir Goldstein if (oip->upperdentry) 792ffa5723cSAmir Goldstein oi->__upperdentry = oip->upperdentry; 793ffa5723cSAmir Goldstein if (oip->lowerpath && oip->lowerpath->dentry) { 794ffa5723cSAmir Goldstein oi->lowerpath.dentry = dget(oip->lowerpath->dentry); 795ffa5723cSAmir Goldstein oi->lowerpath.layer = oip->lowerpath->layer; 796ffa5723cSAmir Goldstein } 79762c832edSAmir Goldstein if (oip->lowerdata) 798ffa5723cSAmir Goldstein oi->lowerdata = igrab(d_inode(oip->lowerdata)); 79962c832edSAmir Goldstein 80062c832edSAmir Goldstein realinode = ovl_inode_real(inode); 8012878dffcSChristian Brauner ovl_copyattr(inode); 80262c832edSAmir Goldstein ovl_copyflags(realinode, inode); 80362c832edSAmir Goldstein ovl_map_ino(inode, ino, fsid); 80462c832edSAmir Goldstein } 80562c832edSAmir Goldstein 80662c832edSAmir Goldstein static void ovl_fill_inode(struct inode *inode, umode_t mode, dev_t rdev) 80762c832edSAmir Goldstein { 808e9be9d5eSMiklos Szeredi inode->i_mode = mode; 809d719e8f2SMiklos Szeredi inode->i_flags |= S_NOCMTIME; 8102a3a2a3fSMiklos Szeredi #ifdef CONFIG_FS_POSIX_ACL 8112a3a2a3fSMiklos Szeredi inode->i_acl = inode->i_default_acl = ACL_DONT_CACHE; 8122a3a2a3fSMiklos Szeredi #endif 813e9be9d5eSMiklos Szeredi 814b1eaa950SAmir Goldstein ovl_lockdep_annotate_inode_mutex_key(inode); 815b1eaa950SAmir Goldstein 816ca4c8a3aSMiklos Szeredi switch (mode & S_IFMT) { 817ca4c8a3aSMiklos Szeredi case S_IFREG: 818ca4c8a3aSMiklos Szeredi inode->i_op = &ovl_file_inode_operations; 819d1d04ef8SMiklos Szeredi inode->i_fop = &ovl_file_operations; 8205b910bd6SAmir Goldstein inode->i_mapping->a_ops = &ovl_aops; 821ca4c8a3aSMiklos Szeredi break; 822ca4c8a3aSMiklos Szeredi 823e9be9d5eSMiklos Szeredi case S_IFDIR: 824e9be9d5eSMiklos Szeredi inode->i_op = &ovl_dir_inode_operations; 825e9be9d5eSMiklos Szeredi inode->i_fop = &ovl_dir_operations; 826e9be9d5eSMiklos Szeredi break; 827e9be9d5eSMiklos Szeredi 828e9be9d5eSMiklos Szeredi case S_IFLNK: 829e9be9d5eSMiklos Szeredi inode->i_op = &ovl_symlink_inode_operations; 830e9be9d5eSMiklos Szeredi break; 831e9be9d5eSMiklos Szeredi 83251f7e52dSMiklos Szeredi default: 8339e142c41SMiklos Szeredi inode->i_op = &ovl_special_inode_operations; 834ca4c8a3aSMiklos Szeredi init_special_inode(inode, mode, rdev); 835e9be9d5eSMiklos Szeredi break; 83651f7e52dSMiklos Szeredi } 83751f7e52dSMiklos Szeredi } 838e9be9d5eSMiklos Szeredi 8395f8415d6SAmir Goldstein /* 8405f8415d6SAmir Goldstein * With inodes index enabled, an overlay inode nlink counts the union of upper 8415f8415d6SAmir Goldstein * hardlinks and non-covered lower hardlinks. During the lifetime of a non-pure 8425f8415d6SAmir Goldstein * upper inode, the following nlink modifying operations can happen: 8435f8415d6SAmir Goldstein * 8445f8415d6SAmir Goldstein * 1. Lower hardlink copy up 8455f8415d6SAmir Goldstein * 2. Upper hardlink created, unlinked or renamed over 8465f8415d6SAmir Goldstein * 3. Lower hardlink whiteout or renamed over 8475f8415d6SAmir Goldstein * 8485f8415d6SAmir Goldstein * For the first, copy up case, the union nlink does not change, whether the 8495f8415d6SAmir Goldstein * operation succeeds or fails, but the upper inode nlink may change. 8505f8415d6SAmir Goldstein * Therefore, before copy up, we store the union nlink value relative to the 8512d2f2d73SMiklos Szeredi * lower inode nlink in the index inode xattr .overlay.nlink. 8525f8415d6SAmir Goldstein * 8535f8415d6SAmir Goldstein * For the second, upper hardlink case, the union nlink should be incremented 8545f8415d6SAmir Goldstein * or decremented IFF the operation succeeds, aligned with nlink change of the 8555f8415d6SAmir Goldstein * upper inode. Therefore, before link/unlink/rename, we store the union nlink 8565f8415d6SAmir Goldstein * value relative to the upper inode nlink in the index inode. 8575f8415d6SAmir Goldstein * 8585f8415d6SAmir Goldstein * For the last, lower cover up case, we simplify things by preceding the 8595f8415d6SAmir Goldstein * whiteout or cover up with copy up. This makes sure that there is an index 8605f8415d6SAmir Goldstein * upper inode where the nlink xattr can be stored before the copied up upper 8615f8415d6SAmir Goldstein * entry is unlink. 8625f8415d6SAmir Goldstein */ 8635f8415d6SAmir Goldstein #define OVL_NLINK_ADD_UPPER (1 << 0) 8645f8415d6SAmir Goldstein 8655f8415d6SAmir Goldstein /* 8665f8415d6SAmir Goldstein * On-disk format for indexed nlink: 8675f8415d6SAmir Goldstein * 8685f8415d6SAmir Goldstein * nlink relative to the upper inode - "U[+-]NUM" 8695f8415d6SAmir Goldstein * nlink relative to the lower inode - "L[+-]NUM" 8705f8415d6SAmir Goldstein */ 8715f8415d6SAmir Goldstein 8725f8415d6SAmir Goldstein static int ovl_set_nlink_common(struct dentry *dentry, 8735f8415d6SAmir Goldstein struct dentry *realdentry, const char *format) 8745f8415d6SAmir Goldstein { 8755f8415d6SAmir Goldstein struct inode *inode = d_inode(dentry); 8765f8415d6SAmir Goldstein struct inode *realinode = d_inode(realdentry); 8775f8415d6SAmir Goldstein char buf[13]; 8785f8415d6SAmir Goldstein int len; 8795f8415d6SAmir Goldstein 8805f8415d6SAmir Goldstein len = snprintf(buf, sizeof(buf), format, 8815f8415d6SAmir Goldstein (int) (inode->i_nlink - realinode->i_nlink)); 8825f8415d6SAmir Goldstein 8836787341aSMiklos Szeredi if (WARN_ON(len >= sizeof(buf))) 8846787341aSMiklos Szeredi return -EIO; 8856787341aSMiklos Szeredi 886c914c0e2SAmir Goldstein return ovl_setxattr(OVL_FS(inode->i_sb), ovl_dentry_upper(dentry), 88726150ab5SMiklos Szeredi OVL_XATTR_NLINK, buf, len); 8885f8415d6SAmir Goldstein } 8895f8415d6SAmir Goldstein 8905f8415d6SAmir Goldstein int ovl_set_nlink_upper(struct dentry *dentry) 8915f8415d6SAmir Goldstein { 8925f8415d6SAmir Goldstein return ovl_set_nlink_common(dentry, ovl_dentry_upper(dentry), "U%+i"); 8935f8415d6SAmir Goldstein } 8945f8415d6SAmir Goldstein 8955f8415d6SAmir Goldstein int ovl_set_nlink_lower(struct dentry *dentry) 8965f8415d6SAmir Goldstein { 8975f8415d6SAmir Goldstein return ovl_set_nlink_common(dentry, ovl_dentry_lower(dentry), "L%+i"); 8985f8415d6SAmir Goldstein } 8995f8415d6SAmir Goldstein 900610afc0bSMiklos Szeredi unsigned int ovl_get_nlink(struct ovl_fs *ofs, struct dentry *lowerdentry, 9015f8415d6SAmir Goldstein struct dentry *upperdentry, 9025f8415d6SAmir Goldstein unsigned int fallback) 9035f8415d6SAmir Goldstein { 9045f8415d6SAmir Goldstein int nlink_diff; 9055f8415d6SAmir Goldstein int nlink; 9065f8415d6SAmir Goldstein char buf[13]; 9075f8415d6SAmir Goldstein int err; 9085f8415d6SAmir Goldstein 9095f8415d6SAmir Goldstein if (!lowerdentry || !upperdentry || d_inode(lowerdentry)->i_nlink == 1) 9105f8415d6SAmir Goldstein return fallback; 9115f8415d6SAmir Goldstein 912dad7017aSChristian Brauner err = ovl_getxattr_upper(ofs, upperdentry, OVL_XATTR_NLINK, 913d5dc7486SMiklos Szeredi &buf, sizeof(buf) - 1); 9145f8415d6SAmir Goldstein if (err < 0) 9155f8415d6SAmir Goldstein goto fail; 9165f8415d6SAmir Goldstein 9175f8415d6SAmir Goldstein buf[err] = '\0'; 9185f8415d6SAmir Goldstein if ((buf[0] != 'L' && buf[0] != 'U') || 9195f8415d6SAmir Goldstein (buf[1] != '+' && buf[1] != '-')) 9205f8415d6SAmir Goldstein goto fail; 9215f8415d6SAmir Goldstein 9225f8415d6SAmir Goldstein err = kstrtoint(buf + 1, 10, &nlink_diff); 9235f8415d6SAmir Goldstein if (err < 0) 9245f8415d6SAmir Goldstein goto fail; 9255f8415d6SAmir Goldstein 9265f8415d6SAmir Goldstein nlink = d_inode(buf[0] == 'L' ? lowerdentry : upperdentry)->i_nlink; 9275f8415d6SAmir Goldstein nlink += nlink_diff; 9285f8415d6SAmir Goldstein 9295f8415d6SAmir Goldstein if (nlink <= 0) 9305f8415d6SAmir Goldstein goto fail; 9315f8415d6SAmir Goldstein 9325f8415d6SAmir Goldstein return nlink; 9335f8415d6SAmir Goldstein 9345f8415d6SAmir Goldstein fail: 9351bd0a3aeSlijiazi pr_warn_ratelimited("failed to get index nlink (%pd2, err=%i)\n", 9365f8415d6SAmir Goldstein upperdentry, err); 9375f8415d6SAmir Goldstein return fallback; 9385f8415d6SAmir Goldstein } 9395f8415d6SAmir Goldstein 940ca4c8a3aSMiklos Szeredi struct inode *ovl_new_inode(struct super_block *sb, umode_t mode, dev_t rdev) 94151f7e52dSMiklos Szeredi { 94251f7e52dSMiklos Szeredi struct inode *inode; 94351f7e52dSMiklos Szeredi 94451f7e52dSMiklos Szeredi inode = new_inode(sb); 94551f7e52dSMiklos Szeredi if (inode) 94662c832edSAmir Goldstein ovl_fill_inode(inode, mode, rdev); 94751f7e52dSMiklos Szeredi 94851f7e52dSMiklos Szeredi return inode; 94951f7e52dSMiklos Szeredi } 95051f7e52dSMiklos Szeredi 95151f7e52dSMiklos Szeredi static int ovl_inode_test(struct inode *inode, void *data) 95251f7e52dSMiklos Szeredi { 95325b7713aSMiklos Szeredi return inode->i_private == data; 95451f7e52dSMiklos Szeredi } 95551f7e52dSMiklos Szeredi 95651f7e52dSMiklos Szeredi static int ovl_inode_set(struct inode *inode, void *data) 95751f7e52dSMiklos Szeredi { 95825b7713aSMiklos Szeredi inode->i_private = data; 95951f7e52dSMiklos Szeredi return 0; 96051f7e52dSMiklos Szeredi } 96151f7e52dSMiklos Szeredi 962b9ac5c27SMiklos Szeredi static bool ovl_verify_inode(struct inode *inode, struct dentry *lowerdentry, 9634b91c30aSAmir Goldstein struct dentry *upperdentry, bool strict) 964b9ac5c27SMiklos Szeredi { 9654b91c30aSAmir Goldstein /* 9664b91c30aSAmir Goldstein * For directories, @strict verify from lookup path performs consistency 9674b91c30aSAmir Goldstein * checks, so NULL lower/upper in dentry must match NULL lower/upper in 9684b91c30aSAmir Goldstein * inode. Non @strict verify from NFS handle decode path passes NULL for 9694b91c30aSAmir Goldstein * 'unknown' lower/upper. 9704b91c30aSAmir Goldstein */ 9714b91c30aSAmir Goldstein if (S_ISDIR(inode->i_mode) && strict) { 97231747edaSAmir Goldstein /* Real lower dir moved to upper layer under us? */ 97331747edaSAmir Goldstein if (!lowerdentry && ovl_inode_lower(inode)) 97431747edaSAmir Goldstein return false; 97531747edaSAmir Goldstein 97631747edaSAmir Goldstein /* Lookup of an uncovered redirect origin? */ 97731747edaSAmir Goldstein if (!upperdentry && ovl_inode_upper(inode)) 97831747edaSAmir Goldstein return false; 97931747edaSAmir Goldstein } 98031747edaSAmir Goldstein 981939ae4efSAmir Goldstein /* 982939ae4efSAmir Goldstein * Allow non-NULL lower inode in ovl_inode even if lowerdentry is NULL. 983939ae4efSAmir Goldstein * This happens when finding a copied up overlay inode for a renamed 984939ae4efSAmir Goldstein * or hardlinked overlay dentry and lower dentry cannot be followed 985939ae4efSAmir Goldstein * by origin because lower fs does not support file handles. 986939ae4efSAmir Goldstein */ 987939ae4efSAmir Goldstein if (lowerdentry && ovl_inode_lower(inode) != d_inode(lowerdentry)) 988b9ac5c27SMiklos Szeredi return false; 989b9ac5c27SMiklos Szeredi 990b9ac5c27SMiklos Szeredi /* 991b9ac5c27SMiklos Szeredi * Allow non-NULL __upperdentry in inode even if upperdentry is NULL. 992b9ac5c27SMiklos Szeredi * This happens when finding a lower alias for a copied up hard link. 993b9ac5c27SMiklos Szeredi */ 994b9ac5c27SMiklos Szeredi if (upperdentry && ovl_inode_upper(inode) != d_inode(upperdentry)) 995b9ac5c27SMiklos Szeredi return false; 996b9ac5c27SMiklos Szeredi 997b9ac5c27SMiklos Szeredi return true; 998b9ac5c27SMiklos Szeredi } 999b9ac5c27SMiklos Szeredi 10004b91c30aSAmir Goldstein struct inode *ovl_lookup_inode(struct super_block *sb, struct dentry *real, 10014b91c30aSAmir Goldstein bool is_upper) 10029436a1a3SAmir Goldstein { 10034b91c30aSAmir Goldstein struct inode *inode, *key = d_inode(real); 10049436a1a3SAmir Goldstein 10059436a1a3SAmir Goldstein inode = ilookup5(sb, (unsigned long) key, ovl_inode_test, key); 10069436a1a3SAmir Goldstein if (!inode) 10079436a1a3SAmir Goldstein return NULL; 10089436a1a3SAmir Goldstein 10094b91c30aSAmir Goldstein if (!ovl_verify_inode(inode, is_upper ? NULL : real, 10104b91c30aSAmir Goldstein is_upper ? real : NULL, false)) { 10119436a1a3SAmir Goldstein iput(inode); 10129436a1a3SAmir Goldstein return ERR_PTR(-ESTALE); 10139436a1a3SAmir Goldstein } 10149436a1a3SAmir Goldstein 10159436a1a3SAmir Goldstein return inode; 10169436a1a3SAmir Goldstein } 10179436a1a3SAmir Goldstein 1018146d62e5SAmir Goldstein bool ovl_lookup_trap_inode(struct super_block *sb, struct dentry *dir) 1019146d62e5SAmir Goldstein { 1020146d62e5SAmir Goldstein struct inode *key = d_inode(dir); 1021146d62e5SAmir Goldstein struct inode *trap; 1022146d62e5SAmir Goldstein bool res; 1023146d62e5SAmir Goldstein 1024146d62e5SAmir Goldstein trap = ilookup5(sb, (unsigned long) key, ovl_inode_test, key); 1025146d62e5SAmir Goldstein if (!trap) 1026146d62e5SAmir Goldstein return false; 1027146d62e5SAmir Goldstein 1028146d62e5SAmir Goldstein res = IS_DEADDIR(trap) && !ovl_inode_upper(trap) && 1029146d62e5SAmir Goldstein !ovl_inode_lower(trap); 1030146d62e5SAmir Goldstein 1031146d62e5SAmir Goldstein iput(trap); 1032146d62e5SAmir Goldstein return res; 1033146d62e5SAmir Goldstein } 1034146d62e5SAmir Goldstein 1035146d62e5SAmir Goldstein /* 1036146d62e5SAmir Goldstein * Create an inode cache entry for layer root dir, that will intentionally 1037146d62e5SAmir Goldstein * fail ovl_verify_inode(), so any lookup that will find some layer root 1038146d62e5SAmir Goldstein * will fail. 1039146d62e5SAmir Goldstein */ 1040146d62e5SAmir Goldstein struct inode *ovl_get_trap_inode(struct super_block *sb, struct dentry *dir) 1041146d62e5SAmir Goldstein { 1042146d62e5SAmir Goldstein struct inode *key = d_inode(dir); 1043146d62e5SAmir Goldstein struct inode *trap; 1044146d62e5SAmir Goldstein 1045146d62e5SAmir Goldstein if (!d_is_dir(dir)) 1046146d62e5SAmir Goldstein return ERR_PTR(-ENOTDIR); 1047146d62e5SAmir Goldstein 1048146d62e5SAmir Goldstein trap = iget5_locked(sb, (unsigned long) key, ovl_inode_test, 1049146d62e5SAmir Goldstein ovl_inode_set, key); 1050146d62e5SAmir Goldstein if (!trap) 1051146d62e5SAmir Goldstein return ERR_PTR(-ENOMEM); 1052146d62e5SAmir Goldstein 1053146d62e5SAmir Goldstein if (!(trap->i_state & I_NEW)) { 1054146d62e5SAmir Goldstein /* Conflicting layer roots? */ 1055146d62e5SAmir Goldstein iput(trap); 1056146d62e5SAmir Goldstein return ERR_PTR(-ELOOP); 1057146d62e5SAmir Goldstein } 1058146d62e5SAmir Goldstein 1059146d62e5SAmir Goldstein trap->i_mode = S_IFDIR; 1060146d62e5SAmir Goldstein trap->i_flags = S_DEAD; 1061146d62e5SAmir Goldstein unlock_new_inode(trap); 1062146d62e5SAmir Goldstein 1063146d62e5SAmir Goldstein return trap; 1064146d62e5SAmir Goldstein } 1065146d62e5SAmir Goldstein 1066764baba8SAmir Goldstein /* 1067764baba8SAmir Goldstein * Does overlay inode need to be hashed by lower inode? 1068764baba8SAmir Goldstein */ 1069764baba8SAmir Goldstein static bool ovl_hash_bylower(struct super_block *sb, struct dentry *upper, 107074c6e384SMiklos Szeredi struct dentry *lower, bool index) 1071764baba8SAmir Goldstein { 1072764baba8SAmir Goldstein struct ovl_fs *ofs = sb->s_fs_info; 1073764baba8SAmir Goldstein 1074764baba8SAmir Goldstein /* No, if pure upper */ 1075764baba8SAmir Goldstein if (!lower) 1076764baba8SAmir Goldstein return false; 1077764baba8SAmir Goldstein 1078764baba8SAmir Goldstein /* Yes, if already indexed */ 1079764baba8SAmir Goldstein if (index) 1080764baba8SAmir Goldstein return true; 1081764baba8SAmir Goldstein 1082764baba8SAmir Goldstein /* Yes, if won't be copied up */ 108308f4c7c8SMiklos Szeredi if (!ovl_upper_mnt(ofs)) 1084764baba8SAmir Goldstein return true; 1085764baba8SAmir Goldstein 1086764baba8SAmir Goldstein /* No, if lower hardlink is or will be broken on copy up */ 1087764baba8SAmir Goldstein if ((upper || !ovl_indexdir(sb)) && 1088764baba8SAmir Goldstein !d_is_dir(lower) && d_inode(lower)->i_nlink > 1) 1089764baba8SAmir Goldstein return false; 1090764baba8SAmir Goldstein 1091764baba8SAmir Goldstein /* No, if non-indexed upper with NFS export */ 1092764baba8SAmir Goldstein if (sb->s_export_op && upper) 1093764baba8SAmir Goldstein return false; 1094764baba8SAmir Goldstein 1095764baba8SAmir Goldstein /* Otherwise, hash by lower inode for fsnotify */ 1096764baba8SAmir Goldstein return true; 1097764baba8SAmir Goldstein } 1098764baba8SAmir Goldstein 109901b39dccSAmir Goldstein static struct inode *ovl_iget5(struct super_block *sb, struct inode *newinode, 110001b39dccSAmir Goldstein struct inode *key) 110101b39dccSAmir Goldstein { 110201b39dccSAmir Goldstein return newinode ? inode_insert5(newinode, (unsigned long) key, 110301b39dccSAmir Goldstein ovl_inode_test, ovl_inode_set, key) : 110401b39dccSAmir Goldstein iget5_locked(sb, (unsigned long) key, 110501b39dccSAmir Goldstein ovl_inode_test, ovl_inode_set, key); 110601b39dccSAmir Goldstein } 110701b39dccSAmir Goldstein 1108ac6a52ebSVivek Goyal struct inode *ovl_get_inode(struct super_block *sb, 1109ac6a52ebSVivek Goyal struct ovl_inode_params *oip) 111051f7e52dSMiklos Szeredi { 1111610afc0bSMiklos Szeredi struct ovl_fs *ofs = OVL_FS(sb); 1112ac6a52ebSVivek Goyal struct dentry *upperdentry = oip->upperdentry; 1113ac6a52ebSVivek Goyal struct ovl_path *lowerpath = oip->lowerpath; 111409d8b586SMiklos Szeredi struct inode *realinode = upperdentry ? d_inode(upperdentry) : NULL; 111551f7e52dSMiklos Szeredi struct inode *inode; 111612574a9fSAmir Goldstein struct dentry *lowerdentry = lowerpath ? lowerpath->dentry : NULL; 1117dad7017aSChristian Brauner struct path realpath = { 1118dad7017aSChristian Brauner .dentry = upperdentry ?: lowerdentry, 1119dad7017aSChristian Brauner .mnt = upperdentry ? ovl_upper_mnt(ofs) : lowerpath->layer->mnt, 1120dad7017aSChristian Brauner }; 1121ac6a52ebSVivek Goyal bool bylower = ovl_hash_bylower(sb, upperdentry, lowerdentry, 1122ac6a52ebSVivek Goyal oip->index); 1123300b124fSAmir Goldstein int fsid = bylower ? lowerpath->layer->fsid : 0; 112428166ab3SVivek Goyal bool is_dir; 1125695b46e7SAmir Goldstein unsigned long ino = 0; 1126acf3062aSAmir Goldstein int err = oip->newinode ? -EEXIST : -ENOMEM; 11276eaf0111SAmir Goldstein 112809d8b586SMiklos Szeredi if (!realinode) 112909d8b586SMiklos Szeredi realinode = d_inode(lowerdentry); 113009d8b586SMiklos Szeredi 11316eaf0111SAmir Goldstein /* 1132764baba8SAmir Goldstein * Copy up origin (lower) may exist for non-indexed upper, but we must 1133764baba8SAmir Goldstein * not use lower as hash key if this is a broken hardlink. 11346eaf0111SAmir Goldstein */ 113531747edaSAmir Goldstein is_dir = S_ISDIR(realinode->i_mode); 1136764baba8SAmir Goldstein if (upperdentry || bylower) { 1137764baba8SAmir Goldstein struct inode *key = d_inode(bylower ? lowerdentry : 1138764baba8SAmir Goldstein upperdentry); 113931747edaSAmir Goldstein unsigned int nlink = is_dir ? 1 : realinode->i_nlink; 1140b9ac5c27SMiklos Szeredi 114101b39dccSAmir Goldstein inode = ovl_iget5(sb, oip->newinode, key); 114209d8b586SMiklos Szeredi if (!inode) 1143027065b7SVivek Goyal goto out_err; 114409d8b586SMiklos Szeredi if (!(inode->i_state & I_NEW)) { 1145b9ac5c27SMiklos Szeredi /* 1146b9ac5c27SMiklos Szeredi * Verify that the underlying files stored in the inode 1147b9ac5c27SMiklos Szeredi * match those in the dentry. 1148b9ac5c27SMiklos Szeredi */ 11494b91c30aSAmir Goldstein if (!ovl_verify_inode(inode, lowerdentry, upperdentry, 11504b91c30aSAmir Goldstein true)) { 1151b9ac5c27SMiklos Szeredi iput(inode); 1152027065b7SVivek Goyal err = -ESTALE; 1153027065b7SVivek Goyal goto out_err; 1154b9ac5c27SMiklos Szeredi } 1155b9ac5c27SMiklos Szeredi 115609d8b586SMiklos Szeredi dput(upperdentry); 11579cec54c8SVivek Goyal kfree(oip->redirect); 115809d8b586SMiklos Szeredi goto out; 115909d8b586SMiklos Szeredi } 1160e9be9d5eSMiklos Szeredi 116131747edaSAmir Goldstein /* Recalculate nlink for non-dir due to indexing */ 116231747edaSAmir Goldstein if (!is_dir) 1163610afc0bSMiklos Szeredi nlink = ovl_get_nlink(ofs, lowerdentry, upperdentry, 1164610afc0bSMiklos Szeredi nlink); 11655f8415d6SAmir Goldstein set_nlink(inode, nlink); 1166695b46e7SAmir Goldstein ino = key->i_ino; 1167e6d2ebddSMiklos Szeredi } else { 1168764baba8SAmir Goldstein /* Lower hardlink that will be broken on copy up */ 11690aceb53eSAmir Goldstein inode = new_inode(sb); 1170027065b7SVivek Goyal if (!inode) { 1171027065b7SVivek Goyal err = -ENOMEM; 1172027065b7SVivek Goyal goto out_err; 1173027065b7SVivek Goyal } 1174300b124fSAmir Goldstein ino = realinode->i_ino; 1175300b124fSAmir Goldstein fsid = lowerpath->layer->fsid; 1176e6d2ebddSMiklos Szeredi } 117762c832edSAmir Goldstein ovl_fill_inode(inode, realinode->i_mode, realinode->i_rdev); 117862c832edSAmir Goldstein ovl_inode_init(inode, oip, ino, fsid); 117913c72075SMiklos Szeredi 1180610afc0bSMiklos Szeredi if (upperdentry && ovl_is_impuredir(sb, upperdentry)) 118113c72075SMiklos Szeredi ovl_set_flag(OVL_IMPURE, inode); 118213c72075SMiklos Szeredi 1183ac6a52ebSVivek Goyal if (oip->index) 11840471a9cdSVivek Goyal ovl_set_flag(OVL_INDEX, inode); 11850471a9cdSVivek Goyal 11869cec54c8SVivek Goyal OVL_I(inode)->redirect = oip->redirect; 11879cec54c8SVivek Goyal 1188a00c2d59SVivek Goyal if (bylower) 1189a00c2d59SVivek Goyal ovl_set_flag(OVL_CONST_INO, inode); 1190a00c2d59SVivek Goyal 1191b79e05aaSAmir Goldstein /* Check for non-merge dir that may have whiteouts */ 119231747edaSAmir Goldstein if (is_dir) { 1193ac6a52ebSVivek Goyal if (((upperdentry && lowerdentry) || oip->numlower > 1) || 1194dad7017aSChristian Brauner ovl_path_check_origin_xattr(ofs, &realpath)) { 1195b79e05aaSAmir Goldstein ovl_set_flag(OVL_WHITEOUTS, inode); 1196b79e05aaSAmir Goldstein } 1197b79e05aaSAmir Goldstein } 1198b79e05aaSAmir Goldstein 1199096a218aSAmir Goldstein /* Check for immutable/append-only inode flags in xattr */ 1200096a218aSAmir Goldstein if (upperdentry) 1201096a218aSAmir Goldstein ovl_check_protattr(inode, upperdentry); 1202096a218aSAmir Goldstein 1203e6d2ebddSMiklos Szeredi if (inode->i_state & I_NEW) 1204e6d2ebddSMiklos Szeredi unlock_new_inode(inode); 1205e6d2ebddSMiklos Szeredi out: 1206e9be9d5eSMiklos Szeredi return inode; 1207b9ac5c27SMiklos Szeredi 1208027065b7SVivek Goyal out_err: 12091bd0a3aeSlijiazi pr_warn_ratelimited("failed to get inode (%i)\n", err); 1210027065b7SVivek Goyal inode = ERR_PTR(err); 1211b9ac5c27SMiklos Szeredi goto out; 1212e9be9d5eSMiklos Szeredi } 1213