Commit 280b058d authored by Jesper Dangaard Brouer's avatar Jesper Dangaard Brouer Committed by David S. Miller
Browse files

samples/bpf: xdp_monitor also record xdp_exception tracepoint 



Also monitor the tracepoint xdp_exception.  This tracepoint is usually
invoked by the drivers.  Programs themselves can activate this by
returning XDP_ABORTED, which will drop the packet but also trigger the
tracepoint.  This is useful for distinguishing intentional (XDP_DROP)
vs. ebpf-program error cases that cased a drop (XDP_ABORTED).

Drivers also use this tracepoint for reporting on XDP actions that are
unknown to the specific driver.  This can help the user to detect if a
driver e.g. doesn't implement XDP_REDIRECT yet.

Signed-off-by: default avatarJesper Dangaard Brouer <brouer@redhat.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent f4ce0a01

samples/bpf/xdp_monitor_kern.c

+37 −1
Original line number Diff line number Diff line
@@ -13,6 +13,14 @@ struct bpf_map_def SEC("maps") redirect_err_cnt = { 
	/* TODO: have entries for all possible errno's */

};



#define XDP_UNKNOWN	XDP_REDIRECT + 1

struct bpf_map_def SEC("maps") exception_cnt = {

	.type		= BPF_MAP_TYPE_PERCPU_ARRAY,

	.key_size	= sizeof(u32),

	.value_size	= sizeof(u64),

	.max_entries	= XDP_UNKNOWN + 1,

};



/* Tracepoint format: /sys/kernel/debug/tracing/events/xdp/xdp_redirect/format

 * Code in:                kernel/include/trace/events/xdp.h

 */
@@ -44,7 +52,7 @@ int xdp_redirect_collect_stat(struct xdp_redirect_ctx *ctx) 


	cnt  = bpf_map_lookup_elem(&redirect_err_cnt, &key);

	if (!cnt)

		return 0;

		return 1;

	*cnt += 1;



	return 0; /* Indicate event was filtered (no further processing)*/
@@ -82,3 +90,31 @@ int trace_xdp_redirect_map(struct xdp_redirect_ctx *ctx) 
{

	return xdp_redirect_collect_stat(ctx);

}



/* Tracepoint format: /sys/kernel/debug/tracing/events/xdp/xdp_exception/format

 * Code in:                kernel/include/trace/events/xdp.h

 */

struct xdp_exception_ctx {

	u64 __pad;	// First 8 bytes are not accessible by bpf code

	int prog_id;	//	offset:8;  size:4; signed:1;

	u32 act;	//	offset:12; size:4; signed:0;

	int ifindex;	//	offset:16; size:4; signed:1;

};



SEC("tracepoint/xdp/xdp_exception")

int trace_xdp_exception(struct xdp_exception_ctx *ctx)

{

	u64 *cnt;;

	u32 key;



	key = ctx->act;

	if (key > XDP_REDIRECT)

		key = XDP_UNKNOWN;



	cnt = bpf_map_lookup_elem(&exception_cnt, &key);

	if (!cnt)

		return 1;

	*cnt += 1;



	return 0;

}

samples/bpf/xdp_monitor_user.c

+84 −24
Original line number Diff line number Diff line
@@ -89,6 +89,23 @@ static const char *err2str(int err) 
		return redir_names[err];

	return NULL;

}

/* enum xdp_action */

#define XDP_UNKNOWN	XDP_REDIRECT + 1

#define XDP_ACTION_MAX (XDP_UNKNOWN + 1)

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 const char *action2str(int action)

{

	if (action < XDP_ACTION_MAX)

		return xdp_action_names[action];

	return NULL;

}



struct record {

