bpf/prog_tests/d_path.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 #define _GNU_SOURCE
0003 #include <test_progs.h>
0004 #include <sys/stat.h>
0005 #include <linux/sched.h>
0006 #include <sys/syscall.h>
0007
0008 #define MAX_PATH_LEN        128
0009 #define MAX_FILES       7
0010
0011 #include "test_d_path.skel.h"
0012 #include "test_d_path_check_rdonly_mem.skel.h"
0013 #include "test_d_path_check_types.skel.h"
0014
0015 static int duration;
0016
0017 static struct {
0018     __u32 cnt;
0019     char paths[MAX_FILES][MAX_PATH_LEN];
0020 } src;
0021
0022 static int set_pathname(int fd, pid_t pid)
0023 {
0024     char buf[MAX_PATH_LEN];
0025
0026     snprintf(buf, MAX_PATH_LEN, "/proc/%d/fd/%d", pid, fd);
0027     return readlink(buf, src.paths[src.cnt++], MAX_PATH_LEN);
0028 }
0029
0030 static int trigger_fstat_events(pid_t pid)
0031 {
0032     int sockfd = -1, procfd = -1, devfd = -1;
0033     int localfd = -1, indicatorfd = -1;
0034     int pipefd[2] = { -1, -1 };
0035     struct stat fileStat;
0036     int ret = -1;
0037
0038     /* unmountable pseudo-filesystems */
0039     if (CHECK(pipe(pipefd) < 0, "trigger", "pipe failed\n"))
0040         return ret;
0041     /* unmountable pseudo-filesystems */
0042     sockfd = socket(AF_INET, SOCK_STREAM, 0);
0043     if (CHECK(sockfd < 0, "trigger", "socket failed\n"))
0044         goto out_close;
0045     /* mountable pseudo-filesystems */
0046     procfd = open("/proc/self/comm", O_RDONLY);
0047     if (CHECK(procfd < 0, "trigger", "open /proc/self/comm failed\n"))
0048         goto out_close;
0049     devfd = open("/dev/urandom", O_RDONLY);
0050     if (CHECK(devfd < 0, "trigger", "open /dev/urandom failed\n"))
0051         goto out_close;
0052     localfd = open("/tmp/d_path_loadgen.txt", O_CREAT | O_RDONLY, 0644);
0053     if (CHECK(localfd < 0, "trigger", "open /tmp/d_path_loadgen.txt failed\n"))
0054         goto out_close;
0055     /* bpf_d_path will return path with (deleted) */
0056     remove("/tmp/d_path_loadgen.txt");
0057     indicatorfd = open("/tmp/", O_PATH);
0058     if (CHECK(indicatorfd < 0, "trigger", "open /tmp/ failed\n"))
0059         goto out_close;
0060
0061     ret = set_pathname(pipefd[0], pid);
0062     if (CHECK(ret < 0, "trigger", "set_pathname failed for pipe[0]\n"))
0063         goto out_close;
0064     ret = set_pathname(pipefd[1], pid);
0065     if (CHECK(ret < 0, "trigger", "set_pathname failed for pipe[1]\n"))
0066         goto out_close;
0067     ret = set_pathname(sockfd, pid);
0068     if (CHECK(ret < 0, "trigger", "set_pathname failed for socket\n"))
0069         goto out_close;
0070     ret = set_pathname(procfd, pid);
0071     if (CHECK(ret < 0, "trigger", "set_pathname failed for proc\n"))
0072         goto out_close;
0073     ret = set_pathname(devfd, pid);
0074     if (CHECK(ret < 0, "trigger", "set_pathname failed for dev\n"))
0075         goto out_close;
0076     ret = set_pathname(localfd, pid);
0077     if (CHECK(ret < 0, "trigger", "set_pathname failed for file\n"))
0078         goto out_close;
0079     ret = set_pathname(indicatorfd, pid);
0080     if (CHECK(ret < 0, "trigger", "set_pathname failed for dir\n"))
0081         goto out_close;
0082
0083     /* triggers vfs_getattr */
0084     fstat(pipefd[0], &fileStat);
0085     fstat(pipefd[1], &fileStat);
0086     fstat(sockfd, &fileStat);
0087     fstat(procfd, &fileStat);
0088     fstat(devfd, &fileStat);
0089     fstat(localfd, &fileStat);
0090     fstat(indicatorfd, &fileStat);
0091
0092 out_close:
0093     /* triggers filp_close */
0094     close(pipefd[0]);
0095     close(pipefd[1]);
0096     close(sockfd);
0097     close(procfd);
0098     close(devfd);
0099     close(localfd);
0100     close(indicatorfd);
0101     return ret;
0102 }
0103
0104 static void test_d_path_basic(void)
0105 {
0106     struct test_d_path__bss *bss;
0107     struct test_d_path *skel;
0108     int err;
0109
0110     skel = test_d_path__open_and_load();
0111     if (CHECK(!skel, "setup", "d_path skeleton failed\n"))
0112         goto cleanup;
0113
0114     err = test_d_path__attach(skel);
0115     if (CHECK(err, "setup", "attach failed: %d\n", err))
0116         goto cleanup;
0117
0118     bss = skel->bss;
0119     bss->my_pid = getpid();
0120
0121     err = trigger_fstat_events(bss->my_pid);
0122     if (err < 0)
0123         goto cleanup;
0124
0125     if (CHECK(!bss->called_stat,
0126           "stat",
0127           "trampoline for security_inode_getattr was not called\n"))
0128         goto cleanup;
0129
0130     if (CHECK(!bss->called_close,
0131           "close",
0132           "trampoline for filp_close was not called\n"))
0133         goto cleanup;
0134
0135     for (int i = 0; i < MAX_FILES; i++) {
0136         CHECK(strncmp(src.paths[i], bss->paths_stat[i], MAX_PATH_LEN),
0137               "check",
0138               "failed to get stat path[%d]: %s vs %s\n",
0139               i, src.paths[i], bss->paths_stat[i]);
0140         CHECK(strncmp(src.paths[i], bss->paths_close[i], MAX_PATH_LEN),
0141               "check",
0142               "failed to get close path[%d]: %s vs %s\n",
0143               i, src.paths[i], bss->paths_close[i]);
0144         /* The d_path helper returns size plus NUL char, hence + 1 */
0145         CHECK(bss->rets_stat[i] != strlen(bss->paths_stat[i]) + 1,
0146               "check",
0147               "failed to match stat return [%d]: %d vs %zd [%s]\n",
0148               i, bss->rets_stat[i], strlen(bss->paths_stat[i]) + 1,
0149               bss->paths_stat[i]);
0150         CHECK(bss->rets_close[i] != strlen(bss->paths_stat[i]) + 1,
0151               "check",
0152               "failed to match stat return [%d]: %d vs %zd [%s]\n",
0153               i, bss->rets_close[i], strlen(bss->paths_close[i]) + 1,
0154               bss->paths_stat[i]);
0155     }
0156
0157 cleanup:
0158     test_d_path__destroy(skel);
0159 }
0160
0161 static void test_d_path_check_rdonly_mem(void)
0162 {
0163     struct test_d_path_check_rdonly_mem *skel;
0164
0165     skel = test_d_path_check_rdonly_mem__open_and_load();
0166     ASSERT_ERR_PTR(skel, "unexpected_load_overwriting_rdonly_mem");
0167
0168     test_d_path_check_rdonly_mem__destroy(skel);
0169 }
0170
0171 static void test_d_path_check_types(void)
0172 {
0173     struct test_d_path_check_types *skel;
0174
0175     skel = test_d_path_check_types__open_and_load();
0176     ASSERT_ERR_PTR(skel, "unexpected_load_passing_wrong_type");
0177
0178     test_d_path_check_types__destroy(skel);
0179 }
0180
0181 void test_d_path(void)
0182 {
0183     if (test__start_subtest("basic"))
0184         test_d_path_basic();
0185
0186     if (test__start_subtest("check_rdonly_mem"))
0187         test_d_path_check_rdonly_mem();
0188
0189     if (test__start_subtest("check_alloc_mem"))
0190         test_d_path_check_types();
0191 }