ethdev: add PFCP header to flow API
[dpdk.git] / app / test-pmd / bpf_cmd.c
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,
90                                 __attribute__((unused)) struct cmdline *cl,
91                                 __attribute__((unused)) void *data)
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,
161                                 __attribute__((unused)) struct cmdline *cl,
162                                 __attribute__((unused)) void *data)
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 };