lkml.org 
[lkml]   [2018]   [Sep]   [21]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH bpf-next 7/9] selftests/bpf: add verifier per-cpu cgroup storage tests
    Date
    This commits adds verifier tests covering per-cpu cgroup storage
    functionality. There are 6 new tests, which are exactly the same
    as for shared cgroup storage, but do use per-cpu cgroup storage
    map.

    Expected output:
    $ ./test_verifier
    #0/u add+sub+mul OK
    #0/p add+sub+mul OK
    ...
    #286/p invalid cgroup storage access 6 OK
    #287/p valid per-cpu cgroup storage access OK
    #288/p invalid per-cpu cgroup storage access 1 OK
    #289/p invalid per-cpu cgroup storage access 2 OK
    #290/p invalid per-cpu cgroup storage access 3 OK
    #291/p invalid per-cpu cgroup storage access 4 OK
    #292/p invalid per-cpu cgroup storage access 5 OK
    #293/p invalid per-cpu cgroup storage access 6 OK
    #294/p multiple registers share map_lookup_elem result OK
    ...
    #662/p mov64 src == dst OK
    #663/p mov64 src != dst OK
    Summary: 914 PASSED, 0 SKIPPED, 0 FAILED

    Signed-off-by: Roman Gushchin <guro@fb.com>
    Cc: Daniel Borkmann <daniel@iogearbox.net>
    Cc: Alexei Starovoitov <ast@kernel.org>
    ---
    tools/testing/selftests/bpf/test_verifier.c | 139 +++++++++++++++++++-
    1 file changed, 133 insertions(+), 6 deletions(-)

    diff --git a/tools/testing/selftests/bpf/test_verifier.c b/tools/testing/selftests/bpf/test_verifier.c
    index 67c412d19c09..c7d25f23baf9 100644
    --- a/tools/testing/selftests/bpf/test_verifier.c
    +++ b/tools/testing/selftests/bpf/test_verifier.c
    @@ -68,6 +68,7 @@ struct bpf_test {
    int fixup_prog2[MAX_FIXUPS];
    int fixup_map_in_map[MAX_FIXUPS];
    int fixup_cgroup_storage[MAX_FIXUPS];
    + int fixup_percpu_cgroup_storage[MAX_FIXUPS];
    const char *errstr;
    const char *errstr_unpriv;
    uint32_t retval;
    @@ -4676,7 +4677,7 @@ static struct bpf_test tests[] = {
    .prog_type = BPF_PROG_TYPE_CGROUP_SKB,
    },
    {
    - "invalid per-cgroup storage access 3",
    + "invalid cgroup storage access 3",
    .insns = {
    BPF_MOV64_IMM(BPF_REG_2, 0),
    BPF_LD_MAP_FD(BPF_REG_1, 0),
    @@ -4743,6 +4744,121 @@ static struct bpf_test tests[] = {
    .errstr = "get_local_storage() doesn't support non-zero flags",
    .prog_type = BPF_PROG_TYPE_CGROUP_SKB,
    },
    + {
    + "valid per-cpu cgroup storage access",
    + .insns = {
    + BPF_MOV64_IMM(BPF_REG_2, 0),
    + BPF_LD_MAP_FD(BPF_REG_1, 0),
    + BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
    + BPF_FUNC_get_local_storage),
    + BPF_LDX_MEM(BPF_W, BPF_REG_1, BPF_REG_0, 0),
    + BPF_MOV64_REG(BPF_REG_0, BPF_REG_1),
    + BPF_ALU64_IMM(BPF_AND, BPF_REG_0, 1),
    + BPF_EXIT_INSN(),
    + },
    + .fixup_percpu_cgroup_storage = { 1 },
    + .result = ACCEPT,
    + .prog_type = BPF_PROG_TYPE_CGROUP_SKB,
    + },
    + {
    + "invalid per-cpu cgroup storage access 1",
    + .insns = {
    + BPF_MOV64_IMM(BPF_REG_2, 0),
    + BPF_LD_MAP_FD(BPF_REG_1, 0),
    + BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
    + BPF_FUNC_get_local_storage),
    + BPF_LDX_MEM(BPF_W, BPF_REG_1, BPF_REG_0, 0),
    + BPF_MOV64_REG(BPF_REG_0, BPF_REG_1),
    + BPF_ALU64_IMM(BPF_AND, BPF_REG_0, 1),
    + BPF_EXIT_INSN(),
    + },
    + .fixup_map1 = { 1 },
    + .result = REJECT,
    + .errstr = "cannot pass map_type 1 into func bpf_get_local_storage",
    + .prog_type = BPF_PROG_TYPE_CGROUP_SKB,
    + },
    + {
    + "invalid per-cpu cgroup storage access 2",
    + .insns = {
    + BPF_MOV64_IMM(BPF_REG_2, 0),
    + BPF_LD_MAP_FD(BPF_REG_1, 1),
    + BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
    + BPF_FUNC_get_local_storage),
    + BPF_ALU64_IMM(BPF_AND, BPF_REG_0, 1),
    + BPF_EXIT_INSN(),
    + },
    + .result = REJECT,
    + .errstr = "fd 1 is not pointing to valid bpf_map",
    + .prog_type = BPF_PROG_TYPE_CGROUP_SKB,
    + },
    + {
    + "invalid per-cpu cgroup storage access 3",
    + .insns = {
    + BPF_MOV64_IMM(BPF_REG_2, 0),
    + BPF_LD_MAP_FD(BPF_REG_1, 0),
    + BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
    + BPF_FUNC_get_local_storage),
    + BPF_LDX_MEM(BPF_W, BPF_REG_1, BPF_REG_0, 256),
    + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 1),
    + BPF_MOV64_IMM(BPF_REG_0, 0),
    + BPF_EXIT_INSN(),
    + },
    + .fixup_percpu_cgroup_storage = { 1 },
    + .result = REJECT,
    + .errstr = "invalid access to map value, value_size=64 off=256 size=4",
    + .prog_type = BPF_PROG_TYPE_CGROUP_SKB,
    + },
    + {
    + "invalid per-cpu cgroup storage access 4",
    + .insns = {
    + BPF_MOV64_IMM(BPF_REG_2, 0),
    + BPF_LD_MAP_FD(BPF_REG_1, 0),
    + BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
    + BPF_FUNC_get_local_storage),
    + BPF_LDX_MEM(BPF_W, BPF_REG_1, BPF_REG_0, -2),
    + BPF_MOV64_REG(BPF_REG_0, BPF_REG_1),
    + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 1),
    + BPF_EXIT_INSN(),
    + },
    + .fixup_cgroup_storage = { 1 },
    + .result = REJECT,
    + .errstr = "invalid access to map value, value_size=64 off=-2 size=4",
    + .prog_type = BPF_PROG_TYPE_CGROUP_SKB,
    + },
    + {
    + "invalid per-cpu cgroup storage access 5",
    + .insns = {
    + BPF_MOV64_IMM(BPF_REG_2, 7),
    + BPF_LD_MAP_FD(BPF_REG_1, 0),
    + BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
    + BPF_FUNC_get_local_storage),
    + BPF_LDX_MEM(BPF_W, BPF_REG_1, BPF_REG_0, 0),
    + BPF_MOV64_REG(BPF_REG_0, BPF_REG_1),
    + BPF_ALU64_IMM(BPF_AND, BPF_REG_0, 1),
    + BPF_EXIT_INSN(),
    + },
    + .fixup_percpu_cgroup_storage = { 1 },
    + .result = REJECT,
    + .errstr = "get_local_storage() doesn't support non-zero flags",
    + .prog_type = BPF_PROG_TYPE_CGROUP_SKB,
    + },
    + {
    + "invalid per-cpu cgroup storage access 6",
    + .insns = {
    + BPF_MOV64_REG(BPF_REG_2, BPF_REG_1),
    + BPF_LD_MAP_FD(BPF_REG_1, 0),
    + BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
    + BPF_FUNC_get_local_storage),
    + BPF_LDX_MEM(BPF_W, BPF_REG_1, BPF_REG_0, 0),
    + BPF_MOV64_REG(BPF_REG_0, BPF_REG_1),
    + BPF_ALU64_IMM(BPF_AND, BPF_REG_0, 1),
    + BPF_EXIT_INSN(),
    + },
    + .fixup_percpu_cgroup_storage = { 1 },
    + .result = REJECT,
    + .errstr = "get_local_storage() doesn't support non-zero flags",
    + .prog_type = BPF_PROG_TYPE_CGROUP_SKB,
    + },
    {
    "multiple registers share map_lookup_elem result",
    .insns = {
    @@ -12615,15 +12731,17 @@ static int create_map_in_map(void)
    return outer_map_fd;
    }

    -static int create_cgroup_storage(void)
    +static int create_cgroup_storage(bool percpu)
    {
    + enum bpf_map_type type = percpu ? BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE :
    + BPF_MAP_TYPE_CGROUP_STORAGE;
    int fd;

    - fd = bpf_create_map(BPF_MAP_TYPE_CGROUP_STORAGE,
    - sizeof(struct bpf_cgroup_storage_key),
    + fd = bpf_create_map(type, sizeof(struct bpf_cgroup_storage_key),
    TEST_DATA_LEN, 0, 0);
    if (fd < 0)
    - printf("Failed to create array '%s'!\n", strerror(errno));
    + printf("Failed to create cgroup storage '%s'!\n",
    + strerror(errno));

    return fd;
    }
    @@ -12641,6 +12759,7 @@ static void do_test_fixup(struct bpf_test *test, struct bpf_insn *prog,
    int *fixup_prog2 = test->fixup_prog2;
    int *fixup_map_in_map = test->fixup_map_in_map;
    int *fixup_cgroup_storage = test->fixup_cgroup_storage;
    + int *fixup_percpu_cgroup_storage = test->fixup_percpu_cgroup_storage;

    if (test->fill_helper)
    test->fill_helper(test);
    @@ -12710,12 +12829,20 @@ static void do_test_fixup(struct bpf_test *test, struct bpf_insn *prog,
    }

    if (*fixup_cgroup_storage) {
    - map_fds[7] = create_cgroup_storage();
    + map_fds[7] = create_cgroup_storage(false);
    do {
    prog[*fixup_cgroup_storage].imm = map_fds[7];
    fixup_cgroup_storage++;
    } while (*fixup_cgroup_storage);
    }
    +
    + if (*fixup_percpu_cgroup_storage) {
    + map_fds[8] = create_cgroup_storage(true);
    + do {
    + prog[*fixup_percpu_cgroup_storage].imm = map_fds[8];
    + fixup_percpu_cgroup_storage++;
    + } while (*fixup_percpu_cgroup_storage);
    + }
    }

    static void do_test_single(struct bpf_test *test, bool unpriv,
    --
    2.17.1
    \
     
     \ /
      Last update: 2018-09-21 19:15    [W:4.441 / U:0.012 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site