samples/bpf/xdp_monitor_kern.c

   1 /* SPDX-License-Identifier: GPL-2.0
   2  *  Copyright(c) 2017-2018 Jesper Dangaard Brouer, Red Hat Inc.
   3  *
   4  * XDP monitor tool, based on tracepoints
   5  */
   6 #include <uapi/linux/bpf.h>
   7 #include "bpf_helpers.h"
   8
   9 struct bpf_map_def SEC("maps") redirect_err_cnt = {
  10         .type = BPF_MAP_TYPE_PERCPU_ARRAY,
  11         .key_size = sizeof(u32),
  12         .value_size = sizeof(u64),
  13         .max_entries = 2,
  14         /* TODO: have entries for all possible errno's */
  15 };
  16
  17 #define XDP_UNKNOWN     XDP_REDIRECT + 1
  18 struct bpf_map_def SEC("maps") exception_cnt = {
  19         .type           = BPF_MAP_TYPE_PERCPU_ARRAY,
  20         .key_size       = sizeof(u32),
  21         .value_size     = sizeof(u64),
  22         .max_entries    = XDP_UNKNOWN + 1,
  23 };
  24
  25 /* Tracepoint format: /sys/kernel/debug/tracing/events/xdp/xdp_redirect/format
  26  * Code in:                kernel/include/trace/events/xdp.h
  27  */
  28 struct xdp_redirect_ctx {
  29         u64 __pad;              // First 8 bytes are not accessible by bpf code
  30         int prog_id;            //      offset:8;  size:4; signed:1;
  31         u32 act;                //      offset:12  size:4; signed:0;
  32         int ifindex;            //      offset:16  size:4; signed:1;
  33         int err;                //      offset:20  size:4; signed:1;
  34         int to_ifindex;         //      offset:24  size:4; signed:1;
  35         u32 map_id;             //      offset:28  size:4; signed:0;
  36         int map_index;          //      offset:32  size:4; signed:1;
  37 };                              //      offset:36
  38
  39 enum {
  40         XDP_REDIRECT_SUCCESS = 0,
  41         XDP_REDIRECT_ERROR = 1
  42 };
  43
  44 static __always_inline
  45 int xdp_redirect_collect_stat(struct xdp_redirect_ctx *ctx)
  46 {
  47         u32 key = XDP_REDIRECT_ERROR;
  48         int err = ctx->err;
  49         u64 *cnt;
  50
  51         if (!err)
  52                 key = XDP_REDIRECT_SUCCESS;
  53
  54         cnt  = bpf_map_lookup_elem(&redirect_err_cnt, &key);
  55         if (!cnt)
  56                 return 1;
  57         *cnt += 1;
  58
  59         return 0; /* Indicate event was filtered (no further processing)*/
  60         /*
  61          * Returning 1 here would allow e.g. a perf-record tracepoint
  62          * to see and record these events, but it doesn't work well
  63          * in-practice as stopping perf-record also unload this
  64          * bpf_prog.  Plus, there is additional overhead of doing so.
  65          */
  66 }
  67
  68 SEC("tracepoint/xdp/xdp_redirect_err")
  69 int trace_xdp_redirect_err(struct xdp_redirect_ctx *ctx)
  70 {
  71         return xdp_redirect_collect_stat(ctx);
  72 }
  73
  74
  75 SEC("tracepoint/xdp/xdp_redirect_map_err")
  76 int trace_xdp_redirect_map_err(struct xdp_redirect_ctx *ctx)
  77 {
  78         return xdp_redirect_collect_stat(ctx);
  79 }
  80
  81 /* Likely unloaded when prog starts */
  82 SEC("tracepoint/xdp/xdp_redirect")
  83 int trace_xdp_redirect(struct xdp_redirect_ctx *ctx)
  84 {
  85         return xdp_redirect_collect_stat(ctx);
  86 }
  87
  88 /* Likely unloaded when prog starts */
  89 SEC("tracepoint/xdp/xdp_redirect_map")
  90 int trace_xdp_redirect_map(struct xdp_redirect_ctx *ctx)
  91 {
  92         return xdp_redirect_collect_stat(ctx);
  93 }
  94
  95 /* Tracepoint format: /sys/kernel/debug/tracing/events/xdp/xdp_exception/format
  96  * Code in:                kernel/include/trace/events/xdp.h
  97  */
  98 struct xdp_exception_ctx {
  99         u64 __pad;      // First 8 bytes are not accessible by bpf code
 100         int prog_id;    //      offset:8;  size:4; signed:1;
 101         u32 act;        //      offset:12; size:4; signed:0;
 102         int ifindex;    //      offset:16; size:4; signed:1;
 103 };
 104
 105 SEC("tracepoint/xdp/xdp_exception")
 106 int trace_xdp_exception(struct xdp_exception_ctx *ctx)
 107 {
 108         u64 *cnt;
 109         u32 key;
 110
 111         key = ctx->act;
 112         if (key > XDP_REDIRECT)
 113                 key = XDP_UNKNOWN;
 114
 115         cnt = bpf_map_lookup_elem(&exception_cnt, &key);
 116         if (!cnt)
 117                 return 1;
 118         *cnt += 1;
 119
 120         return 0;
 121 }
 122
 123 /* Common stats data record shared with _user.c */
 124 struct datarec {
 125         u64 processed;
 126         u64 dropped;
 127         u64 info;
 128 };
 129 #define MAX_CPUS 64
 130
 131 struct bpf_map_def SEC("maps") cpumap_enqueue_cnt = {
 132         .type           = BPF_MAP_TYPE_PERCPU_ARRAY,
 133         .key_size       = sizeof(u32),
 134         .value_size     = sizeof(struct datarec),
 135         .max_entries    = MAX_CPUS,
 136 };
 137
 138 struct bpf_map_def SEC("maps") cpumap_kthread_cnt = {
 139         .type           = BPF_MAP_TYPE_PERCPU_ARRAY,
 140         .key_size       = sizeof(u32),
 141         .value_size     = sizeof(struct datarec),
 142         .max_entries    = 1,
 143 };
 144
 145 /* Tracepoint: /sys/kernel/debug/tracing/events/xdp/xdp_cpumap_enqueue/format
 146  * Code in:         kernel/include/trace/events/xdp.h
 147  */
 148 struct cpumap_enqueue_ctx {
 149         u64 __pad;              // First 8 bytes are not accessible by bpf code
 150         int map_id;             //      offset:8;  size:4; signed:1;
 151         u32 act;                //      offset:12; size:4; signed:0;
 152         int cpu;                //      offset:16; size:4; signed:1;
 153         unsigned int drops;     //      offset:20; size:4; signed:0;
 154         unsigned int processed; //      offset:24; size:4; signed:0;
 155         int to_cpu;             //      offset:28; size:4; signed:1;
 156 };
 157
 158 SEC("tracepoint/xdp/xdp_cpumap_enqueue")
 159 int trace_xdp_cpumap_enqueue(struct cpumap_enqueue_ctx *ctx)
 160 {
 161         u32 to_cpu = ctx->to_cpu;
 162         struct datarec *rec;
 163
 164         if (to_cpu >= MAX_CPUS)
 165                 return 1;
 166
 167         rec = bpf_map_lookup_elem(&cpumap_enqueue_cnt, &to_cpu);
 168         if (!rec)
 169                 return 0;
 170         rec->processed += ctx->processed;
 171         rec->dropped   += ctx->drops;
 172
 173         /* Record bulk events, then userspace can calc average bulk size */
 174         if (ctx->processed > 0)
 175                 rec->info += 1;
 176
 177         return 0;
 178 }
 179
 180 /* Tracepoint: /sys/kernel/debug/tracing/events/xdp/xdp_cpumap_kthread/format
 181  * Code in:         kernel/include/trace/events/xdp.h
 182  */
 183 struct cpumap_kthread_ctx {
 184         u64 __pad;              // First 8 bytes are not accessible by bpf code
 185         int map_id;             //      offset:8;  size:4; signed:1;
 186         u32 act;                //      offset:12; size:4; signed:0;
 187         int cpu;                //      offset:16; size:4; signed:1;
 188         unsigned int drops;     //      offset:20; size:4; signed:0;
 189         unsigned int processed; //      offset:24; size:4; signed:0;
 190         int sched;              //      offset:28; size:4; signed:1;
 191 };
 192
 193 SEC("tracepoint/xdp/xdp_cpumap_kthread")
 194 int trace_xdp_cpumap_kthread(struct cpumap_kthread_ctx *ctx)
 195 {
 196         struct datarec *rec;
 197         u32 key = 0;
 198
 199         rec = bpf_map_lookup_elem(&cpumap_kthread_cnt, &key);
 200         if (!rec)
 201                 return 0;
 202         rec->processed += ctx->processed;
 203         rec->dropped   += ctx->drops;
 204
 205         /* Count times kthread yielded CPU via schedule call */
 206         if (ctx->sched)
 207                 rec->info++;
 208
 209         return 0;
 210 }