[ceph.git] / ceph / src / spdk / dpdk / app / test-pmd / bpf_cmd.c

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright(c) 2018 Intel Corporation
 */

#include <stdio.h>
#include <rte_mbuf.h>
#include <rte_ethdev.h>
#include <rte_flow.h>
#include <rte_bpf_ethdev.h>

#include <cmdline.h>
#include <cmdline_parse.h>
#include <cmdline_parse_num.h>
#include <cmdline_parse_string.h>

#include "testpmd.h"

static const struct rte_bpf_xsym bpf_xsym[] = {
	{
		.name = RTE_STR(stdout),
		.type = RTE_BPF_XTYPE_VAR,
		.var = {
			.val = &stdout,
			.desc = {
				.type = RTE_BPF_ARG_PTR,
				.size = sizeof(stdout),
			},
		},
	},
	{
		.name = RTE_STR(rte_pktmbuf_dump),
		.type = RTE_BPF_XTYPE_FUNC,
		.func = {
			.val = (void *)rte_pktmbuf_dump,
			.nb_args = 3,
			.args = {
				[0] = {
					.type = RTE_BPF_ARG_RAW,
					.size = sizeof(uintptr_t),
				},
				[1] = {
					.type = RTE_BPF_ARG_PTR_MBUF,
					.size = sizeof(struct rte_mbuf),
				},
				[2] = {
					.type = RTE_BPF_ARG_RAW,
					.size = sizeof(uint32_t),
				},
			},
		},
	},
};

/* *** load BPF program *** */
struct cmd_bpf_ld_result {
	cmdline_fixed_string_t bpf;
	cmdline_fixed_string_t dir;
	uint8_t port;
	uint16_t queue;
	cmdline_fixed_string_t op;
	cmdline_fixed_string_t flags;
	cmdline_fixed_string_t prm;
};

static void
bpf_parse_flags(const char *str, struct rte_bpf_arg *arg, uint32_t *flags)
{
	uint32_t i, v;

	*flags = RTE_BPF_ETH_F_NONE;
	arg->type = RTE_BPF_ARG_PTR;
	arg->size = mbuf_data_size;

	for (i = 0; str[i] != 0; i++) {
		v = toupper(str[i]);
		if (v == 'J')
			*flags |= RTE_BPF_ETH_F_JIT;
		else if (v == 'M') {
			arg->type = RTE_BPF_ARG_PTR_MBUF;
			arg->size = sizeof(struct rte_mbuf);
			arg->buf_size = mbuf_data_size;
		} else if (v == '-')
			continue;
		else
			printf("unknown flag: \'%c\'", v);
	}
}

static void cmd_operate_bpf_ld_parsed(void *parsed_result,
				__rte_unused struct cmdline *cl,
				__rte_unused void *data)
{
	int32_t rc;
	uint32_t flags;
	struct cmd_bpf_ld_result *res;
	struct rte_bpf_prm prm;
	const char *fname, *sname;

	res = parsed_result;
	memset(&prm, 0, sizeof(prm));
	prm.xsym = bpf_xsym;
	prm.nb_xsym = RTE_DIM(bpf_xsym);

	bpf_parse_flags(res->flags, &prm.prog_arg, &flags);
	fname = res->prm;
	sname = ".text";

	if (strcmp(res->dir, "rx") == 0) {
		rc = rte_bpf_eth_rx_elf_load(res->port, res->queue, &prm,
			fname, sname, flags);
		printf("%d:%s\n", rc, strerror(-rc));
	} else if (strcmp(res->dir, "tx") == 0) {
		rc = rte_bpf_eth_tx_elf_load(res->port, res->queue, &prm,
			fname, sname, flags);
		printf("%d:%s\n", rc, strerror(-rc));
	} else
		printf("invalid value: %s\n", res->dir);
}

cmdline_parse_token_string_t cmd_load_bpf_start =
	TOKEN_STRING_INITIALIZER(struct cmd_bpf_ld_result,
			bpf, "bpf-load");