	__u64 counter;
@@ -97,6 +114,7 @@ struct record { 


struct stats_record {

	struct record xdp_redir[REDIR_RES_MAX];

	struct record xdp_exception[XDP_ACTION_MAX];

};



static void stats_print_headers(bool err_only)
@@ -104,39 +122,72 @@ static void stats_print_headers(bool err_only) 
	if (err_only)

		printf("\n%s\n", __doc_err_only__);



	printf("%-14s %-10s %-18s %-9s\n",

	       "XDP_REDIRECT", "pps ", "pps-human-readable", "measure-period");

	printf("%-14s %-11s %-10s %-18s %-9s\n",

	       "ACTION", "result", "pps ", "pps-human-readable", "measure-period");

}



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 calc_pps(struct record *r, struct record *p, double period)

{

	__u64 packets = 0;

	double pps = 0;



	if (period > 0) {

		packets = r->counter - p->counter;

		pps = packets / period;

	}

	return pps;

}



static void stats_print(struct stats_record *rec,

			struct stats_record *prev,

			bool err_only)

{

	double period = 0, pps = 0;

	struct record *r, *p;

	int i = 0;



	char *fmt = "%-14s %-11s %-10.0f %'-18.0f %f\n";



	/* tracepoint: xdp:xdp_redirect_* */

	if (err_only)

		i = REDIR_ERROR;



	for (; i < REDIR_RES_MAX; i++) {

		struct record *r = &rec->xdp_redir[i];

		struct record *p = &prev->xdp_redir[i];

		__u64 period  = 0;

		__u64 packets = 0;

		double pps = 0;

		double period_ = 0;

		r = &rec->xdp_redir[i];

		p = &prev->xdp_redir[i];



		if (p->timestamp) {

			packets = r->counter - p->counter;

			period  = r->timestamp - p->timestamp;

			if (period > 0) {

				period_ = ((double) period / NANOSEC_PER_SEC);

				pps = packets / period_;

			period = calc_period(r, p);

			pps = calc_pps(r, p, period);

		}

		printf(fmt, "XDP_REDIRECT", err2str(i), pps, pps, period);

	}



		printf("%-14s %-10.0f %'-18.0f %f\n",

		       err2str(i), pps, pps, period_);

	/* tracepoint: xdp:xdp_exception */

	for (i = 0; i < XDP_ACTION_MAX; i++) {

		r = &rec->xdp_exception[i];

		p = &prev->xdp_exception[i];

		if (p->timestamp) {

			period = calc_period(r, p);

			pps = calc_pps(r, p, period);

		}

		if (pps > 0)

			printf(fmt, action2str(i), "Exception",

			       pps, pps, period);

	}

	printf("\n");

}



static __u64 get_key32_value64_percpu(int fd, __u32 key)
@@ -160,25 +211,33 @@ static __u64 get_key32_value64_percpu(int fd, __u32 key) 
	return sum;

}



static bool stats_collect(int fd, struct stats_record *rec)

static bool stats_collect(struct stats_record *rec)

{

	int fd;

	int i;



	/* TODO: Detect if someone unloaded the perf event_fd's, as

	 * this can happen by someone running perf-record -e

	 */



	fd = map_data[0].fd; /* map0: redirect_err_cnt */

	for (i = 0; i < REDIR_RES_MAX; i++) {

		rec->xdp_redir[i].timestamp = gettime();

		rec->xdp_redir[i].counter = get_key32_value64_percpu(fd, i);

	}



	fd = map_data[1].fd; /* map1: exception_cnt */

	for (i = 0; i < XDP_ACTION_MAX; i++) {

		rec->xdp_exception[i].timestamp = gettime();

		rec->xdp_exception[i].counter = get_key32_value64_percpu(fd, i);

	}



	return true;

}



static void stats_poll(int interval, bool err_only)

{

	struct stats_record rec, prev;

	int map_fd;



	memset(&rec, 0, sizeof(rec));
@@ -190,16 +249,17 @@ static void stats_poll(int interval, bool err_only) 
		printf("\n%s", __doc__);



	/* TODO Need more advanced stats on error types */

	if (verbose)

		printf(" - Stats map: %s\n", map_data[0].name);

	map_fd = map_data[0].fd;



	stats_print_headers(err_only);

	if (verbose) {

		printf(" - Stats map0: %s\n", map_data[0].name);

		printf(" - Stats map1: %s\n", map_data[1].name);

		printf("\n");

	}

	fflush(stdout);



	while (1) {

		memcpy(&prev, &rec, sizeof(rec));

		stats_collect(map_fd, &rec);

		stats_collect(&rec);

		stats_print_headers(err_only);

		stats_print(&rec, &prev, err_only);

		fflush(stdout);

		sleep(interval);

CRA Git | Maintained and supported by SUSTech CRA and CCSE