samples/bpf/xdp_sample.bpf.h

   1 // SPDX-License-Identifier: GPL-2.0
   2 #ifndef _XDP_SAMPLE_BPF_H
   3 #define _XDP_SAMPLE_BPF_H
   4
   5 #include "vmlinux.h"
   6 #include <bpf/bpf_tracing.h>
   7 #include <bpf/bpf_core_read.h>
   8 #include <bpf/bpf_helpers.h>
   9
  10 #include "net_shared.h"
  11 #include "xdp_sample_shared.h"
  12
  13 #define EINVAL 22
  14 #define ENETDOWN 100
  15 #define EMSGSIZE 90
  16 #define EOPNOTSUPP 95
  17 #define ENOSPC 28
  18
  19 typedef struct {
  20         __uint(type, BPF_MAP_TYPE_ARRAY);
  21         __uint(map_flags, BPF_F_MMAPABLE);
  22         __type(key, unsigned int);
  23         __type(value, struct datarec);
  24 } array_map;
  25
  26 extern array_map rx_cnt;
  27 extern const volatile int nr_cpus;
  28
  29 enum {
  30         XDP_REDIRECT_SUCCESS = 0,
  31         XDP_REDIRECT_ERROR = 1
  32 };
  33
  34 static __always_inline void swap_src_dst_mac(void *data)
  35 {
  36         unsigned short *p = data;
  37         unsigned short dst[3];
  38
  39         dst[0] = p[0];
  40         dst[1] = p[1];
  41         dst[2] = p[2];
  42         p[0] = p[3];
  43         p[1] = p[4];
  44         p[2] = p[5];
  45         p[3] = dst[0];
  46         p[4] = dst[1];
  47         p[5] = dst[2];
  48 }
  49
  50 /*
  51  * Note: including linux/compiler.h or linux/kernel.h for the macros below
  52  * conflicts with vmlinux.h include in BPF files, so we define them here.
  53  *
  54  * Following functions are taken from kernel sources and
  55  * break aliasing rules in their original form.
  56  *
  57  * While kernel is compiled with -fno-strict-aliasing,
  58  * perf uses -Wstrict-aliasing=3 which makes build fail
  59  * under gcc 4.4.
  60  *
  61  * Using extra __may_alias__ type to allow aliasing
  62  * in this case.
  63  */
  64 typedef __u8  __attribute__((__may_alias__))  __u8_alias_t;
  65 typedef __u16 __attribute__((__may_alias__)) __u16_alias_t;
  66 typedef __u32 __attribute__((__may_alias__)) __u32_alias_t;
  67 typedef __u64 __attribute__((__may_alias__)) __u64_alias_t;
  68
  69 static __always_inline void __read_once_size(const volatile void *p, void *res, int size)
  70 {
  71         switch (size) {
  72         case 1: *(__u8_alias_t  *) res = *(volatile __u8_alias_t  *) p; break;
  73         case 2: *(__u16_alias_t *) res = *(volatile __u16_alias_t *) p; break;
  74         case 4: *(__u32_alias_t *) res = *(volatile __u32_alias_t *) p; break;
  75         case 8: *(__u64_alias_t *) res = *(volatile __u64_alias_t *) p; break;
  76         default:
  77                 asm volatile ("" : : : "memory");
  78                 __builtin_memcpy((void *)res, (const void *)p, size);
  79                 asm volatile ("" : : : "memory");
  80         }
  81 }
  82
  83 static __always_inline void __write_once_size(volatile void *p, void *res, int size)
  84 {
  85         switch (size) {
  86         case 1: *(volatile  __u8_alias_t *) p = *(__u8_alias_t  *) res; break;
  87         case 2: *(volatile __u16_alias_t *) p = *(__u16_alias_t *) res; break;
  88         case 4: *(volatile __u32_alias_t *) p = *(__u32_alias_t *) res; break;
  89         case 8: *(volatile __u64_alias_t *) p = *(__u64_alias_t *) res; break;
  90         default:
  91                 asm volatile ("" : : : "memory");
  92                 __builtin_memcpy((void *)p, (const void *)res, size);
  93                 asm volatile ("" : : : "memory");
  94         }
  95 }
  96
  97 #define READ_ONCE(x)                                    \
  98 ({                                                      \
  99         union { typeof(x) __val; char __c[1]; } __u =   \
 100                 { .__c = { 0 } };                       \
 101         __read_once_size(&(x), __u.__c, sizeof(x));     \
 102         __u.__val;                                      \
 103 })
 104
 105 #define WRITE_ONCE(x, val)                              \
 106 ({                                                      \
 107         union { typeof(x) __val; char __c[1]; } __u =   \
 108                 { .__val = (val) };                     \
 109         __write_once_size(&(x), __u.__c, sizeof(x));    \
 110         __u.__val;                                      \
 111 })
 112
 113 /* Add a value using relaxed read and relaxed write. Less expensive than
 114  * fetch_add when there is no write concurrency.
 115  */
 116 #define NO_TEAR_ADD(x, val) WRITE_ONCE((x), READ_ONCE(x) + (val))
 117 #define NO_TEAR_INC(x) NO_TEAR_ADD((x), 1)
 118
 119 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
 120
 121 #endif