cmdline_parse_token_string_t cmd_load_bpf_dir =
	TOKEN_STRING_INITIALIZER(struct cmd_bpf_ld_result,
			dir, "rx#tx");
cmdline_parse_token_num_t cmd_load_bpf_port =
	TOKEN_NUM_INITIALIZER(struct cmd_bpf_ld_result, port, UINT8);
cmdline_parse_token_num_t cmd_load_bpf_queue =
	TOKEN_NUM_INITIALIZER(struct cmd_bpf_ld_result, queue, UINT16);
cmdline_parse_token_string_t cmd_load_bpf_flags =
	TOKEN_STRING_INITIALIZER(struct cmd_bpf_ld_result,
			flags, NULL);
cmdline_parse_token_string_t cmd_load_bpf_prm =
	TOKEN_STRING_INITIALIZER(struct cmd_bpf_ld_result,
			prm, NULL);

cmdline_parse_inst_t cmd_operate_bpf_ld_parse = {
	.f = cmd_operate_bpf_ld_parsed,
	.data = NULL,
	.help_str = "bpf-load rx|tx <port> <queue> <J|M|B> <file_name>",
	.tokens = {
		(void *)&cmd_load_bpf_start,
		(void *)&cmd_load_bpf_dir,
		(void *)&cmd_load_bpf_port,
		(void *)&cmd_load_bpf_queue,
		(void *)&cmd_load_bpf_flags,
		(void *)&cmd_load_bpf_prm,
		NULL,
	},
};

/* *** unload BPF program *** */
struct cmd_bpf_unld_result {
	cmdline_fixed_string_t bpf;
	cmdline_fixed_string_t dir;
	uint8_t port;
	uint16_t queue;
};

static void cmd_operate_bpf_unld_parsed(void *parsed_result,
				__rte_unused struct cmdline *cl,
				__rte_unused void *data)
{
	struct cmd_bpf_unld_result *res;

	res = parsed_result;

	if (strcmp(res->dir, "rx") == 0)
		rte_bpf_eth_rx_unload(res->port, res->queue);
	else if (strcmp(res->dir, "tx") == 0)
		rte_bpf_eth_tx_unload(res->port, res->queue);
	else
		printf("invalid value: %s\n", res->dir);
}

cmdline_parse_token_string_t cmd_unload_bpf_start =
	TOKEN_STRING_INITIALIZER(struct cmd_bpf_unld_result,
			bpf, "bpf-unload");
cmdline_parse_token_string_t cmd_unload_bpf_dir =
	TOKEN_STRING_INITIALIZER(struct cmd_bpf_unld_result,
			dir, "rx#tx");
cmdline_parse_token_num_t cmd_unload_bpf_port =
	TOKEN_NUM_INITIALIZER(struct cmd_bpf_unld_result, port, UINT8);
cmdline_parse_token_num_t cmd_unload_bpf_queue =
	TOKEN_NUM_INITIALIZER(struct cmd_bpf_unld_result, queue, UINT16);

