← Back to branch summary

~ubuntu-branches/ubuntu/vivid/aufs/vivid

« back to all changes in this revision

Viewing changes to fs/aufs25/opts.c

  • Committer: Bazaar Package Importer
  • Author(s): Julian Andres Klode
  • Date: 2008-08-21 14:58:54 UTC
  • mfrom: (1.1.8 upstream) (4.1.1 lenny)
  • Revision ID: james.westby@ubuntu.com-20080821145854-4b49x09r4zmvlk5o
Tags: 0+20080719-4
http://bugs.debian.org/495921
01_vserver_apparmor.dpatch: [UPDATE] Disable vserver patches on kernel 
2.6.26, because they are not needed anymore. (Closes: #495921)

Show diffs side-by-side

added added

removed removed

Lines of Context:
fs/aufs25/opts.c
19
19
/*
20
20
 * mount options/flags
21
21
 *
22
 
 * $Id: opts.c,v 1.7 2008/06/02 02:39:03 sfjro Exp $
 
22
 * $Id: opts.c,v 1.10 2008/07/14 00:17:09 sfjro Exp $
23
23
 */
24
24
 
25
25
#include <linux/types.h> /* a distribution requires */
293
293
        char *buf;
294
294
        int ret;
295
295
 
296
 
        buf = kmalloc(s->to - s->from + 1, GFP_KERNEL);
 
296
        buf = kmalloc(s->to - s->from + 1, GFP_NOFS);
297
297
        if (!buf)
298
298
                return -ENOMEM;
299
299
        memcpy(buf, s->from, s->to - s->from);
341
341
        return err;
342
342
}
343
343
 
344
 
static noinline_for_stack int
345
 
au_wbr_create_val(char *str, struct au_opt_wbr_create *create)
 
344
static noinline_for_stack
 
