fs/overlayfs/super.c

   1 /*
   2  *
   3  * Copyright (C) 2011 Novell Inc.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 as published by
   7  * the Free Software Foundation.
   8  */
   9
  10 #include <linux/fs.h>
  11 #include <linux/namei.h>
  12 #include <linux/xattr.h>
  13 #include <linux/security.h>
  14 #include <linux/mount.h>
  15 #include <linux/slab.h>
  16 #include <linux/parser.h>
  17 #include <linux/module.h>
  18 #include <linux/sched.h>
  19 #include <linux/statfs.h>
  20 #include <linux/seq_file.h>
  21 #include "overlayfs.h"
  22
  23 MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>");
  24 MODULE_DESCRIPTION("Overlay filesystem");
  25 MODULE_LICENSE("GPL");
  26
  27 #define OVERLAYFS_SUPER_MAGIC 0x794c764f
  28
  29 struct ovl_config {
  30         char *lowerdir;
  31         char *upperdir;
  32         char *workdir;
  33 };
  34
  35 /* private information held for overlayfs's superblock */
  36 struct ovl_fs {
  37         struct vfsmount *upper_mnt;
  38         struct vfsmount *lower_mnt;
  39         struct dentry *workdir;
  40         long lower_namelen;
  41         /* pathnames of lower and upper dirs, for show_options */
  42         struct ovl_config config;
  43 };
  44
  45 struct ovl_dir_cache;
  46
  47 /* private information held for every overlayfs dentry */
  48 struct ovl_entry {
  49         struct dentry *__upperdentry;
  50         struct dentry *lowerdentry;
  51         struct ovl_dir_cache *cache;
  52         union {
  53                 struct {
  54                         u64 version;
  55                         bool opaque;
  56                 };
  57                 struct rcu_head rcu;
  58         };
  59 };
  60
  61 const char *ovl_opaque_xattr = "trusted.overlay.opaque";
  62
  63
  64 enum ovl_path_type ovl_path_type(struct dentry *dentry)
  65 {
  66         struct ovl_entry *oe = dentry->d_fsdata;
  67
  68         if (oe->__upperdentry) {
  69                 if (oe->lowerdentry) {
  70                         if (S_ISDIR(dentry->d_inode->i_mode))
  71                                 return OVL_PATH_MERGE;
  72                         else
  73                                 return OVL_PATH_UPPER;
  74                 } else {
  75                         if (oe->opaque)
  76                                 return OVL_PATH_UPPER;
  77                         else
  78                                 return OVL_PATH_PURE_UPPER;
  79                 }
  80         } else {
  81                 return OVL_PATH_LOWER;
  82         }
  83 }
  84
  85 static struct dentry *ovl_upperdentry_dereference(struct ovl_entry *oe)
  86 {
  87         struct dentry *upperdentry = ACCESS_ONCE(oe->__upperdentry);
  88         /*
  89          * Make sure to order reads to upperdentry wrt ovl_dentry_update()
  90          */
  91         smp_read_barrier_depends();
  92         return upperdentry;
  93 }
  94
  95 void ovl_path_upper(struct dentry *dentry, struct path *path)
  96 {
  97         struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
  98         struct ovl_entry *oe = dentry->d_fsdata;
  99
 100         path->mnt = ofs->upper_mnt;
 101         path->dentry = ovl_upperdentry_dereference(oe);
 102 }
 103
 104 enum ovl_path_type ovl_path_real(struct dentry *dentry, struct path *path)
 105 {
 106
 107         enum ovl_path_type type = ovl_path_type(dentry);
 108
 109         if (type == OVL_PATH_LOWER)
 110                 ovl_path_lower(dentry, path);
 111         else
 112                 ovl_path_upper(dentry, path);
 113
 114         return type;
 115 }
 116
 117 struct dentry *ovl_dentry_upper(struct dentry *dentry)
 118 {
 119         struct ovl_entry *oe = dentry->d_fsdata;
 120
 121         return ovl_upperdentry_dereference(oe);
 122 }
 123
 124 struct dentry *ovl_dentry_lower(struct dentry *dentry)
 125 {
 126         struct ovl_entry *oe = dentry->d_fsdata;
 127
 128         return oe->lowerdentry;
 129 }
 130
 131 struct dentry *ovl_dentry_real(struct dentry *dentry)
 132 {
 133         struct ovl_entry *oe = dentry->d_fsdata;
 134         struct dentry *realdentry;
 135
 136         realdentry = ovl_upperdentry_dereference(oe);
 137         if (!realdentry)
 138                 realdentry = oe->lowerdentry;
 139
 140         return realdentry;
 141 }
 142
 143 struct dentry *ovl_entry_real(struct ovl_entry *oe, bool *is_upper)
 144 {
 145         struct dentry *realdentry;
 146
 147         realdentry = ovl_upperdentry_dereference(oe);
 148         if (realdentry) {
 149                 *is_upper = true;
 150         } else {
 151                 realdentry = oe->lowerdentry;
 152                 *is_upper = false;
 153         }
 154         return realdentry;
 155 }
 156
 157 struct ovl_dir_cache *ovl_dir_cache(struct dentry *dentry)
 158 {
 159         struct ovl_entry *oe = dentry->d_fsdata;
 160
 161         return oe->cache;
 162 }
 163
 164 void ovl_set_dir_cache(struct dentry *dentry, struct ovl_dir_cache *cache)
 165 {
 166         struct ovl_entry *oe = dentry->d_fsdata;
 167
 168         oe->cache = cache;
 169 }
 170
 171 void ovl_path_lower(struct dentry *dentry, struct path *path)
 172 {
 173         struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
 174         struct ovl_entry *oe = dentry->d_fsdata;
 175
 176         path->mnt = ofs->lower_mnt;
 177         path->dentry = oe->lowerdentry;
 178 }
 179
 180 int ovl_want_write(struct dentry *dentry)
 181 {
 182         struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
 183         return mnt_want_write(ofs->upper_mnt);
 184 }
 185
 186 void ovl_drop_write(struct dentry *dentry)
 187 {
 188         struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
 189         mnt_drop_write(ofs->upper_mnt);
 190 }
 191
 192 struct dentry *ovl_workdir(struct dentry *dentry)
 193 {
 194         struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
 195         return ofs->workdir;
 196 }
 197
 198 bool ovl_dentry_is_opaque(struct dentry *dentry)
 199 {
 200         struct ovl_entry *oe = dentry->d_fsdata;
 201         return oe->opaque;
 202 }
 203
 204 void ovl_dentry_set_opaque(struct dentry *dentry, bool opaque)
 205 {
 206         struct ovl_entry *oe = dentry->d_fsdata;
 207         oe->opaque = opaque;
 208 }
 209
 210 void ovl_dentry_update(struct dentry *dentry, struct dentry *upperdentry)
 211 {
 212         struct ovl_entry *oe = dentry->d_fsdata;
 213
 214         WARN_ON(!mutex_is_locked(&upperdentry->d_parent->d_inode->i_mutex));
 215         WARN_ON(oe->__upperdentry);
 216         BUG_ON(!upperdentry->d_inode);
 217         /*
 218          * Make sure upperdentry is consistent before making it visible to
 219          * ovl_upperdentry_dereference().
 220          */
 221         smp_wmb();
 222         oe->__upperdentry = upperdentry;
 223 }
 224
 225 void ovl_dentry_version_inc(struct dentry *dentry)
 226 {
 227         struct ovl_entry *oe = dentry->d_fsdata;
 228
 229         WARN_ON(!mutex_is_locked(&dentry->d_inode->i_mutex));
 230         oe->version++;
 231 }
 232
 233 u64 ovl_dentry_version_get(struct dentry *dentry)
 234 {
 235         struct ovl_entry *oe = dentry->d_fsdata;
 236
 237         WARN_ON(!mutex_is_locked(&dentry->d_inode->i_mutex));
 238         return oe->version;
 239 }
 240
 241 bool ovl_is_whiteout(struct dentry *dentry)
 242 {
 243         struct inode *inode = dentry->d_inode;
 244
 245         return inode && IS_WHITEOUT(inode);
 246 }
 247
 248 static bool ovl_is_opaquedir(struct dentry *dentry)
 249 {
 250         int res;
 251         char val;
 252         struct inode *inode = dentry->d_inode;
 253
 254         if (!S_ISDIR(inode->i_mode) || !inode->i_op->getxattr)
 255                 return false;
 256
 257         res = inode->i_op->getxattr(dentry, ovl_opaque_xattr, &val, 1);
 258         if (res == 1 && val == 'y')
 259                 return true;
 260
 261         return false;
 262 }
 263
 264 static void ovl_dentry_release(struct dentry *dentry)
 265 {
 266         struct ovl_entry *oe = dentry->d_fsdata;
 267
 268         if (oe) {
 269                 dput(oe->__upperdentry);
 270                 dput(oe->lowerdentry);
 271                 kfree_rcu(oe, rcu);
 272         }
 273 }
 274
 275 static const struct dentry_operations ovl_dentry_operations = {
 276         .d_release = ovl_dentry_release,
 277 };
 278
 279 static struct ovl_entry *ovl_alloc_entry(void)
 280 {
 281         return kzalloc(sizeof(struct ovl_entry), GFP_KERNEL);
 282 }
 283
 284 static inline struct dentry *ovl_lookup_real(struct dentry *dir,
 285                                              struct qstr *name)
 286 {
 287         struct dentry *dentry;
 288
 289         mutex_lock(&dir->d_inode->i_mutex);
 290         dentry = lookup_one_len(name->name, dir, name->len);
 291         mutex_unlock(&dir->d_inode->i_mutex);
 292
 293         if (IS_ERR(dentry)) {
 294                 if (PTR_ERR(dentry) == -ENOENT)
 295                         dentry = NULL;
 296         } else if (!dentry->d_inode) {
 297                 dput(dentry);
 298                 dentry = NULL;
 299         }
 300         return dentry;
 301 }
 302
 303 struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry,
 304                           unsigned int flags)
 305 {
 306         struct ovl_entry *oe;
 307         struct dentry *upperdir;
 308         struct dentry *lowerdir;
 309         struct dentry *upperdentry = NULL;
 310         struct dentry *lowerdentry = NULL;
 311         struct inode *inode = NULL;
 312         int err;
 313
 314         err = -ENOMEM;
 315         oe = ovl_alloc_entry();
 316         if (!oe)
 317                 goto out;
 318
 319         upperdir = ovl_dentry_upper(dentry->d_parent);
 320         lowerdir = ovl_dentry_lower(dentry->d_parent);
 321
 322         if (upperdir) {
 323                 upperdentry = ovl_lookup_real(upperdir, &dentry->d_name);
 324                 err = PTR_ERR(upperdentry);
 325                 if (IS_ERR(upperdentry))
 326                         goto out_put_dir;
 327
 328                 if (lowerdir && upperdentry) {
 329                         if (ovl_is_whiteout(upperdentry)) {
 330                                 dput(upperdentry);
 331                                 upperdentry = NULL;
 332                                 oe->opaque = true;
 333                         } else if (ovl_is_opaquedir(upperdentry)) {
 334                                 oe->opaque = true;
 335                         }
 336                 }
 337         }
 338         if (lowerdir && !oe->opaque) {
 339                 lowerdentry = ovl_lookup_real(lowerdir, &dentry->d_name);
 340                 err = PTR_ERR(lowerdentry);
 341                 if (IS_ERR(lowerdentry))
 342                         goto out_dput_upper;
 343         }
 344
 345         if (lowerdentry && upperdentry &&
 346             (!S_ISDIR(upperdentry->d_inode->i_mode) ||
 347              !S_ISDIR(lowerdentry->d_inode->i_mode))) {
 348                 dput(lowerdentry);
 349                 lowerdentry = NULL;
 350                 oe->opaque = true;
 351         }
 352
 353         if (lowerdentry || upperdentry) {
 354                 struct dentry *realdentry;
 355
 356                 realdentry = upperdentry ? upperdentry : lowerdentry;
 357                 err = -ENOMEM;
 358                 inode = ovl_new_inode(dentry->d_sb, realdentry->d_inode->i_mode,
 359                                       oe);
 360                 if (!inode)
 361                         goto out_dput;
 362                 ovl_copyattr(realdentry->d_inode, inode);
 363         }
 364
 365         oe->__upperdentry = upperdentry;
 366         oe->lowerdentry = lowerdentry;
 367
 368         dentry->d_fsdata = oe;
 369         d_add(dentry, inode);
 370
 371         return NULL;
 372
 373 out_dput:
 374         dput(lowerdentry);
 375 out_dput_upper:
 376         dput(upperdentry);
 377 out_put_dir:
 378         kfree(oe);
 379 out:
 380         return ERR_PTR(err);
 381 }
 382
 383 struct file *ovl_path_open(struct path *path, int flags)
 384 {
 385         return dentry_open(path, flags, current_cred());
 386 }
 387
 388 static void ovl_put_super(struct super_block *sb)
 389 {
 390         struct ovl_fs *ufs = sb->s_fs_info;
 391
 392         dput(ufs->workdir);
 393         mntput(ufs->upper_mnt);
 394         mntput(ufs->lower_mnt);
 395
 396         kfree(ufs->config.lowerdir);
 397         kfree(ufs->config.upperdir);
 398         kfree(ufs->config.workdir);
 399         kfree(ufs);
 400 }
 401
 402 /**
 403  * ovl_statfs
 404  * @sb: The overlayfs super block
 405  * @buf: The struct kstatfs to fill in with stats
 406  *
 407  * Get the filesystem statistics.  As writes always target the upper layer
 408  * filesystem pass the statfs to the same filesystem.
 409  */
 410 static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf)
 411 {
 412         struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
 413         struct dentry *root_dentry = dentry->d_sb->s_root;
 414         struct path path;
 415         int err;
 416
 417         ovl_path_upper(root_dentry, &path);
 418
 419         err = vfs_statfs(&path, buf);
 420         if (!err) {
 421                 buf->f_namelen = max(buf->f_namelen, ofs->lower_namelen);
 422                 buf->f_type = OVERLAYFS_SUPER_MAGIC;
 423         }
 424
 425         return err;
 426 }
 427
 428 /**
 429  * ovl_show_options
 430  *
 431  * Prints the mount options for a given superblock.
 432  * Returns zero; does not fail.
 433  */
 434 static int ovl_show_options(struct seq_file *m, struct dentry *dentry)
 435 {
 436         struct super_block *sb = dentry->d_sb;
 437         struct ovl_fs *ufs = sb->s_fs_info;
 438
 439         seq_printf(m, ",lowerdir=%s", ufs->config.lowerdir);
 440         seq_printf(m, ",upperdir=%s", ufs->config.upperdir);
 441         seq_printf(m, ",workdir=%s", ufs->config.workdir);
 442         return 0;
 443 }
 444
 445 static const struct super_operations ovl_super_operations = {
 446         .put_super      = ovl_put_super,
 447         .statfs         = ovl_statfs,
 448         .show_options   = ovl_show_options,
 449 };
 450
 451 enum {
 452         OPT_LOWERDIR,
 453         OPT_UPPERDIR,
 454         OPT_WORKDIR,
 455         OPT_ERR,
 456 };
 457
 458 static const match_table_t ovl_tokens = {
 459         {OPT_LOWERDIR,                  "lowerdir=%s"},
 460         {OPT_UPPERDIR,                  "upperdir=%s"},
 461         {OPT_WORKDIR,                   "workdir=%s"},
 462         {OPT_ERR,                       NULL}
 463 };
 464
 465 static int ovl_parse_opt(char *opt, struct ovl_config *config)
 466 {
 467         char *p;
 468
 469         while ((p = strsep(&opt, ",")) != NULL) {
 470                 int token;
 471                 substring_t args[MAX_OPT_ARGS];
 472
 473                 if (!*p)
 474                         continue;
 475
 476                 token = match_token(p, ovl_tokens, args);
 477                 switch (token) {
 478                 case OPT_UPPERDIR:
 479                         kfree(config->upperdir);
 480                         config->upperdir = match_strdup(&args[0]);
 481                         if (!config->upperdir)
 482                                 return -ENOMEM;
 483                         break;
 484
 485                 case OPT_LOWERDIR:
 486                         kfree(config->lowerdir);
 487                         config->lowerdir = match_strdup(&args[0]);
 488                         if (!config->lowerdir)
 489                                 return -ENOMEM;
 490                         break;
 491
 492                 case OPT_WORKDIR:
 493                         kfree(config->workdir);
 494                         config->workdir = match_strdup(&args[0]);
 495                         if (!config->workdir)
 496                                 return -ENOMEM;
 497                         break;
 498
 499                 default:
 500                         return -EINVAL;
 501                 }
 502         }
 503         return 0;
 504 }
 505
 506 #define OVL_WORKDIR_NAME "work"
 507
 508 static struct dentry *ovl_workdir_create(struct vfsmount *mnt,
 509                                          struct dentry *dentry)
 510 {
 511         struct inode *dir = dentry->d_inode;
 512         struct dentry *work;
 513         int err;
 514         bool retried = false;
 515
 516         err = mnt_want_write(mnt);
 517         if (err)
 518                 return ERR_PTR(err);
 519
 520         mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
 521 retry:
 522         work = lookup_one_len(OVL_WORKDIR_NAME, dentry,
 523                               strlen(OVL_WORKDIR_NAME));
 524
 525         if (!IS_ERR(work)) {
 526                 struct kstat stat = {
 527                         .mode = S_IFDIR | 0,
 528                 };
 529
 530                 if (work->d_inode) {
 531                         err = -EEXIST;
 532                         if (retried)
 533                                 goto out_dput;
 534
 535                         retried = true;
 536                         ovl_cleanup(dir, work);
 537                         dput(work);
 538                         goto retry;
 539                 }
 540
 541                 err = ovl_create_real(dir, work, &stat, NULL, NULL, true);
 542                 if (err)
 543                         goto out_dput;
 544         }
 545 out_unlock:
 546         mutex_unlock(&dir->i_mutex);
 547         mnt_drop_write(mnt);
 548
 549         return work;
 550
 551 out_dput:
 552         dput(work);
 553         work = ERR_PTR(err);
 554         goto out_unlock;
 555 }
 556
 557 static int ovl_mount_dir(const char *name, struct path *path)
 558 {
 559         int err;
 560
 561         err = kern_path(name, LOOKUP_FOLLOW, path);
 562         if (err) {
 563                 pr_err("overlayfs: failed to resolve '%s': %i\n", name, err);
 564                 err = -EINVAL;
 565         }
 566         return err;
 567 }
 568
 569 static bool ovl_is_allowed_fs_type(struct dentry *root)
 570 {
 571         const struct dentry_operations *dop = root->d_op;
 572
 573         /*
 574          * We don't support:
 575          *  - automount filesystems
 576          *  - filesystems with revalidate (FIXME for lower layer)
 577          *  - filesystems with case insensitive names
 578          */
 579         if (dop &&
 580             (dop->d_manage || dop->d_automount ||
 581              dop->d_revalidate || dop->d_weak_revalidate ||
 582              dop->d_compare || dop->d_hash)) {
 583                 return false;
 584         }
 585         return true;
 586 }
 587
 588 /* Workdir should not be subdir of upperdir and vice versa */
 589 static bool ovl_workdir_ok(struct dentry *workdir, struct dentry *upperdir)
 590 {
 591         bool ok = false;
 592
 593         if (workdir != upperdir) {
 594                 ok = (lock_rename(workdir, upperdir) == NULL);
 595                 unlock_rename(workdir, upperdir);
 596         }
 597         return ok;
 598 }
 599
 600 static int ovl_fill_super(struct super_block *sb, void *data, int silent)
 601 {
 602         struct path lowerpath;
 603         struct path upperpath;
 604         struct path workpath;
 605         struct inode *root_inode;
 606         struct dentry *root_dentry;
 607         struct ovl_entry *oe;
 608         struct ovl_fs *ufs;
 609         struct kstatfs statfs;
 610         int err;
 611
 612         err = -ENOMEM;
 613         ufs = kzalloc(sizeof(struct ovl_fs), GFP_KERNEL);
 614         if (!ufs)
 615                 goto out;
 616
 617         err = ovl_parse_opt((char *) data, &ufs->config);
 618         if (err)
 619                 goto out_free_config;
 620
 621         /* FIXME: workdir is not needed for a R/O mount */
 622         err = -EINVAL;
 623         if (!ufs->config.upperdir || !ufs->config.lowerdir ||
 624             !ufs->config.workdir) {
 625                 pr_err("overlayfs: missing upperdir or lowerdir or workdir\n");
 626                 goto out_free_config;
 627         }
 628
 629         err = -ENOMEM;
 630         oe = ovl_alloc_entry();
 631         if (oe == NULL)
 632                 goto out_free_config;
 633
 634         err = ovl_mount_dir(ufs->config.upperdir, &upperpath);
 635         if (err)
 636                 goto out_free_oe;
 637
 638         err = ovl_mount_dir(ufs->config.lowerdir, &lowerpath);
 639         if (err)
 640                 goto out_put_upperpath;
 641
 642         err = ovl_mount_dir(ufs->config.workdir, &workpath);
 643         if (err)
 644                 goto out_put_lowerpath;
 645
 646         err = -EINVAL;
 647         if (!S_ISDIR(upperpath.dentry->d_inode->i_mode) ||
 648             !S_ISDIR(lowerpath.dentry->d_inode->i_mode) ||
 649             !S_ISDIR(workpath.dentry->d_inode->i_mode)) {
 650                 pr_err("overlayfs: upperdir or lowerdir or workdir not a directory\n");
 651                 goto out_put_workpath;
 652         }
 653
 654         if (upperpath.mnt != workpath.mnt) {
 655                 pr_err("overlayfs: workdir and upperdir must reside under the same mount\n");
 656                 goto out_put_workpath;
 657         }
 658         if (!ovl_workdir_ok(workpath.dentry, upperpath.dentry)) {
 659                 pr_err("overlayfs: workdir and upperdir must be separate subtrees\n");
 660                 goto out_put_workpath;
 661         }
 662
 663         if (!ovl_is_allowed_fs_type(upperpath.dentry)) {
 664                 pr_err("overlayfs: filesystem of upperdir is not supported\n");
 665                 goto out_put_workpath;
 666         }
 667
 668         if (!ovl_is_allowed_fs_type(lowerpath.dentry)) {
 669                 pr_err("overlayfs: filesystem of lowerdir is not supported\n");
 670                 goto out_put_workpath;
 671         }
 672
 673         err = vfs_statfs(&lowerpath, &statfs);
 674         if (err) {
 675                 pr_err("overlayfs: statfs failed on lowerpath\n");
 676                 goto out_put_workpath;
 677         }
 678         ufs->lower_namelen = statfs.f_namelen;
 679
 680         sb->s_stack_depth = max(upperpath.mnt->mnt_sb->s_stack_depth,
 681                                 lowerpath.mnt->mnt_sb->s_stack_depth) + 1;
 682
 683         err = -EINVAL;
 684         if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) {
 685                 pr_err("overlayfs: maximum fs stacking depth exceeded\n");
 686                 goto out_put_workpath;
 687         }
 688
 689         ufs->upper_mnt = clone_private_mount(&upperpath);
 690         err = PTR_ERR(ufs->upper_mnt);
 691         if (IS_ERR(ufs->upper_mnt)) {
 692                 pr_err("overlayfs: failed to clone upperpath\n");
 693                 goto out_put_workpath;
 694         }
 695
 696         ufs->lower_mnt = clone_private_mount(&lowerpath);
 697         err = PTR_ERR(ufs->lower_mnt);
 698         if (IS_ERR(ufs->lower_mnt)) {
 699                 pr_err("overlayfs: failed to clone lowerpath\n");
 700                 goto out_put_upper_mnt;
 701         }
 702
 703         ufs->workdir = ovl_workdir_create(ufs->upper_mnt, workpath.dentry);
 704         err = PTR_ERR(ufs->workdir);
 705         if (IS_ERR(ufs->workdir)) {
 706                 pr_err("overlayfs: failed to create directory %s/%s\n",
 707                        ufs->config.workdir, OVL_WORKDIR_NAME);
 708                 goto out_put_lower_mnt;
 709         }
 710
 711         /*
 712          * Make lower_mnt R/O.  That way fchmod/fchown on lower file
 713          * will fail instead of modifying lower fs.
 714          */
 715         ufs->lower_mnt->mnt_flags |= MNT_READONLY;
 716
 717         /* If the upper fs is r/o, we mark overlayfs r/o too */
 718         if (ufs->upper_mnt->mnt_sb->s_flags & MS_RDONLY)
 719                 sb->s_flags |= MS_RDONLY;
 720
 721         sb->s_d_op = &ovl_dentry_operations;
 722
 723         err = -ENOMEM;
 724         root_inode = ovl_new_inode(sb, S_IFDIR, oe);
 725         if (!root_inode)
 726                 goto out_put_workdir;
 727
 728         root_dentry = d_make_root(root_inode);
 729         if (!root_dentry)
 730                 goto out_put_workdir;
 731
 732         mntput(upperpath.mnt);
 733         mntput(lowerpath.mnt);
 734         path_put(&workpath);
 735
 736         oe->__upperdentry = upperpath.dentry;
 737         oe->lowerdentry = lowerpath.dentry;
 738
 739         root_dentry->d_fsdata = oe;
 740
 741         sb->s_magic = OVERLAYFS_SUPER_MAGIC;
 742         sb->s_op = &ovl_super_operations;
 743         sb->s_root = root_dentry;
 744         sb->s_fs_info = ufs;
 745
 746         return 0;
 747
 748 out_put_workdir:
 749         dput(ufs->workdir);
 750 out_put_lower_mnt:
 751         mntput(ufs->lower_mnt);
 752 out_put_upper_mnt:
 753         mntput(ufs->upper_mnt);
 754 out_put_workpath:
 755         path_put(&workpath);
 756 out_put_lowerpath:
 757         path_put(&lowerpath);
 758 out_put_upperpath:
 759         path_put(&upperpath);
 760 out_free_oe:
 761         kfree(oe);
 762 out_free_config:
 763         kfree(ufs->config.lowerdir);
 764         kfree(ufs->config.upperdir);
 765         kfree(ufs->config.workdir);
 766         kfree(ufs);
 767 out:
 768         return err;
 769 }
 770
 771 static struct dentry *ovl_mount(struct file_system_type *fs_type, int flags,
 772                                 const char *dev_name, void *raw_data)
 773 {
 774         return mount_nodev(fs_type, flags, raw_data, ovl_fill_super);
 775 }
 776
 777 static struct file_system_type ovl_fs_type = {
 778         .owner          = THIS_MODULE,
 779         .name           = "overlayfs",
 780         .mount          = ovl_mount,
 781         .kill_sb        = kill_anon_super,
 782 };
 783 MODULE_ALIAS_FS("overlayfs");
 784
 785 static int __init ovl_init(void)
 786 {
 787         return register_filesystem(&ovl_fs_type);
 788 }
 789
 790 static void __exit ovl_exit(void)
 791 {
 792         unregister_filesystem(&ovl_fs_type);
 793 }
 794
 795 module_init(ovl_init);
 796 module_exit(ovl_exit);