From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.1 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 77B7AC43381 for ; Tue, 26 Feb 2019 22:37:02 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 31BC0218D9 for ; Tue, 26 Feb 2019 22:37:02 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=fb.com header.i=@fb.com header.b="eGWU70Io" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729340AbfBZWhB (ORCPT ); Tue, 26 Feb 2019 17:37:01 -0500 Received: from mx0b-00082601.pphosted.com ([67.231.153.30]:35986 "EHLO mx0b-00082601.pphosted.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1729030AbfBZWg7 (ORCPT ); Tue, 26 Feb 2019 17:36:59 -0500 Received: from pps.filterd (m0109331.ppops.net [127.0.0.1]) by mx0a-00082601.pphosted.com (8.16.0.27/8.16.0.27) with SMTP id x1QMNILW003372 for ; Tue, 26 Feb 2019 14:36:55 -0800 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=fb.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-type; s=facebook; bh=af7Ji4rP8T4l2eXiknpwF3yInePp5ITW7ipPZQ0rPds=; b=eGWU70IoIJuAAOZlnFfHqU4y7aSrF0pEN78MH6FBIEbdaon0MbMVKYOv/BuMd4+Bxbab 4C6oc1828kY/fY0F8uVO/391mrIUXmZFlPjLIZs0c2z2d5EchQGQf9CBmK3opTqGiLGQ vX3emKdC5hWcwO+g4cb/Q0dbc/wYfpqjyRY= Received: from maileast.thefacebook.com ([199.201.65.23]) by mx0a-00082601.pphosted.com with ESMTP id 2qwbwjgke7-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT) for ; Tue, 26 Feb 2019 14:36:54 -0800 Received: from mx-out.facebook.com (2620:10d:c0a1:3::13) by mail.thefacebook.com (2620:10d:c021:18::174) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA) id 15.1.1531.3; Tue, 26 Feb 2019 14:36:53 -0800 Received: by devvm424.lla2.facebook.com (Postfix, from userid 134475) id 05A6AD1D4110; Tue, 26 Feb 2019 14:36:52 -0800 (PST) Smtp-Origin-Hostprefix: devvm From: Javier Honduvilla Coto Smtp-Origin-Hostname: devvm424.lla2.facebook.com To: CC: , Smtp-Origin-Cluster: lla2c09 Subject: [PATCH bpf-next 3/3] bpf: add tests for bpf_progenyof Date: Tue, 26 Feb 2019 14:36:51 -0800 Message-ID: <20190226223651.3166820-4-javierhonduco@fb.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20190226223651.3166820-1-javierhonduco@fb.com> References: <20190226223651.3166820-1-javierhonduco@fb.com> X-FB-Internal: Safe MIME-Version: 1.0 Content-Type: text/plain X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:,, definitions=2019-02-26_11:,, signatures=0 X-Proofpoint-Spam-Reason: safe X-FB-Internal: Safe Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Adding the following test cases: - progenyof(current->pid) == 1 - progenyof(current->real_parent->pid) == 1 - progenyof(1) == 1 - progenyof(0) == 0 - progenyof(current->children[0]->pid) == 0 Signed-off-by: Javier Honduvilla Coto --- tools/testing/selftests/bpf/.gitignore | 1 + tools/testing/selftests/bpf/Makefile | 2 +- tools/testing/selftests/bpf/bpf_helpers.h | 1 + .../selftests/bpf/progs/test_progenyof_kern.c | 46 ++++ .../selftests/bpf/test_progenyof_user.c | 249 ++++++++++++++++++ 5 files changed, 298 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/bpf/progs/test_progenyof_kern.c create mode 100644 tools/testing/selftests/bpf/test_progenyof_user.c diff --git a/tools/testing/selftests/bpf/.gitignore b/tools/testing/selftests/bpf/.gitignore index e47168d1257d..677be3b05cd2 100644 --- a/tools/testing/selftests/bpf/.gitignore +++ b/tools/testing/selftests/bpf/.gitignore @@ -30,3 +30,4 @@ test_section_names test_tcpnotify_user test_libbpf alu32 +test_progenyof_user diff --git a/tools/testing/selftests/bpf/Makefile b/tools/testing/selftests/bpf/Makefile index ccffaa0a0787..8a8d4b2a5b74 100644 --- a/tools/testing/selftests/bpf/Makefile +++ b/tools/testing/selftests/bpf/Makefile @@ -23,7 +23,7 @@ TEST_GEN_PROGS = test_verifier test_tag test_maps test_lru_map test_lpm_map test test_align test_verifier_log test_dev_cgroup test_tcpbpf_user \ test_sock test_btf test_sockmap test_lirc_mode2_user get_cgroup_id_user \ test_socket_cookie test_cgroup_storage test_select_reuseport test_section_names \ - test_netcnt test_tcpnotify_user test_sock_fields + test_netcnt test_tcpnotify_user test_sock_fields test_progenyof_user BPF_OBJ_FILES = $(patsubst %.c,%.o, $(notdir $(wildcard progs/*.c))) TEST_GEN_FILES = $(BPF_OBJ_FILES) diff --git a/tools/testing/selftests/bpf/bpf_helpers.h b/tools/testing/selftests/bpf/bpf_helpers.h index d9999f1ed1d2..1f3e0d1ad159 100644 --- a/tools/testing/selftests/bpf/bpf_helpers.h +++ b/tools/testing/selftests/bpf/bpf_helpers.h @@ -180,6 +180,7 @@ static struct bpf_sock *(*bpf_sk_fullsock)(struct bpf_sock *sk) = (void *) BPF_FUNC_sk_fullsock; static struct bpf_tcp_sock *(*bpf_tcp_sock)(struct bpf_sock *sk) = (void *) BPF_FUNC_tcp_sock; +static int (*bpf_progenyof)(int pid) = (void *) BPF_FUNC_progenyof; /* llvm builtin functions that eBPF C program may use to * emit BPF_LD_ABS and BPF_LD_IND instructions diff --git a/tools/testing/selftests/bpf/progs/test_progenyof_kern.c b/tools/testing/selftests/bpf/progs/test_progenyof_kern.c new file mode 100644 index 000000000000..c4be2c794d83 --- /dev/null +++ b/tools/testing/selftests/bpf/progs/test_progenyof_kern.c @@ -0,0 +1,46 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include +#include "bpf_helpers.h" + +struct bpf_map_def SEC("maps") pidmap = { + .type = BPF_MAP_TYPE_ARRAY, + .key_size = sizeof(__u32), + .value_size = sizeof(__u32), + .max_entries = 2, +}; + +struct bpf_map_def SEC("maps") resultmap = { + .type = BPF_MAP_TYPE_ARRAY, + .key_size = sizeof(__u32), + .value_size = sizeof(__u32), + .max_entries = 1, +}; + +SEC("tracepoint/syscalls/sys_enter_open") +int trace(void *ctx) +{ + __u32 pid = bpf_get_current_pid_tgid(); + __u32 current_key = 0, ancestor_key = 1, *expected_pid, *ancestor_pid; + __u32 *val; + + expected_pid = bpf_map_lookup_elem(&pidmap, ¤t_key); + if (!expected_pid || *expected_pid != pid) + return 0; + + ancestor_pid = bpf_map_lookup_elem(&pidmap, &ancestor_key); + if (!ancestor_pid) + return 0; + + if (!bpf_progenyof(*ancestor_pid)) + return 0; + + val = bpf_map_lookup_elem(&resultmap, ¤t_key); + if (val) + *val = *ancestor_pid; + + return 0; +} + +char _license[] SEC("license") = "GPL"; +__u32 _version SEC("version") = 1; diff --git a/tools/testing/selftests/bpf/test_progenyof_user.c b/tools/testing/selftests/bpf/test_progenyof_user.c new file mode 100644 index 000000000000..0f9572986a11 --- /dev/null +++ b/tools/testing/selftests/bpf/test_progenyof_user.c @@ -0,0 +1,249 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#define CHECK(condition, tag, format...) \ + ({ \ + int __ret = !!(condition); \ + if (__ret) { \ + printf("%s:FAIL:%s ", __func__, tag); \ + printf(format); \ + } else { \ + printf("%s:PASS:%s\n", __func__, tag); \ + } \ + __ret; \ + }) + +static int bpf_find_map(const char *test, struct bpf_object *obj, + const char *name) +{ + struct bpf_map *map; + + map = bpf_object__find_map_by_name(obj, name); + if (!map) + return -1; + return bpf_map__fd(map); +} + +int main(int argc, char **argv) +{ + const char *probe_name = "syscalls/sys_enter_open"; + const char *file = "test_progenyof_kern.o"; + int err, bytes, efd, prog_fd, pmu_fd; + int resultmap_fd, pidmap_fd; + struct perf_event_attr attr = {}; + struct bpf_object *obj; + __u32 retrieved_ancestor_pid = 0; + __u32 key = 0, pid; + int exit_code = EXIT_FAILURE; + char buf[256]; + + int child_pid, ancestor_pid, root_fd; + __u32 ancestor_key = 1; + int pipefd[2]; + char marker[1]; + + err = bpf_prog_load(file, BPF_PROG_TYPE_TRACEPOINT, &obj, &prog_fd); + if (CHECK(err, "bpf_prog_load", "err %d errno %d\n", err, errno)) + goto fail; + + resultmap_fd = bpf_find_map(__func__, obj, "resultmap"); + if (CHECK(resultmap_fd < 0, "bpf_find_map", "err %d errno %d\n", + resultmap_fd, errno)) + goto close_prog; + + pidmap_fd = bpf_find_map(__func__, obj, "pidmap"); + if (CHECK(pidmap_fd < 0, "bpf_find_map", "err %d errno %d\n", pidmap_fd, + errno)) + goto close_prog; + + pid = getpid(); + bpf_map_update_elem(pidmap_fd, &key, &pid, 0); + bpf_map_update_elem(pidmap_fd, &ancestor_key, &pid, 0); + + snprintf(buf, sizeof(buf), "/sys/kernel/debug/tracing/events/%s/id", + probe_name); + efd = open(buf, O_RDONLY, 0); + if (CHECK(efd < 0, "open", "err %d errno %d\n", efd, errno)) + goto close_prog; + bytes = read(efd, buf, sizeof(buf)); + close(efd); + if (CHECK(bytes <= 0 || bytes >= sizeof(buf), "read", + "bytes %d errno %d\n", bytes, errno)) + goto close_prog; + + attr.config = strtol(buf, NULL, 0); + attr.type = PERF_TYPE_TRACEPOINT; + attr.sample_type = PERF_SAMPLE_RAW; + attr.sample_period = 1; + attr.wakeup_events = 1; + + pmu_fd = syscall(__NR_perf_event_open, &attr, getpid(), -1, -1, 0); + if (CHECK(pmu_fd < 0, "perf_event_open", "err %d errno %d\n", pmu_fd, + errno)) + goto close_prog; + + err = ioctl(pmu_fd, PERF_EVENT_IOC_ENABLE, 0); + if (CHECK(err, "perf_event_ioc_enable", "err %d errno %d\n", err, + errno)) + goto close_pmu; + + err = ioctl(pmu_fd, PERF_EVENT_IOC_SET_BPF, prog_fd); + if (CHECK(err, "perf_event_ioc_set_bpf", "err %d errno %d\n", err, + errno)) + goto close_pmu; + + // Test on itself: progenyof(current->pid) is true + bpf_map_update_elem(pidmap_fd, &key, &pid, 0); + bpf_map_update_elem(pidmap_fd, &ancestor_key, &pid, 0); + bpf_map_update_elem(resultmap_fd, &key, &key, 0); + + root_fd = open("/", O_RDONLY); + if (CHECK(efd < 0, "open", "errno %d\n", errno)) + goto close_prog; + close(root_fd); + + err = bpf_map_lookup_elem(resultmap_fd, &key, &retrieved_ancestor_pid); + if (CHECK(err, "bpf_map_lookup_elem", "err %d errno %d\n", err, errno)) + goto close_pmu; + if (CHECK(retrieved_ancestor_pid != pid, + "progenyof is true with same pid", "%d == %d\n", + retrieved_ancestor_pid, pid)) + goto close_pmu; + + // Test that PID 1 is among our progeny + bpf_map_update_elem(pidmap_fd, &key, &pid, 0); + ancestor_pid = 1; + bpf_map_update_elem(pidmap_fd, &ancestor_key, &ancestor_pid, 0); + bpf_map_update_elem(resultmap_fd, &key, &key, 0); + + root_fd = open("/", O_RDONLY); + if (CHECK(efd < 0, "open", "errno %d\n", errno)) + goto close_prog; + close(root_fd); + + err = bpf_map_lookup_elem(resultmap_fd, &key, &retrieved_ancestor_pid); + if (CHECK(err, "bpf_map_lookup_elem", "err %d errno %d\n", err, errno)) + goto close_pmu; + if (CHECK(retrieved_ancestor_pid != ancestor_pid, + "progenyof reaches init", "%d == %d\n", + retrieved_ancestor_pid, ancestor_pid)) + goto close_pmu; + + // Test we don't go over PID 1 + bpf_map_update_elem(pidmap_fd, &key, &pid, 0); + ancestor_pid = 0; + bpf_map_update_elem(pidmap_fd, &ancestor_key, &ancestor_pid, 0); + bpf_map_update_elem(resultmap_fd, &key, &key, 0); + + root_fd = open("/", O_RDONLY); + if (CHECK(efd < 0, "open", "errno %d\n", errno)) + goto close_prog; + close(root_fd); + + err = bpf_map_lookup_elem(resultmap_fd, &key, &retrieved_ancestor_pid); + if (CHECK(err, "bpf_map_lookup_elem", "err %d errno %d\n", err, errno)) + goto close_pmu; + if (CHECK(retrieved_ancestor_pid != 0, + "progenyof does not go over init", "%d == %d\n", + retrieved_ancestor_pid, 0)) + goto close_pmu; + + // Test that we are the progeny of our child + pipe(pipefd); + child_pid = fork(); + if (child_pid == -1) { + printf("fork failed\n"); + goto close_pmu; + } else if (child_pid == 0) { + close(pipefd[1]); + read(pipefd[0], &marker, 1); + + root_fd = open("/", O_RDONLY); + if (CHECK(efd < 0, "open", "errno %d\n", errno)) + goto close_prog; + close(root_fd); + + close(pipefd[0]); + _exit(EXIT_SUCCESS); + } else { + close(pipefd[0]); + bpf_map_update_elem(resultmap_fd, &key, &key, 0); + bpf_map_update_elem(pidmap_fd, &key, &child_pid, 0); + bpf_map_update_elem(pidmap_fd, &ancestor_key, &pid, 0); + + write(pipefd[1], &marker, 1); + wait(NULL); + close(pipefd[1]); + + err = bpf_map_lookup_elem(resultmap_fd, &key, + &retrieved_ancestor_pid); + if (CHECK(err, "bpf_map_lookup_elem", "err %d errno %d\n", err, + errno)) + goto close_pmu; + if (CHECK(retrieved_ancestor_pid != pid, "progenyof of parent", + "%d == %d\n", retrieved_ancestor_pid, pid)) + goto close_pmu; + } + + // Test that a child of ours doesn't belong to our progeny + bpf_map_update_elem(pidmap_fd, &key, &pid, 0); + bpf_map_update_elem(resultmap_fd, &key, &key, 0); + + pipe(pipefd); + child_pid = fork(); + if (child_pid == -1) { + printf("fork failed\n"); + goto close_pmu; + } else if (child_pid == 0) { + close(pipefd[1]); + read(pipefd[0], marker, 1); + close(pipefd[0]); + _exit(EXIT_SUCCESS); + } else { + close(pipefd[0]); + + bpf_map_update_elem(pidmap_fd, &ancestor_key, &child_pid, 0); + + root_fd = open("/", O_RDONLY); + if (CHECK(efd < 0, "open", "errno %d\n", errno)) + goto close_prog; + close(root_fd); + + write(pipefd[1], marker, 1); + wait(NULL); + close(pipefd[1]); + + err = bpf_map_lookup_elem(resultmap_fd, &key, + &retrieved_ancestor_pid); + if (CHECK(err, "bpf_map_lookup_elem", "err %d errno %d\n", err, + errno)) + goto close_pmu; + if (CHECK(retrieved_ancestor_pid != 0, "progenyof of child", + "%d == %d\n", retrieved_ancestor_pid, 0)) + goto close_pmu; + } + + exit_code = EXIT_SUCCESS; + printf("%s:PASS\n", argv[0]); + +close_pmu: + close(pmu_fd); +close_prog: + bpf_object__close(obj); +fail: + return exit_code; +} -- 2.17.1