common/mlx5: glue event interrupt commands
[dpdk.git] / app / test-eventdev / evt_main.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2017 Cavium, Inc
3  */
4
5 #include <stdio.h>
6 #include <unistd.h>
7 #include <signal.h>
8
9 #include <rte_atomic.h>
10 #include <rte_debug.h>
11 #include <rte_eal.h>
12 #include <rte_eventdev.h>
13
14 #include "evt_options.h"
15 #include "evt_test.h"
16
17 struct evt_options opt;
18 struct evt_test *test;
19
20 static void
21 signal_handler(int signum)
22 {
23         int i;
24         static uint8_t once;
25
26         if ((signum == SIGINT || signum == SIGTERM) && !once) {
27                 once = true;
28                 printf("\nSignal %d received, preparing to exit...\n",
29                                 signum);
30
31                 if (test != NULL) {
32                         /* request all lcores to exit from the main loop */
33                         *(int *)test->test_priv = true;
34                         rte_wmb();
35
36                         if (test->ops.ethdev_destroy)
37                                 test->ops.ethdev_destroy(test, &opt);
38
39                         rte_eal_mp_wait_lcore();
40
41                         if (test->ops.test_result)
42                                 test->ops.test_result(test, &opt);
43
44                         if (opt.prod_type == EVT_PROD_TYPE_ETH_RX_ADPTR) {
45                                 RTE_ETH_FOREACH_DEV(i)
46                                         rte_eth_dev_close(i);
47                         }
48
49                         if (test->ops.eventdev_destroy)
50                                 test->ops.eventdev_destroy(test, &opt);
51
52                         if (test->ops.mempool_destroy)
53                                 test->ops.mempool_destroy(test, &opt);
54
55                         if (test->ops.test_destroy)
56                                 test->ops.test_destroy(test, &opt);
57                 }
58
59                 /* exit with the expected status */
60                 signal(signum, SIG_DFL);
61                 kill(getpid(), signum);
62         }
63 }
64
65 static inline void
66 evt_options_dump_all(struct evt_test *test, struct evt_options *opts)
67 {
68         evt_options_dump(opts);
69         if (test->ops.opt_dump)
70                 test->ops.opt_dump(opts);
71 }
72
73 int
74 main(int argc, char **argv)
75 {
76         uint8_t evdevs;
77         int ret;
78
79         signal(SIGINT, signal_handler);
80         signal(SIGTERM, signal_handler);
81
82         ret = rte_eal_init(argc, argv);
83         if (ret < 0)
84                 rte_panic("invalid EAL arguments\n");
85         argc -= ret;
86         argv += ret;
87
88         evdevs = rte_event_dev_count();
89         if (!evdevs)
90                 rte_panic("no eventdev devices found\n");
91
92         /* Populate the default values of the options */
93         evt_options_default(&opt);
94
95         /* Parse the command line arguments */
96         ret = evt_options_parse(&opt, argc, argv);
97         if (ret) {
98                 evt_err("parsing on or more user options failed");
99                 goto error;
100         }
101
102         /* Get struct evt_test *test from name */
103         test = evt_test_get(opt.test_name);
104         if (test == NULL) {
105                 evt_err("failed to find requested test: %s", opt.test_name);
106                 goto error;
107         }
108
109         if (test->ops.test_result == NULL) {
110                 evt_err("%s: ops.test_result not found", opt.test_name);
111                 goto error;
112         }
113
114         /* Verify the command line options */
115         if (opt.dev_id >= rte_event_dev_count()) {
116                 evt_err("invalid event device %d", opt.dev_id);
117                 goto error;
118         }
119         if (test->ops.opt_check) {
120                 if (test->ops.opt_check(&opt)) {
121                         evt_err("invalid command line argument");
122                         evt_options_dump_all(test, &opt);
123                         goto error;
124                 }
125         }
126
127         /* Check the eventdev capability before proceeding */
128         if (test->ops.cap_check) {
129                 if (test->ops.cap_check(&opt) == false) {
130                         evt_info("unsupported test: %s", opt.test_name);
131                         evt_options_dump_all(test, &opt);
132                         ret = EVT_TEST_UNSUPPORTED;
133                         goto nocap;
134                 }
135         }
136
137         /* Dump the options */
138         if (opt.verbose_level)
139                 evt_options_dump_all(test, &opt);
140
141         /* Test specific setup */
142         if (test->ops.test_setup) {
143                 if (test->ops.test_setup(test, &opt))  {
144                         evt_err("failed to setup test: %s", opt.test_name);
145                         goto error;
146
147                 }
148         }
149
150         /* Test specific mempool setup */
151         if (test->ops.mempool_setup) {
152                 if (test->ops.mempool_setup(test, &opt)) {
153                         evt_err("%s: mempool setup failed", opt.test_name);
154                         goto test_destroy;
155                 }
156         }
157
158         /* Test specific ethdev setup */
159         if (test->ops.ethdev_setup) {
160                 if (test->ops.ethdev_setup(test, &opt)) {
161                         evt_err("%s: ethdev setup failed", opt.test_name);
162                         goto mempool_destroy;
163                 }
164         }
165
166         /* Test specific eventdev setup */
167         if (test->ops.eventdev_setup) {
168                 if (test->ops.eventdev_setup(test, &opt)) {
169                         evt_err("%s: eventdev setup failed", opt.test_name);
170                         goto ethdev_destroy;
171                 }
172         }
173
174         /* Launch lcores */
175         if (test->ops.launch_lcores) {
176                 if (test->ops.launch_lcores(test, &opt)) {
177                         evt_err("%s: failed to launch lcores", opt.test_name);
178                         goto eventdev_destroy;
179                 }
180         }
181
182         rte_eal_mp_wait_lcore();
183
184         /* Print the test result */
185         ret = test->ops.test_result(test, &opt);
186 nocap:
187         if (ret == EVT_TEST_SUCCESS) {
188                 printf("Result: "CLGRN"%s"CLNRM"\n", "Success");
189         } else if (ret == EVT_TEST_FAILED) {
190                 printf("Result: "CLRED"%s"CLNRM"\n", "Failed");
191                 return EXIT_FAILURE;
192         } else if (ret == EVT_TEST_UNSUPPORTED) {
193                 printf("Result: "CLYEL"%s"CLNRM"\n", "Unsupported");
194         }
195
196         return 0;
197 eventdev_destroy:
198         if (test->ops.eventdev_destroy)
199                 test->ops.eventdev_destroy(test, &opt);
200
201 ethdev_destroy:
202         if (test->ops.ethdev_destroy)
203                 test->ops.ethdev_destroy(test, &opt);
204
205 mempool_destroy:
206         if (test->ops.mempool_destroy)
207                 test->ops.mempool_destroy(test, &opt);
208
209 test_destroy:
210         if (test->ops.test_destroy)
211                 test->ops.test_destroy(test, &opt);
212 error:
213         return EXIT_FAILURE;
214 }