1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2018 Intel Corporation
11 #include <rte_ethdev.h>
12 #include <rte_malloc.h>
13 #include <rte_vhost.h>
16 #include <rte_string_fns.h>
18 #include <cmdline_parse.h>
19 #include <cmdline_socket.h>
20 #include <cmdline_parse_string.h>
21 #include <cmdline_parse_num.h>
24 #define MAX_PATH_LEN 128
25 #define MAX_VDPA_SAMPLE_PORTS 1024
26 #define RTE_LOGTYPE_VDPA RTE_LOGTYPE_USER1
29 char ifname[MAX_PATH_LEN];
34 struct rte_vdpa_stat_name *stats_names;
35 struct rte_vdpa_stat *stats;
38 static struct vdpa_port vports[MAX_VDPA_SAMPLE_PORTS];
40 static char iface[MAX_PATH_LEN];
43 static int interactive;
44 static int client_mode;
48 vdpa_usage(const char *prgname)
50 printf("Usage: %s [EAL options] -- "
51 " --interactive|-i: run in interactive mode.\n"
52 " --iface <path>: specify the path prefix of the socket files, e.g. /tmp/vhost-user-.\n"
53 " --client: register a vhost-user socket as client mode.\n",
58 parse_args(int argc, char **argv)
60 static const char *short_option = "i";
61 static struct option long_option[] = {
62 {"iface", required_argument, NULL, 0},
63 {"interactive", no_argument, &interactive, 1},
64 {"client", no_argument, &client_mode, 1},
68 char *prgname = argv[0];
70 while ((opt = getopt_long(argc, argv, short_option, long_option, &idx))
74 printf("Interactive-mode selected\n");
79 if (strncmp(long_option[idx].name, "iface",
81 rte_strscpy(iface, optarg, MAX_PATH_LEN);
82 printf("iface %s\n", iface);
84 if (!strcmp(long_option[idx].name, "interactive")) {
85 printf("Interactive-mode selected\n");
96 if (iface[0] == '\0' && interactive == 0) {
107 char ifname[MAX_PATH_LEN];
110 rte_vhost_get_ifname(vid, ifname, sizeof(ifname));
111 for (i = 0; i < MAX_VDPA_SAMPLE_PORTS; i++) {
112 if (strncmp(ifname, vports[i].ifname, MAX_PATH_LEN) == 0) {
113 printf("\nnew port %s, did: %d\n",
114 ifname, vports[i].did);
120 if (i >= MAX_VDPA_SAMPLE_PORTS)
127 destroy_device(int vid)
129 char ifname[MAX_PATH_LEN];
132 rte_vhost_get_ifname(vid, ifname, sizeof(ifname));
133 for (i = 0; i < MAX_VDPA_SAMPLE_PORTS; i++) {
134 if (strcmp(ifname, vports[i].ifname) == 0) {
135 printf("\ndestroy port %s, did: %d\n",
136 ifname, vports[i].did);
142 static const struct vhost_device_ops vdpa_sample_devops = {
143 .new_device = new_device,
144 .destroy_device = destroy_device,
148 start_vdpa(struct vdpa_port *vport)
151 char *socket_path = vport->ifname;
152 struct rte_vdpa_device *vdev;
153 int did = vport->did;
156 vport->flags |= RTE_VHOST_USER_CLIENT;
158 if (access(socket_path, F_OK) != -1 && !client_mode) {
160 "%s exists, please remove it or specify another file and try again.\n",
164 ret = rte_vhost_driver_register(socket_path, vport->flags);
166 rte_exit(EXIT_FAILURE,
167 "register driver failed: %s\n",
170 ret = rte_vhost_driver_callback_register(socket_path,
171 &vdpa_sample_devops);
173 rte_exit(EXIT_FAILURE,
174 "register driver ops failed: %s\n",
177 vdev = rte_vdpa_get_device(did);
179 rte_exit(EXIT_FAILURE,
180 "vDPA device retrieval failed: %p\n",
183 ret = rte_vhost_driver_attach_vdpa_device(socket_path, vdev);
185 rte_exit(EXIT_FAILURE,
186 "attach vdpa device failed: %s\n",
189 if (rte_vhost_driver_start(socket_path) < 0)
190 rte_exit(EXIT_FAILURE,
191 "start vhost driver failed: %s\n",
197 close_vdpa(struct vdpa_port *vport)
200 char *socket_path = vport->ifname;
202 ret = rte_vhost_driver_detach_vdpa_device(socket_path);
205 "detach vdpa device failed: %s\n",
208 ret = rte_vhost_driver_unregister(socket_path);
211 "Fail to unregister vhost driver for %s.\n",
213 if (vport->stats_names) {
214 rte_free(vport->stats_names);
215 vport->stats_names = NULL;
220 vdpa_sample_quit(void)
223 for (i = 0; i < RTE_MIN(MAX_VDPA_SAMPLE_PORTS, dev_total); i++) {
224 if (vports[i].ifname[0] != '\0')
225 close_vdpa(&vports[i]);
230 signal_handler(int signum)
232 if (signum == SIGINT || signum == SIGTERM) {
233 printf("\nSignal %d received, preparing to exit...\n", signum);
239 /* interactive cmds */
241 /* *** Help command with introduction. *** */
242 struct cmd_help_result {
243 cmdline_fixed_string_t help;
246 static void cmd_help_parsed(__rte_unused void *parsed_result,
248 __rte_unused void *data)
253 "The following commands are currently available:\n\n"
255 " help : Show interactive instructions.\n"
256 " list : list all available vdpa devices.\n"
257 " create <socket file> <vdev addr> : create a new vdpa port.\n"
258 " stats <device ID> <virtio queue ID> : show statistics of virtio queue, 0xffff for all.\n"
259 " quit : exit vdpa sample app.\n"
263 cmdline_parse_token_string_t cmd_help_help =
264 TOKEN_STRING_INITIALIZER(struct cmd_help_result, help, "help");
266 cmdline_parse_inst_t cmd_help = {
267 .f = cmd_help_parsed,
269 .help_str = "show help",
271 (void *)&cmd_help_help,
276 /* *** List all available vdpa devices *** */
277 struct cmd_list_result {
278 cmdline_fixed_string_t action;
281 static void cmd_list_vdpa_devices_parsed(
282 __rte_unused void *parsed_result,
284 __rte_unused void *data)
289 struct rte_vdpa_device *vdev;
290 struct rte_device *dev;
291 struct rte_dev_iterator dev_iter;
293 cmdline_printf(cl, "device id\tdevice name\tqueue num\tsupported features\n");
294 RTE_DEV_FOREACH(dev, "class=vdpa", &dev_iter) {
295 did = rte_vdpa_find_device_id_by_name(dev->name);
298 vdev = rte_vdpa_get_device(did);
301 if (vdev->ops->get_queue_num(vdev, &queue_num) < 0) {
303 "failed to get vdpa queue number "
304 "for device id %d.\n", did);
307 if (vdev->ops->get_features(vdev, &features) < 0) {
309 "failed to get vdpa features "
310 "for device id %d.\n", did);
313 cmdline_printf(cl, "%d\t\t%s\t\t%" PRIu32 "\t\t0x%" PRIx64 "\n",
314 did, dev->name, queue_num, features);
318 cmdline_parse_token_string_t cmd_action_list =
319 TOKEN_STRING_INITIALIZER(struct cmd_list_result, action, "list");
321 cmdline_parse_inst_t cmd_list_vdpa_devices = {
322 .f = cmd_list_vdpa_devices_parsed,
324 .help_str = "list all available vdpa devices",
326 (void *)&cmd_action_list,
331 /* *** Create new vdpa port *** */
332 struct cmd_create_result {
333 cmdline_fixed_string_t action;
334 cmdline_fixed_string_t socket_path;
335 cmdline_fixed_string_t bdf;
338 static void cmd_create_vdpa_port_parsed(void *parsed_result,
340 __rte_unused void *data)
343 struct cmd_create_result *res = parsed_result;
345 rte_strscpy(vports[devcnt].ifname, res->socket_path, MAX_PATH_LEN);
346 did = rte_vdpa_find_device_id_by_name(res->bdf);
348 cmdline_printf(cl, "Unable to find vdpa device id for %s.\n",
353 vports[devcnt].did = did;
355 if (start_vdpa(&vports[devcnt]) == 0)
359 cmdline_parse_token_string_t cmd_action_create =
360 TOKEN_STRING_INITIALIZER(struct cmd_create_result, action, "create");
361 cmdline_parse_token_string_t cmd_socket_path =
362 TOKEN_STRING_INITIALIZER(struct cmd_create_result, socket_path, NULL);
363 cmdline_parse_token_string_t cmd_bdf =
364 TOKEN_STRING_INITIALIZER(struct cmd_create_result, bdf, NULL);
366 cmdline_parse_inst_t cmd_create_vdpa_port = {
367 .f = cmd_create_vdpa_port_parsed,
369 .help_str = "create a new vdpa port",
371 (void *)&cmd_action_create,
372 (void *)&cmd_socket_path,
379 struct cmd_stats_result {
380 cmdline_fixed_string_t stats;
385 static void cmd_device_stats_parsed(void *parsed_result, struct cmdline *cl,
386 __rte_unused void *data)
388 struct cmd_stats_result *res = parsed_result;
389 struct rte_vdpa_device *vdev = rte_vdpa_get_device(res->did);
390 struct vdpa_port *vport = NULL;
391 uint32_t first, last;
395 RTE_LOG(ERR, VDPA, "Invalid device id %" PRIu16 ".\n",
399 for (i = 0; i < RTE_MIN(MAX_VDPA_SAMPLE_PORTS, dev_total); i++) {
400 if (vports[i].did == res->did) {
406 RTE_LOG(ERR, VDPA, "Device id %" PRIu16 " was not created.\n",
410 if (res->qid == 0xFFFF) {
412 last = rte_vhost_get_vring_num(vport->vid);
414 RTE_LOG(ERR, VDPA, "Failed to get num of actual virtqs"
415 " for device id %d.\n", (int)res->did);
423 if (!vport->stats_names) {
424 vport->stats_n = rte_vdpa_get_stats_names(vport->did, NULL, 0);
425 if (vport->stats_n <= 0) {
426 RTE_LOG(ERR, VDPA, "Failed to get names number of "
427 "device %d stats.\n", (int)res->did);
430 vport->stats_names = rte_zmalloc(NULL,
431 (sizeof(*vport->stats_names) + sizeof(*vport->stats)) *
433 if (!vport->stats_names) {
434 RTE_LOG(ERR, VDPA, "Failed to allocate memory for stat"
435 " names of device %d.\n", (int)res->did);
438 i = rte_vdpa_get_stats_names(vport->did, vport->stats_names,
440 if (vport->stats_n != i) {
441 RTE_LOG(ERR, VDPA, "Failed to get names of device %d "
442 "stats.\n", (int)res->did);
445 vport->stats = (struct rte_vdpa_stat *)
446 (vport->stats_names + vport->stats_n);
448 cmdline_printf(cl, "\nDevice %d:\n", (int)res->did);
449 for (; first <= last; first++) {
450 memset(vport->stats, 0, sizeof(*vport->stats) * vport->stats_n);
451 if (rte_vdpa_get_stats(vport->did, (int)first, vport->stats,
452 vport->stats_n) <= 0) {
453 RTE_LOG(ERR, VDPA, "Failed to get vdpa queue statistics"
454 " for device id %d qid %d.\n", (int)res->did,
458 cmdline_printf(cl, "\tVirtq %" PRIu32 ":\n", first);
459 for (i = 0; i < vport->stats_n; ++i) {
460 cmdline_printf(cl, "\t\t%-*s %-16" PRIu64 "\n",
461 RTE_VDPA_STATS_NAME_SIZE,
462 vport->stats_names[vport->stats[i].id].name,
463 vport->stats[i].value);
468 cmdline_parse_token_string_t cmd_device_stats_ =
469 TOKEN_STRING_INITIALIZER(struct cmd_stats_result, stats, "stats");
470 cmdline_parse_token_num_t cmd_device_id =
471 TOKEN_NUM_INITIALIZER(struct cmd_stats_result, did, UINT32);
472 cmdline_parse_token_num_t cmd_queue_id =
473 TOKEN_NUM_INITIALIZER(struct cmd_stats_result, qid, UINT32);
475 cmdline_parse_inst_t cmd_device_stats = {
476 .f = cmd_device_stats_parsed,
478 .help_str = "stats: show device statistics",
480 (void *)&cmd_device_stats_,
481 (void *)&cmd_device_id,
482 (void *)&cmd_queue_id,
488 struct cmd_quit_result {
489 cmdline_fixed_string_t quit;
492 static void cmd_quit_parsed(__rte_unused void *parsed_result,
494 __rte_unused void *data)
500 cmdline_parse_token_string_t cmd_quit_quit =
501 TOKEN_STRING_INITIALIZER(struct cmd_quit_result, quit, "quit");
503 cmdline_parse_inst_t cmd_quit = {
504 .f = cmd_quit_parsed,
506 .help_str = "quit: exit application",
508 (void *)&cmd_quit_quit,
512 cmdline_parse_ctx_t main_ctx[] = {
513 (cmdline_parse_inst_t *)&cmd_help,
514 (cmdline_parse_inst_t *)&cmd_list_vdpa_devices,
515 (cmdline_parse_inst_t *)&cmd_create_vdpa_port,
516 (cmdline_parse_inst_t *)&cmd_device_stats,
517 (cmdline_parse_inst_t *)&cmd_quit,
522 main(int argc, char *argv[])
528 struct rte_device *dev;
529 struct rte_dev_iterator dev_iter;
531 ret = rte_eal_init(argc, argv);
533 rte_exit(EXIT_FAILURE, "eal init failed\n");
537 dev_total = rte_vdpa_get_device_num();
539 rte_exit(EXIT_FAILURE, "No available vdpa device found\n");
541 signal(SIGINT, signal_handler);
542 signal(SIGTERM, signal_handler);
544 ret = parse_args(argc, argv);
546 rte_exit(EXIT_FAILURE, "invalid argument\n");
548 if (interactive == 1) {
549 cl = cmdline_stdin_new(main_ctx, "vdpa> ");
551 rte_panic("Cannot create cmdline instance\n");
552 cmdline_interact(cl);
553 cmdline_stdin_exit(cl);
555 RTE_DEV_FOREACH(dev, "class=vdpa", &dev_iter) {
556 did = rte_vdpa_find_device_id_by_name(dev->name);
558 rte_panic("Failed to find device id for %s\n",
561 vports[devcnt].did = did;
562 snprintf(vports[devcnt].ifname, MAX_PATH_LEN, "%s%d",
565 start_vdpa(&vports[devcnt]);
569 printf("enter \'q\' to quit\n");
570 while (scanf("%c", &ch)) {
574 if (scanf("%c", &ch))
577 printf("enter \'q\' to quit\n");