| /* SPDX-License-Identifier: GPL-2.0 | |
| * Copyright(c) 2017-2018 Jesper Dangaard Brouer, Red Hat Inc. | |
| * | |
| * XDP monitor tool, based on tracepoints | |
| */ | |
| #include <uapi/linux/bpf.h> | |
| #include "bpf_helpers.h" | |
| struct bpf_map_def SEC("maps") redirect_err_cnt = { | |
| .type = BPF_MAP_TYPE_PERCPU_ARRAY, | |
| .key_size = sizeof(u32), | |
| .value_size = sizeof(u64), | |
| .max_entries = 2, | |
| /* TODO: have entries for all possible errno's */ | |
| }; | |
| #define XDP_UNKNOWN XDP_REDIRECT + 1 | |
| struct bpf_map_def SEC("maps") exception_cnt = { | |
| .type = BPF_MAP_TYPE_PERCPU_ARRAY, | |
| .key_size = sizeof(u32), | |
| .value_size = sizeof(u64), | |
| .max_entries = XDP_UNKNOWN + 1, | |
| }; | |
| /* Tracepoint format: /sys/kernel/debug/tracing/events/xdp/xdp_redirect/format | |
| * Code in: kernel/include/trace/events/xdp.h | |
| */ | |
| struct xdp_redirect_ctx { | |
| u64 __pad; // First 8 bytes are not accessible by bpf code | |
| int prog_id; // offset:8; size:4; signed:1; | |
| u32 act; // offset:12 size:4; signed:0; | |
| int ifindex; // offset:16 size:4; signed:1; | |
| int err; // offset:20 size:4; signed:1; | |
| int to_ifindex; // offset:24 size:4; signed:1; | |
| u32 map_id; // offset:28 size:4; signed:0; | |
| int map_index; // offset:32 size:4; signed:1; | |
| }; // offset:36 | |
| enum { | |
| XDP_REDIRECT_SUCCESS = 0, | |
| XDP_REDIRECT_ERROR = 1 | |
| }; | |
| static __always_inline | |
| int xdp_redirect_collect_stat(struct xdp_redirect_ctx *ctx) | |
| { | |
| u32 key = XDP_REDIRECT_ERROR; | |
| int err = ctx->err; | |
| u64 *cnt; | |
| if (!err) | |
| key = XDP_REDIRECT_SUCCESS; | |
| cnt = bpf_map_lookup_elem(&redirect_err_cnt, &key); | |
| if (!cnt) | |
| return 1; | |
| *cnt += 1; | |
| return 0; /* Indicate event was filtered (no further processing)*/ | |
| /* | |
| * Returning 1 here would allow e.g. a perf-record tracepoint | |
| * to see and record these events, but it doesn't work well | |
| * in-practice as stopping perf-record also unload this | |
| * bpf_prog. Plus, there is additional overhead of doing so. | |
| */ | |
| } | |
| SEC("tracepoint/xdp/xdp_redirect_err") | |
| int trace_xdp_redirect_err(struct xdp_redirect_ctx *ctx) | |
| { | |
| return xdp_redirect_collect_stat(ctx); | |
| } | |
| SEC("tracepoint/xdp/xdp_redirect_map_err") | |
| int trace_xdp_redirect_map_err(struct xdp_redirect_ctx *ctx) | |
| { | |
| return xdp_redirect_collect_stat(ctx); | |
| } | |
| /* Likely unloaded when prog starts */ | |
| SEC("tracepoint/xdp/xdp_redirect") | |
| int trace_xdp_redirect(struct xdp_redirect_ctx *ctx) | |
| { | |
| return xdp_redirect_collect_stat(ctx); | |
| } | |
| /* Likely unloaded when prog starts */ | |
| SEC("tracepoint/xdp/xdp_redirect_map") | |
| int trace_xdp_redirect_map(struct xdp_redirect_ctx *ctx) | |
| { | |
| return xdp_redirect_collect_stat(ctx); | |
| } | |
| /* Tracepoint format: /sys/kernel/debug/tracing/events/xdp/xdp_exception/format | |
| * Code in: kernel/include/trace/events/xdp.h | |
| */ | |
| struct xdp_exception_ctx { | |
| u64 __pad; // First 8 bytes are not accessible by bpf code | |
| int prog_id; // offset:8; size:4; signed:1; | |
| u32 act; // offset:12; size:4; signed:0; | |
| int ifindex; // offset:16; size:4; signed:1; | |
| }; | |
| SEC("tracepoint/xdp/xdp_exception") | |
| int trace_xdp_exception(struct xdp_exception_ctx *ctx) | |
| { | |
| u64 *cnt; | |
| u32 key; | |
| key = ctx->act; | |
| if (key > XDP_REDIRECT) | |
| key = XDP_UNKNOWN; | |
| cnt = bpf_map_lookup_elem(&exception_cnt, &key); | |
| if (!cnt) | |
| return 1; | |
| *cnt += 1; | |
| return 0; | |
| } | |
| /* Common stats data record shared with _user.c */ | |
| struct datarec { | |
| u64 processed; | |
| u64 dropped; | |
| u64 info; | |
| u64 err; | |
| }; | |
| #define MAX_CPUS 64 | |
| struct bpf_map_def SEC("maps") cpumap_enqueue_cnt = { | |
| .type = BPF_MAP_TYPE_PERCPU_ARRAY, | |
| .key_size = sizeof(u32), | |
| .value_size = sizeof(struct datarec), | |
| .max_entries = MAX_CPUS, | |
| }; | |
| struct bpf_map_def SEC("maps") cpumap_kthread_cnt = { | |
| .type = BPF_MAP_TYPE_PERCPU_ARRAY, | |
| .key_size = sizeof(u32), | |
| .value_size = sizeof(struct datarec), | |
| .max_entries = 1, | |
| }; | |
| /* Tracepoint: /sys/kernel/debug/tracing/events/xdp/xdp_cpumap_enqueue/format | |
| * Code in: kernel/include/trace/events/xdp.h | |
| */ | |
| struct cpumap_enqueue_ctx { | |
| u64 __pad; // First 8 bytes are not accessible by bpf code | |
| int map_id; // offset:8; size:4; signed:1; | |
| u32 act; // offset:12; size:4; signed:0; | |
| int cpu; // offset:16; size:4; signed:1; | |
| unsigned int drops; // offset:20; size:4; signed:0; | |
| unsigned int processed; // offset:24; size:4; signed:0; | |
| int to_cpu; // offset:28; size:4; signed:1; | |
| }; | |
| SEC("tracepoint/xdp/xdp_cpumap_enqueue") | |
| int trace_xdp_cpumap_enqueue(struct cpumap_enqueue_ctx *ctx) | |
| { | |
| u32 to_cpu = ctx->to_cpu; | |
| struct datarec *rec; | |
| if (to_cpu >= MAX_CPUS) | |
| return 1; | |
| rec = bpf_map_lookup_elem(&cpumap_enqueue_cnt, &to_cpu); | |
| if (!rec) | |
| return 0; | |
| rec->processed += ctx->processed; | |
| rec->dropped += ctx->drops; | |
| /* Record bulk events, then userspace can calc average bulk size */ | |
| if (ctx->processed > 0) | |
| rec->info += 1; | |
| return 0; | |
| } | |
| /* Tracepoint: /sys/kernel/debug/tracing/events/xdp/xdp_cpumap_kthread/format | |
| * Code in: kernel/include/trace/events/xdp.h | |
| */ | |
| struct cpumap_kthread_ctx { | |
| u64 __pad; // First 8 bytes are not accessible by bpf code | |
| int map_id; // offset:8; size:4; signed:1; | |
| u32 act; // offset:12; size:4; signed:0; | |
| int cpu; // offset:16; size:4; signed:1; | |
| unsigned int drops; // offset:20; size:4; signed:0; | |
| unsigned int processed; // offset:24; size:4; signed:0; | |
| int sched; // offset:28; size:4; signed:1; | |
| }; | |
| SEC("tracepoint/xdp/xdp_cpumap_kthread") | |
| int trace_xdp_cpumap_kthread(struct cpumap_kthread_ctx *ctx) | |
| { | |
| struct datarec *rec; | |
| u32 key = 0; | |
| rec = bpf_map_lookup_elem(&cpumap_kthread_cnt, &key); | |
| if (!rec) | |
| return 0; | |
| rec->processed += ctx->processed; | |
| rec->dropped += ctx->drops; | |
| /* Count times kthread yielded CPU via schedule call */ | |
| if (ctx->sched) | |
| rec->info++; | |
| return 0; | |
| } | |
| struct bpf_map_def SEC("maps") devmap_xmit_cnt = { | |
| .type = BPF_MAP_TYPE_PERCPU_ARRAY, | |
| .key_size = sizeof(u32), | |
| .value_size = sizeof(struct datarec), | |
| .max_entries = 1, | |
| }; | |
| /* Tracepoint: /sys/kernel/debug/tracing/events/xdp/xdp_devmap_xmit/format | |
| * Code in: kernel/include/trace/events/xdp.h | |
| */ | |
| struct devmap_xmit_ctx { | |
| u64 __pad; // First 8 bytes are not accessible by bpf code | |
| int map_id; // offset:8; size:4; signed:1; | |
| u32 act; // offset:12; size:4; signed:0; | |
| u32 map_index; // offset:16; size:4; signed:0; | |
| int drops; // offset:20; size:4; signed:1; | |
| int sent; // offset:24; size:4; signed:1; | |
| int from_ifindex; // offset:28; size:4; signed:1; | |
| int to_ifindex; // offset:32; size:4; signed:1; | |
| int err; // offset:36; size:4; signed:1; | |
| }; | |
| SEC("tracepoint/xdp/xdp_devmap_xmit") | |
| int trace_xdp_devmap_xmit(struct devmap_xmit_ctx *ctx) | |
| { | |
| struct datarec *rec; | |
| u32 key = 0; | |
| rec = bpf_map_lookup_elem(&devmap_xmit_cnt, &key); | |
| if (!rec) | |
| return 0; | |
| rec->processed += ctx->sent; | |
| rec->dropped += ctx->drops; | |
| /* Record bulk events, then userspace can calc average bulk size */ | |
| rec->info += 1; | |
| /* Record error cases, where no frame were sent */ | |
| if (ctx->err) | |
| rec->err++; | |
| /* Catch API error of drv ndo_xdp_xmit sent more than count */ | |
| if (ctx->drops < 0) | |
| rec->err++; | |
| return 1; | |
| } |