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,URIBL_BLOCKED,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 19E6DC43381 for ; Tue, 5 Mar 2019 22:48:19 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id D1ACE20663 for ; Tue, 5 Mar 2019 22:48:18 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=fb.com header.i=@fb.com header.b="lVP0wZCf" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728520AbfCEWsR (ORCPT ); Tue, 5 Mar 2019 17:48:17 -0500 Received: from mx0b-00082601.pphosted.com ([67.231.153.30]:39188 "EHLO mx0b-00082601.pphosted.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727675AbfCEWsR (ORCPT ); Tue, 5 Mar 2019 17:48:17 -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 x25MlcDn018494 for ; Tue, 5 Mar 2019 14:48:15 -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=Mt/1uEpspy8dAcCapG6kybM8h/PG6M2Cjd22HJZvVm8=; b=lVP0wZCfsog6ruQW8lBCIEYo/+CyCR/yzk15VNVGonvpSYjW7M3/h9u1D/ayLOEtnCrd ERayI01hReTCu30VwsgIjwKF2GtrHV0HHR+KIqxfD7d5QOh79g3+ykQGYqWOnOSldijA rkF6BxbISBAeodkWXEaHu9CV9986109/qIQ= Received: from maileast.thefacebook.com ([199.201.65.23]) by mx0a-00082601.pphosted.com with ESMTP id 2r21q7r3dx-8 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT) for ; Tue, 05 Mar 2019 14:48:15 -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.1713.5; Tue, 5 Mar 2019 14:48:04 -0800 Received: by devvm424.lla2.facebook.com (Postfix, from userid 134475) id 2E61FD6C6FA7; Tue, 5 Mar 2019 14:47:59 -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 v3 bpf-next 3/3] bpf: add tests for bpf_progenyof Date: Tue, 5 Mar 2019 14:47:59 -0800 Message-ID: <20190305224759.2555660-4-javierhonduco@fb.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20190305224759.2555660-1-javierhonduco@fb.com> References: <20190301180614.4134278-2-javierhonduco@fb.com> <20190305224759.2555660-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-03-05_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) == 1 - progenyof(-1) == 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 | 268 ++++++++++++++++++ 5 files changed, 317 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 3b74d23fffab..94590555307c 100644 --- a/tools/testing/selftests/bpf/.gitignore +++ b/tools/testing/selftests/bpf/.gitignore @@ -31,3 +31,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 518cd587cd63..18efaa6e1fb5 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 c9433a496d54..cca12894b1b9 100644 --- a/tools/testing/selftests/bpf/bpf_helpers.h +++ b/tools/testing/selftests/bpf/bpf_helpers.h @@ -182,6 +182,7 @@ static struct bpf_tcp_sock *(*bpf_tcp_sock)(struct bpf_sock *sk) = (void *) BPF_FUNC_tcp_sock; static int (*bpf_skb_ecn_set_ce)(void *ctx) = (void *) BPF_FUNC_skb_ecn_set_ce; +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..a395eb2473b5 --- /dev/null +++ b/tools/testing/selftests/bpf/test_progenyof_user.c @@ -0,0 +1,268 @@ +// 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, nonexistant = -42; + __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 ourselve: 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, &nonexistant, 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, &nonexistant, 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 that PID 0 is among our progeny + 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, &nonexistant, 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 does not go over init", "%d == %d\n", + retrieved_ancestor_pid, ancestor_pid)) + goto close_pmu; + + // Test that we don't go over PID 0 + 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, &nonexistant, 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 != nonexistant, + "progenyof does not go over init", "%d == %d\n", + retrieved_ancestor_pid, nonexistant)) + goto close_pmu; + + // Test that we are among the progeny 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, &nonexistant, 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, &nonexistant, 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 != nonexistant, "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