mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-04 09:34:12 +08:00
e69fe84595
Currently, many programs under sample/bpf often include individual macros by directly including the header under "linux/" rather than using the "vmlinux.h" header. However, there are some problems with migrating to "vmlinux.h" because there is no definition for utility functions such as endianness conversion (ntohs/htons). Fortunately, the xdp_sample program already has a function that can be replaced to solve this problem. Therefore, this commit attempts to separate these functions into a file called net_shared.h to make them universally available. Additionally, this file includes network-related macros that are not defined in "vmlinux.h". (inspired by 'selftests' bpf_tracing_net.h) Signed-off-by: Daniel T. Lee <danieltimlee@gmail.com> Link: https://lore.kernel.org/r/20230115071613.125791-8-danieltimlee@gmail.com Signed-off-by: Alexei Starovoitov <ast@kernel.org>
122 lines
3.3 KiB
C
122 lines
3.3 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
#ifndef _XDP_SAMPLE_BPF_H
|
|
#define _XDP_SAMPLE_BPF_H
|
|
|
|
#include "vmlinux.h"
|
|
#include <bpf/bpf_tracing.h>
|
|
#include <bpf/bpf_core_read.h>
|
|
#include <bpf/bpf_helpers.h>
|
|
|
|
#include "net_shared.h"
|
|
#include "xdp_sample_shared.h"
|
|
|
|
#define EINVAL 22
|
|
#define ENETDOWN 100
|
|
#define EMSGSIZE 90
|
|
#define EOPNOTSUPP 95
|
|
#define ENOSPC 28
|
|
|
|
typedef struct {
|
|
__uint(type, BPF_MAP_TYPE_ARRAY);
|
|
__uint(map_flags, BPF_F_MMAPABLE);
|
|
__type(key, unsigned int);
|
|
__type(value, struct datarec);
|
|
} array_map;
|
|
|
|
extern array_map rx_cnt;
|
|
extern const volatile int nr_cpus;
|
|
|
|
enum {
|
|
XDP_REDIRECT_SUCCESS = 0,
|
|
XDP_REDIRECT_ERROR = 1
|
|
};
|
|
|
|
static __always_inline void swap_src_dst_mac(void *data)
|
|
{
|
|
unsigned short *p = data;
|
|
unsigned short dst[3];
|
|
|
|
dst[0] = p[0];
|
|
dst[1] = p[1];
|
|
dst[2] = p[2];
|
|
p[0] = p[3];
|
|
p[1] = p[4];
|
|
p[2] = p[5];
|
|
p[3] = dst[0];
|
|
p[4] = dst[1];
|
|
p[5] = dst[2];
|
|
}
|
|
|
|
/*
|
|
* Note: including linux/compiler.h or linux/kernel.h for the macros below
|
|
* conflicts with vmlinux.h include in BPF files, so we define them here.
|
|
*
|
|
* Following functions are taken from kernel sources and
|
|
* break aliasing rules in their original form.
|
|
*
|
|
* While kernel is compiled with -fno-strict-aliasing,
|
|
* perf uses -Wstrict-aliasing=3 which makes build fail
|
|
* under gcc 4.4.
|
|
*
|
|
* Using extra __may_alias__ type to allow aliasing
|
|
* in this case.
|
|
*/
|
|
typedef __u8 __attribute__((__may_alias__)) __u8_alias_t;
|
|
typedef __u16 __attribute__((__may_alias__)) __u16_alias_t;
|
|
typedef __u32 __attribute__((__may_alias__)) __u32_alias_t;
|
|
typedef __u64 __attribute__((__may_alias__)) __u64_alias_t;
|
|
|
|
static __always_inline void __read_once_size(const volatile void *p, void *res, int size)
|
|
{
|
|
switch (size) {
|
|
case 1: *(__u8_alias_t *) res = *(volatile __u8_alias_t *) p; break;
|
|
case 2: *(__u16_alias_t *) res = *(volatile __u16_alias_t *) p; break;
|
|
case 4: *(__u32_alias_t *) res = *(volatile __u32_alias_t *) p; break;
|
|
case 8: *(__u64_alias_t *) res = *(volatile __u64_alias_t *) p; break;
|
|
default:
|
|
asm volatile ("" : : : "memory");
|
|
__builtin_memcpy((void *)res, (const void *)p, size);
|
|
asm volatile ("" : : : "memory");
|
|
}
|
|
}
|
|
|
|
static __always_inline void __write_once_size(volatile void *p, void *res, int size)
|
|
{
|
|
switch (size) {
|
|
case 1: *(volatile __u8_alias_t *) p = *(__u8_alias_t *) res; break;
|
|
case 2: *(volatile __u16_alias_t *) p = *(__u16_alias_t *) res; break;
|
|
case 4: *(volatile __u32_alias_t *) p = *(__u32_alias_t *) res; break;
|
|
case 8: *(volatile __u64_alias_t *) p = *(__u64_alias_t *) res; break;
|
|
default:
|
|
asm volatile ("" : : : "memory");
|
|
__builtin_memcpy((void *)p, (const void *)res, size);
|
|
asm volatile ("" : : : "memory");
|
|
}
|
|
}
|
|
|
|
#define READ_ONCE(x) \
|
|
({ \
|
|
union { typeof(x) __val; char __c[1]; } __u = \
|
|
{ .__c = { 0 } }; \
|
|
__read_once_size(&(x), __u.__c, sizeof(x)); \
|
|
__u.__val; \
|
|
})
|
|
|
|
#define WRITE_ONCE(x, val) \
|
|
({ \
|
|
union { typeof(x) __val; char __c[1]; } __u = \
|
|
{ .__val = (val) }; \
|
|
__write_once_size(&(x), __u.__c, sizeof(x)); \
|
|
__u.__val; \
|
|
})
|
|
|
|
/* Add a value using relaxed read and relaxed write. Less expensive than
|
|
* fetch_add when there is no write concurrency.
|
|
*/
|
|
#define NO_TEAR_ADD(x, val) WRITE_ONCE((x), READ_ONCE(x) + (val))
|
|
#define NO_TEAR_INC(x) NO_TEAR_ADD((x), 1)
|
|
|
|
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
|
|
|
|
#endif
|