cmdline_parse_inst_t cmd_operate_bpf_unld_parse = {
	.f = cmd_operate_bpf_unld_parsed,
	.data = NULL,
	.help_str = "bpf-unload rx|tx <port> <queue>",
	.tokens = {
		(void *)&cmd_unload_bpf_start,
		(void *)&cmd_unload_bpf_dir,
		(void *)&cmd_unload_bpf_port,
		(void *)&cmd_unload_bpf_queue,
		NULL,
	},
};
Commit	Line	Data
11fdf7f2 TL	1	/* SPDX-License-Identifier: BSD-3-Clause
	2	* Copyright(c) 2018 Intel Corporation
	3	*/
	4
	5	#include <stdio.h>
	6	#include <rte_mbuf.h>
	7	#include <rte_ethdev.h>
	8	#include <rte_flow.h>
	9	#include <rte_bpf_ethdev.h>
	10
	11	#include <cmdline.h>
	12	#include <cmdline_parse.h>
	13	#include <cmdline_parse_num.h>
	14	#include <cmdline_parse_string.h>
	15
	16	#include "testpmd.h"
	17
	18	static const struct rte_bpf_xsym bpf_xsym[] = {
	19	{
	20	.name = RTE_STR(stdout),
	21	.type = RTE_BPF_XTYPE_VAR,
	22	.var = {
	23	.val = &stdout,
	24	.desc = {
	25	.type = RTE_BPF_ARG_PTR,
	26	.size = sizeof(stdout),
	27	},
	28	},
	29	},
	30	{
	31	.name = RTE_STR(rte_pktmbuf_dump),
	32	.type = RTE_BPF_XTYPE_FUNC,
	33	.func = {
	34	.val = (void *)rte_pktmbuf_dump,
	35	.nb_args = 3,
	36	.args = {
	37	[0] = {
	38	.type = RTE_BPF_ARG_RAW,
	39	.size = sizeof(uintptr_t),
	40	},
	41	[1] = {
	42	.type = RTE_BPF_ARG_PTR_MBUF,
	43	.size = sizeof(struct rte_mbuf),
	44	},
	45	[2] = {
	46	.type = RTE_BPF_ARG_RAW,
	47	.size = sizeof(uint32_t),
	48	},
	49	},
	50	},
	51	},
	52	};
	53
	54	/* * load BPF program * */
	55	struct cmd_bpf_ld_result {
	56	cmdline_fixed_string_t bpf;
	57	cmdline_fixed_string_t dir;
	58	uint8_t port;
	59	uint16_t queue;
	60	cmdline_fixed_string_t op;
	61	cmdline_fixed_string_t flags;
	62	cmdline_fixed_string_t prm;
	63	};
	64
