ubuntu/aufs/opts.c

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