← Back to branch summary

~ubuntu-branches/ubuntu/raring/aufs/raring

« back to all changes in this revision

Viewing changes to fs/aufs/opts.c

  • Committer: Bazaar Package Importer
  • Author(s): Julian Andres Klode
  • Date: 2008-05-06 18:35:50 UTC
  • mfrom: (1.1.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20080506183550-0b6c974kkgc46oeh
Tags: 0+20080506-1
http://bugs.debian.org/479717
http://bugs.debian.org/475042
* New upstream release, supports Kernel 2.6.25 (Closes: #479717)
* Fix building with older Kernels (Closes: #475042)
* Update the patches 01, 04 and 07 to also patch fs/aufs25

Show diffs side-by-side

added added

removed removed

Lines of Context:
fs/aufs/opts.c
1
1
/*
2
 
 * Copyright (C) 2005, 2006, 2007, 2008 Junjiro Okajima
 
2
 * Copyright (C) 2005-2008 Junjiro Okajima
3
3
 *
4
4
 * This program, aufs is free software; you can redistribute it and/or modify
5
5
 * it under the terms of the GNU General Public License as published by
16
16
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17
17
 */
18
18
 
19
 
/* $Id: opts.c,v 1.59 2008/03/31 07:45:32 sfjro Exp $ */
 
19
/*
 
20
 * mount options/flags
 
21
 *
 
22
 * $Id: opts.c,v 1.61 2008/04/13 23:44:07 sfjro Exp $
 
23
 */
20
24
 
21
25
#include <linux/types.h> /* a distribution requires */
22
26
#include <linux/parser.h>
23
27
#include "aufs.h"
24
28
 
25
 
void au_opts_flags_def(struct au_opts_flags *flags)
26
 
{
27
 
        // self-check at build time.
28
 
        flags->f_wbr_create = AuWbrCreate_Last - 1;
29
 
 
30
 
        flags->f_xino = AuXino_XINO;
31
 
        flags->f_trunc_xino = 0;
32
 
        flags->f_dirperm1 = 0;
33
 
        flags->f_shwh = 0;
34
 
        flags->f_udba = AuUdba_REVAL;
35
 
        flags->f_dlgt = 0;
36
 
        flags->f_plink = 1;
37
 
        flags->f_warn_perm = 1;
38
 
        flags->f_coo = AuCoo_NONE;
39
 
        flags->f_always_diropq = 0;
40
 
        flags->f_refrof = 0;
41
 
        flags->f_verbose = 0;
42
 
        flags->f_wbr_copyup = AuWbrCopyup_TDP;
43
 
        flags->f_wbr_create = AuWbrCreate_TDP;
44
 
 
45
 
#ifdef CONFIG_AUFS_COMPAT
46
 
        flags->f_always_diropq = 1;
47
 
#endif
48
 
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 16)
49
 
        flags->f_plink = 0;
50
 
#endif
51
 
}
52
 
 
53
29
/* ---------------------------------------------------------------------- */
54
30
 
55
31
enum {
248
224
/* ---------------------------------------------------------------------- */
249
225
 
250
226
static match_table_t udbalevel = {
251
 
        {AuUdba_REVAL, "reval"},
 
227
        {AuOpt_UDBA_REVAL, "reval"},
252
228
#ifdef CONFIG_AUFS_HINOTIFY
253
 
        {AuUdba_INOTIFY, "inotify"},
 
229
        {AuOpt_UDBA_INOTIFY, "inotify"},
254
230
#endif
255
 
        {AuUdba_NONE, "none"},
 
231
        {AuOpt_UDBA_NONE, "none"},
256
232
        {-1, NULL}
257
233
};
258
234
 
270
246
/* ---------------------------------------------------------------------- */
271
247
 
272
248
static match_table_t coolevel = {
273
 
        {AuCoo_LEAF, "leaf"},
274
 
        {AuCoo_ALL, "all"},
275
 
        {AuCoo_NONE, "none"},
 
249
        {AuOpt_COO_NONE, "none"},
 
250
        {AuOpt_COO_LEAF, "leaf"},
 
251
        {AuOpt_COO_ALL, "all"},
276
252
        {-1, NULL}
277
253
};
278
254
 
757
733
                                                &nd);
758
734
                        if (unlikely(err)) {
759
735
                                AuErr("lookup failed %s (%d)\n",
760
 
                                    u.del->path, err);
 
736
                                      u.del->path, err);
761
737
                                break;
762
738
                        }
763
739
                        u.del->h_root = dget(nd.dentry);
774
750
                        }