345
int au_wbr_create_val(char *str, struct au_opt_wbr_create *create)
346
346
{
347
347
        int err, e;
348
348
        substring_t args[MAX_OPT_ARGS];
409
409
 
410
410
static const int lkup_dirflags = LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
411
411
 
412
 
static noinline_for_stack void dump_opts(struct au_opts *opts)
 
412
static void dump_opts(struct au_opts *opts)
413
413
{
414
414
#ifdef CONFIG_AUFS_DEBUG
415
415
        /* reduce stack space */
672
672
int au_opts_parse(struct super_block *sb, unsigned long flags, char *str,
673
673
                  struct au_opts *opts)
674
674
{
675
 
        int err, n, token, skipped;
 
675
        int err, n, token;
676
676
        struct dentry *root;
677
677
        struct au_opt *opt, *opt_tail;
678
678
        char *opt_str, *p;
679
 
        substring_t args[MAX_OPT_ARGS];
680
679
        aufs_bindex_t bindex, bend;
681
 
        struct nameidata nd;
 
680
        unsigned char skipped;
682
681
        union {
683
682
                struct au_opt_del *del;
684
683
                struct au_opt_mod *mod;
688
687
                struct au_opt_wbr_create *create;
689
688
        } u;
690
689
        struct file *file;
 
690
        /* reduce the stack space */
 
691
        struct {
 
692
                substring_t args[MAX_OPT_ARGS];
 
693
                struct nameidata nd;
 
694
        } *a;
691
695
 
692
696
        LKTRTrace("%s, nopts %d\n", str, opts->max_opt);
693
697
 
 
698
        err = -ENOMEM;
 
699
        a = kmalloc(sizeof(*a), GFP_NOFS);
 
700
        if (unlikely(!a))
 
701
                goto out;
 
702
 
694
703
        root = sb->s_root;
695
704
        err = 0;
696
705
        bindex = 0;
699
708
        opt->type = Opt_tail;
700
709
        while (!err && (opt_str = strsep(&str, ",")) && *opt_str) {
701
710
                err = -EINVAL;
702
 
                token = match_token(opt_str, options, args);
703
 
                LKTRTrace("%s, token %d, args[0]{%p, %p}\n",
704
 
                          opt_str, token, args[0].from, args[0].to);
 
711
                token = match_token(opt_str, options, a->args);
 
712
                LKTRTrace("%s, token %d, a->args[0]{%p, %p}\n",
 
713
                          opt_str, token, a->args[0].from, a->args[0].to);
705
714
 
706
715
                skipped = 0;
707
716
                switch (token) {
708
717
                case Opt_br:
709
718
                        err = 0;
710
 
                        while (!err && (opt_str = strsep(&args[0].from, ":"))
 
719
                        while (!err && (opt_str = strsep(&a->args[0].from, ":"))
711
720
                               && *opt_str) {
712
721
                                err = opt_add(opt, opt_str, sb, bindex++);
713
722
                                if (unlikely(!err && ++opt > opt_tail)) {
719
728
                        }
720
729
                        break;
721
730
                case Opt_add:
722
 
                        if (unlikely(match_int(&args[0], &n))) {
 
731
                        if (unlikely(match_int(&a->args[0], &n))) {
723
732
                                AuErr("bad integer in %s\n", opt_str);
724
733
                                break;
725
734
                        }
726
735
                        bindex = n;
727
 
                        err = opt_add(opt, args[1].from, sb, bindex);
 
736
                        err = opt_add(opt, a->args[1].from, sb, bindex);
728
737
                        break;
729
738
                case Opt_append:
730
 
                        err = opt_add(opt, args[0].from, sb, /*dummy bindex*/1);
 
739
                        err = opt_add(opt, a->args[0].from, sb,
 
740
                                      /*dummy bindex*/1);
731
741
                        if (!err)
732
742
                                opt->type = token;
733
743
                        break;
734
744
                case Opt_prepend:
735
 
                        err = opt_add(opt, args[0].from, sb, /*bindex*/0);
 
745
                        err = opt_add(opt, a->args[0].from, sb, /*bindex*/0);
736
746
                        if (!err)
737
747
                                opt->type = token;
738
748
                        break;
739
749
                case Opt_del:
740
750
                        u.del = &opt->del;
741
 
                        u.del->path = args[0].from;
 
751
                        u.del->path = a->args[0].from;
742
752
                        LKTRTrace("del path %s\n", u.del->path);
743
753
                        /* LSM may detect it */
744
754
                        /* do not superio. */
745
755
                        err = vfsub_path_lookup(u.del->path, lkup_dirflags,
746
 
                                                &nd);
 
756
                                                &a->nd);
747
757
                        if (unlikely(err)) {
748
758
                                AuErr("lookup failed %s (%d)\n",
749
759
                                      u.del->path, err);
750
760
                                break;
751
761
                        }
752
 
                        u.del->h_root = dget(nd.path.dentry);
753
 
                        path_put(&nd.path);
 
762
                        u.del->h_root = dget(a->nd.path.dentry);
 
763
                        path_put(&a->nd.path);
754
764
                        opt->type = token;
755
765
                        break;
756
766
#if 0 /* reserved for future use */
757
767
                case Opt_idel:
758
768
                        u.del = &opt->del;
759
769
                        u.del->path = "(indexed)";
760
 
                        if (unlikely(match_int(&args[0], &n))) {
 
770
                        if (unlikely(match_int(&a->args[0], &n))) {
761
771
                                AuErr("bad integer in %s\n", opt_str);
762
772
                                break;
763
773
                        }
776
786
#endif
777
787
                case Opt_mod:
778
788
                        u.mod = &opt->mod;
779
 
                        u.mod->path = args[0].from;
 
789
                        u.mod->path = a->args[0].from;
780
790
                        p = strchr(u.mod->path, '=');
781
791
                        if (unlikely(!p)) {
782
792
                                AuErr("no permssion %s\n", opt_str);
789
799
                        /* LSM may detect it */
790
800
                        /* do not superio. */
791
801
                        err = vfsub_path_lookup(u.mod->path, lkup_dirflags,
792
 
                                                &nd);
 
802
                                                &a->nd);
793
803
                        if (unlikely(err)) {
794
804
                                AuErr("lookup failed %s (%d)\n",
795
805
                                      u.mod->path, err);
796
806
                                break;
797
807
                        }
798
 
                        u.mod->h_root = dget(nd.path.dentry);
799
 
                        path_put(&nd.path);
 
808
                        u.mod->h_root = dget(a->nd.path.dentry);
 
809
                        path_put(&a->nd.path);
800
810
                        opt->type = token;
801
811
                        break;
802
812
#ifdef IMOD /* reserved for future use */
803
813
                case Opt_imod:
804
814
                        u.mod = &opt->mod;
805
815
                        u.mod->path = "(indexed)";
806
 
                        if (unlikely(match_int(&args[0], &n))) {
 
816
                        if (unlikely(match_int(&a->args[0], &n))) {
807
817
                                AuErr("bad integer in %s\n", opt_str);
808
818
                                break;
809
819
                        }
814
824
                                aufs_read_unlock(root, !AuLock_IR);
815
825
                                break;
816
826
                        }
817
 
                        u.mod->perm = br_perm_val(args[1].from);
 
827
                        u.mod->perm = br_perm_val(a->args[1].from);
818
828
                        LKTRTrace("mod path %s, perm 0x%x, %s\n",
819
 
                                  u.mod->path, u.mod->perm, args[1].from);
 
829
                                  u.mod->path, u.mod->perm, a->args[1].from);
820
830
                        err = 0;
821
831
                        u.mod->h_root = dget(au_h_dptr(root, bindex));
822
832
                        opt->type = token;
825
835
#endif
826
836
                case Opt_xino:
827
837
                        u.xino = &opt->xino;
828
 
                        file = au_xino_create(sb, args[0].from, /*silent*/0,
829
 
                                              /*parent*/NULL);
 
838
                        file = au_xino_create(sb, a->args[0].from, /*silent*/0);
830
839
                        err = PTR_ERR(file);
831
840
                        if (IS_ERR(file))
832
841
                                break;
833
842
                        err = -EINVAL;
834
843
                        if (unlikely(file->f_dentry->d_sb == sb)) {
835
844
                                fput(file);
836
 
                                AuErr("%s must be outside\n", args[0].from);
 
845
                                AuErr("%s must be outside\n", a->args[0].from);
837
846
                                break;
838
847
                        }
839
848
                        err = 0;
840
849
                        u.xino->file = file;
841
 
                        u.xino->path = args[0].from;
 
850
                        u.xino->path = a->args[0].from;
842
851
                        opt->type = token;
843
852
                        break;
844
853
 
845
854
#if 0 /* def CONFIG_AUFS_EXPORT */ /* reserved for futur use */
846
855
                case Opt_xinodir:
847
856
                        u.xinodir = &opt->xinodir;
848
 
                        u.xinodir->name = args[0].from;
 
857
                        u.xinodir->name = a->args[0].from;
849
858
                        err = vfsub_path_lookup(u.xinodir->name, lkup_dirflags,
850
 
                                                &nd);
 
859
                                                &a->nd);
851
860
                        if (unlikely(err)) {
852
861
                                AuErr("lookup failed %s (%d)\n",
853
862
                                      u.xinodir->name, err);
854
863
                                break;
855
864
                        }
856
 
                        u.xinodir->path = nd.path;
 
865
                        u.xinodir->path = a->nd.path;
857
866
                        /* do not path_put() */
858
867
                        opt->type = token;
859
868
                        break;
861
870
 
862
871
                case Opt_trunc_xino_path:
863
872
                        u.xino_itrunc = &opt->xino_itrunc;
864
 
                        p = args[0].from;
 
873
                        p = a->args[0].from;
865
874
                        LKTRTrace("trunc_xino path %s\n", p);
866
875
                        /* LSM may detect it */
867
876
                        /* do not superio. */
868
 
                        err = vfsub_path_lookup(p, lkup_dirflags, &nd);
 
877
                        err = vfsub_path_lookup(p, lkup_dirflags, &a->nd);
869
878
                        if (unlikely(err)) {
870
879
                                AuErr("lookup failed %s (%d)\n", p , err);
871
880
                                break;
874
883
                        aufs_read_lock(root, AuLock_FLUSH);
875
884
                        bend = au_sbend(sb);
876
885
                        for (bindex = 0; bindex <= bend; bindex++) {
877
 
                                if (au_h_dptr(root, bindex) == nd.path.dentry) {
 
886
                                if (au_h_dptr(root, bindex)
 
887
                                    == a->nd.path.dentry) {
878
888
                                        u.xino_itrunc->bindex = bindex;
879
889
                                        break;
880
890
                                }
881
891
                        }
882
892
                        aufs_read_unlock(root, !AuLock_IR);
883
 
                        path_put(&nd.path);
 
893
                        path_put(&a->nd.path);
884
894
                        if (unlikely(u.xino_itrunc->bindex < 0)) {
885
895
                                AuErr("no such branch %s\n", p);
886
896
                                err = -EINVAL;
891
901
 
892
902
                case Opt_itrunc_xino:
893
903
                        u.xino_itrunc = &opt->xino_itrunc;
894
 
                        if (unlikely(match_int(&args[0], &n))) {
 
904
                        if (unlikely(match_int(&a->args[0], &n))) {
895
905
                                AuErr("bad integer in %s\n", opt_str);
896
906
                                break;
897
907
                        }
908
918
                        break;
909
919
 
910
920
                case Opt_dirwh:
911
 
                        if (unlikely(match_int(&args[0], &opt->dirwh)))
 
921
                        if (unlikely(match_int(&a->args[0], &opt->dirwh)))
912
922
                                break;
913
923
                        err = 0;
914
924
                        opt->type = token;
915
925
                        break;
916
926
 
917
927
                case Opt_rdcache:
918
 
                        if (unlikely(match_int(&args[0], &opt->rdcache)))
 
928
                        if (unlikely(match_int(&a->args[0], &opt->rdcache)))
919
929
                                break;
920
930
                        err = 0;
921
931
                        opt->type = token;
956
966
                        break;
957
967
 
958
968
                case Opt_udba:
959
 
                        opt->udba = udba_val(args[0].from);
 
969
                        opt->udba = udba_val(a->args[0].from);
960
970
                        if (opt->udba >= 0) {
961
971
                                err = 0;
962
972
                                opt->type = token;
967
977
                case Opt_wbr_create:
968
978
                        u.create = &opt->wbr_create;
969
979
                        u.create->wbr_create
970
 
                                = au_wbr_create_val(args[0].from, u.create);
 
980
                                = au_wbr_create_val(a->args[0].from, u.create);
971
981
                        if (u.create->wbr_create >= 0) {
972
982
                                err = 0;
973
983
                                opt->type = token;
975
985
                                AuErr("wrong value, %s\n", opt_str);
976
986
                        break;
977
987
                case Opt_wbr_copyup:
978
 
                        opt->wbr_copyup = au_wbr_copyup_val(args[0].from);
 
988
                        opt->wbr_copyup = au_wbr_copyup_val(a->args[0].from);
979
989
                        if (opt->wbr_copyup >= 0) {
980
990
                                err = 0;
981
991
                                opt->type = token;
984
994
                        break;
985
995
 
986
996
                case Opt_coo:
987
 
                        opt->coo = coo_val(args[0].from);
 
997
                        opt->coo = coo_val(a->args[0].from);
988
998
                        if (opt->coo >= 0) {
989
999
                                err = 0;
990
1000
                                opt->type = token;
1016
1026
                }
1017
1027
        }
1018
1028
 
 
1029
        kfree(a);
1019
1030
        dump_opts(opts);
1020
1031
        if (unlikely(err))
1021
1032
                au_opts_free(opts);
 
1033
 
 
1034
 out:
1022
1035
        AuTraceErr(err);
1023
1036
        return err;
1024
1037
}
1286
1299
        return err;
1287
1300
}
1288
1301
 
1289
 
static noinline_for_stack int
1290
 
verify_opts(struct super_block *sb, unsigned int pending, int remount)
 
1302
static int verify_opts(struct super_block *sb, unsigned int pending,
 
1303
                       int remount)
1291
1304
{
1292
1305
        int err;
1293
1306
        aufs_bindex_t bindex, bend;
1362
1375
                if (skip)
1363
1376
                        continue;
1364
1377
 
1365
 
                au_hdir_lock(h_dir, dir, bindex);
 
1378
                mutex_lock_nested(&h_dir->i_mutex, AuLsc_I_PARENT);
1366
1379
                br_wh_write_lock(br);
1367
1380
                err = au_wh_init(au_h_dptr(root, bindex), br,
1368
 
                                 au_nfsmnt(sb, bindex), sb);
 
1381
                                 au_nfsmnt(sb, bindex), sb, bindex);
1369
1382
                br_wh_write_unlock(br);
1370
 
                au_hdir_unlock(h_dir, dir, bindex);
 
1383
                mutex_unlock(&h_dir->i_mutex);
1371
1384
        }
1372
1385
 
1373
1386
        AuTraceErr(err);
1443
1456
        /* enable xino */
1444
1457
        if (au_opt_test(tmp, XINO) && !opt_xino) {
1445
1458
                struct au_opt_xino xino;
 
1459
                struct au_branch *br;
1446
1460
 
1447
1461
                xino.file = au_xino_def(sb);
1448
1462
                err = PTR_ERR(xino.file);
1449
1463
                if (IS_ERR(xino.file))
1450
1464
                        goto out;
1451
1465
 
 
1466
                br = sbinfo->si_xino_def_br;
1452
1467
                err = au_xino_set(sb, &xino, /*remount*/0);
1453
1468
                fput(xino.file);
1454
1469
                if (unlikely(err))
1455
1470
                        goto out;
 
1471
                sbinfo->si_xino_def_br = br;
1456
1472
        }
1457
1473
 
1458
1474
        /* restore hinotify */
1477
1493
        struct au_opt_xino *opt_xino;
1478
1494
        struct au_opt_xinodir *opt_xinodir;
1479
1495
        struct au_opt *opt;
1480
 
        unsigned int dlgt;
 
1496
        unsigned char dlgt;
1481
1497
        struct au_sbinfo *sbinfo;
1482
1498
 
1483
1499
        AuTraceEnter();