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