fs/aufs/opts.c

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