fs/aufs/opts.c

   1 /*
   2  * Copyright (C) 2005-2013 Junjiro R. Okajima
   3  *
   4  * This program, aufs is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17  */
  18
  19 /*
  20  * mount options/flags
  21  */
  22
  23 #include <linux/namei.h>
  24 #include <linux/types.h> /* a distribution requires */
  25 #include <linux/parser.h>
  26 #include "aufs.h"
  27
  28 /* ---------------------------------------------------------------------- */
  29
  30 enum {
  31         Opt_br,
  32         Opt_add, Opt_del, Opt_mod, Opt_reorder, Opt_append, Opt_prepend,
  33         Opt_idel, Opt_imod, Opt_ireorder,
  34         Opt_dirwh, Opt_rdcache, Opt_rdblk, Opt_rdhash, Opt_rendir,
  35         Opt_rdblk_def, Opt_rdhash_def,
  36         Opt_xino, Opt_zxino, Opt_noxino,
  37         Opt_trunc_xino, Opt_trunc_xino_v, Opt_notrunc_xino,
  38         Opt_trunc_xino_path, Opt_itrunc_xino,
  39         Opt_trunc_xib, Opt_notrunc_xib,
  40         Opt_shwh, Opt_noshwh,
  41         Opt_plink, Opt_noplink, Opt_list_plink,
  42         Opt_udba,
  43         Opt_dio, Opt_nodio,
  44         /* Opt_lock, Opt_unlock, */
  45         Opt_cmd, Opt_cmd_args,
  46         Opt_diropq_a, Opt_diropq_w,
  47         Opt_warn_perm, Opt_nowarn_perm,
  48         Opt_wbr_copyup, Opt_wbr_create,
  49         Opt_refrof, Opt_norefrof,
  50         Opt_verbose, Opt_noverbose,
  51         Opt_sum, Opt_nosum, Opt_wsum,
  52         Opt_tail, Opt_ignore, Opt_ignore_silent, Opt_err
  53 };
  54
  55 static match_table_t options = {
  56         {Opt_br, "br=%s"},
  57         {Opt_br, "br:%s"},
  58
  59         {Opt_add, "add=%d:%s"},
  60         {Opt_add, "add:%d:%s"},
  61         {Opt_add, "ins=%d:%s"},
  62         {Opt_add, "ins:%d:%s"},
  63         {Opt_append, "append=%s"},
  64         {Opt_append, "append:%s"},
  65         {Opt_prepend, "prepend=%s"},
  66         {Opt_prepend, "prepend:%s"},
  67
  68         {Opt_del, "del=%s"},
  69         {Opt_del, "del:%s"},
  70         /* {Opt_idel, "idel:%d"}, */
  71         {Opt_mod, "mod=%s"},
  72         {Opt_mod, "mod:%s"},
  73         /* {Opt_imod, "imod:%d:%s"}, */
  74
  75         {Opt_dirwh, "dirwh=%d"},
  76
  77         {Opt_xino, "xino=%s"},
  78         {Opt_noxino, "noxino"},
  79         {Opt_trunc_xino, "trunc_xino"},
  80         {Opt_trunc_xino_v, "trunc_xino_v=%d:%d"},
  81         {Opt_notrunc_xino, "notrunc_xino"},
  82         {Opt_trunc_xino_path, "trunc_xino=%s"},
  83         {Opt_itrunc_xino, "itrunc_xino=%d"},
  84         /* {Opt_zxino, "zxino=%s"}, */
  85         {Opt_trunc_xib, "trunc_xib"},
  86         {Opt_notrunc_xib, "notrunc_xib"},
  87
  88 #ifdef CONFIG_PROC_FS
  89         {Opt_plink, "plink"},
  90 #else
  91         {Opt_ignore_silent, "plink"},
  92 #endif
  93
  94         {Opt_noplink, "noplink"},
  95
  96 #ifdef CONFIG_AUFS_DEBUG
  97         {Opt_list_plink, "list_plink"},
  98 #endif
  99
 100         {Opt_udba, "udba=%s"},
 101
 102         {Opt_dio, "dio"},
 103         {Opt_nodio, "nodio"},
 104
 105         {Opt_diropq_a, "diropq=always"},
 106         {Opt_diropq_a, "diropq=a"},
 107         {Opt_diropq_w, "diropq=whiteouted"},
 108         {Opt_diropq_w, "diropq=w"},
 109
 110         {Opt_warn_perm, "warn_perm"},
 111         {Opt_nowarn_perm, "nowarn_perm"},
 112
 113         /* keep them temporary */
 114         {Opt_ignore_silent, "coo=%s"},
 115         {Opt_ignore_silent, "nodlgt"},
 116         {Opt_ignore_silent, "nodirperm1"},
 117         {Opt_ignore_silent, "clean_plink"},
 118
 119 #ifdef CONFIG_AUFS_SHWH
 120         {Opt_shwh, "shwh"},
 121 #endif
 122         {Opt_noshwh, "noshwh"},
 123
 124         {Opt_rendir, "rendir=%d"},
 125
 126         {Opt_refrof, "refrof"},
 127         {Opt_norefrof, "norefrof"},
 128
 129         {Opt_verbose, "verbose"},
 130         {Opt_verbose, "v"},
 131         {Opt_noverbose, "noverbose"},
 132         {Opt_noverbose, "quiet"},
 133         {Opt_noverbose, "q"},
 134         {Opt_noverbose, "silent"},
 135
 136         {Opt_sum, "sum"},
 137         {Opt_nosum, "nosum"},
 138         {Opt_wsum, "wsum"},
 139
 140         {Opt_rdcache, "rdcache=%d"},
 141         {Opt_rdblk, "rdblk=%d"},
 142         {Opt_rdblk_def, "rdblk=def"},
 143         {Opt_rdhash, "rdhash=%d"},
 144         {Opt_rdhash_def, "rdhash=def"},
 145
 146         {Opt_wbr_create, "create=%s"},
 147         {Opt_wbr_create, "create_policy=%s"},
 148         {Opt_wbr_copyup, "cpup=%s"},
 149         {Opt_wbr_copyup, "copyup=%s"},
 150         {Opt_wbr_copyup, "copyup_policy=%s"},
 151
 152         /* internal use for the scripts */
 153         {Opt_ignore_silent, "si=%s"},
 154
 155         {Opt_br, "dirs=%s"},
 156         {Opt_ignore, "debug=%d"},
 157         {Opt_ignore, "delete=whiteout"},
 158         {Opt_ignore, "delete=all"},
 159         {Opt_ignore, "imap=%s"},
 160
 161         /* temporary workaround, due to old mount(8)? */
 162         {Opt_ignore_silent, "relatime"},
 163
 164         {Opt_err, NULL}
 165 };
 166
 167 /* ---------------------------------------------------------------------- */
 168
 169 static const char *au_parser_pattern(int val, struct match_token *token)
 170 {
 171         while (token->pattern) {
 172                 if (token->token == val)
 173                         return token->pattern;
 174                 token++;
 175         }
 176         BUG();
 177         return "??";
 178 }
 179
 180 /* ---------------------------------------------------------------------- */
 181
 182 static match_table_t brperm = {
 183         {AuBrPerm_RO, AUFS_BRPERM_RO},
 184         {AuBrPerm_RR, AUFS_BRPERM_RR},
 185         {AuBrPerm_RW, AUFS_BRPERM_RW},
 186         {0, NULL}
 187 };
 188
 189 static match_table_t brattr = {
 190         {AuBrAttr_UNPIN, AUFS_BRATTR_UNPIN},
 191         {AuBrRAttr_WH, AUFS_BRRATTR_WH},
 192         {AuBrWAttr_NoLinkWH, AUFS_BRWATTR_NLWH},
 193         {0, NULL}
 194 };
 195
 196 #define AuBrStr_LONGEST AUFS_BRPERM_RW \
 197         "+" AUFS_BRATTR_UNPIN \
 198         "+" AUFS_BRWATTR_NLWH
 199
 200 static int br_attr_val(char *str, match_table_t table, substring_t args[])
 201 {
 202         int attr, v;
 203         char *p;
 204
 205         attr = 0;
 206         do {
 207                 p = strchr(str, '+');
 208                 if (p)
 209                         *p = 0;
 210                 v = match_token(str, table, args);
 211                 if (v)
 212                         attr |= v;
 213                 else {
 214                         if (p)
 215                                 *p = '+';
 216                         pr_warn("ignored branch attribute %s\n", str);
 217                         break;
 218                 }
 219                 if (p)
 220                         str = p + 1;
 221         } while (p);
 222
 223         return attr;
 224 }
 225
 226 static int noinline_for_stack br_perm_val(char *perm)
 227 {
 228         int val;
 229         char *p, *q;
 230         substring_t args[MAX_OPT_ARGS];
 231
 232         p = strchr(perm, '+');
 233         if (p)
 234                 *p = 0;
 235         val = match_token(perm, brperm, args);
 236         if (!val) {
 237                 if (p)
 238                         *p = '+';
 239                 pr_warn("ignored branch permission %s\n", perm);
 240                 val = AuBrPerm_RO;
 241                 goto out;
 242         }
 243         if (!p)
 244                 goto out;
 245
 246         p++;
 247         while (1) {
 248                 q = strchr(p, '+');
 249                 if (q)
 250                         *q = 0;
 251                 val |= br_attr_val(p, brattr, args);
 252                 if (q) {
 253                         *q = '+';
 254                         p = q + 1;
 255                 } else
 256                         break;
 257         }
 258         switch (val & AuBrPerm_Mask) {
 259         case AuBrPerm_RO:
 260         case AuBrPerm_RR:
 261                 if (unlikely(val & AuBrWAttr_NoLinkWH)) {
 262                         pr_warn("ignored branch attribute %s\n",
 263                                 AUFS_BRWATTR_NLWH);
 264                         val &= ~AuBrWAttr_NoLinkWH;
 265                 }
 266                 break;
 267         case AuBrPerm_RW:
 268                 if (unlikely(val & AuBrRAttr_WH)) {
 269                         pr_warn("ignored branch attribute %s\n",
 270                                 AUFS_BRRATTR_WH);
 271                         val &= ~AuBrRAttr_WH;
 272                 }
 273                 break;
 274         }
 275
 276 out:
 277         return val;
 278 }
 279
 280 /* Caller should free the return value */
 281 char *au_optstr_br_perm(int brperm)
 282 {
 283         char *p, a[sizeof(AuBrStr_LONGEST)];
 284         int sz;
 285
 286 #define SetPerm(str) do {                       \
 287                 sz = sizeof(str);               \
 288                 memcpy(a, str, sz);             \
 289                 p = a + sz - 1;                 \
 290         } while (0)
 291
 292 #define AppendAttr(flag, str) do {                      \
 293                 if (brperm & flag) {            \
 294                         sz = sizeof(str);       \
 295                         *p++ = '+';             \
 296                         memcpy(p, str, sz);     \
 297                         p += sz - 1;            \
 298                 }                               \
 299         } while (0)
 300
 301         switch (brperm & AuBrPerm_Mask) {
 302         case AuBrPerm_RO:
 303                 SetPerm(AUFS_BRPERM_RO);
 304                 break;
 305         case AuBrPerm_RR:
 306                 SetPerm(AUFS_BRPERM_RR);
 307                 break;
 308         case AuBrPerm_RW:
 309                 SetPerm(AUFS_BRPERM_RW);
 310                 break;
 311         default:
 312                 AuDebugOn(1);
 313         }
 314
 315         AppendAttr(AuBrAttr_UNPIN, AUFS_BRATTR_UNPIN);
 316         AppendAttr(AuBrRAttr_WH, AUFS_BRRATTR_WH);
 317         AppendAttr(AuBrWAttr_NoLinkWH, AUFS_BRWATTR_NLWH);
 318
 319         AuDebugOn(strlen(a) >= sizeof(a));
 320         return kstrdup(a, GFP_NOFS);
 321 #undef SetPerm
 322 #undef AppendAttr
 323 }
 324
 325 /* ---------------------------------------------------------------------- */
 326
 327 static match_table_t udbalevel = {
 328         {AuOpt_UDBA_REVAL, "reval"},
 329         {AuOpt_UDBA_NONE, "none"},
 330 #ifdef CONFIG_AUFS_HNOTIFY
 331         {AuOpt_UDBA_HNOTIFY, "notify"}, /* abstraction */
 332 #ifdef CONFIG_AUFS_HFSNOTIFY
 333         {AuOpt_UDBA_HNOTIFY, "fsnotify"},
 334 #endif
 335 #endif
 336         {-1, NULL}
 337 };
 338
 339 static int noinline_for_stack udba_val(char *str)
 340 {
 341         substring_t args[MAX_OPT_ARGS];
 342
 343         return match_token(str, udbalevel, args);
 344 }
 345
 346 const char *au_optstr_udba(int udba)
 347 {
 348         return au_parser_pattern(udba, (void *)udbalevel);
 349 }
 350
 351 /* ---------------------------------------------------------------------- */
 352
 353 static match_table_t au_wbr_create_policy = {
 354         {AuWbrCreate_TDP, "tdp"},
 355         {AuWbrCreate_TDP, "top-down-parent"},
 356         {AuWbrCreate_RR, "rr"},
 357         {AuWbrCreate_RR, "round-robin"},
 358         {AuWbrCreate_MFS, "mfs"},
 359         {AuWbrCreate_MFS, "most-free-space"},
 360         {AuWbrCreate_MFSV, "mfs:%d"},
 361         {AuWbrCreate_MFSV, "most-free-space:%d"},
 362
 363         {AuWbrCreate_MFSRR, "mfsrr:%d"},
 364         {AuWbrCreate_MFSRRV, "mfsrr:%d:%d"},
 365         {AuWbrCreate_PMFS, "pmfs"},
 366         {AuWbrCreate_PMFSV, "pmfs:%d"},
 367         {AuWbrCreate_PMFSRR, "pmfsrr:%d"},
 368         {AuWbrCreate_PMFSRRV, "pmfsrr:%d:%d"},
 369
 370         {-1, NULL}
 371 };
 372
 373 /*
 374  * cf. linux/lib/parser.c and cmdline.c
 375  * gave up calling memparse() since it uses simple_strtoull() instead of
 376  * kstrto...().
 377  */
 378 static int noinline_for_stack
 379 au_match_ull(substring_t *s, unsigned long long *result)
 380 {
 381         int err;
 382         unsigned int len;
 383         char a[32];
 384
 385         err = -ERANGE;
 386         len = s->to - s->from;
 387         if (len + 1 <= sizeof(a)) {
 388                 memcpy(a, s->from, len);
 389                 a[len] = '\0';
 390                 err = kstrtoull(a, 0, result);
 391         }
 392         return err;
 393 }
 394
 395 static int au_wbr_mfs_wmark(substring_t *arg, char *str,
 396                             struct au_opt_wbr_create *create)
 397 {
 398         int err;
 399         unsigned long long ull;
 400
 401         err = 0;
 402         if (!au_match_ull(arg, &ull))
 403                 create->mfsrr_watermark = ull;
 404         else {
 405                 pr_err("bad integer in %s\n", str);
 406                 err = -EINVAL;
 407         }
 408
 409         return err;
 410 }
 411
 412 static int au_wbr_mfs_sec(substring_t *arg, char *str,
 413                           struct au_opt_wbr_create *create)
 414 {
 415         int n, err;
 416
 417         err = 0;
 418         if (!match_int(arg, &n) && 0 <= n && n <= AUFS_MFS_MAX_SEC)
 419                 create->mfs_second = n;
 420         else {
 421                 pr_err("bad integer in %s\n", str);
 422                 err = -EINVAL;
 423         }
 424
 425         return err;
 426 }
 427
 428 static int noinline_for_stack
 429 au_wbr_create_val(char *str, struct au_opt_wbr_create *create)
 430 {
 431         int err, e;
 432         substring_t args[MAX_OPT_ARGS];
 433
 434         err = match_token(str, au_wbr_create_policy, args);
 435         create->wbr_create = err;
 436         switch (err) {
 437         case AuWbrCreate_MFSRRV:
 438         case AuWbrCreate_PMFSRRV:
 439                 e = au_wbr_mfs_wmark(&args[0], str, create);
 440                 if (!e)
 441                         e = au_wbr_mfs_sec(&args[1], str, create);
 442                 if (unlikely(e))
 443                         err = e;
 444                 break;
 445         case AuWbrCreate_MFSRR:
 446         case AuWbrCreate_PMFSRR:
 447                 e = au_wbr_mfs_wmark(&args[0], str, create);
 448                 if (unlikely(e)) {
 449                         err = e;
 450                         break;
 451                 }
 452                 /*FALLTHROUGH*/
 453         case AuWbrCreate_MFS:
 454         case AuWbrCreate_PMFS:
 455                 create->mfs_second = AUFS_MFS_DEF_SEC;
 456                 break;
 457         case AuWbrCreate_MFSV:
 458         case AuWbrCreate_PMFSV:
 459                 e = au_wbr_mfs_sec(&args[0], str, create);
 460                 if (unlikely(e))
 461                         err = e;
 462                 break;
 463         }
 464
 465         return err;
 466 }
 467
 468 const char *au_optstr_wbr_create(int wbr_create)
 469 {
 470         return au_parser_pattern(wbr_create, (void *)au_wbr_create_policy);
 471 }
 472
 473 static match_table_t au_wbr_copyup_policy = {
 474         {AuWbrCopyup_TDP, "tdp"},
 475         {AuWbrCopyup_TDP, "top-down-parent"},
 476         {AuWbrCopyup_BUP, "bup"},
 477         {AuWbrCopyup_BUP, "bottom-up-parent"},
 478         {AuWbrCopyup_BU, "bu"},
 479         {AuWbrCopyup_BU, "bottom-up"},
 480         {-1, NULL}
 481 };
 482
 483 static int noinline_for_stack au_wbr_copyup_val(char *str)
 484 {
 485         substring_t args[MAX_OPT_ARGS];
 486
 487         return match_token(str, au_wbr_copyup_policy, args);
 488 }
 489
 490 const char *au_optstr_wbr_copyup(int wbr_copyup)
 491 {
 492         return au_parser_pattern(wbr_copyup, (void *)au_wbr_copyup_policy);
 493 }
 494
 495 /* ---------------------------------------------------------------------- */
 496
 497 static const int lkup_dirflags = LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
 498
 499 static void dump_opts(struct au_opts *opts)
 500 {
 501 #ifdef CONFIG_AUFS_DEBUG
 502         /* reduce stack space */
 503         union {
 504                 struct au_opt_add *add;
 505                 struct au_opt_del *del;
 506                 struct au_opt_mod *mod;
 507                 struct au_opt_xino *xino;
 508                 struct au_opt_xino_itrunc *xino_itrunc;
 509                 struct au_opt_wbr_create *create;
 510         } u;
 511         struct au_opt *opt;
 512
 513         opt = opts->opt;
 514         while (opt->type != Opt_tail) {
 515                 switch (opt->type) {
 516                 case Opt_add:
 517                         u.add = &opt->add;
 518                         AuDbg("add {b%d, %s, 0x%x, %p}\n",
 519                                   u.add->bindex, u.add->pathname, u.add->perm,
 520                                   u.add->path.dentry);
 521                         break;
 522                 case Opt_del:
 523                 case Opt_idel:
 524                         u.del = &opt->del;
 525                         AuDbg("del {%s, %p}\n",
 526                               u.del->pathname, u.del->h_path.dentry);
 527                         break;
 528                 case Opt_mod:
 529                 case Opt_imod:
 530                         u.mod = &opt->mod;
 531                         AuDbg("mod {%s, 0x%x, %p}\n",
 532                                   u.mod->path, u.mod->perm, u.mod->h_root);
 533                         break;
 534                 case Opt_append:
 535                         u.add = &opt->add;
 536                         AuDbg("append {b%d, %s, 0x%x, %p}\n",
 537                                   u.add->bindex, u.add->pathname, u.add->perm,
 538                                   u.add->path.dentry);
 539                         break;
 540                 case Opt_prepend:
 541                         u.add = &opt->add;
 542                         AuDbg("prepend {b%d, %s, 0x%x, %p}\n",
 543                                   u.add->bindex, u.add->pathname, u.add->perm,
 544                                   u.add->path.dentry);
 545                         break;
 546                 case Opt_dirwh:
 547                         AuDbg("dirwh %d\n", opt->dirwh);
 548                         break;
 549                 case Opt_rdcache:
 550                         AuDbg("rdcache %d\n", opt->rdcache);
 551                         break;
 552                 case Opt_rdblk:
 553                         AuDbg("rdblk %u\n", opt->rdblk);
 554                         break;
 555                 case Opt_rdblk_def:
 556                         AuDbg("rdblk_def\n");
 557                         break;
 558                 case Opt_rdhash:
 559                         AuDbg("rdhash %u\n", opt->rdhash);
 560                         break;
 561                 case Opt_rdhash_def:
 562                         AuDbg("rdhash_def\n");
 563                         break;
 564                 case Opt_xino:
 565                         u.xino = &opt->xino;
 566                         AuDbg("xino {%s %.*s}\n",
 567                                   u.xino->path,
 568                                   AuDLNPair(u.xino->file->f_dentry));
 569                         break;
 570                 case Opt_trunc_xino:
 571                         AuLabel(trunc_xino);
 572                         break;
 573                 case Opt_notrunc_xino:
 574                         AuLabel(notrunc_xino);
 575                         break;
 576                 case Opt_trunc_xino_path:
 577                 case Opt_itrunc_xino:
 578                         u.xino_itrunc = &opt->xino_itrunc;
 579                         AuDbg("trunc_xino %d\n", u.xino_itrunc->bindex);
 580                         break;
 581
 582                 case Opt_noxino:
 583                         AuLabel(noxino);
 584                         break;
 585                 case Opt_trunc_xib:
 586                         AuLabel(trunc_xib);
 587                         break;
 588                 case Opt_notrunc_xib:
 589                         AuLabel(notrunc_xib);
 590                         break;
 591                 case Opt_shwh:
 592                         AuLabel(shwh);
 593                         break;
 594                 case Opt_noshwh:
 595                         AuLabel(noshwh);
 596                         break;
 597                 case Opt_plink:
 598                         AuLabel(plink);
 599                         break;
 600                 case Opt_noplink:
 601                         AuLabel(noplink);
 602                         break;
 603                 case Opt_list_plink:
 604                         AuLabel(list_plink);
 605                         break;
 606                 case Opt_udba:
 607                         AuDbg("udba %d, %s\n",
 608                                   opt->udba, au_optstr_udba(opt->udba));
 609                         break;
 610                 case Opt_dio:
 611                         AuLabel(dio);
 612                         break;
 613                 case Opt_nodio:
 614                         AuLabel(nodio);
 615                         break;
 616                 case Opt_diropq_a:
 617                         AuLabel(diropq_a);
 618                         break;
 619                 case Opt_diropq_w:
 620                         AuLabel(diropq_w);
 621                         break;
 622                 case Opt_warn_perm:
 623                         AuLabel(warn_perm);
 624                         break;
 625                 case Opt_nowarn_perm:
 626                         AuLabel(nowarn_perm);
 627                         break;
 628                 case Opt_refrof:
 629                         AuLabel(refrof);
 630                         break;
 631                 case Opt_norefrof:
 632                         AuLabel(norefrof);
 633                         break;
 634                 case Opt_verbose:
 635                         AuLabel(verbose);
 636                         break;
 637                 case Opt_noverbose:
 638                         AuLabel(noverbose);
 639                         break;
 640                 case Opt_sum:
 641                         AuLabel(sum);
 642                         break;
 643                 case Opt_nosum:
 644                         AuLabel(nosum);
 645                         break;
 646                 case Opt_wsum:
 647                         AuLabel(wsum);
 648                         break;
 649                 case Opt_wbr_create:
 650                         u.create = &opt->wbr_create;
 651                         AuDbg("create %d, %s\n", u.create->wbr_create,
 652                                   au_optstr_wbr_create(u.create->wbr_create));
 653                         switch (u.create->wbr_create) {
 654                         case AuWbrCreate_MFSV:
 655                         case AuWbrCreate_PMFSV:
 656                                 AuDbg("%d sec\n", u.create->mfs_second);
 657                                 break;
 658                         case AuWbrCreate_MFSRR:
 659                                 AuDbg("%llu watermark\n",
 660                                           u.create->mfsrr_watermark);
 661                                 break;
 662                         case AuWbrCreate_MFSRRV:
 663                         case AuWbrCreate_PMFSRRV:
 664                                 AuDbg("%llu watermark, %d sec\n",
 665                                           u.create->mfsrr_watermark,
 666                                           u.create->mfs_second);
 667                                 break;
 668                         }
 669                         break;
 670                 case Opt_wbr_copyup:
 671                         AuDbg("copyup %d, %s\n", opt->wbr_copyup,
 672                                   au_optstr_wbr_copyup(opt->wbr_copyup));
 673                         break;
 674                 default:
 675                         BUG();
 676                 }
 677                 opt++;
 678         }
 679 #endif
 680 }
 681
 682 void au_opts_free(struct au_opts *opts)
 683 {
 684         struct au_opt *opt;
 685
 686         opt = opts->opt;
 687         while (opt->type != Opt_tail) {
 688                 switch (opt->type) {
 689                 case Opt_add:
 690                 case Opt_append:
 691                 case Opt_prepend:
 692                         path_put(&opt->add.path);
 693                         break;
 694                 case Opt_del:
 695                 case Opt_idel:
 696                         path_put(&opt->del.h_path);
 697                         break;
 698                 case Opt_mod:
 699                 case Opt_imod:
 700                         dput(opt->mod.h_root);
 701                         break;
 702                 case Opt_xino:
 703                         fput(opt->xino.file);
 704                         break;
 705                 }
 706                 opt++;
 707         }
 708 }
 709
 710 static int opt_add(struct au_opt *opt, char *opt_str, unsigned long sb_flags,
 711                    aufs_bindex_t bindex)
 712 {
 713         int err;
 714         struct au_opt_add *add = &opt->add;
 715         char *p;
 716
 717         add->bindex = bindex;
 718         add->perm = AuBrPerm_RO;
 719         add->pathname = opt_str;
 720         p = strchr(opt_str, '=');
 721         if (p) {
 722                 *p++ = 0;
 723                 if (*p)
 724                         add->perm = br_perm_val(p);
 725         }
 726
 727         err = vfsub_kern_path(add->pathname, lkup_dirflags, &add->path);
 728         if (!err) {
 729                 if (!p) {
 730                         add->perm = AuBrPerm_RO;
 731                         if (au_test_fs_rr(add->path.dentry->d_sb))
 732                                 add->perm = AuBrPerm_RR;
 733                         else if (!bindex && !(sb_flags & MS_RDONLY))
 734                                 add->perm = AuBrPerm_RW;
 735                 }
 736                 opt->type = Opt_add;
 737                 goto out;
 738         }
 739         pr_err("lookup failed %s (%d)\n", add->pathname, err);
 740         err = -EINVAL;
 741
 742 out:
 743         return err;
 744 }
 745
 746 static int au_opts_parse_del(struct au_opt_del *del, substring_t args[])
 747 {
 748         int err;
 749
 750         del->pathname = args[0].from;
 751         AuDbg("del path %s\n", del->pathname);
 752
 753         err = vfsub_kern_path(del->pathname, lkup_dirflags, &del->h_path);
 754         if (unlikely(err))
 755                 pr_err("lookup failed %s (%d)\n", del->pathname, err);
 756
 757         return err;
 758 }
 759
 760 #if 0 /* reserved for future use */
 761 static int au_opts_parse_idel(struct super_block *sb, aufs_bindex_t bindex,
 762                               struct au_opt_del *del, substring_t args[])
 763 {
 764         int err;
 765         struct dentry *root;
 766
 767         err = -EINVAL;
 768         root = sb->s_root;
 769         aufs_read_lock(root, AuLock_FLUSH);
 770         if (bindex < 0 || au_sbend(sb) < bindex) {
 771                 pr_err("out of bounds, %d\n", bindex);
 772                 goto out;
 773         }
 774
 775         err = 0;
 776         del->h_path.dentry = dget(au_h_dptr(root, bindex));
 777         del->h_path.mnt = mntget(au_sbr_mnt(sb, bindex));
 778
 779 out:
 780         aufs_read_unlock(root, !AuLock_IR);
 781         return err;
 782 }
 783 #endif
 784
 785 static int noinline_for_stack
 786 au_opts_parse_mod(struct au_opt_mod *mod, substring_t args[])
 787 {
 788         int err;
 789         struct path path;
 790         char *p;
 791
 792         err = -EINVAL;
 793         mod->path = args[0].from;
 794         p = strchr(mod->path, '=');
 795         if (unlikely(!p)) {
 796                 pr_err("no permssion %s\n", args[0].from);
 797                 goto out;
 798         }
 799
 800         *p++ = 0;
 801         err = vfsub_kern_path(mod->path, lkup_dirflags, &path);
 802         if (unlikely(err)) {
 803                 pr_err("lookup failed %s (%d)\n", mod->path, err);
 804                 goto out;
 805         }
 806
 807         mod->perm = br_perm_val(p);
 808         AuDbg("mod path %s, perm 0x%x, %s\n", mod->path, mod->perm, p);
 809         mod->h_root = dget(path.dentry);
 810         path_put(&path);
 811
 812 out:
 813         return err;
 814 }
 815
 816 #if 0 /* reserved for future use */
 817 static int au_opts_parse_imod(struct super_block *sb, aufs_bindex_t bindex,
 818                               struct au_opt_mod *mod, substring_t args[])
 819 {
 820         int err;
 821         struct dentry *root;
 822
 823         err = -EINVAL;
 824         root = sb->s_root;
 825         aufs_read_lock(root, AuLock_FLUSH);
 826         if (bindex < 0 || au_sbend(sb) < bindex) {
 827                 pr_err("out of bounds, %d\n", bindex);
 828                 goto out;
 829         }
 830
 831         err = 0;
 832         mod->perm = br_perm_val(args[1].from);
 833         AuDbg("mod path %s, perm 0x%x, %s\n",
 834               mod->path, mod->perm, args[1].from);
 835         mod->h_root = dget(au_h_dptr(root, bindex));
 836
 837 out:
 838         aufs_read_unlock(root, !AuLock_IR);
 839         return err;
 840 }
 841 #endif
 842
 843 static int au_opts_parse_xino(struct super_block *sb, struct au_opt_xino *xino,
 844                               substring_t args[])
 845 {
 846         int err;
 847         struct file *file;
 848
 849         file = au_xino_create(sb, args[0].from, /*silent*/0);
 850         err = PTR_ERR(file);
 851         if (IS_ERR(file))
 852                 goto out;
 853
 854         err = -EINVAL;
 855         if (unlikely(file->f_dentry->d_sb == sb)) {
 856                 fput(file);
 857                 pr_err("%s must be outside\n", args[0].from);
 858                 goto out;
 859         }
 860
 861         err = 0;
 862         xino->file = file;
 863         xino->path = args[0].from;
 864
 865 out:
 866         return err;
 867 }
 868
 869 static int noinline_for_stack
 870 au_opts_parse_xino_itrunc_path(struct super_block *sb,
 871                                struct au_opt_xino_itrunc *xino_itrunc,
 872                                substring_t args[])
 873 {
 874         int err;
 875         aufs_bindex_t bend, bindex;
 876         struct path path;
 877         struct dentry *root;
 878
 879         err = vfsub_kern_path(args[0].from, lkup_dirflags, &path);
 880         if (unlikely(err)) {
 881                 pr_err("lookup failed %s (%d)\n", args[0].from, err);
 882                 goto out;
 883         }
 884
 885         xino_itrunc->bindex = -1;
 886         root = sb->s_root;
 887         aufs_read_lock(root, AuLock_FLUSH);
 888         bend = au_sbend(sb);
 889         for (bindex = 0; bindex <= bend; bindex++) {
 890                 if (au_h_dptr(root, bindex) == path.dentry) {
 891                         xino_itrunc->bindex = bindex;
 892                         break;
 893                 }
 894         }
 895         aufs_read_unlock(root, !AuLock_IR);
 896         path_put(&path);
 897
 898         if (unlikely(xino_itrunc->bindex < 0)) {
 899                 pr_err("no such branch %s\n", args[0].from);
 900                 err = -EINVAL;
 901         }
 902
 903 out:
 904         return err;
 905 }
 906
 907 /* called without aufs lock */
 908 int au_opts_parse(struct super_block *sb, char *str, struct au_opts *opts)
 909 {
 910         int err, n, token;
 911         aufs_bindex_t bindex;
 912         unsigned char skipped;
 913         struct dentry *root;
 914         struct au_opt *opt, *opt_tail;
 915         char *opt_str;
 916         /* reduce the stack space */
 917         union {
 918                 struct au_opt_xino_itrunc *xino_itrunc;
 919                 struct au_opt_wbr_create *create;
 920         } u;
 921         struct {
 922                 substring_t args[MAX_OPT_ARGS];
 923         } *a;
 924
 925         err = -ENOMEM;
 926         a = kmalloc(sizeof(*a), GFP_NOFS);
 927         if (unlikely(!a))
 928                 goto out;
 929
 930         root = sb->s_root;
 931         err = 0;
 932         bindex = 0;
 933         opt = opts->opt;
 934         opt_tail = opt + opts->max_opt - 1;
 935         opt->type = Opt_tail;
 936         while (!err && (opt_str = strsep(&str, ",")) && *opt_str) {
 937                 err = -EINVAL;
 938                 skipped = 0;
 939                 token = match_token(opt_str, options, a->args);
 940                 switch (token) {
 941                 case Opt_br:
 942                         err = 0;
 943                         while (!err && (opt_str = strsep(&a->args[0].from, ":"))
 944                                && *opt_str) {
 945                                 err = opt_add(opt, opt_str, opts->sb_flags,
 946                                               bindex++);
 947                                 if (unlikely(!err && ++opt > opt_tail)) {
 948                                         err = -E2BIG;
 949                                         break;
 950                                 }
 951                                 opt->type = Opt_tail;
 952                                 skipped = 1;
 953                         }
 954                         break;
 955                 case Opt_add:
 956                         if (unlikely(match_int(&a->args[0], &n))) {
 957                                 pr_err("bad integer in %s\n", opt_str);
 958                                 break;
 959                         }
 960                         bindex = n;
 961                         err = opt_add(opt, a->args[1].from, opts->sb_flags,
 962                                       bindex);
 963                         if (!err)
 964                                 opt->type = token;
 965                         break;
 966                 case Opt_append:
 967                         err = opt_add(opt, a->args[0].from, opts->sb_flags,
 968                                       /*dummy bindex*/1);
 969                         if (!err)
 970                                 opt->type = token;
 971                         break;
 972                 case Opt_prepend:
 973                         err = opt_add(opt, a->args[0].from, opts->sb_flags,
 974                                       /*bindex*/0);
 975                         if (!err)
 976                                 opt->type = token;
 977                         break;
 978                 case Opt_del:
 979                         err = au_opts_parse_del(&opt->del, a->args);
 980                         if (!err)
 981                                 opt->type = token;
 982                         break;
 983 #if 0 /* reserved for future use */
 984                 case Opt_idel:
 985                         del->pathname = "(indexed)";
 986                         if (unlikely(match_int(&args[0], &n))) {
 987                                 pr_err("bad integer in %s\n", opt_str);
 988                                 break;
 989                         }
 990                         err = au_opts_parse_idel(sb, n, &opt->del, a->args);
 991                         if (!err)
 992                                 opt->type = token;
 993                         break;
 994 #endif
 995                 case Opt_mod:
 996                         err = au_opts_parse_mod(&opt->mod, a->args);
 997                         if (!err)
 998                                 opt->type = token;
 999                         break;
1000 #ifdef IMOD /* reserved for future use */
1001                 case Opt_imod:
1002                         u.mod->path = "(indexed)";
1003                         if (unlikely(match_int(&a->args[0], &n))) {
1004                                 pr_err("bad integer in %s\n", opt_str);
1005                                 break;
1006                         }
1007                         err = au_opts_parse_imod(sb, n, &opt->mod, a->args);
1008                         if (!err)
1009                                 opt->type = token;
1010                         break;
1011 #endif
1012                 case Opt_xino:
1013                         err = au_opts_parse_xino(sb, &opt->xino, a->args);
1014                         if (!err)
1015                                 opt->type = token;
1016                         break;
1017
1018                 case Opt_trunc_xino_path:
1019                         err = au_opts_parse_xino_itrunc_path
1020                                 (sb, &opt->xino_itrunc, a->args);
1021                         if (!err)
1022                                 opt->type = token;
1023                         break;
1024
1025                 case Opt_itrunc_xino:
1026                         u.xino_itrunc = &opt->xino_itrunc;
1027                         if (unlikely(match_int(&a->args[0], &n))) {
1028                                 pr_err("bad integer in %s\n", opt_str);
1029                                 break;
1030                         }
1031                         u.xino_itrunc->bindex = n;
1032                         aufs_read_lock(root, AuLock_FLUSH);
1033                         if (n < 0 || au_sbend(sb) < n) {
1034                                 pr_err("out of bounds, %d\n", n);
1035                                 aufs_read_unlock(root, !AuLock_IR);
1036                                 break;
1037                         }
1038                         aufs_read_unlock(root, !AuLock_IR);
1039                         err = 0;
1040                         opt->type = token;
1041                         break;
1042
1043                 case Opt_dirwh:
1044                         if (unlikely(match_int(&a->args[0], &opt->dirwh)))
1045                                 break;
1046                         err = 0;
1047                         opt->type = token;
1048                         break;
1049
1050                 case Opt_rdcache:
1051                         if (unlikely(match_int(&a->args[0], &n))) {
1052                                 pr_err("bad integer in %s\n", opt_str);
1053                                 break;
1054                         }
1055                         if (unlikely(n > AUFS_RDCACHE_MAX)) {
1056                                 pr_err("rdcache must be smaller than %d\n",
1057                                        AUFS_RDCACHE_MAX);
1058                                 break;
1059                         }
1060                         opt->rdcache = n;
1061                         err = 0;
1062                         opt->type = token;
1063                         break;
1064                 case Opt_rdblk:
1065                         if (unlikely(match_int(&a->args[0], &n)
1066                                      || n < 0
1067                                      || n > KMALLOC_MAX_SIZE)) {
1068                                 pr_err("bad integer in %s\n", opt_str);
1069                                 break;
1070                         }
1071                         if (unlikely(n && n < NAME_MAX)) {
1072                                 pr_err("rdblk must be larger than %d\n",
1073                                        NAME_MAX);
1074                                 break;
1075                         }
1076                         opt->rdblk = n;
1077                         err = 0;
1078                         opt->type = token;
1079                         break;
1080                 case Opt_rdhash:
1081                         if (unlikely(match_int(&a->args[0], &n)
1082                                      || n < 0
1083                                      || n * sizeof(struct hlist_head)
1084                                      > KMALLOC_MAX_SIZE)) {
1085                                 pr_err("bad integer in %s\n", opt_str);
1086                                 break;
1087                         }
1088                         opt->rdhash = n;
1089                         err = 0;
1090                         opt->type = token;
1091                         break;
1092
1093                 case Opt_trunc_xino:
1094                 case Opt_notrunc_xino:
1095                 case Opt_noxino:
1096                 case Opt_trunc_xib:
1097                 case Opt_notrunc_xib:
1098                 case Opt_shwh:
1099                 case Opt_noshwh:
1100                 case Opt_plink:
1101                 case Opt_noplink:
1102                 case Opt_list_plink:
1103                 case Opt_dio:
1104                 case Opt_nodio:
1105                 case Opt_diropq_a:
1106                 case Opt_diropq_w:
1107                 case Opt_warn_perm:
1108                 case Opt_nowarn_perm:
1109                 case Opt_refrof:
1110                 case Opt_norefrof:
1111                 case Opt_verbose:
1112                 case Opt_noverbose:
1113                 case Opt_sum:
1114                 case Opt_nosum:
1115                 case Opt_wsum:
1116                 case Opt_rdblk_def:
1117                 case Opt_rdhash_def:
1118                         err = 0;
1119                         opt->type = token;
1120                         break;
1121
1122                 case Opt_udba:
1123                         opt->udba = udba_val(a->args[0].from);
1124                         if (opt->udba >= 0) {
1125                                 err = 0;
1126                                 opt->type = token;
1127                         } else
1128                                 pr_err("wrong value, %s\n", opt_str);
1129                         break;
1130
1131                 case Opt_wbr_create:
1132                         u.create = &opt->wbr_create;
1133                         u.create->wbr_create
1134                                 = au_wbr_create_val(a->args[0].from, u.create);
1135                         if (u.create->wbr_create >= 0) {
1136                                 err = 0;
1137                                 opt->type = token;
1138                         } else
1139                                 pr_err("wrong value, %s\n", opt_str);
1140                         break;
1141                 case Opt_wbr_copyup:
1142                         opt->wbr_copyup = au_wbr_copyup_val(a->args[0].from);
1143                         if (opt->wbr_copyup >= 0) {
1144                                 err = 0;
1145                                 opt->type = token;
1146                         } else
1147                                 pr_err("wrong value, %s\n", opt_str);
1148                         break;
1149
1150                 case Opt_ignore:
1151                         pr_warn("ignored %s\n", opt_str);
1152                         /*FALLTHROUGH*/
1153                 case Opt_ignore_silent:
1154                         skipped = 1;
1155                         err = 0;
1156                         break;
1157                 case Opt_err:
1158                         pr_err("unknown option %s\n", opt_str);
1159                         break;
1160                 }
1161
1162                 if (!err && !skipped) {
1163                         if (unlikely(++opt > opt_tail)) {
1164                                 err = -E2BIG;
1165                                 opt--;
1166                                 opt->type = Opt_tail;
1167                                 break;
1168                         }
1169                         opt->type = Opt_tail;
1170                 }
1171         }
1172
1173         kfree(a);
1174         dump_opts(opts);
1175         if (unlikely(err))
1176                 au_opts_free(opts);
1177
1178 out:
1179         return err;
1180 }
1181
1182 static int au_opt_wbr_create(struct super_block *sb,
1183                              struct au_opt_wbr_create *create)
1184 {
1185         int err;
1186         struct au_sbinfo *sbinfo;
1187
1188         SiMustWriteLock(sb);
1189
1190         err = 1; /* handled */
1191         sbinfo = au_sbi(sb);
1192         if (sbinfo->si_wbr_create_ops->fin) {
1193                 err = sbinfo->si_wbr_create_ops->fin(sb);
1194                 if (!err)
1195                         err = 1;
1196         }
1197
1198         sbinfo->si_wbr_create = create->wbr_create;
1199         sbinfo->si_wbr_create_ops = au_wbr_create_ops + create->wbr_create;
1200         switch (create->wbr_create) {
1201         case AuWbrCreate_MFSRRV:
1202         case AuWbrCreate_MFSRR:
1203         case AuWbrCreate_PMFSRR:
1204         case AuWbrCreate_PMFSRRV:
1205                 sbinfo->si_wbr_mfs.mfsrr_watermark = create->mfsrr_watermark;
1206                 /*FALLTHROUGH*/
1207         case AuWbrCreate_MFS:
1208         case AuWbrCreate_MFSV:
1209         case AuWbrCreate_PMFS:
1210         case AuWbrCreate_PMFSV:
1211                 sbinfo->si_wbr_mfs.mfs_expire
1212                         = msecs_to_jiffies(create->mfs_second * MSEC_PER_SEC);
1213                 break;
1214         }
1215
1216         if (sbinfo->si_wbr_create_ops->init)
1217                 sbinfo->si_wbr_create_ops->init(sb); /* ignore */
1218
1219         return err;
1220 }
1221
1222 /*
1223  * returns,
1224  * plus: processed without an error
1225  * zero: unprocessed
1226  */
1227 static int au_opt_simple(struct super_block *sb, struct au_opt *opt,
1228                          struct au_opts *opts)
1229 {
1230         int err;
1231         struct au_sbinfo *sbinfo;
1232
1233         SiMustWriteLock(sb);
1234
1235         err = 1; /* handled */
1236         sbinfo = au_sbi(sb);
1237         switch (opt->type) {
1238         case Opt_udba:
1239                 sbinfo->si_mntflags &= ~AuOptMask_UDBA;
1240                 sbinfo->si_mntflags |= opt->udba;
1241                 opts->given_udba |= opt->udba;
1242                 break;
1243
1244         case Opt_plink:
1245                 au_opt_set(sbinfo->si_mntflags, PLINK);
1246                 break;
1247         case Opt_noplink:
1248                 if (au_opt_test(sbinfo->si_mntflags, PLINK))
1249                         au_plink_put(sb, /*verbose*/1);
1250                 au_opt_clr(sbinfo->si_mntflags, PLINK);
1251                 break;
1252         case Opt_list_plink:
1253                 if (au_opt_test(sbinfo->si_mntflags, PLINK))
1254                         au_plink_list(sb);
1255                 break;
1256
1257         case Opt_dio:
1258                 au_opt_set(sbinfo->si_mntflags, DIO);
1259                 au_fset_opts(opts->flags, REFRESH_DYAOP);
1260                 break;
1261         case Opt_nodio:
1262                 au_opt_clr(sbinfo->si_mntflags, DIO);
1263                 au_fset_opts(opts->flags, REFRESH_DYAOP);
1264                 break;
1265
1266         case Opt_diropq_a:
1267                 au_opt_set(sbinfo->si_mntflags, ALWAYS_DIROPQ);
1268                 break;
1269         case Opt_diropq_w:
1270                 au_opt_clr(sbinfo->si_mntflags, ALWAYS_DIROPQ);
1271                 break;
1272
1273         case Opt_warn_perm:
1274                 au_opt_set(sbinfo->si_mntflags, WARN_PERM);
1275                 break;
1276         case Opt_nowarn_perm:
1277                 au_opt_clr(sbinfo->si_mntflags, WARN_PERM);
1278                 break;
1279
1280         case Opt_refrof:
1281                 au_opt_set(sbinfo->si_mntflags, REFROF);
1282                 break;
1283         case Opt_norefrof:
1284                 au_opt_clr(sbinfo->si_mntflags, REFROF);
1285                 break;
1286
1287         case Opt_verbose:
1288                 au_opt_set(sbinfo->si_mntflags, VERBOSE);
1289                 break;
1290         case Opt_noverbose:
1291                 au_opt_clr(sbinfo->si_mntflags, VERBOSE);
1292                 break;
1293
1294         case Opt_sum:
1295                 au_opt_set(sbinfo->si_mntflags, SUM);
1296                 break;
1297         case Opt_wsum:
1298                 au_opt_clr(sbinfo->si_mntflags, SUM);
1299                 au_opt_set(sbinfo->si_mntflags, SUM_W);
1300         case Opt_nosum:
1301                 au_opt_clr(sbinfo->si_mntflags, SUM);
1302                 au_opt_clr(sbinfo->si_mntflags, SUM_W);
1303                 break;
1304
1305         case Opt_wbr_create:
1306                 err = au_opt_wbr_create(sb, &opt->wbr_create);
1307                 break;
1308         case Opt_wbr_copyup:
1309                 sbinfo->si_wbr_copyup = opt->wbr_copyup;
1310                 sbinfo->si_wbr_copyup_ops = au_wbr_copyup_ops + opt->wbr_copyup;
1311                 break;
1312
1313         case Opt_dirwh:
1314                 sbinfo->si_dirwh = opt->dirwh;
1315                 break;
1316
1317         case Opt_rdcache:
1318                 sbinfo->si_rdcache
1319                         = msecs_to_jiffies(opt->rdcache * MSEC_PER_SEC);
1320                 break;
1321         case Opt_rdblk:
1322                 sbinfo->si_rdblk = opt->rdblk;
1323                 break;
1324         case Opt_rdblk_def:
1325                 sbinfo->si_rdblk = AUFS_RDBLK_DEF;
1326                 break;
1327         case Opt_rdhash:
1328                 sbinfo->si_rdhash = opt->rdhash;
1329                 break;
1330         case Opt_rdhash_def:
1331                 sbinfo->si_rdhash = AUFS_RDHASH_DEF;
1332                 break;
1333
1334         case Opt_shwh:
1335                 au_opt_set(sbinfo->si_mntflags, SHWH);
1336                 break;
1337         case Opt_noshwh:
1338                 au_opt_clr(sbinfo->si_mntflags, SHWH);
1339                 break;
1340
1341         case Opt_trunc_xino:
1342                 au_opt_set(sbinfo->si_mntflags, TRUNC_XINO);
1343                 break;
1344         case Opt_notrunc_xino:
1345                 au_opt_clr(sbinfo->si_mntflags, TRUNC_XINO);
1346                 break;
1347
1348         case Opt_trunc_xino_path:
1349         case Opt_itrunc_xino:
1350                 err = au_xino_trunc(sb, opt->xino_itrunc.bindex);
1351                 if (!err)
1352                         err = 1;
1353                 break;
1354
1355         case Opt_trunc_xib:
1356                 au_fset_opts(opts->flags, TRUNC_XIB);
1357                 break;
1358         case Opt_notrunc_xib:
1359                 au_fclr_opts(opts->flags, TRUNC_XIB);
1360                 break;
1361
1362         default:
1363                 err = 0;
1364                 break;
1365         }
1366
1367         return err;
1368 }
1369
1370 /*
1371  * returns tri-state.
1372  * plus: processed without an error
1373  * zero: unprocessed
1374  * minus: error
1375  */
1376 static int au_opt_br(struct super_block *sb, struct au_opt *opt,
1377                      struct au_opts *opts)
1378 {
1379         int err, do_refresh;
1380
1381         err = 0;
1382         switch (opt->type) {
1383         case Opt_append:
1384                 opt->add.bindex = au_sbend(sb) + 1;
1385                 if (opt->add.bindex < 0)
1386                         opt->add.bindex = 0;
1387                 goto add;
1388         case Opt_prepend:
1389                 opt->add.bindex = 0;
1390         add:
1391         case Opt_add:
1392                 err = au_br_add(sb, &opt->add,
1393                                 au_ftest_opts(opts->flags, REMOUNT));
1394                 if (!err) {
1395                         err = 1;
1396                         au_fset_opts(opts->flags, REFRESH);
1397                 }
1398                 break;
1399
1400         case Opt_del:
1401         case Opt_idel:
1402                 err = au_br_del(sb, &opt->del,
1403                                 au_ftest_opts(opts->flags, REMOUNT));
1404                 if (!err) {
1405                         err = 1;
1406                         au_fset_opts(opts->flags, TRUNC_XIB);
1407                         au_fset_opts(opts->flags, REFRESH);
1408                 }
1409                 break;
1410
1411         case Opt_mod:
1412         case Opt_imod:
1413                 err = au_br_mod(sb, &opt->mod,
1414                                 au_ftest_opts(opts->flags, REMOUNT),
1415                                 &do_refresh);
1416                 if (!err) {
1417                         err = 1;
1418                         if (do_refresh)
1419                                 au_fset_opts(opts->flags, REFRESH);
1420                 }
1421                 break;
1422         }
1423
1424         return err;
1425 }
1426
1427 static int au_opt_xino(struct super_block *sb, struct au_opt *opt,
1428                        struct au_opt_xino **opt_xino,
1429                        struct au_opts *opts)
1430 {
1431         int err;
1432         aufs_bindex_t bend, bindex;
1433         struct dentry *root, *parent, *h_root;
1434
1435         err = 0;
1436         switch (opt->type) {
1437         case Opt_xino:
1438                 err = au_xino_set(sb, &opt->xino,
1439                                   !!au_ftest_opts(opts->flags, REMOUNT));
1440                 if (unlikely(err))
1441                         break;
1442
1443                 *opt_xino = &opt->xino;
1444                 au_xino_brid_set(sb, -1);
1445
1446                 /* safe d_parent access */
1447                 parent = opt->xino.file->f_dentry->d_parent;
1448                 root = sb->s_root;
1449                 bend = au_sbend(sb);
1450                 for (bindex = 0; bindex <= bend; bindex++) {
1451                         h_root = au_h_dptr(root, bindex);
1452                         if (h_root == parent) {
1453                                 au_xino_brid_set(sb, au_sbr_id(sb, bindex));
1454                                 break;
1455                         }
1456                 }
1457                 break;
1458
1459         case Opt_noxino:
1460                 au_xino_clr(sb);
1461                 au_xino_brid_set(sb, -1);
1462                 *opt_xino = (void *)-1;
1463                 break;
1464         }
1465
1466         return err;
1467 }
1468
1469 int au_opts_verify(struct super_block *sb, unsigned long sb_flags,
1470                    unsigned int pending)
1471 {
1472         int err;
1473         aufs_bindex_t bindex, bend;
1474         unsigned char do_plink, skip, do_free;
1475         struct au_branch *br;
1476         struct au_wbr *wbr;
1477         struct dentry *root;
1478         struct inode *dir, *h_dir;
1479         struct au_sbinfo *sbinfo;
1480         struct au_hinode *hdir;
1481
1482         SiMustAnyLock(sb);
1483
1484         sbinfo = au_sbi(sb);
1485         AuDebugOn(!(sbinfo->si_mntflags & AuOptMask_UDBA));
1486
1487         if (!(sb_flags & MS_RDONLY)) {
1488                 if (unlikely(!au_br_writable(au_sbr_perm(sb, 0))))
1489                         pr_warn("first branch should be rw\n");
1490                 if (unlikely(au_opt_test(sbinfo->si_mntflags, SHWH)))
1491                         pr_warn("shwh should be used with ro\n");
1492         }
1493
1494         if (au_opt_test((sbinfo->si_mntflags | pending), UDBA_HNOTIFY)
1495             && !au_opt_test(sbinfo->si_mntflags, XINO))
1496                 pr_warn("udba=*notify requires xino\n");
1497
1498         err = 0;
1499         root = sb->s_root;
1500         dir = root->d_inode;
1501         do_plink = !!au_opt_test(sbinfo->si_mntflags, PLINK);
1502         bend = au_sbend(sb);
1503         for (bindex = 0; !err && bindex <= bend; bindex++) {
1504                 skip = 0;
1505                 h_dir = au_h_iptr(dir, bindex);
1506                 br = au_sbr(sb, bindex);
1507                 do_free = 0;
1508
1509                 wbr = br->br_wbr;
1510                 if (wbr)
1511                         wbr_wh_read_lock(wbr);
1512
1513                 if (!au_br_writable(br->br_perm)) {
1514                         do_free = !!wbr;
1515                         skip = (!wbr
1516                                 || (!wbr->wbr_whbase
1517                                     && !wbr->wbr_plink
1518                                     && !wbr->wbr_orph));
1519                 } else if (!au_br_wh_linkable(br->br_perm)) {
1520                         /* skip = (!br->br_whbase && !br->br_orph); */
1521                         skip = (!wbr || !wbr->wbr_whbase);
1522                         if (skip && wbr) {
1523                                 if (do_plink)
1524                                         skip = !!wbr->wbr_plink;
1525                                 else
1526                                         skip = !wbr->wbr_plink;
1527                         }
1528                 } else {
1529                         /* skip = (br->br_whbase && br->br_ohph); */
1530                         skip = (wbr && wbr->wbr_whbase);
1531                         if (skip) {
1532                                 if (do_plink)
1533                                         skip = !!wbr->wbr_plink;
1534                                 else
1535                                         skip = !wbr->wbr_plink;
1536                         }
1537                 }
1538                 if (wbr)
1539                         wbr_wh_read_unlock(wbr);
1540
1541                 if (skip)
1542                         continue;
1543
1544                 hdir = au_hi(dir, bindex);
1545                 au_hn_imtx_lock_nested(hdir, AuLsc_I_PARENT);
1546                 if (wbr)
1547                         wbr_wh_write_lock(wbr);
1548                 err = au_wh_init(br, sb);
1549                 if (wbr)
1550                         wbr_wh_write_unlock(wbr);
1551                 au_hn_imtx_unlock(hdir);
1552
1553                 if (!err && do_free) {
1554                         kfree(wbr);
1555                         br->br_wbr = NULL;
1556                 }
1557         }
1558
1559         return err;
1560 }
1561
1562 int au_opts_mount(struct super_block *sb, struct au_opts *opts)
1563 {
1564         int err;
1565         unsigned int tmp;
1566         aufs_bindex_t bindex, bend;
1567         struct au_opt *opt;
1568         struct au_opt_xino *opt_xino, xino;
1569         struct au_sbinfo *sbinfo;
1570         struct au_branch *br;
1571
1572         SiMustWriteLock(sb);
1573
1574         err = 0;
1575         opt_xino = NULL;
1576         opt = opts->opt;
1577         while (err >= 0 && opt->type != Opt_tail)
1578                 err = au_opt_simple(sb, opt++, opts);
1579         if (err > 0)
1580                 err = 0;
1581         else if (unlikely(err < 0))
1582                 goto out;
1583
1584         /* disable xino and udba temporary */
1585         sbinfo = au_sbi(sb);
1586         tmp = sbinfo->si_mntflags;
1587         au_opt_clr(sbinfo->si_mntflags, XINO);
1588         au_opt_set_udba(sbinfo->si_mntflags, UDBA_REVAL);
1589
1590         opt = opts->opt;
1591         while (err >= 0 && opt->type != Opt_tail)
1592                 err = au_opt_br(sb, opt++, opts);
1593         if (err > 0)
1594                 err = 0;
1595         else if (unlikely(err < 0))
1596                 goto out;
1597
1598         bend = au_sbend(sb);
1599         if (unlikely(bend < 0)) {
1600                 err = -EINVAL;
1601                 pr_err("no branches\n");
1602                 goto out;
1603         }
1604
1605         if (au_opt_test(tmp, XINO))
1606                 au_opt_set(sbinfo->si_mntflags, XINO);
1607         opt = opts->opt;
1608         while (!err && opt->type != Opt_tail)
1609                 err = au_opt_xino(sb, opt++, &opt_xino, opts);
1610         if (unlikely(err))
1611                 goto out;
1612
1613         err = au_opts_verify(sb, sb->s_flags, tmp);
1614         if (unlikely(err))
1615                 goto out;
1616
1617         /* restore xino */
1618         if (au_opt_test(tmp, XINO) && !opt_xino) {
1619                 xino.file = au_xino_def(sb);
1620                 err = PTR_ERR(xino.file);
1621                 if (IS_ERR(xino.file))
1622                         goto out;
1623
1624                 err = au_xino_set(sb, &xino, /*remount*/0);
1625                 fput(xino.file);
1626                 if (unlikely(err))
1627                         goto out;
1628         }
1629
1630         /* restore udba */
1631         tmp &= AuOptMask_UDBA;
1632         sbinfo->si_mntflags &= ~AuOptMask_UDBA;
1633         sbinfo->si_mntflags |= tmp;
1634         bend = au_sbend(sb);
1635         for (bindex = 0; bindex <= bend; bindex++) {
1636                 br = au_sbr(sb, bindex);
1637                 err = au_hnotify_reset_br(tmp, br, br->br_perm);
1638                 if (unlikely(err))
1639                         AuIOErr("hnotify failed on br %d, %d, ignored\n",
1640                                 bindex, err);
1641                 /* go on even if err */
1642         }
1643         if (au_opt_test(tmp, UDBA_HNOTIFY)) {
1644                 struct inode *dir = sb->s_root->d_inode;
1645                 au_hn_reset(dir, au_hi_flags(dir, /*isdir*/1) & ~AuHi_XINO);
1646         }
1647
1648 out:
1649         return err;
1650 }
1651
1652 int au_opts_remount(struct super_block *sb, struct au_opts *opts)
1653 {
1654         int err, rerr;
1655         struct inode *dir;
1656         struct au_opt_xino *opt_xino;
1657         struct au_opt *opt;
1658         struct au_sbinfo *sbinfo;
1659
1660         SiMustWriteLock(sb);
1661
1662         dir = sb->s_root->d_inode;
1663         sbinfo = au_sbi(sb);
1664         err = 0;
1665         opt_xino = NULL;
1666         opt = opts->opt;
1667         while (err >= 0 && opt->type != Opt_tail) {
1668                 err = au_opt_simple(sb, opt, opts);
1669                 if (!err)
1670                         err = au_opt_br(sb, opt, opts);
1671                 if (!err)
1672                         err = au_opt_xino(sb, opt, &opt_xino, opts);
1673                 opt++;
1674         }
1675         if (err > 0)
1676                 err = 0;
1677         AuTraceErr(err);
1678         /* go on even err */
1679
1680         rerr = au_opts_verify(sb, opts->sb_flags, /*pending*/0);
1681         if (unlikely(rerr && !err))
1682                 err = rerr;
1683
1684         if (au_ftest_opts(opts->flags, TRUNC_XIB)) {
1685                 rerr = au_xib_trunc(sb);
1686                 if (unlikely(rerr && !err))
1687                         err = rerr;
1688         }
1689
1690         /* will be handled by the caller */
1691         if (!au_ftest_opts(opts->flags, REFRESH)
1692             && (opts->given_udba || au_opt_test(sbinfo->si_mntflags, XINO)))
1693                 au_fset_opts(opts->flags, REFRESH);
1694
1695         AuDbg("status 0x%x\n", opts->flags);
1696         return err;
1697 }
1698
1699 /* ---------------------------------------------------------------------- */
1700
1701 unsigned int au_opt_udba(struct super_block *sb)
1702 {
1703         return au_mntflags(sb) & AuOptMask_UDBA;
1704 }