Greg Kroah-Hartman | b244131 | 2017-11-01 15:07:57 +0100 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0 |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 2 | #include <stdio.h> |
| 3 | #include <sys/types.h> |
| 4 | #include <sys/stat.h> |
| 5 | #include <fcntl.h> |
| 6 | #include <libelf.h> |
| 7 | #include <gelf.h> |
| 8 | #include <errno.h> |
| 9 | #include <unistd.h> |
| 10 | #include <string.h> |
| 11 | #include <stdbool.h> |
Alexei Starovoitov | b896c4f | 2015-03-25 12:49:23 -0700 | [diff] [blame] | 12 | #include <stdlib.h> |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 13 | #include <linux/bpf.h> |
| 14 | #include <linux/filter.h> |
Alexei Starovoitov | b896c4f | 2015-03-25 12:49:23 -0700 | [diff] [blame] | 15 | #include <linux/perf_event.h> |
Martin KaFai Lau | 12d8bb6 | 2016-12-07 15:53:14 -0800 | [diff] [blame] | 16 | #include <linux/netlink.h> |
| 17 | #include <linux/rtnetlink.h> |
Jesper Dangaard Brouer | 6387d01 | 2017-05-01 11:26:15 +0200 | [diff] [blame] | 18 | #include <linux/types.h> |
Martin KaFai Lau | 12d8bb6 | 2016-12-07 15:53:14 -0800 | [diff] [blame] | 19 | #include <sys/types.h> |
| 20 | #include <sys/socket.h> |
Alexei Starovoitov | b896c4f | 2015-03-25 12:49:23 -0700 | [diff] [blame] | 21 | #include <sys/syscall.h> |
| 22 | #include <sys/ioctl.h> |
| 23 | #include <sys/mman.h> |
| 24 | #include <poll.h> |
Alexei Starovoitov | 5bacd78 | 2015-05-19 16:59:05 -0700 | [diff] [blame] | 25 | #include <ctype.h> |
Martin KaFai Lau | 9fd63d0 | 2017-04-14 10:30:28 -0700 | [diff] [blame] | 26 | #include <assert.h> |
Jakub Kicinski | 2bf3e2e | 2018-05-14 22:35:02 -0700 | [diff] [blame] | 27 | #include <bpf/bpf.h> |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 28 | #include "bpf_load.h" |
Joe Stringer | 205c8ad | 2016-12-08 18:46:19 -0800 | [diff] [blame] | 29 | #include "perf-sys.h" |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 30 | |
Alexei Starovoitov | b896c4f | 2015-03-25 12:49:23 -0700 | [diff] [blame] | 31 | #define DEBUGFS "/sys/kernel/debug/tracing/" |
| 32 | |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 33 | static char license[128]; |
Alexei Starovoitov | b896c4f | 2015-03-25 12:49:23 -0700 | [diff] [blame] | 34 | static int kern_version; |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 35 | static bool processed_sec[128]; |
Joe Stringer | d40fc18 | 2016-12-14 14:43:38 -0800 | [diff] [blame] | 36 | char bpf_log_buf[BPF_LOG_BUF_SIZE]; |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 37 | int map_fd[MAX_MAPS]; |
| 38 | int prog_fd[MAX_PROGS]; |
Alexei Starovoitov | b896c4f | 2015-03-25 12:49:23 -0700 | [diff] [blame] | 39 | int event_fd[MAX_PROGS]; |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 40 | int prog_cnt; |
Alexei Starovoitov | 5bacd78 | 2015-05-19 16:59:05 -0700 | [diff] [blame] | 41 | int prog_array_fd = -1; |
| 42 | |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 43 | struct bpf_map_data map_data[MAX_MAPS]; |
| 44 | int map_data_count = 0; |
| 45 | |
Alexei Starovoitov | 5bacd78 | 2015-05-19 16:59:05 -0700 | [diff] [blame] | 46 | static int populate_prog_array(const char *event, int prog_fd) |
| 47 | { |
| 48 | int ind = atoi(event), err; |
| 49 | |
Joe Stringer | d40fc18 | 2016-12-14 14:43:38 -0800 | [diff] [blame] | 50 | err = bpf_map_update_elem(prog_array_fd, &ind, &prog_fd, BPF_ANY); |
Alexei Starovoitov | 5bacd78 | 2015-05-19 16:59:05 -0700 | [diff] [blame] | 51 | if (err < 0) { |
| 52 | printf("failed to store prog_fd in prog_array\n"); |
| 53 | return -1; |
| 54 | } |
| 55 | return 0; |
| 56 | } |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 57 | |
Daniel T. Lee | 7187ac3 | 2018-11-23 07:14:32 +0900 | [diff] [blame] | 58 | static int write_kprobe_events(const char *val) |
| 59 | { |
| 60 | int fd, ret, flags; |
| 61 | |
| 62 | if ((val != NULL) && (val[0] == '\0')) |
| 63 | flags = O_WRONLY | O_TRUNC; |
| 64 | else |
| 65 | flags = O_WRONLY | O_APPEND; |
| 66 | |
| 67 | fd = open("/sys/kernel/debug/tracing/kprobe_events", flags); |
| 68 | |
| 69 | ret = write(fd, val, strlen(val)); |
| 70 | close(fd); |
| 71 | |
| 72 | return ret; |
| 73 | } |
| 74 | |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 75 | static int load_and_attach(const char *event, struct bpf_insn *prog, int size) |
| 76 | { |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 77 | bool is_socket = strncmp(event, "socket", 6) == 0; |
Alexei Starovoitov | b896c4f | 2015-03-25 12:49:23 -0700 | [diff] [blame] | 78 | bool is_kprobe = strncmp(event, "kprobe/", 7) == 0; |
| 79 | bool is_kretprobe = strncmp(event, "kretprobe/", 10) == 0; |
Alexei Starovoitov | c076604 | 2016-04-06 18:43:29 -0700 | [diff] [blame] | 80 | bool is_tracepoint = strncmp(event, "tracepoint/", 11) == 0; |
Alexei Starovoitov | 4662a4e | 2018-03-28 12:05:39 -0700 | [diff] [blame] | 81 | bool is_raw_tracepoint = strncmp(event, "raw_tracepoint/", 15) == 0; |
Brenden Blanco | 86af8b4 | 2016-07-19 12:16:51 -0700 | [diff] [blame] | 82 | bool is_xdp = strncmp(event, "xdp", 3) == 0; |
Alexei Starovoitov | 1c47910e | 2016-09-01 18:37:25 -0700 | [diff] [blame] | 83 | bool is_perf_event = strncmp(event, "perf_event", 10) == 0; |
David Ahern | 4f2e7ae | 2016-12-01 08:48:07 -0800 | [diff] [blame] | 84 | bool is_cgroup_skb = strncmp(event, "cgroup/skb", 10) == 0; |
| 85 | bool is_cgroup_sk = strncmp(event, "cgroup/sock", 11) == 0; |
Lawrence Brakmo | 40304b2 | 2017-06-30 20:02:40 -0700 | [diff] [blame] | 86 | bool is_sockops = strncmp(event, "sockops", 7) == 0; |
John Fastabend | 69e8cc1 | 2017-08-15 22:33:32 -0700 | [diff] [blame] | 87 | bool is_sk_skb = strncmp(event, "sk_skb", 6) == 0; |
John Fastabend | 4c4c3c2 | 2018-03-18 12:57:41 -0700 | [diff] [blame] | 88 | bool is_sk_msg = strncmp(event, "sk_msg", 6) == 0; |
Joe Stringer | 43371c8 | 2016-12-14 14:43:39 -0800 | [diff] [blame] | 89 | size_t insns_cnt = size / sizeof(struct bpf_insn); |
Alexei Starovoitov | b896c4f | 2015-03-25 12:49:23 -0700 | [diff] [blame] | 90 | enum bpf_prog_type prog_type; |
| 91 | char buf[256]; |
| 92 | int fd, efd, err, id; |
| 93 | struct perf_event_attr attr = {}; |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 94 | |
Alexei Starovoitov | b896c4f | 2015-03-25 12:49:23 -0700 | [diff] [blame] | 95 | attr.type = PERF_TYPE_TRACEPOINT; |
| 96 | attr.sample_type = PERF_SAMPLE_RAW; |
| 97 | attr.sample_period = 1; |
| 98 | attr.wakeup_events = 1; |
| 99 | |
| 100 | if (is_socket) { |
| 101 | prog_type = BPF_PROG_TYPE_SOCKET_FILTER; |
| 102 | } else if (is_kprobe || is_kretprobe) { |
| 103 | prog_type = BPF_PROG_TYPE_KPROBE; |
Alexei Starovoitov | c076604 | 2016-04-06 18:43:29 -0700 | [diff] [blame] | 104 | } else if (is_tracepoint) { |
| 105 | prog_type = BPF_PROG_TYPE_TRACEPOINT; |
Alexei Starovoitov | 4662a4e | 2018-03-28 12:05:39 -0700 | [diff] [blame] | 106 | } else if (is_raw_tracepoint) { |
| 107 | prog_type = BPF_PROG_TYPE_RAW_TRACEPOINT; |
Brenden Blanco | 86af8b4 | 2016-07-19 12:16:51 -0700 | [diff] [blame] | 108 | } else if (is_xdp) { |
| 109 | prog_type = BPF_PROG_TYPE_XDP; |
Alexei Starovoitov | 1c47910e | 2016-09-01 18:37:25 -0700 | [diff] [blame] | 110 | } else if (is_perf_event) { |
| 111 | prog_type = BPF_PROG_TYPE_PERF_EVENT; |
David Ahern | 4f2e7ae | 2016-12-01 08:48:07 -0800 | [diff] [blame] | 112 | } else if (is_cgroup_skb) { |
| 113 | prog_type = BPF_PROG_TYPE_CGROUP_SKB; |
| 114 | } else if (is_cgroup_sk) { |
| 115 | prog_type = BPF_PROG_TYPE_CGROUP_SOCK; |
Lawrence Brakmo | 40304b2 | 2017-06-30 20:02:40 -0700 | [diff] [blame] | 116 | } else if (is_sockops) { |
| 117 | prog_type = BPF_PROG_TYPE_SOCK_OPS; |
John Fastabend | 69e8cc1 | 2017-08-15 22:33:32 -0700 | [diff] [blame] | 118 | } else if (is_sk_skb) { |
| 119 | prog_type = BPF_PROG_TYPE_SK_SKB; |
John Fastabend | 4c4c3c2 | 2018-03-18 12:57:41 -0700 | [diff] [blame] | 120 | } else if (is_sk_msg) { |
| 121 | prog_type = BPF_PROG_TYPE_SK_MSG; |
Alexei Starovoitov | b896c4f | 2015-03-25 12:49:23 -0700 | [diff] [blame] | 122 | } else { |
| 123 | printf("Unknown event '%s'\n", event); |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 124 | return -1; |
Alexei Starovoitov | b896c4f | 2015-03-25 12:49:23 -0700 | [diff] [blame] | 125 | } |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 126 | |
Dan Carpenter | b0294bc | 2018-07-13 18:11:39 +0300 | [diff] [blame] | 127 | if (prog_cnt == MAX_PROGS) |
| 128 | return -1; |
| 129 | |
Joe Stringer | 43371c8 | 2016-12-14 14:43:39 -0800 | [diff] [blame] | 130 | fd = bpf_load_program(prog_type, prog, insns_cnt, license, kern_version, |
Joe Stringer | d40fc18 | 2016-12-14 14:43:38 -0800 | [diff] [blame] | 131 | bpf_log_buf, BPF_LOG_BUF_SIZE); |
Alexei Starovoitov | 5bacd78 | 2015-05-19 16:59:05 -0700 | [diff] [blame] | 132 | if (fd < 0) { |
Joe Stringer | d40fc18 | 2016-12-14 14:43:38 -0800 | [diff] [blame] | 133 | printf("bpf_load_program() err=%d\n%s", errno, bpf_log_buf); |
Alexei Starovoitov | 5bacd78 | 2015-05-19 16:59:05 -0700 | [diff] [blame] | 134 | return -1; |
| 135 | } |
| 136 | |
| 137 | prog_fd[prog_cnt++] = fd; |
| 138 | |
David Ahern | 4f2e7ae | 2016-12-01 08:48:07 -0800 | [diff] [blame] | 139 | if (is_xdp || is_perf_event || is_cgroup_skb || is_cgroup_sk) |
Brenden Blanco | 86af8b4 | 2016-07-19 12:16:51 -0700 | [diff] [blame] | 140 | return 0; |
| 141 | |
John Fastabend | 4c4c3c2 | 2018-03-18 12:57:41 -0700 | [diff] [blame] | 142 | if (is_socket || is_sockops || is_sk_skb || is_sk_msg) { |
Lawrence Brakmo | 40304b2 | 2017-06-30 20:02:40 -0700 | [diff] [blame] | 143 | if (is_socket) |
| 144 | event += 6; |
| 145 | else |
| 146 | event += 7; |
Alexei Starovoitov | 5bacd78 | 2015-05-19 16:59:05 -0700 | [diff] [blame] | 147 | if (*event != '/') |
| 148 | return 0; |
| 149 | event++; |
| 150 | if (!isdigit(*event)) { |
| 151 | printf("invalid prog number\n"); |
| 152 | return -1; |
| 153 | } |
| 154 | return populate_prog_array(event, fd); |
| 155 | } |
| 156 | |
Alexei Starovoitov | 4662a4e | 2018-03-28 12:05:39 -0700 | [diff] [blame] | 157 | if (is_raw_tracepoint) { |
| 158 | efd = bpf_raw_tracepoint_open(event + 15, fd); |
| 159 | if (efd < 0) { |
| 160 | printf("tracepoint %s %s\n", event + 15, strerror(errno)); |
| 161 | return -1; |
| 162 | } |
| 163 | event_fd[prog_cnt - 1] = efd; |
| 164 | return 0; |
| 165 | } |
| 166 | |
Alexei Starovoitov | b896c4f | 2015-03-25 12:49:23 -0700 | [diff] [blame] | 167 | if (is_kprobe || is_kretprobe) { |
Yonghong Song | 34745ae | 2018-04-29 19:27:48 -0700 | [diff] [blame] | 168 | bool need_normal_check = true; |
| 169 | const char *event_prefix = ""; |
| 170 | |
Alexei Starovoitov | b896c4f | 2015-03-25 12:49:23 -0700 | [diff] [blame] | 171 | if (is_kprobe) |
| 172 | event += 7; |
| 173 | else |
| 174 | event += 10; |
| 175 | |
Alexei Starovoitov | 5bacd78 | 2015-05-19 16:59:05 -0700 | [diff] [blame] | 176 | if (*event == 0) { |
| 177 | printf("event name cannot be empty\n"); |
| 178 | return -1; |
| 179 | } |
| 180 | |
| 181 | if (isdigit(*event)) |
| 182 | return populate_prog_array(event, fd); |
| 183 | |
Yonghong Song | 34745ae | 2018-04-29 19:27:48 -0700 | [diff] [blame] | 184 | #ifdef __x86_64__ |
| 185 | if (strncmp(event, "sys_", 4) == 0) { |
Daniel T. Lee | 7187ac3 | 2018-11-23 07:14:32 +0900 | [diff] [blame] | 186 | snprintf(buf, sizeof(buf), "%c:__x64_%s __x64_%s", |
| 187 | is_kprobe ? 'p' : 'r', event, event); |
| 188 | err = write_kprobe_events(buf); |
Yonghong Song | 34745ae | 2018-04-29 19:27:48 -0700 | [diff] [blame] | 189 | if (err >= 0) { |
| 190 | need_normal_check = false; |
| 191 | event_prefix = "__x64_"; |
| 192 | } |
| 193 | } |
| 194 | #endif |
| 195 | if (need_normal_check) { |
Daniel T. Lee | 7187ac3 | 2018-11-23 07:14:32 +0900 | [diff] [blame] | 196 | snprintf(buf, sizeof(buf), "%c:%s %s", |
| 197 | is_kprobe ? 'p' : 'r', event, event); |
| 198 | err = write_kprobe_events(buf); |
Yonghong Song | 34745ae | 2018-04-29 19:27:48 -0700 | [diff] [blame] | 199 | if (err < 0) { |
| 200 | printf("failed to create kprobe '%s' error '%s'\n", |
| 201 | event, strerror(errno)); |
| 202 | return -1; |
| 203 | } |
Alexei Starovoitov | b896c4f | 2015-03-25 12:49:23 -0700 | [diff] [blame] | 204 | } |
Alexei Starovoitov | b896c4f | 2015-03-25 12:49:23 -0700 | [diff] [blame] | 205 | |
Alexei Starovoitov | c076604 | 2016-04-06 18:43:29 -0700 | [diff] [blame] | 206 | strcpy(buf, DEBUGFS); |
| 207 | strcat(buf, "events/kprobes/"); |
Yonghong Song | 34745ae | 2018-04-29 19:27:48 -0700 | [diff] [blame] | 208 | strcat(buf, event_prefix); |
Alexei Starovoitov | c076604 | 2016-04-06 18:43:29 -0700 | [diff] [blame] | 209 | strcat(buf, event); |
| 210 | strcat(buf, "/id"); |
| 211 | } else if (is_tracepoint) { |
| 212 | event += 11; |
| 213 | |
| 214 | if (*event == 0) { |
| 215 | printf("event name cannot be empty\n"); |
| 216 | return -1; |
| 217 | } |
| 218 | strcpy(buf, DEBUGFS); |
| 219 | strcat(buf, "events/"); |
| 220 | strcat(buf, event); |
| 221 | strcat(buf, "/id"); |
| 222 | } |
Alexei Starovoitov | b896c4f | 2015-03-25 12:49:23 -0700 | [diff] [blame] | 223 | |
| 224 | efd = open(buf, O_RDONLY, 0); |
| 225 | if (efd < 0) { |
| 226 | printf("failed to open event %s\n", event); |
| 227 | return -1; |
| 228 | } |
| 229 | |
| 230 | err = read(efd, buf, sizeof(buf)); |
| 231 | if (err < 0 || err >= sizeof(buf)) { |
| 232 | printf("read from '%s' failed '%s'\n", event, strerror(errno)); |
| 233 | return -1; |
| 234 | } |
| 235 | |
| 236 | close(efd); |
| 237 | |
| 238 | buf[err] = 0; |
| 239 | id = atoi(buf); |
| 240 | attr.config = id; |
| 241 | |
Joe Stringer | 205c8ad | 2016-12-08 18:46:19 -0800 | [diff] [blame] | 242 | efd = sys_perf_event_open(&attr, -1/*pid*/, 0/*cpu*/, -1/*group_fd*/, 0); |
Alexei Starovoitov | b896c4f | 2015-03-25 12:49:23 -0700 | [diff] [blame] | 243 | if (efd < 0) { |
| 244 | printf("event %d fd %d err %s\n", id, efd, strerror(errno)); |
| 245 | return -1; |
| 246 | } |
| 247 | event_fd[prog_cnt - 1] = efd; |
Yonghong Song | 0ec9552 | 2017-11-30 13:47:55 -0800 | [diff] [blame] | 248 | err = ioctl(efd, PERF_EVENT_IOC_ENABLE, 0); |
| 249 | if (err < 0) { |
| 250 | printf("ioctl PERF_EVENT_IOC_ENABLE failed err %s\n", |
| 251 | strerror(errno)); |
| 252 | return -1; |
| 253 | } |
| 254 | err = ioctl(efd, PERF_EVENT_IOC_SET_BPF, fd); |
| 255 | if (err < 0) { |
| 256 | printf("ioctl PERF_EVENT_IOC_SET_BPF failed err %s\n", |
| 257 | strerror(errno)); |
| 258 | return -1; |
| 259 | } |
Alexei Starovoitov | b896c4f | 2015-03-25 12:49:23 -0700 | [diff] [blame] | 260 | |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 261 | return 0; |
| 262 | } |
| 263 | |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 264 | static int load_maps(struct bpf_map_data *maps, int nr_maps, |
| 265 | fixup_map_cb fixup_map) |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 266 | { |
Martin KaFai Lau | ad17d0e | 2017-08-18 11:28:01 -0700 | [diff] [blame] | 267 | int i, numa_node; |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 268 | |
Jesper Dangaard Brouer | 5010e94 | 2017-04-28 16:25:04 +0200 | [diff] [blame] | 269 | for (i = 0; i < nr_maps; i++) { |
Jesper Dangaard Brouer | 6979bcc | 2017-05-02 14:32:01 +0200 | [diff] [blame] | 270 | if (fixup_map) { |
| 271 | fixup_map(&maps[i], i); |
| 272 | /* Allow userspace to assign map FD prior to creation */ |
| 273 | if (maps[i].fd != -1) { |
| 274 | map_fd[i] = maps[i].fd; |
| 275 | continue; |
| 276 | } |
| 277 | } |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 278 | |
Martin KaFai Lau | ad17d0e | 2017-08-18 11:28:01 -0700 | [diff] [blame] | 279 | numa_node = maps[i].def.map_flags & BPF_F_NUMA_NODE ? |
| 280 | maps[i].def.numa_node : -1; |
| 281 | |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 282 | if (maps[i].def.type == BPF_MAP_TYPE_ARRAY_OF_MAPS || |
| 283 | maps[i].def.type == BPF_MAP_TYPE_HASH_OF_MAPS) { |
| 284 | int inner_map_fd = map_fd[maps[i].def.inner_map_idx]; |
Martin KaFai Lau | fb30d4b | 2017-03-22 10:00:35 -0700 | [diff] [blame] | 285 | |
Martin KaFai Lau | ad17d0e | 2017-08-18 11:28:01 -0700 | [diff] [blame] | 286 | map_fd[i] = bpf_create_map_in_map_node(maps[i].def.type, |
Martin KaFai Lau | 88cda1c | 2017-09-27 14:37:54 -0700 | [diff] [blame] | 287 | maps[i].name, |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 288 | maps[i].def.key_size, |
| 289 | inner_map_fd, |
| 290 | maps[i].def.max_entries, |
Martin KaFai Lau | ad17d0e | 2017-08-18 11:28:01 -0700 | [diff] [blame] | 291 | maps[i].def.map_flags, |
| 292 | numa_node); |
Martin KaFai Lau | fb30d4b | 2017-03-22 10:00:35 -0700 | [diff] [blame] | 293 | } else { |
Martin KaFai Lau | ad17d0e | 2017-08-18 11:28:01 -0700 | [diff] [blame] | 294 | map_fd[i] = bpf_create_map_node(maps[i].def.type, |
Martin KaFai Lau | 88cda1c | 2017-09-27 14:37:54 -0700 | [diff] [blame] | 295 | maps[i].name, |
Martin KaFai Lau | ad17d0e | 2017-08-18 11:28:01 -0700 | [diff] [blame] | 296 | maps[i].def.key_size, |
| 297 | maps[i].def.value_size, |
| 298 | maps[i].def.max_entries, |
| 299 | maps[i].def.map_flags, |
| 300 | numa_node); |
Martin KaFai Lau | fb30d4b | 2017-03-22 10:00:35 -0700 | [diff] [blame] | 301 | } |
Alexei Starovoitov | 618ec9a7 | 2016-03-07 21:57:18 -0800 | [diff] [blame] | 302 | if (map_fd[i] < 0) { |
| 303 | printf("failed to create a map: %d %s\n", |
| 304 | errno, strerror(errno)); |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 305 | return 1; |
Alexei Starovoitov | 618ec9a7 | 2016-03-07 21:57:18 -0800 | [diff] [blame] | 306 | } |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 307 | maps[i].fd = map_fd[i]; |
Alexei Starovoitov | 5bacd78 | 2015-05-19 16:59:05 -0700 | [diff] [blame] | 308 | |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 309 | if (maps[i].def.type == BPF_MAP_TYPE_PROG_ARRAY) |
Alexei Starovoitov | 5bacd78 | 2015-05-19 16:59:05 -0700 | [diff] [blame] | 310 | prog_array_fd = map_fd[i]; |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 311 | } |
| 312 | return 0; |
| 313 | } |
| 314 | |
| 315 | static int get_sec(Elf *elf, int i, GElf_Ehdr *ehdr, char **shname, |
| 316 | GElf_Shdr *shdr, Elf_Data **data) |
| 317 | { |
| 318 | Elf_Scn *scn; |
| 319 | |
| 320 | scn = elf_getscn(elf, i); |
| 321 | if (!scn) |
| 322 | return 1; |
| 323 | |
| 324 | if (gelf_getshdr(scn, shdr) != shdr) |
| 325 | return 2; |
| 326 | |
| 327 | *shname = elf_strptr(elf, ehdr->e_shstrndx, shdr->sh_name); |
| 328 | if (!*shname || !shdr->sh_size) |
| 329 | return 3; |
| 330 | |
| 331 | *data = elf_getdata(scn, 0); |
| 332 | if (!*data || elf_getdata(scn, *data) != NULL) |
| 333 | return 4; |
| 334 | |
| 335 | return 0; |
| 336 | } |
| 337 | |
| 338 | static int parse_relo_and_apply(Elf_Data *data, Elf_Data *symbols, |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 339 | GElf_Shdr *shdr, struct bpf_insn *insn, |
| 340 | struct bpf_map_data *maps, int nr_maps) |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 341 | { |
| 342 | int i, nrels; |
| 343 | |
| 344 | nrels = shdr->sh_size / shdr->sh_entsize; |
| 345 | |
| 346 | for (i = 0; i < nrels; i++) { |
| 347 | GElf_Sym sym; |
| 348 | GElf_Rel rel; |
| 349 | unsigned int insn_idx; |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 350 | bool match = false; |
| 351 | int j, map_idx; |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 352 | |
| 353 | gelf_getrel(data, i, &rel); |
| 354 | |
| 355 | insn_idx = rel.r_offset / sizeof(struct bpf_insn); |
| 356 | |
| 357 | gelf_getsym(symbols, GELF_R_SYM(rel.r_info), &sym); |
| 358 | |
| 359 | if (insn[insn_idx].code != (BPF_LD | BPF_IMM | BPF_DW)) { |
| 360 | printf("invalid relo for insn[%d].code 0x%x\n", |
| 361 | insn_idx, insn[insn_idx].code); |
| 362 | return 1; |
| 363 | } |
| 364 | insn[insn_idx].src_reg = BPF_PSEUDO_MAP_FD; |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 365 | |
| 366 | /* Match FD relocation against recorded map_data[] offset */ |
| 367 | for (map_idx = 0; map_idx < nr_maps; map_idx++) { |
| 368 | if (maps[map_idx].elf_offset == sym.st_value) { |
| 369 | match = true; |
| 370 | break; |
| 371 | } |
| 372 | } |
| 373 | if (match) { |
| 374 | insn[insn_idx].imm = maps[map_idx].fd; |
| 375 | } else { |
| 376 | printf("invalid relo for insn[%d] no map_data match\n", |
| 377 | insn_idx); |
| 378 | return 1; |
| 379 | } |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 380 | } |
| 381 | |
| 382 | return 0; |
| 383 | } |
| 384 | |
Martin KaFai Lau | 9fd63d0 | 2017-04-14 10:30:28 -0700 | [diff] [blame] | 385 | static int cmp_symbols(const void *l, const void *r) |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 386 | { |
Martin KaFai Lau | 9fd63d0 | 2017-04-14 10:30:28 -0700 | [diff] [blame] | 387 | const GElf_Sym *lsym = (const GElf_Sym *)l; |
| 388 | const GElf_Sym *rsym = (const GElf_Sym *)r; |
| 389 | |
| 390 | if (lsym->st_value < rsym->st_value) |
| 391 | return -1; |
| 392 | else if (lsym->st_value > rsym->st_value) |
| 393 | return 1; |
| 394 | else |
| 395 | return 0; |
| 396 | } |
| 397 | |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 398 | static int load_elf_maps_section(struct bpf_map_data *maps, int maps_shndx, |
| 399 | Elf *elf, Elf_Data *symbols, int strtabidx) |
Martin KaFai Lau | 9fd63d0 | 2017-04-14 10:30:28 -0700 | [diff] [blame] | 400 | { |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 401 | int map_sz_elf, map_sz_copy; |
| 402 | bool validate_zero = false; |
| 403 | Elf_Data *data_maps; |
| 404 | int i, nr_maps; |
| 405 | GElf_Sym *sym; |
| 406 | Elf_Scn *scn; |
| 407 | int copy_sz; |
Martin KaFai Lau | 9fd63d0 | 2017-04-14 10:30:28 -0700 | [diff] [blame] | 408 | |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 409 | if (maps_shndx < 0) |
| 410 | return -EINVAL; |
| 411 | if (!symbols) |
| 412 | return -EINVAL; |
| 413 | |
| 414 | /* Get data for maps section via elf index */ |
| 415 | scn = elf_getscn(elf, maps_shndx); |
| 416 | if (scn) |
| 417 | data_maps = elf_getdata(scn, NULL); |
| 418 | if (!scn || !data_maps) { |
| 419 | printf("Failed to get Elf_Data from maps section %d\n", |
| 420 | maps_shndx); |
| 421 | return -EINVAL; |
| 422 | } |
| 423 | |
| 424 | /* For each map get corrosponding symbol table entry */ |
| 425 | sym = calloc(MAX_MAPS+1, sizeof(GElf_Sym)); |
| 426 | for (i = 0, nr_maps = 0; i < symbols->d_size / sizeof(GElf_Sym); i++) { |
| 427 | assert(nr_maps < MAX_MAPS+1); |
| 428 | if (!gelf_getsym(symbols, i, &sym[nr_maps])) |
Martin KaFai Lau | 9fd63d0 | 2017-04-14 10:30:28 -0700 | [diff] [blame] | 429 | continue; |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 430 | if (sym[nr_maps].st_shndx != maps_shndx) |
Martin KaFai Lau | 9fd63d0 | 2017-04-14 10:30:28 -0700 | [diff] [blame] | 431 | continue; |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 432 | /* Only increment iif maps section */ |
Martin KaFai Lau | 9fd63d0 | 2017-04-14 10:30:28 -0700 | [diff] [blame] | 433 | nr_maps++; |
| 434 | } |
| 435 | |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 436 | /* Align to map_fd[] order, via sort on offset in sym.st_value */ |
| 437 | qsort(sym, nr_maps, sizeof(GElf_Sym), cmp_symbols); |
Martin KaFai Lau | 9fd63d0 | 2017-04-14 10:30:28 -0700 | [diff] [blame] | 438 | |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 439 | /* Keeping compatible with ELF maps section changes |
| 440 | * ------------------------------------------------ |
Jakub Kicinski | 74662ea | 2018-05-10 10:24:38 -0700 | [diff] [blame] | 441 | * The program size of struct bpf_load_map_def is known by loader |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 442 | * code, but struct stored in ELF file can be different. |
| 443 | * |
| 444 | * Unfortunately sym[i].st_size is zero. To calculate the |
| 445 | * struct size stored in the ELF file, assume all struct have |
| 446 | * the same size, and simply divide with number of map |
| 447 | * symbols. |
| 448 | */ |
| 449 | map_sz_elf = data_maps->d_size / nr_maps; |
Jakub Kicinski | 74662ea | 2018-05-10 10:24:38 -0700 | [diff] [blame] | 450 | map_sz_copy = sizeof(struct bpf_load_map_def); |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 451 | if (map_sz_elf < map_sz_copy) { |
| 452 | /* |
| 453 | * Backward compat, loading older ELF file with |
| 454 | * smaller struct, keeping remaining bytes zero. |
| 455 | */ |
| 456 | map_sz_copy = map_sz_elf; |
| 457 | } else if (map_sz_elf > map_sz_copy) { |
| 458 | /* |
| 459 | * Forward compat, loading newer ELF file with larger |
| 460 | * struct with unknown features. Assume zero means |
| 461 | * feature not used. Thus, validate rest of struct |
| 462 | * data is zero. |
| 463 | */ |
| 464 | validate_zero = true; |
| 465 | } |
| 466 | |
| 467 | /* Memcpy relevant part of ELF maps data to loader maps */ |
Martin KaFai Lau | 9fd63d0 | 2017-04-14 10:30:28 -0700 | [diff] [blame] | 468 | for (i = 0; i < nr_maps; i++) { |
Jakub Kicinski | 74662ea | 2018-05-10 10:24:38 -0700 | [diff] [blame] | 469 | struct bpf_load_map_def *def; |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 470 | unsigned char *addr, *end; |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 471 | const char *map_name; |
| 472 | size_t offset; |
Martin KaFai Lau | 9fd63d0 | 2017-04-14 10:30:28 -0700 | [diff] [blame] | 473 | |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 474 | map_name = elf_strptr(elf, strtabidx, sym[i].st_name); |
| 475 | maps[i].name = strdup(map_name); |
| 476 | if (!maps[i].name) { |
Martin KaFai Lau | 9fd63d0 | 2017-04-14 10:30:28 -0700 | [diff] [blame] | 477 | printf("strdup(%s): %s(%d)\n", map_name, |
| 478 | strerror(errno), errno); |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 479 | free(sym); |
| 480 | return -errno; |
| 481 | } |
| 482 | |
| 483 | /* Symbol value is offset into ELF maps section data area */ |
| 484 | offset = sym[i].st_value; |
Jakub Kicinski | 74662ea | 2018-05-10 10:24:38 -0700 | [diff] [blame] | 485 | def = (struct bpf_load_map_def *)(data_maps->d_buf + offset); |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 486 | maps[i].elf_offset = offset; |
Jakub Kicinski | 74662ea | 2018-05-10 10:24:38 -0700 | [diff] [blame] | 487 | memset(&maps[i].def, 0, sizeof(struct bpf_load_map_def)); |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 488 | memcpy(&maps[i].def, def, map_sz_copy); |
| 489 | |
| 490 | /* Verify no newer features were requested */ |
| 491 | if (validate_zero) { |
| 492 | addr = (unsigned char*) def + map_sz_copy; |
| 493 | end = (unsigned char*) def + map_sz_elf; |
| 494 | for (; addr < end; addr++) { |
| 495 | if (*addr != 0) { |
| 496 | free(sym); |
| 497 | return -EFBIG; |
| 498 | } |
| 499 | } |
Martin KaFai Lau | 9fd63d0 | 2017-04-14 10:30:28 -0700 | [diff] [blame] | 500 | } |
| 501 | } |
| 502 | |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 503 | free(sym); |
Jesper Dangaard Brouer | 5010e94 | 2017-04-28 16:25:04 +0200 | [diff] [blame] | 504 | return nr_maps; |
Martin KaFai Lau | 9fd63d0 | 2017-04-14 10:30:28 -0700 | [diff] [blame] | 505 | } |
| 506 | |
| 507 | static int do_load_bpf_file(const char *path, fixup_map_cb fixup_map) |
| 508 | { |
| 509 | int fd, i, ret, maps_shndx = -1, strtabidx = -1; |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 510 | Elf *elf; |
| 511 | GElf_Ehdr ehdr; |
| 512 | GElf_Shdr shdr, shdr_prog; |
Martin KaFai Lau | 9fd63d0 | 2017-04-14 10:30:28 -0700 | [diff] [blame] | 513 | Elf_Data *data, *data_prog, *data_maps = NULL, *symbols = NULL; |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 514 | char *shname, *shname_prog; |
| 515 | int nr_maps = 0; |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 516 | |
Mickaël Salaün | a734fb5 | 2017-02-08 21:27:43 +0100 | [diff] [blame] | 517 | /* reset global variables */ |
| 518 | kern_version = 0; |
| 519 | memset(license, 0, sizeof(license)); |
| 520 | memset(processed_sec, 0, sizeof(processed_sec)); |
| 521 | |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 522 | if (elf_version(EV_CURRENT) == EV_NONE) |
| 523 | return 1; |
| 524 | |
| 525 | fd = open(path, O_RDONLY, 0); |
| 526 | if (fd < 0) |
| 527 | return 1; |
| 528 | |
| 529 | elf = elf_begin(fd, ELF_C_READ, NULL); |
| 530 | |
| 531 | if (!elf) |
| 532 | return 1; |
| 533 | |
| 534 | if (gelf_getehdr(elf, &ehdr) != &ehdr) |
| 535 | return 1; |
| 536 | |
Alexei Starovoitov | b896c4f | 2015-03-25 12:49:23 -0700 | [diff] [blame] | 537 | /* clear all kprobes */ |
Daniel T. Lee | 7187ac3 | 2018-11-23 07:14:32 +0900 | [diff] [blame] | 538 | i = write_kprobe_events(""); |
Alexei Starovoitov | b896c4f | 2015-03-25 12:49:23 -0700 | [diff] [blame] | 539 | |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 540 | /* scan over all elf sections to get license and map info */ |
| 541 | for (i = 1; i < ehdr.e_shnum; i++) { |
| 542 | |
| 543 | if (get_sec(elf, i, &ehdr, &shname, &shdr, &data)) |
| 544 | continue; |
| 545 | |
| 546 | if (0) /* helpful for llvm debugging */ |
| 547 | printf("section %d:%s data %p size %zd link %d flags %d\n", |
| 548 | i, shname, data->d_buf, data->d_size, |
| 549 | shdr.sh_link, (int) shdr.sh_flags); |
| 550 | |
| 551 | if (strcmp(shname, "license") == 0) { |
| 552 | processed_sec[i] = true; |
| 553 | memcpy(license, data->d_buf, data->d_size); |
Alexei Starovoitov | b896c4f | 2015-03-25 12:49:23 -0700 | [diff] [blame] | 554 | } else if (strcmp(shname, "version") == 0) { |
| 555 | processed_sec[i] = true; |
| 556 | if (data->d_size != sizeof(int)) { |
| 557 | printf("invalid size of version section %zd\n", |
| 558 | data->d_size); |
| 559 | return 1; |
| 560 | } |
| 561 | memcpy(&kern_version, data->d_buf, sizeof(int)); |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 562 | } else if (strcmp(shname, "maps") == 0) { |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 563 | int j; |
| 564 | |
Martin KaFai Lau | 9fd63d0 | 2017-04-14 10:30:28 -0700 | [diff] [blame] | 565 | maps_shndx = i; |
| 566 | data_maps = data; |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 567 | for (j = 0; j < MAX_MAPS; j++) |
| 568 | map_data[j].fd = -1; |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 569 | } else if (shdr.sh_type == SHT_SYMTAB) { |
Martin KaFai Lau | 9fd63d0 | 2017-04-14 10:30:28 -0700 | [diff] [blame] | 570 | strtabidx = shdr.sh_link; |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 571 | symbols = data; |
| 572 | } |
| 573 | } |
| 574 | |
Martin KaFai Lau | 9fd63d0 | 2017-04-14 10:30:28 -0700 | [diff] [blame] | 575 | ret = 1; |
| 576 | |
| 577 | if (!symbols) { |
| 578 | printf("missing SHT_SYMTAB section\n"); |
| 579 | goto done; |
| 580 | } |
| 581 | |
| 582 | if (data_maps) { |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 583 | nr_maps = load_elf_maps_section(map_data, maps_shndx, |
| 584 | elf, symbols, strtabidx); |
| 585 | if (nr_maps < 0) { |
| 586 | printf("Error: Failed loading ELF maps (errno:%d):%s\n", |
| 587 | nr_maps, strerror(-nr_maps)); |
Jesper Dangaard Brouer | 5010e94 | 2017-04-28 16:25:04 +0200 | [diff] [blame] | 588 | goto done; |
| 589 | } |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 590 | if (load_maps(map_data, nr_maps, fixup_map)) |
Martin KaFai Lau | 9fd63d0 | 2017-04-14 10:30:28 -0700 | [diff] [blame] | 591 | goto done; |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 592 | map_data_count = nr_maps; |
Martin KaFai Lau | 9fd63d0 | 2017-04-14 10:30:28 -0700 | [diff] [blame] | 593 | |
| 594 | processed_sec[maps_shndx] = true; |
| 595 | } |
| 596 | |
Jesper Dangaard Brouer | 7bc5795 | 2017-05-30 14:37:51 +0200 | [diff] [blame] | 597 | /* process all relo sections, and rewrite bpf insns for maps */ |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 598 | for (i = 1; i < ehdr.e_shnum; i++) { |
Mickaël Salaün | 16ad132 | 2017-02-08 21:27:42 +0100 | [diff] [blame] | 599 | if (processed_sec[i]) |
| 600 | continue; |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 601 | |
| 602 | if (get_sec(elf, i, &ehdr, &shname, &shdr, &data)) |
| 603 | continue; |
Jesper Dangaard Brouer | 7bc5795 | 2017-05-30 14:37:51 +0200 | [diff] [blame] | 604 | |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 605 | if (shdr.sh_type == SHT_REL) { |
| 606 | struct bpf_insn *insns; |
| 607 | |
Jesper Dangaard Brouer | 7bc5795 | 2017-05-30 14:37:51 +0200 | [diff] [blame] | 608 | /* locate prog sec that need map fixup (relocations) */ |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 609 | if (get_sec(elf, shdr.sh_info, &ehdr, &shname_prog, |
| 610 | &shdr_prog, &data_prog)) |
| 611 | continue; |
| 612 | |
Alexei Starovoitov | db6a71d | 2016-11-22 16:52:09 -0800 | [diff] [blame] | 613 | if (shdr_prog.sh_type != SHT_PROGBITS || |
| 614 | !(shdr_prog.sh_flags & SHF_EXECINSTR)) |
| 615 | continue; |
| 616 | |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 617 | insns = (struct bpf_insn *) data_prog->d_buf; |
Jesper Dangaard Brouer | 7bc5795 | 2017-05-30 14:37:51 +0200 | [diff] [blame] | 618 | processed_sec[i] = true; /* relo section */ |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 619 | |
Jesper Dangaard Brouer | 156450d | 2017-05-02 14:31:56 +0200 | [diff] [blame] | 620 | if (parse_relo_and_apply(data, symbols, &shdr, insns, |
| 621 | map_data, nr_maps)) |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 622 | continue; |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 623 | } |
| 624 | } |
| 625 | |
Jesper Dangaard Brouer | 7bc5795 | 2017-05-30 14:37:51 +0200 | [diff] [blame] | 626 | /* load programs */ |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 627 | for (i = 1; i < ehdr.e_shnum; i++) { |
| 628 | |
| 629 | if (processed_sec[i]) |
| 630 | continue; |
| 631 | |
| 632 | if (get_sec(elf, i, &ehdr, &shname, &shdr, &data)) |
| 633 | continue; |
| 634 | |
Alexei Starovoitov | b896c4f | 2015-03-25 12:49:23 -0700 | [diff] [blame] | 635 | if (memcmp(shname, "kprobe/", 7) == 0 || |
| 636 | memcmp(shname, "kretprobe/", 10) == 0 || |
Alexei Starovoitov | c076604 | 2016-04-06 18:43:29 -0700 | [diff] [blame] | 637 | memcmp(shname, "tracepoint/", 11) == 0 || |
Alexei Starovoitov | 4662a4e | 2018-03-28 12:05:39 -0700 | [diff] [blame] | 638 | memcmp(shname, "raw_tracepoint/", 15) == 0 || |
Brenden Blanco | 86af8b4 | 2016-07-19 12:16:51 -0700 | [diff] [blame] | 639 | memcmp(shname, "xdp", 3) == 0 || |
Alexei Starovoitov | 1c47910e | 2016-09-01 18:37:25 -0700 | [diff] [blame] | 640 | memcmp(shname, "perf_event", 10) == 0 || |
David Ahern | 4f2e7ae | 2016-12-01 08:48:07 -0800 | [diff] [blame] | 641 | memcmp(shname, "socket", 6) == 0 || |
Lawrence Brakmo | 40304b2 | 2017-06-30 20:02:40 -0700 | [diff] [blame] | 642 | memcmp(shname, "cgroup/", 7) == 0 || |
John Fastabend | 69e8cc1 | 2017-08-15 22:33:32 -0700 | [diff] [blame] | 643 | memcmp(shname, "sockops", 7) == 0 || |
John Fastabend | 4c4c3c2 | 2018-03-18 12:57:41 -0700 | [diff] [blame] | 644 | memcmp(shname, "sk_skb", 6) == 0 || |
| 645 | memcmp(shname, "sk_msg", 6) == 0) { |
Lawrence Brakmo | f856e46 | 2017-07-04 15:57:50 -0700 | [diff] [blame] | 646 | ret = load_and_attach(shname, data->d_buf, |
| 647 | data->d_size); |
| 648 | if (ret != 0) |
| 649 | goto done; |
| 650 | } |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 651 | } |
| 652 | |
Martin KaFai Lau | 9fd63d0 | 2017-04-14 10:30:28 -0700 | [diff] [blame] | 653 | done: |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 654 | close(fd); |
Martin KaFai Lau | 9fd63d0 | 2017-04-14 10:30:28 -0700 | [diff] [blame] | 655 | return ret; |
| 656 | } |
| 657 | |
| 658 | int load_bpf_file(char *path) |
| 659 | { |
| 660 | return do_load_bpf_file(path, NULL); |
| 661 | } |
| 662 | |
| 663 | int load_bpf_file_fixup_map(const char *path, fixup_map_cb fixup_map) |
| 664 | { |
| 665 | return do_load_bpf_file(path, fixup_map); |
Alexei Starovoitov | 249b812 | 2014-12-01 15:06:37 -0800 | [diff] [blame] | 666 | } |
Alexei Starovoitov | b896c4f | 2015-03-25 12:49:23 -0700 | [diff] [blame] | 667 | |
| 668 | void read_trace_pipe(void) |
| 669 | { |
| 670 | int trace_fd; |
| 671 | |
| 672 | trace_fd = open(DEBUGFS "trace_pipe", O_RDONLY, 0); |
| 673 | if (trace_fd < 0) |
| 674 | return; |
| 675 | |
| 676 | while (1) { |
| 677 | static char buf[4096]; |
| 678 | ssize_t sz; |
| 679 | |
Chang-Hsien Tsai | e777911 | 2019-05-19 09:05:44 +0000 | [diff] [blame] | 680 | sz = read(trace_fd, buf, sizeof(buf) - 1); |
Alexei Starovoitov | b896c4f | 2015-03-25 12:49:23 -0700 | [diff] [blame] | 681 | if (sz > 0) { |
| 682 | buf[sz] = 0; |
| 683 | puts(buf); |
| 684 | } |
| 685 | } |
| 686 | } |