1d2912cb1SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only 2bbb1e54dSMiklos Szeredi /* 3bbb1e54dSMiklos Szeredi * Copyright (C) 2011 Novell Inc. 4bbb1e54dSMiklos Szeredi * Copyright (C) 2016 Red Hat, Inc. 5bbb1e54dSMiklos Szeredi */ 6bbb1e54dSMiklos Szeredi 7bbb1e54dSMiklos Szeredi #include <linux/fs.h> 85b825c3aSIngo Molnar #include <linux/cred.h> 99ee60ce2SAmir Goldstein #include <linux/ctype.h> 10bbb1e54dSMiklos Szeredi #include <linux/namei.h> 11bbb1e54dSMiklos Szeredi #include <linux/xattr.h> 1202b69b28SMiklos Szeredi #include <linux/ratelimit.h> 13a9d01957SAmir Goldstein #include <linux/mount.h> 14a9d01957SAmir Goldstein #include <linux/exportfs.h> 15bbb1e54dSMiklos Szeredi #include "overlayfs.h" 16bbb1e54dSMiklos Szeredi 17e28edc46SMiklos Szeredi struct ovl_lookup_data { 18146d62e5SAmir Goldstein struct super_block *sb; 19*dad7017aSChristian Brauner struct vfsmount *mnt; 20e28edc46SMiklos Szeredi struct qstr name; 21e28edc46SMiklos Szeredi bool is_dir; 22e28edc46SMiklos Szeredi bool opaque; 23e28edc46SMiklos Szeredi bool stop; 24e28edc46SMiklos Szeredi bool last; 2502b69b28SMiklos Szeredi char *redirect; 269d3dfea3SVivek Goyal bool metacopy; 27e28edc46SMiklos Szeredi }; 28bbb1e54dSMiklos Szeredi 29*dad7017aSChristian Brauner static int ovl_check_redirect(struct path *path, struct ovl_lookup_data *d, 3002b69b28SMiklos Szeredi size_t prelen, const char *post) 3102b69b28SMiklos Szeredi { 3202b69b28SMiklos Szeredi int res; 330a2d0d3fSVivek Goyal char *buf; 34610afc0bSMiklos Szeredi struct ovl_fs *ofs = OVL_FS(d->sb); 3502b69b28SMiklos Szeredi 36*dad7017aSChristian Brauner buf = ovl_get_redirect_xattr(ofs, path, prelen + strlen(post)); 370a2d0d3fSVivek Goyal if (IS_ERR_OR_NULL(buf)) 380a2d0d3fSVivek Goyal return PTR_ERR(buf); 3902b69b28SMiklos Szeredi 4002b69b28SMiklos Szeredi if (buf[0] == '/') { 413ec9b3faSAmir Goldstein /* 423ec9b3faSAmir Goldstein * One of the ancestor path elements in an absolute path 433ec9b3faSAmir Goldstein * lookup in ovl_lookup_layer() could have been opaque and 443ec9b3faSAmir Goldstein * that will stop further lookup in lower layers (d->stop=true) 453ec9b3faSAmir Goldstein * But we have found an absolute redirect in decendant path 463ec9b3faSAmir Goldstein * element and that should force continue lookup in lower 473ec9b3faSAmir Goldstein * layers (reset d->stop). 483ec9b3faSAmir Goldstein */ 493ec9b3faSAmir Goldstein d->stop = false; 5002b69b28SMiklos Szeredi } else { 510a2d0d3fSVivek Goyal res = strlen(buf) + 1; 5202b69b28SMiklos Szeredi memmove(buf + prelen, buf, res); 5302b69b28SMiklos Szeredi memcpy(buf, d->name.name, prelen); 5402b69b28SMiklos Szeredi } 5502b69b28SMiklos Szeredi 5602b69b28SMiklos Szeredi strcat(buf, post); 5702b69b28SMiklos Szeredi kfree(d->redirect); 5802b69b28SMiklos Szeredi d->redirect = buf; 5902b69b28SMiklos Szeredi d->name.name = d->redirect; 6002b69b28SMiklos Szeredi d->name.len = strlen(d->redirect); 6102b69b28SMiklos Szeredi 6202b69b28SMiklos Szeredi return 0; 6302b69b28SMiklos Szeredi } 6402b69b28SMiklos Szeredi 65a9d01957SAmir Goldstein static int ovl_acceptable(void *ctx, struct dentry *dentry) 66a9d01957SAmir Goldstein { 67e8f9e5b7SAmir Goldstein /* 68e8f9e5b7SAmir Goldstein * A non-dir origin may be disconnected, which is fine, because 69e8f9e5b7SAmir Goldstein * we only need it for its unique inode number. 70e8f9e5b7SAmir Goldstein */ 71e8f9e5b7SAmir Goldstein if (!d_is_dir(dentry)) 72a9d01957SAmir Goldstein return 1; 73e8f9e5b7SAmir Goldstein 74e8f9e5b7SAmir Goldstein /* Don't decode a deleted empty directory */ 75e8f9e5b7SAmir Goldstein if (d_unhashed(dentry)) 76e8f9e5b7SAmir Goldstein return 0; 77e8f9e5b7SAmir Goldstein 78e8f9e5b7SAmir Goldstein /* Check if directory belongs to the layer we are decoding from */ 79e8f9e5b7SAmir Goldstein return is_subdir(dentry, ((struct vfsmount *)ctx)->mnt_root); 80a9d01957SAmir Goldstein } 81a9d01957SAmir Goldstein 822e1a5328SAmir Goldstein /* 832e1a5328SAmir Goldstein * Check validity of an overlay file handle buffer. 842e1a5328SAmir Goldstein * 852e1a5328SAmir Goldstein * Return 0 for a valid file handle. 862e1a5328SAmir Goldstein * Return -ENODATA for "origin unknown". 872e1a5328SAmir Goldstein * Return <0 for an invalid file handle. 882e1a5328SAmir Goldstein */ 89cbe7fba8SAmir Goldstein int ovl_check_fb_len(struct ovl_fb *fb, int fb_len) 902e1a5328SAmir Goldstein { 91cbe7fba8SAmir Goldstein if (fb_len < sizeof(struct ovl_fb) || fb_len < fb->len) 922e1a5328SAmir Goldstein return -EINVAL; 932e1a5328SAmir Goldstein 94cbe7fba8SAmir Goldstein if (fb->magic != OVL_FH_MAGIC) 952e1a5328SAmir Goldstein return -EINVAL; 962e1a5328SAmir Goldstein 972e1a5328SAmir Goldstein /* Treat larger version and unknown flags as "origin unknown" */ 98cbe7fba8SAmir Goldstein if (fb->version > OVL_FH_VERSION || fb->flags & ~OVL_FH_FLAG_ALL) 992e1a5328SAmir Goldstein return -ENODATA; 1002e1a5328SAmir Goldstein 1012e1a5328SAmir Goldstein /* Treat endianness mismatch as "origin unknown" */ 102cbe7fba8SAmir Goldstein if (!(fb->flags & OVL_FH_FLAG_ANY_ENDIAN) && 103cbe7fba8SAmir Goldstein (fb->flags & OVL_FH_FLAG_BIG_ENDIAN) != OVL_FH_FLAG_CPU_ENDIAN) 1042e1a5328SAmir Goldstein return -ENODATA; 1052e1a5328SAmir Goldstein 1062e1a5328SAmir Goldstein return 0; 1072e1a5328SAmir Goldstein } 1082e1a5328SAmir Goldstein 109*dad7017aSChristian Brauner static struct ovl_fh *ovl_get_fh(struct ovl_fs *ofs, struct dentry *upperdentry, 11043d193f8SMiklos Szeredi enum ovl_xattr ox) 111a9d01957SAmir Goldstein { 1122e1a5328SAmir Goldstein int res, err; 113a9d01957SAmir Goldstein struct ovl_fh *fh = NULL; 114a9d01957SAmir Goldstein 115*dad7017aSChristian Brauner res = ovl_getxattr_upper(ofs, upperdentry, ox, NULL, 0); 116a9d01957SAmir Goldstein if (res < 0) { 117a9d01957SAmir Goldstein if (res == -ENODATA || res == -EOPNOTSUPP) 118a9d01957SAmir Goldstein return NULL; 119a9d01957SAmir Goldstein goto fail; 120a9d01957SAmir Goldstein } 121a9d01957SAmir Goldstein /* Zero size value means "copied up but origin unknown" */ 122a9d01957SAmir Goldstein if (res == 0) 123a9d01957SAmir Goldstein return NULL; 124a9d01957SAmir Goldstein 125cbe7fba8SAmir Goldstein fh = kzalloc(res + OVL_FH_WIRE_OFFSET, GFP_KERNEL); 126a9d01957SAmir Goldstein if (!fh) 127a9d01957SAmir Goldstein return ERR_PTR(-ENOMEM); 128a9d01957SAmir Goldstein 129*dad7017aSChristian Brauner res = ovl_getxattr_upper(ofs, upperdentry, ox, fh->buf, res); 130a9d01957SAmir Goldstein if (res < 0) 131a9d01957SAmir Goldstein goto fail; 132a9d01957SAmir Goldstein 133cbe7fba8SAmir Goldstein err = ovl_check_fb_len(&fh->fb, res); 1342e1a5328SAmir Goldstein if (err < 0) { 1352e1a5328SAmir Goldstein if (err == -ENODATA) 136a9d01957SAmir Goldstein goto out; 1372e1a5328SAmir Goldstein goto invalid; 1382e1a5328SAmir Goldstein } 139a9d01957SAmir Goldstein 1408b88a2e6SAmir Goldstein return fh; 1418b88a2e6SAmir Goldstein 1428b88a2e6SAmir Goldstein out: 1438b88a2e6SAmir Goldstein kfree(fh); 1448b88a2e6SAmir Goldstein return NULL; 1458b88a2e6SAmir Goldstein 1468b88a2e6SAmir Goldstein fail: 1471bd0a3aeSlijiazi pr_warn_ratelimited("failed to get origin (%i)\n", res); 1488b88a2e6SAmir Goldstein goto out; 1498b88a2e6SAmir Goldstein invalid: 1501bd0a3aeSlijiazi pr_warn_ratelimited("invalid origin (%*phN)\n", res, fh); 1518b88a2e6SAmir Goldstein goto out; 1528b88a2e6SAmir Goldstein } 1538b88a2e6SAmir Goldstein 1541cdb0cb6SPavel Tikhomirov struct dentry *ovl_decode_real_fh(struct ovl_fs *ofs, struct ovl_fh *fh, 1551cdb0cb6SPavel Tikhomirov struct vfsmount *mnt, bool connected) 1568b88a2e6SAmir Goldstein { 157e8f9e5b7SAmir Goldstein struct dentry *real; 1588b88a2e6SAmir Goldstein int bytes; 1598b88a2e6SAmir Goldstein 160c846af05SMiklos Szeredi if (!capable(CAP_DAC_READ_SEARCH)) 161c846af05SMiklos Szeredi return NULL; 162c846af05SMiklos Szeredi 163a9d01957SAmir Goldstein /* 164a9d01957SAmir Goldstein * Make sure that the stored uuid matches the uuid of the lower 165a9d01957SAmir Goldstein * layer where file handle will be decoded. 1665830fb6bSPavel Tikhomirov * In case of uuid=off option just make sure that stored uuid is null. 167a9d01957SAmir Goldstein */ 1685830fb6bSPavel Tikhomirov if (ofs->config.uuid ? !uuid_equal(&fh->fb.uuid, &mnt->mnt_sb->s_uuid) : 1695830fb6bSPavel Tikhomirov !uuid_is_null(&fh->fb.uuid)) 1702e1a5328SAmir Goldstein return NULL; 171a9d01957SAmir Goldstein 172cbe7fba8SAmir Goldstein bytes = (fh->fb.len - offsetof(struct ovl_fb, fid)); 173cbe7fba8SAmir Goldstein real = exportfs_decode_fh(mnt, (struct fid *)fh->fb.fid, 174cbe7fba8SAmir Goldstein bytes >> 2, (int)fh->fb.type, 1758a22efa1SAmir Goldstein connected ? ovl_acceptable : NULL, mnt); 176e8f9e5b7SAmir Goldstein if (IS_ERR(real)) { 177e8f9e5b7SAmir Goldstein /* 178e8f9e5b7SAmir Goldstein * Treat stale file handle to lower file as "origin unknown". 179e8f9e5b7SAmir Goldstein * upper file handle could become stale when upper file is 180e8f9e5b7SAmir Goldstein * unlinked and this information is needed to handle stale 181e8f9e5b7SAmir Goldstein * index entries correctly. 182e8f9e5b7SAmir Goldstein */ 183e8f9e5b7SAmir Goldstein if (real == ERR_PTR(-ESTALE) && 184cbe7fba8SAmir Goldstein !(fh->fb.flags & OVL_FH_FLAG_PATH_UPPER)) 185e8f9e5b7SAmir Goldstein real = NULL; 186e8f9e5b7SAmir Goldstein return real; 187a9d01957SAmir Goldstein } 188a9d01957SAmir Goldstein 189e8f9e5b7SAmir Goldstein if (ovl_dentry_weird(real)) { 190e8f9e5b7SAmir Goldstein dput(real); 1912e1a5328SAmir Goldstein return NULL; 1922e1a5328SAmir Goldstein } 1932e1a5328SAmir Goldstein 194e8f9e5b7SAmir Goldstein return real; 195a9d01957SAmir Goldstein } 196a9d01957SAmir Goldstein 197*dad7017aSChristian Brauner static bool ovl_is_opaquedir(struct ovl_fs *ofs, struct path *path) 198ee1d6d37SAmir Goldstein { 199*dad7017aSChristian Brauner return ovl_path_check_dir_xattr(ofs, path, OVL_XATTR_OPAQUE); 200ee1d6d37SAmir Goldstein } 201ee1d6d37SAmir Goldstein 2021434a65eSChengguang Xu static struct dentry *ovl_lookup_positive_unlocked(const char *name, 2031434a65eSChengguang Xu struct dentry *base, int len, 2041434a65eSChengguang Xu bool drop_negative) 2051434a65eSChengguang Xu { 2061434a65eSChengguang Xu struct dentry *ret = lookup_one_len_unlocked(name, base, len); 2071434a65eSChengguang Xu 2081434a65eSChengguang Xu if (!IS_ERR(ret) && d_flags_negative(smp_load_acquire(&ret->d_flags))) { 2091434a65eSChengguang Xu if (drop_negative && ret->d_lockref.count == 1) { 2101434a65eSChengguang Xu spin_lock(&ret->d_lock); 2111434a65eSChengguang Xu /* Recheck condition under lock */ 2121434a65eSChengguang Xu if (d_is_negative(ret) && ret->d_lockref.count == 1) 2131434a65eSChengguang Xu __d_drop(ret); 2141434a65eSChengguang Xu spin_unlock(&ret->d_lock); 2151434a65eSChengguang Xu } 2161434a65eSChengguang Xu dput(ret); 2171434a65eSChengguang Xu ret = ERR_PTR(-ENOENT); 2181434a65eSChengguang Xu } 2191434a65eSChengguang Xu return ret; 2201434a65eSChengguang Xu } 2211434a65eSChengguang Xu 222e28edc46SMiklos Szeredi static int ovl_lookup_single(struct dentry *base, struct ovl_lookup_data *d, 223e28edc46SMiklos Szeredi const char *name, unsigned int namelen, 22402b69b28SMiklos Szeredi size_t prelen, const char *post, 2251434a65eSChengguang Xu struct dentry **ret, bool drop_negative) 226e28edc46SMiklos Szeredi { 227e28edc46SMiklos Szeredi struct dentry *this; 228*dad7017aSChristian Brauner struct path path; 229e28edc46SMiklos Szeredi int err; 230102b0d11SVivek Goyal bool last_element = !post[0]; 231e28edc46SMiklos Szeredi 2321434a65eSChengguang Xu this = ovl_lookup_positive_unlocked(name, base, namelen, drop_negative); 233e28edc46SMiklos Szeredi if (IS_ERR(this)) { 234e28edc46SMiklos Szeredi err = PTR_ERR(this); 235e28edc46SMiklos Szeredi this = NULL; 236e28edc46SMiklos Szeredi if (err == -ENOENT || err == -ENAMETOOLONG) 237e28edc46SMiklos Szeredi goto out; 238e28edc46SMiklos Szeredi goto out_err; 239e28edc46SMiklos Szeredi } 240e28edc46SMiklos Szeredi 241e28edc46SMiklos Szeredi if (ovl_dentry_weird(this)) { 242e28edc46SMiklos Szeredi /* Don't support traversing automounts and other weirdness */ 243e28edc46SMiklos Szeredi err = -EREMOTE; 244e28edc46SMiklos Szeredi goto out_err; 245e28edc46SMiklos Szeredi } 246e28edc46SMiklos Szeredi if (ovl_is_whiteout(this)) { 247e28edc46SMiklos Szeredi d->stop = d->opaque = true; 248e28edc46SMiklos Szeredi goto put_and_out; 249e28edc46SMiklos Szeredi } 2503a291774SMiklos Szeredi /* 2519d3dfea3SVivek Goyal * This dentry should be a regular file if previous layer lookup 2529d3dfea3SVivek Goyal * found a metacopy dentry. 2533a291774SMiklos Szeredi */ 2549d3dfea3SVivek Goyal if (last_element && d->metacopy && !d_is_reg(this)) { 2559d3dfea3SVivek Goyal d->stop = true; 2569d3dfea3SVivek Goyal goto put_and_out; 2579d3dfea3SVivek Goyal } 258*dad7017aSChristian Brauner 259*dad7017aSChristian Brauner path.dentry = this; 260*dad7017aSChristian Brauner path.mnt = d->mnt; 2619d3dfea3SVivek Goyal if (!d_can_lookup(this)) { 2629d3dfea3SVivek Goyal if (d->is_dir || !last_element) { 2639d3dfea3SVivek Goyal d->stop = true; 2649d3dfea3SVivek Goyal goto put_and_out; 2659d3dfea3SVivek Goyal } 266*dad7017aSChristian Brauner err = ovl_check_metacopy_xattr(OVL_FS(d->sb), &path); 2679d3dfea3SVivek Goyal if (err < 0) 2689d3dfea3SVivek Goyal goto out_err; 2699d3dfea3SVivek Goyal 2709d3dfea3SVivek Goyal d->metacopy = err; 2719d3dfea3SVivek Goyal d->stop = !d->metacopy; 272b8a8824cSVivek Goyal if (!d->metacopy || d->last) 273e28edc46SMiklos Szeredi goto out; 2740618a816SVivek Goyal } else { 275146d62e5SAmir Goldstein if (ovl_lookup_trap_inode(d->sb, this)) { 276146d62e5SAmir Goldstein /* Caught in a trap of overlapping layers */ 277146d62e5SAmir Goldstein err = -ELOOP; 278146d62e5SAmir Goldstein goto out_err; 279146d62e5SAmir Goldstein } 280146d62e5SAmir Goldstein 281102b0d11SVivek Goyal if (last_element) 282e28edc46SMiklos Szeredi d->is_dir = true; 283e9b77f90SVivek Goyal if (d->last) 284e9b77f90SVivek Goyal goto out; 285e9b77f90SVivek Goyal 286*dad7017aSChristian Brauner if (ovl_is_opaquedir(OVL_FS(d->sb), &path)) { 287102b0d11SVivek Goyal d->stop = true; 288102b0d11SVivek Goyal if (last_element) 289102b0d11SVivek Goyal d->opaque = true; 290e28edc46SMiklos Szeredi goto out; 291e28edc46SMiklos Szeredi } 2920618a816SVivek Goyal } 293*dad7017aSChristian Brauner err = ovl_check_redirect(&path, d, prelen, post); 29402b69b28SMiklos Szeredi if (err) 29502b69b28SMiklos Szeredi goto out_err; 296e28edc46SMiklos Szeredi out: 297e28edc46SMiklos Szeredi *ret = this; 298e28edc46SMiklos Szeredi return 0; 299e28edc46SMiklos Szeredi 300e28edc46SMiklos Szeredi put_and_out: 301e28edc46SMiklos Szeredi dput(this); 302e28edc46SMiklos Szeredi this = NULL; 303e28edc46SMiklos Szeredi goto out; 304e28edc46SMiklos Szeredi 305e28edc46SMiklos Szeredi out_err: 306e28edc46SMiklos Szeredi dput(this); 307e28edc46SMiklos Szeredi return err; 308e28edc46SMiklos Szeredi } 309e28edc46SMiklos Szeredi 310e28edc46SMiklos Szeredi static int ovl_lookup_layer(struct dentry *base, struct ovl_lookup_data *d, 3111434a65eSChengguang Xu struct dentry **ret, bool drop_negative) 312e28edc46SMiklos Szeredi { 3134c7d0c9cSAmir Goldstein /* Counting down from the end, since the prefix can change */ 3144c7d0c9cSAmir Goldstein size_t rem = d->name.len - 1; 31502b69b28SMiklos Szeredi struct dentry *dentry = NULL; 31602b69b28SMiklos Szeredi int err; 31702b69b28SMiklos Szeredi 3184c7d0c9cSAmir Goldstein if (d->name.name[0] != '/') 31902b69b28SMiklos Szeredi return ovl_lookup_single(base, d, d->name.name, d->name.len, 3201434a65eSChengguang Xu 0, "", ret, drop_negative); 32102b69b28SMiklos Szeredi 3224c7d0c9cSAmir Goldstein while (!IS_ERR_OR_NULL(base) && d_can_lookup(base)) { 3234c7d0c9cSAmir Goldstein const char *s = d->name.name + d->name.len - rem; 32402b69b28SMiklos Szeredi const char *next = strchrnul(s, '/'); 3254c7d0c9cSAmir Goldstein size_t thislen = next - s; 3264c7d0c9cSAmir Goldstein bool end = !next[0]; 32702b69b28SMiklos Szeredi 3284c7d0c9cSAmir Goldstein /* Verify we did not go off the rails */ 3294c7d0c9cSAmir Goldstein if (WARN_ON(s[-1] != '/')) 33002b69b28SMiklos Szeredi return -EIO; 33102b69b28SMiklos Szeredi 3324c7d0c9cSAmir Goldstein err = ovl_lookup_single(base, d, s, thislen, 3331434a65eSChengguang Xu d->name.len - rem, next, &base, 3341434a65eSChengguang Xu drop_negative); 33502b69b28SMiklos Szeredi dput(dentry); 33602b69b28SMiklos Szeredi if (err) 33702b69b28SMiklos Szeredi return err; 33802b69b28SMiklos Szeredi dentry = base; 3394c7d0c9cSAmir Goldstein if (end) 3404c7d0c9cSAmir Goldstein break; 3414c7d0c9cSAmir Goldstein 3424c7d0c9cSAmir Goldstein rem -= thislen + 1; 3434c7d0c9cSAmir Goldstein 3444c7d0c9cSAmir Goldstein if (WARN_ON(rem >= d->name.len)) 3454c7d0c9cSAmir Goldstein return -EIO; 34602b69b28SMiklos Szeredi } 34702b69b28SMiklos Szeredi *ret = dentry; 34802b69b28SMiklos Szeredi return 0; 349e28edc46SMiklos Szeredi } 350e28edc46SMiklos Szeredi 351a9d01957SAmir Goldstein 3528a22efa1SAmir Goldstein int ovl_check_origin_fh(struct ovl_fs *ofs, struct ovl_fh *fh, bool connected, 353f941866fSAmir Goldstein struct dentry *upperdentry, struct ovl_path **stackp) 354a9d01957SAmir Goldstein { 355f7d3dacaSAmir Goldstein struct dentry *origin = NULL; 356f7d3dacaSAmir Goldstein int i; 357a9d01957SAmir Goldstein 35894375f9dSAmir Goldstein for (i = 1; i < ofs->numlayer; i++) { 3597e63c87fSAmir Goldstein /* 3607e63c87fSAmir Goldstein * If lower fs uuid is not unique among lower fs we cannot match 3617e63c87fSAmir Goldstein * fh->uuid to layer. 3627e63c87fSAmir Goldstein */ 36394375f9dSAmir Goldstein if (ofs->layers[i].fsid && 36494375f9dSAmir Goldstein ofs->layers[i].fs->bad_uuid) 3657e63c87fSAmir Goldstein continue; 3667e63c87fSAmir Goldstein 3671cdb0cb6SPavel Tikhomirov origin = ovl_decode_real_fh(ofs, fh, ofs->layers[i].mnt, 3688a22efa1SAmir Goldstein connected); 369f7d3dacaSAmir Goldstein if (origin) 370f7d3dacaSAmir Goldstein break; 371f7d3dacaSAmir Goldstein } 372f7d3dacaSAmir Goldstein 373f7d3dacaSAmir Goldstein if (!origin) 3742e1a5328SAmir Goldstein return -ESTALE; 3752e1a5328SAmir Goldstein else if (IS_ERR(origin)) 3762e1a5328SAmir Goldstein return PTR_ERR(origin); 377f7d3dacaSAmir Goldstein 378f941866fSAmir Goldstein if (upperdentry && !ovl_is_whiteout(upperdentry) && 3796e3e2c43SAl Viro inode_wrong_type(d_inode(upperdentry), d_inode(origin)->i_mode)) 3802e1a5328SAmir Goldstein goto invalid; 3812e1a5328SAmir Goldstein 382415543d5SAmir Goldstein if (!*stackp) 383b9343632SChandan Rajendra *stackp = kmalloc(sizeof(struct ovl_path), GFP_KERNEL); 384a9d01957SAmir Goldstein if (!*stackp) { 385a9d01957SAmir Goldstein dput(origin); 386a9d01957SAmir Goldstein return -ENOMEM; 387a9d01957SAmir Goldstein } 3881eff1a1dSAmir Goldstein **stackp = (struct ovl_path){ 3891eff1a1dSAmir Goldstein .dentry = origin, 39094375f9dSAmir Goldstein .layer = &ofs->layers[i] 3911eff1a1dSAmir Goldstein }; 392a9d01957SAmir Goldstein 393a9d01957SAmir Goldstein return 0; 3942e1a5328SAmir Goldstein 3952e1a5328SAmir Goldstein invalid: 3961bd0a3aeSlijiazi pr_warn_ratelimited("invalid origin (%pd2, ftype=%x, origin ftype=%x).\n", 3972e1a5328SAmir Goldstein upperdentry, d_inode(upperdentry)->i_mode & S_IFMT, 3982e1a5328SAmir Goldstein d_inode(origin)->i_mode & S_IFMT); 3992e1a5328SAmir Goldstein dput(origin); 400ffb24e3cSAmir Goldstein return -ESTALE; 4012e1a5328SAmir Goldstein } 4022e1a5328SAmir Goldstein 4031eff1a1dSAmir Goldstein static int ovl_check_origin(struct ovl_fs *ofs, struct dentry *upperdentry, 404d78a0dcfSyoungjun struct ovl_path **stackp) 4052e1a5328SAmir Goldstein { 406610afc0bSMiklos Szeredi struct ovl_fh *fh = ovl_get_fh(ofs, upperdentry, OVL_XATTR_ORIGIN); 4072e1a5328SAmir Goldstein int err; 4082e1a5328SAmir Goldstein 4092e1a5328SAmir Goldstein if (IS_ERR_OR_NULL(fh)) 4102e1a5328SAmir Goldstein return PTR_ERR(fh); 4112e1a5328SAmir Goldstein 4128a22efa1SAmir Goldstein err = ovl_check_origin_fh(ofs, fh, false, upperdentry, stackp); 4132e1a5328SAmir Goldstein kfree(fh); 4142e1a5328SAmir Goldstein 4152e1a5328SAmir Goldstein if (err) { 4162e1a5328SAmir Goldstein if (err == -ESTALE) 4172e1a5328SAmir Goldstein return 0; 4182e1a5328SAmir Goldstein return err; 4192e1a5328SAmir Goldstein } 4202e1a5328SAmir Goldstein 4212e1a5328SAmir Goldstein return 0; 422a9d01957SAmir Goldstein } 423a9d01957SAmir Goldstein 424bbb1e54dSMiklos Szeredi /* 42505122443SAmir Goldstein * Verify that @fh matches the file handle stored in xattr @name. 4268b88a2e6SAmir Goldstein * Return 0 on match, -ESTALE on mismatch, < 0 on error. 4278b88a2e6SAmir Goldstein */ 428610afc0bSMiklos Szeredi static int ovl_verify_fh(struct ovl_fs *ofs, struct dentry *dentry, 42943d193f8SMiklos Szeredi enum ovl_xattr ox, const struct ovl_fh *fh) 4308b88a2e6SAmir Goldstein { 43143d193f8SMiklos Szeredi struct ovl_fh *ofh = ovl_get_fh(ofs, dentry, ox); 4328b88a2e6SAmir Goldstein int err = 0; 4338b88a2e6SAmir Goldstein 4348b88a2e6SAmir Goldstein if (!ofh) 4358b88a2e6SAmir Goldstein return -ENODATA; 4368b88a2e6SAmir Goldstein 4378b88a2e6SAmir Goldstein if (IS_ERR(ofh)) 4388b88a2e6SAmir Goldstein return PTR_ERR(ofh); 4398b88a2e6SAmir Goldstein 440cbe7fba8SAmir Goldstein if (fh->fb.len != ofh->fb.len || memcmp(&fh->fb, &ofh->fb, fh->fb.len)) 4418b88a2e6SAmir Goldstein err = -ESTALE; 4428b88a2e6SAmir Goldstein 4438b88a2e6SAmir Goldstein kfree(ofh); 4448b88a2e6SAmir Goldstein return err; 4458b88a2e6SAmir Goldstein } 4468b88a2e6SAmir Goldstein 4478b88a2e6SAmir Goldstein /* 44805122443SAmir Goldstein * Verify that @real dentry matches the file handle stored in xattr @name. 4498b88a2e6SAmir Goldstein * 45005122443SAmir Goldstein * If @set is true and there is no stored file handle, encode @real and store 45105122443SAmir Goldstein * file handle in xattr @name. 4528b88a2e6SAmir Goldstein * 45305122443SAmir Goldstein * Return 0 on match, -ESTALE on mismatch, -ENODATA on no xattr, < 0 on error. 4548b88a2e6SAmir Goldstein */ 455610afc0bSMiklos Szeredi int ovl_verify_set_fh(struct ovl_fs *ofs, struct dentry *dentry, 45643d193f8SMiklos Szeredi enum ovl_xattr ox, struct dentry *real, bool is_upper, 457610afc0bSMiklos Szeredi bool set) 4588b88a2e6SAmir Goldstein { 4598b88a2e6SAmir Goldstein struct inode *inode; 4608b88a2e6SAmir Goldstein struct ovl_fh *fh; 4618b88a2e6SAmir Goldstein int err; 4628b88a2e6SAmir Goldstein 4631cdb0cb6SPavel Tikhomirov fh = ovl_encode_real_fh(ofs, real, is_upper); 4648b88a2e6SAmir Goldstein err = PTR_ERR(fh); 465babf4770SAmir Goldstein if (IS_ERR(fh)) { 466babf4770SAmir Goldstein fh = NULL; 4678b88a2e6SAmir Goldstein goto fail; 468babf4770SAmir Goldstein } 4698b88a2e6SAmir Goldstein 47043d193f8SMiklos Szeredi err = ovl_verify_fh(ofs, dentry, ox, fh); 4718b88a2e6SAmir Goldstein if (set && err == -ENODATA) 472c914c0e2SAmir Goldstein err = ovl_setxattr(ofs, dentry, ox, fh->buf, fh->fb.len); 4738b88a2e6SAmir Goldstein if (err) 4748b88a2e6SAmir Goldstein goto fail; 4758b88a2e6SAmir Goldstein 4768b88a2e6SAmir Goldstein out: 4778b88a2e6SAmir Goldstein kfree(fh); 4788b88a2e6SAmir Goldstein return err; 4798b88a2e6SAmir Goldstein 4808b88a2e6SAmir Goldstein fail: 48105122443SAmir Goldstein inode = d_inode(real); 4821bd0a3aeSlijiazi pr_warn_ratelimited("failed to verify %s (%pd2, ino=%lu, err=%i)\n", 48305122443SAmir Goldstein is_upper ? "upper" : "origin", real, 48405122443SAmir Goldstein inode ? inode->i_ino : 0, err); 4858b88a2e6SAmir Goldstein goto out; 4868b88a2e6SAmir Goldstein } 4878b88a2e6SAmir Goldstein 488e8f9e5b7SAmir Goldstein /* Get upper dentry from index */ 4893b0bfc6eSAmir Goldstein struct dentry *ovl_index_upper(struct ovl_fs *ofs, struct dentry *index) 490e8f9e5b7SAmir Goldstein { 491e8f9e5b7SAmir Goldstein struct ovl_fh *fh; 492e8f9e5b7SAmir Goldstein struct dentry *upper; 493e8f9e5b7SAmir Goldstein 494e8f9e5b7SAmir Goldstein if (!d_is_dir(index)) 495e8f9e5b7SAmir Goldstein return dget(index); 496e8f9e5b7SAmir Goldstein 497610afc0bSMiklos Szeredi fh = ovl_get_fh(ofs, index, OVL_XATTR_UPPER); 498e8f9e5b7SAmir Goldstein if (IS_ERR_OR_NULL(fh)) 499e8f9e5b7SAmir Goldstein return ERR_CAST(fh); 500e8f9e5b7SAmir Goldstein 5011cdb0cb6SPavel Tikhomirov upper = ovl_decode_real_fh(ofs, fh, ovl_upper_mnt(ofs), true); 502e8f9e5b7SAmir Goldstein kfree(fh); 503e8f9e5b7SAmir Goldstein 504e8f9e5b7SAmir Goldstein if (IS_ERR_OR_NULL(upper)) 505e8f9e5b7SAmir Goldstein return upper ?: ERR_PTR(-ESTALE); 506e8f9e5b7SAmir Goldstein 507e8f9e5b7SAmir Goldstein if (!d_is_dir(upper)) { 5081bd0a3aeSlijiazi pr_warn_ratelimited("invalid index upper (%pd2, upper=%pd2).\n", 509e8f9e5b7SAmir Goldstein index, upper); 510e8f9e5b7SAmir Goldstein dput(upper); 511e8f9e5b7SAmir Goldstein return ERR_PTR(-EIO); 512e8f9e5b7SAmir Goldstein } 513e8f9e5b7SAmir Goldstein 514e8f9e5b7SAmir Goldstein return upper; 515e8f9e5b7SAmir Goldstein } 516e8f9e5b7SAmir Goldstein 5178b88a2e6SAmir Goldstein /* 518415543d5SAmir Goldstein * Verify that an index entry name matches the origin file handle stored in 519415543d5SAmir Goldstein * OVL_XATTR_ORIGIN and that origin file handle can be decoded to lower path. 520415543d5SAmir Goldstein * Return 0 on match, -ESTALE on mismatch or stale origin, < 0 on error. 521415543d5SAmir Goldstein */ 5221eff1a1dSAmir Goldstein int ovl_verify_index(struct ovl_fs *ofs, struct dentry *index) 523415543d5SAmir Goldstein { 524415543d5SAmir Goldstein struct ovl_fh *fh = NULL; 525415543d5SAmir Goldstein size_t len; 526b9343632SChandan Rajendra struct ovl_path origin = { }; 527b9343632SChandan Rajendra struct ovl_path *stack = &origin; 528e8f9e5b7SAmir Goldstein struct dentry *upper = NULL; 529415543d5SAmir Goldstein int err; 530415543d5SAmir Goldstein 531415543d5SAmir Goldstein if (!d_inode(index)) 532415543d5SAmir Goldstein return 0; 533415543d5SAmir Goldstein 534fa0096e3SAmir Goldstein err = -EINVAL; 535cbe7fba8SAmir Goldstein if (index->d_name.len < sizeof(struct ovl_fb)*2) 536415543d5SAmir Goldstein goto fail; 537415543d5SAmir Goldstein 538415543d5SAmir Goldstein err = -ENOMEM; 539415543d5SAmir Goldstein len = index->d_name.len / 2; 540cbe7fba8SAmir Goldstein fh = kzalloc(len + OVL_FH_WIRE_OFFSET, GFP_KERNEL); 541415543d5SAmir Goldstein if (!fh) 542415543d5SAmir Goldstein goto fail; 543415543d5SAmir Goldstein 544415543d5SAmir Goldstein err = -EINVAL; 545cbe7fba8SAmir Goldstein if (hex2bin(fh->buf, index->d_name.name, len)) 5462e1a5328SAmir Goldstein goto fail; 5472e1a5328SAmir Goldstein 548cbe7fba8SAmir Goldstein err = ovl_check_fb_len(&fh->fb, len); 5492e1a5328SAmir Goldstein if (err) 550415543d5SAmir Goldstein goto fail; 551415543d5SAmir Goldstein 5527db25d36SAmir Goldstein /* 5537db25d36SAmir Goldstein * Whiteout index entries are used as an indication that an exported 5547db25d36SAmir Goldstein * overlay file handle should be treated as stale (i.e. after unlink 5557db25d36SAmir Goldstein * of the overlay inode). These entries contain no origin xattr. 5567db25d36SAmir Goldstein */ 5577db25d36SAmir Goldstein if (ovl_is_whiteout(index)) 5587db25d36SAmir Goldstein goto out; 5597db25d36SAmir Goldstein 560e8f9e5b7SAmir Goldstein /* 561e8f9e5b7SAmir Goldstein * Verifying directory index entries are not stale is expensive, so 562e8f9e5b7SAmir Goldstein * only verify stale dir index if NFS export is enabled. 563e8f9e5b7SAmir Goldstein */ 564e8f9e5b7SAmir Goldstein if (d_is_dir(index) && !ofs->config.nfs_export) 565e8f9e5b7SAmir Goldstein goto out; 566e8f9e5b7SAmir Goldstein 567e8f9e5b7SAmir Goldstein /* 568e8f9e5b7SAmir Goldstein * Directory index entries should have 'upper' xattr pointing to the 569e8f9e5b7SAmir Goldstein * real upper dir. Non-dir index entries are hardlinks to the upper 570e8f9e5b7SAmir Goldstein * real inode. For non-dir index, we can read the copy up origin xattr 571e8f9e5b7SAmir Goldstein * directly from the index dentry, but for dir index we first need to 572e8f9e5b7SAmir Goldstein * decode the upper directory. 573e8f9e5b7SAmir Goldstein */ 574e8f9e5b7SAmir Goldstein upper = ovl_index_upper(ofs, index); 575e8f9e5b7SAmir Goldstein if (IS_ERR_OR_NULL(upper)) { 576e8f9e5b7SAmir Goldstein err = PTR_ERR(upper); 57724f0b172SAmir Goldstein /* 57824f0b172SAmir Goldstein * Directory index entries with no 'upper' xattr need to be 57924f0b172SAmir Goldstein * removed. When dir index entry has a stale 'upper' xattr, 58024f0b172SAmir Goldstein * we assume that upper dir was removed and we treat the dir 58124f0b172SAmir Goldstein * index as orphan entry that needs to be whited out. 58224f0b172SAmir Goldstein */ 58324f0b172SAmir Goldstein if (err == -ESTALE) 58424f0b172SAmir Goldstein goto orphan; 58524f0b172SAmir Goldstein else if (!err) 586e8f9e5b7SAmir Goldstein err = -ESTALE; 587e8f9e5b7SAmir Goldstein goto fail; 588e8f9e5b7SAmir Goldstein } 589e8f9e5b7SAmir Goldstein 590610afc0bSMiklos Szeredi err = ovl_verify_fh(ofs, upper, OVL_XATTR_ORIGIN, fh); 591e8f9e5b7SAmir Goldstein dput(upper); 592415543d5SAmir Goldstein if (err) 593415543d5SAmir Goldstein goto fail; 594415543d5SAmir Goldstein 595e8f9e5b7SAmir Goldstein /* Check if non-dir index is orphan and don't warn before cleaning it */ 596e8f9e5b7SAmir Goldstein if (!d_is_dir(index) && d_inode(index)->i_nlink == 1) { 5978a22efa1SAmir Goldstein err = ovl_check_origin_fh(ofs, fh, false, index, &stack); 598415543d5SAmir Goldstein if (err) 599415543d5SAmir Goldstein goto fail; 600415543d5SAmir Goldstein 601610afc0bSMiklos Szeredi if (ovl_get_nlink(ofs, origin.dentry, index, 0) == 0) 60224f0b172SAmir Goldstein goto orphan; 603e8f9e5b7SAmir Goldstein } 604caf70cb2SAmir Goldstein 605415543d5SAmir Goldstein out: 606e8f9e5b7SAmir Goldstein dput(origin.dentry); 607415543d5SAmir Goldstein kfree(fh); 608415543d5SAmir Goldstein return err; 609415543d5SAmir Goldstein 610415543d5SAmir Goldstein fail: 6111bd0a3aeSlijiazi pr_warn_ratelimited("failed to verify index (%pd2, ftype=%x, err=%i)\n", 61261b67471SAmir Goldstein index, d_inode(index)->i_mode & S_IFMT, err); 613415543d5SAmir Goldstein goto out; 61424f0b172SAmir Goldstein 61524f0b172SAmir Goldstein orphan: 6161bd0a3aeSlijiazi pr_warn_ratelimited("orphan index entry (%pd2, ftype=%x, nlink=%u)\n", 61724f0b172SAmir Goldstein index, d_inode(index)->i_mode & S_IFMT, 61824f0b172SAmir Goldstein d_inode(index)->i_nlink); 61924f0b172SAmir Goldstein err = -ENOENT; 62024f0b172SAmir Goldstein goto out; 621415543d5SAmir Goldstein } 622415543d5SAmir Goldstein 62391ffe7beSAmir Goldstein static int ovl_get_index_name_fh(struct ovl_fh *fh, struct qstr *name) 62491ffe7beSAmir Goldstein { 62591ffe7beSAmir Goldstein char *n, *s; 62691ffe7beSAmir Goldstein 627cbe7fba8SAmir Goldstein n = kcalloc(fh->fb.len, 2, GFP_KERNEL); 62891ffe7beSAmir Goldstein if (!n) 62991ffe7beSAmir Goldstein return -ENOMEM; 63091ffe7beSAmir Goldstein 631cbe7fba8SAmir Goldstein s = bin2hex(n, fh->buf, fh->fb.len); 63291ffe7beSAmir Goldstein *name = (struct qstr) QSTR_INIT(n, s - n); 63391ffe7beSAmir Goldstein 63491ffe7beSAmir Goldstein return 0; 63591ffe7beSAmir Goldstein 63691ffe7beSAmir Goldstein } 63791ffe7beSAmir Goldstein 638415543d5SAmir Goldstein /* 639359f392cSAmir Goldstein * Lookup in indexdir for the index entry of a lower real inode or a copy up 640359f392cSAmir Goldstein * origin inode. The index entry name is the hex representation of the lower 641359f392cSAmir Goldstein * inode file handle. 642359f392cSAmir Goldstein * 643359f392cSAmir Goldstein * If the index dentry in negative, then either no lower aliases have been 644359f392cSAmir Goldstein * copied up yet, or aliases have been copied up in older kernels and are 645359f392cSAmir Goldstein * not indexed. 646359f392cSAmir Goldstein * 647359f392cSAmir Goldstein * If the index dentry for a copy up origin inode is positive, but points 648359f392cSAmir Goldstein * to an inode different than the upper inode, then either the upper inode 649359f392cSAmir Goldstein * has been copied up and not indexed or it was indexed, but since then 650359f392cSAmir Goldstein * index dir was cleared. Either way, that index cannot be used to indentify 651359f392cSAmir Goldstein * the overlay inode. 652359f392cSAmir Goldstein */ 6531cdb0cb6SPavel Tikhomirov int ovl_get_index_name(struct ovl_fs *ofs, struct dentry *origin, 6541cdb0cb6SPavel Tikhomirov struct qstr *name) 655359f392cSAmir Goldstein { 656359f392cSAmir Goldstein struct ovl_fh *fh; 65791ffe7beSAmir Goldstein int err; 658359f392cSAmir Goldstein 6591cdb0cb6SPavel Tikhomirov fh = ovl_encode_real_fh(ofs, origin, false); 660359f392cSAmir Goldstein if (IS_ERR(fh)) 661359f392cSAmir Goldstein return PTR_ERR(fh); 662359f392cSAmir Goldstein 66391ffe7beSAmir Goldstein err = ovl_get_index_name_fh(fh, name); 66491ffe7beSAmir Goldstein 665359f392cSAmir Goldstein kfree(fh); 666359f392cSAmir Goldstein return err; 66791ffe7beSAmir Goldstein } 668359f392cSAmir Goldstein 66991ffe7beSAmir Goldstein /* Lookup index by file handle for NFS export */ 67091ffe7beSAmir Goldstein struct dentry *ovl_get_index_fh(struct ovl_fs *ofs, struct ovl_fh *fh) 67191ffe7beSAmir Goldstein { 67291ffe7beSAmir Goldstein struct dentry *index; 67391ffe7beSAmir Goldstein struct qstr name; 67491ffe7beSAmir Goldstein int err; 67591ffe7beSAmir Goldstein 67691ffe7beSAmir Goldstein err = ovl_get_index_name_fh(fh, &name); 67791ffe7beSAmir Goldstein if (err) 67891ffe7beSAmir Goldstein return ERR_PTR(err); 67991ffe7beSAmir Goldstein 6806c2d4798SAl Viro index = lookup_positive_unlocked(name.name, ofs->indexdir, name.len); 68191ffe7beSAmir Goldstein kfree(name.name); 68291ffe7beSAmir Goldstein if (IS_ERR(index)) { 68391ffe7beSAmir Goldstein if (PTR_ERR(index) == -ENOENT) 68491ffe7beSAmir Goldstein index = NULL; 68591ffe7beSAmir Goldstein return index; 68691ffe7beSAmir Goldstein } 68791ffe7beSAmir Goldstein 6886c2d4798SAl Viro if (ovl_is_whiteout(index)) 68991ffe7beSAmir Goldstein err = -ESTALE; 69091ffe7beSAmir Goldstein else if (ovl_dentry_weird(index)) 69191ffe7beSAmir Goldstein err = -EIO; 69291ffe7beSAmir Goldstein else 69391ffe7beSAmir Goldstein return index; 69491ffe7beSAmir Goldstein 69591ffe7beSAmir Goldstein dput(index); 69691ffe7beSAmir Goldstein return ERR_PTR(err); 697359f392cSAmir Goldstein } 698359f392cSAmir Goldstein 69906170154SAmir Goldstein struct dentry *ovl_lookup_index(struct ovl_fs *ofs, struct dentry *upper, 70006170154SAmir Goldstein struct dentry *origin, bool verify) 701359f392cSAmir Goldstein { 702359f392cSAmir Goldstein struct dentry *index; 703359f392cSAmir Goldstein struct inode *inode; 704359f392cSAmir Goldstein struct qstr name; 705ad1d615cSAmir Goldstein bool is_dir = d_is_dir(origin); 706359f392cSAmir Goldstein int err; 707359f392cSAmir Goldstein 7081cdb0cb6SPavel Tikhomirov err = ovl_get_index_name(ofs, origin, &name); 709359f392cSAmir Goldstein if (err) 710359f392cSAmir Goldstein return ERR_PTR(err); 711359f392cSAmir Goldstein 7126c2d4798SAl Viro index = lookup_positive_unlocked(name.name, ofs->indexdir, name.len); 713359f392cSAmir Goldstein if (IS_ERR(index)) { 714e0082a0fSAmir Goldstein err = PTR_ERR(index); 7157937a56fSAmir Goldstein if (err == -ENOENT) { 7167937a56fSAmir Goldstein index = NULL; 7177937a56fSAmir Goldstein goto out; 7187937a56fSAmir Goldstein } 7191bd0a3aeSlijiazi pr_warn_ratelimited("failed inode index lookup (ino=%lu, key=%.*s, err=%i);\n" 720359f392cSAmir Goldstein "overlayfs: mount with '-o index=off' to disable inodes index.\n", 721359f392cSAmir Goldstein d_inode(origin)->i_ino, name.len, name.name, 722359f392cSAmir Goldstein err); 723359f392cSAmir Goldstein goto out; 724359f392cSAmir Goldstein } 725359f392cSAmir Goldstein 7260e082555SAmir Goldstein inode = d_inode(index); 7276c2d4798SAl Viro if (ovl_is_whiteout(index) && !verify) { 72806170154SAmir Goldstein /* 72906170154SAmir Goldstein * When index lookup is called with !verify for decoding an 73006170154SAmir Goldstein * overlay file handle, a whiteout index implies that decode 73106170154SAmir Goldstein * should treat file handle as stale and no need to print a 73206170154SAmir Goldstein * warning about it. 73306170154SAmir Goldstein */ 73406170154SAmir Goldstein dput(index); 73506170154SAmir Goldstein index = ERR_PTR(-ESTALE); 73606170154SAmir Goldstein goto out; 7370e082555SAmir Goldstein } else if (ovl_dentry_weird(index) || ovl_is_whiteout(index) || 7386e3e2c43SAl Viro inode_wrong_type(inode, d_inode(origin)->i_mode)) { 7390e082555SAmir Goldstein /* 7400e082555SAmir Goldstein * Index should always be of the same file type as origin 7410e082555SAmir Goldstein * except for the case of a whiteout index. A whiteout 7420e082555SAmir Goldstein * index should only exist if all lower aliases have been 7430e082555SAmir Goldstein * unlinked, which means that finding a lower origin on lookup 7440e082555SAmir Goldstein * whose index is a whiteout should be treated as an error. 7450e082555SAmir Goldstein */ 7461bd0a3aeSlijiazi pr_warn_ratelimited("bad index found (index=%pd2, ftype=%x, origin ftype=%x).\n", 7470e082555SAmir Goldstein index, d_inode(index)->i_mode & S_IFMT, 7480e082555SAmir Goldstein d_inode(origin)->i_mode & S_IFMT); 749359f392cSAmir Goldstein goto fail; 75006170154SAmir Goldstein } else if (is_dir && verify) { 751ad1d615cSAmir Goldstein if (!upper) { 7521bd0a3aeSlijiazi pr_warn_ratelimited("suspected uncovered redirected dir found (origin=%pd2, index=%pd2).\n", 753ad1d615cSAmir Goldstein origin, index); 754ad1d615cSAmir Goldstein goto fail; 755359f392cSAmir Goldstein } 756359f392cSAmir Goldstein 757ad1d615cSAmir Goldstein /* Verify that dir index 'upper' xattr points to upper dir */ 758610afc0bSMiklos Szeredi err = ovl_verify_upper(ofs, index, upper, false); 759ad1d615cSAmir Goldstein if (err) { 760ad1d615cSAmir Goldstein if (err == -ESTALE) { 7611bd0a3aeSlijiazi pr_warn_ratelimited("suspected multiply redirected dir found (upper=%pd2, origin=%pd2, index=%pd2).\n", 762ad1d615cSAmir Goldstein upper, origin, index); 763ad1d615cSAmir Goldstein } 764ad1d615cSAmir Goldstein goto fail; 765ad1d615cSAmir Goldstein } 766ad1d615cSAmir Goldstein } else if (upper && d_inode(upper) != inode) { 767ad1d615cSAmir Goldstein goto out_dput; 768ad1d615cSAmir Goldstein } 769359f392cSAmir Goldstein out: 770359f392cSAmir Goldstein kfree(name.name); 771359f392cSAmir Goldstein return index; 772359f392cSAmir Goldstein 7736eaf0111SAmir Goldstein out_dput: 7746eaf0111SAmir Goldstein dput(index); 7756eaf0111SAmir Goldstein index = NULL; 7766eaf0111SAmir Goldstein goto out; 7776eaf0111SAmir Goldstein 778359f392cSAmir Goldstein fail: 779359f392cSAmir Goldstein dput(index); 780359f392cSAmir Goldstein index = ERR_PTR(-EIO); 781359f392cSAmir Goldstein goto out; 782359f392cSAmir Goldstein } 783359f392cSAmir Goldstein 784359f392cSAmir Goldstein /* 785bbb1e54dSMiklos Szeredi * Returns next layer in stack starting from top. 786bbb1e54dSMiklos Szeredi * Returns -1 if this is the last layer. 787bbb1e54dSMiklos Szeredi */ 788bbb1e54dSMiklos Szeredi int ovl_path_next(int idx, struct dentry *dentry, struct path *path) 789bbb1e54dSMiklos Szeredi { 790bbb1e54dSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 791bbb1e54dSMiklos Szeredi 792bbb1e54dSMiklos Szeredi BUG_ON(idx < 0); 793bbb1e54dSMiklos Szeredi if (idx == 0) { 794bbb1e54dSMiklos Szeredi ovl_path_upper(dentry, path); 795bbb1e54dSMiklos Szeredi if (path->dentry) 796bbb1e54dSMiklos Szeredi return oe->numlower ? 1 : -1; 797bbb1e54dSMiklos Szeredi idx++; 798bbb1e54dSMiklos Szeredi } 799bbb1e54dSMiklos Szeredi BUG_ON(idx > oe->numlower); 800b9343632SChandan Rajendra path->dentry = oe->lowerstack[idx - 1].dentry; 801b9343632SChandan Rajendra path->mnt = oe->lowerstack[idx - 1].layer->mnt; 802bbb1e54dSMiklos Szeredi 803bbb1e54dSMiklos Szeredi return (idx < oe->numlower) ? idx + 1 : -1; 804bbb1e54dSMiklos Szeredi } 805bbb1e54dSMiklos Szeredi 8069678e630SAmir Goldstein /* Fix missing 'origin' xattr */ 807610afc0bSMiklos Szeredi static int ovl_fix_origin(struct ovl_fs *ofs, struct dentry *dentry, 808610afc0bSMiklos Szeredi struct dentry *lower, struct dentry *upper) 8099678e630SAmir Goldstein { 8109678e630SAmir Goldstein int err; 8119678e630SAmir Goldstein 812610afc0bSMiklos Szeredi if (ovl_check_origin_xattr(ofs, upper)) 8139678e630SAmir Goldstein return 0; 8149678e630SAmir Goldstein 8159678e630SAmir Goldstein err = ovl_want_write(dentry); 8169678e630SAmir Goldstein if (err) 8179678e630SAmir Goldstein return err; 8189678e630SAmir Goldstein 819a0c236b1SAmir Goldstein err = ovl_set_origin(ofs, lower, upper); 8209678e630SAmir Goldstein if (!err) 8219678e630SAmir Goldstein err = ovl_set_impure(dentry->d_parent, upper->d_parent); 8229678e630SAmir Goldstein 8239678e630SAmir Goldstein ovl_drop_write(dentry); 8249678e630SAmir Goldstein return err; 8259678e630SAmir Goldstein } 8269678e630SAmir Goldstein 827bbb1e54dSMiklos Szeredi struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry, 828bbb1e54dSMiklos Szeredi unsigned int flags) 829bbb1e54dSMiklos Szeredi { 830bbb1e54dSMiklos Szeredi struct ovl_entry *oe; 831bbb1e54dSMiklos Szeredi const struct cred *old_cred; 8326b2d5fe4SMiklos Szeredi struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 833bbb1e54dSMiklos Szeredi struct ovl_entry *poe = dentry->d_parent->d_fsdata; 834c22205d0SAmir Goldstein struct ovl_entry *roe = dentry->d_sb->s_root->d_fsdata; 8359d3dfea3SVivek Goyal struct ovl_path *stack = NULL, *origin_path = NULL; 836bbb1e54dSMiklos Szeredi struct dentry *upperdir, *upperdentry = NULL; 837ad1d615cSAmir Goldstein struct dentry *origin = NULL; 838359f392cSAmir Goldstein struct dentry *index = NULL; 839bbb1e54dSMiklos Szeredi unsigned int ctr = 0; 840bbb1e54dSMiklos Szeredi struct inode *inode = NULL; 841bbb1e54dSMiklos Szeredi bool upperopaque = false; 84202b69b28SMiklos Szeredi char *upperredirect = NULL; 843bbb1e54dSMiklos Szeredi struct dentry *this; 844bbb1e54dSMiklos Szeredi unsigned int i; 845bbb1e54dSMiklos Szeredi int err; 8466815f479SVivek Goyal bool uppermetacopy = false; 847e28edc46SMiklos Szeredi struct ovl_lookup_data d = { 848146d62e5SAmir Goldstein .sb = dentry->d_sb, 849e28edc46SMiklos Szeredi .name = dentry->d_name, 850e28edc46SMiklos Szeredi .is_dir = false, 851e28edc46SMiklos Szeredi .opaque = false, 852e28edc46SMiklos Szeredi .stop = false, 853452061fdSVivek Goyal .last = ofs->config.redirect_follow ? false : !poe->numlower, 85402b69b28SMiklos Szeredi .redirect = NULL, 8559d3dfea3SVivek Goyal .metacopy = false, 856e28edc46SMiklos Szeredi }; 857bbb1e54dSMiklos Szeredi 8586b2d5fe4SMiklos Szeredi if (dentry->d_name.len > ofs->namelen) 8596b2d5fe4SMiklos Szeredi return ERR_PTR(-ENAMETOOLONG); 8606b2d5fe4SMiklos Szeredi 861bbb1e54dSMiklos Szeredi old_cred = ovl_override_creds(dentry->d_sb); 86209d8b586SMiklos Szeredi upperdir = ovl_dentry_upper(dentry->d_parent); 863bbb1e54dSMiklos Szeredi if (upperdir) { 864*dad7017aSChristian Brauner d.mnt = ovl_upper_mnt(ofs); 8651434a65eSChengguang Xu err = ovl_lookup_layer(upperdir, &d, &upperdentry, true); 866e28edc46SMiklos Szeredi if (err) 867bbb1e54dSMiklos Szeredi goto out; 868bbb1e54dSMiklos Szeredi 869bccece1eSMiklos Szeredi if (upperdentry && upperdentry->d_flags & DCACHE_OP_REAL) { 870e28edc46SMiklos Szeredi dput(upperdentry); 871bbb1e54dSMiklos Szeredi err = -EREMOTE; 872bbb1e54dSMiklos Szeredi goto out; 873bbb1e54dSMiklos Szeredi } 874a9d01957SAmir Goldstein if (upperdentry && !d.is_dir) { 875f7d3dacaSAmir Goldstein /* 876f7d3dacaSAmir Goldstein * Lookup copy up origin by decoding origin file handle. 877f7d3dacaSAmir Goldstein * We may get a disconnected dentry, which is fine, 878f7d3dacaSAmir Goldstein * because we only need to hold the origin inode in 879f7d3dacaSAmir Goldstein * cache and use its inode number. We may even get a 880f7d3dacaSAmir Goldstein * connected dentry, that is not under any of the lower 881f7d3dacaSAmir Goldstein * layers root. That is also fine for using it's inode 882f7d3dacaSAmir Goldstein * number - it's the same as if we held a reference 883f7d3dacaSAmir Goldstein * to a dentry in lower layer that was moved under us. 884f7d3dacaSAmir Goldstein */ 885d78a0dcfSyoungjun err = ovl_check_origin(ofs, upperdentry, &origin_path); 886a9d01957SAmir Goldstein if (err) 8875455f92bSVivek Goyal goto out_put_upper; 8889d3dfea3SVivek Goyal 8899d3dfea3SVivek Goyal if (d.metacopy) 8906815f479SVivek Goyal uppermetacopy = true; 891a9d01957SAmir Goldstein } 89202b69b28SMiklos Szeredi 89302b69b28SMiklos Szeredi if (d.redirect) { 8940ce5cdc9SDan Carpenter err = -ENOMEM; 89502b69b28SMiklos Szeredi upperredirect = kstrdup(d.redirect, GFP_KERNEL); 89602b69b28SMiklos Szeredi if (!upperredirect) 89702b69b28SMiklos Szeredi goto out_put_upper; 89802b69b28SMiklos Szeredi if (d.redirect[0] == '/') 899c22205d0SAmir Goldstein poe = roe; 90002b69b28SMiklos Szeredi } 901e28edc46SMiklos Szeredi upperopaque = d.opaque; 902bbb1e54dSMiklos Szeredi } 903bbb1e54dSMiklos Szeredi 904e28edc46SMiklos Szeredi if (!d.stop && poe->numlower) { 905bbb1e54dSMiklos Szeredi err = -ENOMEM; 90694375f9dSAmir Goldstein stack = kcalloc(ofs->numlayer - 1, sizeof(struct ovl_path), 9070ee931c4SMichal Hocko GFP_KERNEL); 908bbb1e54dSMiklos Szeredi if (!stack) 909bbb1e54dSMiklos Szeredi goto out_put_upper; 910bbb1e54dSMiklos Szeredi } 911bbb1e54dSMiklos Szeredi 912e28edc46SMiklos Szeredi for (i = 0; !d.stop && i < poe->numlower; i++) { 913b9343632SChandan Rajendra struct ovl_path lower = poe->lowerstack[i]; 914bbb1e54dSMiklos Szeredi 915452061fdSVivek Goyal if (!ofs->config.redirect_follow) 916e28edc46SMiklos Szeredi d.last = i == poe->numlower - 1; 917452061fdSVivek Goyal else 918452061fdSVivek Goyal d.last = lower.layer->idx == roe->numlower; 919452061fdSVivek Goyal 920*dad7017aSChristian Brauner d.mnt = lower.layer->mnt; 9211434a65eSChengguang Xu err = ovl_lookup_layer(lower.dentry, &d, &this, false); 922e28edc46SMiklos Szeredi if (err) 923bbb1e54dSMiklos Szeredi goto out_put; 9246b2d5fe4SMiklos Szeredi 925bbb1e54dSMiklos Szeredi if (!this) 926bbb1e54dSMiklos Szeredi continue; 927bbb1e54dSMiklos Szeredi 9286815f479SVivek Goyal if ((uppermetacopy || d.metacopy) && !ofs->config.metacopy) { 929eaab1d45SMickaël Salaün dput(this); 9306815f479SVivek Goyal err = -EPERM; 9316815f479SVivek Goyal pr_warn_ratelimited("refusing to follow metacopy origin for (%pd2)\n", dentry); 9326815f479SVivek Goyal goto out_put; 9336815f479SVivek Goyal } 9346815f479SVivek Goyal 9356815f479SVivek Goyal /* 9369678e630SAmir Goldstein * If no origin fh is stored in upper of a merge dir, store fh 9379678e630SAmir Goldstein * of lower dir and set upper parent "impure". 9389678e630SAmir Goldstein */ 9399d3dfea3SVivek Goyal if (upperdentry && !ctr && !ofs->noxattr && d.is_dir) { 940610afc0bSMiklos Szeredi err = ovl_fix_origin(ofs, dentry, this, upperdentry); 9419678e630SAmir Goldstein if (err) { 9429678e630SAmir Goldstein dput(this); 9439678e630SAmir Goldstein goto out_put; 9449678e630SAmir Goldstein } 9459678e630SAmir Goldstein } 9469678e630SAmir Goldstein 94737b12916SAmir Goldstein /* 94837b12916SAmir Goldstein * When "verify_lower" feature is enabled, do not merge with a 949ad1d615cSAmir Goldstein * lower dir that does not match a stored origin xattr. In any 950ad1d615cSAmir Goldstein * case, only verified origin is used for index lookup. 9519d3dfea3SVivek Goyal * 9529d3dfea3SVivek Goyal * For non-dir dentry, if index=on, then ensure origin 9539d3dfea3SVivek Goyal * matches the dentry found using path based lookup, 9549d3dfea3SVivek Goyal * otherwise error out. 95537b12916SAmir Goldstein */ 9569d3dfea3SVivek Goyal if (upperdentry && !ctr && 9579d3dfea3SVivek Goyal ((d.is_dir && ovl_verify_lower(dentry->d_sb)) || 9589d3dfea3SVivek Goyal (!d.is_dir && ofs->config.index && origin_path))) { 959610afc0bSMiklos Szeredi err = ovl_verify_origin(ofs, upperdentry, this, false); 96037b12916SAmir Goldstein if (err) { 96137b12916SAmir Goldstein dput(this); 9629d3dfea3SVivek Goyal if (d.is_dir) 96337b12916SAmir Goldstein break; 9649d3dfea3SVivek Goyal goto out_put; 9659d3dfea3SVivek Goyal } 9669d3dfea3SVivek Goyal origin = this; 96737b12916SAmir Goldstein } 968ad1d615cSAmir Goldstein 96921d8d66aSVivek Goyal if (d.metacopy && ctr) { 97021d8d66aSVivek Goyal /* 97121d8d66aSVivek Goyal * Do not store intermediate metacopy dentries in 97221d8d66aSVivek Goyal * lower chain, except top most lower metacopy dentry. 97321d8d66aSVivek Goyal * Continue the loop so that if there is an absolute 97421d8d66aSVivek Goyal * redirect on this dentry, poe can be reset to roe. 97521d8d66aSVivek Goyal */ 97621d8d66aSVivek Goyal dput(this); 97721d8d66aSVivek Goyal this = NULL; 97821d8d66aSVivek Goyal } else { 979bbb1e54dSMiklos Szeredi stack[ctr].dentry = this; 980b9343632SChandan Rajendra stack[ctr].layer = lower.layer; 981bbb1e54dSMiklos Szeredi ctr++; 98221d8d66aSVivek Goyal } 98302b69b28SMiklos Szeredi 984438c84c2SMiklos Szeredi /* 985438c84c2SMiklos Szeredi * Following redirects can have security consequences: it's like 986438c84c2SMiklos Szeredi * a symlink into the lower layer without the permission checks. 987438c84c2SMiklos Szeredi * This is only a problem if the upper layer is untrusted (e.g 988438c84c2SMiklos Szeredi * comes from an USB drive). This can allow a non-readable file 989438c84c2SMiklos Szeredi * or directory to become readable. 990438c84c2SMiklos Szeredi * 991438c84c2SMiklos Szeredi * Only following redirects when redirects are enabled disables 992438c84c2SMiklos Szeredi * this attack vector when not necessary. 993438c84c2SMiklos Szeredi */ 994438c84c2SMiklos Szeredi err = -EPERM; 995438c84c2SMiklos Szeredi if (d.redirect && !ofs->config.redirect_follow) { 9961bd0a3aeSlijiazi pr_warn_ratelimited("refusing to follow redirect for (%pd2)\n", 997f8167817SAmir Goldstein dentry); 998438c84c2SMiklos Szeredi goto out_put; 999438c84c2SMiklos Szeredi } 1000438c84c2SMiklos Szeredi 1001d1fe96c0SVivek Goyal if (d.stop) 1002d1fe96c0SVivek Goyal break; 1003d1fe96c0SVivek Goyal 1004c22205d0SAmir Goldstein if (d.redirect && d.redirect[0] == '/' && poe != roe) { 1005c22205d0SAmir Goldstein poe = roe; 100602b69b28SMiklos Szeredi /* Find the current layer on the root dentry */ 1007d583ed7dSAmir Goldstein i = lower.layer->idx - 1; 100802b69b28SMiklos Szeredi } 1009bbb1e54dSMiklos Szeredi } 1010bbb1e54dSMiklos Szeredi 10119d3dfea3SVivek Goyal /* 10126815f479SVivek Goyal * For regular non-metacopy upper dentries, there is no lower 10136815f479SVivek Goyal * path based lookup, hence ctr will be zero. If a dentry is found 10146815f479SVivek Goyal * using ORIGIN xattr on upper, install it in stack. 10156815f479SVivek Goyal * 10166815f479SVivek Goyal * For metacopy dentry, path based lookup will find lower dentries. 10176815f479SVivek Goyal * Just make sure a corresponding data dentry has been found. 10189d3dfea3SVivek Goyal */ 10196815f479SVivek Goyal if (d.metacopy || (uppermetacopy && !ctr)) { 10200a8d0b64SKevin Locke pr_warn_ratelimited("metacopy with no lower data found - abort lookup (%pd2)\n", 10210a8d0b64SKevin Locke dentry); 10229d3dfea3SVivek Goyal err = -EIO; 10239d3dfea3SVivek Goyal goto out_put; 10249d3dfea3SVivek Goyal } else if (!d.is_dir && upperdentry && !ctr && origin_path) { 10259d3dfea3SVivek Goyal if (WARN_ON(stack != NULL)) { 10269d3dfea3SVivek Goyal err = -EIO; 10279d3dfea3SVivek Goyal goto out_put; 10289d3dfea3SVivek Goyal } 10299d3dfea3SVivek Goyal stack = origin_path; 10309d3dfea3SVivek Goyal ctr = 1; 103159fb2013SVivek Goyal origin = origin_path->dentry; 10329d3dfea3SVivek Goyal origin_path = NULL; 10339d3dfea3SVivek Goyal } 10349d3dfea3SVivek Goyal 1035ad1d615cSAmir Goldstein /* 103659fb2013SVivek Goyal * Always lookup index if there is no-upperdentry. 10379d3dfea3SVivek Goyal * 103859fb2013SVivek Goyal * For the case of upperdentry, we have set origin by now if it 103959fb2013SVivek Goyal * needed to be set. There are basically three cases. 10409d3dfea3SVivek Goyal * 104159fb2013SVivek Goyal * For directories, lookup index by lower inode and verify it matches 104259fb2013SVivek Goyal * upper inode. We only trust dir index if we verified that lower dir 104359fb2013SVivek Goyal * matches origin, otherwise dir index entries may be inconsistent 104459fb2013SVivek Goyal * and we ignore them. 104559fb2013SVivek Goyal * 104659fb2013SVivek Goyal * For regular upper, we already set origin if upper had ORIGIN 104759fb2013SVivek Goyal * xattr. There is no verification though as there is no path 104859fb2013SVivek Goyal * based dentry lookup in lower in this case. 104959fb2013SVivek Goyal * 105059fb2013SVivek Goyal * For metacopy upper, we set a verified origin already if index 105159fb2013SVivek Goyal * is enabled and if upper had an ORIGIN xattr. 105259fb2013SVivek Goyal * 1053ad1d615cSAmir Goldstein */ 105459fb2013SVivek Goyal if (!upperdentry && ctr) 1055ad1d615cSAmir Goldstein origin = stack[0].dentry; 1056359f392cSAmir Goldstein 1057ad1d615cSAmir Goldstein if (origin && ovl_indexdir(dentry->d_sb) && 1058ad1d615cSAmir Goldstein (!d.is_dir || ovl_index_all(dentry->d_sb))) { 105906170154SAmir Goldstein index = ovl_lookup_index(ofs, upperdentry, origin, true); 1060359f392cSAmir Goldstein if (IS_ERR(index)) { 1061359f392cSAmir Goldstein err = PTR_ERR(index); 1062359f392cSAmir Goldstein index = NULL; 1063359f392cSAmir Goldstein goto out_put; 1064359f392cSAmir Goldstein } 1065359f392cSAmir Goldstein } 1066359f392cSAmir Goldstein 1067bbb1e54dSMiklos Szeredi oe = ovl_alloc_entry(ctr); 1068bbb1e54dSMiklos Szeredi err = -ENOMEM; 1069bbb1e54dSMiklos Szeredi if (!oe) 1070bbb1e54dSMiklos Szeredi goto out_put; 1071bbb1e54dSMiklos Szeredi 1072b9343632SChandan Rajendra memcpy(oe->lowerstack, stack, sizeof(struct ovl_path) * ctr); 1073e6d2ebddSMiklos Szeredi dentry->d_fsdata = oe; 1074e6d2ebddSMiklos Szeredi 1075c62520a8SAmir Goldstein if (upperopaque) 1076c62520a8SAmir Goldstein ovl_dentry_set_opaque(dentry); 1077c62520a8SAmir Goldstein 107855acc661SMiklos Szeredi if (upperdentry) 107955acc661SMiklos Szeredi ovl_dentry_set_upper_alias(dentry); 10800a2d0d3fSVivek Goyal else if (index) { 1081*dad7017aSChristian Brauner struct path upperpath = { 1082*dad7017aSChristian Brauner .dentry = upperdentry = dget(index), 1083*dad7017aSChristian Brauner .mnt = ovl_upper_mnt(ofs), 1084*dad7017aSChristian Brauner }; 1085*dad7017aSChristian Brauner 1086*dad7017aSChristian Brauner upperredirect = ovl_get_redirect_xattr(ofs, &upperpath, 0); 10870a2d0d3fSVivek Goyal if (IS_ERR(upperredirect)) { 10880a2d0d3fSVivek Goyal err = PTR_ERR(upperredirect); 10890a2d0d3fSVivek Goyal upperredirect = NULL; 10900a2d0d3fSVivek Goyal goto out_free_oe; 10910a2d0d3fSVivek Goyal } 1092*dad7017aSChristian Brauner err = ovl_check_metacopy_xattr(ofs, &upperpath); 10934518dfcfSAmir Goldstein if (err < 0) 10944518dfcfSAmir Goldstein goto out_free_oe; 10954518dfcfSAmir Goldstein uppermetacopy = err; 10960a2d0d3fSVivek Goyal } 1097359f392cSAmir Goldstein 1098e6d2ebddSMiklos Szeredi if (upperdentry || ctr) { 1099ac6a52ebSVivek Goyal struct ovl_inode_params oip = { 1100ac6a52ebSVivek Goyal .upperdentry = upperdentry, 1101ac6a52ebSVivek Goyal .lowerpath = stack, 1102ac6a52ebSVivek Goyal .index = index, 1103ac6a52ebSVivek Goyal .numlower = ctr, 11049cec54c8SVivek Goyal .redirect = upperredirect, 11052664bd08SVivek Goyal .lowerdata = (ctr > 1 && !d.is_dir) ? 11062664bd08SVivek Goyal stack[ctr - 1].dentry : NULL, 1107ac6a52ebSVivek Goyal }; 1108ac6a52ebSVivek Goyal 1109ac6a52ebSVivek Goyal inode = ovl_get_inode(dentry->d_sb, &oip); 1110b9ac5c27SMiklos Szeredi err = PTR_ERR(inode); 1111b9ac5c27SMiklos Szeredi if (IS_ERR(inode)) 1112e6d2ebddSMiklos Szeredi goto out_free_oe; 111328166ab3SVivek Goyal if (upperdentry && !uppermetacopy) 111428166ab3SVivek Goyal ovl_set_flag(OVL_UPPERDATA, inode); 1115e6d2ebddSMiklos Szeredi } 1116e6d2ebddSMiklos Szeredi 1117f4288844SMiklos Szeredi ovl_dentry_update_reval(dentry, upperdentry, 1118f4288844SMiklos Szeredi DCACHE_OP_REVALIDATE | DCACHE_OP_WEAK_REVALIDATE); 1119f4288844SMiklos Szeredi 1120e6d2ebddSMiklos Szeredi revert_creds(old_cred); 11219d3dfea3SVivek Goyal if (origin_path) { 11229d3dfea3SVivek Goyal dput(origin_path->dentry); 11239d3dfea3SVivek Goyal kfree(origin_path); 11249d3dfea3SVivek Goyal } 1125359f392cSAmir Goldstein dput(index); 1126bbb1e54dSMiklos Szeredi kfree(stack); 112702b69b28SMiklos Szeredi kfree(d.redirect); 1128829c28beSAmir Goldstein return d_splice_alias(inode, dentry); 1129bbb1e54dSMiklos Szeredi 1130bbb1e54dSMiklos Szeredi out_free_oe: 1131e6d2ebddSMiklos Szeredi dentry->d_fsdata = NULL; 1132bbb1e54dSMiklos Szeredi kfree(oe); 1133bbb1e54dSMiklos Szeredi out_put: 1134359f392cSAmir Goldstein dput(index); 1135bbb1e54dSMiklos Szeredi for (i = 0; i < ctr; i++) 1136bbb1e54dSMiklos Szeredi dput(stack[i].dentry); 1137bbb1e54dSMiklos Szeredi kfree(stack); 1138bbb1e54dSMiklos Szeredi out_put_upper: 11399d3dfea3SVivek Goyal if (origin_path) { 11409d3dfea3SVivek Goyal dput(origin_path->dentry); 11419d3dfea3SVivek Goyal kfree(origin_path); 11429d3dfea3SVivek Goyal } 1143bbb1e54dSMiklos Szeredi dput(upperdentry); 114402b69b28SMiklos Szeredi kfree(upperredirect); 1145bbb1e54dSMiklos Szeredi out: 114602b69b28SMiklos Szeredi kfree(d.redirect); 1147bbb1e54dSMiklos Szeredi revert_creds(old_cred); 1148bbb1e54dSMiklos Szeredi return ERR_PTR(err); 1149bbb1e54dSMiklos Szeredi } 1150bbb1e54dSMiklos Szeredi 1151bbb1e54dSMiklos Szeredi bool ovl_lower_positive(struct dentry *dentry) 1152bbb1e54dSMiklos Szeredi { 1153bbb1e54dSMiklos Szeredi struct ovl_entry *poe = dentry->d_parent->d_fsdata; 1154bbb1e54dSMiklos Szeredi const struct qstr *name = &dentry->d_name; 11556d0a8a90SAmir Goldstein const struct cred *old_cred; 1156bbb1e54dSMiklos Szeredi unsigned int i; 1157bbb1e54dSMiklos Szeredi bool positive = false; 1158bbb1e54dSMiklos Szeredi bool done = false; 1159bbb1e54dSMiklos Szeredi 1160bbb1e54dSMiklos Szeredi /* 1161bbb1e54dSMiklos Szeredi * If dentry is negative, then lower is positive iff this is a 1162bbb1e54dSMiklos Szeredi * whiteout. 1163bbb1e54dSMiklos Szeredi */ 1164bbb1e54dSMiklos Szeredi if (!dentry->d_inode) 1165c62520a8SAmir Goldstein return ovl_dentry_is_opaque(dentry); 1166bbb1e54dSMiklos Szeredi 1167bbb1e54dSMiklos Szeredi /* Negative upper -> positive lower */ 116809d8b586SMiklos Szeredi if (!ovl_dentry_upper(dentry)) 1169bbb1e54dSMiklos Szeredi return true; 1170bbb1e54dSMiklos Szeredi 11716d0a8a90SAmir Goldstein old_cred = ovl_override_creds(dentry->d_sb); 1172bbb1e54dSMiklos Szeredi /* Positive upper -> have to look up lower to see whether it exists */ 1173bbb1e54dSMiklos Szeredi for (i = 0; !done && !positive && i < poe->numlower; i++) { 1174bbb1e54dSMiklos Szeredi struct dentry *this; 1175bbb1e54dSMiklos Szeredi struct dentry *lowerdir = poe->lowerstack[i].dentry; 1176bbb1e54dSMiklos Szeredi 11776c2d4798SAl Viro this = lookup_positive_unlocked(name->name, lowerdir, 1178bbb1e54dSMiklos Szeredi name->len); 1179bbb1e54dSMiklos Szeredi if (IS_ERR(this)) { 1180bbb1e54dSMiklos Szeredi switch (PTR_ERR(this)) { 1181bbb1e54dSMiklos Szeredi case -ENOENT: 1182bbb1e54dSMiklos Szeredi case -ENAMETOOLONG: 1183bbb1e54dSMiklos Szeredi break; 1184bbb1e54dSMiklos Szeredi 1185bbb1e54dSMiklos Szeredi default: 1186bbb1e54dSMiklos Szeredi /* 1187bbb1e54dSMiklos Szeredi * Assume something is there, we just couldn't 1188bbb1e54dSMiklos Szeredi * access it. 1189bbb1e54dSMiklos Szeredi */ 1190bbb1e54dSMiklos Szeredi positive = true; 1191bbb1e54dSMiklos Szeredi break; 1192bbb1e54dSMiklos Szeredi } 1193bbb1e54dSMiklos Szeredi } else { 1194bbb1e54dSMiklos Szeredi positive = !ovl_is_whiteout(this); 1195bbb1e54dSMiklos Szeredi done = true; 1196bbb1e54dSMiklos Szeredi dput(this); 1197bbb1e54dSMiklos Szeredi } 1198bbb1e54dSMiklos Szeredi } 11996d0a8a90SAmir Goldstein revert_creds(old_cred); 1200bbb1e54dSMiklos Szeredi 1201bbb1e54dSMiklos Szeredi return positive; 1202bbb1e54dSMiklos Szeredi } 1203