1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2018 Intel Corporation 3 */ 4 #include <stdio.h> 5 #include <unistd.h> 6 #include <stdint.h> 7 #include <limits.h> 8 9 #include <rte_ethdev_driver.h> 10 #include <rte_pdump.h> 11 #include "rte_eal.h" 12 #include "rte_lcore.h" 13 #include "rte_mempool.h" 14 #include "rte_ring.h" 15 16 #include "sample_packet_forward.h" 17 #include "test.h" 18 #include "process.h" 19 #include "test_pdump.h" 20 21 #define launch_p(ARGV) process_dup(ARGV, \ 22 sizeof(ARGV)/(sizeof(ARGV[0])), __func__) 23 24 struct rte_ring *ring_server; 25 uint16_t portid; 26 uint16_t flag_for_send_pkts = 1; 27 28 int 29 test_pdump_init(void) 30 { 31 int ret = 0; 32 33 ret = rte_pdump_init(); 34 if (ret < 0) { 35 printf("rte_pdump_init failed\n"); 36 return -1; 37 } 38 ret = test_ring_setup(&ring_server, &portid); 39 if (ret < 0) { 40 printf("test_ring_setup failed\n"); 41 return -1; 42 } 43 printf("pdump_init success\n"); 44 return ret; 45 } 46 47 int 48 run_pdump_client_tests(void) 49 { 50 int flags = RTE_PDUMP_FLAG_TX, ret = 0, itr; 51 char deviceid[] = "net_ring_net_ringa"; 52 struct rte_ring *ring_client; 53 struct rte_mempool *mp = NULL; 54 struct rte_eth_dev *eth_dev = NULL; 55 char poolname[] = "mbuf_pool_client"; 56 57 ret = test_get_mempool(&mp, poolname); 58 if (ret < 0) 59 return -1; 60 mp->flags = 0x0000; 61 ring_client = rte_ring_create("SR0", RING_SIZE, rte_socket_id(), 62 RING_F_SP_ENQ | RING_F_SC_DEQ); 63 if (ring_client == NULL) { 64 printf("rte_ring_create SR0 failed"); 65 return -1; 66 } 67 68 eth_dev = rte_eth_dev_attach_secondary(deviceid); 69 if (!eth_dev) { 70 printf("Failed to probe %s", deviceid); 71 return -1; 72 } 73 rte_eth_dev_probing_finish(eth_dev); 74 75 ring_client->prod.single = 0; 76 ring_client->cons.single = 0; 77 78 printf("\n***** flags = RTE_PDUMP_FLAG_TX *****\n"); 79 80 for (itr = 0; itr < NUM_ITR; itr++) { 81 ret = rte_pdump_enable(portid, QUEUE_ID, flags, ring_client, 82 mp, NULL); 83 if (ret < 0) { 84 printf("rte_pdump_enable failed\n"); 85 return -1; 86 } 87 printf("pdump_enable success\n"); 88 89 ret = rte_pdump_disable(portid, QUEUE_ID, flags); 90 if (ret < 0) { 91 printf("rte_pdump_disable failed\n"); 92 return -1; 93 } 94 printf("pdump_disable success\n"); 95 96 ret = rte_pdump_enable_by_deviceid(deviceid, QUEUE_ID, flags, 97 ring_client, mp, NULL); 98 if (ret < 0) { 99 printf("rte_pdump_enable_by_deviceid failed\n"); 100 return -1; 101 } 102 printf("pdump_enable_by_deviceid success\n"); 103 104 ret = rte_pdump_disable_by_deviceid(deviceid, QUEUE_ID, flags); 105 if (ret < 0) { 106 printf("rte_pdump_disable_by_deviceid failed\n"); 107 return -1; 108 } 109 printf("pdump_disable_by_deviceid success\n"); 110 111 if (itr == 0) { 112 flags = RTE_PDUMP_FLAG_RX; 113 printf("\n***** flags = RTE_PDUMP_FLAG_RX *****\n"); 114 } else if (itr == 1) { 115 flags = RTE_PDUMP_FLAG_RXTX; 116 printf("\n***** flags = RTE_PDUMP_FLAG_RXTX *****\n"); 117 } 118 } 119 if (ring_client != NULL) 120 test_ring_free(ring_client); 121 if (mp != NULL) 122 test_mp_free(mp); 123 124 return ret; 125 } 126 127 int 128 test_pdump_uninit(void) 129 { 130 int ret = 0; 131 132 ret = rte_pdump_uninit(); 133 if (ret < 0) { 134 printf("rte_pdump_uninit failed\n"); 135 return -1; 136 } 137 if (ring_server != NULL) 138 test_ring_free(ring_server); 139 printf("pdump_uninit success\n"); 140 test_vdev_uninit("net_ring_net_ringa"); 141 return ret; 142 } 143 144 void * 145 send_pkts(void *empty) 146 { 147 int ret = 0; 148 struct rte_mbuf *pbuf[NUM_PACKETS] = { }; 149 struct rte_mempool *mp; 150 char poolname[] = "mbuf_pool_server"; 151 152 ret = test_get_mbuf_from_pool(&mp, pbuf, poolname); 153 if (ret < 0) 154 printf("get_mbuf_from_pool failed\n"); 155 do { 156 ret = test_packet_forward(pbuf, portid, QUEUE_ID); 157 if (ret < 0) 158 printf("send pkts Failed\n"); 159 } while (flag_for_send_pkts); 160 test_put_mbuf_to_pool(mp, pbuf); 161 return empty; 162 } 163 164 /* 165 * This function is called in the primary i.e. main test, to spawn off secondary 166 * processes to run actual mp tests. Uses fork() and exec pair 167 */ 168 169 int 170 run_pdump_server_tests(void) 171 { 172 int ret = 0; 173 char coremask[10]; 174 175 #ifdef RTE_EXEC_ENV_LINUX 176 char tmp[PATH_MAX] = { 0 }; 177 char prefix[PATH_MAX] = { 0 }; 178 179 get_current_prefix(tmp, sizeof(tmp)); 180 snprintf(prefix, sizeof(prefix), "--file-prefix=%s", tmp); 181 #else 182 const char *prefix = ""; 183 #endif 184 185 /* good case, using secondary */ 186 const char *const argv1[] = { 187 prgname, "-c", coremask, "--proc-type=secondary", 188 prefix 189 }; 190 191 snprintf(coremask, sizeof(coremask), "%x", 192 (1 << rte_get_master_lcore())); 193 194 ret = test_pdump_init(); 195 ret |= launch_p(argv1); 196 ret |= test_pdump_uninit(); 197 return ret; 198 } 199 200 int 201 test_pdump(void) 202 { 203 int ret = 0; 204 if (rte_eal_process_type() == RTE_PROC_PRIMARY) { 205 printf("IN PRIMARY PROCESS\n"); 206 ret = run_pdump_server_tests(); 207 if (ret < 0) 208 return TEST_FAILED; 209 } else if (rte_eal_process_type() == RTE_PROC_SECONDARY) { 210 printf("IN SECONDARY PROCESS\n"); 211 sleep(5); 212 ret = run_pdump_client_tests(); 213 if (ret < 0) 214 return TEST_FAILED; 215 } 216 return TEST_SUCCESS; 217 } 218 219 REGISTER_TEST_COMMAND(pdump_autotest, test_pdump); 220