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> 14*66dbfabfSMiklos Szeredi #include <linux/fileattr.h> 15*66dbfabfSMiklos Szeredi #include <linux/security.h> 16e9be9d5eSMiklos Szeredi #include "overlayfs.h" 17e9be9d5eSMiklos Szeredi 18ba1e563cSChandan Rajendra 19549c7297SChristian Brauner int ovl_setattr(struct user_namespace *mnt_userns, struct dentry *dentry, 20549c7297SChristian Brauner struct iattr *attr) 21e9be9d5eSMiklos Szeredi { 22e9be9d5eSMiklos Szeredi int err; 23997336f2SVivek Goyal bool full_copy_up = false; 24e9be9d5eSMiklos Szeredi struct dentry *upperdentry; 251175b6b8SVivek Goyal const struct cred *old_cred; 26e9be9d5eSMiklos Szeredi 272f221d6fSChristian Brauner err = setattr_prepare(&init_user_ns, dentry, attr); 28cf9a6784SMiklos Szeredi if (err) 29cf9a6784SMiklos Szeredi return err; 30cf9a6784SMiklos Szeredi 31e9be9d5eSMiklos Szeredi err = ovl_want_write(dentry); 32e9be9d5eSMiklos Szeredi if (err) 33e9be9d5eSMiklos Szeredi goto out; 34e9be9d5eSMiklos Szeredi 355812160eSMiklos Szeredi if (attr->ia_valid & ATTR_SIZE) { 365812160eSMiklos Szeredi struct inode *realinode = d_inode(ovl_dentry_real(dentry)); 375812160eSMiklos Szeredi 385812160eSMiklos Szeredi err = -ETXTBSY; 395812160eSMiklos Szeredi if (atomic_read(&realinode->i_writecount) < 0) 405812160eSMiklos Szeredi goto out_drop_write; 41997336f2SVivek Goyal 42997336f2SVivek Goyal /* Truncate should trigger data copy up as well */ 43997336f2SVivek Goyal full_copy_up = true; 445812160eSMiklos Szeredi } 455812160eSMiklos Szeredi 46997336f2SVivek Goyal if (!full_copy_up) 47acff81ecSMiklos Szeredi err = ovl_copy_up(dentry); 48997336f2SVivek Goyal else 49997336f2SVivek Goyal err = ovl_copy_up_with_data(dentry); 50acff81ecSMiklos Szeredi if (!err) { 515812160eSMiklos Szeredi struct inode *winode = NULL; 525812160eSMiklos Szeredi 53e9be9d5eSMiklos Szeredi upperdentry = ovl_dentry_upper(dentry); 54acff81ecSMiklos Szeredi 555812160eSMiklos Szeredi if (attr->ia_valid & ATTR_SIZE) { 565812160eSMiklos Szeredi winode = d_inode(upperdentry); 575812160eSMiklos Szeredi err = get_write_access(winode); 585812160eSMiklos Szeredi if (err) 595812160eSMiklos Szeredi goto out_drop_write; 605812160eSMiklos Szeredi } 615812160eSMiklos Szeredi 62b99c2d91SMiklos Szeredi if (attr->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID)) 63b99c2d91SMiklos Szeredi attr->ia_valid &= ~ATTR_MODE; 64b99c2d91SMiklos Szeredi 65e67f0216SVivek Goyal /* 6615fd2ea9SVivek Goyal * We might have to translate ovl file into real file object 6715fd2ea9SVivek Goyal * once use cases emerge. For now, simply don't let underlying 6815fd2ea9SVivek Goyal * filesystem rely on attr->ia_file 69e67f0216SVivek Goyal */ 70e67f0216SVivek Goyal attr->ia_valid &= ~ATTR_FILE; 71e67f0216SVivek Goyal 7215fd2ea9SVivek Goyal /* 7315fd2ea9SVivek Goyal * If open(O_TRUNC) is done, VFS calls ->setattr with ATTR_OPEN 7415fd2ea9SVivek Goyal * set. Overlayfs does not pass O_TRUNC flag to underlying 7515fd2ea9SVivek Goyal * filesystem during open -> do not pass ATTR_OPEN. This 7615fd2ea9SVivek Goyal * disables optimization in fuse which assumes open(O_TRUNC) 7715fd2ea9SVivek Goyal * already set file size to 0. But we never passed O_TRUNC to 7815fd2ea9SVivek Goyal * fuse. So by clearing ATTR_OPEN, fuse will be forced to send 7915fd2ea9SVivek Goyal * setattr request to server. 8015fd2ea9SVivek Goyal */ 8115fd2ea9SVivek Goyal attr->ia_valid &= ~ATTR_OPEN; 8215fd2ea9SVivek Goyal 835955102cSAl Viro inode_lock(upperdentry->d_inode); 841175b6b8SVivek Goyal old_cred = ovl_override_creds(dentry->d_sb); 852f221d6fSChristian Brauner err = notify_change(&init_user_ns, upperdentry, attr, NULL); 861175b6b8SVivek Goyal revert_creds(old_cred); 87b81de061SKonstantin Khlebnikov if (!err) 88b81de061SKonstantin Khlebnikov ovl_copyattr(upperdentry->d_inode, dentry->d_inode); 895955102cSAl Viro inode_unlock(upperdentry->d_inode); 905812160eSMiklos Szeredi 915812160eSMiklos Szeredi if (winode) 925812160eSMiklos Szeredi put_write_access(winode); 93e9be9d5eSMiklos Szeredi } 945812160eSMiklos Szeredi out_drop_write: 95e9be9d5eSMiklos Szeredi ovl_drop_write(dentry); 96e9be9d5eSMiklos Szeredi out: 97e9be9d5eSMiklos Szeredi return err; 98e9be9d5eSMiklos Szeredi } 99e9be9d5eSMiklos Szeredi 10007f1e596SAmir Goldstein static int ovl_map_dev_ino(struct dentry *dentry, struct kstat *stat, int fsid) 101da309e8cSAmir Goldstein { 1020f831ec8SAmir Goldstein bool samefs = ovl_same_fs(dentry->d_sb); 103e487d889SAmir Goldstein unsigned int xinobits = ovl_xino_bits(dentry->d_sb); 104dfe51d47SAmir Goldstein unsigned int xinoshift = 64 - xinobits; 105da309e8cSAmir Goldstein 106da309e8cSAmir Goldstein if (samefs) { 107da309e8cSAmir Goldstein /* 108da309e8cSAmir Goldstein * When all layers are on the same fs, all real inode 109da309e8cSAmir Goldstein * number are unique, so we use the overlay st_dev, 110da309e8cSAmir Goldstein * which is friendly to du -x. 111da309e8cSAmir Goldstein */ 112da309e8cSAmir Goldstein stat->dev = dentry->d_sb->s_dev; 113e487d889SAmir Goldstein return 0; 114e487d889SAmir Goldstein } else if (xinobits) { 115e487d889SAmir Goldstein /* 116e487d889SAmir Goldstein * All inode numbers of underlying fs should not be using the 117e487d889SAmir Goldstein * high xinobits, so we use high xinobits to partition the 118e487d889SAmir Goldstein * overlay st_ino address space. The high bits holds the fsid 119dfe51d47SAmir Goldstein * (upper fsid is 0). The lowest xinobit is reserved for mapping 120dfe51d47SAmir Goldstein * the non-peresistent inode numbers range in case of overflow. 121dfe51d47SAmir Goldstein * This way all overlay inode numbers are unique and use the 122dfe51d47SAmir Goldstein * overlay st_dev. 123e487d889SAmir Goldstein */ 124926e94d7SAmir Goldstein if (likely(!(stat->ino >> xinoshift))) { 125dfe51d47SAmir Goldstein stat->ino |= ((u64)fsid) << (xinoshift + 1); 126e487d889SAmir Goldstein stat->dev = dentry->d_sb->s_dev; 127e487d889SAmir Goldstein return 0; 128926e94d7SAmir Goldstein } else if (ovl_xino_warn(dentry->d_sb)) { 129926e94d7SAmir Goldstein pr_warn_ratelimited("inode number too big (%pd2, ino=%llu, xinobits=%d)\n", 130926e94d7SAmir Goldstein dentry, stat->ino, xinobits); 131e487d889SAmir Goldstein } 132e487d889SAmir Goldstein } 133e487d889SAmir Goldstein 134e487d889SAmir Goldstein /* The inode could not be mapped to a unified st_ino address space */ 135e487d889SAmir Goldstein if (S_ISDIR(dentry->d_inode->i_mode)) { 136da309e8cSAmir Goldstein /* 137da309e8cSAmir Goldstein * Always use the overlay st_dev for directories, so 'find 138da309e8cSAmir Goldstein * -xdev' will scan the entire overlay mount and won't cross the 139da309e8cSAmir Goldstein * overlay mount boundaries. 140da309e8cSAmir Goldstein * 141da309e8cSAmir Goldstein * If not all layers are on the same fs the pair {real st_ino; 142da309e8cSAmir Goldstein * overlay st_dev} is not unique, so use the non persistent 143da309e8cSAmir Goldstein * overlay st_ino for directories. 144da309e8cSAmir Goldstein */ 145da309e8cSAmir Goldstein stat->dev = dentry->d_sb->s_dev; 146da309e8cSAmir Goldstein stat->ino = dentry->d_inode->i_ino; 147b7bf9908SAmir Goldstein } else { 148da309e8cSAmir Goldstein /* 149da309e8cSAmir Goldstein * For non-samefs setup, if we cannot map all layers st_ino 150da309e8cSAmir Goldstein * to a unified address space, we need to make sure that st_dev 151b7bf9908SAmir Goldstein * is unique per underlying fs, so we use the unique anonymous 152b7bf9908SAmir Goldstein * bdev assigned to the underlying fs. 153da309e8cSAmir Goldstein */ 15407f1e596SAmir Goldstein stat->dev = OVL_FS(dentry->d_sb)->fs[fsid].pseudo_dev; 155da309e8cSAmir Goldstein } 156da309e8cSAmir Goldstein 157da309e8cSAmir Goldstein return 0; 158da309e8cSAmir Goldstein } 159da309e8cSAmir Goldstein 160549c7297SChristian Brauner int ovl_getattr(struct user_namespace *mnt_userns, const struct path *path, 161549c7297SChristian Brauner struct kstat *stat, u32 request_mask, unsigned int flags) 162e9be9d5eSMiklos Szeredi { 163a528d35eSDavid Howells struct dentry *dentry = path->dentry; 16472b608f0SAmir Goldstein enum ovl_path_type type; 165e9be9d5eSMiklos Szeredi struct path realpath; 1661175b6b8SVivek Goyal const struct cred *old_cred; 1675b712091SMiklos Szeredi bool is_dir = S_ISDIR(dentry->d_inode->i_mode); 16807f1e596SAmir Goldstein int fsid = 0; 1691175b6b8SVivek Goyal int err; 17067d756c2SVivek Goyal bool metacopy_blocks = false; 17167d756c2SVivek Goyal 17267d756c2SVivek Goyal metacopy_blocks = ovl_is_metacopy_dentry(dentry); 173e9be9d5eSMiklos Szeredi 17472b608f0SAmir Goldstein type = ovl_path_real(dentry, &realpath); 1751175b6b8SVivek Goyal old_cred = ovl_override_creds(dentry->d_sb); 176a528d35eSDavid Howells err = vfs_getattr(&realpath, stat, request_mask, flags); 17772b608f0SAmir Goldstein if (err) 17872b608f0SAmir Goldstein goto out; 17972b608f0SAmir 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 25607f1e596SAmir Goldstein err = ovl_map_dev_ino(dentry, stat, fsid); 257da309e8cSAmir Goldstein if (err) 258da309e8cSAmir Goldstein goto out; 2595b712091SMiklos Szeredi 2605b712091SMiklos Szeredi /* 2615b712091SMiklos Szeredi * It's probably not worth it to count subdirs to get the 2625b712091SMiklos Szeredi * correct link count. nlink=1 seems to pacify 'find' and 2635b712091SMiklos Szeredi * other utilities. 2645b712091SMiklos Szeredi */ 2655b712091SMiklos Szeredi if (is_dir && OVL_TYPE_MERGE(type)) 2665b712091SMiklos Szeredi stat->nlink = 1; 2675b712091SMiklos Szeredi 2685f8415d6SAmir Goldstein /* 2695f8415d6SAmir Goldstein * Return the overlay inode nlinks for indexed upper inodes. 2705f8415d6SAmir Goldstein * Overlay inode nlink counts the union of the upper hardlinks 2715f8415d6SAmir Goldstein * and non-covered lower hardlinks. It does not include the upper 2725f8415d6SAmir Goldstein * index hardlink. 2735f8415d6SAmir Goldstein */ 2745f8415d6SAmir Goldstein if (!is_dir && ovl_test_flag(OVL_INDEX, d_inode(dentry))) 2755f8415d6SAmir Goldstein stat->nlink = dentry->d_inode->i_nlink; 2765f8415d6SAmir Goldstein 27772b608f0SAmir Goldstein out: 2781175b6b8SVivek Goyal revert_creds(old_cred); 27972b608f0SAmir Goldstein 2801175b6b8SVivek Goyal return err; 281e9be9d5eSMiklos Szeredi } 282e9be9d5eSMiklos Szeredi 283549c7297SChristian Brauner int ovl_permission(struct user_namespace *mnt_userns, 284549c7297SChristian Brauner struct inode *inode, int mask) 285e9be9d5eSMiklos Szeredi { 28609d8b586SMiklos Szeredi struct inode *upperinode = ovl_inode_upper(inode); 28709d8b586SMiklos Szeredi struct inode *realinode = upperinode ?: ovl_inode_lower(inode); 288c0ca3d70SVivek Goyal const struct cred *old_cred; 289e9be9d5eSMiklos Szeredi int err; 290e9be9d5eSMiklos Szeredi 291e9be9d5eSMiklos Szeredi /* Careful in RCU walk mode */ 292e9be9d5eSMiklos Szeredi if (!realinode) { 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 305ec7ba118SMiklos Szeredi old_cred = ovl_override_creds(inode->i_sb); 306ec7ba118SMiklos Szeredi if (!upperinode && 307ec7ba118SMiklos Szeredi !special_file(realinode->i_mode) && mask & MAY_WRITE) { 308754f8cb7SVivek Goyal mask &= ~(MAY_WRITE | MAY_APPEND); 309ec7ba118SMiklos Szeredi /* Make sure mounter can read file for copy up later */ 310500cac3cSVivek Goyal mask |= MAY_READ; 311500cac3cSVivek Goyal } 31247291baaSChristian Brauner err = inode_permission(&init_user_ns, realinode, mask); 313c0ca3d70SVivek Goyal revert_creds(old_cred); 314c0ca3d70SVivek Goyal 315c0ca3d70SVivek Goyal return err; 316e9be9d5eSMiklos Szeredi } 317e9be9d5eSMiklos Szeredi 3186b255391SAl Viro static const char *ovl_get_link(struct dentry *dentry, 319fceef393SAl Viro struct inode *inode, 320fceef393SAl Viro struct delayed_call *done) 321e9be9d5eSMiklos Szeredi { 3221175b6b8SVivek Goyal const struct cred *old_cred; 3231175b6b8SVivek Goyal const char *p; 324e9be9d5eSMiklos Szeredi 3256b255391SAl Viro if (!dentry) 3266b255391SAl Viro return ERR_PTR(-ECHILD); 3276b255391SAl Viro 3281175b6b8SVivek Goyal old_cred = ovl_override_creds(dentry->d_sb); 3297764235bSMiklos Szeredi p = vfs_get_link(ovl_dentry_real(dentry), done); 3301175b6b8SVivek Goyal revert_creds(old_cred); 3311175b6b8SVivek Goyal return p; 332e9be9d5eSMiklos Szeredi } 333e9be9d5eSMiklos Szeredi 334610afc0bSMiklos Szeredi bool ovl_is_private_xattr(struct super_block *sb, const char *name) 335e9be9d5eSMiklos Szeredi { 3362d2f2d73SMiklos Szeredi struct ovl_fs *ofs = sb->s_fs_info; 3372d2f2d73SMiklos Szeredi 3382d2f2d73SMiklos Szeredi if (ofs->config.userxattr) 3392d2f2d73SMiklos Szeredi return strncmp(name, OVL_XATTR_USER_PREFIX, 3402d2f2d73SMiklos Szeredi sizeof(OVL_XATTR_USER_PREFIX) - 1) == 0; 3412d2f2d73SMiklos Szeredi else 3422d2f2d73SMiklos Szeredi return strncmp(name, OVL_XATTR_TRUSTED_PREFIX, 3432d2f2d73SMiklos Szeredi sizeof(OVL_XATTR_TRUSTED_PREFIX) - 1) == 0; 344e9be9d5eSMiklos Szeredi } 345e9be9d5eSMiklos Szeredi 3461d88f183SMiklos Szeredi int ovl_xattr_set(struct dentry *dentry, struct inode *inode, const char *name, 3471d88f183SMiklos Szeredi const void *value, size_t size, int flags) 348e9be9d5eSMiklos Szeredi { 349e9be9d5eSMiklos Szeredi int err; 3501d88f183SMiklos Szeredi struct dentry *upperdentry = ovl_i_dentry_upper(inode); 3511d88f183SMiklos Szeredi struct dentry *realdentry = upperdentry ?: ovl_dentry_lower(dentry); 3521175b6b8SVivek Goyal const struct cred *old_cred; 353e9be9d5eSMiklos Szeredi 354e9be9d5eSMiklos Szeredi err = ovl_want_write(dentry); 355e9be9d5eSMiklos Szeredi if (err) 356e9be9d5eSMiklos Szeredi goto out; 357e9be9d5eSMiklos Szeredi 3581d88f183SMiklos Szeredi if (!value && !upperdentry) { 359554677b9SMiklos Szeredi old_cred = ovl_override_creds(dentry->d_sb); 360c7c7a1a1STycho Andersen err = vfs_getxattr(&init_user_ns, realdentry, name, NULL, 0); 361554677b9SMiklos Szeredi revert_creds(old_cred); 3620e585cccSAndreas Gruenbacher if (err < 0) 3630e585cccSAndreas Gruenbacher goto out_drop_write; 3640e585cccSAndreas Gruenbacher } 3650e585cccSAndreas Gruenbacher 3661d88f183SMiklos Szeredi if (!upperdentry) { 367e9be9d5eSMiklos Szeredi err = ovl_copy_up(dentry); 368e9be9d5eSMiklos Szeredi if (err) 369e9be9d5eSMiklos Szeredi goto out_drop_write; 370e9be9d5eSMiklos Szeredi 3711d88f183SMiklos Szeredi realdentry = ovl_dentry_upper(dentry); 3721d88f183SMiklos Szeredi } 3730e585cccSAndreas Gruenbacher 3741175b6b8SVivek Goyal old_cred = ovl_override_creds(dentry->d_sb); 3750e585cccSAndreas Gruenbacher if (value) 376c7c7a1a1STycho Andersen err = vfs_setxattr(&init_user_ns, realdentry, name, value, size, 377c7c7a1a1STycho Andersen flags); 3780e585cccSAndreas Gruenbacher else { 3790e585cccSAndreas Gruenbacher WARN_ON(flags != XATTR_REPLACE); 380c7c7a1a1STycho Andersen err = vfs_removexattr(&init_user_ns, realdentry, name); 3810e585cccSAndreas Gruenbacher } 3821175b6b8SVivek Goyal revert_creds(old_cred); 383e9be9d5eSMiklos Szeredi 384d9854c87SMiklos Szeredi /* copy c/mtime */ 385d9854c87SMiklos Szeredi ovl_copyattr(d_inode(realdentry), inode); 386d9854c87SMiklos Szeredi 387e9be9d5eSMiklos Szeredi out_drop_write: 388e9be9d5eSMiklos Szeredi ovl_drop_write(dentry); 389e9be9d5eSMiklos Szeredi out: 390e9be9d5eSMiklos Szeredi return err; 391e9be9d5eSMiklos Szeredi } 392e9be9d5eSMiklos Szeredi 3931d88f183SMiklos Szeredi int ovl_xattr_get(struct dentry *dentry, struct inode *inode, const char *name, 3940eb45fc3SAndreas Gruenbacher void *value, size_t size) 395e9be9d5eSMiklos Szeredi { 3961175b6b8SVivek Goyal ssize_t res; 3971175b6b8SVivek Goyal const struct cred *old_cred; 3981d88f183SMiklos Szeredi struct dentry *realdentry = 3991d88f183SMiklos Szeredi ovl_i_dentry_upper(inode) ?: ovl_dentry_lower(dentry); 40052148463SMiklos Szeredi 4011175b6b8SVivek Goyal old_cred = ovl_override_creds(dentry->d_sb); 402c7c7a1a1STycho Andersen res = vfs_getxattr(&init_user_ns, realdentry, name, value, size); 4031175b6b8SVivek Goyal revert_creds(old_cred); 4041175b6b8SVivek Goyal return res; 405e9be9d5eSMiklos Szeredi } 406e9be9d5eSMiklos Szeredi 407610afc0bSMiklos Szeredi static bool ovl_can_list(struct super_block *sb, const char *s) 408a082c6f6SMiklos Szeredi { 4098f6ee74cSMiklos Szeredi /* Never list private (.overlay) */ 4108f6ee74cSMiklos Szeredi if (ovl_is_private_xattr(sb, s)) 4118f6ee74cSMiklos Szeredi return false; 4128f6ee74cSMiklos Szeredi 413a082c6f6SMiklos Szeredi /* List all non-trusted xatts */ 414a082c6f6SMiklos Szeredi if (strncmp(s, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) != 0) 415a082c6f6SMiklos Szeredi return true; 416a082c6f6SMiklos Szeredi 4178f6ee74cSMiklos Szeredi /* list other trusted for superuser only */ 4188f6ee74cSMiklos Szeredi return ns_capable_noaudit(&init_user_ns, CAP_SYS_ADMIN); 419a082c6f6SMiklos Szeredi } 420a082c6f6SMiklos Szeredi 421e9be9d5eSMiklos Szeredi ssize_t ovl_listxattr(struct dentry *dentry, char *list, size_t size) 422e9be9d5eSMiklos Szeredi { 423b581755bSMiklos Szeredi struct dentry *realdentry = ovl_dentry_real(dentry); 424e9be9d5eSMiklos Szeredi ssize_t res; 4257cb35119SMiklos Szeredi size_t len; 4267cb35119SMiklos Szeredi char *s; 4271175b6b8SVivek Goyal const struct cred *old_cred; 428e9be9d5eSMiklos Szeredi 4291175b6b8SVivek Goyal old_cred = ovl_override_creds(dentry->d_sb); 430b581755bSMiklos Szeredi res = vfs_listxattr(realdentry, list, size); 4311175b6b8SVivek Goyal revert_creds(old_cred); 432e9be9d5eSMiklos Szeredi if (res <= 0 || size == 0) 433e9be9d5eSMiklos Szeredi return res; 434e9be9d5eSMiklos Szeredi 435e9be9d5eSMiklos Szeredi /* filter out private xattrs */ 4367cb35119SMiklos Szeredi for (s = list, len = res; len;) { 4377cb35119SMiklos Szeredi size_t slen = strnlen(s, len) + 1; 438e9be9d5eSMiklos Szeredi 4397cb35119SMiklos Szeredi /* underlying fs providing us with an broken xattr list? */ 4407cb35119SMiklos Szeredi if (WARN_ON(slen > len)) 4417cb35119SMiklos Szeredi return -EIO; 442e9be9d5eSMiklos Szeredi 4437cb35119SMiklos Szeredi len -= slen; 444610afc0bSMiklos Szeredi if (!ovl_can_list(dentry->d_sb, s)) { 445e9be9d5eSMiklos Szeredi res -= slen; 4467cb35119SMiklos Szeredi memmove(s, s + slen, len); 447e9be9d5eSMiklos Szeredi } else { 4487cb35119SMiklos Szeredi s += slen; 449e9be9d5eSMiklos Szeredi } 450e9be9d5eSMiklos Szeredi } 451e9be9d5eSMiklos Szeredi 452e9be9d5eSMiklos Szeredi return res; 453e9be9d5eSMiklos Szeredi } 454e9be9d5eSMiklos Szeredi 45539a25b2bSVivek Goyal struct posix_acl *ovl_get_acl(struct inode *inode, int type) 45639a25b2bSVivek Goyal { 45709d8b586SMiklos Szeredi struct inode *realinode = ovl_inode_real(inode); 4581175b6b8SVivek Goyal const struct cred *old_cred; 4591175b6b8SVivek Goyal struct posix_acl *acl; 46039a25b2bSVivek Goyal 4615201dc44SMiklos Szeredi if (!IS_ENABLED(CONFIG_FS_POSIX_ACL) || !IS_POSIXACL(realinode)) 46239a25b2bSVivek Goyal return NULL; 46339a25b2bSVivek Goyal 4641175b6b8SVivek Goyal old_cred = ovl_override_creds(inode->i_sb); 4655201dc44SMiklos Szeredi acl = get_acl(realinode, type); 4661175b6b8SVivek Goyal revert_creds(old_cred); 4671175b6b8SVivek Goyal 4681175b6b8SVivek Goyal return acl; 46939a25b2bSVivek Goyal } 47039a25b2bSVivek Goyal 47195582b00SDeepa Dinamani int ovl_update_time(struct inode *inode, struct timespec64 *ts, int flags) 472d719e8f2SMiklos Szeredi { 4738f35cf51SMiklos Szeredi if (flags & S_ATIME) { 4748f35cf51SMiklos Szeredi struct ovl_fs *ofs = inode->i_sb->s_fs_info; 4758f35cf51SMiklos Szeredi struct path upperpath = { 47608f4c7c8SMiklos Szeredi .mnt = ovl_upper_mnt(ofs), 4778f35cf51SMiklos Szeredi .dentry = ovl_upperdentry_dereference(OVL_I(inode)), 4788f35cf51SMiklos Szeredi }; 479d719e8f2SMiklos Szeredi 480d719e8f2SMiklos Szeredi if (upperpath.dentry) { 481d719e8f2SMiklos Szeredi touch_atime(&upperpath); 482d719e8f2SMiklos Szeredi inode->i_atime = d_inode(upperpath.dentry)->i_atime; 483d719e8f2SMiklos Szeredi } 4848f35cf51SMiklos Szeredi } 485d719e8f2SMiklos Szeredi return 0; 486d719e8f2SMiklos Szeredi } 487d719e8f2SMiklos Szeredi 4889e142c41SMiklos Szeredi static int ovl_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, 4899e142c41SMiklos Szeredi u64 start, u64 len) 4909e142c41SMiklos Szeredi { 4919e142c41SMiklos Szeredi int err; 492c11faf32SChengguang Xu struct inode *realinode = ovl_inode_realdata(inode); 4939e142c41SMiklos Szeredi const struct cred *old_cred; 4949e142c41SMiklos Szeredi 4959e142c41SMiklos Szeredi if (!realinode->i_op->fiemap) 4969e142c41SMiklos Szeredi return -EOPNOTSUPP; 4979e142c41SMiklos Szeredi 4989e142c41SMiklos Szeredi old_cred = ovl_override_creds(inode->i_sb); 4999e142c41SMiklos Szeredi err = realinode->i_op->fiemap(realinode, fieinfo, start, len); 5009e142c41SMiklos Szeredi revert_creds(old_cred); 5019e142c41SMiklos Szeredi 5029e142c41SMiklos Szeredi return err; 5039e142c41SMiklos Szeredi } 5049e142c41SMiklos Szeredi 505*66dbfabfSMiklos Szeredi /* 506*66dbfabfSMiklos Szeredi * Work around the fact that security_file_ioctl() takes a file argument. 507*66dbfabfSMiklos Szeredi * Introducing security_inode_fileattr_get/set() hooks would solve this issue 508*66dbfabfSMiklos Szeredi * properly. 509*66dbfabfSMiklos Szeredi */ 510*66dbfabfSMiklos Szeredi static int ovl_security_fileattr(struct dentry *dentry, struct fileattr *fa, 511*66dbfabfSMiklos Szeredi bool set) 512*66dbfabfSMiklos Szeredi { 513*66dbfabfSMiklos Szeredi struct path realpath; 514*66dbfabfSMiklos Szeredi struct file *file; 515*66dbfabfSMiklos Szeredi unsigned int cmd; 516*66dbfabfSMiklos Szeredi int err; 517*66dbfabfSMiklos Szeredi 518*66dbfabfSMiklos Szeredi ovl_path_real(dentry, &realpath); 519*66dbfabfSMiklos Szeredi file = dentry_open(&realpath, O_RDONLY, current_cred()); 520*66dbfabfSMiklos Szeredi if (IS_ERR(file)) 521*66dbfabfSMiklos Szeredi return PTR_ERR(file); 522*66dbfabfSMiklos Szeredi 523*66dbfabfSMiklos Szeredi if (set) 524*66dbfabfSMiklos Szeredi cmd = fa->fsx_valid ? FS_IOC_FSSETXATTR : FS_IOC_SETFLAGS; 525*66dbfabfSMiklos Szeredi else 526*66dbfabfSMiklos Szeredi cmd = fa->fsx_valid ? FS_IOC_FSGETXATTR : FS_IOC_GETFLAGS; 527*66dbfabfSMiklos Szeredi 528*66dbfabfSMiklos Szeredi err = security_file_ioctl(file, cmd, 0); 529*66dbfabfSMiklos Szeredi fput(file); 530*66dbfabfSMiklos Szeredi 531*66dbfabfSMiklos Szeredi return err; 532*66dbfabfSMiklos Szeredi } 533*66dbfabfSMiklos Szeredi 534*66dbfabfSMiklos Szeredi int ovl_fileattr_set(struct user_namespace *mnt_userns, 535*66dbfabfSMiklos Szeredi struct dentry *dentry, struct fileattr *fa) 536*66dbfabfSMiklos Szeredi { 537*66dbfabfSMiklos Szeredi struct inode *inode = d_inode(dentry); 538*66dbfabfSMiklos Szeredi struct dentry *upperdentry; 539*66dbfabfSMiklos Szeredi const struct cred *old_cred; 540*66dbfabfSMiklos Szeredi int err; 541*66dbfabfSMiklos Szeredi 542*66dbfabfSMiklos Szeredi err = ovl_want_write(dentry); 543*66dbfabfSMiklos Szeredi if (err) 544*66dbfabfSMiklos Szeredi goto out; 545*66dbfabfSMiklos Szeredi 546*66dbfabfSMiklos Szeredi err = ovl_copy_up(dentry); 547*66dbfabfSMiklos Szeredi if (!err) { 548*66dbfabfSMiklos Szeredi upperdentry = ovl_dentry_upper(dentry); 549*66dbfabfSMiklos Szeredi 550*66dbfabfSMiklos Szeredi old_cred = ovl_override_creds(inode->i_sb); 551*66dbfabfSMiklos Szeredi err = ovl_security_fileattr(dentry, fa, true); 552*66dbfabfSMiklos Szeredi if (!err) 553*66dbfabfSMiklos Szeredi err = vfs_fileattr_set(&init_user_ns, upperdentry, fa); 554*66dbfabfSMiklos Szeredi revert_creds(old_cred); 555*66dbfabfSMiklos Szeredi ovl_copyflags(ovl_inode_real(inode), inode); 556*66dbfabfSMiklos Szeredi } 557*66dbfabfSMiklos Szeredi ovl_drop_write(dentry); 558*66dbfabfSMiklos Szeredi out: 559*66dbfabfSMiklos Szeredi return err; 560*66dbfabfSMiklos Szeredi } 561*66dbfabfSMiklos Szeredi 562*66dbfabfSMiklos Szeredi int ovl_fileattr_get(struct dentry *dentry, struct fileattr *fa) 563*66dbfabfSMiklos Szeredi { 564*66dbfabfSMiklos Szeredi struct inode *inode = d_inode(dentry); 565*66dbfabfSMiklos Szeredi struct dentry *realdentry = ovl_dentry_real(dentry); 566*66dbfabfSMiklos Szeredi const struct cred *old_cred; 567*66dbfabfSMiklos Szeredi int err; 568*66dbfabfSMiklos Szeredi 569*66dbfabfSMiklos Szeredi old_cred = ovl_override_creds(inode->i_sb); 570*66dbfabfSMiklos Szeredi err = ovl_security_fileattr(dentry, fa, false); 571*66dbfabfSMiklos Szeredi if (!err) 572*66dbfabfSMiklos Szeredi err = vfs_fileattr_get(realdentry, fa); 573*66dbfabfSMiklos Szeredi revert_creds(old_cred); 574*66dbfabfSMiklos Szeredi 575*66dbfabfSMiklos Szeredi return err; 576*66dbfabfSMiklos Szeredi } 577*66dbfabfSMiklos Szeredi 578e9be9d5eSMiklos Szeredi static const struct inode_operations ovl_file_inode_operations = { 579e9be9d5eSMiklos Szeredi .setattr = ovl_setattr, 580e9be9d5eSMiklos Szeredi .permission = ovl_permission, 581e9be9d5eSMiklos Szeredi .getattr = ovl_getattr, 582e9be9d5eSMiklos Szeredi .listxattr = ovl_listxattr, 58339a25b2bSVivek Goyal .get_acl = ovl_get_acl, 584d719e8f2SMiklos Szeredi .update_time = ovl_update_time, 5859e142c41SMiklos Szeredi .fiemap = ovl_fiemap, 586*66dbfabfSMiklos Szeredi .fileattr_get = ovl_fileattr_get, 587*66dbfabfSMiklos Szeredi .fileattr_set = ovl_fileattr_set, 588e9be9d5eSMiklos Szeredi }; 589e9be9d5eSMiklos Szeredi 590e9be9d5eSMiklos Szeredi static const struct inode_operations ovl_symlink_inode_operations = { 591e9be9d5eSMiklos Szeredi .setattr = ovl_setattr, 5926b255391SAl Viro .get_link = ovl_get_link, 593e9be9d5eSMiklos Szeredi .getattr = ovl_getattr, 594e9be9d5eSMiklos Szeredi .listxattr = ovl_listxattr, 595d719e8f2SMiklos Szeredi .update_time = ovl_update_time, 596e9be9d5eSMiklos Szeredi }; 597e9be9d5eSMiklos Szeredi 5989e142c41SMiklos Szeredi static const struct inode_operations ovl_special_inode_operations = { 5999e142c41SMiklos Szeredi .setattr = ovl_setattr, 6009e142c41SMiklos Szeredi .permission = ovl_permission, 6019e142c41SMiklos Szeredi .getattr = ovl_getattr, 6029e142c41SMiklos Szeredi .listxattr = ovl_listxattr, 6039e142c41SMiklos Szeredi .get_acl = ovl_get_acl, 6049e142c41SMiklos Szeredi .update_time = ovl_update_time, 6059e142c41SMiklos Szeredi }; 6069e142c41SMiklos Szeredi 60769383c59SWei Yongjun static const struct address_space_operations ovl_aops = { 6085b910bd6SAmir Goldstein /* For O_DIRECT dentry_open() checks f_mapping->a_ops->direct_IO */ 6095b910bd6SAmir Goldstein .direct_IO = noop_direct_IO, 6105b910bd6SAmir Goldstein }; 6115b910bd6SAmir Goldstein 612b1eaa950SAmir Goldstein /* 613b1eaa950SAmir Goldstein * It is possible to stack overlayfs instance on top of another 614a5a84682SChengguang Xu * overlayfs instance as lower layer. We need to annotate the 615b1eaa950SAmir Goldstein * stackable i_mutex locks according to stack level of the super 616b1eaa950SAmir Goldstein * block instance. An overlayfs instance can never be in stack 617b1eaa950SAmir Goldstein * depth 0 (there is always a real fs below it). An overlayfs 618b1eaa950SAmir Goldstein * inode lock will use the lockdep annotaion ovl_i_mutex_key[depth]. 619b1eaa950SAmir Goldstein * 620b1eaa950SAmir Goldstein * For example, here is a snip from /proc/lockdep_chains after 621b1eaa950SAmir Goldstein * dir_iterate of nested overlayfs: 622b1eaa950SAmir Goldstein * 623b1eaa950SAmir Goldstein * [...] &ovl_i_mutex_dir_key[depth] (stack_depth=2) 624b1eaa950SAmir Goldstein * [...] &ovl_i_mutex_dir_key[depth]#2 (stack_depth=1) 625b1eaa950SAmir Goldstein * [...] &type->i_mutex_dir_key (stack_depth=0) 626b1f9d385SAmir Goldstein * 627b1f9d385SAmir Goldstein * Locking order w.r.t ovl_want_write() is important for nested overlayfs. 628b1f9d385SAmir Goldstein * 629b1f9d385SAmir Goldstein * This chain is valid: 630b1f9d385SAmir Goldstein * - inode->i_rwsem (inode_lock[2]) 631b1f9d385SAmir Goldstein * - upper_mnt->mnt_sb->s_writers (ovl_want_write[0]) 632b1f9d385SAmir Goldstein * - OVL_I(inode)->lock (ovl_inode_lock[2]) 633b1f9d385SAmir Goldstein * - OVL_I(lowerinode)->lock (ovl_inode_lock[1]) 634b1f9d385SAmir Goldstein * 635b1f9d385SAmir Goldstein * And this chain is valid: 636b1f9d385SAmir Goldstein * - inode->i_rwsem (inode_lock[2]) 637b1f9d385SAmir Goldstein * - OVL_I(inode)->lock (ovl_inode_lock[2]) 638b1f9d385SAmir Goldstein * - lowerinode->i_rwsem (inode_lock[1]) 639b1f9d385SAmir Goldstein * - OVL_I(lowerinode)->lock (ovl_inode_lock[1]) 640b1f9d385SAmir Goldstein * 641b1f9d385SAmir Goldstein * But lowerinode->i_rwsem SHOULD NOT be acquired while ovl_want_write() is 642b1f9d385SAmir Goldstein * held, because it is in reverse order of the non-nested case using the same 643b1f9d385SAmir Goldstein * upper fs: 644b1f9d385SAmir Goldstein * - inode->i_rwsem (inode_lock[1]) 645b1f9d385SAmir Goldstein * - upper_mnt->mnt_sb->s_writers (ovl_want_write[0]) 646b1f9d385SAmir Goldstein * - OVL_I(inode)->lock (ovl_inode_lock[1]) 647b1eaa950SAmir Goldstein */ 648b1eaa950SAmir Goldstein #define OVL_MAX_NESTING FILESYSTEM_MAX_STACK_DEPTH 649b1eaa950SAmir Goldstein 650b1eaa950SAmir Goldstein static inline void ovl_lockdep_annotate_inode_mutex_key(struct inode *inode) 651b1eaa950SAmir Goldstein { 652b1eaa950SAmir Goldstein #ifdef CONFIG_LOCKDEP 653b1eaa950SAmir Goldstein static struct lock_class_key ovl_i_mutex_key[OVL_MAX_NESTING]; 654b1eaa950SAmir Goldstein static struct lock_class_key ovl_i_mutex_dir_key[OVL_MAX_NESTING]; 6554eae06deSAmir Goldstein static struct lock_class_key ovl_i_lock_key[OVL_MAX_NESTING]; 656b1eaa950SAmir Goldstein 657b1eaa950SAmir Goldstein int depth = inode->i_sb->s_stack_depth - 1; 658b1eaa950SAmir Goldstein 659b1eaa950SAmir Goldstein if (WARN_ON_ONCE(depth < 0 || depth >= OVL_MAX_NESTING)) 660b1eaa950SAmir Goldstein depth = 0; 661b1eaa950SAmir Goldstein 662b1eaa950SAmir Goldstein if (S_ISDIR(inode->i_mode)) 663b1eaa950SAmir Goldstein lockdep_set_class(&inode->i_rwsem, &ovl_i_mutex_dir_key[depth]); 664b1eaa950SAmir Goldstein else 665b1eaa950SAmir Goldstein lockdep_set_class(&inode->i_rwsem, &ovl_i_mutex_key[depth]); 6664eae06deSAmir Goldstein 6674eae06deSAmir Goldstein lockdep_set_class(&OVL_I(inode)->lock, &ovl_i_lock_key[depth]); 668b1eaa950SAmir Goldstein #endif 669b1eaa950SAmir Goldstein } 670b1eaa950SAmir Goldstein 6714d314f78SAmir Goldstein static void ovl_next_ino(struct inode *inode) 6724d314f78SAmir Goldstein { 6734d314f78SAmir Goldstein struct ovl_fs *ofs = inode->i_sb->s_fs_info; 6744d314f78SAmir Goldstein 6754d314f78SAmir Goldstein inode->i_ino = atomic_long_inc_return(&ofs->last_ino); 6764d314f78SAmir Goldstein if (unlikely(!inode->i_ino)) 6774d314f78SAmir Goldstein inode->i_ino = atomic_long_inc_return(&ofs->last_ino); 6784d314f78SAmir Goldstein } 6794d314f78SAmir Goldstein 68062c832edSAmir Goldstein static void ovl_map_ino(struct inode *inode, unsigned long ino, int fsid) 681e9be9d5eSMiklos Szeredi { 68212574a9fSAmir Goldstein int xinobits = ovl_xino_bits(inode->i_sb); 683dfe51d47SAmir Goldstein unsigned int xinoshift = 64 - xinobits; 68412574a9fSAmir Goldstein 685695b46e7SAmir Goldstein /* 6866dde1e42SAmir Goldstein * When d_ino is consistent with st_ino (samefs or i_ino has enough 6876dde1e42SAmir Goldstein * bits to encode layer), set the same value used for st_ino to i_ino, 6886dde1e42SAmir Goldstein * so inode number exposed via /proc/locks and a like will be 6896dde1e42SAmir Goldstein * consistent with d_ino and st_ino values. An i_ino value inconsistent 690735c907dSAmir Goldstein * with d_ino also causes nfsd readdirplus to fail. 691695b46e7SAmir Goldstein */ 692695b46e7SAmir Goldstein inode->i_ino = ino; 693dfe51d47SAmir Goldstein if (ovl_same_fs(inode->i_sb)) { 694dfe51d47SAmir Goldstein return; 695dfe51d47SAmir Goldstein } else if (xinobits && likely(!(ino >> xinoshift))) { 696dfe51d47SAmir Goldstein inode->i_ino |= (unsigned long)fsid << (xinoshift + 1); 697dfe51d47SAmir Goldstein return; 698dfe51d47SAmir Goldstein } 699dfe51d47SAmir Goldstein 700dfe51d47SAmir Goldstein /* 701dfe51d47SAmir Goldstein * For directory inodes on non-samefs with xino disabled or xino 702dfe51d47SAmir Goldstein * overflow, we allocate a non-persistent inode number, to be used for 703dfe51d47SAmir Goldstein * resolving st_ino collisions in ovl_map_dev_ino(). 704dfe51d47SAmir Goldstein * 705dfe51d47SAmir Goldstein * To avoid ino collision with legitimate xino values from upper 706dfe51d47SAmir Goldstein * layer (fsid 0), use the lowest xinobit to map the non 707dfe51d47SAmir Goldstein * persistent inode numbers to the unified st_ino address space. 708dfe51d47SAmir Goldstein */ 709dfe51d47SAmir Goldstein if (S_ISDIR(inode->i_mode)) { 7104d314f78SAmir Goldstein ovl_next_ino(inode); 711dfe51d47SAmir Goldstein if (xinobits) { 712dfe51d47SAmir Goldstein inode->i_ino &= ~0UL >> xinobits; 713dfe51d47SAmir Goldstein inode->i_ino |= 1UL << xinoshift; 714dfe51d47SAmir Goldstein } 71512574a9fSAmir Goldstein } 71662c832edSAmir Goldstein } 71762c832edSAmir Goldstein 71862c832edSAmir Goldstein void ovl_inode_init(struct inode *inode, struct ovl_inode_params *oip, 71962c832edSAmir Goldstein unsigned long ino, int fsid) 72062c832edSAmir Goldstein { 72162c832edSAmir Goldstein struct inode *realinode; 72262c832edSAmir Goldstein 72362c832edSAmir Goldstein if (oip->upperdentry) 72462c832edSAmir Goldstein OVL_I(inode)->__upperdentry = oip->upperdentry; 72562c832edSAmir Goldstein if (oip->lowerpath && oip->lowerpath->dentry) 72662c832edSAmir Goldstein OVL_I(inode)->lower = igrab(d_inode(oip->lowerpath->dentry)); 72762c832edSAmir Goldstein if (oip->lowerdata) 72862c832edSAmir Goldstein OVL_I(inode)->lowerdata = igrab(d_inode(oip->lowerdata)); 72962c832edSAmir Goldstein 73062c832edSAmir Goldstein realinode = ovl_inode_real(inode); 73162c832edSAmir Goldstein ovl_copyattr(realinode, inode); 73262c832edSAmir Goldstein ovl_copyflags(realinode, inode); 73362c832edSAmir Goldstein ovl_map_ino(inode, ino, fsid); 73462c832edSAmir Goldstein } 73562c832edSAmir Goldstein 73662c832edSAmir Goldstein static void ovl_fill_inode(struct inode *inode, umode_t mode, dev_t rdev) 73762c832edSAmir Goldstein { 738e9be9d5eSMiklos Szeredi inode->i_mode = mode; 739d719e8f2SMiklos Szeredi inode->i_flags |= S_NOCMTIME; 7402a3a2a3fSMiklos Szeredi #ifdef CONFIG_FS_POSIX_ACL 7412a3a2a3fSMiklos Szeredi inode->i_acl = inode->i_default_acl = ACL_DONT_CACHE; 7422a3a2a3fSMiklos Szeredi #endif 743e9be9d5eSMiklos Szeredi 744b1eaa950SAmir Goldstein ovl_lockdep_annotate_inode_mutex_key(inode); 745b1eaa950SAmir Goldstein 746ca4c8a3aSMiklos Szeredi switch (mode & S_IFMT) { 747ca4c8a3aSMiklos Szeredi case S_IFREG: 748ca4c8a3aSMiklos Szeredi inode->i_op = &ovl_file_inode_operations; 749d1d04ef8SMiklos Szeredi inode->i_fop = &ovl_file_operations; 7505b910bd6SAmir Goldstein inode->i_mapping->a_ops = &ovl_aops; 751ca4c8a3aSMiklos Szeredi break; 752ca4c8a3aSMiklos Szeredi 753e9be9d5eSMiklos Szeredi case S_IFDIR: 754e9be9d5eSMiklos Szeredi inode->i_op = &ovl_dir_inode_operations; 755e9be9d5eSMiklos Szeredi inode->i_fop = &ovl_dir_operations; 756e9be9d5eSMiklos Szeredi break; 757e9be9d5eSMiklos Szeredi 758e9be9d5eSMiklos Szeredi case S_IFLNK: 759e9be9d5eSMiklos Szeredi inode->i_op = &ovl_symlink_inode_operations; 760e9be9d5eSMiklos Szeredi break; 761e9be9d5eSMiklos Szeredi 76251f7e52dSMiklos Szeredi default: 7639e142c41SMiklos Szeredi inode->i_op = &ovl_special_inode_operations; 764ca4c8a3aSMiklos Szeredi init_special_inode(inode, mode, rdev); 765e9be9d5eSMiklos Szeredi break; 76651f7e52dSMiklos Szeredi } 76751f7e52dSMiklos Szeredi } 768e9be9d5eSMiklos Szeredi 7695f8415d6SAmir Goldstein /* 7705f8415d6SAmir Goldstein * With inodes index enabled, an overlay inode nlink counts the union of upper 7715f8415d6SAmir Goldstein * hardlinks and non-covered lower hardlinks. During the lifetime of a non-pure 7725f8415d6SAmir Goldstein * upper inode, the following nlink modifying operations can happen: 7735f8415d6SAmir Goldstein * 7745f8415d6SAmir Goldstein * 1. Lower hardlink copy up 7755f8415d6SAmir Goldstein * 2. Upper hardlink created, unlinked or renamed over 7765f8415d6SAmir Goldstein * 3. Lower hardlink whiteout or renamed over 7775f8415d6SAmir Goldstein * 7785f8415d6SAmir Goldstein * For the first, copy up case, the union nlink does not change, whether the 7795f8415d6SAmir Goldstein * operation succeeds or fails, but the upper inode nlink may change. 7805f8415d6SAmir Goldstein * Therefore, before copy up, we store the union nlink value relative to the 7812d2f2d73SMiklos Szeredi * lower inode nlink in the index inode xattr .overlay.nlink. 7825f8415d6SAmir Goldstein * 7835f8415d6SAmir Goldstein * For the second, upper hardlink case, the union nlink should be incremented 7845f8415d6SAmir Goldstein * or decremented IFF the operation succeeds, aligned with nlink change of the 7855f8415d6SAmir Goldstein * upper inode. Therefore, before link/unlink/rename, we store the union nlink 7865f8415d6SAmir Goldstein * value relative to the upper inode nlink in the index inode. 7875f8415d6SAmir Goldstein * 7885f8415d6SAmir Goldstein * For the last, lower cover up case, we simplify things by preceding the 7895f8415d6SAmir Goldstein * whiteout or cover up with copy up. This makes sure that there is an index 7905f8415d6SAmir Goldstein * upper inode where the nlink xattr can be stored before the copied up upper 7915f8415d6SAmir Goldstein * entry is unlink. 7925f8415d6SAmir Goldstein */ 7935f8415d6SAmir Goldstein #define OVL_NLINK_ADD_UPPER (1 << 0) 7945f8415d6SAmir Goldstein 7955f8415d6SAmir Goldstein /* 7965f8415d6SAmir Goldstein * On-disk format for indexed nlink: 7975f8415d6SAmir Goldstein * 7985f8415d6SAmir Goldstein * nlink relative to the upper inode - "U[+-]NUM" 7995f8415d6SAmir Goldstein * nlink relative to the lower inode - "L[+-]NUM" 8005f8415d6SAmir Goldstein */ 8015f8415d6SAmir Goldstein 8025f8415d6SAmir Goldstein static int ovl_set_nlink_common(struct dentry *dentry, 8035f8415d6SAmir Goldstein struct dentry *realdentry, const char *format) 8045f8415d6SAmir Goldstein { 8055f8415d6SAmir Goldstein struct inode *inode = d_inode(dentry); 8065f8415d6SAmir Goldstein struct inode *realinode = d_inode(realdentry); 8075f8415d6SAmir Goldstein char buf[13]; 8085f8415d6SAmir Goldstein int len; 8095f8415d6SAmir Goldstein 8105f8415d6SAmir Goldstein len = snprintf(buf, sizeof(buf), format, 8115f8415d6SAmir Goldstein (int) (inode->i_nlink - realinode->i_nlink)); 8125f8415d6SAmir Goldstein 8136787341aSMiklos Szeredi if (WARN_ON(len >= sizeof(buf))) 8146787341aSMiklos Szeredi return -EIO; 8156787341aSMiklos Szeredi 816610afc0bSMiklos Szeredi return ovl_do_setxattr(OVL_FS(inode->i_sb), ovl_dentry_upper(dentry), 81726150ab5SMiklos Szeredi OVL_XATTR_NLINK, buf, len); 8185f8415d6SAmir Goldstein } 8195f8415d6SAmir Goldstein 8205f8415d6SAmir Goldstein int ovl_set_nlink_upper(struct dentry *dentry) 8215f8415d6SAmir Goldstein { 8225f8415d6SAmir Goldstein return ovl_set_nlink_common(dentry, ovl_dentry_upper(dentry), "U%+i"); 8235f8415d6SAmir Goldstein } 8245f8415d6SAmir Goldstein 8255f8415d6SAmir Goldstein int ovl_set_nlink_lower(struct dentry *dentry) 8265f8415d6SAmir Goldstein { 8275f8415d6SAmir Goldstein return ovl_set_nlink_common(dentry, ovl_dentry_lower(dentry), "L%+i"); 8285f8415d6SAmir Goldstein } 8295f8415d6SAmir Goldstein 830610afc0bSMiklos Szeredi unsigned int ovl_get_nlink(struct ovl_fs *ofs, struct dentry *lowerdentry, 8315f8415d6SAmir Goldstein struct dentry *upperdentry, 8325f8415d6SAmir Goldstein unsigned int fallback) 8335f8415d6SAmir Goldstein { 8345f8415d6SAmir Goldstein int nlink_diff; 8355f8415d6SAmir Goldstein int nlink; 8365f8415d6SAmir Goldstein char buf[13]; 8375f8415d6SAmir Goldstein int err; 8385f8415d6SAmir Goldstein 8395f8415d6SAmir Goldstein if (!lowerdentry || !upperdentry || d_inode(lowerdentry)->i_nlink == 1) 8405f8415d6SAmir Goldstein return fallback; 8415f8415d6SAmir Goldstein 842610afc0bSMiklos Szeredi err = ovl_do_getxattr(ofs, upperdentry, OVL_XATTR_NLINK, 843d5dc7486SMiklos Szeredi &buf, sizeof(buf) - 1); 8445f8415d6SAmir Goldstein if (err < 0) 8455f8415d6SAmir Goldstein goto fail; 8465f8415d6SAmir Goldstein 8475f8415d6SAmir Goldstein buf[err] = '\0'; 8485f8415d6SAmir Goldstein if ((buf[0] != 'L' && buf[0] != 'U') || 8495f8415d6SAmir Goldstein (buf[1] != '+' && buf[1] != '-')) 8505f8415d6SAmir Goldstein goto fail; 8515f8415d6SAmir Goldstein 8525f8415d6SAmir Goldstein err = kstrtoint(buf + 1, 10, &nlink_diff); 8535f8415d6SAmir Goldstein if (err < 0) 8545f8415d6SAmir Goldstein goto fail; 8555f8415d6SAmir Goldstein 8565f8415d6SAmir Goldstein nlink = d_inode(buf[0] == 'L' ? lowerdentry : upperdentry)->i_nlink; 8575f8415d6SAmir Goldstein nlink += nlink_diff; 8585f8415d6SAmir Goldstein 8595f8415d6SAmir Goldstein if (nlink <= 0) 8605f8415d6SAmir Goldstein goto fail; 8615f8415d6SAmir Goldstein 8625f8415d6SAmir Goldstein return nlink; 8635f8415d6SAmir Goldstein 8645f8415d6SAmir Goldstein fail: 8651bd0a3aeSlijiazi pr_warn_ratelimited("failed to get index nlink (%pd2, err=%i)\n", 8665f8415d6SAmir Goldstein upperdentry, err); 8675f8415d6SAmir Goldstein return fallback; 8685f8415d6SAmir Goldstein } 8695f8415d6SAmir Goldstein 870ca4c8a3aSMiklos Szeredi struct inode *ovl_new_inode(struct super_block *sb, umode_t mode, dev_t rdev) 87151f7e52dSMiklos Szeredi { 87251f7e52dSMiklos Szeredi struct inode *inode; 87351f7e52dSMiklos Szeredi 87451f7e52dSMiklos Szeredi inode = new_inode(sb); 87551f7e52dSMiklos Szeredi if (inode) 87662c832edSAmir Goldstein ovl_fill_inode(inode, mode, rdev); 87751f7e52dSMiklos Szeredi 87851f7e52dSMiklos Szeredi return inode; 87951f7e52dSMiklos Szeredi } 88051f7e52dSMiklos Szeredi 88151f7e52dSMiklos Szeredi static int ovl_inode_test(struct inode *inode, void *data) 88251f7e52dSMiklos Szeredi { 88325b7713aSMiklos Szeredi return inode->i_private == data; 88451f7e52dSMiklos Szeredi } 88551f7e52dSMiklos Szeredi 88651f7e52dSMiklos Szeredi static int ovl_inode_set(struct inode *inode, void *data) 88751f7e52dSMiklos Szeredi { 88825b7713aSMiklos Szeredi inode->i_private = data; 88951f7e52dSMiklos Szeredi return 0; 89051f7e52dSMiklos Szeredi } 89151f7e52dSMiklos Szeredi 892b9ac5c27SMiklos Szeredi static bool ovl_verify_inode(struct inode *inode, struct dentry *lowerdentry, 8934b91c30aSAmir Goldstein struct dentry *upperdentry, bool strict) 894b9ac5c27SMiklos Szeredi { 8954b91c30aSAmir Goldstein /* 8964b91c30aSAmir Goldstein * For directories, @strict verify from lookup path performs consistency 8974b91c30aSAmir Goldstein * checks, so NULL lower/upper in dentry must match NULL lower/upper in 8984b91c30aSAmir Goldstein * inode. Non @strict verify from NFS handle decode path passes NULL for 8994b91c30aSAmir Goldstein * 'unknown' lower/upper. 9004b91c30aSAmir Goldstein */ 9014b91c30aSAmir Goldstein if (S_ISDIR(inode->i_mode) && strict) { 90231747edaSAmir Goldstein /* Real lower dir moved to upper layer under us? */ 90331747edaSAmir Goldstein if (!lowerdentry && ovl_inode_lower(inode)) 90431747edaSAmir Goldstein return false; 90531747edaSAmir Goldstein 90631747edaSAmir Goldstein /* Lookup of an uncovered redirect origin? */ 90731747edaSAmir Goldstein if (!upperdentry && ovl_inode_upper(inode)) 90831747edaSAmir Goldstein return false; 90931747edaSAmir Goldstein } 91031747edaSAmir Goldstein 911939ae4efSAmir Goldstein /* 912939ae4efSAmir Goldstein * Allow non-NULL lower inode in ovl_inode even if lowerdentry is NULL. 913939ae4efSAmir Goldstein * This happens when finding a copied up overlay inode for a renamed 914939ae4efSAmir Goldstein * or hardlinked overlay dentry and lower dentry cannot be followed 915939ae4efSAmir Goldstein * by origin because lower fs does not support file handles. 916939ae4efSAmir Goldstein */ 917939ae4efSAmir Goldstein if (lowerdentry && ovl_inode_lower(inode) != d_inode(lowerdentry)) 918b9ac5c27SMiklos Szeredi return false; 919b9ac5c27SMiklos Szeredi 920b9ac5c27SMiklos Szeredi /* 921b9ac5c27SMiklos Szeredi * Allow non-NULL __upperdentry in inode even if upperdentry is NULL. 922b9ac5c27SMiklos Szeredi * This happens when finding a lower alias for a copied up hard link. 923b9ac5c27SMiklos Szeredi */ 924b9ac5c27SMiklos Szeredi if (upperdentry && ovl_inode_upper(inode) != d_inode(upperdentry)) 925b9ac5c27SMiklos Szeredi return false; 926b9ac5c27SMiklos Szeredi 927b9ac5c27SMiklos Szeredi return true; 928b9ac5c27SMiklos Szeredi } 929b9ac5c27SMiklos Szeredi 9304b91c30aSAmir Goldstein struct inode *ovl_lookup_inode(struct super_block *sb, struct dentry *real, 9314b91c30aSAmir Goldstein bool is_upper) 9329436a1a3SAmir Goldstein { 9334b91c30aSAmir Goldstein struct inode *inode, *key = d_inode(real); 9349436a1a3SAmir Goldstein 9359436a1a3SAmir Goldstein inode = ilookup5(sb, (unsigned long) key, ovl_inode_test, key); 9369436a1a3SAmir Goldstein if (!inode) 9379436a1a3SAmir Goldstein return NULL; 9389436a1a3SAmir Goldstein 9394b91c30aSAmir Goldstein if (!ovl_verify_inode(inode, is_upper ? NULL : real, 9404b91c30aSAmir Goldstein is_upper ? real : NULL, false)) { 9419436a1a3SAmir Goldstein iput(inode); 9429436a1a3SAmir Goldstein return ERR_PTR(-ESTALE); 9439436a1a3SAmir Goldstein } 9449436a1a3SAmir Goldstein 9459436a1a3SAmir Goldstein return inode; 9469436a1a3SAmir Goldstein } 9479436a1a3SAmir Goldstein 948146d62e5SAmir Goldstein bool ovl_lookup_trap_inode(struct super_block *sb, struct dentry *dir) 949146d62e5SAmir Goldstein { 950146d62e5SAmir Goldstein struct inode *key = d_inode(dir); 951146d62e5SAmir Goldstein struct inode *trap; 952146d62e5SAmir Goldstein bool res; 953146d62e5SAmir Goldstein 954146d62e5SAmir Goldstein trap = ilookup5(sb, (unsigned long) key, ovl_inode_test, key); 955146d62e5SAmir Goldstein if (!trap) 956146d62e5SAmir Goldstein return false; 957146d62e5SAmir Goldstein 958146d62e5SAmir Goldstein res = IS_DEADDIR(trap) && !ovl_inode_upper(trap) && 959146d62e5SAmir Goldstein !ovl_inode_lower(trap); 960146d62e5SAmir Goldstein 961146d62e5SAmir Goldstein iput(trap); 962146d62e5SAmir Goldstein return res; 963146d62e5SAmir Goldstein } 964146d62e5SAmir Goldstein 965146d62e5SAmir Goldstein /* 966146d62e5SAmir Goldstein * Create an inode cache entry for layer root dir, that will intentionally 967146d62e5SAmir Goldstein * fail ovl_verify_inode(), so any lookup that will find some layer root 968146d62e5SAmir Goldstein * will fail. 969146d62e5SAmir Goldstein */ 970146d62e5SAmir Goldstein struct inode *ovl_get_trap_inode(struct super_block *sb, struct dentry *dir) 971146d62e5SAmir Goldstein { 972146d62e5SAmir Goldstein struct inode *key = d_inode(dir); 973146d62e5SAmir Goldstein struct inode *trap; 974146d62e5SAmir Goldstein 975146d62e5SAmir Goldstein if (!d_is_dir(dir)) 976146d62e5SAmir Goldstein return ERR_PTR(-ENOTDIR); 977146d62e5SAmir Goldstein 978146d62e5SAmir Goldstein trap = iget5_locked(sb, (unsigned long) key, ovl_inode_test, 979146d62e5SAmir Goldstein ovl_inode_set, key); 980146d62e5SAmir Goldstein if (!trap) 981146d62e5SAmir Goldstein return ERR_PTR(-ENOMEM); 982146d62e5SAmir Goldstein 983146d62e5SAmir Goldstein if (!(trap->i_state & I_NEW)) { 984146d62e5SAmir Goldstein /* Conflicting layer roots? */ 985146d62e5SAmir Goldstein iput(trap); 986146d62e5SAmir Goldstein return ERR_PTR(-ELOOP); 987146d62e5SAmir Goldstein } 988146d62e5SAmir Goldstein 989146d62e5SAmir Goldstein trap->i_mode = S_IFDIR; 990146d62e5SAmir Goldstein trap->i_flags = S_DEAD; 991146d62e5SAmir Goldstein unlock_new_inode(trap); 992146d62e5SAmir Goldstein 993146d62e5SAmir Goldstein return trap; 994146d62e5SAmir Goldstein } 995146d62e5SAmir Goldstein 996764baba8SAmir Goldstein /* 997764baba8SAmir Goldstein * Does overlay inode need to be hashed by lower inode? 998764baba8SAmir Goldstein */ 999764baba8SAmir Goldstein static bool ovl_hash_bylower(struct super_block *sb, struct dentry *upper, 100074c6e384SMiklos Szeredi struct dentry *lower, bool index) 1001764baba8SAmir Goldstein { 1002764baba8SAmir Goldstein struct ovl_fs *ofs = sb->s_fs_info; 1003764baba8SAmir Goldstein 1004764baba8SAmir Goldstein /* No, if pure upper */ 1005764baba8SAmir Goldstein if (!lower) 1006764baba8SAmir Goldstein return false; 1007764baba8SAmir Goldstein 1008764baba8SAmir Goldstein /* Yes, if already indexed */ 1009764baba8SAmir Goldstein if (index) 1010764baba8SAmir Goldstein return true; 1011764baba8SAmir Goldstein 1012764baba8SAmir Goldstein /* Yes, if won't be copied up */ 101308f4c7c8SMiklos Szeredi if (!ovl_upper_mnt(ofs)) 1014764baba8SAmir Goldstein return true; 1015764baba8SAmir Goldstein 1016764baba8SAmir Goldstein /* No, if lower hardlink is or will be broken on copy up */ 1017764baba8SAmir Goldstein if ((upper || !ovl_indexdir(sb)) && 1018764baba8SAmir Goldstein !d_is_dir(lower) && d_inode(lower)->i_nlink > 1) 1019764baba8SAmir Goldstein return false; 1020764baba8SAmir Goldstein 1021764baba8SAmir Goldstein /* No, if non-indexed upper with NFS export */ 1022764baba8SAmir Goldstein if (sb->s_export_op && upper) 1023764baba8SAmir Goldstein return false; 1024764baba8SAmir Goldstein 1025764baba8SAmir Goldstein /* Otherwise, hash by lower inode for fsnotify */ 1026764baba8SAmir Goldstein return true; 1027764baba8SAmir Goldstein } 1028764baba8SAmir Goldstein 102901b39dccSAmir Goldstein static struct inode *ovl_iget5(struct super_block *sb, struct inode *newinode, 103001b39dccSAmir Goldstein struct inode *key) 103101b39dccSAmir Goldstein { 103201b39dccSAmir Goldstein return newinode ? inode_insert5(newinode, (unsigned long) key, 103301b39dccSAmir Goldstein ovl_inode_test, ovl_inode_set, key) : 103401b39dccSAmir Goldstein iget5_locked(sb, (unsigned long) key, 103501b39dccSAmir Goldstein ovl_inode_test, ovl_inode_set, key); 103601b39dccSAmir Goldstein } 103701b39dccSAmir Goldstein 1038ac6a52ebSVivek Goyal struct inode *ovl_get_inode(struct super_block *sb, 1039ac6a52ebSVivek Goyal struct ovl_inode_params *oip) 104051f7e52dSMiklos Szeredi { 1041610afc0bSMiklos Szeredi struct ovl_fs *ofs = OVL_FS(sb); 1042ac6a52ebSVivek Goyal struct dentry *upperdentry = oip->upperdentry; 1043ac6a52ebSVivek Goyal struct ovl_path *lowerpath = oip->lowerpath; 104409d8b586SMiklos Szeredi struct inode *realinode = upperdentry ? d_inode(upperdentry) : NULL; 104551f7e52dSMiklos Szeredi struct inode *inode; 104612574a9fSAmir Goldstein struct dentry *lowerdentry = lowerpath ? lowerpath->dentry : NULL; 1047ac6a52ebSVivek Goyal bool bylower = ovl_hash_bylower(sb, upperdentry, lowerdentry, 1048ac6a52ebSVivek Goyal oip->index); 1049300b124fSAmir Goldstein int fsid = bylower ? lowerpath->layer->fsid : 0; 105028166ab3SVivek Goyal bool is_dir; 1051695b46e7SAmir Goldstein unsigned long ino = 0; 1052acf3062aSAmir Goldstein int err = oip->newinode ? -EEXIST : -ENOMEM; 10536eaf0111SAmir Goldstein 105409d8b586SMiklos Szeredi if (!realinode) 105509d8b586SMiklos Szeredi realinode = d_inode(lowerdentry); 105609d8b586SMiklos Szeredi 10576eaf0111SAmir Goldstein /* 1058764baba8SAmir Goldstein * Copy up origin (lower) may exist for non-indexed upper, but we must 1059764baba8SAmir Goldstein * not use lower as hash key if this is a broken hardlink. 10606eaf0111SAmir Goldstein */ 106131747edaSAmir Goldstein is_dir = S_ISDIR(realinode->i_mode); 1062764baba8SAmir Goldstein if (upperdentry || bylower) { 1063764baba8SAmir Goldstein struct inode *key = d_inode(bylower ? lowerdentry : 1064764baba8SAmir Goldstein upperdentry); 106531747edaSAmir Goldstein unsigned int nlink = is_dir ? 1 : realinode->i_nlink; 1066b9ac5c27SMiklos Szeredi 106701b39dccSAmir Goldstein inode = ovl_iget5(sb, oip->newinode, key); 106809d8b586SMiklos Szeredi if (!inode) 1069027065b7SVivek Goyal goto out_err; 107009d8b586SMiklos Szeredi if (!(inode->i_state & I_NEW)) { 1071b9ac5c27SMiklos Szeredi /* 1072b9ac5c27SMiklos Szeredi * Verify that the underlying files stored in the inode 1073b9ac5c27SMiklos Szeredi * match those in the dentry. 1074b9ac5c27SMiklos Szeredi */ 10754b91c30aSAmir Goldstein if (!ovl_verify_inode(inode, lowerdentry, upperdentry, 10764b91c30aSAmir Goldstein true)) { 1077b9ac5c27SMiklos Szeredi iput(inode); 1078027065b7SVivek Goyal err = -ESTALE; 1079027065b7SVivek Goyal goto out_err; 1080b9ac5c27SMiklos Szeredi } 1081b9ac5c27SMiklos Szeredi 108209d8b586SMiklos Szeredi dput(upperdentry); 10839cec54c8SVivek Goyal kfree(oip->redirect); 108409d8b586SMiklos Szeredi goto out; 108509d8b586SMiklos Szeredi } 1086e9be9d5eSMiklos Szeredi 108731747edaSAmir Goldstein /* Recalculate nlink for non-dir due to indexing */ 108831747edaSAmir Goldstein if (!is_dir) 1089610afc0bSMiklos Szeredi nlink = ovl_get_nlink(ofs, lowerdentry, upperdentry, 1090610afc0bSMiklos Szeredi nlink); 10915f8415d6SAmir Goldstein set_nlink(inode, nlink); 1092695b46e7SAmir Goldstein ino = key->i_ino; 1093e6d2ebddSMiklos Szeredi } else { 1094764baba8SAmir Goldstein /* Lower hardlink that will be broken on copy up */ 10950aceb53eSAmir Goldstein inode = new_inode(sb); 1096027065b7SVivek Goyal if (!inode) { 1097027065b7SVivek Goyal err = -ENOMEM; 1098027065b7SVivek Goyal goto out_err; 1099027065b7SVivek Goyal } 1100300b124fSAmir Goldstein ino = realinode->i_ino; 1101300b124fSAmir Goldstein fsid = lowerpath->layer->fsid; 1102e6d2ebddSMiklos Szeredi } 110362c832edSAmir Goldstein ovl_fill_inode(inode, realinode->i_mode, realinode->i_rdev); 110462c832edSAmir Goldstein ovl_inode_init(inode, oip, ino, fsid); 110513c72075SMiklos Szeredi 1106610afc0bSMiklos Szeredi if (upperdentry && ovl_is_impuredir(sb, upperdentry)) 110713c72075SMiklos Szeredi ovl_set_flag(OVL_IMPURE, inode); 110813c72075SMiklos Szeredi 1109ac6a52ebSVivek Goyal if (oip->index) 11100471a9cdSVivek Goyal ovl_set_flag(OVL_INDEX, inode); 11110471a9cdSVivek Goyal 11129cec54c8SVivek Goyal OVL_I(inode)->redirect = oip->redirect; 11139cec54c8SVivek Goyal 1114a00c2d59SVivek Goyal if (bylower) 1115a00c2d59SVivek Goyal ovl_set_flag(OVL_CONST_INO, inode); 1116a00c2d59SVivek Goyal 1117b79e05aaSAmir Goldstein /* Check for non-merge dir that may have whiteouts */ 111831747edaSAmir Goldstein if (is_dir) { 1119ac6a52ebSVivek Goyal if (((upperdentry && lowerdentry) || oip->numlower > 1) || 1120610afc0bSMiklos Szeredi ovl_check_origin_xattr(ofs, upperdentry ?: lowerdentry)) { 1121b79e05aaSAmir Goldstein ovl_set_flag(OVL_WHITEOUTS, inode); 1122b79e05aaSAmir Goldstein } 1123b79e05aaSAmir Goldstein } 1124b79e05aaSAmir Goldstein 1125e6d2ebddSMiklos Szeredi if (inode->i_state & I_NEW) 1126e6d2ebddSMiklos Szeredi unlock_new_inode(inode); 1127e6d2ebddSMiklos Szeredi out: 1128e9be9d5eSMiklos Szeredi return inode; 1129b9ac5c27SMiklos Szeredi 1130027065b7SVivek Goyal out_err: 11311bd0a3aeSlijiazi pr_warn_ratelimited("failed to get inode (%i)\n", err); 1132027065b7SVivek Goyal inode = ERR_PTR(err); 1133b9ac5c27SMiklos Szeredi goto out; 1134e9be9d5eSMiklos Szeredi } 1135