fs/overlayfs/params.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2
   3 #include <linux/fs.h>
   4 #include <linux/module.h>
   5 #include <linux/namei.h>
   6 #include <linux/fs_context.h>
   7 #include <linux/fs_parser.h>
   8 #include <linux/posix_acl_xattr.h>
   9 #include <linux/seq_file.h>
  10 #include <linux/xattr.h>
  11 #include "overlayfs.h"
  12 #include "params.h"
  13
  14 static bool ovl_redirect_dir_def = IS_ENABLED(CONFIG_OVERLAY_FS_REDIRECT_DIR);
  15 module_param_named(redirect_dir, ovl_redirect_dir_def, bool, 0644);
  16 MODULE_PARM_DESC(redirect_dir,
  17                  "Default to on or off for the redirect_dir feature");
  18
  19 static bool ovl_redirect_always_follow =
  20         IS_ENABLED(CONFIG_OVERLAY_FS_REDIRECT_ALWAYS_FOLLOW);
  21 module_param_named(redirect_always_follow, ovl_redirect_always_follow,
  22                    bool, 0644);
  23 MODULE_PARM_DESC(redirect_always_follow,
  24                  "Follow redirects even if redirect_dir feature is turned off");
  25
  26 static bool ovl_xino_auto_def = IS_ENABLED(CONFIG_OVERLAY_FS_XINO_AUTO);
  27 module_param_named(xino_auto, ovl_xino_auto_def, bool, 0644);
  28 MODULE_PARM_DESC(xino_auto,
  29                  "Auto enable xino feature");
  30
  31 static bool ovl_index_def = IS_ENABLED(CONFIG_OVERLAY_FS_INDEX);
  32 module_param_named(index, ovl_index_def, bool, 0644);
  33 MODULE_PARM_DESC(index,
  34                  "Default to on or off for the inodes index feature");
  35
  36 static bool ovl_nfs_export_def = IS_ENABLED(CONFIG_OVERLAY_FS_NFS_EXPORT);
  37 module_param_named(nfs_export, ovl_nfs_export_def, bool, 0644);
  38 MODULE_PARM_DESC(nfs_export,
  39                  "Default to on or off for the NFS export feature");
  40
  41 static bool ovl_metacopy_def = IS_ENABLED(CONFIG_OVERLAY_FS_METACOPY);
  42 module_param_named(metacopy, ovl_metacopy_def, bool, 0644);
  43 MODULE_PARM_DESC(metacopy,
  44                  "Default to on or off for the metadata only copy up feature");
  45
  46 enum ovl_opt {
  47         Opt_lowerdir,
  48         Opt_lowerdir_add,
  49         Opt_datadir_add,
  50         Opt_upperdir,
  51         Opt_workdir,
  52         Opt_default_permissions,
  53         Opt_redirect_dir,
  54         Opt_index,
  55         Opt_uuid,
  56         Opt_nfs_export,
  57         Opt_userxattr,
  58         Opt_xino,
  59         Opt_metacopy,
  60         Opt_verity,
  61         Opt_volatile,
  62 };
  63
  64 static const struct constant_table ovl_parameter_bool[] = {
  65         { "on",         true  },
  66         { "off",        false },
  67         {}
  68 };
  69
  70 static const struct constant_table ovl_parameter_uuid[] = {
  71         { "off",        OVL_UUID_OFF  },
  72         { "null",       OVL_UUID_NULL },
  73         { "auto",       OVL_UUID_AUTO },
  74         { "on",         OVL_UUID_ON   },
  75         {}
  76 };
  77
  78 static const char *ovl_uuid_mode(struct ovl_config *config)
  79 {
  80         return ovl_parameter_uuid[config->uuid].name;
  81 }
  82
  83 static int ovl_uuid_def(void)
  84 {
  85         return OVL_UUID_AUTO;
  86 }
  87
  88 static const struct constant_table ovl_parameter_xino[] = {
  89         { "off",        OVL_XINO_OFF  },
  90         { "auto",       OVL_XINO_AUTO },
  91         { "on",         OVL_XINO_ON   },
  92         {}
  93 };
  94
  95 const char *ovl_xino_mode(struct ovl_config *config)
  96 {
  97         return ovl_parameter_xino[config->xino].name;
  98 }
  99
 100 static int ovl_xino_def(void)
 101 {
 102         return ovl_xino_auto_def ? OVL_XINO_AUTO : OVL_XINO_OFF;
 103 }
 104
 105 const struct constant_table ovl_parameter_redirect_dir[] = {
 106         { "off",        OVL_REDIRECT_OFF      },
 107         { "follow",     OVL_REDIRECT_FOLLOW   },
 108         { "nofollow",   OVL_REDIRECT_NOFOLLOW },
 109         { "on",         OVL_REDIRECT_ON       },
 110         {}
 111 };
 112
 113 static const char *ovl_redirect_mode(struct ovl_config *config)
 114 {
 115         return ovl_parameter_redirect_dir[config->redirect_mode].name;
 116 }
 117
 118 static int ovl_redirect_mode_def(void)
 119 {
 120         return ovl_redirect_dir_def       ? OVL_REDIRECT_ON :
 121                ovl_redirect_always_follow ? OVL_REDIRECT_FOLLOW :
 122                                             OVL_REDIRECT_NOFOLLOW;
 123 }
 124
 125 static const struct constant_table ovl_parameter_verity[] = {
 126         { "off",        OVL_VERITY_OFF     },
 127         { "on",         OVL_VERITY_ON      },
 128         { "require",    OVL_VERITY_REQUIRE },
 129         {}
 130 };
 131
 132 static const char *ovl_verity_mode(struct ovl_config *config)
 133 {
 134         return ovl_parameter_verity[config->verity_mode].name;
 135 }
 136
 137 static int ovl_verity_mode_def(void)
 138 {
 139         return OVL_VERITY_OFF;
 140 }
 141
 142 const struct fs_parameter_spec ovl_parameter_spec[] = {
 143         fsparam_string_empty("lowerdir",    Opt_lowerdir),
 144         fsparam_string("lowerdir+",         Opt_lowerdir_add),
 145         fsparam_string("datadir+",          Opt_datadir_add),
 146         fsparam_string("upperdir",          Opt_upperdir),
 147         fsparam_string("workdir",           Opt_workdir),
 148         fsparam_flag("default_permissions", Opt_default_permissions),
 149         fsparam_enum("redirect_dir",        Opt_redirect_dir, ovl_parameter_redirect_dir),
 150         fsparam_enum("index",               Opt_index, ovl_parameter_bool),
 151         fsparam_enum("uuid",                Opt_uuid, ovl_parameter_uuid),
 152         fsparam_enum("nfs_export",          Opt_nfs_export, ovl_parameter_bool),
 153         fsparam_flag("userxattr",           Opt_userxattr),
 154         fsparam_enum("xino",                Opt_xino, ovl_parameter_xino),
 155         fsparam_enum("metacopy",            Opt_metacopy, ovl_parameter_bool),
 156         fsparam_enum("verity",              Opt_verity, ovl_parameter_verity),
 157         fsparam_flag("volatile",            Opt_volatile),
 158         {}
 159 };
 160
 161 static char *ovl_next_opt(char **s)
 162 {
 163         char *sbegin = *s;
 164         char *p;
 165
 166         if (sbegin == NULL)
 167                 return NULL;
 168
 169         for (p = sbegin; *p; p++) {
 170                 if (*p == '\\') {
 171                         p++;
 172                         if (!*p)
 173                                 break;
 174                 } else if (*p == ',') {
 175                         *p = '\0';
 176                         *s = p + 1;
 177                         return sbegin;
 178                 }
 179         }
 180         *s = NULL;
 181         return sbegin;
 182 }
 183
 184 static int ovl_parse_monolithic(struct fs_context *fc, void *data)
 185 {
 186         return vfs_parse_monolithic_sep(fc, data, ovl_next_opt);
 187 }
 188
 189 static ssize_t ovl_parse_param_split_lowerdirs(char *str)
 190 {
 191         ssize_t nr_layers = 1, nr_colons = 0;
 192         char *s, *d;
 193
 194         for (s = d = str;; s++, d++) {
 195                 if (*s == '\\') {
 196                         /* keep esc chars in split lowerdir */
 197                         *d++ = *s++;
 198                 } else if (*s == ':') {
 199                         bool next_colon = (*(s + 1) == ':');
 200
 201                         nr_colons++;
 202                         if (nr_colons == 2 && next_colon) {
 203                                 pr_err("only single ':' or double '::' sequences of unescaped colons in lowerdir mount option allowed.\n");
 204                                 return -EINVAL;
 205                         }
 206                         /* count layers, not colons */
 207                         if (!next_colon)
 208                                 nr_layers++;
 209
 210                         *d = '\0';
 211                         continue;
 212                 }
 213
 214                 *d = *s;
 215                 if (!*s) {
 216                         /* trailing colons */
 217                         if (nr_colons) {
 218                                 pr_err("unescaped trailing colons in lowerdir mount option.\n");
 219                                 return -EINVAL;
 220                         }
 221                         break;
 222                 }
 223                 nr_colons = 0;
 224         }
 225
 226         return nr_layers;
 227 }
 228
 229 static int ovl_mount_dir_noesc(const char *name, struct path *path)
 230 {
 231         int err = -EINVAL;
 232
 233         if (!*name) {
 234                 pr_err("empty lowerdir\n");
 235                 goto out;
 236         }
 237         err = kern_path(name, LOOKUP_FOLLOW, path);
 238         if (err) {
 239                 pr_err("failed to resolve '%s': %i\n", name, err);
 240                 goto out;
 241         }
 242         return 0;
 243
 244 out:
 245         return err;
 246 }
 247
 248 static void ovl_unescape(char *s)
 249 {
 250         char *d = s;
 251
 252         for (;; s++, d++) {
 253                 if (*s == '\\')
 254                         s++;
 255                 *d = *s;
 256                 if (!*s)
 257                         break;
 258         }
 259 }
 260
 261 static int ovl_mount_dir(const char *name, struct path *path)
 262 {
 263         int err = -ENOMEM;
 264         char *tmp = kstrdup(name, GFP_KERNEL);
 265
 266         if (tmp) {
 267                 ovl_unescape(tmp);
 268                 err = ovl_mount_dir_noesc(tmp, path);
 269                 kfree(tmp);
 270         }
 271         return err;
 272 }
 273
 274 static int ovl_mount_dir_check(struct fs_context *fc, const struct path *path,
 275                                enum ovl_opt layer, const char *name, bool upper)
 276 {
 277         struct ovl_fs_context *ctx = fc->fs_private;
 278
 279         if (!d_is_dir(path->dentry))
 280                 return invalfc(fc, "%s is not a directory", name);
 281
 282         /*
 283          * Root dentries of case-insensitive capable filesystems might
 284          * not have the dentry operations set, but still be incompatible
 285          * with overlayfs.  Check explicitly to prevent post-mount
 286          * failures.
 287          */
 288         if (sb_has_encoding(path->mnt->mnt_sb))
 289                 return invalfc(fc, "case-insensitive capable filesystem on %s not supported", name);
 290
 291         if (ovl_dentry_weird(path->dentry))
 292                 return invalfc(fc, "filesystem on %s not supported", name);
 293
 294         /*
 295          * Check whether upper path is read-only here to report failures
 296          * early. Don't forget to recheck when the superblock is created
 297          * as the mount attributes could change.
 298          */
 299         if (upper) {
 300                 if (path->dentry->d_flags & DCACHE_OP_REAL)
 301                         return invalfc(fc, "filesystem on %s not supported as upperdir", name);
 302                 if (__mnt_is_readonly(path->mnt))
 303                         return invalfc(fc, "filesystem on %s is read-only", name);
 304         } else {
 305                 if (ctx->lowerdir_all && layer != Opt_lowerdir)
 306                         return invalfc(fc, "lowerdir+ and datadir+ cannot follow lowerdir");
 307                 if (ctx->nr_data && layer == Opt_lowerdir_add)
 308                         return invalfc(fc, "regular lower layers cannot follow data layers");
 309                 if (ctx->nr == OVL_MAX_STACK)
 310                         return invalfc(fc, "too many lower directories, limit is %d",
 311                                        OVL_MAX_STACK);
 312         }
 313         return 0;
 314 }
 315
 316 static int ovl_ctx_realloc_lower(struct fs_context *fc)
 317 {
 318         struct ovl_fs_context *ctx = fc->fs_private;
 319         struct ovl_fs_context_layer *l;
 320         size_t nr;
 321
 322         if (ctx->nr < ctx->capacity)
 323                 return 0;
 324
 325         nr = min_t(size_t, max(4096 / sizeof(*l), ctx->capacity * 2),
 326                    OVL_MAX_STACK);
 327         l = krealloc_array(ctx->lower, nr, sizeof(*l), GFP_KERNEL_ACCOUNT);
 328         if (!l)
 329                 return -ENOMEM;
 330
 331         ctx->lower = l;
 332         ctx->capacity = nr;
 333         return 0;
 334 }
 335
 336 static void ovl_add_layer(struct fs_context *fc, enum ovl_opt layer,
 337                          struct path *path, char **pname)
 338 {
 339         struct ovl_fs *ofs = fc->s_fs_info;
 340         struct ovl_config *config = &ofs->config;
 341         struct ovl_fs_context *ctx = fc->fs_private;
 342         struct ovl_fs_context_layer *l;
 343
 344         switch (layer) {
 345         case Opt_workdir:
 346                 swap(config->workdir, *pname);
 347                 swap(ctx->work, *path);
 348                 break;
 349         case Opt_upperdir:
 350                 swap(config->upperdir, *pname);
 351                 swap(ctx->upper, *path);
 352                 break;
 353         case Opt_datadir_add:
 354                 ctx->nr_data++;
 355                 fallthrough;
 356         case Opt_lowerdir_add:
 357                 WARN_ON(ctx->nr >= ctx->capacity);
 358                 l = &ctx->lower[ctx->nr++];
 359                 memset(l, 0, sizeof(*l));
 360                 swap(l->name, *pname);
 361                 swap(l->path, *path);
 362                 break;
 363         default:
 364                 WARN_ON(1);
 365         }
 366 }
 367
 368 static int ovl_parse_layer(struct fs_context *fc, struct fs_parameter *param,
 369                            enum ovl_opt layer)
 370 {
 371         char *name = kstrdup(param->string, GFP_KERNEL);
 372         bool upper = (layer == Opt_upperdir || layer == Opt_workdir);
 373         struct path path;
 374         int err;
 375
 376         if (!name)
 377                 return -ENOMEM;
 378
 379         if (upper)
 380                 err = ovl_mount_dir(name, &path);
 381         else
 382                 err = ovl_mount_dir_noesc(name, &path);
 383         if (err)
 384                 goto out_free;
 385
 386         err = ovl_mount_dir_check(fc, &path, layer, name, upper);
 387         if (err)
 388                 goto out_put;
 389
 390         if (!upper) {
 391                 err = ovl_ctx_realloc_lower(fc);
 392                 if (err)
 393                         goto out_put;
 394         }
 395
 396         /* Store the user provided path string in ctx to show in mountinfo */
 397         ovl_add_layer(fc, layer, &path, &name);
 398
 399 out_put:
 400         path_put(&path);
 401 out_free:
 402         kfree(name);
 403         return err;
 404 }
 405
 406 static void ovl_reset_lowerdirs(struct ovl_fs_context *ctx)
 407 {
 408         struct ovl_fs_context_layer *l = ctx->lower;
 409
 410         // Reset old user provided lowerdir string
 411         kfree(ctx->lowerdir_all);
 412         ctx->lowerdir_all = NULL;
 413
 414         for (size_t nr = 0; nr < ctx->nr; nr++, l++) {
 415                 path_put(&l->path);
 416                 kfree(l->name);
 417                 l->name = NULL;
 418         }
 419         ctx->nr = 0;
 420         ctx->nr_data = 0;
 421 }
 422
 423 /*
 424  * Parse lowerdir= mount option:
 425  *
 426  * e.g.: lowerdir=/lower1:/lower2:/lower3::/data1::/data2
 427  *     Set "/lower1", "/lower2", and "/lower3" as lower layers and
 428  *     "/data1" and "/data2" as data lower layers. Any existing lower
 429  *     layers are replaced.
 430  */
 431 static int ovl_parse_param_lowerdir(const char *name, struct fs_context *fc)
 432 {
 433         int err;
 434         struct ovl_fs_context *ctx = fc->fs_private;
 435         struct ovl_fs_context_layer *l;
 436         char *dup = NULL, *iter;
 437         ssize_t nr_lower, nr;
 438         bool data_layer = false;
 439
 440         /*
 441          * Ensure we're backwards compatible with mount(2)
 442          * by allowing relative paths.
 443          */
 444
 445         /* drop all existing lower layers */
 446         ovl_reset_lowerdirs(ctx);
 447
 448         if (!*name)
 449                 return 0;
 450
 451         if (*name == ':') {
 452                 pr_err("cannot append lower layer");
 453                 return -EINVAL;
 454         }
 455
 456         // Store user provided lowerdir string to show in mount options
 457         ctx->lowerdir_all = kstrdup(name, GFP_KERNEL);
 458         if (!ctx->lowerdir_all)
 459                 return -ENOMEM;
 460
 461         dup = kstrdup(name, GFP_KERNEL);
 462         if (!dup)
 463                 return -ENOMEM;
 464
 465         err = -EINVAL;
 466         nr_lower = ovl_parse_param_split_lowerdirs(dup);
 467         if (nr_lower < 0)
 468                 goto out_err;
 469
 470         if (nr_lower > OVL_MAX_STACK) {
 471                 pr_err("too many lower directories, limit is %d\n", OVL_MAX_STACK);
 472                 goto out_err;
 473         }
 474
 475         if (nr_lower > ctx->capacity) {
 476                 err = -ENOMEM;
 477                 l = krealloc_array(ctx->lower, nr_lower, sizeof(*ctx->lower),
 478                                    GFP_KERNEL_ACCOUNT);
 479                 if (!l)
 480                         goto out_err;
 481
 482                 ctx->lower = l;
 483                 ctx->capacity = nr_lower;
 484         }
 485
 486         iter = dup;
 487         l = ctx->lower;
 488         for (nr = 0; nr < nr_lower; nr++, l++) {
 489                 ctx->nr++;
 490                 memset(l, 0, sizeof(*l));
 491
 492                 err = ovl_mount_dir(iter, &l->path);
 493                 if (err)
 494                         goto out_put;
 495
 496                 err = ovl_mount_dir_check(fc, &l->path, Opt_lowerdir, iter, false);
 497                 if (err)
 498                         goto out_put;
 499
 500                 err = -ENOMEM;
 501                 l->name = kstrdup(iter, GFP_KERNEL_ACCOUNT);
 502                 if (!l->name)
 503                         goto out_put;
 504
 505                 if (data_layer)
 506                         ctx->nr_data++;
 507
 508                 /* Calling strchr() again would overrun. */
 509                 if (ctx->nr == nr_lower)
 510                         break;
 511
 512                 err = -EINVAL;
 513                 iter = strchr(iter, '\0') + 1;
 514                 if (*iter) {
 515                         /*
 516                          * This is a regular layer so we require that
 517                          * there are no data layers.
 518                          */
 519                         if (ctx->nr_data > 0) {
 520                                 pr_err("regular lower layers cannot follow data lower layers");
 521                                 goto out_put;
 522                         }
 523
 524                         data_layer = false;
 525                         continue;
 526                 }
 527
 528                 /* This is a data lower layer. */
 529                 data_layer = true;
 530                 iter++;
 531         }
 532         kfree(dup);
 533         return 0;
 534
 535 out_put:
 536         ovl_reset_lowerdirs(ctx);
 537
 538 out_err:
 539         kfree(dup);
 540
 541         /* Intentionally don't realloc to a smaller size. */
 542         return err;
 543 }
 544
 545 static int ovl_parse_param(struct fs_context *fc, struct fs_parameter *param)
 546 {
 547         int err = 0;
 548         struct fs_parse_result result;
 549         struct ovl_fs *ofs = fc->s_fs_info;
 550         struct ovl_config *config = &ofs->config;
 551         struct ovl_fs_context *ctx = fc->fs_private;
 552         int opt;
 553
 554         if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE) {
 555                 /*
 556                  * On remount overlayfs has always ignored all mount
 557                  * options no matter if malformed or not so for
 558                  * backwards compatibility we do the same here.
 559                  */
 560                 if (fc->oldapi)
 561                         return 0;
 562
 563                 /*
 564                  * Give us the freedom to allow changing mount options
 565                  * with the new mount api in the future. So instead of
 566                  * silently ignoring everything we report a proper
 567                  * error. This is only visible for users of the new
 568                  * mount api.
 569                  */
 570                 return invalfc(fc, "No changes allowed in reconfigure");
 571         }
 572
 573         opt = fs_parse(fc, ovl_parameter_spec, param, &result);
 574         if (opt < 0)
 575                 return opt;
 576
 577         switch (opt) {
 578         case Opt_lowerdir:
 579                 err = ovl_parse_param_lowerdir(param->string, fc);
 580                 break;
 581         case Opt_lowerdir_add:
 582         case Opt_datadir_add:
 583         case Opt_upperdir:
 584         case Opt_workdir:
 585                 err = ovl_parse_layer(fc, param, opt);
 586                 break;
 587         case Opt_default_permissions:
 588                 config->default_permissions = true;
 589                 break;
 590         case Opt_redirect_dir:
 591                 config->redirect_mode = result.uint_32;
 592                 if (config->redirect_mode == OVL_REDIRECT_OFF) {
 593                         config->redirect_mode = ovl_redirect_always_follow ?
 594                                                 OVL_REDIRECT_FOLLOW :
 595                                                 OVL_REDIRECT_NOFOLLOW;
 596                 }
 597                 ctx->set.redirect = true;
 598                 break;
 599         case Opt_index:
 600                 config->index = result.uint_32;
 601                 ctx->set.index = true;
 602                 break;
 603         case Opt_uuid:
 604                 config->uuid = result.uint_32;
 605                 break;
 606         case Opt_nfs_export:
 607                 config->nfs_export = result.uint_32;
 608                 ctx->set.nfs_export = true;
 609                 break;
 610         case Opt_xino:
 611                 config->xino = result.uint_32;
 612                 break;
 613         case Opt_metacopy:
 614                 config->metacopy = result.uint_32;
 615                 ctx->set.metacopy = true;
 616                 break;
 617         case Opt_verity:
 618                 config->verity_mode = result.uint_32;
 619                 break;
 620         case Opt_volatile:
 621                 config->ovl_volatile = true;
 622                 break;
 623         case Opt_userxattr:
 624                 config->userxattr = true;
 625                 break;
 626         default:
 627                 pr_err("unrecognized mount option \"%s\" or missing value\n",
 628                        param->key);
 629                 return -EINVAL;
 630         }
 631
 632         return err;
 633 }
 634
 635 static int ovl_get_tree(struct fs_context *fc)
 636 {
 637         return get_tree_nodev(fc, ovl_fill_super);
 638 }
 639
 640 static inline void ovl_fs_context_free(struct ovl_fs_context *ctx)
 641 {
 642         ovl_reset_lowerdirs(ctx);
 643         path_put(&ctx->upper);
 644         path_put(&ctx->work);
 645         kfree(ctx->lower);
 646         kfree(ctx);
 647 }
 648
 649 static void ovl_free(struct fs_context *fc)
 650 {
 651         struct ovl_fs *ofs = fc->s_fs_info;
 652         struct ovl_fs_context *ctx = fc->fs_private;
 653
 654         /*
 655          * ofs is stored in the fs_context when it is initialized.
 656          * ofs is transferred to the superblock on a successful mount,
 657          * but if an error occurs before the transfer we have to free
 658          * it here.
 659          */
 660         if (ofs)
 661                 ovl_free_fs(ofs);
 662
 663         if (ctx)
 664                 ovl_fs_context_free(ctx);
 665 }
 666
 667 static int ovl_reconfigure(struct fs_context *fc)
 668 {
 669         struct super_block *sb = fc->root->d_sb;
 670         struct ovl_fs *ofs = OVL_FS(sb);
 671         struct super_block *upper_sb;
 672         int ret = 0;
 673
 674         if (!(fc->sb_flags & SB_RDONLY) && ovl_force_readonly(ofs))
 675                 return -EROFS;
 676
 677         if (fc->sb_flags & SB_RDONLY && !sb_rdonly(sb)) {
 678                 upper_sb = ovl_upper_mnt(ofs)->mnt_sb;
 679                 if (ovl_should_sync(ofs)) {
 680                         down_read(&upper_sb->s_umount);
 681                         ret = sync_filesystem(upper_sb);
 682                         up_read(&upper_sb->s_umount);
 683                 }
 684         }
 685
 686         return ret;
 687 }
 688
 689 static const struct fs_context_operations ovl_context_ops = {
 690         .parse_monolithic = ovl_parse_monolithic,
 691         .parse_param = ovl_parse_param,
 692         .get_tree    = ovl_get_tree,
 693         .reconfigure = ovl_reconfigure,
 694         .free        = ovl_free,
 695 };
 696
 697 /*
 698  * This is called during fsopen() and will record the user namespace of
 699  * the caller in fc->user_ns since we've raised FS_USERNS_MOUNT. We'll
 700  * need it when we actually create the superblock to verify that the
 701  * process creating the superblock is in the same user namespace as
 702  * process that called fsopen().
 703  */
 704 int ovl_init_fs_context(struct fs_context *fc)
 705 {
 706         struct ovl_fs_context *ctx;
 707         struct ovl_fs *ofs;
 708
 709         ctx = kzalloc(sizeof(*ctx), GFP_KERNEL_ACCOUNT);
 710         if (!ctx)
 711                 return -ENOMEM;
 712
 713         /*
 714          * By default we allocate for three lower layers. It's likely
 715          * that it'll cover most users.
 716          */
 717         ctx->lower = kmalloc_array(3, sizeof(*ctx->lower), GFP_KERNEL_ACCOUNT);
 718         if (!ctx->lower)
 719                 goto out_err;
 720         ctx->capacity = 3;
 721
 722         ofs = kzalloc(sizeof(struct ovl_fs), GFP_KERNEL);
 723         if (!ofs)
 724                 goto out_err;
 725
 726         ofs->config.redirect_mode       = ovl_redirect_mode_def();
 727         ofs->config.index               = ovl_index_def;
 728         ofs->config.uuid                = ovl_uuid_def();
 729         ofs->config.nfs_export          = ovl_nfs_export_def;
 730         ofs->config.xino                = ovl_xino_def();
 731         ofs->config.metacopy            = ovl_metacopy_def;
 732
 733         fc->s_fs_info           = ofs;
 734         fc->fs_private          = ctx;
 735         fc->ops                 = &ovl_context_ops;
 736         return 0;
 737
 738 out_err:
 739         ovl_fs_context_free(ctx);
 740         return -ENOMEM;
 741
 742 }
 743
 744 void ovl_free_fs(struct ovl_fs *ofs)
 745 {
 746         struct vfsmount **mounts;
 747         unsigned i;
 748
 749         iput(ofs->workbasedir_trap);
 750         iput(ofs->workdir_trap);
 751         dput(ofs->whiteout);
 752         dput(ofs->workdir);
 753         if (ofs->workdir_locked)
 754                 ovl_inuse_unlock(ofs->workbasedir);
 755         dput(ofs->workbasedir);
 756         if (ofs->upperdir_locked)
 757                 ovl_inuse_unlock(ovl_upper_mnt(ofs)->mnt_root);
 758
 759         /* Reuse ofs->config.lowerdirs as a vfsmount array before freeing it */
 760         mounts = (struct vfsmount **) ofs->config.lowerdirs;
 761         for (i = 0; i < ofs->numlayer; i++) {
 762                 iput(ofs->layers[i].trap);
 763                 kfree(ofs->config.lowerdirs[i]);
 764                 mounts[i] = ofs->layers[i].mnt;
 765         }
 766         kern_unmount_array(mounts, ofs->numlayer);
 767         kfree(ofs->layers);
 768         for (i = 0; i < ofs->numfs; i++)
 769                 free_anon_bdev(ofs->fs[i].pseudo_dev);
 770         kfree(ofs->fs);
 771
 772         kfree(ofs->config.lowerdirs);
 773         kfree(ofs->config.upperdir);
 774         kfree(ofs->config.workdir);
 775         if (ofs->creator_cred)
 776                 put_cred(ofs->creator_cred);
 777         kfree(ofs);
 778 }
 779
 780 int ovl_fs_params_verify(const struct ovl_fs_context *ctx,
 781                          struct ovl_config *config)
 782 {
 783         struct ovl_opt_set set = ctx->set;
 784
 785         if (ctx->nr_data > 0 && !config->metacopy) {
 786                 pr_err("lower data-only dirs require metacopy support.\n");
 787                 return -EINVAL;
 788         }
 789
 790         /* Workdir/index are useless in non-upper mount */
 791         if (!config->upperdir) {
 792                 if (config->workdir) {
 793                         pr_info("option \"workdir=%s\" is useless in a non-upper mount, ignore\n",
 794                                 config->workdir);
 795                         kfree(config->workdir);
 796                         config->workdir = NULL;
 797                 }
 798                 if (config->index && set.index) {
 799                         pr_info("option \"index=on\" is useless in a non-upper mount, ignore\n");
 800                         set.index = false;
 801                 }
 802                 config->index = false;
 803         }
 804
 805         if (!config->upperdir && config->ovl_volatile) {
 806                 pr_info("option \"volatile\" is meaningless in a non-upper mount, ignoring it.\n");
 807                 config->ovl_volatile = false;
 808         }
 809
 810         if (!config->upperdir && config->uuid == OVL_UUID_ON) {
 811                 pr_info("option \"uuid=on\" requires an upper fs, falling back to uuid=null.\n");
 812                 config->uuid = OVL_UUID_NULL;
 813         }
 814
 815         /* Resolve verity -> metacopy dependency */
 816         if (config->verity_mode && !config->metacopy) {
 817                 /* Don't allow explicit specified conflicting combinations */
 818                 if (set.metacopy) {
 819                         pr_err("conflicting options: metacopy=off,verity=%s\n",
 820                                ovl_verity_mode(config));
 821                         return -EINVAL;
 822                 }
 823                 /* Otherwise automatically enable metacopy. */
 824                 config->metacopy = true;
 825         }
 826
 827         /*
 828          * This is to make the logic below simpler.  It doesn't make any other
 829          * difference, since redirect_dir=on is only used for upper.
 830          */
 831         if (!config->upperdir && config->redirect_mode == OVL_REDIRECT_FOLLOW)
 832                 config->redirect_mode = OVL_REDIRECT_ON;
 833
 834         /* Resolve verity -> metacopy -> redirect_dir dependency */
 835         if (config->metacopy && config->redirect_mode != OVL_REDIRECT_ON) {
 836                 if (set.metacopy && set.redirect) {
 837                         pr_err("conflicting options: metacopy=on,redirect_dir=%s\n",
 838                                ovl_redirect_mode(config));
 839                         return -EINVAL;
 840                 }
 841                 if (config->verity_mode && set.redirect) {
 842                         pr_err("conflicting options: verity=%s,redirect_dir=%s\n",
 843                                ovl_verity_mode(config), ovl_redirect_mode(config));
 844                         return -EINVAL;
 845                 }
 846                 if (set.redirect) {
 847                         /*
 848                          * There was an explicit redirect_dir=... that resulted
 849                          * in this conflict.
 850                          */
 851                         pr_info("disabling metacopy due to redirect_dir=%s\n",
 852                                 ovl_redirect_mode(config));
 853                         config->metacopy = false;
 854                 } else {
 855                         /* Automatically enable redirect otherwise. */
 856                         config->redirect_mode = OVL_REDIRECT_ON;
 857                 }
 858         }
 859
 860         /* Resolve nfs_export -> index dependency */
 861         if (config->nfs_export && !config->index) {
 862                 if (!config->upperdir &&
 863                     config->redirect_mode != OVL_REDIRECT_NOFOLLOW) {
 864                         pr_info("NFS export requires \"redirect_dir=nofollow\" on non-upper mount, falling back to nfs_export=off.\n");
 865                         config->nfs_export = false;
 866                 } else if (set.nfs_export && set.index) {
 867                         pr_err("conflicting options: nfs_export=on,index=off\n");
 868                         return -EINVAL;
 869                 } else if (set.index) {
 870                         /*
 871                          * There was an explicit index=off that resulted
 872                          * in this conflict.
 873                          */
 874                         pr_info("disabling nfs_export due to index=off\n");
 875                         config->nfs_export = false;
 876                 } else {
 877                         /* Automatically enable index otherwise. */
 878                         config->index = true;
 879                 }
 880         }
 881
 882         /* Resolve nfs_export -> !metacopy && !verity dependency */
 883         if (config->nfs_export && config->metacopy) {
 884                 if (set.nfs_export && set.metacopy) {
 885                         pr_err("conflicting options: nfs_export=on,metacopy=on\n");
 886                         return -EINVAL;
 887                 }
 888                 if (set.metacopy) {
 889                         /*
 890                          * There was an explicit metacopy=on that resulted
 891                          * in this conflict.
 892                          */
 893                         pr_info("disabling nfs_export due to metacopy=on\n");
 894                         config->nfs_export = false;
 895                 } else if (config->verity_mode) {
 896                         /*
 897                          * There was an explicit verity=.. that resulted
 898                          * in this conflict.
 899                          */
 900                         pr_info("disabling nfs_export due to verity=%s\n",
 901                                 ovl_verity_mode(config));
 902                         config->nfs_export = false;
 903                 } else {
 904                         /*
 905                          * There was an explicit nfs_export=on that resulted
 906                          * in this conflict.
 907                          */
 908                         pr_info("disabling metacopy due to nfs_export=on\n");
 909                         config->metacopy = false;
 910                 }
 911         }
 912
 913
 914         /* Resolve userxattr -> !redirect && !metacopy && !verity dependency */
 915         if (config->userxattr) {
 916                 if (set.redirect &&
 917                     config->redirect_mode != OVL_REDIRECT_NOFOLLOW) {
 918                         pr_err("conflicting options: userxattr,redirect_dir=%s\n",
 919                                ovl_redirect_mode(config));
 920                         return -EINVAL;
 921                 }
 922                 if (config->metacopy && set.metacopy) {
 923                         pr_err("conflicting options: userxattr,metacopy=on\n");
 924                         return -EINVAL;
 925                 }
 926                 if (config->verity_mode) {
 927                         pr_err("conflicting options: userxattr,verity=%s\n",
 928                                ovl_verity_mode(config));
 929                         return -EINVAL;
 930                 }
 931                 /*
 932                  * Silently disable default setting of redirect and metacopy.
 933                  * This shall be the default in the future as well: these
 934                  * options must be explicitly enabled if used together with
 935                  * userxattr.
 936                  */
 937                 config->redirect_mode = OVL_REDIRECT_NOFOLLOW;
 938                 config->metacopy = false;
 939         }
 940
 941         return 0;
 942 }
 943
 944 /**
 945  * ovl_show_options
 946  * @m: the seq_file handle
 947  * @dentry: The dentry to query
 948  *
 949  * Prints the mount options for a given superblock.
 950  * Returns zero; does not fail.
 951  */
 952 int ovl_show_options(struct seq_file *m, struct dentry *dentry)
 953 {
 954         struct super_block *sb = dentry->d_sb;
 955         struct ovl_fs *ofs = OVL_FS(sb);
 956         size_t nr, nr_merged_lower, nr_lower = 0;
 957         char **lowerdirs = ofs->config.lowerdirs;
 958
 959         /*
 960          * lowerdirs[0] holds the colon separated list that user provided
 961          * with lowerdir mount option.
 962          * lowerdirs[1..numlayer] hold the lowerdir paths that were added
 963          * using the lowerdir+ and datadir+ mount options.
 964          * For now, we do not allow mixing the legacy lowerdir mount option
 965          * with the new lowerdir+ and datadir+ mount options.
 966          */
 967         if (lowerdirs[0]) {
 968                 seq_show_option(m, "lowerdir", lowerdirs[0]);
 969         } else {
 970                 nr_lower = ofs->numlayer;
 971                 nr_merged_lower = nr_lower - ofs->numdatalayer;
 972         }
 973         for (nr = 1; nr < nr_lower; nr++) {
 974                 if (nr < nr_merged_lower)
 975                         seq_show_option(m, "lowerdir+", lowerdirs[nr]);
 976                 else
 977                         seq_show_option(m, "datadir+", lowerdirs[nr]);
 978         }
 979         if (ofs->config.upperdir) {
 980                 seq_show_option(m, "upperdir", ofs->config.upperdir);
 981                 seq_show_option(m, "workdir", ofs->config.workdir);
 982         }
 983         if (ofs->config.default_permissions)
 984                 seq_puts(m, ",default_permissions");
 985         if (ofs->config.redirect_mode != ovl_redirect_mode_def())
 986                 seq_printf(m, ",redirect_dir=%s",
 987                            ovl_redirect_mode(&ofs->config));
 988         if (ofs->config.index != ovl_index_def)
 989                 seq_printf(m, ",index=%s", ofs->config.index ? "on" : "off");
 990         if (ofs->config.uuid != ovl_uuid_def())
 991                 seq_printf(m, ",uuid=%s", ovl_uuid_mode(&ofs->config));
 992         if (ofs->config.nfs_export != ovl_nfs_export_def)
 993                 seq_printf(m, ",nfs_export=%s", ofs->config.nfs_export ?
 994                                                 "on" : "off");
 995         if (ofs->config.xino != ovl_xino_def() && !ovl_same_fs(ofs))
 996                 seq_printf(m, ",xino=%s", ovl_xino_mode(&ofs->config));
 997         if (ofs->config.metacopy != ovl_metacopy_def)
 998                 seq_printf(m, ",metacopy=%s",
 999                            ofs->config.metacopy ? "on" : "off");
1000         if (ofs->config.ovl_volatile)
1001                 seq_puts(m, ",volatile");
1002         if (ofs->config.userxattr)
1003                 seq_puts(m, ",userxattr");
1004         if (ofs->config.verity_mode != ovl_verity_mode_def())
1005                 seq_printf(m, ",verity=%s",
1006                            ovl_verity_mode(&ofs->config));
1007         return 0;
1008 }