fs/overlayfs/super.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *
   4  * Copyright (C) 2011 Novell Inc.
   5  */
   6
   7 #include <uapi/linux/magic.h>
   8 #include <linux/fs.h>
   9 #include <linux/namei.h>
  10 #include <linux/xattr.h>
  11 #include <linux/mount.h>
  12 #include <linux/parser.h>
  13 #include <linux/module.h>
  14 #include <linux/statfs.h>
  15 #include <linux/seq_file.h>
  16 #include <linux/posix_acl_xattr.h>
  17 #include <linux/exportfs.h>
  18 #include <linux/file.h>
  19 #include <linux/fs_context.h>
  20 #include <linux/fs_parser.h>
  21 #include "overlayfs.h"
  22 #include "params.h"
  23
  24 MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>");
  25 MODULE_DESCRIPTION("Overlay filesystem");
  26 MODULE_LICENSE("GPL");
  27
  28
  29 struct ovl_dir_cache;
  30
  31 static struct dentry *ovl_d_real(struct dentry *dentry,
  32                                  const struct inode *inode)
  33 {
  34         struct dentry *real = NULL, *lower;
  35         int err;
  36
  37         /*
  38          * vfs is only expected to call d_real() with NULL from d_real_inode()
  39          * and with overlay inode from file_dentry() on an overlay file.
  40          *
  41          * TODO: remove @inode argument from d_real() API, remove code in this
  42          * function that deals with non-NULL @inode and remove d_real() call
  43          * from file_dentry().
  44          */
  45         if (inode && d_inode(dentry) == inode)
  46                 return dentry;
  47         else if (inode)
  48                 goto bug;
  49
  50         if (!d_is_reg(dentry)) {
  51                 /* d_real_inode() is only relevant for regular files */
  52                 return dentry;
  53         }
  54
  55         real = ovl_dentry_upper(dentry);
  56         if (real && (inode == d_inode(real)))
  57                 return real;
  58
  59         if (real && !inode && ovl_has_upperdata(d_inode(dentry)))
  60                 return real;
  61
  62         /*
  63          * Best effort lazy lookup of lowerdata for !inode case to return
  64          * the real lowerdata dentry.  The only current caller of d_real() with
  65          * NULL inode is d_real_inode() from trace_uprobe and this caller is
  66          * likely going to be followed reading from the file, before placing
  67          * uprobes on offset within the file, so lowerdata should be available
  68          * when setting the uprobe.
  69          */
  70         err = ovl_verify_lowerdata(dentry);
  71         if (err)
  72                 goto bug;
  73         lower = ovl_dentry_lowerdata(dentry);
  74         if (!lower)
  75                 goto bug;
  76         real = lower;
  77
  78         /* Handle recursion */
  79         real = d_real(real, inode);
  80
  81         if (!inode || inode == d_inode(real))
  82                 return real;
  83 bug:
  84         WARN(1, "%s(%pd4, %s:%lu): real dentry (%p/%lu) not found\n",
  85              __func__, dentry, inode ? inode->i_sb->s_id : "NULL",
  86              inode ? inode->i_ino : 0, real,
  87              real && d_inode(real) ? d_inode(real)->i_ino : 0);
  88         return dentry;
  89 }
  90
  91 static int ovl_revalidate_real(struct dentry *d, unsigned int flags, bool weak)
  92 {
  93         int ret = 1;
  94
  95         if (!d)
  96                 return 1;
  97
  98         if (weak) {
  99                 if (d->d_flags & DCACHE_OP_WEAK_REVALIDATE)
 100                         ret =  d->d_op->d_weak_revalidate(d, flags);
 101         } else if (d->d_flags & DCACHE_OP_REVALIDATE) {
 102                 ret = d->d_op->d_revalidate(d, flags);
 103                 if (!ret) {
 104                         if (!(flags & LOOKUP_RCU))
 105                                 d_invalidate(d);
 106                         ret = -ESTALE;
 107                 }
 108         }
 109         return ret;
 110 }
 111
 112 static int ovl_dentry_revalidate_common(struct dentry *dentry,
 113                                         unsigned int flags, bool weak)
 114 {
 115         struct ovl_entry *oe;
 116         struct ovl_path *lowerstack;
 117         struct inode *inode = d_inode_rcu(dentry);
 118         struct dentry *upper;
 119         unsigned int i;
 120         int ret = 1;
 121
 122         /* Careful in RCU mode */
 123         if (!inode)
 124                 return -ECHILD;
 125
 126         oe = OVL_I_E(inode);
 127         lowerstack = ovl_lowerstack(oe);
 128         upper = ovl_i_dentry_upper(inode);
 129         if (upper)
 130                 ret = ovl_revalidate_real(upper, flags, weak);
 131
 132         for (i = 0; ret > 0 && i < ovl_numlower(oe); i++)
 133                 ret = ovl_revalidate_real(lowerstack[i].dentry, flags, weak);
 134
 135         return ret;
 136 }
 137
 138 static int ovl_dentry_revalidate(struct dentry *dentry, unsigned int flags)
 139 {
 140         return ovl_dentry_revalidate_common(dentry, flags, false);
 141 }
 142
 143 static int ovl_dentry_weak_revalidate(struct dentry *dentry, unsigned int flags)
 144 {
 145         return ovl_dentry_revalidate_common(dentry, flags, true);
 146 }
 147
 148 static const struct dentry_operations ovl_dentry_operations = {
 149         .d_real = ovl_d_real,
 150         .d_revalidate = ovl_dentry_revalidate,
 151         .d_weak_revalidate = ovl_dentry_weak_revalidate,
 152 };
 153
 154 static struct kmem_cache *ovl_inode_cachep;
 155
 156 static struct inode *ovl_alloc_inode(struct super_block *sb)
 157 {
 158         struct ovl_inode *oi = alloc_inode_sb(sb, ovl_inode_cachep, GFP_KERNEL);
 159
 160         if (!oi)
 161                 return NULL;
 162
 163         oi->cache = NULL;
 164         oi->redirect = NULL;
 165         oi->version = 0;
 166         oi->flags = 0;
 167         oi->__upperdentry = NULL;
 168         oi->lowerdata_redirect = NULL;
 169         oi->oe = NULL;
 170         mutex_init(&oi->lock);
 171
 172         return &oi->vfs_inode;
 173 }
 174
 175 static void ovl_free_inode(struct inode *inode)
 176 {
 177         struct ovl_inode *oi = OVL_I(inode);
 178
 179         kfree(oi->redirect);
 180         kfree(oi->oe);
 181         mutex_destroy(&oi->lock);
 182         kmem_cache_free(ovl_inode_cachep, oi);
 183 }
 184
 185 static void ovl_destroy_inode(struct inode *inode)
 186 {
 187         struct ovl_inode *oi = OVL_I(inode);
 188
 189         dput(oi->__upperdentry);
 190         ovl_stack_put(ovl_lowerstack(oi->oe), ovl_numlower(oi->oe));
 191         if (S_ISDIR(inode->i_mode))
 192                 ovl_dir_cache_free(inode);
 193         else
 194                 kfree(oi->lowerdata_redirect);
 195 }
 196
 197 static void ovl_put_super(struct super_block *sb)
 198 {
 199         struct ovl_fs *ofs = OVL_FS(sb);
 200
 201         if (ofs)
 202                 ovl_free_fs(ofs);
 203 }
 204
 205 /* Sync real dirty inodes in upper filesystem (if it exists) */
 206 static int ovl_sync_fs(struct super_block *sb, int wait)
 207 {
 208         struct ovl_fs *ofs = OVL_FS(sb);
 209         struct super_block *upper_sb;
 210         int ret;
 211
 212         ret = ovl_sync_status(ofs);
 213         /*
 214          * We have to always set the err, because the return value isn't
 215          * checked in syncfs, and instead indirectly return an error via
 216          * the sb's writeback errseq, which VFS inspects after this call.
 217          */
 218         if (ret < 0) {
 219                 errseq_set(&sb->s_wb_err, -EIO);
 220                 return -EIO;
 221         }
 222
 223         if (!ret)
 224                 return ret;
 225
 226         /*
 227          * Not called for sync(2) call or an emergency sync (SB_I_SKIP_SYNC).
 228          * All the super blocks will be iterated, including upper_sb.
 229          *
 230          * If this is a syncfs(2) call, then we do need to call
 231          * sync_filesystem() on upper_sb, but enough if we do it when being
 232          * called with wait == 1.
 233          */
 234         if (!wait)
 235                 return 0;
 236
 237         upper_sb = ovl_upper_mnt(ofs)->mnt_sb;
 238
 239         down_read(&upper_sb->s_umount);
 240         ret = sync_filesystem(upper_sb);
 241         up_read(&upper_sb->s_umount);
 242
 243         return ret;
 244 }
 245
 246 /**
 247  * ovl_statfs
 248  * @dentry: The dentry to query
 249  * @buf: The struct kstatfs to fill in with stats
 250  *
 251  * Get the filesystem statistics.  As writes always target the upper layer
 252  * filesystem pass the statfs to the upper filesystem (if it exists)
 253  */
 254 static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf)
 255 {
 256         struct super_block *sb = dentry->d_sb;
 257         struct ovl_fs *ofs = OVL_FS(sb);
 258         struct dentry *root_dentry = sb->s_root;
 259         struct path path;
 260         int err;
 261
 262         ovl_path_real(root_dentry, &path);
 263
 264         err = vfs_statfs(&path, buf);
 265         if (!err) {
 266                 buf->f_namelen = ofs->namelen;
 267                 buf->f_type = OVERLAYFS_SUPER_MAGIC;
 268                 if (ovl_has_fsid(ofs))
 269                         buf->f_fsid = uuid_to_fsid(sb->s_uuid.b);
 270         }
 271
 272         return err;
 273 }
 274
 275 static const struct super_operations ovl_super_operations = {
 276         .alloc_inode    = ovl_alloc_inode,
 277         .free_inode     = ovl_free_inode,
 278         .destroy_inode  = ovl_destroy_inode,
 279         .drop_inode     = generic_delete_inode,
 280         .put_super      = ovl_put_super,
 281         .sync_fs        = ovl_sync_fs,
 282         .statfs         = ovl_statfs,
 283         .show_options   = ovl_show_options,
 284 };
 285
 286 #define OVL_WORKDIR_NAME "work"
 287 #define OVL_INDEXDIR_NAME "index"
 288
 289 static struct dentry *ovl_workdir_create(struct ovl_fs *ofs,
 290                                          const char *name, bool persist)
 291 {
 292         struct inode *dir =  ofs->workbasedir->d_inode;
 293         struct vfsmount *mnt = ovl_upper_mnt(ofs);
 294         struct dentry *work;
 295         int err;
 296         bool retried = false;
 297
 298         inode_lock_nested(dir, I_MUTEX_PARENT);
 299 retry:
 300         work = ovl_lookup_upper(ofs, name, ofs->workbasedir, strlen(name));
 301
 302         if (!IS_ERR(work)) {
 303                 struct iattr attr = {
 304                         .ia_valid = ATTR_MODE,
 305                         .ia_mode = S_IFDIR | 0,
 306                 };
 307
 308                 if (work->d_inode) {
 309                         err = -EEXIST;
 310                         if (retried)
 311                                 goto out_dput;
 312
 313                         if (persist)
 314                                 goto out_unlock;
 315
 316                         retried = true;
 317                         err = ovl_workdir_cleanup(ofs, dir, mnt, work, 0);
 318                         dput(work);
 319                         if (err == -EINVAL) {
 320                                 work = ERR_PTR(err);
 321                                 goto out_unlock;
 322                         }
 323                         goto retry;
 324                 }
 325
 326                 err = ovl_mkdir_real(ofs, dir, &work, attr.ia_mode);
 327                 if (err)
 328                         goto out_dput;
 329
 330                 /* Weird filesystem returning with hashed negative (kernfs)? */
 331                 err = -EINVAL;
 332                 if (d_really_is_negative(work))
 333                         goto out_dput;
 334
 335                 /*
 336                  * Try to remove POSIX ACL xattrs from workdir.  We are good if:
 337                  *
 338                  * a) success (there was a POSIX ACL xattr and was removed)
 339                  * b) -ENODATA (there was no POSIX ACL xattr)
 340                  * c) -EOPNOTSUPP (POSIX ACL xattrs are not supported)
 341                  *
 342                  * There are various other error values that could effectively
 343                  * mean that the xattr doesn't exist (e.g. -ERANGE is returned
 344                  * if the xattr name is too long), but the set of filesystems
 345                  * allowed as upper are limited to "normal" ones, where checking
 346                  * for the above two errors is sufficient.
 347                  */
 348                 err = ovl_do_remove_acl(ofs, work, XATTR_NAME_POSIX_ACL_DEFAULT);
 349                 if (err && err != -ENODATA && err != -EOPNOTSUPP)
 350                         goto out_dput;
 351
 352                 err = ovl_do_remove_acl(ofs, work, XATTR_NAME_POSIX_ACL_ACCESS);
 353                 if (err && err != -ENODATA && err != -EOPNOTSUPP)
 354                         goto out_dput;
 355
 356                 /* Clear any inherited mode bits */
 357                 inode_lock(work->d_inode);
 358                 err = ovl_do_notify_change(ofs, work, &attr);
 359                 inode_unlock(work->d_inode);
 360                 if (err)
 361                         goto out_dput;
 362         } else {
 363                 err = PTR_ERR(work);
 364                 goto out_err;
 365         }
 366 out_unlock:
 367         inode_unlock(dir);
 368         return work;
 369
 370 out_dput:
 371         dput(work);
 372 out_err:
 373         pr_warn("failed to create directory %s/%s (errno: %i); mounting read-only\n",
 374                 ofs->config.workdir, name, -err);
 375         work = NULL;
 376         goto out_unlock;
 377 }
 378
 379 static int ovl_check_namelen(const struct path *path, struct ovl_fs *ofs,
 380                              const char *name)
 381 {
 382         struct kstatfs statfs;
 383         int err = vfs_statfs(path, &statfs);
 384
 385         if (err)
 386                 pr_err("statfs failed on '%s'\n", name);
 387         else
 388                 ofs->namelen = max(ofs->namelen, statfs.f_namelen);
 389
 390         return err;
 391 }
 392
 393 static int ovl_lower_dir(const char *name, struct path *path,
 394                          struct ovl_fs *ofs, int *stack_depth)
 395 {
 396         int fh_type;
 397         int err;
 398
 399         err = ovl_check_namelen(path, ofs, name);
 400         if (err)
 401                 return err;
 402
 403         *stack_depth = max(*stack_depth, path->mnt->mnt_sb->s_stack_depth);
 404
 405         /*
 406          * The inodes index feature and NFS export need to encode and decode
 407          * file handles, so they require that all layers support them.
 408          */
 409         fh_type = ovl_can_decode_fh(path->dentry->d_sb);
 410         if ((ofs->config.nfs_export ||
 411              (ofs->config.index && ofs->config.upperdir)) && !fh_type) {
 412                 ofs->config.index = false;
 413                 ofs->config.nfs_export = false;
 414                 pr_warn("fs on '%s' does not support file handles, falling back to index=off,nfs_export=off.\n",
 415                         name);
 416         }
 417         ofs->nofh |= !fh_type;
 418         /*
 419          * Decoding origin file handle is required for persistent st_ino.
 420          * Without persistent st_ino, xino=auto falls back to xino=off.
 421          */
 422         if (ofs->config.xino == OVL_XINO_AUTO &&
 423             ofs->config.upperdir && !fh_type) {
 424                 ofs->config.xino = OVL_XINO_OFF;
 425                 pr_warn("fs on '%s' does not support file handles, falling back to xino=off.\n",
 426                         name);
 427         }
 428
 429         /* Check if lower fs has 32bit inode numbers */
 430         if (fh_type != FILEID_INO32_GEN)
 431                 ofs->xino_mode = -1;
 432
 433         return 0;
 434 }
 435
 436 /* Workdir should not be subdir of upperdir and vice versa */
 437 static bool ovl_workdir_ok(struct dentry *workdir, struct dentry *upperdir)
 438 {
 439         bool ok = false;
 440
 441         if (workdir != upperdir) {
 442                 ok = (lock_rename(workdir, upperdir) == NULL);
 443                 unlock_rename(workdir, upperdir);
 444         }
 445         return ok;
 446 }
 447
 448 static int ovl_own_xattr_get(const struct xattr_handler *handler,
 449                              struct dentry *dentry, struct inode *inode,
 450                              const char *name, void *buffer, size_t size)
 451 {
 452         return -EOPNOTSUPP;
 453 }
 454
 455 static int ovl_own_xattr_set(const struct xattr_handler *handler,
 456                              struct mnt_idmap *idmap,
 457                              struct dentry *dentry, struct inode *inode,
 458                              const char *name, const void *value,
 459                              size_t size, int flags)
 460 {
 461         return -EOPNOTSUPP;
 462 }
 463
 464 static int ovl_other_xattr_get(const struct xattr_handler *handler,
 465                                struct dentry *dentry, struct inode *inode,
 466                                const char *name, void *buffer, size_t size)
 467 {
 468         return ovl_xattr_get(dentry, inode, name, buffer, size);
 469 }
 470
 471 static int ovl_other_xattr_set(const struct xattr_handler *handler,
 472                                struct mnt_idmap *idmap,
 473                                struct dentry *dentry, struct inode *inode,
 474                                const char *name, const void *value,
 475                                size_t size, int flags)
 476 {
 477         return ovl_xattr_set(dentry, inode, name, value, size, flags);
 478 }
 479
 480 static const struct xattr_handler ovl_own_trusted_xattr_handler = {
 481         .prefix = OVL_XATTR_TRUSTED_PREFIX,
 482         .get = ovl_own_xattr_get,
 483         .set = ovl_own_xattr_set,
 484 };
 485
 486 static const struct xattr_handler ovl_own_user_xattr_handler = {
 487         .prefix = OVL_XATTR_USER_PREFIX,
 488         .get = ovl_own_xattr_get,
 489         .set = ovl_own_xattr_set,
 490 };
 491
 492 static const struct xattr_handler ovl_other_xattr_handler = {
 493         .prefix = "", /* catch all */
 494         .get = ovl_other_xattr_get,
 495         .set = ovl_other_xattr_set,
 496 };
 497
 498 static const struct xattr_handler * const ovl_trusted_xattr_handlers[] = {
 499         &ovl_own_trusted_xattr_handler,
 500         &ovl_other_xattr_handler,
 501         NULL
 502 };
 503
 504 static const struct xattr_handler * const ovl_user_xattr_handlers[] = {
 505         &ovl_own_user_xattr_handler,
 506         &ovl_other_xattr_handler,
 507         NULL
 508 };
 509
 510 static int ovl_setup_trap(struct super_block *sb, struct dentry *dir,
 511                           struct inode **ptrap, const char *name)
 512 {
 513         struct inode *trap;
 514         int err;
 515
 516         trap = ovl_get_trap_inode(sb, dir);
 517         err = PTR_ERR_OR_ZERO(trap);
 518         if (err) {
 519                 if (err == -ELOOP)
 520                         pr_err("conflicting %s path\n", name);
 521                 return err;
 522         }
 523
 524         *ptrap = trap;
 525         return 0;
 526 }
 527
 528 /*
 529  * Determine how we treat concurrent use of upperdir/workdir based on the
 530  * index feature. This is papering over mount leaks of container runtimes,
 531  * for example, an old overlay mount is leaked and now its upperdir is
 532  * attempted to be used as a lower layer in a new overlay mount.
 533  */
 534 static int ovl_report_in_use(struct ovl_fs *ofs, const char *name)
 535 {
 536         if (ofs->config.index) {
 537                 pr_err("%s is in-use as upperdir/workdir of another mount, mount with '-o index=off' to override exclusive upperdir protection.\n",
 538                        name);
 539                 return -EBUSY;
 540         } else {
 541                 pr_warn("%s is in-use as upperdir/workdir of another mount, accessing files from both mounts will result in undefined behavior.\n",
 542                         name);
 543                 return 0;
 544         }
 545 }
 546
 547 static int ovl_get_upper(struct super_block *sb, struct ovl_fs *ofs,
 548                          struct ovl_layer *upper_layer,
 549                          const struct path *upperpath)
 550 {
 551         struct vfsmount *upper_mnt;
 552         int err;
 553
 554         /* Upperdir path should not be r/o */
 555         if (__mnt_is_readonly(upperpath->mnt)) {
 556                 pr_err("upper fs is r/o, try multi-lower layers mount\n");
 557                 err = -EINVAL;
 558                 goto out;
 559         }
 560
 561         err = ovl_check_namelen(upperpath, ofs, ofs->config.upperdir);
 562         if (err)
 563                 goto out;
 564
 565         err = ovl_setup_trap(sb, upperpath->dentry, &upper_layer->trap,
 566                              "upperdir");
 567         if (err)
 568                 goto out;
 569
 570         upper_mnt = clone_private_mount(upperpath);
 571         err = PTR_ERR(upper_mnt);
 572         if (IS_ERR(upper_mnt)) {
 573                 pr_err("failed to clone upperpath\n");
 574                 goto out;
 575         }
 576
 577         /* Don't inherit atime flags */
 578         upper_mnt->mnt_flags &= ~(MNT_NOATIME | MNT_NODIRATIME | MNT_RELATIME);
 579         upper_layer->mnt = upper_mnt;
 580         upper_layer->idx = 0;
 581         upper_layer->fsid = 0;
 582
 583         /*
 584          * Inherit SB_NOSEC flag from upperdir.
 585          *
 586          * This optimization changes behavior when a security related attribute
 587          * (suid/sgid/security.*) is changed on an underlying layer.  This is
 588          * okay because we don't yet have guarantees in that case, but it will
 589          * need careful treatment once we want to honour changes to underlying
 590          * filesystems.
 591          */
 592         if (upper_mnt->mnt_sb->s_flags & SB_NOSEC)
 593                 sb->s_flags |= SB_NOSEC;
 594
 595         if (ovl_inuse_trylock(ovl_upper_mnt(ofs)->mnt_root)) {
 596                 ofs->upperdir_locked = true;
 597         } else {
 598                 err = ovl_report_in_use(ofs, "upperdir");
 599                 if (err)
 600                         goto out;
 601         }
 602
 603         err = 0;
 604 out:
 605         return err;
 606 }
 607
 608 /*
 609  * Returns 1 if RENAME_WHITEOUT is supported, 0 if not supported and
 610  * negative values if error is encountered.
 611  */
 612 static int ovl_check_rename_whiteout(struct ovl_fs *ofs)
 613 {
 614         struct dentry *workdir = ofs->workdir;
 615         struct inode *dir = d_inode(workdir);
 616         struct dentry *temp;
 617         struct dentry *dest;
 618         struct dentry *whiteout;
 619         struct name_snapshot name;
 620         int err;
 621
 622         inode_lock_nested(dir, I_MUTEX_PARENT);
 623
 624         temp = ovl_create_temp(ofs, workdir, OVL_CATTR(S_IFREG | 0));
 625         err = PTR_ERR(temp);
 626         if (IS_ERR(temp))
 627                 goto out_unlock;
 628
 629         dest = ovl_lookup_temp(ofs, workdir);
 630         err = PTR_ERR(dest);
 631         if (IS_ERR(dest)) {
 632                 dput(temp);
 633                 goto out_unlock;
 634         }
 635
 636         /* Name is inline and stable - using snapshot as a copy helper */
 637         take_dentry_name_snapshot(&name, temp);
 638         err = ovl_do_rename(ofs, dir, temp, dir, dest, RENAME_WHITEOUT);
 639         if (err) {
 640                 if (err == -EINVAL)
 641                         err = 0;
 642                 goto cleanup_temp;
 643         }
 644
 645         whiteout = ovl_lookup_upper(ofs, name.name.name, workdir, name.name.len);
 646         err = PTR_ERR(whiteout);
 647         if (IS_ERR(whiteout))
 648                 goto cleanup_temp;
 649
 650         err = ovl_is_whiteout(whiteout);
 651
 652         /* Best effort cleanup of whiteout and temp file */
 653         if (err)
 654                 ovl_cleanup(ofs, dir, whiteout);
 655         dput(whiteout);
 656
 657 cleanup_temp:
 658         ovl_cleanup(ofs, dir, temp);
 659         release_dentry_name_snapshot(&name);
 660         dput(temp);
 661         dput(dest);
 662
 663 out_unlock:
 664         inode_unlock(dir);
 665
 666         return err;
 667 }
 668
 669 static struct dentry *ovl_lookup_or_create(struct ovl_fs *ofs,
 670                                            struct dentry *parent,
 671                                            const char *name, umode_t mode)
 672 {
 673         size_t len = strlen(name);
 674         struct dentry *child;
 675
 676         inode_lock_nested(parent->d_inode, I_MUTEX_PARENT);
 677         child = ovl_lookup_upper(ofs, name, parent, len);
 678         if (!IS_ERR(child) && !child->d_inode)
 679                 child = ovl_create_real(ofs, parent->d_inode, child,
 680                                         OVL_CATTR(mode));
 681         inode_unlock(parent->d_inode);
 682         dput(parent);
 683
 684         return child;
 685 }
 686
 687 /*
 688  * Creates $workdir/work/incompat/volatile/dirty file if it is not already
 689  * present.
 690  */
 691 static int ovl_create_volatile_dirty(struct ovl_fs *ofs)
 692 {
 693         unsigned int ctr;
 694         struct dentry *d = dget(ofs->workbasedir);
 695         static const char *const volatile_path[] = {
 696                 OVL_WORKDIR_NAME, "incompat", "volatile", "dirty"
 697         };
 698         const char *const *name = volatile_path;
 699
 700         for (ctr = ARRAY_SIZE(volatile_path); ctr; ctr--, name++) {
 701                 d = ovl_lookup_or_create(ofs, d, *name, ctr > 1 ? S_IFDIR : S_IFREG);
 702                 if (IS_ERR(d))
 703                         return PTR_ERR(d);
 704         }
 705         dput(d);
 706         return 0;
 707 }
 708
 709 static int ovl_make_workdir(struct super_block *sb, struct ovl_fs *ofs,
 710                             const struct path *workpath)
 711 {
 712         struct vfsmount *mnt = ovl_upper_mnt(ofs);
 713         struct dentry *workdir;
 714         struct file *tmpfile;
 715         bool rename_whiteout;
 716         bool d_type;
 717         int fh_type;
 718         int err;
 719
 720         err = mnt_want_write(mnt);
 721         if (err)
 722                 return err;
 723
 724         workdir = ovl_workdir_create(ofs, OVL_WORKDIR_NAME, false);
 725         err = PTR_ERR(workdir);
 726         if (IS_ERR_OR_NULL(workdir))
 727                 goto out;
 728
 729         ofs->workdir = workdir;
 730
 731         err = ovl_setup_trap(sb, ofs->workdir, &ofs->workdir_trap, "workdir");
 732         if (err)
 733                 goto out;
 734
 735         /*
 736          * Upper should support d_type, else whiteouts are visible.  Given
 737          * workdir and upper are on same fs, we can do iterate_dir() on
 738          * workdir. This check requires successful creation of workdir in
 739          * previous step.
 740          */
 741         err = ovl_check_d_type_supported(workpath);
 742         if (err < 0)
 743                 goto out;
 744
 745         d_type = err;
 746         if (!d_type)
 747                 pr_warn("upper fs needs to support d_type.\n");
 748
 749         /* Check if upper/work fs supports O_TMPFILE */
 750         tmpfile = ovl_do_tmpfile(ofs, ofs->workdir, S_IFREG | 0);
 751         ofs->tmpfile = !IS_ERR(tmpfile);
 752         if (ofs->tmpfile)
 753                 fput(tmpfile);
 754         else
 755                 pr_warn("upper fs does not support tmpfile.\n");
 756
 757
 758         /* Check if upper/work fs supports RENAME_WHITEOUT */
 759         err = ovl_check_rename_whiteout(ofs);
 760         if (err < 0)
 761                 goto out;
 762
 763         rename_whiteout = err;
 764         if (!rename_whiteout)
 765                 pr_warn("upper fs does not support RENAME_WHITEOUT.\n");
 766
 767         /*
 768          * Check if upper/work fs supports (trusted|user).overlay.* xattr
 769          */
 770         err = ovl_setxattr(ofs, ofs->workdir, OVL_XATTR_OPAQUE, "0", 1);
 771         if (err) {
 772                 pr_warn("failed to set xattr on upper\n");
 773                 ofs->noxattr = true;
 774                 if (ovl_redirect_follow(ofs)) {
 775                         ofs->config.redirect_mode = OVL_REDIRECT_NOFOLLOW;
 776                         pr_warn("...falling back to redirect_dir=nofollow.\n");
 777                 }
 778                 if (ofs->config.metacopy) {
 779                         ofs->config.metacopy = false;
 780                         pr_warn("...falling back to metacopy=off.\n");
 781                 }
 782                 if (ofs->config.index) {
 783                         ofs->config.index = false;
 784                         pr_warn("...falling back to index=off.\n");
 785                 }
 786                 if (ovl_has_fsid(ofs)) {
 787                         ofs->config.uuid = OVL_UUID_NULL;
 788                         pr_warn("...falling back to uuid=null.\n");
 789                 }
 790                 /*
 791                  * xattr support is required for persistent st_ino.
 792                  * Without persistent st_ino, xino=auto falls back to xino=off.
 793                  */
 794                 if (ofs->config.xino == OVL_XINO_AUTO) {
 795                         ofs->config.xino = OVL_XINO_OFF;
 796                         pr_warn("...falling back to xino=off.\n");
 797                 }
 798                 if (err == -EPERM && !ofs->config.userxattr)
 799                         pr_info("try mounting with 'userxattr' option\n");
 800                 err = 0;
 801         } else {
 802                 ovl_removexattr(ofs, ofs->workdir, OVL_XATTR_OPAQUE);
 803         }
 804
 805         /*
 806          * We allowed sub-optimal upper fs configuration and don't want to break
 807          * users over kernel upgrade, but we never allowed remote upper fs, so
 808          * we can enforce strict requirements for remote upper fs.
 809          */
 810         if (ovl_dentry_remote(ofs->workdir) &&
 811             (!d_type || !rename_whiteout || ofs->noxattr)) {
 812                 pr_err("upper fs missing required features.\n");
 813                 err = -EINVAL;
 814                 goto out;
 815         }
 816
 817         /*
 818          * For volatile mount, create a incompat/volatile/dirty file to keep
 819          * track of it.
 820          */
 821         if (ofs->config.ovl_volatile) {
 822                 err = ovl_create_volatile_dirty(ofs);
 823                 if (err < 0) {
 824                         pr_err("Failed to create volatile/dirty file.\n");
 825                         goto out;
 826                 }
 827         }
 828
 829         /* Check if upper/work fs supports file handles */
 830         fh_type = ovl_can_decode_fh(ofs->workdir->d_sb);
 831         if (ofs->config.index && !fh_type) {
 832                 ofs->config.index = false;
 833                 pr_warn("upper fs does not support file handles, falling back to index=off.\n");
 834         }
 835         ofs->nofh |= !fh_type;
 836
 837         /* Check if upper fs has 32bit inode numbers */
 838         if (fh_type != FILEID_INO32_GEN)
 839                 ofs->xino_mode = -1;
 840
 841         /* NFS export of r/w mount depends on index */
 842         if (ofs->config.nfs_export && !ofs->config.index) {
 843                 pr_warn("NFS export requires \"index=on\", falling back to nfs_export=off.\n");
 844                 ofs->config.nfs_export = false;
 845         }
 846 out:
 847         mnt_drop_write(mnt);
 848         return err;
 849 }
 850
 851 static int ovl_get_workdir(struct super_block *sb, struct ovl_fs *ofs,
 852                            const struct path *upperpath,
 853                            const struct path *workpath)
 854 {
 855         int err;
 856
 857         err = -EINVAL;
 858         if (upperpath->mnt != workpath->mnt) {
 859                 pr_err("workdir and upperdir must reside under the same mount\n");
 860                 return err;
 861         }
 862         if (!ovl_workdir_ok(workpath->dentry, upperpath->dentry)) {
 863                 pr_err("workdir and upperdir must be separate subtrees\n");
 864                 return err;
 865         }
 866
 867         ofs->workbasedir = dget(workpath->dentry);
 868
 869         if (ovl_inuse_trylock(ofs->workbasedir)) {
 870                 ofs->workdir_locked = true;
 871         } else {
 872                 err = ovl_report_in_use(ofs, "workdir");
 873                 if (err)
 874                         return err;
 875         }
 876
 877         err = ovl_setup_trap(sb, ofs->workbasedir, &ofs->workbasedir_trap,
 878                              "workdir");
 879         if (err)
 880                 return err;
 881
 882         return ovl_make_workdir(sb, ofs, workpath);
 883 }
 884
 885 static int ovl_get_indexdir(struct super_block *sb, struct ovl_fs *ofs,
 886                             struct ovl_entry *oe, const struct path *upperpath)
 887 {
 888         struct vfsmount *mnt = ovl_upper_mnt(ofs);
 889         struct dentry *indexdir;
 890         int err;
 891
 892         err = mnt_want_write(mnt);
 893         if (err)
 894                 return err;
 895
 896         /* Verify lower root is upper root origin */
 897         err = ovl_verify_origin(ofs, upperpath->dentry,
 898                                 ovl_lowerstack(oe)->dentry, true);
 899         if (err) {
 900                 pr_err("failed to verify upper root origin\n");
 901                 goto out;
 902         }
 903
 904         /* index dir will act also as workdir */
 905         iput(ofs->workdir_trap);
 906         ofs->workdir_trap = NULL;
 907         dput(ofs->workdir);
 908         ofs->workdir = NULL;
 909         indexdir = ovl_workdir_create(ofs, OVL_INDEXDIR_NAME, true);
 910         if (IS_ERR(indexdir)) {
 911                 err = PTR_ERR(indexdir);
 912         } else if (indexdir) {
 913                 ofs->indexdir = indexdir;
 914                 ofs->workdir = dget(indexdir);
 915
 916                 err = ovl_setup_trap(sb, ofs->indexdir, &ofs->indexdir_trap,
 917                                      "indexdir");
 918                 if (err)
 919                         goto out;
 920
 921                 /*
 922                  * Verify upper root is exclusively associated with index dir.
 923                  * Older kernels stored upper fh in ".overlay.origin"
 924                  * xattr. If that xattr exists, verify that it is a match to
 925                  * upper dir file handle. In any case, verify or set xattr
 926                  * ".overlay.upper" to indicate that index may have
 927                  * directory entries.
 928                  */
 929                 if (ovl_check_origin_xattr(ofs, ofs->indexdir)) {
 930                         err = ovl_verify_set_fh(ofs, ofs->indexdir,
 931                                                 OVL_XATTR_ORIGIN,
 932                                                 upperpath->dentry, true, false);
 933                         if (err)
 934                                 pr_err("failed to verify index dir 'origin' xattr\n");
 935                 }
 936                 err = ovl_verify_upper(ofs, ofs->indexdir, upperpath->dentry,
 937                                        true);
 938                 if (err)
 939                         pr_err("failed to verify index dir 'upper' xattr\n");
 940
 941                 /* Cleanup bad/stale/orphan index entries */
 942                 if (!err)
 943                         err = ovl_indexdir_cleanup(ofs);
 944         }
 945         if (err || !ofs->indexdir)
 946                 pr_warn("try deleting index dir or mounting with '-o index=off' to disable inodes index.\n");
 947
 948 out:
 949         mnt_drop_write(mnt);
 950         return err;
 951 }
 952
 953 static bool ovl_lower_uuid_ok(struct ovl_fs *ofs, const uuid_t *uuid)
 954 {
 955         unsigned int i;
 956
 957         if (!ofs->config.nfs_export && !ovl_upper_mnt(ofs))
 958                 return true;
 959
 960         /*
 961          * We allow using single lower with null uuid for index and nfs_export
 962          * for example to support those features with single lower squashfs.
 963          * To avoid regressions in setups of overlay with re-formatted lower
 964          * squashfs, do not allow decoding origin with lower null uuid unless
 965          * user opted-in to one of the new features that require following the
 966          * lower inode of non-dir upper.
 967          */
 968         if (ovl_allow_offline_changes(ofs) && uuid_is_null(uuid))
 969                 return false;
 970
 971         for (i = 0; i < ofs->numfs; i++) {
 972                 /*
 973                  * We use uuid to associate an overlay lower file handle with a
 974                  * lower layer, so we can accept lower fs with null uuid as long
 975                  * as all lower layers with null uuid are on the same fs.
 976                  * if we detect multiple lower fs with the same uuid, we
 977                  * disable lower file handle decoding on all of them.
 978                  */
 979                 if (ofs->fs[i].is_lower &&
 980                     uuid_equal(&ofs->fs[i].sb->s_uuid, uuid)) {
 981                         ofs->fs[i].bad_uuid = true;
 982                         return false;
 983                 }
 984         }
 985         return true;
 986 }
 987
 988 /* Get a unique fsid for the layer */
 989 static int ovl_get_fsid(struct ovl_fs *ofs, const struct path *path)
 990 {
 991         struct super_block *sb = path->mnt->mnt_sb;
 992         unsigned int i;
 993         dev_t dev;
 994         int err;
 995         bool bad_uuid = false;
 996         bool warn = false;
 997
 998         for (i = 0; i < ofs->numfs; i++) {
 999                 if (ofs->fs[i].sb == sb)
1000                         return i;
1001         }
1002
1003         if (!ovl_lower_uuid_ok(ofs, &sb->s_uuid)) {
1004                 bad_uuid = true;
1005                 if (ofs->config.xino == OVL_XINO_AUTO) {
1006                         ofs->config.xino = OVL_XINO_OFF;
1007                         warn = true;
1008                 }
1009                 if (ofs->config.index || ofs->config.nfs_export) {
1010                         ofs->config.index = false;
1011                         ofs->config.nfs_export = false;
1012                         warn = true;
1013                 }
1014                 if (warn) {
1015                         pr_warn("%s uuid detected in lower fs '%pd2', falling back to xino=%s,index=off,nfs_export=off.\n",
1016                                 uuid_is_null(&sb->s_uuid) ? "null" :
1017                                                             "conflicting",
1018                                 path->dentry, ovl_xino_mode(&ofs->config));
1019                 }
1020         }
1021
1022         err = get_anon_bdev(&dev);
1023         if (err) {
1024                 pr_err("failed to get anonymous bdev for lowerpath\n");
1025                 return err;
1026         }
1027
1028         ofs->fs[ofs->numfs].sb = sb;
1029         ofs->fs[ofs->numfs].pseudo_dev = dev;
1030         ofs->fs[ofs->numfs].bad_uuid = bad_uuid;
1031
1032         return ofs->numfs++;
1033 }
1034
1035 /*
1036  * The fsid after the last lower fsid is used for the data layers.
1037  * It is a "null fs" with a null sb, null uuid, and no pseudo dev.
1038  */
1039 static int ovl_get_data_fsid(struct ovl_fs *ofs)
1040 {
1041         return ofs->numfs;
1042 }
1043
1044
1045 static int ovl_get_layers(struct super_block *sb, struct ovl_fs *ofs,
1046                           struct ovl_fs_context *ctx, struct ovl_layer *layers)
1047 {
1048         int err;
1049         unsigned int i;
1050         size_t nr_merged_lower;
1051
1052         ofs->fs = kcalloc(ctx->nr + 2, sizeof(struct ovl_sb), GFP_KERNEL);
1053         if (ofs->fs == NULL)
1054                 return -ENOMEM;
1055
1056         /*
1057          * idx/fsid 0 are reserved for upper fs even with lower only overlay
1058          * and the last fsid is reserved for "null fs" of the data layers.
1059          */
1060         ofs->numfs++;
1061
1062         /*
1063          * All lower layers that share the same fs as upper layer, use the same
1064          * pseudo_dev as upper layer.  Allocate fs[0].pseudo_dev even for lower
1065          * only overlay to simplify ovl_fs_free().
1066          * is_lower will be set if upper fs is shared with a lower layer.
1067          */
1068         err = get_anon_bdev(&ofs->fs[0].pseudo_dev);
1069         if (err) {
1070                 pr_err("failed to get anonymous bdev for upper fs\n");
1071                 return err;
1072         }
1073
1074         if (ovl_upper_mnt(ofs)) {
1075                 ofs->fs[0].sb = ovl_upper_mnt(ofs)->mnt_sb;
1076                 ofs->fs[0].is_lower = false;
1077         }
1078
1079         nr_merged_lower = ctx->nr - ctx->nr_data;
1080         for (i = 0; i < ctx->nr; i++) {
1081                 struct ovl_fs_context_layer *l = &ctx->lower[i];
1082                 struct vfsmount *mnt;
1083                 struct inode *trap;
1084                 int fsid;
1085
1086                 if (i < nr_merged_lower)
1087                         fsid = ovl_get_fsid(ofs, &l->path);
1088                 else
1089                         fsid = ovl_get_data_fsid(ofs);
1090                 if (fsid < 0)
1091                         return fsid;
1092
1093                 /*
1094                  * Check if lower root conflicts with this overlay layers before
1095                  * checking if it is in-use as upperdir/workdir of "another"
1096                  * mount, because we do not bother to check in ovl_is_inuse() if
1097                  * the upperdir/workdir is in fact in-use by our
1098                  * upperdir/workdir.
1099                  */
1100                 err = ovl_setup_trap(sb, l->path.dentry, &trap, "lowerdir");
1101                 if (err)
1102                         return err;
1103
1104                 if (ovl_is_inuse(l->path.dentry)) {
1105                         err = ovl_report_in_use(ofs, "lowerdir");
1106                         if (err) {
1107                                 iput(trap);
1108                                 return err;
1109                         }
1110                 }
1111
1112                 mnt = clone_private_mount(&l->path);
1113                 err = PTR_ERR(mnt);
1114                 if (IS_ERR(mnt)) {
1115                         pr_err("failed to clone lowerpath\n");
1116                         iput(trap);
1117                         return err;
1118                 }
1119
1120                 /*
1121                  * Make lower layers R/O.  That way fchmod/fchown on lower file
1122                  * will fail instead of modifying lower fs.
1123                  */
1124                 mnt->mnt_flags |= MNT_READONLY | MNT_NOATIME;
1125
1126                 layers[ofs->numlayer].trap = trap;
1127                 layers[ofs->numlayer].mnt = mnt;
1128                 layers[ofs->numlayer].idx = ofs->numlayer;
1129                 layers[ofs->numlayer].fsid = fsid;
1130                 layers[ofs->numlayer].fs = &ofs->fs[fsid];
1131                 /* Store for printing lowerdir=... in ovl_show_options() */
1132                 ofs->config.lowerdirs[ofs->numlayer] = l->name;
1133                 l->name = NULL;
1134                 ofs->numlayer++;
1135                 ofs->fs[fsid].is_lower = true;
1136         }
1137
1138         /*
1139          * When all layers on same fs, overlay can use real inode numbers.
1140          * With mount option "xino=<on|auto>", mounter declares that there are
1141          * enough free high bits in underlying fs to hold the unique fsid.
1142          * If overlayfs does encounter underlying inodes using the high xino
1143          * bits reserved for fsid, it emits a warning and uses the original
1144          * inode number or a non persistent inode number allocated from a
1145          * dedicated range.
1146          */
1147         if (ofs->numfs - !ovl_upper_mnt(ofs) == 1) {
1148                 if (ofs->config.xino == OVL_XINO_ON)
1149                         pr_info("\"xino=on\" is useless with all layers on same fs, ignore.\n");
1150                 ofs->xino_mode = 0;
1151         } else if (ofs->config.xino == OVL_XINO_OFF) {
1152                 ofs->xino_mode = -1;
1153         } else if (ofs->xino_mode < 0) {
1154                 /*
1155                  * This is a roundup of number of bits needed for encoding
1156                  * fsid, where fsid 0 is reserved for upper fs (even with
1157                  * lower only overlay) +1 extra bit is reserved for the non
1158                  * persistent inode number range that is used for resolving
1159                  * xino lower bits overflow.
1160                  */
1161                 BUILD_BUG_ON(ilog2(OVL_MAX_STACK) > 30);
1162                 ofs->xino_mode = ilog2(ofs->numfs - 1) + 2;
1163         }
1164
1165         if (ofs->xino_mode > 0) {
1166                 pr_info("\"xino\" feature enabled using %d upper inode bits.\n",
1167                         ofs->xino_mode);
1168         }
1169
1170         return 0;
1171 }
1172
1173 static struct ovl_entry *ovl_get_lowerstack(struct super_block *sb,
1174                                             struct ovl_fs_context *ctx,
1175                                             struct ovl_fs *ofs,
1176                                             struct ovl_layer *layers)
1177 {
1178         int err;
1179         unsigned int i;
1180         size_t nr_merged_lower;
1181         struct ovl_entry *oe;
1182         struct ovl_path *lowerstack;
1183
1184         struct ovl_fs_context_layer *l;
1185
1186         if (!ofs->config.upperdir && ctx->nr == 1) {
1187                 pr_err("at least 2 lowerdir are needed while upperdir nonexistent\n");
1188                 return ERR_PTR(-EINVAL);
1189         }
1190
1191         err = -EINVAL;
1192         for (i = 0; i < ctx->nr; i++) {
1193                 l = &ctx->lower[i];
1194
1195                 err = ovl_lower_dir(l->name, &l->path, ofs, &sb->s_stack_depth);
1196                 if (err)
1197                         return ERR_PTR(err);
1198         }
1199
1200         err = -EINVAL;
1201         sb->s_stack_depth++;
1202         if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) {
1203                 pr_err("maximum fs stacking depth exceeded\n");
1204                 return ERR_PTR(err);
1205         }
1206
1207         err = ovl_get_layers(sb, ofs, ctx, layers);
1208         if (err)
1209                 return ERR_PTR(err);
1210
1211         err = -ENOMEM;
1212         /* Data-only layers are not merged in root directory */
1213         nr_merged_lower = ctx->nr - ctx->nr_data;
1214         oe = ovl_alloc_entry(nr_merged_lower);
1215         if (!oe)
1216                 return ERR_PTR(err);
1217
1218         lowerstack = ovl_lowerstack(oe);
1219         for (i = 0; i < nr_merged_lower; i++) {
1220                 l = &ctx->lower[i];
1221                 lowerstack[i].dentry = dget(l->path.dentry);
1222                 lowerstack[i].layer = &ofs->layers[i + 1];
1223         }
1224         ofs->numdatalayer = ctx->nr_data;
1225
1226         return oe;
1227 }
1228
1229 /*
1230  * Check if this layer root is a descendant of:
1231  * - another layer of this overlayfs instance
1232  * - upper/work dir of any overlayfs instance
1233  */
1234 static int ovl_check_layer(struct super_block *sb, struct ovl_fs *ofs,
1235                            struct dentry *dentry, const char *name,
1236                            bool is_lower)
1237 {
1238         struct dentry *next = dentry, *parent;
1239         int err = 0;
1240
1241         if (!dentry)
1242                 return 0;
1243
1244         parent = dget_parent(next);
1245
1246         /* Walk back ancestors to root (inclusive) looking for traps */
1247         while (!err && parent != next) {
1248                 if (is_lower && ovl_lookup_trap_inode(sb, parent)) {
1249                         err = -ELOOP;
1250                         pr_err("overlapping %s path\n", name);
1251                 } else if (ovl_is_inuse(parent)) {
1252                         err = ovl_report_in_use(ofs, name);
1253                 }
1254                 next = parent;
1255                 parent = dget_parent(next);
1256                 dput(next);
1257         }
1258
1259         dput(parent);
1260
1261         return err;
1262 }
1263
1264 /*
1265  * Check if any of the layers or work dirs overlap.
1266  */
1267 static int ovl_check_overlapping_layers(struct super_block *sb,
1268                                         struct ovl_fs *ofs)
1269 {
1270         int i, err;
1271
1272         if (ovl_upper_mnt(ofs)) {
1273                 err = ovl_check_layer(sb, ofs, ovl_upper_mnt(ofs)->mnt_root,
1274                                       "upperdir", false);
1275                 if (err)
1276                         return err;
1277
1278                 /*
1279                  * Checking workbasedir avoids hitting ovl_is_inuse(parent) of
1280                  * this instance and covers overlapping work and index dirs,
1281                  * unless work or index dir have been moved since created inside
1282                  * workbasedir.  In that case, we already have their traps in
1283                  * inode cache and we will catch that case on lookup.
1284                  */
1285                 err = ovl_check_layer(sb, ofs, ofs->workbasedir, "workdir",
1286                                       false);
1287                 if (err)
1288                         return err;
1289         }
1290
1291         for (i = 1; i < ofs->numlayer; i++) {
1292                 err = ovl_check_layer(sb, ofs,
1293                                       ofs->layers[i].mnt->mnt_root,
1294                                       "lowerdir", true);
1295                 if (err)
1296                         return err;
1297         }
1298
1299         return 0;
1300 }
1301
1302 static struct dentry *ovl_get_root(struct super_block *sb,
1303                                    struct dentry *upperdentry,
1304                                    struct ovl_entry *oe)
1305 {
1306         struct dentry *root;
1307         struct ovl_path *lowerpath = ovl_lowerstack(oe);
1308         unsigned long ino = d_inode(lowerpath->dentry)->i_ino;
1309         int fsid = lowerpath->layer->fsid;
1310         struct ovl_inode_params oip = {
1311                 .upperdentry = upperdentry,
1312                 .oe = oe,
1313         };
1314
1315         root = d_make_root(ovl_new_inode(sb, S_IFDIR, 0));
1316         if (!root)
1317                 return NULL;
1318
1319         if (upperdentry) {
1320                 /* Root inode uses upper st_ino/i_ino */
1321                 ino = d_inode(upperdentry)->i_ino;
1322                 fsid = 0;
1323                 ovl_dentry_set_upper_alias(root);
1324                 if (ovl_is_impuredir(sb, upperdentry))
1325                         ovl_set_flag(OVL_IMPURE, d_inode(root));
1326         }
1327
1328         /* Root is always merge -> can have whiteouts */
1329         ovl_set_flag(OVL_WHITEOUTS, d_inode(root));
1330         ovl_dentry_set_flag(OVL_E_CONNECTED, root);
1331         ovl_set_upperdata(d_inode(root));
1332         ovl_inode_init(d_inode(root), &oip, ino, fsid);
1333         ovl_dentry_init_flags(root, upperdentry, oe, DCACHE_OP_WEAK_REVALIDATE);
1334         /* root keeps a reference of upperdentry */
1335         dget(upperdentry);
1336
1337         return root;
1338 }
1339
1340 int ovl_fill_super(struct super_block *sb, struct fs_context *fc)
1341 {
1342         struct ovl_fs *ofs = sb->s_fs_info;
1343         struct ovl_fs_context *ctx = fc->fs_private;
1344         struct dentry *root_dentry;
1345         struct ovl_entry *oe;
1346         struct ovl_layer *layers;
1347         struct cred *cred;
1348         int err;
1349
1350         err = -EIO;
1351         if (WARN_ON(fc->user_ns != current_user_ns()))
1352                 goto out_err;
1353
1354         sb->s_d_op = &ovl_dentry_operations;
1355
1356         err = -ENOMEM;
1357         ofs->creator_cred = cred = prepare_creds();
1358         if (!cred)
1359                 goto out_err;
1360
1361         err = ovl_fs_params_verify(ctx, &ofs->config);
1362         if (err)
1363                 goto out_err;
1364
1365         err = -EINVAL;
1366         if (ctx->nr == 0) {
1367                 if (!(fc->sb_flags & SB_SILENT))
1368                         pr_err("missing 'lowerdir'\n");
1369                 goto out_err;
1370         }
1371
1372         err = -ENOMEM;
1373         layers = kcalloc(ctx->nr + 1, sizeof(struct ovl_layer), GFP_KERNEL);
1374         if (!layers)
1375                 goto out_err;
1376
1377         ofs->config.lowerdirs = kcalloc(ctx->nr + 1, sizeof(char *), GFP_KERNEL);
1378         if (!ofs->config.lowerdirs) {
1379                 kfree(layers);
1380                 goto out_err;
1381         }
1382         ofs->layers = layers;
1383         /*
1384          * Layer 0 is reserved for upper even if there's no upper.
1385          * For consistency, config.lowerdirs[0] is NULL.
1386          */
1387         ofs->numlayer = 1;
1388
1389         sb->s_stack_depth = 0;
1390         sb->s_maxbytes = MAX_LFS_FILESIZE;
1391         atomic_long_set(&ofs->last_ino, 1);
1392         /* Assume underlying fs uses 32bit inodes unless proven otherwise */
1393         if (ofs->config.xino != OVL_XINO_OFF) {
1394                 ofs->xino_mode = BITS_PER_LONG - 32;
1395                 if (!ofs->xino_mode) {
1396                         pr_warn("xino not supported on 32bit kernel, falling back to xino=off.\n");
1397                         ofs->config.xino = OVL_XINO_OFF;
1398                 }
1399         }
1400
1401         /* alloc/destroy_inode needed for setting up traps in inode cache */
1402         sb->s_op = &ovl_super_operations;
1403
1404         if (ofs->config.upperdir) {
1405                 struct super_block *upper_sb;
1406
1407                 err = -EINVAL;
1408                 if (!ofs->config.workdir) {
1409                         pr_err("missing 'workdir'\n");
1410                         goto out_err;
1411                 }
1412
1413                 err = ovl_get_upper(sb, ofs, &layers[0], &ctx->upper);
1414                 if (err)
1415                         goto out_err;
1416
1417                 upper_sb = ovl_upper_mnt(ofs)->mnt_sb;
1418                 if (!ovl_should_sync(ofs)) {
1419                         ofs->errseq = errseq_sample(&upper_sb->s_wb_err);
1420                         if (errseq_check(&upper_sb->s_wb_err, ofs->errseq)) {
1421                                 err = -EIO;
1422                                 pr_err("Cannot mount volatile when upperdir has an unseen error. Sync upperdir fs to clear state.\n");
1423                                 goto out_err;
1424                         }
1425                 }
1426
1427                 err = ovl_get_workdir(sb, ofs, &ctx->upper, &ctx->work);
1428                 if (err)
1429                         goto out_err;
1430
1431                 if (!ofs->workdir)
1432                         sb->s_flags |= SB_RDONLY;
1433
1434                 sb->s_stack_depth = upper_sb->s_stack_depth;
1435                 sb->s_time_gran = upper_sb->s_time_gran;
1436         }
1437         oe = ovl_get_lowerstack(sb, ctx, ofs, layers);
1438         err = PTR_ERR(oe);
1439         if (IS_ERR(oe))
1440                 goto out_err;
1441
1442         /* If the upper fs is nonexistent, we mark overlayfs r/o too */
1443         if (!ovl_upper_mnt(ofs))
1444                 sb->s_flags |= SB_RDONLY;
1445
1446         if (!ovl_origin_uuid(ofs) && ofs->numfs > 1) {
1447                 pr_warn("The uuid=off requires a single fs for lower and upper, falling back to uuid=null.\n");
1448                 ofs->config.uuid = OVL_UUID_NULL;
1449         } else if (ovl_has_fsid(ofs) && ovl_upper_mnt(ofs)) {
1450                 /* Use per instance persistent uuid/fsid */
1451                 ovl_init_uuid_xattr(sb, ofs, &ctx->upper);
1452         }
1453
1454         if (!ovl_force_readonly(ofs) && ofs->config.index) {
1455                 err = ovl_get_indexdir(sb, ofs, oe, &ctx->upper);
1456                 if (err)
1457                         goto out_free_oe;
1458
1459                 /* Force r/o mount with no index dir */
1460                 if (!ofs->indexdir)
1461                         sb->s_flags |= SB_RDONLY;
1462         }
1463
1464         err = ovl_check_overlapping_layers(sb, ofs);
1465         if (err)
1466                 goto out_free_oe;
1467
1468         /* Show index=off in /proc/mounts for forced r/o mount */
1469         if (!ofs->indexdir) {
1470                 ofs->config.index = false;
1471                 if (ovl_upper_mnt(ofs) && ofs->config.nfs_export) {
1472                         pr_warn("NFS export requires an index dir, falling back to nfs_export=off.\n");
1473                         ofs->config.nfs_export = false;
1474                 }
1475         }
1476
1477         if (ofs->config.metacopy && ofs->config.nfs_export) {
1478                 pr_warn("NFS export is not supported with metadata only copy up, falling back to nfs_export=off.\n");
1479                 ofs->config.nfs_export = false;
1480         }
1481
1482         /*
1483          * Support encoding decodable file handles with nfs_export=on
1484          * and encoding non-decodable file handles with nfs_export=off
1485          * if all layers support file handles.
1486          */
1487         if (ofs->config.nfs_export)
1488                 sb->s_export_op = &ovl_export_operations;
1489         else if (!ofs->nofh)
1490                 sb->s_export_op = &ovl_export_fid_operations;
1491
1492         /* Never override disk quota limits or use reserved space */
1493         cap_lower(cred->cap_effective, CAP_SYS_RESOURCE);
1494
1495         sb->s_magic = OVERLAYFS_SUPER_MAGIC;
1496         sb->s_xattr = ofs->config.userxattr ? ovl_user_xattr_handlers :
1497                 ovl_trusted_xattr_handlers;
1498         sb->s_fs_info = ofs;
1499 #ifdef CONFIG_FS_POSIX_ACL
1500         sb->s_flags |= SB_POSIXACL;
1501 #endif
1502         sb->s_iflags |= SB_I_SKIP_SYNC;
1503         /*
1504          * Ensure that umask handling is done by the filesystems used
1505          * for the the upper layer instead of overlayfs as that would
1506          * lead to unexpected results.
1507          */
1508         sb->s_iflags |= SB_I_NOUMASK;
1509
1510         err = -ENOMEM;
1511         root_dentry = ovl_get_root(sb, ctx->upper.dentry, oe);
1512         if (!root_dentry)
1513                 goto out_free_oe;
1514
1515         sb->s_root = root_dentry;
1516
1517         return 0;
1518
1519 out_free_oe:
1520         ovl_free_entry(oe);
1521 out_err:
1522         ovl_free_fs(ofs);
1523         sb->s_fs_info = NULL;
1524         return err;
1525 }
1526
1527 struct file_system_type ovl_fs_type = {
1528         .owner                  = THIS_MODULE,
1529         .name                   = "overlay",
1530         .init_fs_context        = ovl_init_fs_context,
1531         .parameters             = ovl_parameter_spec,
1532         .fs_flags               = FS_USERNS_MOUNT,
1533         .kill_sb                = kill_anon_super,
1534 };
1535 MODULE_ALIAS_FS("overlay");
1536
1537 static void ovl_inode_init_once(void *foo)
1538 {
1539         struct ovl_inode *oi = foo;
1540
1541         inode_init_once(&oi->vfs_inode);
1542 }
1543
1544 static int __init ovl_init(void)
1545 {
1546         int err;
1547
1548         ovl_inode_cachep = kmem_cache_create("ovl_inode",
1549                                              sizeof(struct ovl_inode), 0,
1550                                              (SLAB_RECLAIM_ACCOUNT|
1551                                               SLAB_MEM_SPREAD|SLAB_ACCOUNT),
1552                                              ovl_inode_init_once);
1553         if (ovl_inode_cachep == NULL)
1554                 return -ENOMEM;
1555
1556         err = ovl_aio_request_cache_init();
1557         if (!err) {
1558                 err = register_filesystem(&ovl_fs_type);
1559                 if (!err)
1560                         return 0;
1561
1562                 ovl_aio_request_cache_destroy();
1563         }
1564         kmem_cache_destroy(ovl_inode_cachep);
1565
1566         return err;
1567 }
1568
1569 static void __exit ovl_exit(void)
1570 {
1571         unregister_filesystem(&ovl_fs_type);
1572
1573         /*
1574          * Make sure all delayed rcu free inodes are flushed before we
1575          * destroy cache.
1576          */
1577         rcu_barrier();
1578         kmem_cache_destroy(ovl_inode_cachep);
1579         ovl_aio_request_cache_destroy();
1580 }
1581
1582 module_init(ovl_init);
1583 module_exit(ovl_exit);