65	static void
66	bpf_parse_flags(const char str, struct rte_bpf_arg arg, uint32_t *flags)
67	{
68	uint32_t i, v;
69
70	*flags = RTE_BPF_ETH_F_NONE;
71	arg->type = RTE_BPF_ARG_PTR;
72	arg->size = mbuf_data_size;
73
74	for (i = 0; str[i] != 0; i++) {
75	v = toupper(str[i]);
76	if (v == 'J')
77	*flags \|= RTE_BPF_ETH_F_JIT;
78	else if (v == 'M') {
79	arg->type = RTE_BPF_ARG_PTR_MBUF;
80	arg->size = sizeof(struct rte_mbuf);
81	arg->buf_size = mbuf_data_size;
82	} else if (v == '-')
83	continue;
84	else
85	printf("unknown flag: \'%c\'", v);
86	}
87	}
88
89	static void cmd_operate_bpf_ld_parsed(void *parsed_result,
f67539c2 TL	90	__rte_unused struct cmdline *cl,
f67539c2 TL	91	__rte_unused void *data)
11fdf7f2 TL	92	{
	93	int32_t rc;
	94	uint32_t flags;
	95	struct cmd_bpf_ld_result *res;
	96	struct rte_bpf_prm prm;
	97	const char fname, sname;
	98
	99	res = parsed_result;
	100	memset(&prm, 0, sizeof(prm));
	101	prm.xsym = bpf_xsym;
	102	prm.nb_xsym = RTE_DIM(bpf_xsym);
	103
	104	bpf_parse_flags(res->flags, &prm.prog_arg, &flags);
	105	fname = res->prm;
	106	sname = ".text";
	107
	108	if (strcmp(res->dir, "rx") == 0) {
	109	rc = rte_bpf_eth_rx_elf_load(res->port, res->queue, &prm,
	110	fname, sname, flags);
	111	printf("%d:%s\n", rc, strerror(-rc));
	112	} else if (strcmp(res->dir, "tx") == 0) {
	113	rc = rte_bpf_eth_tx_elf_load(res->port, res->queue, &prm,
	114	fname, sname, flags);
	115	printf("%d:%s\n", rc, strerror(-rc));
	116	} else
	117	printf("invalid value: %s\n", res->dir);
	118	}
	119
	120	cmdline_parse_token_string_t cmd_load_bpf_start =
	121	TOKEN_STRING_INITIALIZER(struct cmd_bpf_ld_result,
	122	bpf, "bpf-load");
	123	cmdline_parse_token_string_t cmd_load_bpf_dir =
	124	TOKEN_STRING_INITIALIZER(struct cmd_bpf_ld_result,
	125	dir, "rx#tx");
	126	cmdline_parse_token_num_t cmd_load_bpf_port =
	127	TOKEN_NUM_INITIALIZER(struct cmd_bpf_ld_result, port, UINT8);
	128	cmdline_parse_token_num_t cmd_load_bpf_queue =
	129	TOKEN_NUM_INITIALIZER(struct cmd_bpf_ld_result, queue, UINT16);
	130	cmdline_parse_token_string_t cmd_load_bpf_flags =
	131	TOKEN_STRING_INITIALIZER(struct cmd_bpf_ld_result,
	132	flags, NULL);
	133	cmdline_parse_token_string_t cmd_load_bpf_prm =
	134	TOKEN_STRING_INITIALIZER(struct cmd_bpf_ld_result,
	135	prm, NULL);
	136
	137	cmdline_parse_inst_t cmd_operate_bpf_ld_parse = {
	138	.f = cmd_operate_bpf_ld_parsed,
	139	.data = NULL,
	140	.help_str = "bpf-load rx\|tx <port> <queue> <J\|M\|B> <file_name>",
	141	.tokens = {
	142	(void *)&cmd_load_bpf_start,
	143	(void *)&cmd_load_bpf_dir,
	144	(void *)&cmd_load_bpf_port,
	145	(void *)&cmd_load_bpf_queue,
	146	(void *)&cmd_load_bpf_flags,
	147	(void *)&cmd_load_bpf_prm,
	148	NULL,
	149	},
	150	};
	151
	152	/* * unload BPF program * */
	153	struct cmd_bpf_unld_result {
	154	cmdline_fixed_string_t bpf;
	155	cmdline_fixed_string_t dir;
156	uint8_t port;
157	uint16_t queue;
158	};
159
160	static void cmd_operate_bpf_unld_parsed(void *parsed_result,
f67539c2 TL	161	__rte_unused struct cmdline *cl,
f67539c2 TL	162	__rte_unused void *data)
11fdf7f2 TL	163	{
	164	struct cmd_bpf_unld_result *res;
	165
	166	res = parsed_result;
	167
	168	if (strcmp(res->dir, "rx") == 0)
	169	rte_bpf_eth_rx_unload(res->port, res->queue);
	170	else if (strcmp(res->dir, "tx") == 0)
	171	rte_bpf_eth_tx_unload(res->port, res->queue);
	172	else
	173	printf("invalid value: %s\n", res->dir);
	174	}
	175
	176	cmdline_parse_token_string_t cmd_unload_bpf_start =
	177	TOKEN_STRING_INITIALIZER(struct cmd_bpf_unld_result,
	178	bpf, "bpf-unload");
	179	cmdline_parse_token_string_t cmd_unload_bpf_dir =
	180	TOKEN_STRING_INITIALIZER(struct cmd_bpf_unld_result,
	181	dir, "rx#tx");
	182	cmdline_parse_token_num_t cmd_unload_bpf_port =
	183	TOKEN_NUM_INITIALIZER(struct cmd_bpf_unld_result, port, UINT8);
	184	cmdline_parse_token_num_t cmd_unload_bpf_queue =
	185	TOKEN_NUM_INITIALIZER(struct cmd_bpf_unld_result, queue, UINT16);
	186
	187	cmdline_parse_inst_t cmd_operate_bpf_unld_parse = {
	188	.f = cmd_operate_bpf_unld_parsed,
	189	.data = NULL,
	190	.help_str = "bpf-unload rx\|tx <port> <queue>",
	191	.tokens = {
	192	(void *)&cmd_unload_bpf_start,
	193	(void *)&cmd_unload_bpf_dir,
	194	(void *)&cmd_unload_bpf_port,
	195	(void *)&cmd_unload_bpf_queue,
	196	NULL,
	197	},
	198	};