1bbb1e54dSMiklos Szeredi /* 2bbb1e54dSMiklos Szeredi * Copyright (C) 2011 Novell Inc. 3bbb1e54dSMiklos Szeredi * Copyright (C) 2016 Red Hat, Inc. 4bbb1e54dSMiklos Szeredi * 5bbb1e54dSMiklos Szeredi * This program is free software; you can redistribute it and/or modify it 6bbb1e54dSMiklos Szeredi * under the terms of the GNU General Public License version 2 as published by 7bbb1e54dSMiklos Szeredi * the Free Software Foundation. 8bbb1e54dSMiklos Szeredi */ 9bbb1e54dSMiklos Szeredi 10bbb1e54dSMiklos Szeredi #include <linux/fs.h> 115b825c3aSIngo Molnar #include <linux/cred.h> 129ee60ce2SAmir Goldstein #include <linux/ctype.h> 13bbb1e54dSMiklos Szeredi #include <linux/namei.h> 14bbb1e54dSMiklos Szeredi #include <linux/xattr.h> 1502b69b28SMiklos Szeredi #include <linux/ratelimit.h> 16a9d01957SAmir Goldstein #include <linux/mount.h> 17a9d01957SAmir Goldstein #include <linux/exportfs.h> 18bbb1e54dSMiklos Szeredi #include "overlayfs.h" 19bbb1e54dSMiklos Szeredi 20e28edc46SMiklos Szeredi struct ovl_lookup_data { 21146d62e5SAmir Goldstein struct super_block *sb; 22e28edc46SMiklos Szeredi struct qstr name; 23e28edc46SMiklos Szeredi bool is_dir; 24e28edc46SMiklos Szeredi bool opaque; 25e28edc46SMiklos Szeredi bool stop; 26e28edc46SMiklos Szeredi bool last; 2702b69b28SMiklos Szeredi char *redirect; 289d3dfea3SVivek Goyal bool metacopy; 29e28edc46SMiklos Szeredi }; 30bbb1e54dSMiklos Szeredi 3102b69b28SMiklos Szeredi static int ovl_check_redirect(struct dentry *dentry, struct ovl_lookup_data *d, 3202b69b28SMiklos Szeredi size_t prelen, const char *post) 3302b69b28SMiklos Szeredi { 3402b69b28SMiklos Szeredi int res; 350a2d0d3fSVivek Goyal char *buf; 3602b69b28SMiklos Szeredi 370a2d0d3fSVivek Goyal buf = ovl_get_redirect_xattr(dentry, prelen + strlen(post)); 380a2d0d3fSVivek Goyal if (IS_ERR_OR_NULL(buf)) 390a2d0d3fSVivek Goyal return PTR_ERR(buf); 4002b69b28SMiklos Szeredi 4102b69b28SMiklos Szeredi if (buf[0] == '/') { 423ec9b3faSAmir Goldstein /* 433ec9b3faSAmir Goldstein * One of the ancestor path elements in an absolute path 443ec9b3faSAmir Goldstein * lookup in ovl_lookup_layer() could have been opaque and 453ec9b3faSAmir Goldstein * that will stop further lookup in lower layers (d->stop=true) 463ec9b3faSAmir Goldstein * But we have found an absolute redirect in decendant path 473ec9b3faSAmir Goldstein * element and that should force continue lookup in lower 483ec9b3faSAmir Goldstein * layers (reset d->stop). 493ec9b3faSAmir Goldstein */ 503ec9b3faSAmir Goldstein d->stop = false; 5102b69b28SMiklos Szeredi } else { 520a2d0d3fSVivek Goyal res = strlen(buf) + 1; 5302b69b28SMiklos Szeredi memmove(buf + prelen, buf, res); 5402b69b28SMiklos Szeredi memcpy(buf, d->name.name, prelen); 5502b69b28SMiklos Szeredi } 5602b69b28SMiklos Szeredi 5702b69b28SMiklos Szeredi strcat(buf, post); 5802b69b28SMiklos Szeredi kfree(d->redirect); 5902b69b28SMiklos Szeredi d->redirect = buf; 6002b69b28SMiklos Szeredi d->name.name = d->redirect; 6102b69b28SMiklos Szeredi d->name.len = strlen(d->redirect); 6202b69b28SMiklos Szeredi 6302b69b28SMiklos Szeredi return 0; 6402b69b28SMiklos Szeredi } 6502b69b28SMiklos Szeredi 66a9d01957SAmir Goldstein static int ovl_acceptable(void *ctx, struct dentry *dentry) 67a9d01957SAmir Goldstein { 68e8f9e5b7SAmir Goldstein /* 69e8f9e5b7SAmir Goldstein * A non-dir origin may be disconnected, which is fine, because 70e8f9e5b7SAmir Goldstein * we only need it for its unique inode number. 71e8f9e5b7SAmir Goldstein */ 72e8f9e5b7SAmir Goldstein if (!d_is_dir(dentry)) 73a9d01957SAmir Goldstein return 1; 74e8f9e5b7SAmir Goldstein 75e8f9e5b7SAmir Goldstein /* Don't decode a deleted empty directory */ 76e8f9e5b7SAmir Goldstein if (d_unhashed(dentry)) 77e8f9e5b7SAmir Goldstein return 0; 78e8f9e5b7SAmir Goldstein 79e8f9e5b7SAmir Goldstein /* Check if directory belongs to the layer we are decoding from */ 80e8f9e5b7SAmir Goldstein return is_subdir(dentry, ((struct vfsmount *)ctx)->mnt_root); 81a9d01957SAmir Goldstein } 82a9d01957SAmir Goldstein 832e1a5328SAmir Goldstein /* 842e1a5328SAmir Goldstein * Check validity of an overlay file handle buffer. 852e1a5328SAmir Goldstein * 862e1a5328SAmir Goldstein * Return 0 for a valid file handle. 872e1a5328SAmir Goldstein * Return -ENODATA for "origin unknown". 882e1a5328SAmir Goldstein * Return <0 for an invalid file handle. 892e1a5328SAmir Goldstein */ 908556a420SAmir Goldstein int ovl_check_fh_len(struct ovl_fh *fh, int fh_len) 912e1a5328SAmir Goldstein { 922e1a5328SAmir Goldstein if (fh_len < sizeof(struct ovl_fh) || fh_len < fh->len) 932e1a5328SAmir Goldstein return -EINVAL; 942e1a5328SAmir Goldstein 952e1a5328SAmir Goldstein if (fh->magic != OVL_FH_MAGIC) 962e1a5328SAmir Goldstein return -EINVAL; 972e1a5328SAmir Goldstein 982e1a5328SAmir Goldstein /* Treat larger version and unknown flags as "origin unknown" */ 992e1a5328SAmir Goldstein if (fh->version > OVL_FH_VERSION || fh->flags & ~OVL_FH_FLAG_ALL) 1002e1a5328SAmir Goldstein return -ENODATA; 1012e1a5328SAmir Goldstein 1022e1a5328SAmir Goldstein /* Treat endianness mismatch as "origin unknown" */ 1032e1a5328SAmir Goldstein if (!(fh->flags & OVL_FH_FLAG_ANY_ENDIAN) && 1042e1a5328SAmir Goldstein (fh->flags & OVL_FH_FLAG_BIG_ENDIAN) != OVL_FH_FLAG_CPU_ENDIAN) 1052e1a5328SAmir Goldstein return -ENODATA; 1062e1a5328SAmir Goldstein 1072e1a5328SAmir Goldstein return 0; 1082e1a5328SAmir Goldstein } 1092e1a5328SAmir Goldstein 11005122443SAmir Goldstein static struct ovl_fh *ovl_get_fh(struct dentry *dentry, const char *name) 111a9d01957SAmir Goldstein { 1122e1a5328SAmir Goldstein int res, err; 113a9d01957SAmir Goldstein struct ovl_fh *fh = NULL; 114a9d01957SAmir Goldstein 11505122443SAmir Goldstein res = vfs_getxattr(dentry, name, 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 1250ee931c4SMichal Hocko fh = kzalloc(res, GFP_KERNEL); 126a9d01957SAmir Goldstein if (!fh) 127a9d01957SAmir Goldstein return ERR_PTR(-ENOMEM); 128a9d01957SAmir Goldstein 12905122443SAmir Goldstein res = vfs_getxattr(dentry, name, fh, res); 130a9d01957SAmir Goldstein if (res < 0) 131a9d01957SAmir Goldstein goto fail; 132a9d01957SAmir Goldstein 1332e1a5328SAmir Goldstein err = ovl_check_fh_len(fh, 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: 1478b88a2e6SAmir Goldstein pr_warn_ratelimited("overlayfs: failed to get origin (%i)\n", res); 1488b88a2e6SAmir Goldstein goto out; 1498b88a2e6SAmir Goldstein invalid: 1508b88a2e6SAmir Goldstein pr_warn_ratelimited("overlayfs: invalid origin (%*phN)\n", res, fh); 1518b88a2e6SAmir Goldstein goto out; 1528b88a2e6SAmir Goldstein } 1538b88a2e6SAmir Goldstein 1548a22efa1SAmir Goldstein struct dentry *ovl_decode_real_fh(struct ovl_fh *fh, struct vfsmount *mnt, 1558a22efa1SAmir Goldstein bool connected) 1568b88a2e6SAmir Goldstein { 157e8f9e5b7SAmir Goldstein struct dentry *real; 1588b88a2e6SAmir Goldstein int bytes; 1598b88a2e6SAmir Goldstein 160a9d01957SAmir Goldstein /* 161a9d01957SAmir Goldstein * Make sure that the stored uuid matches the uuid of the lower 162a9d01957SAmir Goldstein * layer where file handle will be decoded. 163a9d01957SAmir Goldstein */ 16485787090SChristoph Hellwig if (!uuid_equal(&fh->uuid, &mnt->mnt_sb->s_uuid)) 1652e1a5328SAmir Goldstein return NULL; 166a9d01957SAmir Goldstein 1678b88a2e6SAmir Goldstein bytes = (fh->len - offsetof(struct ovl_fh, fid)); 168e8f9e5b7SAmir Goldstein real = exportfs_decode_fh(mnt, (struct fid *)fh->fid, 169a9d01957SAmir Goldstein bytes >> 2, (int)fh->type, 1708a22efa1SAmir Goldstein connected ? ovl_acceptable : NULL, mnt); 171e8f9e5b7SAmir Goldstein if (IS_ERR(real)) { 172e8f9e5b7SAmir Goldstein /* 173e8f9e5b7SAmir Goldstein * Treat stale file handle to lower file as "origin unknown". 174e8f9e5b7SAmir Goldstein * upper file handle could become stale when upper file is 175e8f9e5b7SAmir Goldstein * unlinked and this information is needed to handle stale 176e8f9e5b7SAmir Goldstein * index entries correctly. 177e8f9e5b7SAmir Goldstein */ 178e8f9e5b7SAmir Goldstein if (real == ERR_PTR(-ESTALE) && 179e8f9e5b7SAmir Goldstein !(fh->flags & OVL_FH_FLAG_PATH_UPPER)) 180e8f9e5b7SAmir Goldstein real = NULL; 181e8f9e5b7SAmir Goldstein return real; 182a9d01957SAmir Goldstein } 183a9d01957SAmir Goldstein 184e8f9e5b7SAmir Goldstein if (ovl_dentry_weird(real)) { 185e8f9e5b7SAmir Goldstein dput(real); 1862e1a5328SAmir Goldstein return NULL; 1872e1a5328SAmir Goldstein } 1882e1a5328SAmir Goldstein 189e8f9e5b7SAmir Goldstein return real; 190a9d01957SAmir Goldstein } 191a9d01957SAmir Goldstein 192ee1d6d37SAmir Goldstein static bool ovl_is_opaquedir(struct dentry *dentry) 193ee1d6d37SAmir Goldstein { 194ee1d6d37SAmir Goldstein return ovl_check_dir_xattr(dentry, OVL_XATTR_OPAQUE); 195ee1d6d37SAmir Goldstein } 196ee1d6d37SAmir Goldstein 197e28edc46SMiklos Szeredi static int ovl_lookup_single(struct dentry *base, struct ovl_lookup_data *d, 198e28edc46SMiklos Szeredi const char *name, unsigned int namelen, 19902b69b28SMiklos Szeredi size_t prelen, const char *post, 200e28edc46SMiklos Szeredi struct dentry **ret) 201e28edc46SMiklos Szeredi { 202e28edc46SMiklos Szeredi struct dentry *this; 203e28edc46SMiklos Szeredi int err; 204102b0d11SVivek Goyal bool last_element = !post[0]; 205e28edc46SMiklos Szeredi 206e28edc46SMiklos Szeredi this = lookup_one_len_unlocked(name, base, namelen); 207e28edc46SMiklos Szeredi if (IS_ERR(this)) { 208e28edc46SMiklos Szeredi err = PTR_ERR(this); 209e28edc46SMiklos Szeredi this = NULL; 210e28edc46SMiklos Szeredi if (err == -ENOENT || err == -ENAMETOOLONG) 211e28edc46SMiklos Szeredi goto out; 212e28edc46SMiklos Szeredi goto out_err; 213e28edc46SMiklos Szeredi } 214e28edc46SMiklos Szeredi if (!this->d_inode) 215e28edc46SMiklos Szeredi goto put_and_out; 216e28edc46SMiklos Szeredi 217e28edc46SMiklos Szeredi if (ovl_dentry_weird(this)) { 218e28edc46SMiklos Szeredi /* Don't support traversing automounts and other weirdness */ 219e28edc46SMiklos Szeredi err = -EREMOTE; 220e28edc46SMiklos Szeredi goto out_err; 221e28edc46SMiklos Szeredi } 222e28edc46SMiklos Szeredi if (ovl_is_whiteout(this)) { 223e28edc46SMiklos Szeredi d->stop = d->opaque = true; 224e28edc46SMiklos Szeredi goto put_and_out; 225e28edc46SMiklos Szeredi } 2263a291774SMiklos Szeredi /* 2279d3dfea3SVivek Goyal * This dentry should be a regular file if previous layer lookup 2289d3dfea3SVivek Goyal * found a metacopy dentry. 2293a291774SMiklos Szeredi */ 2309d3dfea3SVivek Goyal if (last_element && d->metacopy && !d_is_reg(this)) { 2319d3dfea3SVivek Goyal d->stop = true; 2329d3dfea3SVivek Goyal goto put_and_out; 2339d3dfea3SVivek Goyal } 2349d3dfea3SVivek Goyal if (!d_can_lookup(this)) { 2359d3dfea3SVivek Goyal if (d->is_dir || !last_element) { 2369d3dfea3SVivek Goyal d->stop = true; 2379d3dfea3SVivek Goyal goto put_and_out; 2389d3dfea3SVivek Goyal } 2399d3dfea3SVivek Goyal err = ovl_check_metacopy_xattr(this); 2409d3dfea3SVivek Goyal if (err < 0) 2419d3dfea3SVivek Goyal goto out_err; 2429d3dfea3SVivek Goyal 2439d3dfea3SVivek Goyal d->metacopy = err; 2449d3dfea3SVivek Goyal d->stop = !d->metacopy; 245b8a8824cSVivek Goyal if (!d->metacopy || d->last) 246e28edc46SMiklos Szeredi goto out; 2470618a816SVivek Goyal } else { 248146d62e5SAmir Goldstein if (ovl_lookup_trap_inode(d->sb, this)) { 249146d62e5SAmir Goldstein /* Caught in a trap of overlapping layers */ 250146d62e5SAmir Goldstein err = -ELOOP; 251146d62e5SAmir Goldstein goto out_err; 252146d62e5SAmir Goldstein } 253146d62e5SAmir Goldstein 254102b0d11SVivek Goyal if (last_element) 255e28edc46SMiklos Szeredi d->is_dir = true; 256e9b77f90SVivek Goyal if (d->last) 257e9b77f90SVivek Goyal goto out; 258e9b77f90SVivek Goyal 259e9b77f90SVivek Goyal if (ovl_is_opaquedir(this)) { 260102b0d11SVivek Goyal d->stop = true; 261102b0d11SVivek Goyal if (last_element) 262102b0d11SVivek Goyal d->opaque = true; 263e28edc46SMiklos Szeredi goto out; 264e28edc46SMiklos Szeredi } 2650618a816SVivek Goyal } 26602b69b28SMiklos Szeredi err = ovl_check_redirect(this, d, prelen, post); 26702b69b28SMiklos Szeredi if (err) 26802b69b28SMiklos Szeredi goto out_err; 269e28edc46SMiklos Szeredi out: 270e28edc46SMiklos Szeredi *ret = this; 271e28edc46SMiklos Szeredi return 0; 272e28edc46SMiklos Szeredi 273e28edc46SMiklos Szeredi put_and_out: 274e28edc46SMiklos Szeredi dput(this); 275e28edc46SMiklos Szeredi this = NULL; 276e28edc46SMiklos Szeredi goto out; 277e28edc46SMiklos Szeredi 278e28edc46SMiklos Szeredi out_err: 279e28edc46SMiklos Szeredi dput(this); 280e28edc46SMiklos Szeredi return err; 281e28edc46SMiklos Szeredi } 282e28edc46SMiklos Szeredi 283e28edc46SMiklos Szeredi static int ovl_lookup_layer(struct dentry *base, struct ovl_lookup_data *d, 284e28edc46SMiklos Szeredi struct dentry **ret) 285e28edc46SMiklos Szeredi { 2864c7d0c9cSAmir Goldstein /* Counting down from the end, since the prefix can change */ 2874c7d0c9cSAmir Goldstein size_t rem = d->name.len - 1; 28802b69b28SMiklos Szeredi struct dentry *dentry = NULL; 28902b69b28SMiklos Szeredi int err; 29002b69b28SMiklos Szeredi 2914c7d0c9cSAmir Goldstein if (d->name.name[0] != '/') 29202b69b28SMiklos Szeredi return ovl_lookup_single(base, d, d->name.name, d->name.len, 29302b69b28SMiklos Szeredi 0, "", ret); 29402b69b28SMiklos Szeredi 2954c7d0c9cSAmir Goldstein while (!IS_ERR_OR_NULL(base) && d_can_lookup(base)) { 2964c7d0c9cSAmir Goldstein const char *s = d->name.name + d->name.len - rem; 29702b69b28SMiklos Szeredi const char *next = strchrnul(s, '/'); 2984c7d0c9cSAmir Goldstein size_t thislen = next - s; 2994c7d0c9cSAmir Goldstein bool end = !next[0]; 30002b69b28SMiklos Szeredi 3014c7d0c9cSAmir Goldstein /* Verify we did not go off the rails */ 3024c7d0c9cSAmir Goldstein if (WARN_ON(s[-1] != '/')) 30302b69b28SMiklos Szeredi return -EIO; 30402b69b28SMiklos Szeredi 3054c7d0c9cSAmir Goldstein err = ovl_lookup_single(base, d, s, thislen, 3064c7d0c9cSAmir Goldstein d->name.len - rem, next, &base); 30702b69b28SMiklos Szeredi dput(dentry); 30802b69b28SMiklos Szeredi if (err) 30902b69b28SMiklos Szeredi return err; 31002b69b28SMiklos Szeredi dentry = base; 3114c7d0c9cSAmir Goldstein if (end) 3124c7d0c9cSAmir Goldstein break; 3134c7d0c9cSAmir Goldstein 3144c7d0c9cSAmir Goldstein rem -= thislen + 1; 3154c7d0c9cSAmir Goldstein 3164c7d0c9cSAmir Goldstein if (WARN_ON(rem >= d->name.len)) 3174c7d0c9cSAmir Goldstein return -EIO; 31802b69b28SMiklos Szeredi } 31902b69b28SMiklos Szeredi *ret = dentry; 32002b69b28SMiklos Szeredi return 0; 321e28edc46SMiklos Szeredi } 322e28edc46SMiklos Szeredi 323a9d01957SAmir Goldstein 3248a22efa1SAmir Goldstein int ovl_check_origin_fh(struct ovl_fs *ofs, struct ovl_fh *fh, bool connected, 325f941866fSAmir Goldstein struct dentry *upperdentry, struct ovl_path **stackp) 326a9d01957SAmir Goldstein { 327f7d3dacaSAmir Goldstein struct dentry *origin = NULL; 328f7d3dacaSAmir Goldstein int i; 329a9d01957SAmir Goldstein 3301eff1a1dSAmir Goldstein for (i = 0; i < ofs->numlower; i++) { 3318a22efa1SAmir Goldstein origin = ovl_decode_real_fh(fh, ofs->lower_layers[i].mnt, 3328a22efa1SAmir Goldstein connected); 333f7d3dacaSAmir Goldstein if (origin) 334f7d3dacaSAmir Goldstein break; 335f7d3dacaSAmir Goldstein } 336f7d3dacaSAmir Goldstein 337f7d3dacaSAmir Goldstein if (!origin) 3382e1a5328SAmir Goldstein return -ESTALE; 3392e1a5328SAmir Goldstein else if (IS_ERR(origin)) 3402e1a5328SAmir Goldstein return PTR_ERR(origin); 341f7d3dacaSAmir Goldstein 342f941866fSAmir Goldstein if (upperdentry && !ovl_is_whiteout(upperdentry) && 3432e1a5328SAmir Goldstein ((d_inode(origin)->i_mode ^ d_inode(upperdentry)->i_mode) & S_IFMT)) 3442e1a5328SAmir Goldstein goto invalid; 3452e1a5328SAmir Goldstein 346415543d5SAmir Goldstein if (!*stackp) 347b9343632SChandan Rajendra *stackp = kmalloc(sizeof(struct ovl_path), GFP_KERNEL); 348a9d01957SAmir Goldstein if (!*stackp) { 349a9d01957SAmir Goldstein dput(origin); 350a9d01957SAmir Goldstein return -ENOMEM; 351a9d01957SAmir Goldstein } 3521eff1a1dSAmir Goldstein **stackp = (struct ovl_path){ 3531eff1a1dSAmir Goldstein .dentry = origin, 3541eff1a1dSAmir Goldstein .layer = &ofs->lower_layers[i] 3551eff1a1dSAmir Goldstein }; 356a9d01957SAmir Goldstein 357a9d01957SAmir Goldstein return 0; 3582e1a5328SAmir Goldstein 3592e1a5328SAmir Goldstein invalid: 3602e1a5328SAmir Goldstein pr_warn_ratelimited("overlayfs: invalid origin (%pd2, ftype=%x, origin ftype=%x).\n", 3612e1a5328SAmir Goldstein upperdentry, d_inode(upperdentry)->i_mode & S_IFMT, 3622e1a5328SAmir Goldstein d_inode(origin)->i_mode & S_IFMT); 3632e1a5328SAmir Goldstein dput(origin); 3642e1a5328SAmir Goldstein return -EIO; 3652e1a5328SAmir Goldstein } 3662e1a5328SAmir Goldstein 3671eff1a1dSAmir Goldstein static int ovl_check_origin(struct ovl_fs *ofs, struct dentry *upperdentry, 3682e1a5328SAmir Goldstein struct ovl_path **stackp, unsigned int *ctrp) 3692e1a5328SAmir Goldstein { 37005122443SAmir Goldstein struct ovl_fh *fh = ovl_get_fh(upperdentry, OVL_XATTR_ORIGIN); 3712e1a5328SAmir Goldstein int err; 3722e1a5328SAmir Goldstein 3732e1a5328SAmir Goldstein if (IS_ERR_OR_NULL(fh)) 3742e1a5328SAmir Goldstein return PTR_ERR(fh); 3752e1a5328SAmir Goldstein 3768a22efa1SAmir Goldstein err = ovl_check_origin_fh(ofs, fh, false, upperdentry, stackp); 3772e1a5328SAmir Goldstein kfree(fh); 3782e1a5328SAmir Goldstein 3792e1a5328SAmir Goldstein if (err) { 3802e1a5328SAmir Goldstein if (err == -ESTALE) 3812e1a5328SAmir Goldstein return 0; 3822e1a5328SAmir Goldstein return err; 3832e1a5328SAmir Goldstein } 3842e1a5328SAmir Goldstein 3852e1a5328SAmir Goldstein if (WARN_ON(*ctrp)) 3862e1a5328SAmir Goldstein return -EIO; 3872e1a5328SAmir Goldstein 3882e1a5328SAmir Goldstein *ctrp = 1; 3892e1a5328SAmir Goldstein return 0; 390a9d01957SAmir Goldstein } 391a9d01957SAmir Goldstein 392bbb1e54dSMiklos Szeredi /* 39305122443SAmir Goldstein * Verify that @fh matches the file handle stored in xattr @name. 3948b88a2e6SAmir Goldstein * Return 0 on match, -ESTALE on mismatch, < 0 on error. 3958b88a2e6SAmir Goldstein */ 39605122443SAmir Goldstein static int ovl_verify_fh(struct dentry *dentry, const char *name, 39705122443SAmir Goldstein const struct ovl_fh *fh) 3988b88a2e6SAmir Goldstein { 39905122443SAmir Goldstein struct ovl_fh *ofh = ovl_get_fh(dentry, name); 4008b88a2e6SAmir Goldstein int err = 0; 4018b88a2e6SAmir Goldstein 4028b88a2e6SAmir Goldstein if (!ofh) 4038b88a2e6SAmir Goldstein return -ENODATA; 4048b88a2e6SAmir Goldstein 4058b88a2e6SAmir Goldstein if (IS_ERR(ofh)) 4068b88a2e6SAmir Goldstein return PTR_ERR(ofh); 4078b88a2e6SAmir Goldstein 4088b88a2e6SAmir Goldstein if (fh->len != ofh->len || memcmp(fh, ofh, fh->len)) 4098b88a2e6SAmir Goldstein err = -ESTALE; 4108b88a2e6SAmir Goldstein 4118b88a2e6SAmir Goldstein kfree(ofh); 4128b88a2e6SAmir Goldstein return err; 4138b88a2e6SAmir Goldstein } 4148b88a2e6SAmir Goldstein 4158b88a2e6SAmir Goldstein /* 41605122443SAmir Goldstein * Verify that @real dentry matches the file handle stored in xattr @name. 4178b88a2e6SAmir Goldstein * 41805122443SAmir Goldstein * If @set is true and there is no stored file handle, encode @real and store 41905122443SAmir Goldstein * file handle in xattr @name. 4208b88a2e6SAmir Goldstein * 42105122443SAmir Goldstein * Return 0 on match, -ESTALE on mismatch, -ENODATA on no xattr, < 0 on error. 4228b88a2e6SAmir Goldstein */ 42305122443SAmir Goldstein int ovl_verify_set_fh(struct dentry *dentry, const char *name, 42405122443SAmir Goldstein struct dentry *real, bool is_upper, bool set) 4258b88a2e6SAmir Goldstein { 4268b88a2e6SAmir Goldstein struct inode *inode; 4278b88a2e6SAmir Goldstein struct ovl_fh *fh; 4288b88a2e6SAmir Goldstein int err; 4298b88a2e6SAmir Goldstein 4305b2cccd3SAmir Goldstein fh = ovl_encode_real_fh(real, is_upper); 4318b88a2e6SAmir Goldstein err = PTR_ERR(fh); 432babf4770SAmir Goldstein if (IS_ERR(fh)) { 433babf4770SAmir Goldstein fh = NULL; 4348b88a2e6SAmir Goldstein goto fail; 435babf4770SAmir Goldstein } 4368b88a2e6SAmir Goldstein 43705122443SAmir Goldstein err = ovl_verify_fh(dentry, name, fh); 4388b88a2e6SAmir Goldstein if (set && err == -ENODATA) 43905122443SAmir Goldstein err = ovl_do_setxattr(dentry, name, fh, fh->len, 0); 4408b88a2e6SAmir Goldstein if (err) 4418b88a2e6SAmir Goldstein goto fail; 4428b88a2e6SAmir Goldstein 4438b88a2e6SAmir Goldstein out: 4448b88a2e6SAmir Goldstein kfree(fh); 4458b88a2e6SAmir Goldstein return err; 4468b88a2e6SAmir Goldstein 4478b88a2e6SAmir Goldstein fail: 44805122443SAmir Goldstein inode = d_inode(real); 44905122443SAmir Goldstein pr_warn_ratelimited("overlayfs: failed to verify %s (%pd2, ino=%lu, err=%i)\n", 45005122443SAmir Goldstein is_upper ? "upper" : "origin", real, 45105122443SAmir Goldstein inode ? inode->i_ino : 0, err); 4528b88a2e6SAmir Goldstein goto out; 4538b88a2e6SAmir Goldstein } 4548b88a2e6SAmir Goldstein 455e8f9e5b7SAmir Goldstein /* Get upper dentry from index */ 4563b0bfc6eSAmir Goldstein struct dentry *ovl_index_upper(struct ovl_fs *ofs, struct dentry *index) 457e8f9e5b7SAmir Goldstein { 458e8f9e5b7SAmir Goldstein struct ovl_fh *fh; 459e8f9e5b7SAmir Goldstein struct dentry *upper; 460e8f9e5b7SAmir Goldstein 461e8f9e5b7SAmir Goldstein if (!d_is_dir(index)) 462e8f9e5b7SAmir Goldstein return dget(index); 463e8f9e5b7SAmir Goldstein 464e8f9e5b7SAmir Goldstein fh = ovl_get_fh(index, OVL_XATTR_UPPER); 465e8f9e5b7SAmir Goldstein if (IS_ERR_OR_NULL(fh)) 466e8f9e5b7SAmir Goldstein return ERR_CAST(fh); 467e8f9e5b7SAmir Goldstein 4688a22efa1SAmir Goldstein upper = ovl_decode_real_fh(fh, ofs->upper_mnt, true); 469e8f9e5b7SAmir Goldstein kfree(fh); 470e8f9e5b7SAmir Goldstein 471e8f9e5b7SAmir Goldstein if (IS_ERR_OR_NULL(upper)) 472e8f9e5b7SAmir Goldstein return upper ?: ERR_PTR(-ESTALE); 473e8f9e5b7SAmir Goldstein 474e8f9e5b7SAmir Goldstein if (!d_is_dir(upper)) { 475e8f9e5b7SAmir Goldstein pr_warn_ratelimited("overlayfs: invalid index upper (%pd2, upper=%pd2).\n", 476e8f9e5b7SAmir Goldstein index, upper); 477e8f9e5b7SAmir Goldstein dput(upper); 478e8f9e5b7SAmir Goldstein return ERR_PTR(-EIO); 479e8f9e5b7SAmir Goldstein } 480e8f9e5b7SAmir Goldstein 481e8f9e5b7SAmir Goldstein return upper; 482e8f9e5b7SAmir Goldstein } 483e8f9e5b7SAmir Goldstein 4849ee60ce2SAmir Goldstein /* Is this a leftover from create/whiteout of directory index entry? */ 4859ee60ce2SAmir Goldstein static bool ovl_is_temp_index(struct dentry *index) 4869ee60ce2SAmir Goldstein { 4879ee60ce2SAmir Goldstein return index->d_name.name[0] == '#'; 4889ee60ce2SAmir Goldstein } 4899ee60ce2SAmir Goldstein 4908b88a2e6SAmir Goldstein /* 491415543d5SAmir Goldstein * Verify that an index entry name matches the origin file handle stored in 492415543d5SAmir Goldstein * OVL_XATTR_ORIGIN and that origin file handle can be decoded to lower path. 493415543d5SAmir Goldstein * Return 0 on match, -ESTALE on mismatch or stale origin, < 0 on error. 494415543d5SAmir Goldstein */ 4951eff1a1dSAmir Goldstein int ovl_verify_index(struct ovl_fs *ofs, struct dentry *index) 496415543d5SAmir Goldstein { 497415543d5SAmir Goldstein struct ovl_fh *fh = NULL; 498415543d5SAmir Goldstein size_t len; 499b9343632SChandan Rajendra struct ovl_path origin = { }; 500b9343632SChandan Rajendra struct ovl_path *stack = &origin; 501e8f9e5b7SAmir Goldstein struct dentry *upper = NULL; 502415543d5SAmir Goldstein int err; 503415543d5SAmir Goldstein 504415543d5SAmir Goldstein if (!d_inode(index)) 505415543d5SAmir Goldstein return 0; 506415543d5SAmir Goldstein 5079ee60ce2SAmir Goldstein /* Cleanup leftover from index create/cleanup attempt */ 5089ee60ce2SAmir Goldstein err = -ESTALE; 5099ee60ce2SAmir Goldstein if (ovl_is_temp_index(index)) 5109ee60ce2SAmir Goldstein goto fail; 5119ee60ce2SAmir Goldstein 512fa0096e3SAmir Goldstein err = -EINVAL; 513415543d5SAmir Goldstein if (index->d_name.len < sizeof(struct ovl_fh)*2) 514415543d5SAmir Goldstein goto fail; 515415543d5SAmir Goldstein 516415543d5SAmir Goldstein err = -ENOMEM; 517415543d5SAmir Goldstein len = index->d_name.len / 2; 5180ee931c4SMichal Hocko fh = kzalloc(len, GFP_KERNEL); 519415543d5SAmir Goldstein if (!fh) 520415543d5SAmir Goldstein goto fail; 521415543d5SAmir Goldstein 522415543d5SAmir Goldstein err = -EINVAL; 5232e1a5328SAmir Goldstein if (hex2bin((u8 *)fh, index->d_name.name, len)) 5242e1a5328SAmir Goldstein goto fail; 5252e1a5328SAmir Goldstein 5262e1a5328SAmir Goldstein err = ovl_check_fh_len(fh, len); 5272e1a5328SAmir Goldstein if (err) 528415543d5SAmir Goldstein goto fail; 529415543d5SAmir Goldstein 5307db25d36SAmir Goldstein /* 5317db25d36SAmir Goldstein * Whiteout index entries are used as an indication that an exported 5327db25d36SAmir Goldstein * overlay file handle should be treated as stale (i.e. after unlink 5337db25d36SAmir Goldstein * of the overlay inode). These entries contain no origin xattr. 5347db25d36SAmir Goldstein */ 5357db25d36SAmir Goldstein if (ovl_is_whiteout(index)) 5367db25d36SAmir Goldstein goto out; 5377db25d36SAmir Goldstein 538e8f9e5b7SAmir Goldstein /* 539e8f9e5b7SAmir Goldstein * Verifying directory index entries are not stale is expensive, so 540e8f9e5b7SAmir Goldstein * only verify stale dir index if NFS export is enabled. 541e8f9e5b7SAmir Goldstein */ 542e8f9e5b7SAmir Goldstein if (d_is_dir(index) && !ofs->config.nfs_export) 543e8f9e5b7SAmir Goldstein goto out; 544e8f9e5b7SAmir Goldstein 545e8f9e5b7SAmir Goldstein /* 546e8f9e5b7SAmir Goldstein * Directory index entries should have 'upper' xattr pointing to the 547e8f9e5b7SAmir Goldstein * real upper dir. Non-dir index entries are hardlinks to the upper 548e8f9e5b7SAmir Goldstein * real inode. For non-dir index, we can read the copy up origin xattr 549e8f9e5b7SAmir Goldstein * directly from the index dentry, but for dir index we first need to 550e8f9e5b7SAmir Goldstein * decode the upper directory. 551e8f9e5b7SAmir Goldstein */ 552e8f9e5b7SAmir Goldstein upper = ovl_index_upper(ofs, index); 553e8f9e5b7SAmir Goldstein if (IS_ERR_OR_NULL(upper)) { 554e8f9e5b7SAmir Goldstein err = PTR_ERR(upper); 55524f0b172SAmir Goldstein /* 55624f0b172SAmir Goldstein * Directory index entries with no 'upper' xattr need to be 55724f0b172SAmir Goldstein * removed. When dir index entry has a stale 'upper' xattr, 55824f0b172SAmir Goldstein * we assume that upper dir was removed and we treat the dir 55924f0b172SAmir Goldstein * index as orphan entry that needs to be whited out. 56024f0b172SAmir Goldstein */ 56124f0b172SAmir Goldstein if (err == -ESTALE) 56224f0b172SAmir Goldstein goto orphan; 56324f0b172SAmir Goldstein else if (!err) 564e8f9e5b7SAmir Goldstein err = -ESTALE; 565e8f9e5b7SAmir Goldstein goto fail; 566e8f9e5b7SAmir Goldstein } 567e8f9e5b7SAmir Goldstein 568e8f9e5b7SAmir Goldstein err = ovl_verify_fh(upper, OVL_XATTR_ORIGIN, fh); 569e8f9e5b7SAmir Goldstein dput(upper); 570415543d5SAmir Goldstein if (err) 571415543d5SAmir Goldstein goto fail; 572415543d5SAmir Goldstein 573e8f9e5b7SAmir Goldstein /* Check if non-dir index is orphan and don't warn before cleaning it */ 574e8f9e5b7SAmir Goldstein if (!d_is_dir(index) && d_inode(index)->i_nlink == 1) { 5758a22efa1SAmir Goldstein err = ovl_check_origin_fh(ofs, fh, false, index, &stack); 576415543d5SAmir Goldstein if (err) 577415543d5SAmir Goldstein goto fail; 578415543d5SAmir Goldstein 579e8f9e5b7SAmir Goldstein if (ovl_get_nlink(origin.dentry, index, 0) == 0) 58024f0b172SAmir Goldstein goto orphan; 581e8f9e5b7SAmir Goldstein } 582caf70cb2SAmir Goldstein 583415543d5SAmir Goldstein out: 584e8f9e5b7SAmir Goldstein dput(origin.dentry); 585415543d5SAmir Goldstein kfree(fh); 586415543d5SAmir Goldstein return err; 587415543d5SAmir Goldstein 588415543d5SAmir Goldstein fail: 58961b67471SAmir Goldstein pr_warn_ratelimited("overlayfs: failed to verify index (%pd2, ftype=%x, err=%i)\n", 59061b67471SAmir Goldstein index, d_inode(index)->i_mode & S_IFMT, err); 591415543d5SAmir Goldstein goto out; 59224f0b172SAmir Goldstein 59324f0b172SAmir Goldstein orphan: 59424f0b172SAmir Goldstein pr_warn_ratelimited("overlayfs: orphan index entry (%pd2, ftype=%x, nlink=%u)\n", 59524f0b172SAmir Goldstein index, d_inode(index)->i_mode & S_IFMT, 59624f0b172SAmir Goldstein d_inode(index)->i_nlink); 59724f0b172SAmir Goldstein err = -ENOENT; 59824f0b172SAmir Goldstein goto out; 599415543d5SAmir Goldstein } 600415543d5SAmir Goldstein 60191ffe7beSAmir Goldstein static int ovl_get_index_name_fh(struct ovl_fh *fh, struct qstr *name) 60291ffe7beSAmir Goldstein { 60391ffe7beSAmir Goldstein char *n, *s; 60491ffe7beSAmir Goldstein 6056396bb22SKees Cook n = kcalloc(fh->len, 2, GFP_KERNEL); 60691ffe7beSAmir Goldstein if (!n) 60791ffe7beSAmir Goldstein return -ENOMEM; 60891ffe7beSAmir Goldstein 60991ffe7beSAmir Goldstein s = bin2hex(n, fh, fh->len); 61091ffe7beSAmir Goldstein *name = (struct qstr) QSTR_INIT(n, s - n); 61191ffe7beSAmir Goldstein 61291ffe7beSAmir Goldstein return 0; 61391ffe7beSAmir Goldstein 61491ffe7beSAmir Goldstein } 61591ffe7beSAmir Goldstein 616415543d5SAmir Goldstein /* 617359f392cSAmir Goldstein * Lookup in indexdir for the index entry of a lower real inode or a copy up 618359f392cSAmir Goldstein * origin inode. The index entry name is the hex representation of the lower 619359f392cSAmir Goldstein * inode file handle. 620359f392cSAmir Goldstein * 621359f392cSAmir Goldstein * If the index dentry in negative, then either no lower aliases have been 622359f392cSAmir Goldstein * copied up yet, or aliases have been copied up in older kernels and are 623359f392cSAmir Goldstein * not indexed. 624359f392cSAmir Goldstein * 625359f392cSAmir Goldstein * If the index dentry for a copy up origin inode is positive, but points 626359f392cSAmir Goldstein * to an inode different than the upper inode, then either the upper inode 627359f392cSAmir Goldstein * has been copied up and not indexed or it was indexed, but since then 628359f392cSAmir Goldstein * index dir was cleared. Either way, that index cannot be used to indentify 629359f392cSAmir Goldstein * the overlay inode. 630359f392cSAmir Goldstein */ 631359f392cSAmir Goldstein int ovl_get_index_name(struct dentry *origin, struct qstr *name) 632359f392cSAmir Goldstein { 633359f392cSAmir Goldstein struct ovl_fh *fh; 63491ffe7beSAmir Goldstein int err; 635359f392cSAmir Goldstein 6365b2cccd3SAmir Goldstein fh = ovl_encode_real_fh(origin, false); 637359f392cSAmir Goldstein if (IS_ERR(fh)) 638359f392cSAmir Goldstein return PTR_ERR(fh); 639359f392cSAmir Goldstein 64091ffe7beSAmir Goldstein err = ovl_get_index_name_fh(fh, name); 64191ffe7beSAmir Goldstein 642359f392cSAmir Goldstein kfree(fh); 643359f392cSAmir Goldstein return err; 64491ffe7beSAmir Goldstein } 645359f392cSAmir Goldstein 64691ffe7beSAmir Goldstein /* Lookup index by file handle for NFS export */ 64791ffe7beSAmir Goldstein struct dentry *ovl_get_index_fh(struct ovl_fs *ofs, struct ovl_fh *fh) 64891ffe7beSAmir Goldstein { 64991ffe7beSAmir Goldstein struct dentry *index; 65091ffe7beSAmir Goldstein struct qstr name; 65191ffe7beSAmir Goldstein int err; 65291ffe7beSAmir Goldstein 65391ffe7beSAmir Goldstein err = ovl_get_index_name_fh(fh, &name); 65491ffe7beSAmir Goldstein if (err) 65591ffe7beSAmir Goldstein return ERR_PTR(err); 65691ffe7beSAmir Goldstein 65791ffe7beSAmir Goldstein index = lookup_one_len_unlocked(name.name, ofs->indexdir, name.len); 65891ffe7beSAmir Goldstein kfree(name.name); 65991ffe7beSAmir Goldstein if (IS_ERR(index)) { 66091ffe7beSAmir Goldstein if (PTR_ERR(index) == -ENOENT) 66191ffe7beSAmir Goldstein index = NULL; 66291ffe7beSAmir Goldstein return index; 66391ffe7beSAmir Goldstein } 66491ffe7beSAmir Goldstein 66591ffe7beSAmir Goldstein if (d_is_negative(index)) 66691ffe7beSAmir Goldstein err = 0; 66791ffe7beSAmir Goldstein else if (ovl_is_whiteout(index)) 66891ffe7beSAmir Goldstein err = -ESTALE; 66991ffe7beSAmir Goldstein else if (ovl_dentry_weird(index)) 67091ffe7beSAmir Goldstein err = -EIO; 67191ffe7beSAmir Goldstein else 67291ffe7beSAmir Goldstein return index; 67391ffe7beSAmir Goldstein 67491ffe7beSAmir Goldstein dput(index); 67591ffe7beSAmir Goldstein return ERR_PTR(err); 676359f392cSAmir Goldstein } 677359f392cSAmir Goldstein 67806170154SAmir Goldstein struct dentry *ovl_lookup_index(struct ovl_fs *ofs, struct dentry *upper, 67906170154SAmir Goldstein struct dentry *origin, bool verify) 680359f392cSAmir Goldstein { 681359f392cSAmir Goldstein struct dentry *index; 682359f392cSAmir Goldstein struct inode *inode; 683359f392cSAmir Goldstein struct qstr name; 684ad1d615cSAmir Goldstein bool is_dir = d_is_dir(origin); 685359f392cSAmir Goldstein int err; 686359f392cSAmir Goldstein 687359f392cSAmir Goldstein err = ovl_get_index_name(origin, &name); 688359f392cSAmir Goldstein if (err) 689359f392cSAmir Goldstein return ERR_PTR(err); 690359f392cSAmir Goldstein 691359f392cSAmir Goldstein index = lookup_one_len_unlocked(name.name, ofs->indexdir, name.len); 692359f392cSAmir Goldstein if (IS_ERR(index)) { 693e0082a0fSAmir Goldstein err = PTR_ERR(index); 6947937a56fSAmir Goldstein if (err == -ENOENT) { 6957937a56fSAmir Goldstein index = NULL; 6967937a56fSAmir Goldstein goto out; 6977937a56fSAmir Goldstein } 698601350ffSAmir Goldstein pr_warn_ratelimited("overlayfs: failed inode index lookup (ino=%lu, key=%.*s, err=%i);\n" 699359f392cSAmir Goldstein "overlayfs: mount with '-o index=off' to disable inodes index.\n", 700359f392cSAmir Goldstein d_inode(origin)->i_ino, name.len, name.name, 701359f392cSAmir Goldstein err); 702359f392cSAmir Goldstein goto out; 703359f392cSAmir Goldstein } 704359f392cSAmir Goldstein 7050e082555SAmir Goldstein inode = d_inode(index); 706359f392cSAmir Goldstein if (d_is_negative(index)) { 7076eaf0111SAmir Goldstein goto out_dput; 70806170154SAmir Goldstein } else if (ovl_is_whiteout(index) && !verify) { 70906170154SAmir Goldstein /* 71006170154SAmir Goldstein * When index lookup is called with !verify for decoding an 71106170154SAmir Goldstein * overlay file handle, a whiteout index implies that decode 71206170154SAmir Goldstein * should treat file handle as stale and no need to print a 71306170154SAmir Goldstein * warning about it. 71406170154SAmir Goldstein */ 71506170154SAmir Goldstein dput(index); 71606170154SAmir Goldstein index = ERR_PTR(-ESTALE); 71706170154SAmir Goldstein goto out; 7180e082555SAmir Goldstein } else if (ovl_dentry_weird(index) || ovl_is_whiteout(index) || 7190e082555SAmir Goldstein ((inode->i_mode ^ d_inode(origin)->i_mode) & S_IFMT)) { 7200e082555SAmir Goldstein /* 7210e082555SAmir Goldstein * Index should always be of the same file type as origin 7220e082555SAmir Goldstein * except for the case of a whiteout index. A whiteout 7230e082555SAmir Goldstein * index should only exist if all lower aliases have been 7240e082555SAmir Goldstein * unlinked, which means that finding a lower origin on lookup 7250e082555SAmir Goldstein * whose index is a whiteout should be treated as an error. 7260e082555SAmir Goldstein */ 7270e082555SAmir Goldstein pr_warn_ratelimited("overlayfs: bad index found (index=%pd2, ftype=%x, origin ftype=%x).\n", 7280e082555SAmir Goldstein index, d_inode(index)->i_mode & S_IFMT, 7290e082555SAmir Goldstein d_inode(origin)->i_mode & S_IFMT); 730359f392cSAmir Goldstein goto fail; 73106170154SAmir Goldstein } else if (is_dir && verify) { 732ad1d615cSAmir Goldstein if (!upper) { 733ad1d615cSAmir Goldstein pr_warn_ratelimited("overlayfs: suspected uncovered redirected dir found (origin=%pd2, index=%pd2).\n", 734ad1d615cSAmir Goldstein origin, index); 735ad1d615cSAmir Goldstein goto fail; 736359f392cSAmir Goldstein } 737359f392cSAmir Goldstein 738ad1d615cSAmir Goldstein /* Verify that dir index 'upper' xattr points to upper dir */ 739ad1d615cSAmir Goldstein err = ovl_verify_upper(index, upper, false); 740ad1d615cSAmir Goldstein if (err) { 741ad1d615cSAmir Goldstein if (err == -ESTALE) { 742ad1d615cSAmir Goldstein pr_warn_ratelimited("overlayfs: suspected multiply redirected dir found (upper=%pd2, origin=%pd2, index=%pd2).\n", 743ad1d615cSAmir Goldstein upper, origin, index); 744ad1d615cSAmir Goldstein } 745ad1d615cSAmir Goldstein goto fail; 746ad1d615cSAmir Goldstein } 747ad1d615cSAmir Goldstein } else if (upper && d_inode(upper) != inode) { 748ad1d615cSAmir Goldstein goto out_dput; 749ad1d615cSAmir Goldstein } 750359f392cSAmir Goldstein out: 751359f392cSAmir Goldstein kfree(name.name); 752359f392cSAmir Goldstein return index; 753359f392cSAmir Goldstein 7546eaf0111SAmir Goldstein out_dput: 7556eaf0111SAmir Goldstein dput(index); 7566eaf0111SAmir Goldstein index = NULL; 7576eaf0111SAmir Goldstein goto out; 7586eaf0111SAmir Goldstein 759359f392cSAmir Goldstein fail: 760359f392cSAmir Goldstein dput(index); 761359f392cSAmir Goldstein index = ERR_PTR(-EIO); 762359f392cSAmir Goldstein goto out; 763359f392cSAmir Goldstein } 764359f392cSAmir Goldstein 765359f392cSAmir Goldstein /* 766bbb1e54dSMiklos Szeredi * Returns next layer in stack starting from top. 767bbb1e54dSMiklos Szeredi * Returns -1 if this is the last layer. 768bbb1e54dSMiklos Szeredi */ 769bbb1e54dSMiklos Szeredi int ovl_path_next(int idx, struct dentry *dentry, struct path *path) 770bbb1e54dSMiklos Szeredi { 771bbb1e54dSMiklos Szeredi struct ovl_entry *oe = dentry->d_fsdata; 772bbb1e54dSMiklos Szeredi 773bbb1e54dSMiklos Szeredi BUG_ON(idx < 0); 774bbb1e54dSMiklos Szeredi if (idx == 0) { 775bbb1e54dSMiklos Szeredi ovl_path_upper(dentry, path); 776bbb1e54dSMiklos Szeredi if (path->dentry) 777bbb1e54dSMiklos Szeredi return oe->numlower ? 1 : -1; 778bbb1e54dSMiklos Szeredi idx++; 779bbb1e54dSMiklos Szeredi } 780bbb1e54dSMiklos Szeredi BUG_ON(idx > oe->numlower); 781b9343632SChandan Rajendra path->dentry = oe->lowerstack[idx - 1].dentry; 782b9343632SChandan Rajendra path->mnt = oe->lowerstack[idx - 1].layer->mnt; 783bbb1e54dSMiklos Szeredi 784bbb1e54dSMiklos Szeredi return (idx < oe->numlower) ? idx + 1 : -1; 785bbb1e54dSMiklos Szeredi } 786bbb1e54dSMiklos Szeredi 7879678e630SAmir Goldstein /* Fix missing 'origin' xattr */ 7889678e630SAmir Goldstein static int ovl_fix_origin(struct dentry *dentry, struct dentry *lower, 7899678e630SAmir Goldstein struct dentry *upper) 7909678e630SAmir Goldstein { 7919678e630SAmir Goldstein int err; 7929678e630SAmir Goldstein 7939678e630SAmir Goldstein if (ovl_check_origin_xattr(upper)) 7949678e630SAmir Goldstein return 0; 7959678e630SAmir Goldstein 7969678e630SAmir Goldstein err = ovl_want_write(dentry); 7979678e630SAmir Goldstein if (err) 7989678e630SAmir Goldstein return err; 7999678e630SAmir Goldstein 8009678e630SAmir Goldstein err = ovl_set_origin(dentry, lower, upper); 8019678e630SAmir Goldstein if (!err) 8029678e630SAmir Goldstein err = ovl_set_impure(dentry->d_parent, upper->d_parent); 8039678e630SAmir Goldstein 8049678e630SAmir Goldstein ovl_drop_write(dentry); 8059678e630SAmir Goldstein return err; 8069678e630SAmir Goldstein } 8079678e630SAmir Goldstein 808bbb1e54dSMiklos Szeredi struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry, 809bbb1e54dSMiklos Szeredi unsigned int flags) 810bbb1e54dSMiklos Szeredi { 811bbb1e54dSMiklos Szeredi struct ovl_entry *oe; 812bbb1e54dSMiklos Szeredi const struct cred *old_cred; 8136b2d5fe4SMiklos Szeredi struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 814bbb1e54dSMiklos Szeredi struct ovl_entry *poe = dentry->d_parent->d_fsdata; 815c22205d0SAmir Goldstein struct ovl_entry *roe = dentry->d_sb->s_root->d_fsdata; 8169d3dfea3SVivek Goyal struct ovl_path *stack = NULL, *origin_path = NULL; 817bbb1e54dSMiklos Szeredi struct dentry *upperdir, *upperdentry = NULL; 818ad1d615cSAmir Goldstein struct dentry *origin = NULL; 819359f392cSAmir Goldstein struct dentry *index = NULL; 820bbb1e54dSMiklos Szeredi unsigned int ctr = 0; 821bbb1e54dSMiklos Szeredi struct inode *inode = NULL; 822bbb1e54dSMiklos Szeredi bool upperopaque = false; 82302b69b28SMiklos Szeredi char *upperredirect = NULL; 824bbb1e54dSMiklos Szeredi struct dentry *this; 825bbb1e54dSMiklos Szeredi unsigned int i; 826bbb1e54dSMiklos Szeredi int err; 8279d3dfea3SVivek Goyal bool metacopy = false; 828e28edc46SMiklos Szeredi struct ovl_lookup_data d = { 829146d62e5SAmir Goldstein .sb = dentry->d_sb, 830e28edc46SMiklos Szeredi .name = dentry->d_name, 831e28edc46SMiklos Szeredi .is_dir = false, 832e28edc46SMiklos Szeredi .opaque = false, 833e28edc46SMiklos Szeredi .stop = false, 834452061fdSVivek Goyal .last = ofs->config.redirect_follow ? false : !poe->numlower, 83502b69b28SMiklos Szeredi .redirect = NULL, 8369d3dfea3SVivek Goyal .metacopy = false, 837e28edc46SMiklos Szeredi }; 838bbb1e54dSMiklos Szeredi 8396b2d5fe4SMiklos Szeredi if (dentry->d_name.len > ofs->namelen) 8406b2d5fe4SMiklos Szeredi return ERR_PTR(-ENAMETOOLONG); 8416b2d5fe4SMiklos Szeredi 842bbb1e54dSMiklos Szeredi old_cred = ovl_override_creds(dentry->d_sb); 84309d8b586SMiklos Szeredi upperdir = ovl_dentry_upper(dentry->d_parent); 844bbb1e54dSMiklos Szeredi if (upperdir) { 845e28edc46SMiklos Szeredi err = ovl_lookup_layer(upperdir, &d, &upperdentry); 846e28edc46SMiklos Szeredi if (err) 847bbb1e54dSMiklos Szeredi goto out; 848bbb1e54dSMiklos Szeredi 849e28edc46SMiklos Szeredi if (upperdentry && unlikely(ovl_dentry_remote(upperdentry))) { 850e28edc46SMiklos Szeredi dput(upperdentry); 851bbb1e54dSMiklos Szeredi err = -EREMOTE; 852bbb1e54dSMiklos Szeredi goto out; 853bbb1e54dSMiklos Szeredi } 854a9d01957SAmir Goldstein if (upperdentry && !d.is_dir) { 8559d3dfea3SVivek Goyal unsigned int origin_ctr = 0; 8569d3dfea3SVivek Goyal 857f7d3dacaSAmir Goldstein /* 858f7d3dacaSAmir Goldstein * Lookup copy up origin by decoding origin file handle. 859f7d3dacaSAmir Goldstein * We may get a disconnected dentry, which is fine, 860f7d3dacaSAmir Goldstein * because we only need to hold the origin inode in 861f7d3dacaSAmir Goldstein * cache and use its inode number. We may even get a 862f7d3dacaSAmir Goldstein * connected dentry, that is not under any of the lower 863f7d3dacaSAmir Goldstein * layers root. That is also fine for using it's inode 864f7d3dacaSAmir Goldstein * number - it's the same as if we held a reference 865f7d3dacaSAmir Goldstein * to a dentry in lower layer that was moved under us. 866f7d3dacaSAmir Goldstein */ 8679d3dfea3SVivek Goyal err = ovl_check_origin(ofs, upperdentry, &origin_path, 8689d3dfea3SVivek Goyal &origin_ctr); 869a9d01957SAmir Goldstein if (err) 8705455f92bSVivek Goyal goto out_put_upper; 8719d3dfea3SVivek Goyal 8729d3dfea3SVivek Goyal if (d.metacopy) 8739d3dfea3SVivek Goyal metacopy = true; 874a9d01957SAmir Goldstein } 87502b69b28SMiklos Szeredi 87602b69b28SMiklos Szeredi if (d.redirect) { 8770ce5cdc9SDan Carpenter err = -ENOMEM; 87802b69b28SMiklos Szeredi upperredirect = kstrdup(d.redirect, GFP_KERNEL); 87902b69b28SMiklos Szeredi if (!upperredirect) 88002b69b28SMiklos Szeredi goto out_put_upper; 88102b69b28SMiklos Szeredi if (d.redirect[0] == '/') 882c22205d0SAmir Goldstein poe = roe; 88302b69b28SMiklos Szeredi } 884e28edc46SMiklos Szeredi upperopaque = d.opaque; 885bbb1e54dSMiklos Szeredi } 886bbb1e54dSMiklos Szeredi 887e28edc46SMiklos Szeredi if (!d.stop && poe->numlower) { 888bbb1e54dSMiklos Szeredi err = -ENOMEM; 889b9343632SChandan Rajendra stack = kcalloc(ofs->numlower, sizeof(struct ovl_path), 8900ee931c4SMichal Hocko GFP_KERNEL); 891bbb1e54dSMiklos Szeredi if (!stack) 892bbb1e54dSMiklos Szeredi goto out_put_upper; 893bbb1e54dSMiklos Szeredi } 894bbb1e54dSMiklos Szeredi 895e28edc46SMiklos Szeredi for (i = 0; !d.stop && i < poe->numlower; i++) { 896b9343632SChandan Rajendra struct ovl_path lower = poe->lowerstack[i]; 897bbb1e54dSMiklos Szeredi 898452061fdSVivek Goyal if (!ofs->config.redirect_follow) 899e28edc46SMiklos Szeredi d.last = i == poe->numlower - 1; 900452061fdSVivek Goyal else 901452061fdSVivek Goyal d.last = lower.layer->idx == roe->numlower; 902452061fdSVivek Goyal 903b9343632SChandan Rajendra err = ovl_lookup_layer(lower.dentry, &d, &this); 904e28edc46SMiklos Szeredi if (err) 905bbb1e54dSMiklos Szeredi goto out_put; 9066b2d5fe4SMiklos Szeredi 907bbb1e54dSMiklos Szeredi if (!this) 908bbb1e54dSMiklos Szeredi continue; 909bbb1e54dSMiklos Szeredi 9109678e630SAmir Goldstein /* 9119678e630SAmir Goldstein * If no origin fh is stored in upper of a merge dir, store fh 9129678e630SAmir Goldstein * of lower dir and set upper parent "impure". 9139678e630SAmir Goldstein */ 9149d3dfea3SVivek Goyal if (upperdentry && !ctr && !ofs->noxattr && d.is_dir) { 9159678e630SAmir Goldstein err = ovl_fix_origin(dentry, this, upperdentry); 9169678e630SAmir Goldstein if (err) { 9179678e630SAmir Goldstein dput(this); 9189678e630SAmir Goldstein goto out_put; 9199678e630SAmir Goldstein } 9209678e630SAmir Goldstein } 9219678e630SAmir Goldstein 92237b12916SAmir Goldstein /* 92337b12916SAmir Goldstein * When "verify_lower" feature is enabled, do not merge with a 924ad1d615cSAmir Goldstein * lower dir that does not match a stored origin xattr. In any 925ad1d615cSAmir Goldstein * case, only verified origin is used for index lookup. 9269d3dfea3SVivek Goyal * 9279d3dfea3SVivek Goyal * For non-dir dentry, if index=on, then ensure origin 9289d3dfea3SVivek Goyal * matches the dentry found using path based lookup, 9299d3dfea3SVivek Goyal * otherwise error out. 93037b12916SAmir Goldstein */ 9319d3dfea3SVivek Goyal if (upperdentry && !ctr && 9329d3dfea3SVivek Goyal ((d.is_dir && ovl_verify_lower(dentry->d_sb)) || 9339d3dfea3SVivek Goyal (!d.is_dir && ofs->config.index && origin_path))) { 93437b12916SAmir Goldstein err = ovl_verify_origin(upperdentry, this, false); 93537b12916SAmir Goldstein if (err) { 93637b12916SAmir Goldstein dput(this); 9379d3dfea3SVivek Goyal if (d.is_dir) 93837b12916SAmir Goldstein break; 9399d3dfea3SVivek Goyal goto out_put; 9409d3dfea3SVivek Goyal } 9419d3dfea3SVivek Goyal origin = this; 94237b12916SAmir Goldstein } 943ad1d615cSAmir Goldstein 9449d3dfea3SVivek Goyal if (d.metacopy) 9459d3dfea3SVivek Goyal metacopy = true; 9469d3dfea3SVivek Goyal /* 9479d3dfea3SVivek Goyal * Do not store intermediate metacopy dentries in chain, 9489d3dfea3SVivek Goyal * except top most lower metacopy dentry 9499d3dfea3SVivek Goyal */ 9509d3dfea3SVivek Goyal if (d.metacopy && ctr) { 9519d3dfea3SVivek Goyal dput(this); 9529d3dfea3SVivek Goyal continue; 95337b12916SAmir Goldstein } 95437b12916SAmir Goldstein 955bbb1e54dSMiklos Szeredi stack[ctr].dentry = this; 956b9343632SChandan Rajendra stack[ctr].layer = lower.layer; 957bbb1e54dSMiklos Szeredi ctr++; 95802b69b28SMiklos Szeredi 959438c84c2SMiklos Szeredi /* 960438c84c2SMiklos Szeredi * Following redirects can have security consequences: it's like 961438c84c2SMiklos Szeredi * a symlink into the lower layer without the permission checks. 962438c84c2SMiklos Szeredi * This is only a problem if the upper layer is untrusted (e.g 963438c84c2SMiklos Szeredi * comes from an USB drive). This can allow a non-readable file 964438c84c2SMiklos Szeredi * or directory to become readable. 965438c84c2SMiklos Szeredi * 966438c84c2SMiklos Szeredi * Only following redirects when redirects are enabled disables 967438c84c2SMiklos Szeredi * this attack vector when not necessary. 968438c84c2SMiklos Szeredi */ 969438c84c2SMiklos Szeredi err = -EPERM; 970438c84c2SMiklos Szeredi if (d.redirect && !ofs->config.redirect_follow) { 971f8167817SAmir Goldstein pr_warn_ratelimited("overlayfs: refusing to follow redirect for (%pd2)\n", 972f8167817SAmir Goldstein dentry); 973438c84c2SMiklos Szeredi goto out_put; 974438c84c2SMiklos Szeredi } 975438c84c2SMiklos Szeredi 976d1fe96c0SVivek Goyal if (d.stop) 977d1fe96c0SVivek Goyal break; 978d1fe96c0SVivek Goyal 979c22205d0SAmir Goldstein if (d.redirect && d.redirect[0] == '/' && poe != roe) { 980c22205d0SAmir Goldstein poe = roe; 98102b69b28SMiklos Szeredi /* Find the current layer on the root dentry */ 982d583ed7dSAmir Goldstein i = lower.layer->idx - 1; 98302b69b28SMiklos Szeredi } 984bbb1e54dSMiklos Szeredi } 985bbb1e54dSMiklos Szeredi 9869d3dfea3SVivek Goyal if (metacopy) { 9879d3dfea3SVivek Goyal /* 9889d3dfea3SVivek Goyal * Found a metacopy dentry but did not find corresponding 9899d3dfea3SVivek Goyal * data dentry 9909d3dfea3SVivek Goyal */ 9919d3dfea3SVivek Goyal if (d.metacopy) { 9929d3dfea3SVivek Goyal err = -EIO; 9939d3dfea3SVivek Goyal goto out_put; 9949d3dfea3SVivek Goyal } 9959d3dfea3SVivek Goyal 9969d3dfea3SVivek Goyal err = -EPERM; 9979d3dfea3SVivek Goyal if (!ofs->config.metacopy) { 9989d3dfea3SVivek Goyal pr_warn_ratelimited("overlay: refusing to follow metacopy origin for (%pd2)\n", 9999d3dfea3SVivek Goyal dentry); 10009d3dfea3SVivek Goyal goto out_put; 10019d3dfea3SVivek Goyal } 10029d3dfea3SVivek Goyal } else if (!d.is_dir && upperdentry && !ctr && origin_path) { 10039d3dfea3SVivek Goyal if (WARN_ON(stack != NULL)) { 10049d3dfea3SVivek Goyal err = -EIO; 10059d3dfea3SVivek Goyal goto out_put; 10069d3dfea3SVivek Goyal } 10079d3dfea3SVivek Goyal stack = origin_path; 10089d3dfea3SVivek Goyal ctr = 1; 10099d3dfea3SVivek Goyal origin_path = NULL; 10109d3dfea3SVivek Goyal } 10119d3dfea3SVivek Goyal 1012ad1d615cSAmir Goldstein /* 1013ad1d615cSAmir Goldstein * Lookup index by lower inode and verify it matches upper inode. 1014ad1d615cSAmir Goldstein * We only trust dir index if we verified that lower dir matches 1015ad1d615cSAmir Goldstein * origin, otherwise dir index entries may be inconsistent and we 10169d3dfea3SVivek Goyal * ignore them. 10179d3dfea3SVivek Goyal * 10189d3dfea3SVivek Goyal * For non-dir upper metacopy dentry, we already set "origin" if we 10199d3dfea3SVivek Goyal * verified that lower matched upper origin. If upper origin was 10209d3dfea3SVivek Goyal * not present (because lower layer did not support fh encode/decode), 10219d3dfea3SVivek Goyal * or indexing is not enabled, do not set "origin" and skip looking up 10229d3dfea3SVivek Goyal * index. This case should be handled in same way as a non-dir upper 10239d3dfea3SVivek Goyal * without ORIGIN is handled. 10249d3dfea3SVivek Goyal * 10259d3dfea3SVivek Goyal * Always lookup index of non-dir non-metacopy and non-upper. 1026ad1d615cSAmir Goldstein */ 10279d3dfea3SVivek Goyal if (ctr && (!upperdentry || (!d.is_dir && !metacopy))) 1028ad1d615cSAmir Goldstein origin = stack[0].dentry; 1029359f392cSAmir Goldstein 1030ad1d615cSAmir Goldstein if (origin && ovl_indexdir(dentry->d_sb) && 1031ad1d615cSAmir Goldstein (!d.is_dir || ovl_index_all(dentry->d_sb))) { 103206170154SAmir Goldstein index = ovl_lookup_index(ofs, upperdentry, origin, true); 1033359f392cSAmir Goldstein if (IS_ERR(index)) { 1034359f392cSAmir Goldstein err = PTR_ERR(index); 1035359f392cSAmir Goldstein index = NULL; 1036359f392cSAmir Goldstein goto out_put; 1037359f392cSAmir Goldstein } 1038359f392cSAmir Goldstein } 1039359f392cSAmir Goldstein 1040bbb1e54dSMiklos Szeredi oe = ovl_alloc_entry(ctr); 1041bbb1e54dSMiklos Szeredi err = -ENOMEM; 1042bbb1e54dSMiklos Szeredi if (!oe) 1043bbb1e54dSMiklos Szeredi goto out_put; 1044bbb1e54dSMiklos Szeredi 1045b9343632SChandan Rajendra memcpy(oe->lowerstack, stack, sizeof(struct ovl_path) * ctr); 1046e6d2ebddSMiklos Szeredi dentry->d_fsdata = oe; 1047e6d2ebddSMiklos Szeredi 1048c62520a8SAmir Goldstein if (upperopaque) 1049c62520a8SAmir Goldstein ovl_dentry_set_opaque(dentry); 1050c62520a8SAmir Goldstein 105155acc661SMiklos Szeredi if (upperdentry) 105255acc661SMiklos Szeredi ovl_dentry_set_upper_alias(dentry); 10530a2d0d3fSVivek Goyal else if (index) { 1054359f392cSAmir Goldstein upperdentry = dget(index); 10550a2d0d3fSVivek Goyal upperredirect = ovl_get_redirect_xattr(upperdentry, 0); 10560a2d0d3fSVivek Goyal if (IS_ERR(upperredirect)) { 10570a2d0d3fSVivek Goyal err = PTR_ERR(upperredirect); 10580a2d0d3fSVivek Goyal upperredirect = NULL; 10590a2d0d3fSVivek Goyal goto out_free_oe; 10600a2d0d3fSVivek Goyal } 10610a2d0d3fSVivek Goyal } 1062359f392cSAmir Goldstein 1063e6d2ebddSMiklos Szeredi if (upperdentry || ctr) { 1064ac6a52ebSVivek Goyal struct ovl_inode_params oip = { 1065ac6a52ebSVivek Goyal .upperdentry = upperdentry, 1066ac6a52ebSVivek Goyal .lowerpath = stack, 1067ac6a52ebSVivek Goyal .index = index, 1068ac6a52ebSVivek Goyal .numlower = ctr, 10699cec54c8SVivek Goyal .redirect = upperredirect, 10702664bd08SVivek Goyal .lowerdata = (ctr > 1 && !d.is_dir) ? 10712664bd08SVivek Goyal stack[ctr - 1].dentry : NULL, 1072ac6a52ebSVivek Goyal }; 1073ac6a52ebSVivek Goyal 1074ac6a52ebSVivek Goyal inode = ovl_get_inode(dentry->d_sb, &oip); 1075b9ac5c27SMiklos Szeredi err = PTR_ERR(inode); 1076b9ac5c27SMiklos Szeredi if (IS_ERR(inode)) 1077e6d2ebddSMiklos Szeredi goto out_free_oe; 1078e6d2ebddSMiklos Szeredi } 1079e6d2ebddSMiklos Szeredi 1080e6d2ebddSMiklos Szeredi revert_creds(old_cred); 10819d3dfea3SVivek Goyal if (origin_path) { 10829d3dfea3SVivek Goyal dput(origin_path->dentry); 10839d3dfea3SVivek Goyal kfree(origin_path); 10849d3dfea3SVivek Goyal } 1085359f392cSAmir Goldstein dput(index); 1086bbb1e54dSMiklos Szeredi kfree(stack); 108702b69b28SMiklos Szeredi kfree(d.redirect); 1088829c28beSAmir Goldstein return d_splice_alias(inode, dentry); 1089bbb1e54dSMiklos Szeredi 1090bbb1e54dSMiklos Szeredi out_free_oe: 1091e6d2ebddSMiklos Szeredi dentry->d_fsdata = NULL; 1092bbb1e54dSMiklos Szeredi kfree(oe); 1093bbb1e54dSMiklos Szeredi out_put: 1094359f392cSAmir Goldstein dput(index); 1095bbb1e54dSMiklos Szeredi for (i = 0; i < ctr; i++) 1096bbb1e54dSMiklos Szeredi dput(stack[i].dentry); 1097bbb1e54dSMiklos Szeredi kfree(stack); 1098bbb1e54dSMiklos Szeredi out_put_upper: 10999d3dfea3SVivek Goyal if (origin_path) { 11009d3dfea3SVivek Goyal dput(origin_path->dentry); 11019d3dfea3SVivek Goyal kfree(origin_path); 11029d3dfea3SVivek Goyal } 1103bbb1e54dSMiklos Szeredi dput(upperdentry); 110402b69b28SMiklos Szeredi kfree(upperredirect); 1105bbb1e54dSMiklos Szeredi out: 110602b69b28SMiklos Szeredi kfree(d.redirect); 1107bbb1e54dSMiklos Szeredi revert_creds(old_cred); 1108bbb1e54dSMiklos Szeredi return ERR_PTR(err); 1109bbb1e54dSMiklos Szeredi } 1110bbb1e54dSMiklos Szeredi 1111bbb1e54dSMiklos Szeredi bool ovl_lower_positive(struct dentry *dentry) 1112bbb1e54dSMiklos Szeredi { 1113bbb1e54dSMiklos Szeredi struct ovl_entry *poe = dentry->d_parent->d_fsdata; 1114bbb1e54dSMiklos Szeredi const struct qstr *name = &dentry->d_name; 11156d0a8a90SAmir Goldstein const struct cred *old_cred; 1116bbb1e54dSMiklos Szeredi unsigned int i; 1117bbb1e54dSMiklos Szeredi bool positive = false; 1118bbb1e54dSMiklos Szeredi bool done = false; 1119bbb1e54dSMiklos Szeredi 1120bbb1e54dSMiklos Szeredi /* 1121bbb1e54dSMiklos Szeredi * If dentry is negative, then lower is positive iff this is a 1122bbb1e54dSMiklos Szeredi * whiteout. 1123bbb1e54dSMiklos Szeredi */ 1124bbb1e54dSMiklos Szeredi if (!dentry->d_inode) 1125c62520a8SAmir Goldstein return ovl_dentry_is_opaque(dentry); 1126bbb1e54dSMiklos Szeredi 1127bbb1e54dSMiklos Szeredi /* Negative upper -> positive lower */ 112809d8b586SMiklos Szeredi if (!ovl_dentry_upper(dentry)) 1129bbb1e54dSMiklos Szeredi return true; 1130bbb1e54dSMiklos Szeredi 11316d0a8a90SAmir Goldstein old_cred = ovl_override_creds(dentry->d_sb); 1132bbb1e54dSMiklos Szeredi /* Positive upper -> have to look up lower to see whether it exists */ 1133bbb1e54dSMiklos Szeredi for (i = 0; !done && !positive && i < poe->numlower; i++) { 1134bbb1e54dSMiklos Szeredi struct dentry *this; 1135bbb1e54dSMiklos Szeredi struct dentry *lowerdir = poe->lowerstack[i].dentry; 1136bbb1e54dSMiklos Szeredi 1137bbb1e54dSMiklos Szeredi this = lookup_one_len_unlocked(name->name, lowerdir, 1138bbb1e54dSMiklos Szeredi name->len); 1139bbb1e54dSMiklos Szeredi if (IS_ERR(this)) { 1140bbb1e54dSMiklos Szeredi switch (PTR_ERR(this)) { 1141bbb1e54dSMiklos Szeredi case -ENOENT: 1142bbb1e54dSMiklos Szeredi case -ENAMETOOLONG: 1143bbb1e54dSMiklos Szeredi break; 1144bbb1e54dSMiklos Szeredi 1145bbb1e54dSMiklos Szeredi default: 1146bbb1e54dSMiklos Szeredi /* 1147bbb1e54dSMiklos Szeredi * Assume something is there, we just couldn't 1148bbb1e54dSMiklos Szeredi * access it. 1149bbb1e54dSMiklos Szeredi */ 1150bbb1e54dSMiklos Szeredi positive = true; 1151bbb1e54dSMiklos Szeredi break; 1152bbb1e54dSMiklos Szeredi } 1153bbb1e54dSMiklos Szeredi } else { 1154bbb1e54dSMiklos Szeredi if (this->d_inode) { 1155bbb1e54dSMiklos Szeredi positive = !ovl_is_whiteout(this); 1156bbb1e54dSMiklos Szeredi done = true; 1157bbb1e54dSMiklos Szeredi } 1158bbb1e54dSMiklos Szeredi dput(this); 1159bbb1e54dSMiklos Szeredi } 1160bbb1e54dSMiklos Szeredi } 11616d0a8a90SAmir Goldstein revert_creds(old_cred); 1162bbb1e54dSMiklos Szeredi 1163bbb1e54dSMiklos Szeredi return positive; 1164bbb1e54dSMiklos Szeredi } 1165