diff options
Diffstat (limited to '')
| -rw-r--r-- | lib/util/Makefile | 34 | ||||
| -rw-r--r-- | lib/util/compat.h | 12 | ||||
| -rw-r--r-- | lib/util/logging.c | 96 | ||||
| -rw-r--r-- | lib/util/logging.h | 35 | ||||
| -rw-r--r-- | lib/util/params.c | 808 | ||||
| -rw-r--r-- | lib/util/params.h | 149 | ||||
| -rw-r--r-- | lib/util/stats.c | 292 | ||||
| -rw-r--r-- | lib/util/stats.h | 26 | ||||
| -rw-r--r-- | lib/util/util.c | 946 | ||||
| -rw-r--r-- | lib/util/util.h | 97 | ||||
| -rw-r--r-- | lib/util/util.mk | 2 | ||||
| -rw-r--r-- | lib/util/xdp_sample.bpf.c | 18 | ||||
| -rw-r--r-- | lib/util/xdp_sample.c | 1643 | ||||
| -rw-r--r-- | lib/util/xdp_sample.h | 133 | ||||
| -rw-r--r-- | lib/util/xpcapng.c | 635 | ||||
| -rw-r--r-- | lib/util/xpcapng.h | 58 |
16 files changed, 4984 insertions, 0 deletions
diff --git a/lib/util/Makefile b/lib/util/Makefile new file mode 100644 index 0000000..24070f0 --- /dev/null +++ b/lib/util/Makefile @@ -0,0 +1,34 @@ +include util.mk + +LIB_DIR ?= .. + +include $(LIB_DIR)/defines.mk +include $(LIBXDP_DIR)/libxdp.mk + +all: $(UTIL_OBJS) + +UTIL_SKEL_H = $(UTIL_BPF_OBJS:.bpf.o=.skel.h) + +$(UTIL_OBJS): %.o: %.c %.h $(UTIL_SKEL_H) $(LIBMK) + $(QUIET_CC)$(CC) $(CFLAGS) $(CPPFLAGS) -Wall -I../../headers -c -o $@ $< + +clean: + $(Q)rm -f $(UTIL_OBJS) $(UTIL_BPF_OBJS) $(UTIL_SKEL_H) + +BPF_CFLAGS += -I$(HEADER_DIR) $(ARCH_INCLUDES) + +$(UTIL_BPF_OBJS): %.o: %.c $(KERN_USER_H) $(BPF_HEADERS) $(LIBMK) + $(QUIET_CLANG)$(CLANG) -S \ + -target $(BPF_TARGET) \ + -D __BPF_TRACING__ \ + $(BPF_CFLAGS) \ + -Wall \ + -Wno-unused-value \ + -Wno-pointer-sign \ + -Wno-compare-distinct-pointer-types \ + -Werror \ + -O2 -emit-llvm -c -g -o ${@:.o=.ll} $< + $(QUIET_LLC)$(LLC) -march=$(BPF_TARGET) -filetype=obj -o $@ ${@:.o=.ll} + +$(UTIL_SKEL_H): %.skel.h: %.bpf.o + $(QUIET_GEN)$(BPFTOOL) gen skeleton $< name ${@:.skel.h=} > $@ diff --git a/lib/util/compat.h b/lib/util/compat.h new file mode 100644 index 0000000..f058e9c --- /dev/null +++ b/lib/util/compat.h @@ -0,0 +1,12 @@ +#ifndef __COMPAT_H +#define __COMPAT_H + +#ifndef HAVE_LIBBPF_BTF__TYPE_CNT +static __u32 btf__type_cnt(const struct btf *btf) +{ + /* old function didn't include 'void' type in count */ + return btf__get_nr_types(btf) + 1; +} +#endif + +#endif diff --git a/lib/util/logging.c b/lib/util/logging.c new file mode 100644 index 0000000..7ad21d7 --- /dev/null +++ b/lib/util/logging.c @@ -0,0 +1,96 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +#include <stdio.h> +#include <stdarg.h> + +#include <bpf/libbpf.h> +#include <xdp/libxdp.h> + +#include "logging.h" +#include "util.h" + +static enum logging_print_level log_level = LOG_INFO; + +static int print_func(enum logging_print_level level, int indent, + const char *format, va_list args) +{ + int i; + if (level > log_level) + return 0; + + for (i = 0; i < indent; i++) + fprintf(stderr, " "); + + return vfprintf(stderr, format, args); +} + +static int libbpf_print_func(enum libbpf_print_level level, const char *format, + va_list args) +{ + return print_func(level + 1, 2, format, args); +} + +static int libbpf_silent_func(__unused enum libbpf_print_level level, + __unused const char *format, + __unused va_list args) +{ + return 0; +} + +static int libxdp_print_func(enum libxdp_print_level level, const char *format, + va_list args) +{ + return print_func(level + 1, 1, format, args); +} + +static int libxdp_silent_func(__unused enum libxdp_print_level level, + __unused const char *format, + __unused va_list args) +{ + return 0; +} + +#define __printf(a, b) __attribute__((format(printf, a, b))) + +__printf(2, 3) void logging_print(enum logging_print_level level, + const char *format, ...) +{ + va_list args; + + va_start(args, format); + print_func(level, 0, format, args); + va_end(args); +} + +void init_lib_logging(void) +{ + libbpf_set_print(libbpf_print_func); + libxdp_set_print(libxdp_print_func); +} + +void silence_libbpf_logging(void) +{ + if (log_level < LOG_VERBOSE) + libbpf_set_print(libbpf_silent_func); +} + +void silence_libxdp_logging(void) +{ + if (log_level < LOG_VERBOSE) + libxdp_set_print(libxdp_silent_func); +} + +enum logging_print_level set_log_level(enum logging_print_level level) +{ + enum logging_print_level old_level = log_level; + + log_level = level; + return old_level; +} + +enum logging_print_level increase_log_level(void) +{ + if (log_level < LOG_VERBOSE) + log_level++; + return log_level; +} diff --git a/lib/util/logging.h b/lib/util/logging.h new file mode 100644 index 0000000..16c4e74 --- /dev/null +++ b/lib/util/logging.h @@ -0,0 +1,35 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +#ifndef __LOGGING_H +#define __LOGGING_H + +/* This matches the libbpf logging levels, but with an additional VERBOSE level; + * we demote all libbpf messages by one level so debug messages only show up on + * VERBOSE. + */ +enum logging_print_level { + LOG_WARN, + LOG_INFO, + LOG_DEBUG, + LOG_VERBOSE, +}; + +extern void logging_print(enum logging_print_level level, const char *format, + ...) __attribute__((format(printf, 2, 3))); + +#define __pr(level, fmt, ...) \ + do { \ + logging_print(level, fmt, ##__VA_ARGS__); \ + } while (0) + +#define pr_warn(fmt, ...) __pr(LOG_WARN, fmt, ##__VA_ARGS__) +#define pr_info(fmt, ...) __pr(LOG_INFO, fmt, ##__VA_ARGS__) +#define pr_debug(fmt, ...) __pr(LOG_DEBUG, fmt, ##__VA_ARGS__) + +void init_lib_logging(void); +void silence_libbpf_logging(void); +void silence_libxdp_logging(void); +enum logging_print_level set_log_level(enum logging_print_level level); +enum logging_print_level increase_log_level(); + +#endif diff --git a/lib/util/params.c b/lib/util/params.c new file mode 100644 index 0000000..838a520 --- /dev/null +++ b/lib/util/params.c @@ -0,0 +1,808 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#define _GNU_SOURCE + +#include <stddef.h> +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <stdbool.h> +#include <getopt.h> +#include <errno.h> + +#include <net/if.h> +#include <linux/if_ether.h> +#include <linux/if_link.h> /* XDP_FLAGS_* depend on kernel-headers installed */ +#include <linux/if_xdp.h> +#include <arpa/inet.h> + +#include "params.h" +#include "logging.h" +#include "util.h" + +#define BUFSIZE 30 +#define FIRST_PRINTABLE 65 /* ord('A') = 65 */ +#define VERSION_SHORT_OPT 0 + +static bool opt_needs_arg(const struct prog_option *opt) +{ + return opt->type > OPT_BOOL && !opt->positional; +} + +static bool opt_is_multi(const struct prog_option *opt) +{ + return opt->type == OPT_MULTISTRING || opt->type == OPT_IFNAME_MULTI || + opt->type == OPT_U32_MULTI; +} + +static int handle_bool(__unused char *optarg, void *tgt, __unused struct prog_option *opt) +{ + bool *opt_set = tgt; + + *opt_set = true; + return 0; +} + +static int handle_string(char *optarg, void *tgt, __unused struct prog_option *opt) +{ + char **opt_set = tgt; + + *opt_set = optarg; + return 0; +} + +static int handle_multistring(char *optarg, void *tgt, __unused struct prog_option *opt) +{ + struct multistring *opt_set = tgt; + void *ptr; + + if (opt_set->num_strings +1 > SIZE_MAX / sizeof(*opt_set->strings)) + return -ENOMEM; + + ptr = realloc(opt_set->strings, sizeof(*opt_set->strings) * (opt_set->num_strings +1)); + + if (!ptr) + return -errno; + + opt_set->strings = ptr; + opt_set->strings[opt_set->num_strings++] = optarg; + return 0; +} + +static int handle_u32(char *optarg, void *tgt, __unused struct prog_option *opt) +{ + __u32 *opt_set = tgt; + unsigned long val; + + errno = 0; + val = strtoul(optarg, NULL, 10); + if (errno || val > 0xffffffff) + return -EINVAL; + + *opt_set = val; + return 0; +} + +static int handle_u32_multi(char *optarg, void *tgt, struct prog_option *opt) +{ + struct u32_multi *opt_set = tgt; + __u32 val; + void *ptr; + int ret; + + if (opt_set->num_vals +1 > SIZE_MAX / sizeof(*opt_set->vals)) + return -ENOMEM; + + ret = handle_u32(optarg, &val, opt); + if (ret) + return ret; + + ptr = realloc(opt_set->vals, sizeof(*opt_set->vals) * (opt_set->num_vals +1)); + if (!ptr) + return -errno; + + opt_set->vals = ptr; + opt_set->vals[opt_set->num_vals++] = val; + return 0; +} + +static int handle_u16(char *optarg, void *tgt, __unused struct prog_option *opt) +{ + __u16 *opt_set = tgt; + unsigned long val; + + errno = 0; + val = strtoul(optarg, NULL, 10); + if (errno || val > 0xffff) + return -EINVAL; + *opt_set = val; + return 0; +} + +static int parse_mac(char *str, unsigned char mac[ETH_ALEN]) +{ + unsigned int v[ETH_ALEN]; + int len, i; + + /* Based on https://stackoverflow.com/a/20553913 */ + len = sscanf(str, "%x:%x:%x:%x:%x:%x%*c", + &v[0], &v[1], &v[2], &v[3], &v[4], &v[5]); + + if (len != ETH_ALEN) + return -EINVAL; + + for (i = 0; i < ETH_ALEN; i++) { + if (v[i] > 0xFF) + return -EINVAL; + mac[i] = v[i]; + } + return 0; +} + +static int handle_macaddr(char *optarg, void *tgt, __unused struct prog_option *opt) +{ + struct mac_addr *opt_set = tgt; + int err; + + err = parse_mac(optarg, opt_set->addr); + if (err) + pr_warn("Invalid MAC address: %s\n", optarg); + + return err; +} + +void print_macaddr(char *buf, size_t buf_len, const struct mac_addr *addr) +{ + int i, len; + + for (i = 0; buf_len > 0 && i < ETH_ALEN; i++) { + len = snprintf(buf, buf_len, "%02x", addr->addr[i]); + if (len < 0 || (size_t)len >= buf_len) + break; + + buf += len; + buf_len -= len; + + if (i < ETH_ALEN - 1) { + *buf++ = ':'; + buf_len -= 1; + } + } + + *buf = '\0'; +} + +bool macaddr_is_null(const struct mac_addr *addr) { + static struct mac_addr nulladdr = {}; + + return memcmp(addr, &nulladdr, sizeof(nulladdr)) == 0; +} + +static const struct flag_val *find_flag(const struct flag_val *flag_vals, + const char *chr) +{ + while (flag_vals->flagstring) { + if (strcmp(chr, flag_vals->flagstring) == 0) + return flag_vals; + flag_vals++; + } + return NULL; +} + +static int handle_flags(char *optarg, void *tgt, struct prog_option *opt) +{ + const struct flag_val *flag, *flag_vals = opt->typearg; + unsigned int *opt_set = tgt; + unsigned int flagval = 0; + char *c = NULL; + + while (*optarg) { + c = strchr(optarg, ','); + if (c) + *c = '\0'; + flag = find_flag(flag_vals, optarg); + if (!flag) + return -EINVAL; + flagval |= flag->flagval; + + if (!c) + break; + optarg = c + 1; + } + *opt_set = flagval; + return 0; +} + +static int get_ifindex(const char *ifname) +{ + int ifindex; + + ifindex = if_nametoindex(ifname); + if (!ifindex) { + pr_warn("Couldn't find network interface '%s'.\n", ifname); + return -ENOENT; + } + return ifindex; +} + +static int handle_ifname(char *optarg, void *tgt, __unused struct prog_option *opt) +{ + struct iface *iface = tgt; + int ifindex; + + ifindex = get_ifindex(optarg); + if (ifindex < 0) + return ifindex; + + iface->ifname = optarg; + iface->ifindex = ifindex; + return 0; +} + +static int handle_ifname_multi(char *optarg, void *tgt, __unused struct prog_option *opt) +{ + struct iface **ifaces = tgt; + struct iface *iface, *tmp; + int ifindex; + + ifindex = get_ifindex(optarg); + if (ifindex < 0) + return ifindex; + + iface = calloc(sizeof(*iface), 1); + if (!iface) + return -ENOMEM; + + iface->ifname = optarg; + iface->ifindex = ifindex; + + if (!*ifaces) { + *ifaces = iface; + return 0; + } + + tmp = *ifaces; + while(tmp->next) + tmp = tmp->next; + + tmp->next = iface; + return 0; +} + +void print_addr(char *buf, size_t buf_len, const struct ip_addr *addr) +{ + inet_ntop(addr->af, &addr->addr, buf, buf_len); +} + +bool ipaddr_is_null(const struct ip_addr *addr) { + static struct ip_addr nulladdr = {}; + + return memcmp(addr, &nulladdr, sizeof(nulladdr)) == 0; +} + +static int handle_ipaddr(char *optarg, void *tgt, __unused struct prog_option *opt) +{ + struct ip_addr *addr = tgt; + int af; + + af = strchr(optarg, ':') ? AF_INET6 : AF_INET; + + if (inet_pton(af, optarg, &addr->addr) != 1) { + pr_warn("Invalid IP address: %s\n", optarg); + return -ENOENT; /* caller won't print error on ENOENT */ + } + + addr->af = af; + return 0; +} + +static const struct enum_val *find_enum(const struct enum_val *enum_vals, + const char *chr) +{ + while (enum_vals->name) { + if (strcmp(chr, enum_vals->name) == 0) + return enum_vals; + enum_vals++; + } + return NULL; +} + +static int handle_enum(char *optarg, void *tgt, struct prog_option *opt) +{ + const struct enum_val *val, *all_vals = opt->typearg; + unsigned int *opt_set = tgt; + + val = find_enum(all_vals, optarg); + if (!val) + return -EINVAL; + *opt_set = val->value; + return 0; +} + +static void print_enum_vals(char *buf, size_t buf_len, + const struct enum_val *vals) +{ + const struct enum_val *val; + bool first = true; + + for (val = vals; buf_len && val->name; val++) { + int len; + + if (!first) { + *buf++ = ','; + buf_len--; + } + first = false; + + len = snprintf(buf, buf_len, "%s", val->name); + if (len < 0 || (size_t)len >= buf_len) + break; + buf += len; + buf_len -= len; + } + *buf = '\0'; +} + +const char *get_enum_name(const struct enum_val *vals, unsigned int value) +{ + const struct enum_val *val; + + for (val = vals; val->name; val++) + if (val->value == value) + return val->name; + return NULL; +} + +static const struct opthandler { + int (*func)(char *optarg, void *tgt, struct prog_option *opt); +} handlers[__OPT_MAX] = { + {NULL}, + {handle_bool}, + {handle_flags}, + {handle_string}, + {handle_u16}, + {handle_u32}, + {handle_u32_multi}, + {handle_macaddr}, + {handle_ifname}, + {handle_ifname_multi}, + {handle_ipaddr}, + {handle_enum}, + {handle_multistring} +}; + +void print_flags(char *buf, size_t buf_len, const struct flag_val *flags, + unsigned long flags_set) +{ + const struct flag_val *flag; + bool first = true; + + for (flag = flags; buf_len && flag->flagstring; flag++) { + int len; + + if (!(flag->flagval & flags_set)) + continue; + + if (!first) { + *buf++ = ','; + buf_len--; + } + first = false; + len = snprintf(buf, buf_len, "%s", flag->flagstring); + if (len < 0 || (size_t)len >= buf_len) + break; + buf += len; + buf_len -= len; + } + *buf = '\0'; +} + +static void print_help_flags(const struct prog_option *opt) +{ + char buf[100] = {}; + + if (!opt->typearg) + pr_warn("Missing typearg for opt %s\n", opt->name); + else + print_flags(buf, sizeof(buf), opt->typearg, -1); + + printf(" %s (valid values: %s)", opt->help, buf); +} + +static void print_help_enum(const struct prog_option *opt) +{ + char buf[100] = {}; + + if (!opt->typearg) + pr_warn("Missing typearg for opt %s\n", opt->name); + else + print_enum_vals(buf, sizeof(buf), opt->typearg); + + printf(" %s (valid values: %s)", opt->help, buf); +} + +static const struct helprinter { + void (*func)(const struct prog_option *opt); +} help_printers[__OPT_MAX] = { + {NULL}, + {NULL}, + {print_help_flags}, + {NULL}, + {NULL}, + {NULL}, + {NULL}, + {NULL}, + {NULL}, + {NULL}, + {NULL}, + {print_help_enum}, + {NULL} +}; + + +static void _print_positional(const struct prog_option *long_options) +{ + const struct prog_option *opt; + + FOR_EACH_OPTION (long_options, opt) { + if (!opt->positional) + continue; + + printf(" %s", opt->metavar ?: opt->name); + } +} + +static void _print_options(const struct prog_option *poptions, bool required) +{ + const struct prog_option *opt; + + FOR_EACH_OPTION (poptions, opt) { + if (opt->required != required) + continue; + + if (opt->positional) { + printf(" %-30s", opt->metavar ?: opt->name); + } else { + char buf[BUFSIZE]; + int pos; + + if (opt->short_opt >= FIRST_PRINTABLE) + printf(" -%c,", opt->short_opt); + else + printf(" "); + pos = snprintf(buf, BUFSIZE, " --%s", opt->name); + if (pos < 0 || pos >= BUFSIZE) { + pr_warn("opt name too long: %s\n", opt->name); + continue; + } + if (opt->metavar) + snprintf(&buf[pos], BUFSIZE - pos, " %s", + opt->metavar); + printf("%-28s", buf); + } + + if (help_printers[opt->type].func != NULL) + help_printers[opt->type].func(opt); + else if (opt->help) + printf(" %s", opt->help); + printf("\n"); + } +} + +bool is_prefix(const char *pfx, const char *str) +{ + if (!pfx) + return false; + if (strlen(str) < strlen(pfx)) + return false; + + return !memcmp(str, pfx, strlen(pfx)); +} + +void usage(const char *prog_name, const char *doc, + const struct prog_option *poptions, bool full) +{ + const struct prog_option *opt; + int num_req = 0; + + printf("\nUsage: %s [options]", prog_name); + _print_positional(poptions); + printf("\n"); + + if (!full) { + printf("Use --help (or -h) to see full option list.\n"); + return; + } + + FOR_EACH_OPTION (poptions, opt) + if (opt->required) + num_req++; + + printf("\n %s\n\n", doc); + if (num_req) { + printf("Required parameters:\n"); + _print_options(poptions, true); + printf("\n"); + } + printf("Options:\n"); + _print_options(poptions, false); + printf(" -v, --verbose Enable verbose logging (-vv: more verbose)\n"); + printf(" --version Display version information\n"); + printf(" -h, --help Show this help\n"); + printf("\n"); +} + +static int prog_options_to_options(struct prog_option *poptions, + struct option **options, char **optstring) +{ + int num = 0, num_cmn = 0, n_sopt = VERSION_SHORT_OPT + 1; + struct option *new_options, *nopt; + struct prog_option *opt; + char buf[100], *c = buf; + + struct option common_opts[] = { + {"help", no_argument, NULL, 'h'}, + {"verbose", no_argument, NULL, 'v'}, + {"version", no_argument, NULL, VERSION_SHORT_OPT}, + {} + }; + + for (nopt = common_opts; nopt->name; nopt++) { + num++; + num_cmn++; + if (nopt->val != VERSION_SHORT_OPT) + *c++ = nopt->val; + } + + FOR_EACH_OPTION (poptions, opt) + if (!opt->positional) + num++; + + new_options = calloc(num + 1, sizeof(struct option)); + if (!new_options) + return -ENOMEM; + + memcpy(new_options, &common_opts, sizeof(struct option) * num_cmn); + nopt = new_options + num_cmn; + + FOR_EACH_OPTION (poptions, opt) { + if (opt->positional) + continue; + if (opt->short_opt) { + *(c++) = opt->short_opt; + if (opt_needs_arg(opt)) + *(c++) = ':'; + } else { + /* getopt expects options to have unique values in the + * 'val' field, however we want to be able to define + * options that don't have a short opt. So get around + * that, just number such options sequentially. + */ + if (n_sopt >= FIRST_PRINTABLE) { + pr_warn("Too many options with no short opt\n"); + goto err; + } + opt->short_opt = n_sopt++; + } + nopt->has_arg = opt_needs_arg(opt) ? required_argument : no_argument; + nopt->name = opt->name; + nopt->val = opt->short_opt; + nopt->flag = NULL; + nopt++; + } + *(c++) = '\0'; + + *optstring = strdup(buf); + if (!*optstring) + goto err; + + /* Make sure we clear the last option, or else we crash. */ + memset(new_options + num, 0, sizeof(struct option)); + + *options = new_options; + return 0; + +err: + free(new_options); + return -EINVAL; +} + +static struct prog_option *find_opt(struct prog_option *all_opts, int optchar) +{ + struct prog_option *opt; + + FOR_EACH_OPTION (all_opts, opt) + if (opt->short_opt == optchar) + return opt; + return NULL; +} + +static int _set_opt(void *cfg, struct prog_option *opt, char *optarg) +{ + int ret; + + if (opt->max_num && opt->num_set + 1 > opt->max_num) { + pr_warn("Too many parameters for %s (max %u)\n", + opt->metavar ?: opt->name, opt->max_num); + return -E2BIG; + } + + ret = handlers[opt->type].func(optarg, (cfg + opt->cfg_offset), opt); + if (!ret) + opt->num_set++; + else if (ret != -ENOENT) + pr_warn("Couldn't parse option %s: %s.\n", opt->name, strerror(-ret)); + return ret; +} + +static int set_opt(void *cfg, struct prog_option *all_opts, int optchar, + char *optarg) +{ + struct prog_option *opt; + + if (!cfg) + return -EFAULT; + + opt = find_opt(all_opts, optchar); + if (!opt) + return -ENOENT; + + return _set_opt(cfg, opt, optarg); +} + +static int set_pos_opt(void *cfg, struct prog_option *all_opts, char *optarg) +{ + struct prog_option *o, *opt = NULL; + + FOR_EACH_OPTION (all_opts, o) { + if (o->positional && (!o->num_set || opt_is_multi(o))) { + opt = o; + break; + } + } + + if (!opt) + return -ENOENT; + + return _set_opt(cfg, opt, optarg); +} + +int parse_cmdline_args(int argc, char **argv, struct prog_option *poptions, + void *cfg, const char *prog, const char *usage_cmd, + const char *doc, const void *defaults) +{ + struct prog_option *opt_iter; + struct option *long_options; + bool full_help = false; + int i, opt, err = 0; + int longindex = 0; + char *optstring; + + if (prog_options_to_options(poptions, &long_options, &optstring)) { + pr_warn("Unable to malloc()\n"); + return -ENOMEM; + } + + /* Parse commands line args */ + while ((opt = getopt_long(argc, argv, optstring, + long_options, &longindex)) != -1) { + switch (opt) { + case 'h': + usage(usage_cmd, doc, poptions, true); + err = EXIT_FAILURE; + goto out; + case 'v': + increase_log_level(); + break; + case VERSION_SHORT_OPT: + printf("%s version %s using libbpf version %s\n", + prog, + TOOLS_VERSION, + get_libbpf_version()); + err = EXIT_FAILURE; + goto out; + default: + if (set_opt(cfg, poptions, opt, optarg)) { + usage(prog, doc, poptions, full_help); + err = EXIT_FAILURE; + goto out; + } + break; + } + } + + for (i = optind; i < argc; i++) { + if (set_pos_opt(cfg, poptions, argv[i])) { + usage(usage_cmd, doc, poptions, full_help); + err = EXIT_FAILURE; + goto out; + } + } + + FOR_EACH_OPTION (poptions, opt_iter) { + if (opt_iter->num_set && (!opt_iter->min_num || + opt_iter->num_set >= opt_iter->min_num)) + continue; + + if (opt_iter->required) { + if (opt_iter->positional) + pr_warn("Missing required parameter %s\n", + opt_iter->metavar ?: opt_iter->name); + else + pr_warn("Missing required option '--%s'\n", + opt_iter->name); + usage(prog, doc, poptions, full_help); + err = EXIT_FAILURE; + goto out; + } else if (defaults) { + void *dst = cfg + opt_iter->cfg_offset; + const void *src = defaults + opt_iter->cfg_offset; + + memcpy(dst, src, opt_iter->opt_size); + } + } +out: + free(long_options); + free(optstring); + + return err; +} + +int dispatch_commands(const char *argv0, int argc, char **argv, + const struct prog_command *cmds, size_t cfg_size, + const char *prog_name, bool needs_bpffs) +{ + const struct prog_command *c, *cmd = NULL; + int ret = EXIT_FAILURE, err, len; + char pin_root_path[PATH_MAX]; + char usagebuf[100]; + void *cfg; + + for (c = cmds; c->name; c++) { + if (is_prefix(argv0, c->name)) { + cmd = c; + break; + } + } + + if (!cmd) { + pr_warn("Command '%s' is unknown, try '%s help'.\n", + argv0, prog_name); + return EXIT_FAILURE; + } + + if (cmd->no_cfg) + return cmd->func(NULL, NULL); + + cfg = calloc(1, cfg_size); + if (!cfg) { + pr_warn("Couldn't allocate memory\n"); + return EXIT_FAILURE; + } + + len = snprintf(usagebuf, sizeof(usagebuf), "%s %s", prog_name, cmd->name); + if (len < 0 || (size_t)len >= sizeof(usagebuf)) + goto out; + + err = parse_cmdline_args(argc, argv, cmd->options, cfg, prog_name, usagebuf, + cmd->doc, cmd->default_cfg); + if (err) + goto out; + + err = get_bpf_root_dir(pin_root_path, sizeof(pin_root_path), prog_name, + needs_bpffs); + if (err && needs_bpffs) + goto out; + + err = check_bpf_environ(); + if (err) + goto out; + + if (prog_lock_get(prog_name)) + goto out; + + ret = cmd->func(cfg, pin_root_path); + prog_lock_release(0); +out: + free(cfg); + return ret; +} diff --git a/lib/util/params.h b/lib/util/params.h new file mode 100644 index 0000000..fa77964 --- /dev/null +++ b/lib/util/params.h @@ -0,0 +1,149 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +#ifndef __PARAMS_H +#define __PARAMS_H + +#include <getopt.h> +#include <stdbool.h> +#include <stdlib.h> +#include <linux/in.h> +#include <linux/in6.h> +#include <linux/if_ether.h> +#include <bpf/libbpf.h> + +enum option_type { + OPT_NONE, + OPT_BOOL, + OPT_FLAGS, + OPT_STRING, + OPT_U16, + OPT_U32, + OPT_U32_MULTI, + OPT_MACADDR, + OPT_IFNAME, + OPT_IFNAME_MULTI, + OPT_IPADDR, + OPT_ENUM, + OPT_MULTISTRING, + __OPT_MAX +}; + +struct prog_option { + enum option_type type; + size_t cfg_size; + size_t cfg_offset; + size_t opt_size; + char *name; + char short_opt; + char *help; + char *metavar; + void *typearg; + bool required; + bool positional; + unsigned int min_num; + unsigned int max_num; + unsigned int num_set; +}; + +struct flag_val { + const char *flagstring; + unsigned int flagval; +}; + +struct enum_val { + const char *name; + unsigned int value; +}; + +struct multistring { + const char **strings; + size_t num_strings; +}; + +struct u32_multi { + __u32 *vals; + size_t num_vals; +}; + +struct iface { + struct iface *next; + char *ifname; + int ifindex; +}; + +struct ip_addr { + int af; + union { + struct in_addr addr4; + struct in6_addr addr6; + } addr; +}; + +struct mac_addr { + unsigned char addr[ETH_ALEN]; +}; + +#define sizeof_field(TYPE, MEMBER) sizeof((((TYPE *)0)->MEMBER)) + +#define DEFINE_OPTION(_name, _type, _cfgtype, _cfgmember, ...) \ + { \ + .cfg_size = sizeof(_cfgtype), \ + .opt_size = sizeof_field(_cfgtype, _cfgmember), \ + .cfg_offset = offsetof(_cfgtype, _cfgmember), .name = _name, \ + .type = _type, __VA_ARGS__ \ + } + +#define END_OPTIONS \ + { \ + } + +#define FOR_EACH_OPTION(_options, _opt) \ + for (_opt = _options; _opt->type != OPT_NONE; _opt++) + +struct prog_command { + const char *name; + int (*func)(const void *cfg, const char *pin_root_path); + struct prog_option *options; + const void *default_cfg; + char *doc; + bool no_cfg; +}; + +#define DEFINE_COMMAND_NAME(_name, _func, _doc) \ + { \ + .name = _name, .func = do_##_func, \ + .options = _func##_options, .default_cfg = &defaults_##_func, \ + .doc = _doc \ + } +#define DEFINE_COMMAND(_name, _doc) DEFINE_COMMAND_NAME(textify(_name), _name, _doc) + +#define DEFINE_COMMAND_NODEF(_name, _doc) \ + { \ + .name = textify(_name), .func = do_##_name, \ + .options = _name##_options, .doc = _doc \ + } + +#define END_COMMANDS \ + { \ + } + +const char *get_enum_name(const struct enum_val *vals, unsigned int value); +void print_flags(char *buf, size_t buf_len, const struct flag_val *flags, + unsigned long flags_val); +void print_addr(char *buf, size_t buf_len, const struct ip_addr *addr); +void print_macaddr(char *buf, size_t buf_len, const struct mac_addr *addr); +bool macaddr_is_null(const struct mac_addr *addr); +bool ipaddr_is_null(const struct ip_addr *addr); +bool is_prefix(const char *prefix, const char *string); +void usage(const char *prog_name, const char *doc, + const struct prog_option *long_options, bool full); + +int parse_cmdline_args(int argc, char **argv, struct prog_option *long_options, + void *cfg, const char *prog, const char *usage_cmd, + const char *doc, const void *defaults); + +int dispatch_commands(const char *argv0, int argc, char **argv, + const struct prog_command *cmds, size_t cfg_size, + const char *prog_name, bool needs_bpffs); + +#endif /* __COMMON_PARAMS_H */ diff --git a/lib/util/stats.c b/lib/util/stats.c new file mode 100644 index 0000000..f04c968 --- /dev/null +++ b/lib/util/stats.c @@ -0,0 +1,292 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <errno.h> +#include <getopt.h> + +#include <locale.h> +#include <unistd.h> +#include <time.h> + +#include <bpf/bpf.h> +#include <bpf/libbpf.h> + +#include "stats.h" +#include "util.h" +#include "logging.h" + +#define NANOSEC_PER_SEC 1000000000 /* 10^9 */ +static int gettime(__u64 *nstime) +{ + struct timespec t; + int res; + + res = clock_gettime(CLOCK_MONOTONIC, &t); + if (res < 0) { + pr_warn("Error with gettimeofday! (%i)\n", res); + return res; + } + + *nstime = (__u64)t.tv_sec * NANOSEC_PER_SEC + t.tv_nsec; + return 0; +} + +static double calc_period(struct record *r, struct record *p) +{ + double period_ = 0; + __u64 period = 0; + + period = r->timestamp - p->timestamp; + if (period > 0) + period_ = ((double)period / NANOSEC_PER_SEC); + + return period_; +} + +int stats_print_one(struct stats_record *stats_rec) +{ + __u64 packets, bytes; + struct record *rec; + int i, err; + + /* Print for each XDP actions stats */ + for (i = 0; i < XDP_ACTION_MAX; i++) { + char *fmt = " %-35s %'11lld pkts %'11lld KiB\n"; + const char *action = action2str(i); + + rec = &stats_rec->stats[i]; + packets = rec->total.rx_packets; + bytes = rec->total.rx_bytes; + + if (rec->enabled) { + err = printf(fmt, action, packets, bytes / 1024); + if (err < 0) + return err; + } + } + + return 0; +} + +int stats_print(struct stats_record *stats_rec, struct stats_record *stats_prev) +{ + struct record *rec, *prev; + __u64 packets, bytes; + struct timespec t; + bool first = true; + double period; + double pps; /* packets per sec */ + double bps; /* bits per sec */ + int i, err; + + err = clock_gettime(CLOCK_REALTIME, &t); + if (err < 0) { + pr_warn("Error with gettimeofday! (%i)\n", err); + return err; + } + + /* Print for each XDP actions stats */ + for (i = 0; i < XDP_ACTION_MAX; i++) { + char *fmt = "%-12s %'11lld pkts (%'10.0f pps)" + " %'11lld KiB (%'6.0f Mbits/s)\n"; + const char *action = action2str(i); + + rec = &stats_rec->stats[i]; + prev = &stats_prev->stats[i]; + + if (!rec->enabled) + continue; + + packets = rec->total.rx_packets - prev->total.rx_packets; + bytes = rec->total.rx_bytes - prev->total.rx_bytes; + + period = calc_period(rec, prev); + if (period == 0) + return 0; + + if (first) { + printf("Period of %fs ending at %ld.%06ld\n", period, + (long) t.tv_sec, (long) t.tv_nsec / 1000); + first = false; + } + + pps = packets / period; + + bps = (bytes * 8) / period / 1000000; + + printf(fmt, action, rec->total.rx_packets, pps, + rec->total.rx_bytes / 1024, bps, period); + } + printf("\n"); + + return 0; +} + +/* BPF_MAP_TYPE_ARRAY */ +static int map_get_value_array(int fd, __u32 key, struct xdp_stats_record *value) +{ + int err = 0; + + err = bpf_map_lookup_elem(fd, &key, value); + if (err) + pr_debug("bpf_map_lookup_elem failed key:0x%X\n", key); + + return err; +} + +/* BPF_MAP_TYPE_PERCPU_ARRAY */ +static int map_get_value_percpu_array(int fd, __u32 key, struct xdp_stats_record *value) +{ + /* For percpu maps, userspace gets a value per possible CPU */ + int nr_cpus = libbpf_num_possible_cpus(); + struct xdp_stats_record *values; + __u64 sum_bytes = 0; + __u64 sum_pkts = 0; + int i, err; + + if (nr_cpus < 0) + return nr_cpus; + + values = calloc(nr_cpus, sizeof(*values)); + if (!values) + return -ENOMEM; + + err = bpf_map_lookup_elem(fd, &key, values); + if (err) { + pr_debug("bpf_map_lookup_elem failed key:0x%X\n", key); + goto out; + } + + /* Sum values from each CPU */ + for (i = 0; i < nr_cpus; i++) { + sum_pkts += values[i].rx_packets; + sum_bytes += values[i].rx_bytes; + } + value->rx_packets = sum_pkts; + value->rx_bytes = sum_bytes; +out: + free(values); + return err; +} + +static int map_collect(int fd, __u32 map_type, __u32 key, struct record *rec) +{ + struct xdp_stats_record value = {}; + int err; + + /* Get time as close as possible to reading map contents */ + err = gettime(&rec->timestamp); + if (err) + return err; + + switch (map_type) { + case BPF_MAP_TYPE_ARRAY: + err = map_get_value_array(fd, key, &value); + break; + case BPF_MAP_TYPE_PERCPU_ARRAY: + err = map_get_value_percpu_array(fd, key, &value); + break; + default: + pr_warn("Unknown map_type: %u cannot handle\n", map_type); + err = -EINVAL; + break; + } + + if (err) + return err; + + rec->total.rx_packets = value.rx_packets; + rec->total.rx_bytes = value.rx_bytes; + return 0; +} + +int stats_collect(int map_fd, __u32 map_type, struct stats_record *stats_rec) +{ + /* Collect all XDP actions stats */ + __u32 key; + int err; + + for (key = 0; key < XDP_ACTION_MAX; key++) { + if (!stats_rec->stats[key].enabled) + continue; + + err = map_collect(map_fd, map_type, key, + &stats_rec->stats[key]); + if (err) + return err; + } + + return 0; +} + +static int check_map_pin(__u32 map_id, const char *pin_dir, const char *map_name) +{ + struct bpf_map_info info = {}; + int fd, ret = 0; + + fd = get_pinned_map_fd(pin_dir, map_name, &info); + if (fd < 0) { + if (fd == -ENOENT) + pr_warn("Stats map disappeared while polling\n"); + else + pr_warn("Unable to re-open stats map\n"); + return fd; + } + + if (info.id != map_id) { + pr_warn("Stats map ID changed while polling\n"); + ret = -EINVAL; + } + close(fd); + + return ret; +} + +int stats_poll(int map_fd, int interval, bool *exit, + const char *pin_dir, const char *map_name) +{ + struct bpf_map_info info = {}; + struct stats_record prev, record = { 0 }; + __u32 info_len = sizeof(info); + __u32 map_type, map_id; + int err; + + record.stats[XDP_DROP].enabled = true; + record.stats[XDP_PASS].enabled = true; + record.stats[XDP_REDIRECT].enabled = true; + record.stats[XDP_TX].enabled = true; + + if (!interval) + return -EINVAL; + + err = bpf_obj_get_info_by_fd(map_fd, &info, &info_len); + if (err) + return -errno; + map_type = info.type; + map_id = info.id; + + /* Get initial reading quickly */ + stats_collect(map_fd, map_type, &record); + + usleep(1000000 / 4); + + while (!*exit) { + if (pin_dir) { + err = check_map_pin(map_id, pin_dir, map_name); + if (err) + return err; + } + + memset(&info, 0, sizeof(info)); + prev = record; /* struct copy */ + stats_collect(map_fd, map_type, &record); + err = stats_print(&record, &prev); + if (err) + return err; + usleep(interval * 1000); + } + + return 0; +} diff --git a/lib/util/stats.h b/lib/util/stats.h new file mode 100644 index 0000000..9ee0cad --- /dev/null +++ b/lib/util/stats.h @@ -0,0 +1,26 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +#ifndef __STATS_H +#define __STATS_H + +#include <bpf/libbpf.h> + +#include "xdp/xdp_stats_kern_user.h" + +struct record { + __u64 timestamp; + bool enabled; + struct xdp_stats_record total; /* defined in common_kern_user.h */ +}; + +struct stats_record { + struct record stats[XDP_ACTION_MAX]; +}; + +int stats_print_one(struct stats_record *stats_rec); +int stats_print(struct stats_record *stats_rec, + struct stats_record *stats_prev); +int stats_collect(int map_fd, __u32 map_type, struct stats_record *stats_rec); +int stats_poll(int map_fd, int interval, bool *exit, const char *pin_dir, const char *map_name); + +#endif diff --git a/lib/util/util.c b/lib/util/util.c new file mode 100644 index 0000000..70c5d18 --- /dev/null +++ b/lib/util/util.c @@ -0,0 +1,946 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +#include <errno.h> +#include <unistd.h> +#include <stdlib.h> +#include <string.h> +#include <fcntl.h> +#include <signal.h> +#include <sys/types.h> +#include <sys/resource.h> +#include <sys/vfs.h> +#include <sys/stat.h> +#include <linux/if_link.h> /* Need XDP flags */ +#include <linux/magic.h> /* BPF FS magic */ +#include <linux/err.h> /* ERR_PTR */ +#include <bpf/bpf.h> +#include <dirent.h> +#include <net/if.h> + +#include "util.h" +#include "logging.h" + +static struct enum_val xdp_modes[] = { + {"native", XDP_MODE_NATIVE}, + {"skb", XDP_MODE_SKB}, + {"hw", XDP_MODE_HW}, + {"unspecified", XDP_MODE_UNSPEC}, + {NULL, 0} +}; + +int try_snprintf(char *buf, size_t buf_len, const char *format, ...) +{ + va_list args; + int len; + + va_start(args, format); + len = vsnprintf(buf, buf_len, format, args); + va_end(args); + + if (len < 0) + return -EINVAL; + else if ((size_t)len >= buf_len) + return -ENAMETOOLONG; + + return 0; +} + +static int set_rlimit(unsigned int min_limit) +{ + struct rlimit limit; + int err = 0; + + err = getrlimit(RLIMIT_MEMLOCK, &limit); + if (err) { + err = -errno; + pr_warn("Couldn't get current rlimit\n"); + return err; + } + + if (limit.rlim_cur == RLIM_INFINITY || limit.rlim_cur == 0) { + pr_debug("Current rlimit is infinity or 0. Not raising\n"); + return -ENOMEM; + } + + if (min_limit) { + if (limit.rlim_cur >= min_limit) { + pr_debug("Current rlimit %ju already >= minimum %u\n", + (uintmax_t)limit.rlim_cur, min_limit); + return 0; + } + pr_debug("Setting rlimit to minimum %u\n", min_limit); + limit.rlim_cur = min_limit; + } else { + pr_debug("Doubling current rlimit of %ju\n", (uintmax_t)limit.rlim_cur); + limit.rlim_cur <<= 1; + } + limit.rlim_max = max(limit.rlim_cur, limit.rlim_max); + + err = setrlimit(RLIMIT_MEMLOCK, &limit); + if (err) { + err = -errno; + pr_warn("Couldn't raise rlimit: %s\n", strerror(-err)); + return err; + } + + return 0; +} + +int double_rlimit(void) +{ + pr_debug("Permission denied when loading eBPF object; " + "raising rlimit and retrying\n"); + + return set_rlimit(0); +} + +static const char *_libbpf_compile_version = LIBBPF_VERSION; +static char _libbpf_version[10] = {}; + +const char *get_libbpf_version(void) +{ + /* Start by copying compile-time version into buffer so we have a + * fallback value in case we are dynamically linked, or can't find a + * version in /proc/self/maps below. + */ + strncpy(_libbpf_version, _libbpf_compile_version, + sizeof(_libbpf_version)-1); + +#ifdef LIBBPF_DYNAMIC + char path[PATH_MAX], buf[PATH_MAX], *s; + bool found = false; + FILE *fp; + + /* When dynamically linking against libbpf, we can't be sure that the + * version we discovered at compile time is actually the one we are + * using at runtime. This can lead to hard-to-debug errors, so we try to + * discover the correct version at runtime. + * + * The simple solution to this would be if libbpf itself exported a + * version in its API. But since it doesn't, we work around this by + * parsing the mappings of the binary at runtime, looking for the full + * filename of libbpf.so and using that. + */ + fp = fopen("/proc/self/maps", "r"); + if (fp == NULL) + goto out; + + while ((s = fgets(buf, sizeof(buf), fp)) != NULL) { + /* We are looking for a line like: + * 7f63c2105000-7f63c2106000 rw-p 00032000 fe:02 4200947 /usr/lib/libbpf.so.0.1.0 + */ + if (sscanf(s, "%*x-%*x %*4c %*x %*5c %*d %s\n", path) == 1 && + (s = strstr(path, "libbpf.so.")) != NULL) { + strncpy(_libbpf_version, s+10, sizeof(_libbpf_version)-1); + found = true; + break; + } + } + + fclose(fp); +out: + if (!found) + pr_warn("Couldn't find runtime libbpf version - falling back to compile-time value!\n"); + +#endif + _libbpf_version[sizeof(_libbpf_version)-1] = '\0'; + return _libbpf_version; +} + +int find_bpf_file(char *buf, size_t buf_size, const char *progname) +{ + static char *bpf_obj_paths[] = { +#ifdef DEBUG + ".", +#endif + BPF_OBJECT_PATH, + NULL + }; + struct stat sb = {}; + char **path; + int err; + + for (path = bpf_obj_paths; *path; path++) { + err = try_snprintf(buf, buf_size, "%s/%s", *path, progname); + if (err) + return err; + + pr_debug("Looking for '%s'\n", buf); + err = stat(buf, &sb); + if (err) + continue; + + return 0; + } + + pr_warn("Couldn't find a BPF file with name %s\n", progname); + return -ENOENT; +} + +struct bpf_object *open_bpf_file(const char *progname, + struct bpf_object_open_opts *opts) +{ + char buf[PATH_MAX]; + int err; + + err = find_bpf_file(buf, sizeof(buf), progname); + if (err) + return ERR_PTR(err); + + pr_debug("Loading bpf file '%s' from '%s'\n", progname, buf); + return bpf_object__open_file(buf, opts); +} + +static int get_pinned_object_fd(const char *path, void *info, __u32 *info_len) +{ + char errmsg[STRERR_BUFSIZE]; + int pin_fd, err; + + pin_fd = bpf_obj_get(path); + if (pin_fd < 0) { + err = -errno; + libbpf_strerror(-err, errmsg, sizeof(errmsg)); + pr_debug("Couldn't retrieve pinned object '%s': %s\n", path, errmsg); + return err; + } + + if (info) { + err = bpf_obj_get_info_by_fd(pin_fd, info, info_len); + if (err) { + err = -errno; + libbpf_strerror(-err, errmsg, sizeof(errmsg)); + pr_debug("Couldn't retrieve object info: %s\n", errmsg); + return err; + } + } + + return pin_fd; +} + +int make_dir_subdir(const char *parent, const char *dir) +{ + char path[PATH_MAX]; + int err; + + err = try_snprintf(path, sizeof(path), "%s/%s", parent, dir); + if (err) + return err; + + err = mkdir(parent, S_IRWXU); + if (err && errno != EEXIST) { + err = -errno; + return err; + } + + err = mkdir(path, S_IRWXU); + if (err && errno != EEXIST) { + err = -errno; + return err; + } + + return 0; +} + +int attach_xdp_program(struct xdp_program *prog, const struct iface *iface, + enum xdp_attach_mode mode, const char *pin_root_path) +{ + char pin_path[PATH_MAX]; + int err = 0; + + if (!prog || !pin_root_path) + return -EINVAL; + + err = make_dir_subdir(pin_root_path, "programs"); + if (err) { + pr_warn("Unable to create pin directory: %s\n", strerror(-err)); + return err; + } + + err = try_snprintf(pin_path, sizeof(pin_path), "%s/programs/%s/%s", + pin_root_path, iface->ifname, + xdp_program__name(prog)); + if (err) + return err; + + err = xdp_program__attach(prog, iface->ifindex, mode, 0); + if (err) { + if (pin_root_path && err != -EEXIST) + unlink(pin_path); + return err; + } + + pr_debug("Program '%s' loaded on interface '%s'%s\n", + xdp_program__name(prog), iface->ifname, + mode == XDP_MODE_SKB ? " in skb mode" : ""); + + err = xdp_program__pin(prog, pin_path); + if (err) { + pr_warn("Unable to pin XDP program at %s: %s\n", + pin_path, strerror(-err)); + goto unload; + } + pr_debug("XDP program pinned at %s\n", pin_path); + return err; + +unload: + xdp_program__detach(prog, iface->ifindex, mode, 0); + return err; +} + +int detach_xdp_program(struct xdp_program *prog, const struct iface *iface, + enum xdp_attach_mode mode, const char *pin_root_path) +{ + char pin_path[PATH_MAX]; + int err; + + err = xdp_program__detach(prog, iface->ifindex, mode, 0); + if (err) + goto out; + + err = try_snprintf(pin_path, sizeof(pin_path), "%s/programs/%s/%s", + pin_root_path, iface->ifname, + xdp_program__name(prog)); + if (err) + return err; + + err = unlink(pin_path); + if (err && errno != ENOENT) + goto out; + + err = try_snprintf(pin_path, sizeof(pin_path), "%s/programs/%s", + pin_root_path, iface->ifname); + if (err) + goto out; + + err = rmdir(pin_path); + if (err && errno == ENOENT) + err = 0; + else if (err) + err = -errno; +out: + return err; +} + +int get_pinned_program(const struct iface *iface, const char *pin_root_path, + enum xdp_attach_mode *mode, + struct xdp_program **xdp_prog) +{ + int ret = -ENOENT, err, ifindex = iface->ifindex; + char pin_path[PATH_MAX]; + bool remove_all = false; + enum xdp_attach_mode m; + struct dirent *de; + DIR *dr; + + err = try_snprintf(pin_path, sizeof(pin_path), "%s/programs/%s", + pin_root_path, iface->ifname); + if (err) + return err; + + dr = opendir(pin_path); + if (!dr) { + err = -errno; + pr_debug("Couldn't open pin directory %s: %s\n", + pin_path, strerror(-err)); + return err; + } + + if (!ifindex) + ifindex = if_nametoindex(iface->ifname); + if (!ifindex) { + pr_debug("Interface %s no longer exists\n", iface->ifname); + remove_all = true; + ret = -ENODEV; + } + + while ((de = readdir(dr)) != NULL) { + DECLARE_LIBXDP_OPTS(xdp_program_opts, opts, 0); + struct xdp_program *prog; + + if (!strcmp(".", de->d_name) || !strcmp("..", de->d_name)) + continue; + + err = try_snprintf(pin_path, sizeof(pin_path), + "%s/programs/%s/%s", pin_root_path, + iface->ifname, de->d_name); + if (err) + goto out; + + if (remove_all) { + err = unlink(pin_path); + if (err) + ret = err; + continue; + } + + opts.pin_path = pin_path; + prog = xdp_program__create(&opts); + if (libxdp_get_error(prog) || + !(m = xdp_program__is_attached(prog, iface->ifindex))) { + ret = libxdp_get_error(prog) ?: -ENOENT; + pr_debug("Program %s no longer loaded on %s: %s\n", + de->d_name, iface->ifname, strerror(-ret)); + err = unlink(pin_path); + if (err) + ret = err; + if (prog) + xdp_program__close(prog); + } else { + if (strcmp(xdp_program__name(prog), de->d_name)) { + pr_warn("Pinned and kernel prog names differ: %s/%s\n", + xdp_program__name(prog), de->d_name); + ret = -EFAULT; + xdp_program__close(prog); + } else { + ret = 0; + *xdp_prog = prog; + if (mode) + *mode = m; + } + break; + } + } +out: + closedir(dr); + return ret; +} + +int iterate_pinned_programs(const char *pin_root_path, program_callback cb, + void *arg) +{ + char pin_path[PATH_MAX]; + struct dirent *de; + int err = 0; + DIR *dr; + + err = try_snprintf(pin_path, sizeof(pin_path), "%s/programs", + pin_root_path); + if (err) + return err; + + dr = opendir(pin_path); + if (!dr) + return -ENOENT; + + while ((de = readdir(dr)) != NULL) { + enum xdp_attach_mode mode = XDP_MODE_UNSPEC; + struct xdp_program *prog = NULL; + struct iface iface = {}; + + if (!strcmp(".", de->d_name) || !strcmp("..", de->d_name)) + continue; + + iface.ifname = de->d_name; + iface.ifindex = if_nametoindex(iface.ifname); + + err = try_snprintf(pin_path, sizeof(pin_path), "%s/programs/%s", + pin_root_path, iface.ifname); + if (err) + goto out; + + err = get_pinned_program(&iface, pin_root_path, &mode, &prog); + if (err == -ENOENT || err == -ENODEV) { + err = rmdir(pin_path); + if (err) + goto out; + continue; + } else if (err) { + goto out; + } + + err = cb(&iface, prog, mode, arg); + xdp_program__close(prog); + if (err) + goto out; + } + +out: + closedir(dr); + return err; +} + +int iterate_iface_multiprogs(multiprog_callback cb, void *arg) +{ + struct if_nameindex *idx, *indexes = NULL; + int err = 0; + + indexes = if_nameindex(); + if (!indexes) { + err = -errno; + pr_warn("Couldn't get list of interfaces: %s\n", strerror(-err)); + return err; + } + + for (idx = indexes; idx->if_index; idx++) { + struct xdp_multiprog *mp; + struct iface iface = { + .ifindex = idx->if_index, + .ifname = idx->if_name, + }; + + mp = xdp_multiprog__get_from_ifindex(iface.ifindex); + if (IS_ERR_OR_NULL(mp)) { + if (PTR_ERR(mp) != -ENOENT) { + err = PTR_ERR(mp); + pr_warn("Error getting XDP status for interface %s: %s\n", + idx->if_name, strerror(-err)); + goto out; + } + mp = NULL; + } + + err = cb(&iface, mp, arg); + xdp_multiprog__close(mp); + if (err) + goto out; + } + +out: + if_freenameindex(indexes); + return err; +} + +static bool bpf_is_valid_mntpt(const char *mnt, unsigned long magic) +{ + struct statfs st_fs; + + if (statfs(mnt, &st_fs) < 0) + return false; + if ((unsigned long)st_fs.f_type != magic) + return false; + + return true; +} + +static const char *bpf_find_mntpt_single(unsigned long magic, char *mnt, + int len, const char *mntpt) +{ + if (bpf_is_valid_mntpt(mntpt, magic)) { + strncpy(mnt, mntpt, len - 1); + mnt[len - 1] = '\0'; + return mnt; + } + + return NULL; +} + +static const char *bpf_find_mntpt(const char *fstype, unsigned long magic, + char *mnt, int len, + const char * const *known_mnts) +{ + const char * const *ptr; + char type[100]; + FILE *fp; + + if (known_mnts) { + ptr = known_mnts; + while (*ptr) { + if (bpf_find_mntpt_single(magic, mnt, len, *ptr)) + return mnt; + ptr++; + } + } + + if (len != PATH_MAX) + return NULL; + + fp = fopen("/proc/mounts", "r"); + if (fp == NULL) + return NULL; + + while (fscanf(fp, "%*s %" textify(PATH_MAX) "s %99s %*s %*d %*d\n", mnt, + type) == 2) { + if (strcmp(type, fstype) == 0) + break; + } + + fclose(fp); + if (strcmp(type, fstype) != 0) + return NULL; + + return mnt; +} + +static int bpf_mnt_check_target(const char *target) +{ + int ret; + + ret = mkdir(target, S_IRWXU); + if (ret && errno != EEXIST) { + ret = -errno; + pr_warn("mkdir %s failed: %s\n", target, strerror(-ret)); + return ret; + } + + return 0; +} +/* simplified version of code from iproute2 */ +static const char *bpf_get_work_dir() +{ + static char bpf_tmp[PATH_MAX] = BPF_DIR_MNT; + static char bpf_wrk_dir[PATH_MAX]; + static const char *mnt; + static bool bpf_mnt_cached; + static const char *const bpf_known_mnts[] = { + BPF_DIR_MNT, + "/bpf", + 0, + }; + int ret; + + if (bpf_mnt_cached) + return mnt; + + mnt = bpf_find_mntpt("bpf", BPF_FS_MAGIC, bpf_tmp, sizeof(bpf_tmp), + bpf_known_mnts); + if (!mnt) { + mnt = BPF_DIR_MNT; + ret = bpf_mnt_check_target(mnt); + if (ret || !bpf_is_valid_mntpt(mnt, BPF_FS_MAGIC)) { + mnt = NULL; + goto out; + } + } + + strncpy(bpf_wrk_dir, mnt, sizeof(bpf_wrk_dir)); + bpf_wrk_dir[sizeof(bpf_wrk_dir) - 1] = '\0'; + mnt = bpf_wrk_dir; +out: + bpf_mnt_cached = true; + return mnt; +} + +int get_bpf_root_dir(char *buf, size_t buf_len, const char *subdir, bool fatal) +{ + const char *bpf_dir; + + bpf_dir = bpf_get_work_dir(); + if (!bpf_dir) { + logging_print(fatal ? LOG_WARN : LOG_DEBUG, + "Could not find BPF working dir - bpffs not mounted?\n"); + return -ENOENT; + } + + if (subdir) + return try_snprintf(buf, buf_len, "%s/%s", bpf_dir, subdir); + else + return try_snprintf(buf, buf_len, "%s", bpf_dir); +} + +int get_pinned_map_fd(const char *bpf_root, const char *map_name, + struct bpf_map_info *info) +{ + __u32 info_len = sizeof(*info); + char buf[PATH_MAX]; + int err; + + err = try_snprintf(buf, sizeof(buf), "%s/%s", bpf_root, map_name); + if (err) + return err; + + pr_debug("Getting pinned object from %s\n", buf); + return get_pinned_object_fd(buf, info, &info_len); +} + +int unlink_pinned_map(int dir_fd, const char *map_name) +{ + struct stat statbuf = {}; + int err; + + err = fstatat(dir_fd, map_name, &statbuf, 0); + if (err && errno == ENOENT) { + pr_debug("Map name %s not pinned\n", map_name); + return 0; + } else if (err) { + err = -errno; + pr_warn("Couldn't stat pinned map %s: %s\n", + map_name, strerror(-err)); + return err; + } + + pr_debug("Unlinking pinned map %s\n", map_name); + err = unlinkat(dir_fd, map_name, 0); + if (err) { + err = -errno; + pr_warn("Couldn't unlink pinned map %s: %s\n", + map_name, strerror(-err)); + return -errno; + } + + return 0; +} + +#define XDP_UNKNOWN (XDP_REDIRECT + 1) +#ifndef XDP_ACTION_MAX +#define XDP_ACTION_MAX (XDP_UNKNOWN + 1) +#endif + +static const char *xdp_action_names[XDP_ACTION_MAX] = { + [XDP_ABORTED] = "XDP_ABORTED", + [XDP_DROP] = "XDP_DROP", + [XDP_PASS] = "XDP_PASS", + [XDP_TX] = "XDP_TX", + [XDP_REDIRECT] = "XDP_REDIRECT", + [XDP_UNKNOWN] = "XDP_UNKNOWN", +}; + +const char *action2str(__u32 action) +{ + if (action < XDP_ACTION_MAX) + return xdp_action_names[action]; + return NULL; +} + +int check_bpf_environ(void) +{ + init_lib_logging(); + + if (geteuid() != 0) { + pr_warn("This program must be run as root.\n"); + return 1; + } + + /* Try to avoid probing errors due to rlimit exhaustion by starting out + * with an rlimit of 1 MiB. This is not going to solve all issues, but + * it will at least make things work when there is nothing else loaded. + * + * Ignore return code because an error shouldn't abort running. + */ + set_rlimit(1024 * 1024); + + return 0; +} + +static const char *lock_dir = RUNDIR; +static char *prog_lock_file = NULL; +static int prog_lock_fd = -1; +static pid_t prog_pid = 0; + +void prog_lock_release(int signal) +{ + struct sigaction sigact = { .sa_flags = SA_RESETHAND }; + int err; + + if (prog_lock_fd < 0 || !prog_lock_file) + return; + + sigaction(SIGHUP, &sigact, NULL); + sigaction(SIGINT, &sigact, NULL); + sigaction(SIGSEGV, &sigact, NULL); + sigaction(SIGFPE, &sigact, NULL); + sigaction(SIGTERM, &sigact, NULL); + + err = unlink(prog_lock_file); + if (err) { + err = -errno; + pr_warn("Unable to unlink lock file: %s\n", strerror(-err)); + goto out; + } + + close(prog_lock_fd); + free(prog_lock_file); + prog_lock_fd = -1; + prog_lock_file = NULL; + +out: + if (signal) { + pr_debug("Exiting on signal %d\n", signal); + if (prog_pid) + kill(prog_pid, signal); + else + exit(signal); + } +} + +int prog_lock_get(const char *progname) +{ + char buf[PATH_MAX]; + int err; + struct sigaction sigact = { .sa_handler = prog_lock_release }; + + if (prog_lock_fd >= 0) { + pr_warn("Attempt to get prog_lock twice.\n"); + return -EFAULT; + } + + if (!prog_lock_file) { + err = try_snprintf(buf, sizeof(buf), "%s/%s.lck", lock_dir, + progname); + if (err) + return err; + + prog_lock_file = strdup(buf); + if (!prog_lock_file) + return -ENOMEM; + } + + prog_pid = getpid(); + + if (sigaction(SIGHUP, &sigact, NULL) || + sigaction(SIGINT, &sigact, NULL) || + sigaction(SIGSEGV, &sigact, NULL) || + sigaction(SIGFPE, &sigact, NULL) || + sigaction(SIGTERM, &sigact, NULL)) { + err = -errno; + pr_warn("Unable to install signal handler: %s\n", strerror(-err)); + return err; + } + + prog_lock_fd = open(prog_lock_file, O_WRONLY | O_CREAT | O_EXCL, 0644); + if (prog_lock_fd < 0) { + err = -errno; + if (err == -EEXIST) { + pid_t pid = 0; + char buf[100]; + ssize_t len; + int fd; + + fd = open(prog_lock_file, O_RDONLY); + if (fd < 0) { + err = -errno; + pr_warn("Unable to open lockfile for reading: %s\n", + strerror(-err)); + return err; + } + + len = read(fd, buf, sizeof(buf) - 1); + err = -errno; + close(fd); + if (len > 0) { + buf[len] = '\0'; + pid = strtoul(buf, NULL, 10); + } + if (!pid || err) { + pr_warn("Unable to read PID from lockfile: %s\n", + strerror(-err)); + return err; + } + pr_warn("Unable to get program lock: Already held by pid %d\n", + pid); + } else { + pr_warn("Unable to get program lock: %s\n", strerror(-err)); + } + return err; + } + + err = dprintf(prog_lock_fd, "%d\n", prog_pid); + if (err < 0) { + err = -errno; + pr_warn("Unable to write pid to lock file: %s\n", strerror(-err)); + goto out_err; + } + + err = fsync(prog_lock_fd); + if (err) { + err = -errno; + pr_warn("Unable fsync() lock file: %s\n", strerror(-err)); + goto out_err; + } + + return 0; +out_err: + unlink(prog_lock_file); + close(prog_lock_fd); + free(prog_lock_file); + prog_lock_file = NULL; + prog_lock_fd = -1; + return err; +} + +static char *print_bpf_tag(char buf[BPF_TAG_SIZE * 2 + 1], + const unsigned char tag[BPF_TAG_SIZE]) +{ + int i; + + for (i = 0; i < BPF_TAG_SIZE; i++) + sprintf(&buf[i * 2], "%02x", tag[i]); + buf[BPF_TAG_SIZE * 2] = '\0'; + return buf; +} + +static int print_iface_status(const struct iface *iface, + const struct xdp_multiprog *mp, + __unused void *arg) +{ + struct xdp_program *prog, *dispatcher, *hw_prog; + char tag[BPF_TAG_SIZE * 2 + 1]; + char buf[STRERR_BUFSIZE]; + int err; + + if (!mp) { + printf("%-22s <No XDP program loaded!>\n", iface->ifname); + return 0; + } + + hw_prog = xdp_multiprog__hw_prog(mp); + if (hw_prog) { + printf("%-16s %-5s %-17s %-8s %-4d %-17s\n", + iface->ifname, + "", + xdp_program__name(hw_prog), + get_enum_name(xdp_modes, XDP_MODE_HW), + xdp_program__id(hw_prog), + print_bpf_tag(tag, xdp_program__tag(hw_prog))); + } + + dispatcher = xdp_multiprog__main_prog(mp); + if (dispatcher) { + printf("%-16s %-5s %-17s %-8s %-4d %-17s\n", + iface->ifname, + "", + xdp_program__name(dispatcher), + get_enum_name(xdp_modes, xdp_multiprog__attach_mode(mp)), + xdp_program__id(dispatcher), + print_bpf_tag(tag, xdp_program__tag(dispatcher))); + + + for (prog = xdp_multiprog__next_prog(NULL, mp); + prog; + prog = xdp_multiprog__next_prog(prog, mp)) { + + err = xdp_program__print_chain_call_actions(prog, buf, + sizeof(buf)); + if (err) + return err; + + printf("%-16s %-5d %-16s %-8s %-4u %-17s %s\n", + " =>", xdp_program__run_prio(prog), + xdp_program__name(prog), + "", xdp_program__id(prog), + print_bpf_tag(tag, xdp_program__tag(prog)), + buf); + } + } + + return 0; +} + +int iface_print_status(const struct iface *iface) +{ + int err = 0; + + printf("%-16s %-5s %-17s Mode ID %-17s %s\n", + "Interface", "Prio", "Program name", "Tag", "Chain actions"); + printf("--------------------------------------------------------------------------------------\n"); + + if (iface) { + struct xdp_multiprog *mp; + + mp = xdp_multiprog__get_from_ifindex(iface->ifindex); + if (IS_ERR_OR_NULL(mp)) { + if (PTR_ERR(mp) != -ENOENT) { + err = PTR_ERR(mp); + pr_warn("Error getting XDP status for interface %s: %s\n", + iface->ifname, strerror(-err)); + goto out; + } + mp = NULL; + } + print_iface_status(iface, mp, NULL); + } else { + err = iterate_iface_multiprogs(print_iface_status, NULL); + } + printf("\n"); +out: + return err; +} diff --git a/lib/util/util.h b/lib/util/util.h new file mode 100644 index 0000000..8848e41 --- /dev/null +++ b/lib/util/util.h @@ -0,0 +1,97 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +#ifndef __UTIL_H +#define __UTIL_H + +#include <bpf/libbpf.h> +#include <xdp/libxdp.h> +#include "params.h" + +#ifndef PATH_MAX +#define PATH_MAX 4096 +#endif +#define STRERR_BUFSIZE 1024 +#define _textify(x) #x +#define textify(x) _textify(x) + +#define __unused __attribute__((unused)) + +#ifndef BPF_DIR_MNT +#define BPF_DIR_MNT "/sys/fs/bpf" +#endif + +#ifndef BPF_OBJECT_PATH +#define BPF_OBJECT_PATH "/usr/lib/bpf" +#endif + +#define ARRAY_SIZE(x) (sizeof(x) / sizeof(*(x))) + +#define FOR_EACH_MAP_KEY(_err, _map_fd, _map_key, _prev_key) \ + for (_err = bpf_map_get_next_key(_map_fd, NULL, &_map_key); \ + !_err; \ + _prev_key = _map_key, \ + _err = bpf_map_get_next_key(_map_fd, &_prev_key, &_map_key)) + +#define min(x, y) ((x) < (y) ? x : y) +#define max(x, y) ((x) > (y) ? x : y) + +#ifndef offsetof +#define offsetof(type, member) ((size_t) & ((type *)0)->member) +#endif + +#ifndef container_of +#define container_of(ptr, type, member) \ + ({ \ + const typeof(((type *)0)->member) *__mptr = (ptr); \ + (type *)((char *)__mptr - offsetof(type, member)); \ + }) +#endif + +#ifndef roundup +#define roundup(x, y) \ + ({ \ + typeof(y) __y = y; \ + (((x) + (__y - 1)) / __y) * __y; \ + }) +#endif + +int try_snprintf(char *buf, size_t buf_len, const char *format, ...); +int make_dir_subdir(const char *parent, const char *dir); + +int check_bpf_environ(void); +int double_rlimit(void); + +int attach_xdp_program(struct xdp_program *prog, const struct iface *iface, + enum xdp_attach_mode mode, const char *pin_root_dir); +int detach_xdp_program(struct xdp_program *prog, const struct iface *iface, + enum xdp_attach_mode mode, const char *pin_root_dir); + +int find_bpf_file(char *buf, size_t buf_size, const char *progname); +struct bpf_object *open_bpf_file(const char *progname, + struct bpf_object_open_opts *opts); + +typedef int (*program_callback)(const struct iface *iface, + struct xdp_program *prog, + enum xdp_attach_mode mode, void *arg); +typedef int (*multiprog_callback)(const struct iface *iface, + const struct xdp_multiprog *mp, void *arg); +int get_pinned_program(const struct iface *iface, const char *pin_root_path, + enum xdp_attach_mode *mode, struct xdp_program **prog); +int iterate_pinned_programs(const char *pin_root_path, program_callback cb, + void *arg); +int iterate_iface_multiprogs(multiprog_callback cb, void *arg); + +int get_bpf_root_dir(char *buf, size_t buf_len, const char *subdir, bool fatal); +int get_pinned_map_fd(const char *bpf_root, const char *map_name, + struct bpf_map_info *info); +int unlink_pinned_map(int dir_fd, const char *map_name); + +const char *action2str(__u32 action); + +int prog_lock_get(const char *progname); +void prog_lock_release(int signal); + +const char *get_libbpf_version(void); +int iface_print_status(const struct iface *iface); + +#endif diff --git a/lib/util/util.mk b/lib/util/util.mk new file mode 100644 index 0000000..7fc3b43 --- /dev/null +++ b/lib/util/util.mk @@ -0,0 +1,2 @@ +UTIL_OBJS := params.o logging.o util.o stats.o xpcapng.o xdp_sample.o +UTIL_BPF_OBJS := xdp_sample.bpf.o diff --git a/lib/util/xdp_sample.bpf.c b/lib/util/xdp_sample.bpf.c new file mode 100644 index 0000000..3e301bb --- /dev/null +++ b/lib/util/xdp_sample.bpf.c @@ -0,0 +1,18 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include <bpf/vmlinux.h> +#include <linux/bpf.h> +#include <bpf/bpf_tracing.h> +#include <bpf/bpf_core_read.h> +#include <bpf/bpf_helpers.h> + +SEC("tp_btf/xdp_cpumap_kthread") +int BPF_PROG(tp_xdp_cpumap_kthread, int map_id, unsigned int processed, + unsigned int drops, int sched, struct xdp_cpumap_stats *xdp_stats) +{ + bpf_printk("Stats: %d %u %u %d %d\n", + map_id, processed, drops, sched, xdp_stats->pass); + return 0; +} + +char _license[] SEC("license") = "GPL"; diff --git a/lib/util/xdp_sample.c b/lib/util/xdp_sample.c new file mode 100644 index 0000000..4385ea5 --- /dev/null +++ b/lib/util/xdp_sample.c @@ -0,0 +1,1643 @@ +// SPDX-License-Identifier: GPL-2.0-only +#define _GNU_SOURCE + +#include <math.h> +#include <poll.h> +#include <time.h> +#include <errno.h> +#include <fcntl.h> +#include <stdio.h> +#include <getopt.h> +#include <locale.h> +#include <net/if.h> +#include <signal.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <bpf/bpf.h> +#include <stdbool.h> +#include <inttypes.h> +#include <sys/mman.h> +#include <arpa/inet.h> +#include <sys/ioctl.h> +#include <bpf/libbpf.h> +#include <sys/sysinfo.h> +#include <sys/timerfd.h> +#include <sys/utsname.h> +#include <linux/limits.h> +#include <sys/resource.h> +#include <sys/signalfd.h> +#include <linux/ethtool.h> +#include <linux/if_link.h> +#include <linux/sockios.h> +#include <linux/hashtable.h> + +#include "xdp_sample.h" +#include "logging.h" + +#include "xdp_sample.skel.h" + +#define __sample_print(fmt, cond, ...) \ + ({ \ + if (cond) \ + printf(fmt, ##__VA_ARGS__); \ + }) + +#define print_always(fmt, ...) __sample_print(fmt, 1, ##__VA_ARGS__) +#define print_default(fmt, ...) \ + __sample_print(fmt, sample_log_level & LL_DEFAULT, ##__VA_ARGS__) +#define __print_err(err, fmt, ...) \ + ({ \ + __sample_print(fmt, err > 0 || sample_log_level & LL_DEFAULT, \ + ##__VA_ARGS__); \ + sample_err_exp = sample_err_exp ? true : err > 0; \ + }) +#define print_err(err, fmt, ...) __print_err(err, fmt, ##__VA_ARGS__) + +#define __COLUMN(x) "%'10" x " %-13s" +#define FMT_COLUMNf __COLUMN(".0f") +#define FMT_COLUMNd __COLUMN("d") +#define FMT_COLUMNl __COLUMN(PRIu64) +#define RX(rx) rx, "rx/s" +#define PPS(pps) pps, "pkt/s" +#define DROP(drop) drop, "drop/s" +#define ERR(err) err, "error/s" +#define HITS(hits) hits, "hit/s" +#define XMIT(xmit) xmit, "xmit/s" +#define PASS(pass) pass, "pass/s" +#define REDIR(redir) redir, "redir/s" +#define NANOSEC_PER_SEC 1000000000 /* 10^9 */ + +#define XDP_UNKNOWN (XDP_REDIRECT + 1) +#define XDP_ACTION_MAX (XDP_UNKNOWN + 1) +#define XDP_REDIRECT_ERR_MAX 7 + +enum map_type { + MAP_RX, + MAP_RXQ, + MAP_REDIRECT_ERR, + MAP_CPUMAP_ENQUEUE, + MAP_CPUMAP_KTHREAD, + MAP_EXCEPTION, + MAP_DEVMAP_XMIT, + MAP_DEVMAP_XMIT_MULTI, + NUM_MAP, +}; + +enum log_level { + LL_DEFAULT = 1U << 0, + LL_SIMPLE = 1U << 1, + LL_DEBUG = 1U << 2, +}; + +struct record { + __u64 timestamp; + struct datarec total; + union { + struct datarec *cpu; + struct datarec *rxq; + }; +}; + +struct map_entry { + struct hlist_node node; + __u64 pair; + struct record val; +}; + +struct stats_record { + struct record rx_cnt; + struct record rxq_cnt; + struct record redir_err[XDP_REDIRECT_ERR_MAX]; + struct record kthread; + struct record exception[XDP_ACTION_MAX]; + struct record devmap_xmit; + DECLARE_HASHTABLE(xmit_map, 5); + struct record enq[]; +}; + +struct sample_output { + struct { + uint64_t rx; + uint64_t redir; + uint64_t drop; + uint64_t drop_xmit; + uint64_t err; + uint64_t xmit; + } totals; + struct { + union { + uint64_t pps; + uint64_t num; + }; + uint64_t drop; + uint64_t err; + } rx_cnt; + struct { + uint64_t suc; + uint64_t err; + } redir_cnt; + struct { + uint64_t hits; + } except_cnt; + struct { + uint64_t pps; + uint64_t drop; + uint64_t err; + double bavg; + } xmit_cnt; +}; + +struct datarec *sample_mmap[NUM_MAP]; +struct bpf_map *sample_map[NUM_MAP]; +size_t sample_map_count[NUM_MAP]; +enum log_level sample_log_level; +struct sample_output sample_out; +unsigned long sample_interval; +bool sample_err_exp; +int sample_xdp_cnt; +int sample_n_cpus; +int sample_n_rxqs; +int sample_sig_fd; +int sample_mask; +int ifindex[2]; + +static struct { + bool checked; + bool compat; +} sample_compat[SAMPLE_COMPAT_MAX] = {}; + +bool sample_is_compat(enum sample_compat compat_value) +{ + return sample_compat[compat_value].compat; +} + +bool sample_probe_cpumap_compat(void) +{ + struct xdp_sample *skel; + bool res; + + skel = xdp_sample__open_and_load(); + res = !!skel; + xdp_sample__destroy(skel); + + return res; +} + +void sample_check_cpumap_compat(struct bpf_program *prog, + struct bpf_program *prog_compat) +{ + bool res = sample_compat[SAMPLE_COMPAT_CPUMAP_KTHREAD].compat; + + if (!sample_compat[SAMPLE_COMPAT_CPUMAP_KTHREAD].checked) { + res = sample_probe_cpumap_compat(); + + sample_compat[SAMPLE_COMPAT_CPUMAP_KTHREAD].checked = true; + sample_compat[SAMPLE_COMPAT_CPUMAP_KTHREAD].compat = res; + } + + if (res) { + pr_debug("Kernel supports 5-arg xdp_cpumap_kthread tracepoint\n"); + bpf_program__set_autoload(prog_compat, false); + } else { + pr_debug("Kernel does not support 5-arg xdp_cpumap_kthread tracepoint, using compat version\n"); + bpf_program__set_autoload(prog, false); + } +} + +static const char *xdp_redirect_err_names[XDP_REDIRECT_ERR_MAX] = { + /* Key=1 keeps unknown errors */ + "Success", + "Unknown", + "EINVAL", + "ENETDOWN", + "EMSGSIZE", + "EOPNOTSUPP", + "ENOSPC", +}; + +static const char *xdp_action_names[XDP_ACTION_MAX] = { + [XDP_ABORTED] = "XDP_ABORTED", + [XDP_DROP] = "XDP_DROP", + [XDP_PASS] = "XDP_PASS", + [XDP_TX] = "XDP_TX", + [XDP_REDIRECT] = "XDP_REDIRECT", + [XDP_UNKNOWN] = "XDP_UNKNOWN", +}; + +static __u64 gettime(void) +{ + struct timespec t; + int res; + + res = clock_gettime(CLOCK_MONOTONIC, &t); + if (res < 0) { + pr_warn("Error with gettimeofday! (%i)\n", res); + return UINT64_MAX; + } + return (__u64)t.tv_sec * NANOSEC_PER_SEC + t.tv_nsec; +} + +static const char *xdp_action2str(int action) +{ + if (action < XDP_ACTION_MAX) + return xdp_action_names[action]; + return NULL; +} + +static struct datarec *alloc_records(int nr_entries) +{ + struct datarec *array; + + if (nr_entries <= 0) + return NULL; + + array = calloc(nr_entries, sizeof(*array)); + if (!array) { + pr_warn("Failed to allocate memory (nr_entries: %u)\n", nr_entries); + return NULL; + } + return array; +} + +static int map_entry_init(struct map_entry *e, __u64 pair) +{ + e->pair = pair; + INIT_HLIST_NODE(&e->node); + e->val.timestamp = gettime(); + e->val.cpu = alloc_records(libbpf_num_possible_cpus()); + if (!e->val.cpu) + return -ENOMEM; + return 0; +} + +static void map_collect_rxqs(struct datarec *values, struct record *rec) +{ + int i; + + /* Get time as close as possible to reading map contents */ + rec->timestamp = gettime(); + + /* Record and sum values from each RXQ */ + for (i = 0; i < sample_n_rxqs; i++) { + pr_debug("%d: %lx %lx\n", i, (unsigned long)&rec->rxq[i], (unsigned long)&values[i]); + rec->rxq[i].processed = READ_ONCE(values[i].processed); + rec->rxq[i].dropped = READ_ONCE(values[i].dropped); + rec->rxq[i].issue = READ_ONCE(values[i].issue); + rec->rxq[i].xdp_pass = READ_ONCE(values[i].xdp_pass); + rec->rxq[i].xdp_drop = READ_ONCE(values[i].xdp_drop); + rec->rxq[i].xdp_redirect = READ_ONCE(values[i].xdp_redirect); + } +} + +static void map_collect_percpu(struct datarec *values, struct record *rec) +{ + /* For percpu maps, userspace gets a value per possible CPU */ + int nr_cpus = libbpf_num_possible_cpus(); + __u64 sum_xdp_redirect = 0; + __u64 sum_processed = 0; + __u64 sum_xdp_pass = 0; + __u64 sum_xdp_drop = 0; + __u64 sum_dropped = 0; + __u64 sum_issue = 0; + int i; + + /* Get time as close as possible to reading map contents */ + rec->timestamp = gettime(); + + /* Record and sum values from each CPU */ + for (i = 0; i < nr_cpus; i++) { + rec->cpu[i].processed = READ_ONCE(values[i].processed); + rec->cpu[i].dropped = READ_ONCE(values[i].dropped); + rec->cpu[i].issue = READ_ONCE(values[i].issue); + rec->cpu[i].xdp_pass = READ_ONCE(values[i].xdp_pass); + rec->cpu[i].xdp_drop = READ_ONCE(values[i].xdp_drop); + rec->cpu[i].xdp_redirect = READ_ONCE(values[i].xdp_redirect); + + sum_processed += rec->cpu[i].processed; + sum_dropped += rec->cpu[i].dropped; + sum_issue += rec->cpu[i].issue; + sum_xdp_pass += rec->cpu[i].xdp_pass; + sum_xdp_drop += rec->cpu[i].xdp_drop; + sum_xdp_redirect += rec->cpu[i].xdp_redirect; + } + + rec->total.processed = sum_processed; + rec->total.dropped = sum_dropped; + rec->total.issue = sum_issue; + rec->total.xdp_pass = sum_xdp_pass; + rec->total.xdp_drop = sum_xdp_drop; + rec->total.xdp_redirect = sum_xdp_redirect; +} + +static int map_collect_percpu_devmap(int map_fd, struct stats_record *rec) +{ + int nr_cpus = libbpf_num_possible_cpus(); + int i, ret, count = 32; + struct datarec *values; + bool init = false; + __u32 batch; + __u64 *keys; + + keys = calloc(count, sizeof(__u64)); + if (!keys) + return -ENOMEM; + values = calloc(count * nr_cpus, sizeof(struct datarec)); + if (!values) { + free(keys); + return -ENOMEM; + } + + for (;;) { + bool exit = false; + + ret = bpf_map_lookup_batch(map_fd, init ? &batch : NULL, &batch, + keys, values, (__u32 *)&count, NULL); + if (ret < 0 && errno != ENOENT) + break; + if (errno == ENOENT) + exit = true; + + init = true; + for (i = 0; i < count; i++) { + struct map_entry *e, *x = NULL; + __u64 pair = keys[i]; + struct datarec *arr; + + arr = &values[i * nr_cpus]; + hash_for_each_possible(rec->xmit_map, e, node, pair) { + if (e->pair == pair) { + x = e; + break; + } + } + if (!x) { + x = calloc(1, sizeof(*x)); + if (!x) + goto cleanup; + if (map_entry_init(x, pair) < 0) { + free(x); + goto cleanup; + } + hash_add(rec->xmit_map, &x->node, pair); + } + map_collect_percpu(arr, &x->val); + } + + if (exit) + break; + count = 32; + } + + free(values); + free(keys); + return 0; +cleanup: + free(values); + free(keys); + return -ENOMEM; +} + +static struct stats_record *alloc_stats_record(void) +{ + struct stats_record *rec; + int i; + + rec = calloc(1, sizeof(*rec) + sample_n_cpus * sizeof(struct record)); + if (!rec) { + pr_warn("Failed to allocate memory\n"); + return NULL; + } + + if (sample_mask & SAMPLE_RX_CNT) { + rec->rx_cnt.cpu = alloc_records(libbpf_num_possible_cpus()); + if (!rec->rx_cnt.cpu) { + pr_warn("Failed to allocate rx_cnt per-CPU array\n"); + goto end_rec; + } + } + if (sample_mask & SAMPLE_RXQ_STATS) { + if (sample_n_rxqs <= 0) { + pr_warn("Invalid number of RXQs: %d\n", sample_n_rxqs); + goto end_rx_cnt; + } + + rec->rxq_cnt.rxq = alloc_records(sample_n_rxqs); + if (!rec->rxq_cnt.rxq) { + pr_warn("Failed to allocate rxq_cnt per RXQ array\n"); + goto end_rx_cnt; + } + } + if (sample_mask & (SAMPLE_REDIRECT_CNT | SAMPLE_REDIRECT_ERR_CNT)) { + for (i = 0; i < XDP_REDIRECT_ERR_MAX; i++) { + rec->redir_err[i].cpu = alloc_records(libbpf_num_possible_cpus()); + if (!rec->redir_err[i].cpu) { + pr_warn("Failed to allocate redir_err per-CPU array for \"%s\" case\n", + xdp_redirect_err_names[i]); + while (i--) + free(rec->redir_err[i].cpu); + goto end_rxq_cnt; + } + } + } + if (sample_mask & SAMPLE_CPUMAP_KTHREAD_CNT) { + rec->kthread.cpu = alloc_records(libbpf_num_possible_cpus()); + if (!rec->kthread.cpu) { + pr_warn("Failed to allocate kthread per-CPU array\n"); + goto end_redir; + } + } + if (sample_mask & SAMPLE_EXCEPTION_CNT) { + for (i = 0; i < XDP_ACTION_MAX; i++) { + rec->exception[i].cpu = alloc_records(libbpf_num_possible_cpus()); + if (!rec->exception[i].cpu) { + pr_warn("Failed to allocate exception per-CPU array for \"%s\" case\n", + xdp_action2str(i)); + while (i--) + free(rec->exception[i].cpu); + goto end_kthread; + } + } + } + if (sample_mask & SAMPLE_DEVMAP_XMIT_CNT) { + rec->devmap_xmit.cpu = alloc_records(libbpf_num_possible_cpus()); + if (!rec->devmap_xmit.cpu) { + pr_warn("Failed to allocate devmap_xmit per-CPU array\n"); + goto end_exception; + } + } + if (sample_mask & SAMPLE_DEVMAP_XMIT_CNT_MULTI) + hash_init(rec->xmit_map); + if (sample_mask & SAMPLE_CPUMAP_ENQUEUE_CNT) { + for (i = 0; i < sample_n_cpus; i++) { + rec->enq[i].cpu = alloc_records(libbpf_num_possible_cpus()); + if (!rec->enq[i].cpu) { + pr_warn("Failed to allocate enqueue per-CPU array for CPU %d\n", i); + while (i--) + free(rec->enq[i].cpu); + goto end_devmap_xmit; + } + } + } + + return rec; + +end_devmap_xmit: + free(rec->devmap_xmit.cpu); +end_exception: + for (i = 0; i < XDP_ACTION_MAX; i++) + free(rec->exception[i].cpu); +end_kthread: + free(rec->kthread.cpu); +end_redir: + for (i = 0; i < XDP_REDIRECT_ERR_MAX; i++) + free(rec->redir_err[i].cpu); +end_rxq_cnt: + free(rec->rxq_cnt.rxq); +end_rx_cnt: + free(rec->rx_cnt.cpu); +end_rec: + free(rec); + return NULL; +} + +static void free_stats_record(struct stats_record *r) +{ + struct hlist_node *tmp; + struct map_entry *e; + unsigned int bkt; + int i; + + for (i = 0; i < sample_n_cpus; i++) + free(r->enq[i].cpu); + hash_for_each_safe(r->xmit_map, bkt, tmp, e, node) { + hash_del(&e->node); + free(e->val.cpu); + free(e); + } + free(r->devmap_xmit.cpu); + for (i = 0; i < XDP_ACTION_MAX; i++) + free(r->exception[i].cpu); + free(r->kthread.cpu); + for (i = 0; i < XDP_REDIRECT_ERR_MAX; i++) + free(r->redir_err[i].cpu); + free(r->rx_cnt.cpu); + free(r); +} + +static double calc_period(struct record *r, struct record *p) +{ + double period_ = 0; + __u64 period = 0; + + period = r->timestamp - p->timestamp; + if (period > 0) + period_ = ((double)period / NANOSEC_PER_SEC); + + return period_; +} + +static double sample_round(double val) +{ + if (val - floor(val) < 0.5) + return floor(val); + return ceil(val); +} + +static __u64 calc_pps(struct datarec *r, struct datarec *p, double period_) +{ + __u64 packets = 0; + __u64 pps = 0; + + if (period_ > 0) { + packets = r->processed - p->processed; + pps = sample_round(packets / period_); + } + return pps; +} + +static __u64 calc_drop_pps(struct datarec *r, struct datarec *p, double period_) +{ + __u64 packets = 0; + __u64 pps = 0; + + if (period_ > 0) { + packets = r->dropped - p->dropped; + pps = sample_round(packets / period_); + } + return pps; +} + +static __u64 calc_errs_pps(struct datarec *r, struct datarec *p, double period_) +{ + __u64 packets = 0; + __u64 pps = 0; + + if (period_ > 0) { + packets = r->issue - p->issue; + pps = sample_round(packets / period_); + } + return pps; +} + +static __u64 calc_info_pps(struct datarec *r, struct datarec *p, double period_) +{ + __u64 packets = 0; + __u64 pps = 0; + + if (period_ > 0) { + packets = r->info - p->info; + pps = sample_round(packets / period_); + } + return pps; +} + +static void calc_xdp_pps(struct datarec *r, struct datarec *p, double *xdp_pass, + double *xdp_drop, double *xdp_redirect, double period_) +{ + *xdp_pass = 0, *xdp_drop = 0, *xdp_redirect = 0; + if (period_ > 0) { + *xdp_redirect = (r->xdp_redirect - p->xdp_redirect) / period_; + *xdp_pass = (r->xdp_pass - p->xdp_pass) / period_; + *xdp_drop = (r->xdp_drop - p->xdp_drop) / period_; + } +} + +static void stats_get_rx_cnt(struct stats_record *stats_rec, + struct stats_record *stats_prev, + int nr_cpus, struct sample_output *out) +{ + struct record *rec, *prev; + double t, pps, drop, err; + int i; + + rec = &stats_rec->rx_cnt; + prev = &stats_prev->rx_cnt; + t = calc_period(rec, prev); + + for (i = 0; i < nr_cpus; i++) { + struct datarec *r = &rec->cpu[i]; + struct datarec *p = &prev->cpu[i]; + char str[64]; + + pps = calc_pps(r, p, t); + drop = calc_drop_pps(r, p, t); + err = calc_errs_pps(r, p, t); + if (!pps && !drop && !err) + continue; + + snprintf(str, sizeof(str), "cpu:%d", i); + print_default(" %-18s " FMT_COLUMNf FMT_COLUMNf FMT_COLUMNf + "\n", + str, PPS(pps), DROP(drop), ERR(err)); + } + + if (out) { + pps = calc_pps(&rec->total, &prev->total, t); + drop = calc_drop_pps(&rec->total, &prev->total, t); + err = calc_errs_pps(&rec->total, &prev->total, t); + + out->rx_cnt.pps = pps; + out->rx_cnt.drop = drop; + out->rx_cnt.err = err; + out->totals.rx += pps; + out->totals.drop += drop; + out->totals.err += err; + } +} + +static void stats_get_rxq_cnt(struct stats_record *stats_rec, + struct stats_record *stats_prev) +{ + struct record *rec, *prev; + double t, pps, drop, err; + int i; + + rec = &stats_rec->rxq_cnt; + prev = &stats_prev->rxq_cnt; + t = calc_period(rec, prev); + + print_default("\n"); + for (i = 0; i < sample_n_rxqs; i++) { + struct datarec *r = &rec->rxq[i]; + struct datarec *p = &prev->rxq[i]; + char str[64]; + + pps = calc_pps(r, p, t); + drop = calc_drop_pps(r, p, t); + err = calc_errs_pps(r, p, t); + if (!pps && !drop && !err) + continue; + + snprintf(str, sizeof(str), "rxq:%d", i); + print_default(" %-18s " FMT_COLUMNf FMT_COLUMNf FMT_COLUMNf + "\n", + str, PPS(pps), DROP(drop), ERR(err)); + } +} + +static void stats_get_cpumap_enqueue(struct stats_record *stats_rec, + struct stats_record *stats_prev, + int nr_cpus) +{ + struct record *rec, *prev; + double t, pps, drop, err; + int i, to_cpu; + + /* cpumap enqueue stats */ + for (to_cpu = 0; to_cpu < sample_n_cpus; to_cpu++) { + rec = &stats_rec->enq[to_cpu]; + prev = &stats_prev->enq[to_cpu]; + t = calc_period(rec, prev); + + pps = calc_pps(&rec->total, &prev->total, t); + drop = calc_drop_pps(&rec->total, &prev->total, t); + err = calc_errs_pps(&rec->total, &prev->total, t); + + if (pps > 0 || drop > 0) { + char str[64]; + + snprintf(str, sizeof(str), "enqueue to cpu %d", to_cpu); + + if (err > 0) + err = pps / err; /* calc average bulk size */ + + print_err(drop, + " %-20s " FMT_COLUMNf FMT_COLUMNf __COLUMN( + ".2f") "\n", + str, PPS(pps), DROP(drop), err, "bulk-avg"); + } + + for (i = 0; i < nr_cpus; i++) { + struct datarec *r = &rec->cpu[i]; + struct datarec *p = &prev->cpu[i]; + char str[64]; + + pps = calc_pps(r, p, t); + drop = calc_drop_pps(r, p, t); + err = calc_errs_pps(r, p, t); + if (!pps && !drop && !err) + continue; + + snprintf(str, sizeof(str), "cpu:%d->%d", i, to_cpu); + if (err > 0) + err = pps / err; /* calc average bulk size */ + print_default( + " %-18s " FMT_COLUMNf FMT_COLUMNf __COLUMN( + ".2f") "\n", + str, PPS(pps), DROP(drop), err, "bulk-avg"); + } + } +} + +static void stats_get_cpumap_remote(struct stats_record *stats_rec, + struct stats_record *stats_prev, + int nr_cpus) +{ + double xdp_pass, xdp_drop, xdp_redirect; + struct record *rec, *prev; + double t; + int i; + + rec = &stats_rec->kthread; + prev = &stats_prev->kthread; + t = calc_period(rec, prev); + + calc_xdp_pps(&rec->total, &prev->total, &xdp_pass, &xdp_drop, + &xdp_redirect, t); + if (xdp_pass || xdp_drop || xdp_redirect) { + print_err(xdp_drop, + " %-18s " FMT_COLUMNf FMT_COLUMNf FMT_COLUMNf "\n", + "xdp_stats", PASS(xdp_pass), DROP(xdp_drop), + REDIR(xdp_redirect)); + } + + for (i = 0; i < nr_cpus; i++) { + struct datarec *r = &rec->cpu[i]; + struct datarec *p = &prev->cpu[i]; + char str[64]; + + calc_xdp_pps(r, p, &xdp_pass, &xdp_drop, &xdp_redirect, t); + if (!xdp_pass && !xdp_drop && !xdp_redirect) + continue; + + snprintf(str, sizeof(str), "cpu:%d", i); + print_default(" %-16s " FMT_COLUMNf FMT_COLUMNf FMT_COLUMNf + "\n", + str, PASS(xdp_pass), DROP(xdp_drop), + REDIR(xdp_redirect)); + } +} + +static void stats_get_cpumap_kthread(struct stats_record *stats_rec, + struct stats_record *stats_prev, + int nr_cpus) +{ + struct record *rec, *prev; + double t, pps, drop, err; + int i; + + rec = &stats_rec->kthread; + prev = &stats_prev->kthread; + t = calc_period(rec, prev); + + pps = calc_pps(&rec->total, &prev->total, t); + drop = calc_drop_pps(&rec->total, &prev->total, t); + err = calc_errs_pps(&rec->total, &prev->total, t); + + print_err(drop, " %-20s " FMT_COLUMNf FMT_COLUMNf FMT_COLUMNf "\n", + pps ? "kthread total" : "kthread", PPS(pps), DROP(drop), err, + "sched"); + + for (i = 0; i < nr_cpus; i++) { + struct datarec *r = &rec->cpu[i]; + struct datarec *p = &prev->cpu[i]; + char str[64]; + + pps = calc_pps(r, p, t); + drop = calc_drop_pps(r, p, t); + err = calc_errs_pps(r, p, t); + if (!pps && !drop && !err) + continue; + + snprintf(str, sizeof(str), "cpu:%d", i); + print_default(" %-18s " FMT_COLUMNf FMT_COLUMNf FMT_COLUMNf + "\n", + str, PPS(pps), DROP(drop), err, "sched"); + } +} + +static void stats_get_redirect_cnt(struct stats_record *stats_rec, + struct stats_record *stats_prev, + int nr_cpus, + struct sample_output *out) +{ + struct record *rec, *prev; + double t, pps; + int i; + + rec = &stats_rec->redir_err[0]; + prev = &stats_prev->redir_err[0]; + t = calc_period(rec, prev); + for (i = 0; i < nr_cpus; i++) { + struct datarec *r = &rec->cpu[i]; + struct datarec *p = &prev->cpu[i]; + char str[64]; + + pps = calc_pps(r, p, t); + if (!pps) + continue; + + snprintf(str, sizeof(str), "cpu:%d", i); + print_default(" %-18s " FMT_COLUMNf "\n", str, REDIR(pps)); + } + + if (out) { + pps = calc_pps(&rec->total, &prev->total, t); + out->redir_cnt.suc = pps; + out->totals.redir += pps; + } +} + +static void stats_get_redirect_err_cnt(struct stats_record *stats_rec, + struct stats_record *stats_prev, + int nr_cpus, + struct sample_output *out) +{ + struct record *rec, *prev; + double t, drop, sum = 0; + int rec_i, i; + + for (rec_i = 1; rec_i < XDP_REDIRECT_ERR_MAX; rec_i++) { + char str[64]; + + rec = &stats_rec->redir_err[rec_i]; + prev = &stats_prev->redir_err[rec_i]; + t = calc_period(rec, prev); + + drop = calc_drop_pps(&rec->total, &prev->total, t); + if (drop > 0 && !out) { + snprintf(str, sizeof(str), + sample_log_level & LL_DEFAULT ? "%s total" : + "%s", + xdp_redirect_err_names[rec_i]); + print_err(drop, " %-18s " FMT_COLUMNf "\n", str, + ERR(drop)); + } + + for (i = 0; i < nr_cpus; i++) { + struct datarec *r = &rec->cpu[i]; + struct datarec *p = &prev->cpu[i]; + double drop; + + drop = calc_drop_pps(r, p, t); + if (!drop) + continue; + + snprintf(str, sizeof(str), "cpu:%d", i); + print_default(" %-16s" FMT_COLUMNf "\n", str, + ERR(drop)); + } + + sum += drop; + } + + if (out) { + out->redir_cnt.err = sum; + out->totals.err += sum; + } +} + +static void stats_get_exception_cnt(struct stats_record *stats_rec, + struct stats_record *stats_prev, + int nr_cpus, + struct sample_output *out) +{ + double t, drop, sum = 0; + struct record *rec, *prev; + int rec_i, i; + + for (rec_i = 0; rec_i < XDP_ACTION_MAX; rec_i++) { + rec = &stats_rec->exception[rec_i]; + prev = &stats_prev->exception[rec_i]; + t = calc_period(rec, prev); + + drop = calc_drop_pps(&rec->total, &prev->total, t); + /* Fold out errors after heading */ + sum += drop; + + if (drop > 0 && !out) { + print_always(" %-18s " FMT_COLUMNf "\n", + xdp_action2str(rec_i), ERR(drop)); + + for (i = 0; i < nr_cpus; i++) { + struct datarec *r = &rec->cpu[i]; + struct datarec *p = &prev->cpu[i]; + char str[64]; + double drop; + + drop = calc_drop_pps(r, p, t); + if (!drop) + continue; + + snprintf(str, sizeof(str), "cpu:%d", i); + print_default(" %-16s" FMT_COLUMNf "\n", + str, ERR(drop)); + } + } + } + + if (out) { + out->except_cnt.hits = sum; + out->totals.err += sum; + } +} + +static void stats_get_devmap_xmit(struct stats_record *stats_rec, + struct stats_record *stats_prev, + int nr_cpus, + struct sample_output *out) +{ + double pps, drop, info, err; + struct record *rec, *prev; + double t; + int i; + + rec = &stats_rec->devmap_xmit; + prev = &stats_prev->devmap_xmit; + t = calc_period(rec, prev); + for (i = 0; i < nr_cpus; i++) { + struct datarec *r = &rec->cpu[i]; + struct datarec *p = &prev->cpu[i]; + char str[64]; + + pps = calc_pps(r, p, t); + drop = calc_drop_pps(r, p, t); + err = calc_errs_pps(r, p, t); + + if (!pps && !drop && !err) + continue; + + snprintf(str, sizeof(str), "cpu:%d", i); + info = calc_info_pps(r, p, t); + if (info > 0) + info = (pps + drop) / info; /* calc avg bulk */ + print_default(" %-18s" FMT_COLUMNf FMT_COLUMNf FMT_COLUMNf + __COLUMN(".2f") "\n", + str, XMIT(pps), DROP(drop), err, "drv_err/s", + info, "bulk-avg"); + } + if (out) { + pps = calc_pps(&rec->total, &prev->total, t); + drop = calc_drop_pps(&rec->total, &prev->total, t); + info = calc_info_pps(&rec->total, &prev->total, t); + if (info > 0) + info = (pps + drop) / info; /* calc avg bulk */ + err = calc_errs_pps(&rec->total, &prev->total, t); + + out->xmit_cnt.pps = pps; + out->xmit_cnt.drop = drop; + out->xmit_cnt.bavg = info; + out->xmit_cnt.err = err; + out->totals.xmit += pps; + out->totals.drop_xmit += drop; + out->totals.err += err; + } +} + +static void stats_get_devmap_xmit_multi(struct stats_record *stats_rec, + struct stats_record *stats_prev, + int nr_cpus, + struct sample_output *out) +{ + double pps, drop, info, err; + struct map_entry *entry; + struct record *r, *p; + unsigned int bkt; + double t; + + hash_for_each(stats_rec->xmit_map, bkt, entry, node) { + struct map_entry *e, *x = NULL; + char ifname_from[IFNAMSIZ]; + char ifname_to[IFNAMSIZ]; + const char *fstr, *tstr; + unsigned long prev_time; + struct record beg = {}; + __u32 from_idx, to_idx; + char str[128]; + __u64 pair; + int i; + + prev_time = sample_interval * NANOSEC_PER_SEC; + + pair = entry->pair; + from_idx = pair >> 32; + to_idx = pair & 0xFFFFFFFF; + + r = &entry->val; + beg.timestamp = r->timestamp - prev_time; + + /* Find matching entry from stats_prev map */ + hash_for_each_possible(stats_prev->xmit_map, e, node, pair) { + if (e->pair == pair) { + x = e; + break; + } + } + if (x) + p = &x->val; + else + p = &beg; + t = calc_period(r, p); + pps = calc_pps(&r->total, &p->total, t); + drop = calc_drop_pps(&r->total, &p->total, t); + info = calc_info_pps(&r->total, &p->total, t); + if (info > 0) + info = (pps + drop) / info; /* calc avg bulk */ + err = calc_errs_pps(&r->total, &p->total, t); + + if (out) { + /* We are responsible for filling out totals */ + out->totals.xmit += pps; + out->totals.drop_xmit += drop; + out->totals.err += err; + continue; + } + + fstr = tstr = NULL; + if (if_indextoname(from_idx, ifname_from)) + fstr = ifname_from; + if (if_indextoname(to_idx, ifname_to)) + tstr = ifname_to; + + snprintf(str, sizeof(str), "xmit %s->%s", fstr ?: "?", + tstr ?: "?"); + /* Skip idle streams of redirection */ + if (pps || drop || err) { + print_err(drop * !(sample_mask & SAMPLE_DROP_OK), + " %-20s " FMT_COLUMNf FMT_COLUMNf FMT_COLUMNf + __COLUMN(".2f") "\n", str, XMIT(pps), DROP(drop), + err, "drv_err/s", info, "bulk-avg"); + } + + for (i = 0; i < nr_cpus; i++) { + struct datarec *rc = &r->cpu[i]; + struct datarec *pc, p_beg = {}; + char str[64]; + + pc = p == &beg ? &p_beg : &p->cpu[i]; + + pps = calc_pps(rc, pc, t); + drop = calc_drop_pps(rc, pc, t); + err = calc_errs_pps(rc, pc, t); + + if (!pps && !drop && !err) + continue; + + snprintf(str, sizeof(str), "cpu:%d", i); + info = calc_info_pps(rc, pc, t); + if (info > 0) + info = (pps + drop) / info; /* calc avg bulk */ + + print_default(" %-18s" FMT_COLUMNf FMT_COLUMNf FMT_COLUMNf + __COLUMN(".2f") "\n", str, XMIT(pps), + DROP(drop), err, "drv_err/s", info, "bulk-avg"); + } + } +} + +static void stats_print(const char *prefix, int mask, struct stats_record *r, + struct stats_record *p, struct sample_output *out) +{ + int nr_cpus = libbpf_num_possible_cpus(); + const char *str; + + print_always("%-23s", prefix ?: "Summary"); + if (mask & SAMPLE_RX_CNT) + print_always(FMT_COLUMNl, RX(out->totals.rx)); + if (mask & SAMPLE_REDIRECT_CNT) + print_always(FMT_COLUMNl, REDIR(out->totals.redir)); + printf(FMT_COLUMNl, + out->totals.err + ((out->totals.drop_xmit + out->totals.drop) * !(mask & SAMPLE_DROP_OK)), + (mask & SAMPLE_DROP_OK) ? "err/s" : "err,drop/s"); + if (mask & SAMPLE_DEVMAP_XMIT_CNT || + mask & SAMPLE_DEVMAP_XMIT_CNT_MULTI) + printf(FMT_COLUMNl, XMIT(out->totals.xmit)); + printf("\n"); + + if (mask & SAMPLE_RX_CNT) { + str = (sample_log_level & LL_DEFAULT) && out->rx_cnt.pps ? + "receive total" : + "receive"; + print_err((out->rx_cnt.err || (out->rx_cnt.drop && !(mask & SAMPLE_DROP_OK))), + " %-20s " FMT_COLUMNl FMT_COLUMNl FMT_COLUMNl "\n", + str, PPS(out->rx_cnt.pps), DROP(out->rx_cnt.drop), + ERR(out->rx_cnt.err)); + + stats_get_rx_cnt(r, p, nr_cpus, NULL); + } + + if (mask & SAMPLE_RXQ_STATS) + stats_get_rxq_cnt(r, p); + + if (mask & SAMPLE_CPUMAP_ENQUEUE_CNT) + stats_get_cpumap_enqueue(r, p, nr_cpus); + + if (mask & SAMPLE_CPUMAP_KTHREAD_CNT) { + stats_get_cpumap_kthread(r, p, nr_cpus); + stats_get_cpumap_remote(r, p, nr_cpus); + } + + if (mask & SAMPLE_REDIRECT_CNT) { + str = out->redir_cnt.suc ? "redirect total" : "redirect"; + print_default(" %-20s " FMT_COLUMNl "\n", str, + REDIR(out->redir_cnt.suc)); + + stats_get_redirect_cnt(r, p, nr_cpus, NULL); + } + + if (mask & SAMPLE_REDIRECT_ERR_CNT) { + str = (sample_log_level & LL_DEFAULT) && out->redir_cnt.err ? + "redirect_err total" : + "redirect_err"; + print_err(out->redir_cnt.err, " %-20s " FMT_COLUMNl "\n", str, + ERR(out->redir_cnt.err)); + + stats_get_redirect_err_cnt(r, p, nr_cpus, NULL); + } + + if (mask & SAMPLE_EXCEPTION_CNT) { + str = out->except_cnt.hits ? "xdp_exception total" : + "xdp_exception"; + + print_err(out->except_cnt.hits, " %-20s " FMT_COLUMNl "\n", str, + HITS(out->except_cnt.hits)); + + stats_get_exception_cnt(r, p, nr_cpus, NULL); + } + + if (mask & SAMPLE_DEVMAP_XMIT_CNT) { + str = (sample_log_level & LL_DEFAULT) && out->xmit_cnt.pps ? + "devmap_xmit total" : + "devmap_xmit"; + + print_err(out->xmit_cnt.err || out->xmit_cnt.drop, + " %-20s " FMT_COLUMNl FMT_COLUMNl FMT_COLUMNl + __COLUMN(".2f") "\n", + str, XMIT(out->xmit_cnt.pps), + DROP(out->xmit_cnt.drop), (uint64_t)out->xmit_cnt.err, + "drv_err/s", out->xmit_cnt.bavg, "bulk-avg"); + + stats_get_devmap_xmit(r, p, nr_cpus, NULL); + } + + if (mask & SAMPLE_DEVMAP_XMIT_CNT_MULTI) + stats_get_devmap_xmit_multi(r, p, nr_cpus, NULL); + + if (sample_log_level & LL_DEFAULT || + ((sample_log_level & LL_SIMPLE) && sample_err_exp)) { + sample_err_exp = false; + printf("\n"); + } +} + +static int get_num_rxqs(const char *ifname) +{ + struct ethtool_channels ch = { + .cmd = ETHTOOL_GCHANNELS, + }; + + struct ifreq ifr = { + .ifr_data = (void *)&ch, + }; + int fd, ret; + + if (!ifname || strlen(ifname) > sizeof(ifr.ifr_name) - 1) + return 0; + + strcpy(ifr.ifr_name, ifname); + fd = socket(AF_UNIX, SOCK_DGRAM, 0); + if (fd < 0) { + ret = -errno; + pr_warn("Couldn't open socket socket: %s\n", strerror(-ret)); + return ret; + } + + ret = ioctl(fd, SIOCETHTOOL, &ifr); + if (ret < 0) { + ret = -errno; + pr_debug("Error in ethtool ioctl: %s\n", strerror(-ret)); + goto out; + } + + ret = ch.rx_count + ch.combined_count; +out: + close(fd); + pr_debug("Got %d queues for ifname %s\n", ret, ifname); + return ret; +} + + +int sample_setup_maps(struct bpf_map **maps, const char *ifname) +{ + sample_n_cpus = libbpf_num_possible_cpus(); + + for (int i = 0; i < MAP_DEVMAP_XMIT_MULTI; i++) { + sample_map[i] = maps[i]; + int n_cpus; + + switch (i) { + case MAP_RX: + case MAP_CPUMAP_KTHREAD: + case MAP_DEVMAP_XMIT: + sample_map_count[i] = sample_n_cpus; + break; + case MAP_RXQ: + sample_n_rxqs = get_num_rxqs(ifname); + sample_map_count[i] = sample_n_rxqs > 0 ? sample_n_rxqs : 1; + break; + case MAP_REDIRECT_ERR: + sample_map_count[i] = + XDP_REDIRECT_ERR_MAX * sample_n_cpus; + break; + case MAP_EXCEPTION: + sample_map_count[i] = XDP_ACTION_MAX * sample_n_cpus; + break; + case MAP_CPUMAP_ENQUEUE: + if (__builtin_mul_overflow(sample_n_cpus, sample_n_cpus, &n_cpus)) + return -EOVERFLOW; + sample_map_count[i] = n_cpus; + break; + default: + return -EINVAL; + } + if (bpf_map__set_max_entries(sample_map[i], sample_map_count[i]) < 0) + return -errno; + } + sample_map[MAP_DEVMAP_XMIT_MULTI] = maps[MAP_DEVMAP_XMIT_MULTI]; + return 0; +} + +static int sample_setup_maps_mappings(void) +{ + for (int i = 0; i < MAP_DEVMAP_XMIT_MULTI; i++) { + size_t size = sample_map_count[i] * sizeof(struct datarec); + + sample_mmap[i] = mmap(NULL, size, PROT_READ | PROT_WRITE, + MAP_SHARED, bpf_map__fd(sample_map[i]), 0); + if (sample_mmap[i] == MAP_FAILED) + return -errno; + } + return 0; +} + +int __sample_init(int mask, int ifindex_from, int ifindex_to) +{ + sigset_t st; + + if (mask & SAMPLE_RXQ_STATS && sample_n_rxqs <= 0) { + pr_warn("Couldn't retrieve the number of RXQs, so can't enable RXQ stats\n"); + return -EINVAL; + } + + sigemptyset(&st); + sigaddset(&st, SIGQUIT); + sigaddset(&st, SIGINT); + sigaddset(&st, SIGTERM); + + if (sigprocmask(SIG_BLOCK, &st, NULL) < 0) + return -errno; + + sample_sig_fd = signalfd(-1, &st, SFD_CLOEXEC | SFD_NONBLOCK); + if (sample_sig_fd < 0) + return -errno; + + sample_mask = mask; + ifindex[0] = ifindex_from; + ifindex[1] = ifindex_to; + + return sample_setup_maps_mappings(); +} + +static void sample_summary_print(void) +{ + double num = sample_out.rx_cnt.num; + + if (sample_out.totals.rx) { + double pkts = sample_out.totals.rx; + + print_always(" Packets received : %'-10" PRIu64 "\n", + (uint64_t)sample_out.totals.rx); + print_always(" Average packets/s : %'-10.0f\n", + sample_round(pkts / num)); + } + if (sample_out.totals.redir) { + double pkts = sample_out.totals.redir; + + print_always(" Packets redirected : %'-10" PRIu64 "\n", + sample_out.totals.redir); + print_always(" Average redir/s : %'-10.0f\n", + sample_round(pkts / num)); + } + if (sample_out.totals.drop) + print_always(" Rx dropped : %'-10" PRIu64 "\n", + sample_out.totals.drop); + if (sample_out.totals.drop_xmit) + print_always(" Tx dropped : %'-10" PRIu64 "\n", + sample_out.totals.drop_xmit); + if (sample_out.totals.err) + print_always(" Errors recorded : %'-10" PRIu64 "\n", + sample_out.totals.err); + if (sample_out.totals.xmit) { + double pkts = sample_out.totals.xmit; + + print_always(" Packets transmitted : %'-10" PRIu64 "\n", + sample_out.totals.xmit); + print_always(" Average transmit/s : %'-10.0f\n", + sample_round(pkts / num)); + } +} + +void sample_teardown(void) +{ + size_t size; + + for (int i = 0; i < NUM_MAP; i++) { + size = sample_map_count[i] * sizeof(**sample_mmap); + munmap(sample_mmap[i], size); + } + sample_summary_print(); + close(sample_sig_fd); +} + +static int sample_stats_collect(struct stats_record *rec) +{ + int i; + + if (sample_mask & SAMPLE_RX_CNT) + map_collect_percpu(sample_mmap[MAP_RX], &rec->rx_cnt); + + if (sample_mask & SAMPLE_RXQ_STATS) + map_collect_rxqs(sample_mmap[MAP_RXQ], &rec->rxq_cnt); + + if (sample_mask & SAMPLE_REDIRECT_CNT) + map_collect_percpu(sample_mmap[MAP_REDIRECT_ERR], &rec->redir_err[0]); + + if (sample_mask & SAMPLE_REDIRECT_ERR_CNT) { + for (i = 1; i < XDP_REDIRECT_ERR_MAX; i++) + map_collect_percpu(&sample_mmap[MAP_REDIRECT_ERR][i * sample_n_cpus], + &rec->redir_err[i]); + } + + if (sample_mask & SAMPLE_CPUMAP_ENQUEUE_CNT) + for (i = 0; i < sample_n_cpus; i++) + map_collect_percpu(&sample_mmap[MAP_CPUMAP_ENQUEUE][i * sample_n_cpus], + &rec->enq[i]); + + if (sample_mask & SAMPLE_CPUMAP_KTHREAD_CNT) + map_collect_percpu(sample_mmap[MAP_CPUMAP_KTHREAD], + &rec->kthread); + + if (sample_mask & SAMPLE_EXCEPTION_CNT) + for (i = 0; i < XDP_ACTION_MAX; i++) + map_collect_percpu(&sample_mmap[MAP_EXCEPTION][i * sample_n_cpus], + &rec->exception[i]); + + if (sample_mask & SAMPLE_DEVMAP_XMIT_CNT) + map_collect_percpu(sample_mmap[MAP_DEVMAP_XMIT], &rec->devmap_xmit); + + if (sample_mask & SAMPLE_DEVMAP_XMIT_CNT_MULTI) { + if (map_collect_percpu_devmap(bpf_map__fd(sample_map[MAP_DEVMAP_XMIT_MULTI]), rec) < 0) + return -EINVAL; + } + return 0; +} + +static void sample_summary_update(struct sample_output *out) +{ + sample_out.totals.rx += out->totals.rx; + sample_out.totals.redir += out->totals.redir; + sample_out.totals.drop += out->totals.drop; + sample_out.totals.drop_xmit += out->totals.drop_xmit; + sample_out.totals.err += out->totals.err; + sample_out.totals.xmit += out->totals.xmit; + sample_out.rx_cnt.num++; +} + +static void sample_stats_print(int mask, struct stats_record *cur, + struct stats_record *prev, char *prog_name) +{ + struct sample_output out = {}; + + if (mask & SAMPLE_RX_CNT) + stats_get_rx_cnt(cur, prev, 0, &out); + if (mask & SAMPLE_REDIRECT_CNT) + stats_get_redirect_cnt(cur, prev, 0, &out); + if (mask & SAMPLE_REDIRECT_ERR_CNT) + stats_get_redirect_err_cnt(cur, prev, 0, &out); + if (mask & SAMPLE_EXCEPTION_CNT) + stats_get_exception_cnt(cur, prev, 0, &out); + if (mask & SAMPLE_DEVMAP_XMIT_CNT) + stats_get_devmap_xmit(cur, prev, 0, &out); + else if (mask & SAMPLE_DEVMAP_XMIT_CNT_MULTI) + stats_get_devmap_xmit_multi(cur, prev, 0, &out); + sample_summary_update(&out); + + stats_print(prog_name, mask, cur, prev, &out); +} + +void sample_switch_mode(void) +{ + sample_log_level ^= LL_DEBUG - 1; +} + +static int sample_signal_cb(void) +{ + struct signalfd_siginfo si; + int r; + + r = read(sample_sig_fd, &si, sizeof(si)); + if (r < 0) + return -errno; + + switch (si.ssi_signo) { + case SIGQUIT: + sample_switch_mode(); + printf("\n"); + break; + default: + printf("\n"); + return 1; + } + + return 0; +} + +/* Pointer swap trick */ +static void swap(struct stats_record **a, struct stats_record **b) +{ + struct stats_record *tmp; + + tmp = *a; + *a = *b; + *b = tmp; +} + +static int sample_timer_cb(int timerfd, struct stats_record **rec, + struct stats_record **prev) +{ + char line[64] = "Summary"; + int ret; + __u64 t; + + ret = read(timerfd, &t, sizeof(t)); + if (ret < 0) + return -errno; + + swap(prev, rec); + ret = sample_stats_collect(*rec); + if (ret < 0) + return ret; + + if (ifindex[0] && !(sample_mask & SAMPLE_SKIP_HEADING)) { + char fi[IFNAMSIZ]; + char to[IFNAMSIZ]; + const char *f, *t; + + f = t = NULL; + if (if_indextoname(ifindex[0], fi)) + f = fi; + if (if_indextoname(ifindex[1], to)) + t = to; + + snprintf(line, sizeof(line), "%s->%s", f ?: "?", t ?: "?"); + } + + sample_stats_print(sample_mask, *rec, *prev, line); + return 0; +} + +int sample_run(int interval, void (*post_cb)(void *), void *ctx) +{ + struct timespec ts = { interval, 0 }; + struct itimerspec its = { ts, ts }; + struct stats_record *rec, *prev; + struct pollfd pfd[2] = {}; + bool imm_exit = false; + const char *envval; + int timerfd, ret; + + envval = secure_getenv("XDP_SAMPLE_IMMEDIATE_EXIT"); + if (envval && envval[0] == '1' && envval[1] == '\0') { + pr_debug("XDP_SAMPLE_IMMEDIATE_EXIT envvar set, exiting immediately after setup\n"); + imm_exit = true; + } + + if (!interval) { + pr_warn("Incorrect interval 0\n"); + return -EINVAL; + } + sample_interval = interval; + /* Pretty print numbers */ + setlocale(LC_NUMERIC, "en_US.UTF-8"); + + timerfd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK); + if (timerfd < 0) + return -errno; + timerfd_settime(timerfd, 0, &its, NULL); + + pfd[0].fd = sample_sig_fd; + pfd[0].events = POLLIN; + + pfd[1].fd = timerfd; + pfd[1].events = POLLIN; + + ret = -ENOMEM; + rec = alloc_stats_record(); + if (!rec) + goto end; + prev = alloc_stats_record(); + if (!prev) + goto end_rec; + + ret = sample_stats_collect(rec); + if (ret < 0) + goto end_rec_prev; + + if (imm_exit) + goto end_rec_prev; + + for (;;) { + ret = poll(pfd, 2, -1); + if (ret < 0) { + if (errno == EINTR) + continue; + else + break; + } + + if (pfd[0].revents & POLLIN) + ret = sample_signal_cb(); + else if (pfd[1].revents & POLLIN) + ret = sample_timer_cb(timerfd, &rec, &prev); + + if (ret) + break; + + if (post_cb) + post_cb(ctx); + } + +end_rec_prev: + free_stats_record(prev); +end_rec: + free_stats_record(rec); +end: + close(timerfd); + + return ret; +} + +const char *get_driver_name(int ifindex) +{ + struct ethtool_drvinfo drv = {}; + char ifname[IF_NAMESIZE]; + static char drvname[32]; + struct ifreq ifr = {}; + int fd, r = 0; + + fd = socket(AF_INET, SOCK_DGRAM, 0); + if (fd < 0) + return "[error]"; + + if (!if_indextoname(ifindex, ifname)) + goto end; + + drv.cmd = ETHTOOL_GDRVINFO; + safe_strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name)); + ifr.ifr_data = (void *)&drv; + + r = ioctl(fd, SIOCETHTOOL, &ifr); + if (r) + goto end; + + safe_strncpy(drvname, drv.driver, sizeof(drvname)); + + close(fd); + return drvname; + +end: + r = errno; + close(fd); + return r == EOPNOTSUPP ? "loopback" : "[error]"; +} + +int get_mac_addr(int ifindex, void *mac_addr) +{ + char ifname[IF_NAMESIZE]; + struct ifreq ifr = {}; + int fd, r; + + fd = socket(AF_INET, SOCK_DGRAM, 0); + if (fd < 0) + return -errno; + + if (!if_indextoname(ifindex, ifname)) { + r = -errno; + goto end; + } + + safe_strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name)); + + r = ioctl(fd, SIOCGIFHWADDR, &ifr); + if (r) { + r = -errno; + goto end; + } + + memcpy(mac_addr, ifr.ifr_hwaddr.sa_data, 6 * sizeof(char)); + +end: + close(fd); + return r; +} diff --git a/lib/util/xdp_sample.h b/lib/util/xdp_sample.h new file mode 100644 index 0000000..701f83f --- /dev/null +++ b/lib/util/xdp_sample.h @@ -0,0 +1,133 @@ +// SPDX-License-Identifier: GPL-2.0-only +#ifndef XDP_SAMPLE_USER_H +#define XDP_SAMPLE_USER_H + +#include <bpf/libbpf.h> +#include <getopt.h> + +#include <xdp/xdp_sample_shared.h> + +enum stats_mask { + _SAMPLE_REDIRECT_MAP = 1U << 0, + SAMPLE_RX_CNT = 1U << 1, + SAMPLE_REDIRECT_ERR_CNT = 1U << 2, + SAMPLE_CPUMAP_ENQUEUE_CNT = 1U << 3, + SAMPLE_CPUMAP_KTHREAD_CNT = 1U << 4, + SAMPLE_EXCEPTION_CNT = 1U << 5, + SAMPLE_DEVMAP_XMIT_CNT = 1U << 6, + SAMPLE_REDIRECT_CNT = 1U << 7, + SAMPLE_REDIRECT_MAP_CNT = SAMPLE_REDIRECT_CNT | _SAMPLE_REDIRECT_MAP, + SAMPLE_REDIRECT_ERR_MAP_CNT = SAMPLE_REDIRECT_ERR_CNT | _SAMPLE_REDIRECT_MAP, + SAMPLE_DEVMAP_XMIT_CNT_MULTI = 1U << 8, + SAMPLE_SKIP_HEADING = 1U << 9, + SAMPLE_RXQ_STATS = 1U << 10, + SAMPLE_DROP_OK = 1U << 11, +}; + +enum sample_compat { + SAMPLE_COMPAT_CPUMAP_KTHREAD, + __SAMPLE_COMPAT_MAX +}; +#define SAMPLE_COMPAT_MAX __SAMPLE_COMPAT_MAX + +/* Exit return codes */ +#define EXIT_OK 0 +#define EXIT_FAIL 1 +#define EXIT_FAIL_OPTION 2 +#define EXIT_FAIL_XDP 3 +#define EXIT_FAIL_BPF 4 +#define EXIT_FAIL_MEM 5 + +int sample_setup_maps(struct bpf_map **maps, const char *ifname); +int __sample_init(int mask, int ifindex_from, int ifindex_to); +void sample_teardown(void); +int sample_run(int interval, void (*post_cb)(void *), void *ctx); +bool sample_is_compat(enum sample_compat compat_value); +bool sample_probe_cpumap_compat(void); +void sample_check_cpumap_compat(struct bpf_program *prog, + struct bpf_program *prog_compat); + +void sample_switch_mode(void); + +const char *get_driver_name(int ifindex); +int get_mac_addr(int ifindex, void *mac_addr); + +#pragma GCC diagnostic push +#ifndef __clang__ +#pragma GCC diagnostic ignored "-Wstringop-truncation" +#endif +__attribute__((unused)) +static inline char *safe_strncpy(char *dst, const char *src, size_t size) +{ + if (!size) + return dst; + strncpy(dst, src, size - 1); + dst[size - 1] = '\0'; + return dst; +} +#pragma GCC diagnostic pop + +#define __attach_tp(name) \ + ({ \ + if (bpf_program__type(skel->progs.name) != BPF_PROG_TYPE_TRACING)\ + return -EINVAL; \ + skel->links.name = bpf_program__attach(skel->progs.name); \ + if (!skel->links.name) \ + return -errno; \ + }) + +#define __attach_tp_compat(name, name_compat, _compat) \ + ({ \ + if (sample_is_compat(SAMPLE_COMPAT_ ## _compat)) \ + __attach_tp(name); \ + else \ + __attach_tp(name_compat); \ + }) + +#define sample_init_pre_load(skel, ifname) \ + ({ \ + skel->rodata->nr_cpus = libbpf_num_possible_cpus(); \ + sample_check_cpumap_compat(skel->progs.tp_xdp_cpumap_kthread, \ + skel->progs.tp_xdp_cpumap_compat); \ + sample_setup_maps((struct bpf_map *[]){ \ + skel->maps.rx_cnt, skel->maps.rxq_cnt, \ + skel->maps.redir_err_cnt, \ + skel->maps.cpumap_enqueue_cnt, \ + skel->maps.cpumap_kthread_cnt, \ + skel->maps.exception_cnt, skel->maps.devmap_xmit_cnt, \ + skel->maps.devmap_xmit_cnt_multi}, ifname); \ + }) + +#define DEFINE_SAMPLE_INIT(name) \ + static int sample_init(struct name *skel, int sample_mask, \ + int ifindex_from, int ifindex_to) \ + { \ + int ret; \ + ret = __sample_init(sample_mask, ifindex_from, \ + ifindex_to); \ + if (ret < 0) \ + return ret; \ + if (sample_mask & SAMPLE_REDIRECT_MAP_CNT) \ + __attach_tp(tp_xdp_redirect_map); \ + if (sample_mask & SAMPLE_REDIRECT_CNT) \ + __attach_tp(tp_xdp_redirect); \ + if (sample_mask & SAMPLE_REDIRECT_ERR_MAP_CNT) \ + __attach_tp(tp_xdp_redirect_map_err); \ + if (sample_mask & SAMPLE_REDIRECT_ERR_CNT) \ + __attach_tp(tp_xdp_redirect_err); \ + if (sample_mask & SAMPLE_CPUMAP_ENQUEUE_CNT) \ + __attach_tp(tp_xdp_cpumap_enqueue); \ + if (sample_mask & SAMPLE_CPUMAP_KTHREAD_CNT) \ + __attach_tp_compat(tp_xdp_cpumap_kthread, \ + tp_xdp_cpumap_compat, \ + CPUMAP_KTHREAD); \ + if (sample_mask & SAMPLE_EXCEPTION_CNT) \ + __attach_tp(tp_xdp_exception); \ + if (sample_mask & SAMPLE_DEVMAP_XMIT_CNT) \ + __attach_tp(tp_xdp_devmap_xmit); \ + if (sample_mask & SAMPLE_DEVMAP_XMIT_CNT_MULTI) \ + __attach_tp(tp_xdp_devmap_xmit_multi); \ + return 0; \ + } + +#endif diff --git a/lib/util/xpcapng.c b/lib/util/xpcapng.c new file mode 100644 index 0000000..e453b88 --- /dev/null +++ b/lib/util/xpcapng.c @@ -0,0 +1,635 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Description: + * Simple PcapNG library developed from scratch as no library existed that + * met the requirements for xdpdump. It can also be used by other XDP + * applications that would like to capture packets for debugging purposes. + */ + +/***************************************************************************** + * Include files + *****************************************************************************/ +#include <ctype.h> +#include <errno.h> +#include <fcntl.h> +#include <inttypes.h> +#include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include <sys/uio.h> + +#include "xpcapng.h" + +/***************************************************************************** + * Simple roundup() macro + *****************************************************************************/ +#ifndef roundup +#define roundup(x, y) ( \ +{ \ + typeof(y) __y = y; \ + (((x) + (__y - 1)) / __y) * __y; \ +} \ +) +#endif + +/***************************************************************************** + * pcapng_dumper structure + *****************************************************************************/ +struct xpcapng_dumper { + int pd_fd; + uint32_t pd_interfaces; +}; + +/***************************************************************************** + * general pcapng block and option definitions + *****************************************************************************/ +enum pcapng_block_types { + PCAPNG_SECTION_BLOCK = 0x0A0D0D0A, + PCAPNG_INTERFACE_BLOCK = 1, + PCAPNG_PACKET_BLOCK, + PCAPNG_SIMPLE_PACKET_BLOCK, + PCAPNG_NAME_RESOLUTION_BLOCK, + PCAPNG_INTERFACE_STATS_BLOCK, + PCAPNG_ENHANCED_PACKET_BLOCK +}; + +struct pcapng_option { + uint16_t po_type; + uint16_t po_length; + uint8_t po_data[]; +} __attribute__((__packed__)); + +enum pcapng_opt { + PCAPNG_OPT_END = 0, + PCAPNG_OPT_COMMENT = 1, + PCAPNG_OPT_CUSTOME_2988 = 2988, + PCAPNG_OPT_CUSTOME_2989 = 2989, + PCAPNG_OPT_CUSTOME_19372 = 19372, + PCAPNG_OPT_CUSTOME_19373 = 29373 +}; + +/***************************************************************************** + * pcapng section header block definitions + *****************************************************************************/ +struct pcapng_section_header_block { + uint32_t shb_block_type; + uint32_t shb_block_length; + uint32_t shb_byte_order_magic; + uint16_t shb_major_version; + uint16_t shb_minor_version; + uint64_t shb_section_length; + uint8_t shb_options[]; + /* The options are followed by another: + * uint32_t shb_block_length; + */ +} __attribute__((__packed__)); + +#define PCAPNG_BYTE_ORDER_MAGIC 0x1A2B3C4D +#define PCAPNG_MAJOR_VERSION 1 +#define PCAPNG_MINOR_VERSION 0 + +enum pcapng_opt_shb { + PCAPNG_OPT_SHB_HARDWARE = 2, + PCAPNG_OPT_SHB_OS, + PCAPNG_OPT_SHB_USERAPPL +}; + +/***************************************************************************** + * pcapng interface description block definitions + *****************************************************************************/ +struct pcapng_interface_description_block { + uint32_t idb_block_type; + uint32_t idb_block_length; + uint16_t idb_link_type; + uint16_t idb_reserved; + uint32_t idb_snap_len; + uint8_t idb_options[]; + /* The options are followed by another: + * uint32_t idb_block_length; + */ +} __attribute__((__packed__)); + +enum pcapng_opt_idb { + PCAPNG_OPT_IDB_IF_NAME = 2, + PCAPNG_OPT_IDB_IF_DESCRIPTION, + PCAPNG_OPT_IDB_IF_IPV4_ADDR, + PCAPNG_OPT_IDB_IF_IPV6_ADDR, + PCAPNG_OPT_IDB_IF_MAC_ADDR, + PCAPNG_OPT_IDB_IF_EUI_ADDR, + PCAPNG_OPT_IDB_IF_SPEED, + PCAPNG_OPT_IDB_IF_TSRESOL, + PCAPNG_OPT_IDB_IF_TZONE, + PCAPNG_OPT_IDB_IF_FILTER, + PCAPNG_OPT_IDB_IF_OS, + PCAPNG_OPT_IDB_IF_FCSLEN, + PCAPNG_OPT_IDB_IF_TOFFSET, + PCAPNG_OPT_IDB_IF_HARDWARE +}; + +/***************************************************************************** + * pcapng interface description block definitions + *****************************************************************************/ +struct pcapng_enhanced_packet_block { + uint32_t epb_block_type; + uint32_t epb_block_length; + uint32_t epb_interface_id; + uint32_t epb_timestamp_hi; + uint32_t epb_timestamp_low; + uint32_t epb_captured_length; + uint32_t epb_original_length; + uint8_t epb_packet_data[]; + /* The packet data is followed by: + * uint8_t epb_options[]; + * uint32_t epb_block_length; + */ +} __attribute__((__packed__)); + +enum pcapng_opt_epb { + PCAPNG_OPT_EPB_FLAGS = 2, + PCAPNG_OPT_EPB_HASH, + PCAPNG_OPT_EPB_DROPCOUNT, + PCAPNG_OPT_EPB_PACKETID, + PCAPNG_OPT_EPB_QUEUE, + PCAPNG_OPT_EPB_VERDICT +}; + +enum pcapng_epb_vedict_type { + PCAPNG_EPB_VEDRICT_TYPE_HARDWARE = 0, + PCAPNG_EPB_VEDRICT_TYPE_EBPF_TC, + PCAPNG_EPB_VEDRICT_TYPE_EBPF_XDP +}; + +/***************************************************************************** + * pcapng_get_option_length() + *****************************************************************************/ +static size_t pcapng_get_option_length(size_t len) +{ + return roundup(sizeof(struct pcapng_option) + len, sizeof(uint32_t)); +} + +/***************************************************************************** + * pcapng_add_option() + *****************************************************************************/ +static struct pcapng_option *pcapng_add_option(struct pcapng_option *opt, + uint16_t type, uint16_t length, + const void *data) +{ + if (opt == NULL) + return NULL; + + opt->po_type = type; + opt->po_length = length; + if (data) + memcpy(opt->po_data, data, length); + + return (struct pcapng_option *) + ((uint8_t *)opt + pcapng_get_option_length(length)); +} + +/***************************************************************************** + * pcapng_write_shb() + *****************************************************************************/ +static bool pcapng_write_shb(struct xpcapng_dumper *pd, const char *comment, + const char *hardware, const char *os, + const char *user_application) +{ + int rc; + size_t shb_length; + struct pcapng_section_header_block *shb; + struct pcapng_option *opt; + + if (pd == NULL) { + errno = EINVAL; + return false; + } + + /* First calculate the total length of the SHB. */ + shb_length = sizeof(*shb); + + if (comment) + shb_length += pcapng_get_option_length(strlen(comment)); + + if (hardware) + shb_length += pcapng_get_option_length(strlen(hardware)); + + if (os) + shb_length += pcapng_get_option_length(strlen(os)); + + if (user_application) + shb_length += pcapng_get_option_length( + strlen(user_application)); + + shb_length += pcapng_get_option_length(0); + shb_length += sizeof(uint32_t); + + /* Allocate the SHB and fill it. */ + shb = calloc(shb_length, 1); + if (shb == NULL) { + errno = ENOMEM; + return false; + } + + shb->shb_block_type = PCAPNG_SECTION_BLOCK; + shb->shb_block_length = shb_length; + shb->shb_byte_order_magic = PCAPNG_BYTE_ORDER_MAGIC; + shb->shb_major_version = PCAPNG_MAJOR_VERSION; + shb->shb_minor_version = PCAPNG_MINOR_VERSION; + shb->shb_section_length = UINT64_MAX; + + /* Add the options and block_length value */ + opt = (struct pcapng_option *) &shb->shb_options; + + if (comment) + opt = pcapng_add_option(opt, PCAPNG_OPT_COMMENT, + strlen(comment), comment); + + if (hardware) + opt = pcapng_add_option(opt, PCAPNG_OPT_SHB_HARDWARE, + strlen(hardware), hardware); + + if (os) + opt = pcapng_add_option(opt, PCAPNG_OPT_SHB_OS, + strlen(os), os); + + if (user_application) + opt = pcapng_add_option(opt, PCAPNG_OPT_SHB_USERAPPL, + strlen(user_application), + user_application); + /* WARNING: If a new option is added, make sure the length calculation + * above is also updated! + */ + + opt = pcapng_add_option(opt, PCAPNG_OPT_END, 0, NULL); + memcpy(opt, &shb->shb_block_length, sizeof(shb->shb_block_length)); + + /* Write the SHB, and free its memory. */ + rc = write(pd->pd_fd, shb, shb_length); + free(shb); + + if ((size_t)rc != shb_length) + return false; + + return true; +} + +/***************************************************************************** + * pcapng_write_idb() + *****************************************************************************/ +static bool pcapng_write_idb(struct xpcapng_dumper *pd, const char *name, + uint16_t snap_len, const char *description, + const uint8_t *mac, uint64_t speed, + uint8_t ts_resolution, const char *hardware) +{ + int rc; + size_t idb_length; + struct pcapng_interface_description_block *idb; + struct pcapng_option *opt; + + if (pd == NULL) { + errno = EINVAL; + return false; + } + + /* First calculate the total length of the IDB. */ + idb_length = sizeof(*idb); + + if (name) + idb_length += pcapng_get_option_length(strlen(name)); + + if (description) + idb_length += pcapng_get_option_length(strlen(description)); + + if (mac) + idb_length += pcapng_get_option_length(6); + + if (speed) + idb_length += pcapng_get_option_length(sizeof(uint64_t)); + + if (ts_resolution != 6 && ts_resolution != 0) + idb_length += pcapng_get_option_length(1); + + if (hardware) + idb_length += pcapng_get_option_length(strlen(hardware)); + + idb_length += pcapng_get_option_length(0); + idb_length += sizeof(uint32_t); + + /* Allocate the IDB and fill it. */ + idb = calloc(idb_length, 1); + if (idb == NULL) { + errno = ENOMEM; + return false; + } + + idb->idb_block_type = PCAPNG_INTERFACE_BLOCK; + idb->idb_block_length = idb_length; + idb->idb_link_type = 1; /* Ethernet */ + idb->idb_snap_len = snap_len; + + /* Add the options and block_length value */ + opt = (struct pcapng_option *) &idb->idb_options; + + if (name) + opt = pcapng_add_option(opt, PCAPNG_OPT_IDB_IF_NAME, + strlen(name), name); + + if (description) + opt = pcapng_add_option(opt, PCAPNG_OPT_IDB_IF_DESCRIPTION, + strlen(description), description); + + if (mac) + opt = pcapng_add_option(opt, PCAPNG_OPT_IDB_IF_MAC_ADDR, 6, + mac); + + if (speed) + opt = pcapng_add_option(opt, PCAPNG_OPT_IDB_IF_SPEED, + sizeof(uint64_t), &speed); + + if (ts_resolution != 6 && ts_resolution != 0) + opt = pcapng_add_option(opt, PCAPNG_OPT_IDB_IF_TSRESOL, + sizeof(uint8_t), &ts_resolution); + + if (hardware) + opt = pcapng_add_option(opt, PCAPNG_OPT_IDB_IF_HARDWARE, + strlen(hardware), hardware); + /* WARNING: If a new option is added, make sure the length calculation + * above is also updated! + */ + + opt = pcapng_add_option(opt, PCAPNG_OPT_END, 0, NULL); + memcpy(opt, &idb->idb_block_length, sizeof(idb->idb_block_length)); + + /* Write the IDB, and free it's memory. */ + rc = write(pd->pd_fd, idb, idb_length); + free(idb); + + if ((size_t)rc != idb_length) + return false; + + return true; +} + +/***************************************************************************** + * pcapng_write_epb() + *****************************************************************************/ +static bool pcapng_write_epb(struct xpcapng_dumper *pd, uint32_t ifid, + const uint8_t *pkt, uint32_t len, + uint32_t caplen, uint64_t timestamp, + struct xpcapng_epb_options_s *epb_options) +{ + int i = 0; + int rc; + size_t pad_length; + size_t com_length = 0; + size_t epb_length; + struct pcapng_enhanced_packet_block epb; + struct pcapng_option *opt; + struct iovec iov[7]; + static uint8_t pad[4] = {0, 0, 0, 0}; + uint8_t options[8 + 12 + 12 + 8 + 16 + 4 + 4]; + /* PCAPNG_OPT_EPB_FLAGS[8] + + * PCAPNG_OPT_EPB_DROPCOUNT[12] + + * PCAPNG_OPT_EPB_PACKETID[12] + + * PCAPNG_OPT_EPB_QUEUE[8] + + * PCAPNG_OPT_EPB_VERDICT[16] + + * PCAPNG_OPT_END[4] + + * epb_block_length + */ + static struct xdp_verdict { + uint8_t type; + int64_t verdict; + }__attribute__((__packed__)) verdict = { + PCAPNG_EPB_VEDRICT_TYPE_EBPF_XDP, 0 }; + + if (pd == NULL) { + errno = EINVAL; + return false; + } + + /* First calculate the total length of the EPB. */ + pad_length = roundup(caplen, sizeof(uint32_t)) - caplen; + + epb_length = sizeof(epb); + epb_length += caplen + pad_length; + + if (epb_options->flags) + epb_length += pcapng_get_option_length(sizeof(uint32_t)); + + if (epb_options->dropcount) + epb_length += pcapng_get_option_length(sizeof(uint64_t)); + + if (epb_options->packetid) + epb_length += pcapng_get_option_length(sizeof(uint64_t)); + + if (epb_options->queue) + epb_length += pcapng_get_option_length(sizeof(uint32_t)); + + if (epb_options->xdp_verdict) + epb_length += pcapng_get_option_length(sizeof(verdict)); + + if (epb_options->comment) { + com_length = strlen(epb_options->comment); + epb_length += pcapng_get_option_length(com_length); + } + + epb_length += pcapng_get_option_length(0); + epb_length += sizeof(uint32_t); + + /* Fill in the EPB. */ + epb.epb_block_type = PCAPNG_ENHANCED_PACKET_BLOCK; + epb.epb_block_length = epb_length; + epb.epb_interface_id = ifid; + epb.epb_timestamp_hi = timestamp >> 32; + epb.epb_timestamp_low = (uint32_t) timestamp; + epb.epb_captured_length = caplen; + epb.epb_original_length = len; + + /* Add the flag/end option and block_length value */ + opt = (struct pcapng_option *) options; + + if (epb_options->flags) + opt = pcapng_add_option(opt, PCAPNG_OPT_EPB_FLAGS, + sizeof(uint32_t), &epb_options->flags); + + if (epb_options->dropcount) + opt = pcapng_add_option(opt, PCAPNG_OPT_EPB_DROPCOUNT, + sizeof(uint64_t), + &epb_options->dropcount); + + if (epb_options->packetid) + opt = pcapng_add_option(opt, PCAPNG_OPT_EPB_PACKETID, + sizeof(uint64_t), + epb_options->packetid); + + if (epb_options->queue) + opt = pcapng_add_option(opt, PCAPNG_OPT_EPB_QUEUE, + sizeof(uint32_t), epb_options->queue); + + if (epb_options->xdp_verdict) { + verdict.verdict = *epb_options->xdp_verdict; + opt = pcapng_add_option(opt, PCAPNG_OPT_EPB_VERDICT, + sizeof(verdict), &verdict); + } + /* WARNING: If a new option is added, make sure the length calculation + * and the options[] variable above are also updated! + */ + + opt = pcapng_add_option(opt, PCAPNG_OPT_END, 0, NULL); + memcpy(opt, &epb.epb_block_length, sizeof(epb.epb_block_length)); + + /* Write the EPB in parts, including the options, this looks not as + * straightforward as pcapng_write_idb() but here we would like to + * avoid as many memcopy's as possible. + */ + + /* Add base EPB structure. */ + iov[i].iov_base = &epb; + iov[i++].iov_len = sizeof(epb); + + /* Add Packet Data. */ + iov[i].iov_base = (void *)pkt; + iov[i++].iov_len = caplen; + + /* Add Packet Data padding if needed. */ + if (pad_length > 0) { + iov[i].iov_base = pad; + iov[i++].iov_len = pad_length; + } + + /* Add comment if supplied */ + if (epb_options->comment) { + uint16_t opt[2] = {PCAPNG_OPT_COMMENT, com_length}; + size_t opt_pad = roundup(com_length, + sizeof(uint32_t)) - com_length; + /* Add option header. */ + iov[i].iov_base = opt; + iov[i++].iov_len = sizeof(opt); + + /* Add actual comment string. */ + iov[i].iov_base = (void *)epb_options->comment; + iov[i++].iov_len = com_length; + + /* Add padding to uint32_t if needed. */ + if (opt_pad) { + iov[i].iov_base = pad; + iov[i++].iov_len = opt_pad; + } + } + + /* Write other options and final EPB size. */ + iov[i].iov_base = options; + iov[i++].iov_len = 8 + (epb_options->flags ? 8 : 0) + + (epb_options->dropcount ? 12 : 0) + + (epb_options->packetid ? 12 : 0) + + (epb_options->queue ? 8 : 0) + + (epb_options->xdp_verdict ? 16 : 0); + rc = writev(pd->pd_fd, iov, i); + if ((size_t)rc != epb_length) + return false; + + return true; +} + +/***************************************************************************** + * xpcapng_dump_open() + *****************************************************************************/ +struct xpcapng_dumper *xpcapng_dump_open(const char *file, + const char *comment, + const char *hardware, + const char *os, + const char *user_application) +{ + struct xpcapng_dumper *pd = NULL; + + if (file == NULL) { + errno = EINVAL; + goto error_exit; + } + + pd = calloc(sizeof(*pd), 1); + if (pd == NULL) { + errno = ENOMEM; + goto error_exit; + } + pd->pd_fd = -1; + + if (strcmp(file, "-") == 0) { + pd->pd_fd = STDOUT_FILENO; + } else { + pd->pd_fd = open(file, O_WRONLY | O_CREAT | O_TRUNC, 0600); + if (pd->pd_fd < 0) + goto error_exit; + } + + if (!pcapng_write_shb(pd, comment, hardware, os, user_application)) + goto error_exit; + + return pd; + +error_exit: + if (pd) { + if (pd->pd_fd >= 0 && pd->pd_fd != STDOUT_FILENO) + close(pd->pd_fd); + + free(pd); + } + return NULL; +} + +/***************************************************************************** + * xpcapng_dump_close() + *****************************************************************************/ +void xpcapng_dump_close(struct xpcapng_dumper *pd) +{ + if (pd == NULL) + return; + + if (pd->pd_fd < 0 && pd->pd_fd != STDOUT_FILENO) + close(pd->pd_fd); + + free(pd); +} + +/***************************************************************************** + * xpcapng_dump_flush() + *****************************************************************************/ +int xpcapng_dump_flush(struct xpcapng_dumper *pd) +{ + if (pd != NULL) + return fsync(pd->pd_fd); + + errno = EINVAL; + return -1; +} + +/***************************************************************************** + * pcapng_dump_add_interface() + *****************************************************************************/ +int xpcapng_dump_add_interface(struct xpcapng_dumper *pd, uint16_t snap_len, + const char *name, const char *description, + const uint8_t *mac, uint64_t speed, + uint8_t ts_resolution, const char *hardware) +{ + if (!pcapng_write_idb(pd, name, snap_len, description, mac, speed, + ts_resolution, hardware)) + return -1; + + return pd->pd_interfaces++; +} + +/***************************************************************************** + * xpcapng_dump_enhanced_pkt() + *****************************************************************************/ +bool xpcapng_dump_enhanced_pkt(struct xpcapng_dumper *pd, uint32_t ifid, + const uint8_t *pkt, uint32_t len, + uint32_t caplen, uint64_t timestamp, + struct xpcapng_epb_options_s *options) +{ + struct xpcapng_epb_options_s default_options = {}; + + return pcapng_write_epb(pd, ifid, pkt, len, caplen, timestamp, + options ?: &default_options); +} diff --git a/lib/util/xpcapng.h b/lib/util/xpcapng.h new file mode 100644 index 0000000..1590a4c --- /dev/null +++ b/lib/util/xpcapng.h @@ -0,0 +1,58 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +/***************************************************************************** + * Multiple include protection + *****************************************************************************/ +#ifndef __XPCAPNG_H_ +#define __XPCAPNG_H_ + +/***************************************************************************** + * Handle + *****************************************************************************/ +struct xpcapng_dumper; + +/***************************************************************************** + * Flag variables + *****************************************************************************/ +enum xpcapng_epb_flags { + PCAPNG_EPB_FLAG_INBOUND = 0x1, + PCAPNG_EPB_FLAG_OUTBOUND = 0x2 +}; + +/***************************************************************************** + * EPB options structure + *****************************************************************************/ +struct xpcapng_epb_options_s { + enum xpcapng_epb_flags flags; + uint64_t dropcount; + uint64_t *packetid; + uint32_t *queue; + int64_t *xdp_verdict; + const char *comment; +}; + +/***************************************************************************** + * APIs + *****************************************************************************/ +extern struct xpcapng_dumper *xpcapng_dump_open(const char *file, + const char *comment, + const char *hardware, + const char *os, + const char *user_application); +extern void xpcapng_dump_close(struct xpcapng_dumper *pd); +extern int xpcapng_dump_flush(struct xpcapng_dumper *pd); +extern int xpcapng_dump_add_interface(struct xpcapng_dumper *pd, + uint16_t snap_len, + const char *name, const char *description, + const uint8_t *mac, uint64_t speed, + uint8_t ts_resolution, + const char *hardware); +extern bool xpcapng_dump_enhanced_pkt(struct xpcapng_dumper *pd, uint32_t ifid, + const uint8_t *pkt, uint32_t len, + uint32_t caplen, uint64_t timestamp, + struct xpcapng_epb_options_s *options); + +/***************************************************************************** + * End-of include file + *****************************************************************************/ +#endif /* __XPCAPNG_H_ */ |