775
751
                        bindex = n;
776
752
                        aufs_read_lock(root, AuLock_FLUSH);
777
 
                        if (bindex < 0 || sbend(sb) < bindex) {
 
753
                        if (bindex < 0 || au_sbend(sb) < bindex) {
778
754
                                AuErr("out of bounds, %d\n", bindex);
779
755
                                aufs_read_unlock(root, !AuLock_IR);
780
756
                                break;
803
779
                                                &nd);
804
780
                        if (unlikely(err)) {
805
781
                                AuErr("lookup failed %s (%d)\n",
806
 
                                    u.mod->path, err);
 
782
                                      u.mod->path, err);
807
783
                                break;
808
784
                        }
809
785
                        u.mod->h_root = dget(nd.dentry);
820
796
                        }
821
797
                        bindex = n;
822
798
                        aufs_read_lock(root, AuLock_FLUSH);
823
 
                        if (bindex < 0 || sbend(sb) < bindex) {
 
799
                        if (bindex < 0 || au_sbend(sb) < bindex) {
824
800
                                AuErr("out of bounds, %d\n", bindex);
825
801
                                aufs_read_unlock(root, !AuLock_IR);
826
802
                                break;
836
812
#endif
837
813
                case Opt_xino:
838
814
                        u.xino = &opt->xino;
839
 
                        file = xino_create(sb, args[0].from, /*silent*/0,
840
 
                                           /*parent*/NULL);
 
815
                        file = au_xino_create(sb, args[0].from, /*silent*/0,
 
816
                                              /*parent*/NULL);
841
817
                        err = PTR_ERR(file);
842
818
                        if (IS_ERR(file))
843
819
                                break;
866
842
                        }
867
843
                        u.xino_itrunc->bindex = -1;
868
844
                        aufs_read_lock(root, AuLock_FLUSH);
869
 
                        bend = sbend(sb);
 
845
                        bend = au_sbend(sb);
870
846
                        for (bindex = 0; bindex <= bend; bindex++) {
871
847
                                if (au_h_dptr_i(root, bindex) == nd.dentry) {
872
848
                                        u.xino_itrunc->bindex = bindex;
891
867
                        }
892
868
                        u.xino_itrunc->bindex = n;
893
869
                        aufs_read_lock(root, AuLock_FLUSH);
894
 
                        if (n < 0 || sbend(sb) < n) {
 
870
                        if (n < 0 || au_sbend(sb) < n) {
895
871
                                AuErr("out of bounds, %d\n", n);
896
872
                                aufs_read_unlock(root, !AuLock_IR);
897
873
                                break;
1021
997
                         struct au_opts *opts)
1022
998
{
1023
999
        int err;
1024
 
        struct aufs_sbinfo *sbinfo;
1025
 
        struct au_opts_flags *given;
 
1000
        struct au_sbinfo *sbinfo;
1026
1001
        struct au_opt_wbr_create *create;
1027
1002
 
1028
1003
        AuTraceEnter();
1029
1004
 
1030
1005
        err = 1; /* handled */
1031
 
        sbinfo = stosi(sb);
1032
 
        given = &opts->given;
 
1006
        sbinfo = au_sbi(sb);
1033
1007
        switch (opt->type) {
1034
1008
        case Opt_udba:
1035
 
                AuFlagSet(sbinfo, f_udba, opt->udba);
1036
 
                given->f_udba = 1;
 
1009
                sbinfo->si_mntflags &= ~AuOptMask_UDBA;
 
1010
                sbinfo->si_mntflags |= opt->udba;
 
1011
                opts->given_udba |= opt->udba;
1037
1012
                break;
1038
1013
 
1039
1014
        case Opt_plink:
1040
 
                AuFlagSet(sbinfo, f_plink, 1);
1041
 
                given->f_plink = 1;
 
1015
                au_opt_set(sbinfo->si_mntflags, PLINK);
1042
1016
                break;
1043
1017
        case Opt_noplink:
1044
 
                if (AuFlag(sbinfo, f_plink))
1045
 
                        au_put_plink(sb);
1046
 
                AuFlagSet(sbinfo, f_plink, 0);
1047
 
                given->f_plink = 1;
 
1018
                if (au_opt_test(sbinfo->si_mntflags, PLINK))
 
1019
                        au_plink_put(sb);
 
1020
                au_opt_clr(sbinfo->si_mntflags, PLINK);
1048
1021
                break;
1049
1022
        case Opt_list_plink:
1050
 
                if (AuFlag(sbinfo, f_plink))
1051
 
                        au_list_plink(sb);
 
1023
                if (au_opt_test(sbinfo->si_mntflags, PLINK))
 
1024
                        au_plink_list(sb);
1052
1025
                break;
1053
1026
        case Opt_clean_plink:
1054
 
                if (AuFlag(sbinfo, f_plink))
1055
 
                        au_put_plink(sb);
 
1027
                if (au_opt_test(sbinfo->si_mntflags, PLINK))
 
1028
                        au_plink_put(sb);
1056
1029
                break;
1057
1030
 
1058
1031
        case Opt_diropq_a:
1059
 
                AuFlagSet(sbinfo, f_always_diropq, 1);
1060
 
                given->f_always_diropq = 1;
 
1032
                au_opt_set(sbinfo->si_mntflags, ALWAYS_DIROPQ);
1061
1033
                break;
1062
1034
        case Opt_diropq_w:
1063
 
                AuFlagSet(sbinfo, f_always_diropq, 0);
1064
 
                given->f_always_diropq = 1;
 
1035
                au_opt_clr(sbinfo->si_mntflags, ALWAYS_DIROPQ);
1065
1036
                break;
1066
1037
 
1067
1038
        case Opt_dlgt:
1068
 
                AuFlagSet(sbinfo, f_dlgt, 1);
1069
 
                given->f_dlgt = 1;
 
1039
                au_opt_set(sbinfo->si_mntflags, DLGT);
1070
1040
                break;
1071
1041
        case Opt_nodlgt:
1072
 
                AuFlagSet(sbinfo, f_dlgt, 0);
1073
 
                given->f_dlgt = 1;
 
1042
                au_opt_clr(sbinfo->si_mntflags, DLGT);
1074
1043
                break;
1075
1044
 
1076
1045
        case Opt_warn_perm:
1077
 
                AuFlagSet(sbinfo, f_warn_perm, 1);
1078
 
                given->f_warn_perm = 1;
 
1046
                au_opt_set(sbinfo->si_mntflags, WARN_PERM);
1079
1047
                break;
1080
1048
        case Opt_nowarn_perm:
1081
 
                AuFlagSet(sbinfo, f_warn_perm, 0);
1082
 
                given->f_warn_perm = 1;
 
1049
                au_opt_clr(sbinfo->si_mntflags, WARN_PERM);
1083
1050
                break;
1084
1051
 
1085
1052
        case Opt_refrof:
1086
 
                AuFlagSet(sbinfo, f_refrof, 1);
1087
 
                given->f_refrof = 1;
 
1053
                au_opt_set(sbinfo->si_mntflags, REFROF);
1088
1054
                break;
1089
1055
        case Opt_norefrof:
1090
 
                //coo_set(sb, AuFlag_COO_LEAF);
1091
 
                AuFlagSet(sbinfo, f_refrof, 0);
1092
 
                given->f_refrof = 1;
 
1056
                //au_opt_set(sbinfo->si_mntflags, COO_LEAF);
 
1057
                au_opt_clr(sbinfo->si_mntflags, REFROF);
1093
1058
                break;
1094
1059
 
1095
1060
        case Opt_verbose:
1096
 
                AuFlagSet(sbinfo, f_verbose, 1);
1097
 
                given->f_verbose = 1;
 
1061
                au_opt_set(sbinfo->si_mntflags, VERBOSE);
1098
1062
                break;
1099
1063
        case Opt_noverbose:
1100
 
                AuFlagSet(sbinfo, f_verbose, 0);
1101
 
                given->f_verbose = 1;
 
1064
                au_opt_clr(sbinfo->si_mntflags, VERBOSE);
1102
1065
                break;
1103
1066
 
1104
1067
        case Opt_wbr_create:
1108
1071
                        if (!err)
1109
1072
                                err = 1;
1110
1073
                }
1111
 
                AuFlagSet(sbinfo, f_wbr_create, create->wbr_create);
 
1074
                sbinfo->si_wbr_create = create->wbr_create;
1112
1075
                sbinfo->si_wbr_create_ops
1113
1076
                        = au_wbr_create_ops + create->wbr_create;
1114
1077
                switch (create->wbr_create) {
1126
1089
                }
1127
1090
                if (sbinfo->si_wbr_create_ops->init)
1128
1091
                        sbinfo->si_wbr_create_ops->init(sb); /* ignore */
1129
 
                given->f_wbr_create = 1;
1130
1092
                break;
1131
1093
        case Opt_wbr_copyup:
1132
 
                AuFlagSet(sbinfo, f_wbr_copyup, opt->wbr_copyup);
 
1094
                sbinfo->si_wbr_copyup = opt->wbr_copyup;
1133
1095
                sbinfo->si_wbr_copyup_ops = au_wbr_copyup_ops + opt->wbr_copyup;
1134
 
                given->f_wbr_copyup = 1;
1135
1096
                break;
1136
1097
 
1137
1098
        case Opt_coo:
1138
 
                AuFlagSet(sbinfo, f_coo, opt->coo);
1139
 
                given->f_coo = 1;
 
1099
                sbinfo->si_mntflags &= ~AuOptMask_COO;
 
1100
                sbinfo->si_mntflags |= opt->coo;
1140
1101
                break;
1141
1102
 
1142
1103
        case Opt_dirwh:
1148
1109
                break;
1149
1110
 
1150
1111
        case Opt_trunc_xino:
1151
 
                AuFlagSet(sbinfo, f_trunc_xino, 1);
1152
 
                given->f_trunc_xino = 1;
 
1112
                au_opt_set(sbinfo->si_mntflags, TRUNC_XINO);
1153
1113
                break;
1154
1114
        case Opt_notrunc_xino:
1155
 
                AuFlagSet(sbinfo, f_trunc_xino, 0);
1156
 
                given->f_trunc_xino = 1;
 
1115
                au_opt_clr(sbinfo->si_mntflags, TRUNC_XINO);
1157
1116
                break;
1158
1117
 
1159
1118
        case Opt_dirperm1:
1160
 
                AuFlagSet(sbinfo, f_dirperm1, 1);
1161
 
                given->f_dirperm1 = 1;
 
1119
                au_opt_set(sbinfo->si_mntflags, DIRPERM1);
1162
1120
                break;
1163
1121
        case Opt_nodirperm1:
1164
 
                AuFlagSet(sbinfo, f_dirperm1, 0);
1165
 
                given->f_dirperm1 = 1;
 
1122
                au_opt_clr(sbinfo->si_mntflags, DIRPERM1);
1166
1123
                break;
1167
1124
 
1168
1125
        case Opt_shwh:
1169
 
                AuFlagSet(sbinfo, f_shwh, 1);
1170
 
                given->f_shwh = 1;
 
1126
                au_opt_set(sbinfo->si_mntflags, SHWH);
1171
1127
                break;
1172
1128
        case Opt_noshwh:
1173
 
                AuFlagSet(sbinfo, f_shwh, 0);
1174
 
                given->f_shwh = 1;
 
1129
                au_opt_clr(sbinfo->si_mntflags, SHWH);
1175
1130
                break;
1176
1131
 
1177
1132
        case Opt_trunc_xino_path:
1178
1133
        case Opt_itrunc_xino:
1179
 
                err = xino_trunc(sb, opt->xino_itrunc.bindex);
 
1134
                err = au_xino_trunc(sb, opt->xino_itrunc.bindex);
1180
1135
                if (!err)
1181
1136
                        err = 1;
1182
1137
                break;
1213
1168
        err = 0;
1214
1169
        switch (opt->type) {
1215
1170
        case Opt_append:
1216
 
                opt->add.bindex = sbend(sb) + 1;
 
1171
                opt->add.bindex = au_sbend(sb) + 1;
1217
1172
                if (unlikely(opt->add.bindex < 0))
1218
1173
                        opt->add.bindex = 0;
1219
1174
                goto add;
1221
1176
                opt->add.bindex = 0;
1222
1177
        add:
1223
1178
        case Opt_add:
1224
 
                err = br_add(sb, &opt->add,
1225
 
                             au_ftest_opts(opts->flags, REMOUNT));
 
1179
                err = au_br_add(sb, &opt->add,
 
1180
                                au_ftest_opts(opts->flags, REMOUNT));
1226
1181
                if (!err) {
1227
1182
                        err = 1;
1228
1183
                        au_fset_opts(opts->flags, REFRESH_DIR);
1229
 
                        if (unlikely(br_whable(opt->add.perm)))
 
1184
                        if (unlikely(au_br_whable(opt->add.perm)))
1230
1185
                                au_fset_opts(opts->flags, REFRESH_NONDIR);
1231
1186
                }
1232
1187
                break;
1233
1188
 
1234
1189
        case Opt_del:
1235
1190
        case Opt_idel:
1236
 
                err = br_del(sb, &opt->del,
1237
 
                             au_ftest_opts(opts->flags, REMOUNT));
 
1191
                err = au_br_del(sb, &opt->del,
 
1192
                                au_ftest_opts(opts->flags, REMOUNT));
1238
1193
                if (!err) {
1239
1194
                        err = 1;
1240
1195
                        au_fset_opts(opts->flags, TRUNC_XIB);
1245
1200
 
1246
1201
        case Opt_mod:
1247
1202
        case Opt_imod:
1248
 
                err = br_mod(sb, &opt->mod, au_ftest_opts(opts->flags, REMOUNT),
1249
 
                             &do_refresh);
 
1203
                err = au_br_mod(sb, &opt->mod,
 
1204
                                au_ftest_opts(opts->flags, REMOUNT),
 
1205
                                &do_refresh);
1250
1206
                if (!err) {
1251
1207
                        err = 1;
1252
1208
                        if (unlikely(do_refresh)) {
1271
1227
        err = 0;
1272
1228
        switch (opt->type) {
1273
1229
        case Opt_xino:
1274
 
                err = xino_set(sb, &opt->xino,
1275
 
                               au_ftest_opts(opts->flags, REMOUNT));
 
1230
                err = au_xino_set(sb, &opt->xino,
 
1231
                                  au_ftest_opts(opts->flags, REMOUNT));
1276
1232
                if (!err)
1277
1233
                        *opt_xino = &opt->xino;
1278
1234
                break;
1279
1235
        case Opt_noxino:
1280
 
                xino_clr(sb);
 
1236
                au_xino_clr(sb);
1281
1237
                *opt_xino = (void *)-1;
1282
1238
                break;
1283
1239
        }
1286
1242
        return err;
1287
1243
}
1288
1244
 
1289
 
static int verify_opts(struct super_block *sb, struct au_opts_flags *pending,
 
1245
static int verify_opts(struct super_block *sb, unsigned int pending,
1290
1246
                       int remount)
1291
1247
{
1292
1248
        int err;
1293
1249
        aufs_bindex_t bindex, bend;
1294
 
        struct aufs_branch *br;
 
1250
        struct au_branch *br;
1295
1251
        struct dentry *root;
1296
1252
        struct inode *dir;
1297
1253
        unsigned int do_plink;
1298
 
        struct aufs_sbinfo *sbinfo;
 
1254
        unsigned int mnt_flags;
1299
1255
 
1300
1256
        AuTraceEnter();
 
1257
        mnt_flags = au_mntflags(sb);
 
1258
        AuDebugOn(!(mnt_flags & AuOptMask_COO));
 
1259
        AuDebugOn(!(mnt_flags & AuOptMask_UDBA));
1301
1260
 
1302
1261
        if (!(sb->s_flags & MS_RDONLY)) {
1303
 
                if (unlikely(!br_writable(sbr_perm(sb, 0))))
 
1262
                if (unlikely(!au_br_writable(au_sbr_perm(sb, 0))))
1304
1263
                        AuWarn("first branch should be rw\n");
1305
 
                if (unlikely(au_flag_test_shwh(sb)))
 
1264
                if (unlikely(au_opt_test(mnt_flags, SHWH)))
1306
1265
                        AuWarn("shwh should be used with ro\n");
1307
1266
        }
1308
1267
 
1309
 
        sbinfo = stosi(sb);
1310
 
        if (unlikely((au_flag_test_udba_inotify(sb)
1311
 
                      || pending->f_udba == AuUdba_INOTIFY)
1312
 
                     && AuFlag(sbinfo, f_xino) == AuXino_NONE))
 
1268
        if (unlikely(au_opt_test(mnt_flags | pending, UDBA_INOTIFY)
 
1269
                     && !au_opt_test(mnt_flags, XINO)))
1313
1270
                AuWarn("udba=inotify requires xino\n");
1314
1271
 
1315
1272
        err = 0;
1316
1273
        root = sb->s_root;
1317
1274
        dir = sb->s_root->d_inode;
1318
 
        do_plink = AuFlag(sbinfo, f_plink);
1319
 
        bend = sbend(sb);
 
1275
        do_plink = !!au_opt_test(mnt_flags, PLINK);
 
1276
        bend = au_sbend(sb);
1320
1277
        for (bindex = 0; !err && bindex <= bend; bindex++) {
1321
1278
                struct inode *h_dir;
1322
1279
                int skip;
1323
1280
 
1324
1281
                skip = 0;
1325
1282
                h_dir = au_h_iptr_i(dir, bindex);
1326
 
                br = stobr(sb, bindex);
 
1283
                br = au_sbr(sb, bindex);
1327
1284
                br_wh_read_lock(br);
1328
1285
                switch (br->br_perm) {
1329
1286
                case AuBr_RR:
1361
1318
                if (skip)
1362
1319
                        continue;
1363
1320
 
1364
 
                hdir_lock(h_dir, dir, bindex);
 
1321
                au_hdir_lock(h_dir, dir, bindex);
1365
1322
                br_wh_write_lock(br);
1366
 
                err = init_wh(au_h_dptr_i(root, bindex), br,
1367
 
                              au_nfsmnt(sb, bindex), sb);
 
1323
                err = au_wh_init(au_h_dptr_i(root, bindex), br,
 
1324
                                 au_nfsmnt(sb, bindex), sb);
1368
1325
                br_wh_write_unlock(br);
1369
 
                hdir_unlock(h_dir, dir, bindex);
 
1326
                au_hdir_unlock(h_dir, dir, bindex);
1370
1327
        }
1371
1328
 
1372
1329
        AuTraceErr(err);
1380
1337
        struct au_opt *opt;
1381
1338
        struct au_opt_xino *opt_xino;
1382
1339
        aufs_bindex_t bend;
1383
 
        struct aufs_sbinfo *sbinfo;
1384
 
        struct au_opts_flags tmp;
 
1340
        struct au_sbinfo *sbinfo;
 
1341
        unsigned int tmp;
1385
1342
 
1386
1343
        AuTraceEnter();
1387
1344
        SiMustWriteLock(sb);
1400
1357
                goto out;
1401
1358
 
1402
1359
        /* disable xino, hinotify, dlgt temporary */
1403
 
        sbinfo = stosi(sb);
1404
 
        tmp = sbinfo->au_si_flags;
1405
 
        AuFlagSet(sbinfo, f_xino, AuXino_NONE);
1406
 
        AuFlagSet(sbinfo, f_dlgt, 0);
1407
 
        AuFlagSet(sbinfo, f_udba, AuUdba_REVAL);
 
1360
        sbinfo = au_sbi(sb);
 
1361
        tmp = sbinfo->si_mntflags;
 
1362
        au_opt_clr(sbinfo->si_mntflags, XINO);
 
1363
        au_opt_clr(sbinfo->si_mntflags, DLGT);
 
1364
        au_opt_set_udba(sbinfo->si_mntflags, UDBA_REVAL);
1408
1365
 
1409
1366
        opt = opts->opt;
1410
1367
        while (err >= 0 && opt->type != Opt_tail)
1414
1371
        else if (unlikely(err < 0))
1415
1372
                goto out;
1416
1373
 
1417
 
        bend = sbend(sb);
 
1374
        bend = au_sbend(sb);
1418
1375
        if (unlikely(bend < 0)) {
1419
1376
                err = -EINVAL;
1420
1377
                AuErr("no branches\n");
1421
1378
                goto out;
1422
1379
        }
1423
1380
 
1424
 
        AuFlagSet(sbinfo, f_xino, tmp.f_xino);
 
1381
        if (au_opt_test(tmp, XINO))
 
1382
                au_opt_set(sbinfo->si_mntflags, XINO);
1425
1383
        opt = opts->opt;
1426
1384
        while (!err && opt->type != Opt_tail)
1427
1385
                err = au_opt_xino(sb, opt++, &opt_xino, opts);
1429
1387
                goto out;
1430
1388
 
1431
1389
        //todo: test this error case.
1432
 
        err = verify_opts(sb, &tmp, /*remount*/0);
 
1390
        err = verify_opts(sb, tmp, /*remount*/0);
1433
1391
        if (unlikely(err))
1434
1392
                goto out;
1435
1393
 
1436
1394
        /* enable xino */
1437
 
        if (tmp.f_xino != AuXino_NONE && !opt_xino) {
 
1395
        if (au_opt_test(tmp, XINO) && !opt_xino) {
1438
1396
                struct au_opt_xino xino;
1439
1397
 
1440
 
                xino.file = xino_def(sb);
 
1398
                xino.file = au_xino_def(sb);
1441
1399
                err = PTR_ERR(xino.file);
1442
1400
                if (IS_ERR(xino.file))
1443
1401
                        goto out;
1444
1402
 
1445
 
                err = xino_set(sb, &xino, /*remount*/0);
 
1403
                err = au_xino_set(sb, &xino, /*remount*/0);
1446
1404
                fput(xino.file);
1447
1405
                if (unlikely(err))
1448
1406
                        goto out;
1449
1407
        }
1450
1408
 
1451
1409
        /* restore hinotify */
1452
 
        AuFlagSet(sbinfo, f_udba, tmp.f_udba);
1453
 
        if (tmp.f_udba == AuUdba_INOTIFY)
 
1410
        sbinfo->si_mntflags &= ~AuOptMask_UDBA;
 
1411
        sbinfo->si_mntflags |= (tmp & AuOptMask_UDBA);
 
1412
        if (au_opt_test(tmp, UDBA_INOTIFY))
1454
1413
                au_reset_hinotify(dir, au_hi_flags(dir, 1) & ~AuHi_XINO);
1455
1414
 
1456
1415
        /* restore dlgt */
1457
 
        AuFlagSet(sbinfo, f_dlgt, tmp.f_dlgt);
 
1416
        if (au_opt_test_dlgt(tmp))
 
1417
                au_opt_set(sbinfo->si_mntflags, DLGT);
1458
1418
 
1459
1419
 out:
1460
1420
        AuTraceErr(err);
1468
1428
        struct au_opt_xino *opt_xino;
1469
1429
        struct au_opt *opt;
1470
1430
        unsigned int dlgt;
1471
 
        struct aufs_sbinfo *sbinfo;
 
1431
        struct au_sbinfo *sbinfo;
1472
1432
 
1473
1433
        AuTraceEnter();
1474
1434
        SiMustWriteLock(sb);
1475
1435
        DiMustWriteLock(sb->s_root);
1476
1436
        dir = sb->s_root->d_inode;
1477
1437
        IiMustWriteLock(dir);
1478
 
        //AuDebugOn(au_flag_test_udba_inotify(sb));
 
1438
        sbinfo = au_sbi(sb);
 
1439
        //AuDebugOn(au_opt_test(sbifno->si_mntflags, UDBA_INOTIFY));
1479
1440
 
1480
1441
        err = 0;
1481
 
        sbinfo = stosi(sb);
1482
 
        dlgt = au_need_dlgt(sb);
 
1442
        dlgt = !!au_opt_test_dlgt(sbinfo->si_mntflags);
1483
1443
        opt_xino = NULL;
1484
1444
        opt = opts->opt;
1485
1445
        while (err >= 0 && opt->type != Opt_tail) {
1486
1446
                err = au_opt_simple(sb, opt, opts);
1487
1447
 
1488
1448
                /* disable it temporary */
1489
 
                dlgt = au_need_dlgt(sb);
1490
 
                AuFlagSet(sbinfo, f_dlgt, 0);
 
1449
                dlgt = !!au_opt_test_dlgt(sbinfo->si_mntflags);
 
1450
                au_opt_clr(sbinfo->si_mntflags, DLGT);
1491
1451
 
1492
1452
                if (!err)
1493
1453
                        err = au_opt_br(sb, opt, opts);
1495
1455
                        err = au_opt_xino(sb, opt, &opt_xino, opts);
1496
1456
 
1497
1457
                /* restore it */
1498
 
                AuFlagSet(sbinfo, f_dlgt, dlgt);
 
1458
                if (unlikely(dlgt))
 
1459
                        au_opt_set(sbinfo->si_mntflags, DLGT);
1499
1460
                opt++;
1500
1461
        }
1501
1462
        if (err > 0)
1505
1466
        /* go on even err */
1506
1467
 
1507
1468
        //todo: test this error case.
1508
 
        AuFlagSet(sbinfo, f_dlgt, 0);
1509
 
        rerr = verify_opts(sb, &sbinfo->au_si_flags, /*remount*/1);
1510
 
        AuFlagSet(sbinfo, f_dlgt, dlgt);
 
1469
        au_opt_clr(sbinfo->si_mntflags, DLGT);
 
1470
        rerr = verify_opts(sb, sbinfo->si_mntflags, /*remount*/1);
 
1471
        if (unlikely(dlgt))
 
1472
                au_opt_set(sbinfo->si_mntflags, DLGT);
1511
1473
        if (unlikely(rerr && !err))
1512
1474
                err = rerr;
1513
1475
 
1514
1476
        if (unlikely(au_ftest_opts(opts->flags, TRUNC_XIB))) {
1515
 
                rerr = xib_trunc(sb);
 
1477
                rerr = au_xib_trunc(sb);
1516
1478
                if (unlikely(rerr && !err))
1517
1479
                        err = rerr;
1518
1480
        }
1519
1481
 
1520
1482
        /* they are handled by the caller */
1521
1483
        if (!au_ftest_opts(opts->flags, REFRESH_DIR)
1522
 
            && (opts->given.f_udba || AuFlag(sbinfo, f_xino) != AuXino_NONE))
 
1484
            && (opts->given_udba || au_opt_test(sbinfo->si_mntflags, XINO)))
1523
1485
                au_fset_opts(opts->flags, REFRESH_DIR);
1524
1486
 
1525
1487
        LKTRTrace("status 0x%x\n", opts->flags);