2 // Copyright (c) 2010-2017 Intel Corporation
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
8 // http://www.apache.org/licenses/LICENSE-2.0
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
18 #include <rte_table_hash.h>
19 #include <rte_version.h>
20 #include <rte_malloc.h>
21 #if RTE_VERSION >= RTE_VERSION_NUM(18,5,0,0)
22 #include <rte_eal_memconfig.h>
25 #include "prox_malloc.h"
31 #include "hash_utils.h"
33 #include "prox_port_cfg.h"
35 #include "handle_qos.h"
36 #include "handle_qinq_encap4.h"
41 #include "stats_core.h"
43 void start_core_all(int task_id)
45 uint32_t cores[RTE_MAX_LCORE];
50 prox_core_to_str(tmp, sizeof(tmp), 0);
51 plog_info("Starting cores: %s\n", tmp);
54 while (prox_core_next(&lcore_id, 0) == 0) {
55 cores[cnt++] = lcore_id;
57 start_cores(cores, cnt, task_id);
60 void stop_core_all(int task_id)
62 uint32_t cores[RTE_MAX_LCORE];
67 prox_core_to_str(tmp, sizeof(tmp), 0);
68 plog_info("Stopping cores: %s\n", tmp);
71 while (prox_core_next(&lcore_id, 0) == 0) {
72 cores[cnt++] = lcore_id;
75 stop_cores(cores, cnt, task_id);
78 static void warn_inactive_cores(uint32_t *cores, int count, const char *prefix)
80 for (int i = 0; i < count; ++i) {
81 if (!prox_core_active(cores[i], 0)) {
82 plog_warn("%s %u: core is not active\n", prefix, cores[i]);
87 static inline int wait_command_handled(struct lcore_cfg *lconf)
89 uint64_t t1 = rte_rdtsc(), t2;
92 if (lconf->msg.type == LCONF_MSG_STOP)
95 while (lconf_is_req(lconf)) {
97 if (t2 - t1 > max_time * rte_get_tsc_hz()) {
98 // Failed to handle command ...
99 for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
100 struct task_args *targs = &lconf->targs[task_id];
101 if (!(targs->flags & TASK_ARG_DROP)) {
102 plogx_err("Failed to handle command - task is in NO_DROP and might be stuck...\n");
106 plogx_err("Failed to handle command\n");
113 static inline void start_l3(struct task_args *targ)
115 if (!task_is_master(targ)) {
116 if ((targ->nb_txrings != 0) || (targ->nb_txports != 0)) {
117 if (targ->flags & TASK_ARG_L3)
118 task_start_l3(targ->tbase, targ);
123 void start_cores(uint32_t *cores, int count, int task_id)
125 int n_started_cores = 0;
126 uint32_t started_cores[RTE_MAX_LCORE];
127 struct task_args *targ;
129 warn_inactive_cores(cores, count, "Can't start core");
131 for (int i = 0; i < count; ++i) {
132 struct lcore_cfg *lconf = &lcore_cfg[cores[i]];
134 if (lconf->n_tasks_run != lconf->n_tasks_all) {
136 for (uint8_t tid = 0; tid < lconf->n_tasks_all; ++tid) {
137 targ = &lconf->targs[tid];
140 } else if (task_id < lconf->n_tasks_all) {
141 targ = &lconf->targs[task_id];
144 plog_warn("Invalid task id %d on core %u\n", task_id, cores[i]);
147 if (wait_command_handled(lconf) == -1) return;
148 lconf->msg.type = LCONF_MSG_START;
149 lconf->msg.task_id = task_id;
150 lconf_set_req(lconf);
152 plog_info("Starting core %u (all tasks)\n", cores[i]);
154 plog_info("Starting core %u task %u\n", cores[i], task_id);
155 started_cores[n_started_cores++] = cores[i];
156 lconf->flags |= LCONF_FLAG_RUNNING;
157 rte_eal_remote_launch(lconf_run, NULL, cores[i]);
160 plog_warn("Core %u is already running all its tasks\n", cores[i]);
164 /* This function is blocking, so detect when each core has
165 consumed the message. */
166 for (int i = 0; i < n_started_cores; ++i) {
167 struct lcore_cfg *lconf = &lcore_cfg[started_cores[i]];
168 plog_info("Waiting for core %u to start...", started_cores[i]);
169 if (wait_command_handled(lconf) == -1) return;
174 void stop_cores(uint32_t *cores, int count, int task_id)
176 int n_stopped_cores = 0;
177 uint32_t stopped_cores[RTE_MAX_LCORE];
180 warn_inactive_cores(cores, count, "Can't stop core");
182 for (int i = 0; i < count; ++i) {
183 struct lcore_cfg *lconf = &lcore_cfg[cores[i]];
184 if (task_id >= lconf->n_tasks_all) {
185 plog_warn("Trying to stop invalid task id %d on core %u\n", task_id, cores[i]);
188 if (lconf->n_tasks_run) {
189 if (wait_command_handled(lconf) == -1) return;
191 lconf->msg.type = LCONF_MSG_STOP;
192 lconf->msg.task_id = task_id;
193 lconf_set_req(lconf);
194 stopped_cores[n_stopped_cores++] = cores[i];
198 for (int i = 0; i < n_stopped_cores; ++i) {
199 c = stopped_cores[i];
200 struct lcore_cfg *lconf = &lcore_cfg[c];
201 if (wait_command_handled(lconf) == -1) return;
203 if (lconf->n_tasks_run == 0) {
204 plog_info("All tasks stopped on core %u, waiting for core to stop...", c);
205 rte_eal_wait_lcore(c);
207 lconf->flags &= ~LCONF_FLAG_RUNNING;
210 plog_info("Stopped task %u on core %u\n", task_id, c);
221 static struct size_unit to_size_unit(uint64_t bytes)
223 struct size_unit ret;
225 if (bytes > 1 << 30) {
226 ret.val = bytes >> 30;
227 ret.frac = ((bytes - (ret.val << 30)) * 1000) / (1 << 30);
228 strcpy(ret.unit, "GB");
230 else if (bytes > 1 << 20) {
231 ret.val = bytes >> 20;
232 ret.frac = ((bytes - (ret.val << 20)) * 1000) / (1 << 20);
233 strcpy(ret.unit, "MB");
235 else if (bytes > 1 << 10) {
236 ret.val = bytes >> 10;
237 ret.frac = (bytes - (ret.val << 10)) * 1000 / (1 << 10);
238 strcpy(ret.unit, "KB");
243 strcpy(ret.unit, "B");
249 static int add_multicast_addr(uint8_t port_id, struct ether_addr *addr)
254 struct prox_port_cfg* port_cfg = &prox_port_cfg[port_id];
256 if (port_cfg->nb_mc_addr >= NB_MCAST_ADDR) {
257 plog_err("Already reached maximum number (%d) of mcast addr on port %u\n", NB_MCAST_ADDR, port_id);
260 for (i = 0; i < port_cfg->nb_mc_addr; i++) {
261 if (is_same_ether_addr(addr, &port_cfg->mc_addr[i])) {
262 plog_info("multicast address already added to port\n");
267 ether_addr_copy(addr, &port_cfg->mc_addr[port_cfg->nb_mc_addr]);
268 if ((rc = rte_eth_dev_set_mc_addr_list(port_id, port_cfg->mc_addr, port_cfg->nb_mc_addr + 1)) != 0) {
269 plog_err("rte_eth_dev_set_mc_addr_list returns %d on port %u\n", rc, port_id);
273 port_cfg->nb_mc_addr++;
274 plog_info("rte_eth_dev_set_mc_addr_list(%d addr) on port %u\n", port_cfg->nb_mc_addr, port_id);
278 static int del_multicast_addr(uint8_t port_id, struct ether_addr *addr)
283 struct prox_port_cfg* port_cfg = &prox_port_cfg[port_id];
285 for (i = 0; i < port_cfg->nb_mc_addr; i++) {
286 if (is_same_ether_addr(addr, &port_cfg->mc_addr[i])) {
287 // Copy last address to the slot to be deleted
288 ether_addr_copy(&port_cfg->mc_addr[port_cfg->nb_mc_addr-1], &port_cfg->mc_addr[i]);
290 if ((rc = rte_eth_dev_set_mc_addr_list(port_id, port_cfg->mc_addr, port_cfg->nb_mc_addr - 1)) != 0) {
291 plog_err("rte_eth_dev_set_mc_addr_list returns %d on port %u\n", rc, port_id);
292 // When set failed, let restore the situation we were before calling the function...
293 ether_addr_copy(addr, &port_cfg->mc_addr[i]);
296 port_cfg->nb_mc_addr--;
297 plog_info("rte_eth_dev_set_mc_addr_list(%d addr) on port %u\n", port_cfg->nb_mc_addr, port_id);
301 plog_err("multicast address not found on port %u\n", port_id);
304 void cmd_mem_stats(void)
306 struct rte_malloc_socket_stats sock_stats;
310 for (uint32_t i = 0; i < RTE_MAX_NUMA_NODES; ++i) {
311 if (rte_malloc_get_socket_stats(i, &sock_stats) < 0 || sock_stats.heap_totalsz_bytes == 0)
314 plogx_info("Socket %u memory stats:\n", i);
315 su = to_size_unit(sock_stats.heap_totalsz_bytes);
316 plogx_info("\tHeap_size: %zu.%03zu %s\n", su.val, su.frac, su.unit);
317 su = to_size_unit(sock_stats.heap_freesz_bytes);
318 plogx_info("\tFree_size: %zu.%03zu %s\n", su.val, su.frac, su.unit);
319 su = to_size_unit(sock_stats.heap_allocsz_bytes);
320 plogx_info("\tAlloc_size: %zu.%03zu %s\n", su.val, su.frac, su.unit);
321 su = to_size_unit(sock_stats.greatest_free_size);
322 plogx_info("\tGreatest_free_size: %zu %s\n", su.val, su.unit);
323 plogx_info("\tAlloc_count: %u\n", sock_stats.alloc_count);
324 plogx_info("\tFree_count: %u\n", sock_stats.free_count);
328 static void get_hp_sz_string(char *sz_str, uint64_t hp_sz)
330 switch (hp_sz >> 20) {
332 strcpy(sz_str, " 0 ");
335 strcpy(sz_str, "2MB");
338 strcpy(sz_str, "1GB");
341 strcpy(sz_str, "??");
345 #if RTE_VERSION >= RTE_VERSION_NUM(18,5,0,0)
346 // Print all segments, 1 by 1
347 // Unused for now, keep for reference
348 static int print_all_segments(const struct rte_memseg_list *memseg_list, const struct rte_memseg *memseg, void *arg)
350 struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
351 int memseg_list_idx, memseg_idx;
352 int n = (*(int *)arg)++;
354 memseg_list_idx = memseg_list - mcfg->memsegs;
355 if ((memseg_list_idx < 0) || (memseg_list_idx >= RTE_MAX_MEMSEG_LISTS)) {
356 plog_err("Invalid memseg_list_idx = %d; memseg_list = %p, mcfg->memsegs = %p\n", memseg_list_idx, memseg_list, mcfg->memsegs);
359 memseg_idx = rte_fbarray_find_idx(&memseg_list->memseg_arr, memseg);
360 if (memseg_idx < 0) {
361 plog_err("Invalid memseg_idx = %d; memseg_list = %p, memseg = %p\n", memseg_idx, memseg_list, memseg);
366 get_hp_sz_string(sz_str, memseg->hugepage_sz);
367 plog_info("Segment %u (sock %d): [%i-%i] [%#lx-%#lx] at %p using %zu pages of %s\n",
373 memseg->iova+memseg->len,
375 memseg->len/memseg->hugepage_sz, sz_str);
380 // Print memory segments
381 // Contiguous segments are shown as 1 big segment
382 static int print_segments(const struct rte_memseg_list *memseg_list, const struct rte_memseg *memseg, size_t len, void *arg)
384 struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
385 int memseg_list_idx, memseg_idx;
388 memseg_list_idx = memseg_list - mcfg->memsegs;
389 if ((memseg_list_idx < 0) || (memseg_list_idx >= RTE_MAX_MEMSEG_LISTS)) {
390 plog_err("Invalid memseg_list_idx = %d; memseg_list = %p, mcfg->memsegs = %p\n", memseg_list_idx, memseg_list, mcfg->memsegs);
393 memseg_idx = rte_fbarray_find_idx(&memseg_list->memseg_arr, memseg);
394 if (memseg_idx < 0) {
395 plog_err("Invalid memseg_idx = %d; memseg_list = %p, memseg = %p\n", memseg_idx, memseg_list, memseg);
400 get_hp_sz_string(sz_str, memseg->hugepage_sz);
401 plog_info("Segment %u (sock %d): [%i-%i] [%#lx-%#lx] at %p using %zu pages of %s\n",
409 memseg->hugepage_sz?len/memseg->hugepage_sz:0, sz_str);
415 void cmd_mem_layout(void)
417 #if RTE_VERSION < RTE_VERSION_NUM(18,5,0,0)
418 const struct rte_memseg* memseg = rte_eal_get_physmem_layout();
420 plog_info("Memory layout:\n");
421 for (uint32_t i = 0; i < RTE_MAX_MEMSEG; i++) {
422 if (memseg[i].addr == NULL)
426 get_hp_sz_string(sz_str, memseg[i].hugepage_sz);
428 plog_info("Segment %u: [%#lx-%#lx] at %p using %zu pages of %s\n",
431 memseg[i].phys_addr + memseg[i].len,
433 memseg[i].len/memseg[i].hugepage_sz, sz_str);
436 int segment_number = 0;
437 //rte_memseg_walk(print_all_segments, &segment_number);
438 rte_memseg_contig_walk(print_segments, &segment_number);
442 void cmd_dump(uint8_t lcore_id, uint8_t task_id, uint32_t nb_packets, struct input *input, int rx, int tx)
444 plog_info("dump %u %u %u\n", lcore_id, task_id, nb_packets);
445 if (lcore_id > RTE_MAX_LCORE) {
446 plog_warn("core_id too high, maximum allowed is: %u\n", RTE_MAX_LCORE);
448 else if (task_id >= lcore_cfg[lcore_id].n_tasks_all) {
449 plog_warn("task_id too high, should be in [0, %u]\n", lcore_cfg[lcore_id].n_tasks_all - 1);
452 struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
454 lconf->tasks_all[task_id]->aux->task_rt_dump.input = input;
456 if (wait_command_handled(lconf) == -1) return;
458 lconf->msg.type = LCONF_MSG_DUMP;
460 lconf->msg.type = LCONF_MSG_DUMP_RX;
462 lconf->msg.type = LCONF_MSG_DUMP_TX;
465 lconf->msg.task_id = task_id;
466 lconf->msg.val = nb_packets;
467 lconf_set_req(lconf);
470 if (lconf->n_tasks_run == 0) {
471 lconf_do_flags(lconf);
476 void cmd_trace(uint8_t lcore_id, uint8_t task_id, uint32_t nb_packets)
478 plog_info("trace %u %u %u\n", lcore_id, task_id, nb_packets);
479 if (lcore_id > RTE_MAX_LCORE) {
480 plog_warn("core_id too high, maximum allowed is: %u\n", RTE_MAX_LCORE);
482 else if (task_id >= lcore_cfg[lcore_id].n_tasks_all) {
483 plog_warn("task_id too high, should be in [0, %u]\n", lcore_cfg[lcore_id].n_tasks_all - 1);
486 struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
488 if (wait_command_handled(lconf) == -1) return;
490 lconf->msg.type = LCONF_MSG_TRACE;
491 lconf->msg.task_id = task_id;
492 lconf->msg.val = nb_packets;
493 lconf_set_req(lconf);
495 if (lconf->n_tasks_run == 0) {
496 lconf_do_flags(lconf);
501 void cmd_rx_bw_start(uint32_t lcore_id)
503 if (lcore_id > RTE_MAX_LCORE) {
504 plog_warn("core_id too high, maximum allowed is: %u\n", RTE_MAX_LCORE);
505 } else if (lcore_cfg[lcore_id].flags & LCONF_FLAG_RX_BW_ACTIVE) {
506 plog_warn("rx bandwidt already on core %u\n", lcore_id);
509 struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
511 if (wait_command_handled(lconf) == -1) return;
512 lconf->msg.type = LCONF_MSG_RX_BW_START;
513 lconf_set_req(lconf);
515 if (lconf->n_tasks_run == 0) {
516 lconf_do_flags(lconf);
521 void cmd_tx_bw_start(uint32_t lcore_id)
523 if (lcore_id > RTE_MAX_LCORE) {
524 plog_warn("core_id too high, maximum allowed is: %u\n", RTE_MAX_LCORE);
525 } else if (lcore_cfg[lcore_id].flags & LCONF_FLAG_TX_BW_ACTIVE) {
526 plog_warn("tx bandwidth already running on core %u\n", lcore_id);
529 struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
531 if (wait_command_handled(lconf) == -1) return;
532 lconf->msg.type = LCONF_MSG_TX_BW_START;
533 lconf_set_req(lconf);
535 if (lconf->n_tasks_run == 0) {
536 lconf_do_flags(lconf);
541 void cmd_rx_bw_stop(uint32_t lcore_id)
543 if (lcore_id > RTE_MAX_LCORE) {
544 plog_warn("core_id too high, maximum allowed is: %u\n", RTE_MAX_LCORE);
545 } else if (!(lcore_cfg[lcore_id].flags & LCONF_FLAG_RX_BW_ACTIVE)) {
546 plog_warn("rx bandwidth not running on core %u\n", lcore_id);
549 struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
551 if (wait_command_handled(lconf) == -1) return;
552 lconf->msg.type = LCONF_MSG_RX_BW_STOP;
553 lconf_set_req(lconf);
555 if (lconf->n_tasks_run == 0) {
556 lconf_do_flags(lconf);
561 void cmd_tx_bw_stop(uint32_t lcore_id)
563 if (lcore_id > RTE_MAX_LCORE) {
564 plog_warn("core_id too high, maximum allowed is: %u\n", RTE_MAX_LCORE);
565 } else if (!(lcore_cfg[lcore_id].flags & LCONF_FLAG_TX_BW_ACTIVE)) {
566 plog_warn("tx bandwidth not running on core %u\n", lcore_id);
569 struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
571 if (wait_command_handled(lconf) == -1) return;
572 lconf->msg.type = LCONF_MSG_TX_BW_STOP;
573 lconf_set_req(lconf);
575 if (lconf->n_tasks_run == 0) {
576 lconf_do_flags(lconf);
580 void cmd_rx_distr_start(uint32_t lcore_id)
582 if (lcore_id > RTE_MAX_LCORE) {
583 plog_warn("core_id too high, maximum allowed is: %u\n", RTE_MAX_LCORE);
584 } else if (lcore_cfg[lcore_id].flags & LCONF_FLAG_RX_DISTR_ACTIVE) {
585 plog_warn("rx distribution already xrunning on core %u\n", lcore_id);
587 struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
589 if (wait_command_handled(lconf) == -1) return;
590 lconf->msg.type = LCONF_MSG_RX_DISTR_START;
591 lconf_set_req(lconf);
593 if (lconf->n_tasks_run == 0) {
594 lconf_do_flags(lconf);
599 void cmd_tx_distr_start(uint32_t lcore_id)
601 if (lcore_id > RTE_MAX_LCORE) {
602 plog_warn("core_id too high, maximum allowed is: %u\n", RTE_MAX_LCORE);
603 } else if (lcore_cfg[lcore_id].flags & LCONF_FLAG_TX_DISTR_ACTIVE) {
604 plog_warn("tx distribution already xrunning on core %u\n", lcore_id);
606 struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
608 if (wait_command_handled(lconf) == -1) return;
609 lconf->msg.type = LCONF_MSG_TX_DISTR_START;
610 lconf_set_req(lconf);
612 if (lconf->n_tasks_run == 0) {
613 lconf_do_flags(lconf);
618 void cmd_rx_distr_stop(uint32_t lcore_id)
620 if (lcore_id > RTE_MAX_LCORE) {
621 plog_warn("core_id too high, maximum allowed is: %u\n", RTE_MAX_LCORE);
622 } else if ((lcore_cfg[lcore_id].flags & LCONF_FLAG_RX_DISTR_ACTIVE) == 0) {
623 plog_warn("rx distribution not running on core %u\n", lcore_id);
625 struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
627 if (wait_command_handled(lconf) == -1) return;
628 lconf->msg.type = LCONF_MSG_RX_DISTR_STOP;
629 lconf_set_req(lconf);
631 if (lconf->n_tasks_run == 0) {
632 lconf_do_flags(lconf);
637 void cmd_tx_distr_stop(uint32_t lcore_id)
639 if (lcore_id > RTE_MAX_LCORE) {
640 plog_warn("core_id too high, maximum allowed is: %u\n", RTE_MAX_LCORE);
641 } else if ((lcore_cfg[lcore_id].flags & LCONF_FLAG_TX_DISTR_ACTIVE) == 0) {
642 plog_warn("tx distribution not running on core %u\n", lcore_id);
644 struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
646 if (wait_command_handled(lconf) == -1) return;
647 lconf->msg.type = LCONF_MSG_TX_DISTR_STOP;
648 lconf_set_req(lconf);
650 if (lconf->n_tasks_run == 0) {
651 lconf_do_flags(lconf);
656 void cmd_rx_distr_rst(uint32_t lcore_id)
658 if (lcore_id > RTE_MAX_LCORE) {
659 plog_warn("core_id too high, maximum allowed is: %u\n", RTE_MAX_LCORE);
661 struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
663 if (wait_command_handled(lconf) == -1) return;
664 lconf->msg.type = LCONF_MSG_RX_DISTR_RESET;
665 lconf_set_req(lconf);
667 if (lconf->n_tasks_run == 0) {
668 lconf_do_flags(lconf);
673 void cmd_tx_distr_rst(uint32_t lcore_id)
675 if (lcore_id > RTE_MAX_LCORE) {
676 plog_warn("core_id too high, maximum allowed is: %u\n", RTE_MAX_LCORE);
678 struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
680 if (wait_command_handled(lconf) == -1) return;
681 lconf->msg.type = LCONF_MSG_TX_DISTR_RESET;
682 lconf_set_req(lconf);
684 if (lconf->n_tasks_run == 0) {
685 lconf_do_flags(lconf);
690 void cmd_rx_distr_show(uint32_t lcore_id)
692 if (lcore_id > RTE_MAX_LCORE) {
693 plog_warn("core_id too high, maximum allowed is: %u\n", RTE_MAX_LCORE);
695 for (uint32_t i = 0; i < lcore_cfg[lcore_id].n_tasks_all; ++i) {
696 struct task_base *t = lcore_cfg[lcore_id].tasks_all[i];
697 plog_info("t[%u]: ", i);
698 for (uint32_t j = 0; j < sizeof(t->aux->rx_bucket)/sizeof(t->aux->rx_bucket[0]); ++j) {
699 plog_info("%u ", t->aux->rx_bucket[j]);
705 void cmd_tx_distr_show(uint32_t lcore_id)
707 if (lcore_id > RTE_MAX_LCORE) {
708 plog_warn("core_id too high, maximum allowed is: %u\n", RTE_MAX_LCORE);
710 for (uint32_t i = 0; i < lcore_cfg[lcore_id].n_tasks_all; ++i) {
711 struct task_base *t = lcore_cfg[lcore_id].tasks_all[i];
712 uint64_t tot = 0, avg = 0;
713 for (uint32_t j = 0; j < sizeof(t->aux->tx_bucket)/sizeof(t->aux->tx_bucket[0]); ++j) {
714 tot += t->aux->tx_bucket[j];
715 avg += j * t->aux->tx_bucket[j];
720 plog_info("t[%u]: %lu: ", i, avg);
721 for (uint32_t j = 0; j < sizeof(t->aux->tx_bucket)/sizeof(t->aux->tx_bucket[0]); ++j) {
722 plog_info("%u ", t->aux->tx_bucket[j]);
729 void cmd_ringinfo_all(void)
731 struct lcore_cfg *lconf;
732 uint32_t lcore_id = -1;
734 while(prox_core_next(&lcore_id, 0) == 0) {
735 lconf = &lcore_cfg[lcore_id];
736 for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
737 cmd_ringinfo(lcore_id, task_id);
742 void cmd_ringinfo(uint8_t lcore_id, uint8_t task_id)
744 struct lcore_cfg *lconf;
745 struct rte_ring *ring;
746 struct task_args* targ;
749 if (!prox_core_active(lcore_id, 0)) {
750 plog_info("lcore %u is not active\n", lcore_id);
753 lconf = &lcore_cfg[lcore_id];
754 if (task_id >= lconf->n_tasks_all) {
755 plog_warn("Invalid task index %u: lcore %u has %u tasks\n", task_id, lcore_id, lconf->n_tasks_all);
759 targ = &lconf->targs[task_id];
760 plog_info("Core %u task %u: %u rings\n", lcore_id, task_id, targ->nb_rxrings);
761 for (uint8_t i = 0; i < targ->nb_rxrings; ++i) {
762 ring = targ->rx_rings[i];
763 #if RTE_VERSION < RTE_VERSION_NUM(17,5,0,1)
764 count = ring->prod.mask + 1;
766 count = ring->mask + 1;
768 plog_info("\tRing %u:\n", i);
769 plog_info("\t\tFlags: %s,%s\n", ring->flags & RING_F_SP_ENQ? "sp":"mp", ring->flags & RING_F_SC_DEQ? "sc":"mc");
770 plog_info("\t\tMemory size: %zu bytes\n", rte_ring_get_memsize(count));
771 plog_info("\t\tOccupied: %u/%u\n", rte_ring_count(ring), count);
775 void cmd_port_up(uint8_t port_id)
779 if (!port_is_active(port_id)) {
783 if ((err = rte_eth_dev_set_link_up(port_id)) == 0) {
784 plog_info("Bringing port %d up\n", port_id);
787 plog_warn("Failed to bring port %d up with error %d\n", port_id, err);
791 void cmd_port_down(uint8_t port_id)
795 if (!port_is_active(port_id)) {
799 if ((err = rte_eth_dev_set_link_down(port_id)) == 0) {
800 plog_info("Bringing port %d down\n", port_id);
803 plog_warn("Failed to bring port %d down with error %d\n", port_id, err);
807 void cmd_xstats(uint8_t port_id)
809 #if RTE_VERSION >= RTE_VERSION_NUM(16,7,0,0)
811 struct rte_eth_xstat *eth_xstat = NULL; // id and value
812 struct rte_eth_xstat_name *eth_xstat_name = NULL; // only names
813 struct prox_port_cfg* port_cfg = &prox_port_cfg[port_id];
816 n_xstats = rte_eth_xstats_get(port_id, NULL, 0);
817 eth_xstat_name = prox_zmalloc(n_xstats * sizeof(*eth_xstat_name), port_cfg->socket);
818 PROX_ASSERT(eth_xstat_name);
819 rc = rte_eth_xstats_get_names(port_id, eth_xstat_name, n_xstats);
820 if ((rc < 0) || (rc > n_xstats)) {
822 plog_warn("Failed to get xstats_names on port %d with error %d\n", port_id, rc);
823 } else if (rc > n_xstats) {
824 plog_warn("Failed to get xstats_names on port %d: too many xstats (%d)\n", port_id, rc);
828 eth_xstat = prox_zmalloc(n_xstats * sizeof(*eth_xstat), port_cfg->socket);
829 PROX_ASSERT(eth_xstat);
830 rc = rte_eth_xstats_get(port_id, eth_xstat, n_xstats);
831 if ((rc < 0) || (rc > n_xstats)) {
833 plog_warn("Failed to get xstats on port %d with error %d\n", port_id, rc);
834 } else if (rc > n_xstats) {
835 plog_warn("Failed to get xstats on port %d: too many xstats (%d)\n", port_id, rc);
838 for (int i=0;i<rc;i++) {
839 plog_info("%s: %ld\n", eth_xstat_name[i].name, eth_xstat[i].value);
843 prox_free(eth_xstat_name);
845 prox_free(eth_xstat);
847 #if RTE_VERSION >= RTE_VERSION_NUM(2,1,0,0)
849 struct rte_eth_xstats *eth_xstats;
850 struct prox_port_cfg* port_cfg = &prox_port_cfg[port_id];
853 n_xstats = rte_eth_xstats_get(port_id, NULL, 0);
854 eth_xstats = prox_zmalloc(n_xstats * sizeof(*eth_xstats), port_cfg->socket);
855 PROX_ASSERT(eth_xstats);
856 rc = rte_eth_xstats_get(port_id, eth_xstats, n_xstats);
857 if ((rc < 0) || (rc > n_xstats)) {
859 plog_warn("Failed to get xstats on port %d with error %d\n", port_id, rc);
860 } else if (rc > n_xstats) {
861 plog_warn("Failed to get xstats on port %d: too many xstats (%d)\n", port_id, rc);
864 for (int i=0;i<rc;i++) {
865 plog_info("%s: %ld\n", eth_xstats[i].name, eth_xstats[i].value);
869 prox_free(eth_xstats);
871 plog_warn("Failed to get xstats, xstats are not supported in this version of dpdk\n");
876 void cmd_portinfo(int port_id, char *dst, size_t max_len)
878 char *end = dst + max_len;
882 uint8_t max_port_idx = prox_last_port_active() + 1;
884 for (uint8_t port_id = 0; port_id < max_port_idx; ++port_id) {
885 if (!prox_port_cfg[port_id].active) {
888 struct prox_port_cfg* port_cfg = &prox_port_cfg[port_id];
890 dst += snprintf(dst, end - dst,
891 "%2d:%10s; "MAC_BYTES_FMT"; %s\n",
894 MAC_BYTES(port_cfg->eth_addr.addr_bytes),
900 if (!port_is_active(port_id)) {
904 struct prox_port_cfg* port_cfg = &prox_port_cfg[port_id];
906 dst += snprintf(dst, end - dst, "Port info for port %u\n", port_id);
907 dst += snprintf(dst, end - dst, "\tName: %s\n", port_cfg->name);
908 dst += snprintf(dst, end - dst, "\tDriver: %s\n", port_cfg->driver_name);
909 dst += snprintf(dst, end - dst, "\tMac address: "MAC_BYTES_FMT"\n", MAC_BYTES(port_cfg->eth_addr.addr_bytes));
910 dst += snprintf(dst, end - dst, "\tLink speed: %u Mbps\n", port_cfg->link_speed);
911 dst += snprintf(dst, end - dst, "\tLink max speed: %u Mbps\n", port_cfg->max_link_speed);
912 dst += snprintf(dst, end - dst, "\tLink status: %s\n", port_cfg->link_up? "up" : "down");
913 dst += snprintf(dst, end - dst, "\tSocket: %u\n", port_cfg->socket);
914 dst += snprintf(dst, end - dst, "\tPCI address: %s\n", port_cfg->pci_addr);
915 dst += snprintf(dst, end - dst, "\tPromiscuous: %s\n", port_cfg->promiscuous? "yes" : "no");
916 for (unsigned int i = 0; i < port_cfg->nb_mc_addr; i++) {
917 dst += snprintf(dst, end - dst, "\tmcast address: "MAC_BYTES_FMT"\n", MAC_BYTES(port_cfg->mc_addr[i].addr_bytes));
919 dst += snprintf(dst, end - dst, "\tNumber of RX/TX descriptors: %u/%u\n", port_cfg->n_rxd, port_cfg->n_txd);
920 dst += snprintf(dst, end - dst, "\tNumber of RX/TX queues: %u/%u (max: %u/%u)\n", port_cfg->n_rxq, port_cfg->n_txq, port_cfg->max_rxq, port_cfg->max_txq);
921 dst += snprintf(dst, end - dst, "\tMemory pools:\n");
923 for (uint8_t i = 0; i < 32; ++i) {
924 if (port_cfg->pool[i]) {
925 dst += snprintf(dst, end - dst, "\t\tname: %s (%p)\n",
926 port_cfg->pool[i]->name, port_cfg->pool[i]);
931 void cmd_read_reg(uint8_t port_id, unsigned int id)
933 unsigned int val, rc;
934 if (!port_is_active(port_id)) {
937 rc = read_reg(port_id, id, &val);
939 plog_warn("Failed to read register %d on port %d\n", id, port_id);
942 plog_info("Register 0x%08X : %08X \n", id, val);
946 void cmd_reset_port(uint8_t portid)
949 if (!prox_port_cfg[portid].active) {
950 plog_info("port not active \n");
953 rte_eth_dev_stop(portid);
954 rc = rte_eth_dev_start(portid);
956 plog_warn("Failed to restart port %d\n", portid);
960 void cmd_multicast(uint8_t port_id, unsigned int val, struct ether_addr *mac)
962 if (!port_is_active(port_id)) {
965 struct prox_port_cfg* port_cfg = &prox_port_cfg[port_id];
967 if (port_cfg->nb_mc_addr == 0) {
968 rte_eth_allmulticast_enable(port_id);
970 if (add_multicast_addr(port_id, mac) != 0) {
971 if (port_cfg->nb_mc_addr == 0)
972 rte_eth_allmulticast_disable(port_id);
974 } else if (val == 0) {
975 if (del_multicast_addr(port_id, mac) == 0) {
976 if (port_cfg->nb_mc_addr == 0) {
977 rte_eth_allmulticast_disable(port_id);
981 plog_err("Unexpected value in cmd_multicast on port %d\n", port_id);
985 void cmd_write_reg(uint8_t port_id, unsigned int id, unsigned int val)
987 if (!port_is_active(port_id)) {
991 plog_info("writing 0x%08X %08X\n", id, val);
992 write_reg(port_id, id, val);
995 void cmd_set_vlan_offload(uint8_t port_id, unsigned int val)
997 if (!port_is_active(port_id)) {
1001 plog_info("setting vlan offload to %d\n", val);
1002 if (val & ~(ETH_VLAN_STRIP_OFFLOAD | ETH_VLAN_FILTER_OFFLOAD | ETH_VLAN_EXTEND_OFFLOAD)) {
1003 plog_info("wrong vlan offload value\n");
1005 int ret = rte_eth_dev_set_vlan_offload(port_id, val);
1006 plog_info("rte_eth_dev_set_vlan_offload return %d\n", ret);
1009 void cmd_set_vlan_filter(uint8_t port_id, unsigned int id, unsigned int val)
1011 if (!port_is_active(port_id)) {
1015 plog_info("setting vln filter for vlan %d to %d\n", id, val);
1016 int ret = rte_eth_dev_vlan_filter(port_id, id, val);
1017 plog_info("rte_eth_dev_vlan_filter return %d\n", ret);
1020 void cmd_thread_info(uint8_t lcore_id, uint8_t task_id)
1022 plog_info("thread_info %u %u \n", lcore_id, task_id);
1023 if (lcore_id > RTE_MAX_LCORE) {
1024 plog_warn("core_id too high, maximum allowed is: %u\n", RTE_MAX_LCORE);
1026 if (!prox_core_active(lcore_id, 0)) {
1027 plog_warn("lcore %u is not active\n", lcore_id);
1030 if (task_id >= lcore_cfg[lcore_id].n_tasks_all) {
1031 plog_warn("task_id too high, should be in [0, %u]\n", lcore_cfg[lcore_id].n_tasks_all - 1);
1034 if (strcmp(lcore_cfg[lcore_id].targs[task_id].task_init->mode_str, "qos") == 0) {
1035 struct task_base *task;
1037 task = lcore_cfg[lcore_id].tasks_all[task_id];
1038 plog_info("core %d, task %d: %d mbufs stored in QoS\n", lcore_id, task_id,
1039 task_qos_n_pkts_buffered(task));
1041 #ifdef ENABLE_EXTRA_USER_STATISTICS
1043 else if (lcore_cfg[lcore_id].targs[task_id].mode == QINQ_ENCAP4) {
1044 struct task_qinq_encap4 *task;
1045 task = (struct task_qinq_encap4 *)(lcore_cfg[lcore_id].tasks_all[task_id]);
1046 for (int i=0;i<task->n_users;i++) {
1047 if (task->stats_per_user[i])
1048 plog_info("User %d: %d packets\n", i, task->stats_per_user[i]);
1053 // Only QoS thread info so far
1054 plog_err("core %d, task %d: not a qos core (%p)\n", lcore_id, task_id, lcore_cfg[lcore_id].thread_x);
1058 void cmd_rx_tx_info(void)
1060 uint32_t lcore_id = -1;
1061 while(prox_core_next(&lcore_id, 0) == 0) {
1062 for (uint8_t task_id = 0; task_id < lcore_cfg[lcore_id].n_tasks_all; ++task_id) {
1063 struct task_args *targ = &lcore_cfg[lcore_id].targs[task_id];
1065 plog_info("Core %u:", lcore_id);
1066 if (targ->rx_port_queue[0].port != OUT_DISCARD) {
1067 for (int i = 0; i < targ->nb_rxports; i++) {
1068 plog_info(" RX port %u (queue %u)", targ->rx_port_queue[i].port, targ->rx_port_queue[i].queue);
1072 for (uint8_t j = 0; j < targ->nb_rxrings; ++j) {
1073 plog_info(" RX ring[%u,%u] %p", task_id, j, targ->rx_rings[j]);
1077 for (uint8_t j = 0; j < targ->nb_txports; ++j) {
1078 plog_info(" TX port %u (queue %u)", targ->tx_port_queue[j].port,
1079 targ->tx_port_queue[j].queue);
1082 for (uint8_t j = 0; j < targ->nb_txrings; ++j) {
1083 plog_info(" TX ring %p", targ->tx_rings[j]);
1090 void cmd_get_cache_class(uint32_t lcore_id, uint32_t *set)
1092 uint64_t tmp_rmid = 0;
1093 cqm_assoc_read(lcore_id, &tmp_rmid);
1094 *set = (uint32_t)(tmp_rmid >> 32);
1097 void cmd_get_cache_class_mask(uint32_t lcore_id, uint32_t set, uint32_t *val)
1099 cat_get_class_mask(lcore_id, set, val);
1102 void cmd_set_cache_class_mask(uint32_t lcore_id, uint32_t set, uint32_t val)
1104 cat_set_class_mask(lcore_id, set, val);
1105 lcore_cfg[lcore_id].cache_set = set;
1107 while(prox_core_next(&id, 0) == 0) {
1108 if ((lcore_cfg[id].cache_set == set) && (rte_lcore_to_socket_id(id) == rte_lcore_to_socket_id(lcore_id))) {
1109 plog_info("Updating mask for core %d to %d\n", id, set);
1110 stats_update_cache_mask(id, val);
1115 void cmd_set_cache_class(uint32_t lcore_id, uint32_t set)
1117 uint64_t tmp_rmid = 0;
1119 cqm_assoc_read(lcore_id, &tmp_rmid);
1120 cqm_assoc(lcore_id, (tmp_rmid & 0xffffffff) | ((set * 1L) << 32));
1121 cat_get_class_mask(lcore_id, set, &val);
1122 stats_update_cache_mask(lcore_id, val);
1125 void cmd_cache_reset(void)
1127 uint8_t sockets[MAX_SOCKETS] = {0};
1128 uint8_t cores[MAX_SOCKETS] = {0};
1129 uint32_t mask = (1 << cat_get_num_ways()) - 1;
1130 uint32_t lcore_id = -1, socket_id;
1131 while(prox_core_next(&lcore_id, 0) == 0) {
1132 cqm_assoc(lcore_id, 0);
1133 socket_id = rte_lcore_to_socket_id(lcore_id);
1134 if (socket_id < MAX_SOCKETS) {
1135 sockets[socket_id] = 1;
1136 cores[socket_id] = lcore_id;
1138 stats_update_cache_mask(lcore_id, mask);
1139 plog_info("Setting core %d to cache mask %x\n", lcore_id, mask);
1140 lcore_cfg[lcore_id].cache_set = 0;
1142 for (uint32_t s = 0; s < MAX_SOCKETS; s++) {
1144 cat_reset_cache(cores[s]);
1146 stats_lcore_assoc_rmid();
1149 int bypass_task(uint32_t lcore_id, uint32_t task_id)
1151 struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
1152 struct task_args *targ, *starg, *dtarg;
1153 struct rte_ring *ring = NULL;
1155 if (task_id >= lconf->n_tasks_all)
1158 targ = &lconf->targs[task_id];
1159 if (targ->nb_txrings == 1) {
1160 plog_info("Task has %d receive and 1 transmmit ring and can be bypassed, %d precedent tasks\n", targ->nb_rxrings, targ->n_prev_tasks);
1162 for (unsigned int i = 0; i < targ->n_prev_tasks; i++) {
1163 starg = targ->prev_tasks[i];
1164 for (unsigned int j = 0; j < starg->nb_txrings; j++) {
1165 for (unsigned int k = 0; k < targ->nb_rxrings; k++) {
1166 if (starg->tx_rings[j] == targ->rx_rings[k]) {
1167 plog_info("bypassing ring %p and connecting it to %p\n", starg->tx_rings[j], targ->tx_rings[0]);
1168 starg->tx_rings[j] = targ->tx_rings[0];
1169 struct task_base *tbase = starg->tbase;
1170 tbase->tx_params_sw.tx_rings[j] = starg->tx_rings[j];
1176 plog_info("Task has %d receive and %d transmit ring and cannot be bypassed\n", targ->nb_rxrings, targ->nb_txrings);
1183 int reconnect_task(uint32_t lcore_id, uint32_t task_id)
1185 struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
1186 struct task_args *targ, *starg, *dtarg = NULL;
1187 struct rte_ring *ring = NULL;
1189 if (task_id >= lconf->n_tasks_all)
1192 targ = &lconf->targs[task_id];
1193 if (targ->nb_txrings == 1) {
1195 for (unsigned int i = 0; i < targ->n_prev_tasks; i++) {
1196 starg = targ->prev_tasks[i];
1197 for (unsigned int j = 0; j < starg->nb_txrings; j++) {
1198 if (starg->tx_rings[j] == targ->tx_rings[0]) {
1199 if (targ->n_prev_tasks == targ->nb_rxrings) {
1200 starg->tx_rings[j] = targ->rx_rings[i];
1201 struct task_base *tbase = starg->tbase;
1202 tbase->tx_params_sw.tx_rings[j] = starg->tx_rings[j];
1203 plog_info("Task has %d receive and 1 transmmit ring and can be reconnected, %d precedent tasks\n", targ->nb_rxrings, targ->n_prev_tasks);
1204 } else if (targ->nb_rxrings == 1) {
1205 starg->tx_rings[j] = targ->rx_rings[0];
1206 struct task_base *tbase = starg->tbase;
1207 tbase->tx_params_sw.tx_rings[j] = starg->tx_rings[j];
1208 plog_info("Task has %d receive and 1 transmmit ring and ring %p can be reconnected, %d precedent tasks\n", targ->nb_rxrings, starg->tx_rings[j], targ->n_prev_tasks);
1210 plog_err("Unexpected configuration: %d precedent tasks, %d rx rings\n", targ->n_prev_tasks, targ->nb_rxrings);
1216 plog_info("Task has %d receive and %d transmit ring and cannot be bypassed\n", targ->nb_rxrings, targ->nb_txrings);