FD.io VPP  v18.04-17-g3a0d853
Vector Packet Processing
cli.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015 Cisco and/or its affiliates.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at:
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include <vnet/vnet.h>
16 #include <vppinfra/vec.h>
17 #include <vppinfra/error.h>
18 #include <vppinfra/format.h>
19 #include <vppinfra/xxhash.h>
20 
21 #include <vnet/ethernet/ethernet.h>
22 #include <dpdk/device/dpdk.h>
24 #include <vnet/mpls/packet.h>
25 
26 #include <dpdk/device/dpdk_priv.h>
27 
28 /**
29  * @file
30  * @brief CLI for DPDK Abstraction Layer and pcap Tx Trace.
31  *
32  * This file contains the source code for CLI for DPDK
33  * Abstraction Layer and pcap Tx Trace.
34  */
35 
36 
37 static clib_error_t *
38 get_hqos (u32 hw_if_index, u32 subport_id, dpdk_device_t ** xd,
39  dpdk_device_config_t ** devconf)
40 {
41  dpdk_main_t *dm = &dpdk_main;
43  struct rte_eth_dev_info dev_info;
44  uword *p = 0;
45  clib_error_t *error = NULL;
46 
47 
48  if (hw_if_index == (u32) ~ 0)
49  {
50  error = clib_error_return (0, "please specify valid interface name");
51  goto done;
52  }
53 
54  if (subport_id != 0)
55  {
56  error = clib_error_return (0, "Invalid subport");
57  goto done;
58  }
59 
60  hw = vnet_get_hw_interface (dm->vnet_main, hw_if_index);
61  *xd = vec_elt_at_index (dm->devices, hw->dev_instance);
62 
63  rte_eth_dev_info_get ((*xd)->device_index, &dev_info);
64  if (dev_info.pci_dev)
65  { /* bonded interface has no pci info */
66  vlib_pci_addr_t pci_addr;
67 
68  pci_addr.domain = dev_info.pci_dev->addr.domain;
69  pci_addr.bus = dev_info.pci_dev->addr.bus;
70  pci_addr.slot = dev_info.pci_dev->addr.devid;
71  pci_addr.function = dev_info.pci_dev->addr.function;
72 
73  p =
74  hash_get (dm->conf->device_config_index_by_pci_addr, pci_addr.as_u32);
75  }
76 
77  if (p)
78  (*devconf) = pool_elt_at_index (dm->conf->dev_confs, p[0]);
79  else
80  (*devconf) = &dm->conf->default_devconf;
81 
82 done:
83  return error;
84 }
85 
86 static clib_error_t *
88  unformat_input_t * input, vlib_cli_command_t * cmd)
89 {
90 #define PCAP_DEF_PKT_TO_CAPTURE (100)
91 
92  unformat_input_t _line_input, *line_input = &_line_input;
93  dpdk_main_t *dm = &dpdk_main;
94  u8 *filename;
95  u8 *chroot_filename = 0;
96  u32 max = 0;
97  int enabled = 0;
98  int errorFlag = 0;
99  clib_error_t *error = 0;
100 
101  /* Get a line of input. */
102  if (!unformat_user (input, unformat_line_input, line_input))
103  return 0;
104 
105  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
106  {
107  if (unformat (line_input, "on"))
108  {
109  if (dm->tx_pcap_enable == 0)
110  {
111  enabled = 1;
112  }
113  else
114  {
115  vlib_cli_output (vm, "pcap tx capture already on...");
116  errorFlag = 1;
117  break;
118  }
119  }
120  else if (unformat (line_input, "off"))
121  {
122  if (dm->tx_pcap_enable)
123  {
124  vlib_cli_output (vm, "captured %d pkts...",
125  dm->pcap_main.n_packets_captured + 1);
127  {
130  error = pcap_write (&dm->pcap_main);
131  if (error)
132  clib_error_report (error);
133  else
134  vlib_cli_output (vm, "saved to %s...", dm->pcap_filename);
135  }
136 
137  dm->tx_pcap_enable = 0;
138  }
139  else
140  {
141  vlib_cli_output (vm, "pcap tx capture already off...");
142  errorFlag = 1;
143  break;
144  }
145  }
146  else if (unformat (line_input, "max %d", &max))
147  {
148  if (dm->tx_pcap_enable)
149  {
150  vlib_cli_output (vm,
151  "can't change max value while pcap tx capture active...");
152  errorFlag = 1;
153  break;
154  }
155  }
156  else if (unformat (line_input, "intfc %U",
158  &dm->pcap_sw_if_index))
159  ;
160 
161  else if (unformat (line_input, "intfc any"))
162  {
163  dm->pcap_sw_if_index = 0;
164  }
165  else if (unformat (line_input, "file %s", &filename))
166  {
167  if (dm->tx_pcap_enable)
168  {
169  vlib_cli_output (vm,
170  "can't change file while pcap tx capture active...");
171  errorFlag = 1;
172  break;
173  }
174 
175  /* Brain-police user path input */
176  if (strstr ((char *) filename, "..")
177  || index ((char *) filename, '/'))
178  {
179  vlib_cli_output (vm, "illegal characters in filename '%s'",
180  filename);
181  vlib_cli_output (vm,
182  "Hint: Only filename, do not enter directory structure.");
183  vec_free (filename);
184  errorFlag = 1;
185  break;
186  }
187 
188  chroot_filename = format (0, "/tmp/%s%c", filename, 0);
189  vec_free (filename);
190  }
191  else if (unformat (line_input, "status"))
192  {
193  if (dm->pcap_sw_if_index == 0)
194  {
195  vlib_cli_output (vm, "max is %d for any interface to file %s",
196  dm->
197  pcap_pkts_to_capture ? dm->pcap_pkts_to_capture
199  dm->
200  pcap_filename ? dm->pcap_filename : (u8 *)
201  "/tmp/vpe.pcap");
202  }
203  else
204  {
205  vlib_cli_output (vm, "max is %d for interface %U to file %s",
206  dm->
207  pcap_pkts_to_capture ? dm->pcap_pkts_to_capture
210  dm->pcap_sw_if_index,
211  dm->
212  pcap_filename ? dm->pcap_filename : (u8 *)
213  "/tmp/vpe.pcap");
214  }
215 
216  if (dm->tx_pcap_enable == 0)
217  {
218  vlib_cli_output (vm, "pcap tx capture is off...");
219  }
220  else
221  {
222  vlib_cli_output (vm, "pcap tx capture is on: %d of %d pkts...",
225  }
226  break;
227  }
228 
229  else
230  {
231  error = clib_error_return (0, "unknown input `%U'",
232  format_unformat_error, line_input);
233  errorFlag = 1;
234  break;
235  }
236  }
237  unformat_free (line_input);
238 
239 
240  if (errorFlag == 0)
241  {
242  /* Since no error, save configured values. */
243  if (chroot_filename)
244  {
245  if (dm->pcap_filename)
246  vec_free (dm->pcap_filename);
247  vec_add1 (chroot_filename, 0);
248  dm->pcap_filename = chroot_filename;
249  }
250 
251  if (max)
252  dm->pcap_pkts_to_capture = max;
253 
254 
255  if (enabled)
256  {
257  if (dm->pcap_filename == 0)
258  dm->pcap_filename = format (0, "/tmp/vpe.pcap%c", 0);
259 
260  memset (&dm->pcap_main, 0, sizeof (dm->pcap_main));
261  dm->pcap_main.file_name = (char *) dm->pcap_filename;
263  if (dm->pcap_pkts_to_capture)
265 
266  dm->pcap_main.packet_type = PCAP_PACKET_TYPE_ethernet;
267  dm->tx_pcap_enable = 1;
268  vlib_cli_output (vm, "pcap tx capture on...");
269  }
270  }
271  else if (chroot_filename)
272  vec_free (chroot_filename);
273 
274 
275  return error;
276 }
277 
278 /*?
279  * This command is used to start or stop a packet capture, or show
280  * the status of packet capture.
281  *
282  * This command has the following optional parameters:
283  *
284  * - <b>on|off</b> - Used to start or stop a packet capture.
285  *
286  * - <b>max <nn></b> - Depth of local buffer. Once '<em>nn</em>' number
287  * of packets have been received, buffer is flushed to file. Once another
288  * '<em>nn</em>' number of packets have been received, buffer is flushed
289  * to file, overwriting previous write. If not entered, value defaults
290  * to 100. Can only be updated if packet capture is off.
291  *
292  * - <b>intfc <interface>|any</b> - Used to specify a given interface,
293  * or use '<em>any</em>' to run packet capture on all interfaces.
294  * '<em>any</em>' is the default if not provided. Settings from a previous
295  * packet capture are preserved, so '<em>any</em>' can be used to reset
296  * the interface setting.
297  *
298  * - <b>file <name></b> - Used to specify the output filename. The file will
299  * be placed in the '<em>/tmp</em>' directory, so only the filename is
300  * supported. Directory should not be entered. If file already exists, file
301  * will be overwritten. If no filename is provided, '<em>/tmp/vpe.pcap</em>'
302  * will be used. Can only be updated if packet capture is off.
303  *
304  * - <b>status</b> - Displays the current status and configured attributes
305  * associated with a packet capture. If packet capture is in progress,
306  * '<em>status</em>' also will return the number of packets currently in
307  * the local buffer. All additional attributes entered on command line
308  * with '<em>status</em>' will be ingnored and not applied.
309  *
310  * @cliexpar
311  * Example of how to display the status of a tx packet capture when off:
312  * @cliexstart{pcap tx trace status}
313  * max is 100, for any interface to file /tmp/vpe.pcap
314  * pcap tx capture is off...
315  * @cliexend
316  * Example of how to start a tx packet capture:
317  * @cliexstart{pcap tx trace on max 35 intfc GigabitEthernet0/8/0 file vppTest.pcap}
318  * pcap tx capture on...
319  * @cliexend
320  * Example of how to display the status of a tx packet capture in progress:
321  * @cliexstart{pcap tx trace status}
322  * max is 35, for interface GigabitEthernet0/8/0 to file /tmp/vppTest.pcap
323  * pcap tx capture is on: 20 of 35 pkts...
324  * @cliexend
325  * Example of how to stop a tx packet capture:
326  * @cliexstart{vppctl pcap tx trace off}
327  * captured 21 pkts...
328  * saved to /tmp/vppTest.pcap...
329  * @cliexend
330 ?*/
331 /* *INDENT-OFF* */
332 VLIB_CLI_COMMAND (pcap_trace_command, static) = {
333  .path = "pcap tx trace",
334  .short_help =
335  "pcap tx trace [on|off] [max <nn>] [intfc <interface>|any] [file <name>] [status]",
336  .function = pcap_trace_command_fn,
337 };
338 /* *INDENT-ON* */
339 
340 
341 static clib_error_t *
343  vlib_cli_command_t * cmd)
344 {
345  struct rte_mempool *rmp;
346  int i;
347 
348  for (i = 0; i < vec_len (dpdk_main.pktmbuf_pools); i++)
349  {
350  rmp = dpdk_main.pktmbuf_pools[i];
351  if (rmp)
352  {
353  unsigned count = rte_mempool_avail_count (rmp);
354  unsigned free_count = rte_mempool_in_use_count (rmp);
355 
356  vlib_cli_output (vm,
357  "name=\"%s\" available = %7d allocated = %7d total = %7d\n",
358  rmp->name, (u32) count, (u32) free_count,
359  (u32) (count + free_count));
360  }
361  else
362  {
363  vlib_cli_output (vm, "rte_mempool is NULL (!)\n");
364  }
365  }
366  return 0;
367 }
368 
369 /*?
370  * This command displays statistics of each DPDK mempool.
371  *
372  * @cliexpar
373  * Example of how to display DPDK buffer data:
374  * @cliexstart{show dpdk buffer}
375  * name="mbuf_pool_socket0" available = 15104 allocated = 1280 total = 16384
376  * @cliexend
377 ?*/
378 /* *INDENT-OFF* */
379 VLIB_CLI_COMMAND (cmd_show_dpdk_bufferr,static) = {
380  .path = "show dpdk buffer",
381  .short_help = "show dpdk buffer",
382  .function = show_dpdk_buffer,
383  .is_mp_safe = 1,
384 };
385 /* *INDENT-ON* */
386 
387 static clib_error_t *
389  vlib_cli_command_t * cmd)
390 {
391  static u32 *allocated_buffers;
392  u32 n_alloc = 0;
393  u32 n_free = 0;
394  u32 first, actual_alloc;
395 
397  {
398  if (unformat (input, "allocate %d", &n_alloc))
399  ;
400  else if (unformat (input, "free %d", &n_free))
401  ;
402  else
403  break;
404  }
405 
406  if (n_free)
407  {
408  if (vec_len (allocated_buffers) < n_free)
409  return clib_error_return (0, "Can't free %d, only %d allocated",
410  n_free, vec_len (allocated_buffers));
411 
412  first = vec_len (allocated_buffers) - n_free;
413  vlib_buffer_free (vm, allocated_buffers + first, n_free);
414  _vec_len (allocated_buffers) = first;
415  }
416  if (n_alloc)
417  {
418  first = vec_len (allocated_buffers);
419  vec_validate (allocated_buffers,
420  vec_len (allocated_buffers) + n_alloc - 1);
421 
422  actual_alloc = vlib_buffer_alloc (vm, allocated_buffers + first,
423  n_alloc);
424  _vec_len (allocated_buffers) = first + actual_alloc;
425 
426  if (actual_alloc < n_alloc)
427  vlib_cli_output (vm, "WARNING: only allocated %d buffers",
428  actual_alloc);
429  }
430 
431  vlib_cli_output (vm, "Currently %d buffers allocated",
432  vec_len (allocated_buffers));
433 
434  if (allocated_buffers && vec_len (allocated_buffers) == 0)
435  vec_free (allocated_buffers);
436 
437  return 0;
438 }
439 
440 /*?
441  * This command tests the allocation and freeing of DPDK buffers.
442  * If both '<em>allocate</em>' and '<em>free</em>' are entered on the
443  * same command, the '<em>free</em>' is executed first. If no
444  * parameters are provided, this command display how many DPDK buffers
445  * the test command has allocated.
446  *
447  * @cliexpar
448  * @parblock
449  *
450  * Example of how to display how many DPDK buffer test command has allcoated:
451  * @cliexstart{test dpdk buffer}
452  * Currently 0 buffers allocated
453  * @cliexend
454  *
455  * Example of how to allocate DPDK buffers using the test command:
456  * @cliexstart{test dpdk buffer allocate 10}
457  * Currently 10 buffers allocated
458  * @cliexend
459  *
460  * Example of how to free DPDK buffers allocated by the test command:
461  * @cliexstart{test dpdk buffer free 10}
462  * Currently 0 buffers allocated
463  * @cliexend
464  * @endparblock
465 ?*/
466 /* *INDENT-OFF* */
467 VLIB_CLI_COMMAND (cmd_test_dpdk_buffer,static) = {
468  .path = "test dpdk buffer",
469  .short_help = "test dpdk buffer [allocate <nn>] [free <nn>]",
470  .function = test_dpdk_buffer,
471  .is_mp_safe = 1,
472 };
473 /* *INDENT-ON* */
474 
475 static clib_error_t *
477  vlib_cli_command_t * cmd)
478 {
479  unformat_input_t _line_input, *line_input = &_line_input;
480  dpdk_main_t *dm = &dpdk_main;
482  dpdk_device_t *xd;
483  u32 hw_if_index = (u32) ~ 0;
484  u32 nb_rx_desc = (u32) ~ 0;
485  u32 nb_tx_desc = (u32) ~ 0;
486  clib_error_t *error = NULL;
487 
488  if (!unformat_user (input, unformat_line_input, line_input))
489  return 0;
490 
491  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
492  {
493  if (unformat
494  (line_input, "%U", unformat_vnet_hw_interface, dm->vnet_main,
495  &hw_if_index))
496  ;
497  else if (unformat (line_input, "tx %d", &nb_tx_desc))
498  ;
499  else if (unformat (line_input, "rx %d", &nb_rx_desc))
500  ;
501  else
502  {
503  error = clib_error_return (0, "parse error: '%U'",
504  format_unformat_error, line_input);
505  goto done;
506  }
507  }
508 
509  if (hw_if_index == (u32) ~ 0)
510  {
511  error = clib_error_return (0, "please specify valid interface name");
512  goto done;
513  }
514 
515  hw = vnet_get_hw_interface (dm->vnet_main, hw_if_index);
516  xd = vec_elt_at_index (dm->devices, hw->dev_instance);
517 
518  if ((xd->flags & DPDK_DEVICE_FLAG_PMD) == 0)
519  {
520  error =
522  "number of descriptors can be set only for "
523  "physical devices");
524  goto done;
525  }
526 
527  if ((nb_rx_desc == (u32) ~ 0 || nb_rx_desc == xd->nb_rx_desc) &&
528  (nb_tx_desc == (u32) ~ 0 || nb_tx_desc == xd->nb_tx_desc))
529  {
530  error = clib_error_return (0, "nothing changed");
531  goto done;
532  }
533 
534  if (nb_rx_desc != (u32) ~ 0)
535  xd->nb_rx_desc = nb_rx_desc;
536 
537  if (nb_tx_desc != (u32) ~ 0)
538  xd->nb_tx_desc = nb_tx_desc;
539 
540  dpdk_device_setup (xd);
541 
542  if (vec_len (xd->errors))
543  return clib_error_return (0, "%U", format_dpdk_device_errors, xd);
544 
545 done:
546  unformat_free (line_input);
547 
548  return error;
549 }
550 
551 /*?
552  * This command sets the number of DPDK '<em>rx</em>' and
553  * '<em>tx</em>' descriptors for the given physical interface. Use
554  * the command '<em>show hardware-interface</em>' to display the
555  * current descriptor allocation.
556  *
557  * @cliexpar
558  * Example of how to set the DPDK interface descriptors:
559  * @cliexcmd{set dpdk interface descriptors GigabitEthernet0/8/0 rx 512 tx 512}
560 ?*/
561 /* *INDENT-OFF* */
562 VLIB_CLI_COMMAND (cmd_set_dpdk_if_desc,static) = {
563  .path = "set dpdk interface descriptors",
564  .short_help = "set dpdk interface descriptors <interface> [rx <nn>] [tx <nn>]",
565  .function = set_dpdk_if_desc,
566 };
567 /* *INDENT-ON* */
568 
569 static int
570 dpdk_device_queue_sort (void *a1, void *a2)
571 {
572  dpdk_device_and_queue_t *dq1 = a1;
573  dpdk_device_and_queue_t *dq2 = a2;
574 
575  if (dq1->device > dq2->device)
576  return 1;
577  else if (dq1->device < dq2->device)
578  return -1;
579  else if (dq1->queue_id > dq2->queue_id)
580  return 1;
581  else if (dq1->queue_id < dq2->queue_id)
582  return -1;
583  else
584  return 0;
585 }
586 
587 
588 static clib_error_t *
590  vlib_cli_command_t * cmd)
591 {
593  dpdk_main_t *dm = &dpdk_main;
595  int cpu;
596 
597  if (tm->n_vlib_mains == 1)
598  vlib_cli_output (vm, "All interfaces are handled by main thread");
599 
600  for (cpu = 0; cpu < vec_len (dm->devices_by_hqos_cpu); cpu++)
601  {
602  if (cpu >= dm->hqos_cpu_first_index &&
603  cpu < (dm->hqos_cpu_first_index + dm->hqos_cpu_count))
604  vlib_cli_output (vm, "Thread %u (%s at lcore %u):", cpu,
605  vlib_worker_threads[cpu].name,
606  vlib_worker_threads[cpu].lcore_id);
607 
608  vec_foreach (dq, dm->devices_by_hqos_cpu[cpu])
609  {
610  u32 hw_if_index = dm->devices[dq->device].hw_if_index;
612  vnet_get_hw_interface (dm->vnet_main, hw_if_index);
613  vlib_cli_output (vm, " %v queue %u", hi->name, dq->queue_id);
614  }
615  }
616  return 0;
617 }
618 
619 /*?
620  * This command is used to display the thread and core each
621  * DPDK output interface and HQoS queue is assigned too.
622  *
623  * @cliexpar
624  * Example of how to display the DPDK output interface and HQoS queue placement:
625  * @cliexstart{show dpdk interface hqos placement}
626  * Thread 1 (vpp_hqos-threads_0 at lcore 3):
627  * GigabitEthernet0/8/0 queue 0
628  * Thread 2 (vpp_hqos-threads_1 at lcore 4):
629  * GigabitEthernet0/9/0 queue 0
630  * @cliexend
631 ?*/
632 /* *INDENT-OFF* */
633 VLIB_CLI_COMMAND (cmd_show_dpdk_if_hqos_placement, static) = {
634  .path = "show dpdk interface hqos placement",
635  .short_help = "show dpdk interface hqos placement",
636  .function = show_dpdk_if_hqos_placement,
637 };
638 /* *INDENT-ON* */
639 
640 static clib_error_t *
642  vlib_cli_command_t * cmd)
643 {
644  unformat_input_t _line_input, *line_input = &_line_input;
645  dpdk_main_t *dm = &dpdk_main;
648  dpdk_device_t *xd;
649  u32 hw_if_index = (u32) ~ 0;
650  u32 cpu = (u32) ~ 0;
651  int i;
652  clib_error_t *error = NULL;
653 
654  if (!unformat_user (input, unformat_line_input, line_input))
655  return 0;
656 
657  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
658  {
659  if (unformat
660  (line_input, "%U", unformat_vnet_hw_interface, dm->vnet_main,
661  &hw_if_index))
662  ;
663  else if (unformat (line_input, "thread %d", &cpu))
664  ;
665  else
666  {
667  error = clib_error_return (0, "parse error: '%U'",
668  format_unformat_error, line_input);
669  goto done;
670  }
671  }
672 
673  if (hw_if_index == (u32) ~ 0)
674  return clib_error_return (0, "please specify valid interface name");
675 
676  if (cpu < dm->hqos_cpu_first_index ||
677  cpu >= (dm->hqos_cpu_first_index + dm->hqos_cpu_count))
678  {
679  error = clib_error_return (0, "please specify valid thread id");
680  goto done;
681  }
682 
683  hw = vnet_get_hw_interface (dm->vnet_main, hw_if_index);
684  xd = vec_elt_at_index (dm->devices, hw->dev_instance);
685 
686  for (i = 0; i < vec_len (dm->devices_by_hqos_cpu); i++)
687  {
688  vec_foreach (dq, dm->devices_by_hqos_cpu[i])
689  {
690  if (hw_if_index == dm->devices[dq->device].hw_if_index)
691  {
692  if (cpu == i) /* nothing to do */
693  goto done;
694 
696  dq - dm->devices_by_hqos_cpu[i]);
697  vec_add2 (dm->devices_by_hqos_cpu[cpu], dq, 1);
698  dq->queue_id = 0;
699  dq->device = xd->device_index;
700 
703 
706 
707  goto done;
708  }
709  }
710  }
711 
712  error = clib_error_return (0, "not found");
713 
714 done:
715  unformat_free (line_input);
716 
717  return error;
718 }
719 
720 /*?
721  * This command is used to assign a given DPDK output interface and
722  * HQoS queue to a different thread. This will not create a thread,
723  * so the thread must already exist. Use '<em>/etc/vpp/startup.conf</em>'
724  * for the initial thread creation. See @ref qos_doc for more details.
725  *
726  * @cliexpar
727  * Example of how to display the DPDK output interface and HQoS queue placement:
728  * @cliexstart{show dpdk interface hqos placement}
729  * Thread 1 (vpp_hqos-threads_0 at lcore 3):
730  * GigabitEthernet0/8/0 queue 0
731  * Thread 2 (vpp_hqos-threads_1 at lcore 4):
732  * GigabitEthernet0/9/0 queue 0
733  * @cliexend
734  * Example of how to assign a DPDK output interface and HQoS queue to a thread:
735  * @cliexcmd{set dpdk interface hqos placement GigabitEthernet0/8/0 thread 2}
736 ?*/
737 /* *INDENT-OFF* */
738 VLIB_CLI_COMMAND (cmd_set_dpdk_if_hqos_placement, static) = {
739  .path = "set dpdk interface hqos placement",
740  .short_help = "set dpdk interface hqos placement <interface> thread <n>",
741  .function = set_dpdk_if_hqos_placement,
742 };
743 /* *INDENT-ON* */
744 
745 static clib_error_t *
747  vlib_cli_command_t * cmd)
748 {
749  unformat_input_t _line_input, *line_input = &_line_input;
750  dpdk_main_t *dm = &dpdk_main;
752  dpdk_device_t *xd;
753  u32 hw_if_index = (u32) ~ 0;
754  u32 subport_id = (u32) ~ 0;
755  u32 pipe_id = (u32) ~ 0;
756  u32 profile_id = (u32) ~ 0;
757  int rv;
758  clib_error_t *error = NULL;
759 
760  if (!unformat_user (input, unformat_line_input, line_input))
761  return 0;
762 
763  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
764  {
765  if (unformat
766  (line_input, "%U", unformat_vnet_hw_interface, dm->vnet_main,
767  &hw_if_index))
768  ;
769  else if (unformat (line_input, "subport %d", &subport_id))
770  ;
771  else if (unformat (line_input, "pipe %d", &pipe_id))
772  ;
773  else if (unformat (line_input, "profile %d", &profile_id))
774  ;
775  else
776  {
777  error = clib_error_return (0, "parse error: '%U'",
778  format_unformat_error, line_input);
779  goto done;
780  }
781  }
782 
783  if (hw_if_index == (u32) ~ 0)
784  {
785  error = clib_error_return (0, "please specify valid interface name");
786  goto done;
787  }
788 
789  hw = vnet_get_hw_interface (dm->vnet_main, hw_if_index);
790  xd = vec_elt_at_index (dm->devices, hw->dev_instance);
791 
792  rv =
793  rte_sched_pipe_config (xd->hqos_ht->hqos, subport_id, pipe_id,
794  profile_id);
795  if (rv)
796  {
797  error = clib_error_return (0, "pipe configuration failed");
798  goto done;
799  }
800 
801 done:
802  unformat_free (line_input);
803 
804  return error;
805 }
806 
807 /*?
808  * This command is used to change the profile associate with a HQoS pipe. The
809  * '<em><profile_id></em>' is zero based. Use the command
810  * '<em>show dpdk interface hqos</em>' to display the content of each profile.
811  * See @ref qos_doc for more details.
812  *
813  * @note
814  * Currently there is not an API to create a new HQoS pipe profile. One is
815  * created by default in the code (search for '<em>hqos_pipe_params_default</em>'').
816  * Additional profiles can be created in code and code recompiled. Then use this
817  * command to assign it.
818  *
819  * @cliexpar
820  * Example of how to assign a new profile to a HQoS pipe:
821  * @cliexcmd{set dpdk interface hqos pipe GigabitEthernet0/8/0 subport 0 pipe 2 profile 1}
822 ?*/
823 /* *INDENT-OFF* */
824 VLIB_CLI_COMMAND (cmd_set_dpdk_if_hqos_pipe, static) =
825 {
826  .path = "set dpdk interface hqos pipe",
827  .short_help = "set dpdk interface hqos pipe <interface> subport <subport_id> pipe <pipe_id> "
828  "profile <profile_id>",
829  .function = set_dpdk_if_hqos_pipe,
830 };
831 /* *INDENT-ON* */
832 
833 static clib_error_t *
835  vlib_cli_command_t * cmd)
836 {
837  unformat_input_t _line_input, *line_input = &_line_input;
838  dpdk_main_t *dm = &dpdk_main;
839  dpdk_device_t *xd = NULL;
840  u32 hw_if_index = (u32) ~ 0;
841  u32 subport_id = (u32) ~ 0;
842  struct rte_sched_subport_params p;
843  int rv;
844  clib_error_t *error = NULL;
845  u32 tb_rate = (u32) ~ 0;
846  u32 tb_size = (u32) ~ 0;
847  u32 tc_rate[RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE] =
848  { (u32) ~ 0, (u32) ~ 0, (u32) ~ 0, (u32) ~ 0 };
849  u32 tc_period = (u32) ~ 0;
850  dpdk_device_config_t *devconf = NULL;
851 
852  if (!unformat_user (input, unformat_line_input, line_input))
853  return 0;
854 
855  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
856  {
857  if (unformat
858  (line_input, "%U", unformat_vnet_hw_interface, dm->vnet_main,
859  &hw_if_index))
860  ;
861  else if (unformat (line_input, "subport %d", &subport_id))
862  ;
863  else if (unformat (line_input, "rate %d", &tb_rate))
864  ;
865  else if (unformat (line_input, "bktsize %d", &tb_size))
866  ;
867  else if (unformat (line_input, "tc0 %d", &tc_rate[0]))
868  ;
869  else if (unformat (line_input, "tc1 %d", &tc_rate[1]))
870  ;
871  else if (unformat (line_input, "tc2 %d", &tc_rate[2]))
872  ;
873  else if (unformat (line_input, "tc3 %d", &tc_rate[3]))
874  ;
875  else if (unformat (line_input, "period %d", &tc_period))
876  ;
877  else
878  {
879  error = clib_error_return (0, "parse error: '%U'",
880  format_unformat_error, line_input);
881  goto done;
882  }
883  }
884 
885  error = get_hqos (hw_if_index, subport_id, &xd, &devconf);
886 
887  if (error == NULL)
888  {
889  /* Copy the current values over to local structure. */
890  memcpy (&p, &devconf->hqos.subport[subport_id], sizeof (p));
891 
892  /* Update local structure with input values. */
893  if (tb_rate != (u32) ~ 0)
894  {
895  p.tb_rate = tb_rate;
896  p.tc_rate[0] = tb_rate;
897  p.tc_rate[1] = tb_rate;
898  p.tc_rate[2] = tb_rate;
899  p.tc_rate[3] = tb_rate;
900  }
901  if (tb_size != (u32) ~ 0)
902  {
903  p.tb_size = tb_size;
904  }
905  if (tc_rate[0] != (u32) ~ 0)
906  {
907  p.tc_rate[0] = tc_rate[0];
908  }
909  if (tc_rate[1] != (u32) ~ 0)
910  {
911  p.tc_rate[1] = tc_rate[1];
912  }
913  if (tc_rate[2] != (u32) ~ 0)
914  {
915  p.tc_rate[2] = tc_rate[2];
916  }
917  if (tc_rate[3] != (u32) ~ 0)
918  {
919  p.tc_rate[3] = tc_rate[3];
920  }
921  if (tc_period != (u32) ~ 0)
922  {
923  p.tc_period = tc_period;
924  }
925 
926  /* Apply changes. */
927  rv = rte_sched_subport_config (xd->hqos_ht->hqos, subport_id, &p);
928  if (rv)
929  {
930  error = clib_error_return (0, "subport configuration failed");
931  goto done;
932  }
933  else
934  {
935  /* Successfully applied, so save of the input values. */
936  memcpy (&devconf->hqos.subport[subport_id], &p, sizeof (p));
937  }
938  }
939 
940 done:
941  unformat_free (line_input);
942 
943  return error;
944 }
945 
946 /*?
947  * This command is used to set the subport level parameters such as token
948  * bucket rate (bytes per seconds), token bucket size (bytes), traffic class
949  * rates (bytes per seconds) and token update period (Milliseconds).
950  *
951  * By default, the '<em>rate</em>' is set to 1250000000 bytes/second (10GbE
952  * rate) and each of the four traffic classes is set to 100% of the port rate.
953  * If the '<em>rate</em>' is updated by this command, all four traffic classes
954  * are assigned the same value. Each of the four traffic classes can be updated
955  * individually.
956  *
957  * @cliexpar
958  * Example of how modify the subport attributes for a 1GbE link:
959  * @cliexcmd{set dpdk interface hqos subport GigabitEthernet0/8/0 subport 0 rate 125000000}
960 ?*/
961 /* *INDENT-OFF* */
962 VLIB_CLI_COMMAND (cmd_set_dpdk_if_hqos_subport, static) = {
963  .path = "set dpdk interface hqos subport",
964  .short_help = "set dpdk interface hqos subport <interface> subport <subport_id> "
965  "[rate <n>] [bktsize <n>] [tc0 <n>] [tc1 <n>] [tc2 <n>] [tc3 <n>] "
966  "[period <n>]",
967  .function = set_dpdk_if_hqos_subport,
968 };
969 /* *INDENT-ON* */
970 
971 static clib_error_t *
973  vlib_cli_command_t * cmd)
974 {
975  unformat_input_t _line_input, *line_input = &_line_input;
977  dpdk_main_t *dm = &dpdk_main;
979  dpdk_device_t *xd;
980  u32 hw_if_index = (u32) ~ 0;
981  u32 tc = (u32) ~ 0;
982  u32 queue = (u32) ~ 0;
983  u32 entry = (u32) ~ 0;
984  u32 val, i;
985  clib_error_t *error = NULL;
986 
987  if (!unformat_user (input, unformat_line_input, line_input))
988  return 0;
989 
990  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
991  {
992  if (unformat
993  (line_input, "%U", unformat_vnet_hw_interface, dm->vnet_main,
994  &hw_if_index))
995  ;
996  else if (unformat (line_input, "entry %d", &entry))
997  ;
998  else if (unformat (line_input, "tc %d", &tc))
999  ;
1000  else if (unformat (line_input, "queue %d", &queue))
1001  ;
1002  else
1003  {
1004  error = clib_error_return (0, "parse error: '%U'",
1005  format_unformat_error, line_input);
1006  goto done;
1007  }
1008  }
1009 
1010  if (hw_if_index == (u32) ~ 0)
1011  {
1012  error = clib_error_return (0, "please specify valid interface name");
1013  goto done;
1014  }
1015  if (entry >= 64)
1016  {
1017  error = clib_error_return (0, "invalid entry");
1018  goto done;
1019  }
1020  if (tc >= RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE)
1021  {
1022  error = clib_error_return (0, "invalid traffic class");
1023  goto done;
1024  }
1025  if (queue >= RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS)
1026  {
1027  error = clib_error_return (0, "invalid traffic class queue");
1028  goto done;
1029  }
1030 
1031  hw = vnet_get_hw_interface (dm->vnet_main, hw_if_index);
1032  xd = vec_elt_at_index (dm->devices, hw->dev_instance);
1033 
1034  /* Detect the set of worker threads */
1035  uword *p = hash_get_mem (tm->thread_registrations_by_name, "workers");
1036  /* Should never happen, shut up Coverity warning */
1037  if (p == 0)
1038  {
1039  error = clib_error_return (0, "no worker registrations?");
1040  goto done;
1041  }
1042 
1044  int worker_thread_first = tr->first_index;
1045  int worker_thread_count = tr->count;
1046 
1047  val = tc * RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS + queue;
1048  for (i = 0; i < worker_thread_count; i++)
1049  xd->hqos_wt[worker_thread_first + i].hqos_tc_table[entry] = val;
1050 
1051 done:
1052  unformat_free (line_input);
1053 
1054  return error;
1055 }
1056 
1057 /*?
1058  * This command is used to set the traffic class translation table. The
1059  * traffic class translation table is used to map 64 values (0-63) to one of
1060  * four traffic class and one of four HQoS input queue. Use the '<em>show
1061  * dpdk interface hqos</em>' command to display the traffic class translation
1062  * table. See @ref qos_doc for more details.
1063  *
1064  * This command has the following parameters:
1065  *
1066  * - <b><interface></b> - Used to specify the output interface.
1067  *
1068  * - <b>entry <map_val></b> - Mapped value (0-63) to assign traffic class and queue to.
1069  *
1070  * - <b>tc <tc_id></b> - Traffic class (0-3) to be used by the provided mapped value.
1071  *
1072  * - <b>queue <queue_id></b> - HQoS input queue (0-3) to be used by the provided mapped value.
1073  *
1074  * @cliexpar
1075  * Example of how modify the traffic class translation table:
1076  * @cliexcmd{set dpdk interface hqos tctbl GigabitEthernet0/8/0 entry 16 tc 2 queue 2}
1077 ?*/
1078 /* *INDENT-OFF* */
1079 VLIB_CLI_COMMAND (cmd_set_dpdk_if_hqos_tctbl, static) = {
1080  .path = "set dpdk interface hqos tctbl",
1081  .short_help = "set dpdk interface hqos tctbl <interface> entry <map_val> tc <tc_id> queue <queue_id>",
1082  .function = set_dpdk_if_hqos_tctbl,
1083 };
1084 /* *INDENT-ON* */
1085 
1086 static clib_error_t *
1088  vlib_cli_command_t * cmd)
1089 {
1090  unformat_input_t _line_input, *line_input = &_line_input;
1092  dpdk_main_t *dm = &dpdk_main;
1093  clib_error_t *error = NULL;
1094 
1095  /* Device specific data */
1096  struct rte_eth_dev_info dev_info;
1097  dpdk_device_config_t *devconf = 0;
1098  vnet_hw_interface_t *hw;
1099  dpdk_device_t *xd;
1100  u32 hw_if_index = (u32) ~ 0;
1101 
1102  /* Detect the set of worker threads */
1103  uword *p = hash_get_mem (tm->thread_registrations_by_name, "workers");
1104  /* Should never happen, shut up Coverity warning */
1105  if (p == 0)
1106  return clib_error_return (0, "no worker registrations?");
1107 
1109  int worker_thread_first = tr->first_index;
1110  int worker_thread_count = tr->count;
1111 
1112  /* Packet field configuration */
1113  u64 mask = (u64) ~ 0;
1114  u32 id = (u32) ~ 0;
1115  u32 offset = (u32) ~ 0;
1116 
1117  /* HQoS params */
1118  u32 n_subports_per_port, n_pipes_per_subport, tctbl_size;
1119 
1120  u32 i;
1121 
1122  /* Parse input arguments */
1123  if (!unformat_user (input, unformat_line_input, line_input))
1124  return 0;
1125 
1126  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1127  {
1128  if (unformat
1129  (line_input, "%U", unformat_vnet_hw_interface, dm->vnet_main,
1130  &hw_if_index))
1131  ;
1132  else if (unformat (line_input, "id subport"))
1133  id = 0;
1134  else if (unformat (line_input, "id pipe"))
1135  id = 1;
1136  else if (unformat (line_input, "id tc"))
1137  id = 2;
1138  else if (unformat (line_input, "id %d", &id))
1139  ;
1140  else if (unformat (line_input, "offset %d", &offset))
1141  ;
1142  else if (unformat (line_input, "mask %llx", &mask))
1143  ;
1144  else
1145  {
1146  error = clib_error_return (0, "parse error: '%U'",
1147  format_unformat_error, line_input);
1148  goto done;
1149  }
1150  }
1151 
1152  /* Get interface */
1153  if (hw_if_index == (u32) ~ 0)
1154  {
1155  error = clib_error_return (0, "please specify valid interface name");
1156  goto done;
1157  }
1158 
1159  hw = vnet_get_hw_interface (dm->vnet_main, hw_if_index);
1160  xd = vec_elt_at_index (dm->devices, hw->dev_instance);
1161 
1162  rte_eth_dev_info_get (xd->device_index, &dev_info);
1163  if (dev_info.pci_dev)
1164  { /* bonded interface has no pci info */
1165  vlib_pci_addr_t pci_addr;
1166 
1167  pci_addr.domain = dev_info.pci_dev->addr.domain;
1168  pci_addr.bus = dev_info.pci_dev->addr.bus;
1169  pci_addr.slot = dev_info.pci_dev->addr.devid;
1170  pci_addr.function = dev_info.pci_dev->addr.function;
1171 
1172  p =
1173  hash_get (dm->conf->device_config_index_by_pci_addr, pci_addr.as_u32);
1174  }
1175 
1176  if (p)
1177  devconf = pool_elt_at_index (dm->conf->dev_confs, p[0]);
1178  else
1179  devconf = &dm->conf->default_devconf;
1180 
1181  if (devconf->hqos_enabled == 0)
1182  {
1183  vlib_cli_output (vm, "HQoS disabled for this interface");
1184  goto done;
1185  }
1186 
1187  n_subports_per_port = devconf->hqos.port.n_subports_per_port;
1188  n_pipes_per_subport = devconf->hqos.port.n_pipes_per_subport;
1189  tctbl_size = RTE_DIM (devconf->hqos.tc_table);
1190 
1191  /* Validate packet field configuration: id, offset and mask */
1192  if (id >= 3)
1193  {
1194  error = clib_error_return (0, "invalid packet field id");
1195  goto done;
1196  }
1197 
1198  switch (id)
1199  {
1200  case 0:
1201  if (dpdk_hqos_validate_mask (mask, n_subports_per_port) != 0)
1202  {
1203  error = clib_error_return (0, "invalid subport ID mask "
1204  "(n_subports_per_port = %u)",
1205  n_subports_per_port);
1206  goto done;
1207  }
1208  break;
1209  case 1:
1210  if (dpdk_hqos_validate_mask (mask, n_pipes_per_subport) != 0)
1211  {
1212  error = clib_error_return (0, "invalid pipe ID mask "
1213  "(n_pipes_per_subport = %u)",
1214  n_pipes_per_subport);
1215  goto done;
1216  }
1217  break;
1218  case 2:
1219  default:
1220  if (dpdk_hqos_validate_mask (mask, tctbl_size) != 0)
1221  {
1222  error = clib_error_return (0, "invalid TC table index mask "
1223  "(TC table size = %u)", tctbl_size);
1224  goto done;
1225  }
1226  }
1227 
1228  /* Propagate packet field configuration to all workers */
1229  for (i = 0; i < worker_thread_count; i++)
1230  switch (id)
1231  {
1232  case 0:
1233  xd->hqos_wt[worker_thread_first + i].hqos_field0_slabpos = offset;
1234  xd->hqos_wt[worker_thread_first + i].hqos_field0_slabmask = mask;
1235  xd->hqos_wt[worker_thread_first + i].hqos_field0_slabshr =
1236  __builtin_ctzll (mask);
1237  break;
1238  case 1:
1239  xd->hqos_wt[worker_thread_first + i].hqos_field1_slabpos = offset;
1240  xd->hqos_wt[worker_thread_first + i].hqos_field1_slabmask = mask;
1241  xd->hqos_wt[worker_thread_first + i].hqos_field1_slabshr =
1242  __builtin_ctzll (mask);
1243  break;
1244  case 2:
1245  default:
1246  xd->hqos_wt[worker_thread_first + i].hqos_field2_slabpos = offset;
1247  xd->hqos_wt[worker_thread_first + i].hqos_field2_slabmask = mask;
1248  xd->hqos_wt[worker_thread_first + i].hqos_field2_slabshr =
1249  __builtin_ctzll (mask);
1250  }
1251 
1252 done:
1253  unformat_free (line_input);
1254 
1255  return error;
1256 }
1257 
1258 /*?
1259  * This command is used to set the packet fields required for classifiying the
1260  * incoming packet. As a result of classification process, packet field
1261  * information will be mapped to 5 tuples (subport, pipe, traffic class, pipe,
1262  * color) and stored in packet mbuf.
1263  *
1264  * This command has the following parameters:
1265  *
1266  * - <b><interface></b> - Used to specify the output interface.
1267  *
1268  * - <b>id subport|pipe|tc</b> - Classification occurs across three fields.
1269  * This parameter indicates which of the three masks are being configured. Legacy
1270  * code used 0-2 to represent these three fields, so 0-2 is still accepted.
1271  * - <b>subport|0</b> - Currently only one subport is supported, so only
1272  * an empty mask is supported for the subport classification.
1273  * - <b>pipe|1</b> - Currently, 4096 pipes per subport are supported, so a
1274  * 12-bit mask should be configure to map to the 0-4095 pipes.
1275  * - <b>tc|2</b> - The translation table (see '<em>set dpdk interface hqos
1276  * tctbl</em>' command) maps each value (0-63) into one of the 4 traffic classes
1277  * per pipe. A 6-bit mask should be configure to map this field to a traffic class.
1278  *
1279  * - <b>offset <n></b> - Offset in the packet to apply the 64-bit mask for classification.
1280  * The offset should be on an 8-byte boundary (0,8,16,24..).
1281  *
1282  * - <b>mask <hex-mask></b> - 64-bit mask to apply to packet at the given '<em>offset</em>'.
1283  * Bits must be contiguous and should not include '<em>0x</em>'.
1284  *
1285  * The default values for the '<em>pktfield</em>' assumes Ethernet/IPv4/UDP packets with
1286  * no VLAN. Adjust based on expected packet format and desired classification field.
1287  * - '<em>subport</em>' is always empty (offset 0 mask 0000000000000000)
1288  * - By default, '<em>pipe</em>' maps to the UDP payload bits 12 .. 23 (offset 40
1289  * mask 0000000fff000000)
1290  * - By default, '<em>tc</em>' maps to the DSCP field in IP header (offset 48 mask
1291  * 00000000000000fc)
1292  *
1293  * @cliexpar
1294  * Example of how modify the '<em>pipe</em>' classification filter to match VLAN:
1295  * @cliexcmd{set dpdk interface hqos pktfield GigabitEthernet0/8/0 id pipe offset 8 mask 0000000000000FFF}
1296 ?*/
1297 /* *INDENT-OFF* */
1298 VLIB_CLI_COMMAND (cmd_set_dpdk_if_hqos_pktfield, static) = {
1299  .path = "set dpdk interface hqos pktfield",
1300  .short_help = "set dpdk interface hqos pktfield <interface> id subport|pipe|tc offset <n> "
1301  "mask <hex-mask>",
1302  .function = set_dpdk_if_hqos_pktfield,
1303 };
1304 /* *INDENT-ON* */
1305 
1306 static clib_error_t *
1308  vlib_cli_command_t * cmd)
1309 {
1310  unformat_input_t _line_input, *line_input = &_line_input;
1312  dpdk_main_t *dm = &dpdk_main;
1313  vnet_hw_interface_t *hw;
1314  dpdk_device_t *xd;
1318  u32 *tctbl;
1319  u32 hw_if_index = (u32) ~ 0;
1320  u32 profile_id, subport_id, i;
1321  struct rte_eth_dev_info dev_info;
1322  dpdk_device_config_t *devconf = 0;
1324  uword *p = 0;
1325  clib_error_t *error = NULL;
1326 
1327  if (!unformat_user (input, unformat_line_input, line_input))
1328  return 0;
1329 
1330  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1331  {
1332  if (unformat
1333  (line_input, "%U", unformat_vnet_hw_interface, dm->vnet_main,
1334  &hw_if_index))
1335  ;
1336  else
1337  {
1338  error = clib_error_return (0, "parse error: '%U'",
1339  format_unformat_error, line_input);
1340  goto done;
1341  }
1342  }
1343 
1344  if (hw_if_index == (u32) ~ 0)
1345  {
1346  error = clib_error_return (0, "please specify interface name!!");
1347  goto done;
1348  }
1349 
1350  hw = vnet_get_hw_interface (dm->vnet_main, hw_if_index);
1351  xd = vec_elt_at_index (dm->devices, hw->dev_instance);
1352 
1353  rte_eth_dev_info_get (xd->device_index, &dev_info);
1354  if (dev_info.pci_dev)
1355  { /* bonded interface has no pci info */
1356  vlib_pci_addr_t pci_addr;
1357 
1358  pci_addr.domain = dev_info.pci_dev->addr.domain;
1359  pci_addr.bus = dev_info.pci_dev->addr.bus;
1360  pci_addr.slot = dev_info.pci_dev->addr.devid;
1361  pci_addr.function = dev_info.pci_dev->addr.function;
1362 
1363  p =
1364  hash_get (dm->conf->device_config_index_by_pci_addr, pci_addr.as_u32);
1365  }
1366 
1367  if (p)
1368  devconf = pool_elt_at_index (dm->conf->dev_confs, p[0]);
1369  else
1370  devconf = &dm->conf->default_devconf;
1371 
1372  if (devconf->hqos_enabled == 0)
1373  {
1374  vlib_cli_output (vm, "HQoS disabled for this interface");
1375  goto done;
1376  }
1377 
1378  /* Detect the set of worker threads */
1379  p = hash_get_mem (tm->thread_registrations_by_name, "workers");
1380 
1381  /* Should never happen, shut up Coverity warning */
1382  if (p == 0)
1383  {
1384  error = clib_error_return (0, "no worker registrations?");
1385  goto done;
1386  }
1387 
1388  tr = (vlib_thread_registration_t *) p[0];
1389 
1390  cfg = &devconf->hqos;
1391  ht = xd->hqos_ht;
1392  wk = &xd->hqos_wt[tr->first_index];
1393  tctbl = wk->hqos_tc_table;
1394 
1395  vlib_cli_output (vm, " Thread:");
1396  vlib_cli_output (vm, " Input SWQ size = %u packets", cfg->swq_size);
1397  vlib_cli_output (vm, " Enqueue burst size = %u packets",
1398  ht->hqos_burst_enq);
1399  vlib_cli_output (vm, " Dequeue burst size = %u packets",
1400  ht->hqos_burst_deq);
1401 
1402  vlib_cli_output (vm,
1403  " Packet field 0: slab position = %4u, slab bitmask = 0x%016llx (subport)",
1405  vlib_cli_output (vm,
1406  " Packet field 1: slab position = %4u, slab bitmask = 0x%016llx (pipe)",
1408  vlib_cli_output (vm,
1409  " Packet field 2: slab position = %4u, slab bitmask = 0x%016llx (tc)",
1411  vlib_cli_output (vm,
1412  " Packet field 2 tc translation table: ([Mapped Value Range]: tc/queue tc/queue ...)");
1413  vlib_cli_output (vm,
1414  " [ 0 .. 15]: "
1415  "%u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u",
1416  tctbl[0] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1417  tctbl[0] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1418  tctbl[1] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1419  tctbl[1] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1420  tctbl[2] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1421  tctbl[2] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1422  tctbl[3] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1423  tctbl[3] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1424  tctbl[4] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1425  tctbl[4] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1426  tctbl[5] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1427  tctbl[5] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1428  tctbl[6] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1429  tctbl[6] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1430  tctbl[7] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1431  tctbl[7] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1432  tctbl[8] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1433  tctbl[8] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1434  tctbl[9] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1435  tctbl[9] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1436  tctbl[10] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1437  tctbl[10] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1438  tctbl[11] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1439  tctbl[11] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1440  tctbl[12] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1441  tctbl[12] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1442  tctbl[13] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1443  tctbl[13] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1444  tctbl[14] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1445  tctbl[14] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1446  tctbl[15] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1447  tctbl[15] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS);
1448  vlib_cli_output (vm,
1449  " [16 .. 31]: "
1450  "%u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u",
1451  tctbl[16] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1452  tctbl[16] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1453  tctbl[17] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1454  tctbl[17] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1455  tctbl[18] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1456  tctbl[18] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1457  tctbl[19] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1458  tctbl[19] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1459  tctbl[20] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1460  tctbl[20] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1461  tctbl[21] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1462  tctbl[21] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1463  tctbl[22] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1464  tctbl[22] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1465  tctbl[23] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1466  tctbl[23] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1467  tctbl[24] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1468  tctbl[24] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1469  tctbl[25] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1470  tctbl[25] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1471  tctbl[26] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1472  tctbl[26] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1473  tctbl[27] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1474  tctbl[27] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1475  tctbl[28] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1476  tctbl[28] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1477  tctbl[29] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1478  tctbl[29] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1479  tctbl[30] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1480  tctbl[30] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1481  tctbl[31] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1482  tctbl[31] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS);
1483  vlib_cli_output (vm,
1484  " [32 .. 47]: "
1485  "%u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u",
1486  tctbl[32] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1487  tctbl[32] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1488  tctbl[33] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1489  tctbl[33] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1490  tctbl[34] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1491  tctbl[34] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1492  tctbl[35] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1493  tctbl[35] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1494  tctbl[36] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1495  tctbl[36] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1496  tctbl[37] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1497  tctbl[37] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1498  tctbl[38] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1499  tctbl[38] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1500  tctbl[39] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1501  tctbl[39] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1502  tctbl[40] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1503  tctbl[40] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1504  tctbl[41] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1505  tctbl[41] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1506  tctbl[42] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1507  tctbl[42] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1508  tctbl[43] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1509  tctbl[43] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1510  tctbl[44] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1511  tctbl[44] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1512  tctbl[45] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1513  tctbl[45] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1514  tctbl[46] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1515  tctbl[46] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1516  tctbl[47] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1517  tctbl[47] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS);
1518  vlib_cli_output (vm,
1519  " [48 .. 63]: "
1520  "%u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u %u/%u",
1521  tctbl[48] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1522  tctbl[48] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1523  tctbl[49] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1524  tctbl[49] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1525  tctbl[50] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1526  tctbl[50] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1527  tctbl[51] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1528  tctbl[51] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1529  tctbl[52] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1530  tctbl[52] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1531  tctbl[53] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1532  tctbl[53] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1533  tctbl[54] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1534  tctbl[54] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1535  tctbl[55] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1536  tctbl[55] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1537  tctbl[56] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1538  tctbl[56] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1539  tctbl[57] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1540  tctbl[57] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1541  tctbl[58] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1542  tctbl[58] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1543  tctbl[59] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1544  tctbl[59] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1545  tctbl[60] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1546  tctbl[60] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1547  tctbl[61] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1548  tctbl[61] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1549  tctbl[62] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1550  tctbl[62] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1551  tctbl[63] / RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS,
1552  tctbl[63] % RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS);
1553  vlib_cli_output (vm, " Port:");
1554  vlib_cli_output (vm, " Rate = %u bytes/second", cfg->port.rate);
1555  vlib_cli_output (vm, " MTU = %u bytes", cfg->port.mtu);
1556  vlib_cli_output (vm, " Frame overhead = %u bytes",
1557  cfg->port.frame_overhead);
1558  vlib_cli_output (vm, " Number of subports = %u",
1559  cfg->port.n_subports_per_port);
1560  vlib_cli_output (vm, " Number of pipes per subport = %u",
1561  cfg->port.n_pipes_per_subport);
1562  vlib_cli_output (vm,
1563  " Packet queue size: TC0 = %u, TC1 = %u, TC2 = %u, TC3 = %u packets",
1564  cfg->port.qsize[0], cfg->port.qsize[1], cfg->port.qsize[2],
1565  cfg->port.qsize[3]);
1566  vlib_cli_output (vm, " Number of pipe profiles = %u",
1567  cfg->port.n_pipe_profiles);
1568 
1569  for (subport_id = 0; subport_id < vec_len (cfg->subport); subport_id++)
1570  {
1571  vlib_cli_output (vm, " Subport %u:", subport_id);
1572  vlib_cli_output (vm, " Rate = %u bytes/second",
1573  cfg->subport[subport_id].tb_rate);
1574  vlib_cli_output (vm, " Token bucket size = %u bytes",
1575  cfg->subport[subport_id].tb_size);
1576  vlib_cli_output (vm,
1577  " Traffic class rate: TC0 = %u, TC1 = %u, TC2 = %u, TC3 = %u bytes/second",
1578  cfg->subport[subport_id].tc_rate[0],
1579  cfg->subport[subport_id].tc_rate[1],
1580  cfg->subport[subport_id].tc_rate[2],
1581  cfg->subport[subport_id].tc_rate[3]);
1582  vlib_cli_output (vm, " TC period = %u milliseconds",
1583  cfg->subport[subport_id].tc_period);
1584  }
1585 
1586  for (profile_id = 0; profile_id < vec_len (cfg->pipe); profile_id++)
1587  {
1588  vlib_cli_output (vm, " Pipe profile %u:", profile_id);
1589  vlib_cli_output (vm, " Rate = %u bytes/second",
1590  cfg->pipe[profile_id].tb_rate);
1591  vlib_cli_output (vm, " Token bucket size = %u bytes",
1592  cfg->pipe[profile_id].tb_size);
1593  vlib_cli_output (vm,
1594  " Traffic class rate: TC0 = %u, TC1 = %u, TC2 = %u, TC3 = %u bytes/second",
1595  cfg->pipe[profile_id].tc_rate[0],
1596  cfg->pipe[profile_id].tc_rate[1],
1597  cfg->pipe[profile_id].tc_rate[2],
1598  cfg->pipe[profile_id].tc_rate[3]);
1599  vlib_cli_output (vm, " TC period = %u milliseconds",
1600  cfg->pipe[profile_id].tc_period);
1601 #ifdef RTE_SCHED_SUBPORT_TC_OV
1602  vlib_cli_output (vm, " TC3 oversubscription_weight = %u",
1603  cfg->pipe[profile_id].tc_ov_weight);
1604 #endif
1605 
1606  for (i = 0; i < RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE; i++)
1607  {
1608  vlib_cli_output (vm,
1609  " TC%u WRR weights: Q0 = %u, Q1 = %u, Q2 = %u, Q3 = %u",
1610  i, cfg->pipe[profile_id].wrr_weights[i * 4],
1611  cfg->pipe[profile_id].wrr_weights[i * 4 + 1],
1612  cfg->pipe[profile_id].wrr_weights[i * 4 + 2],
1613  cfg->pipe[profile_id].wrr_weights[i * 4 + 3]);
1614  }
1615  }
1616 
1617 #ifdef RTE_SCHED_RED
1618  vlib_cli_output (vm, " Weighted Random Early Detection (WRED):");
1619  for (i = 0; i < RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE; i++)
1620  {
1621  vlib_cli_output (vm, " TC%u min: G = %u, Y = %u, R = %u", i,
1622  cfg->port.red_params[i][e_RTE_METER_GREEN].min_th,
1623  cfg->port.red_params[i][e_RTE_METER_YELLOW].min_th,
1624  cfg->port.red_params[i][e_RTE_METER_RED].min_th);
1625 
1626  vlib_cli_output (vm, " TC%u max: G = %u, Y = %u, R = %u", i,
1627  cfg->port.red_params[i][e_RTE_METER_GREEN].max_th,
1628  cfg->port.red_params[i][e_RTE_METER_YELLOW].max_th,
1629  cfg->port.red_params[i][e_RTE_METER_RED].max_th);
1630 
1631  vlib_cli_output (vm,
1632  " TC%u inverted probability: G = %u, Y = %u, R = %u",
1633  i, cfg->port.red_params[i][e_RTE_METER_GREEN].maxp_inv,
1634  cfg->port.red_params[i][e_RTE_METER_YELLOW].maxp_inv,
1635  cfg->port.red_params[i][e_RTE_METER_RED].maxp_inv);
1636 
1637  vlib_cli_output (vm, " TC%u weight: R = %u, Y = %u, R = %u", i,
1638  cfg->port.red_params[i][e_RTE_METER_GREEN].wq_log2,
1639  cfg->port.red_params[i][e_RTE_METER_YELLOW].wq_log2,
1640  cfg->port.red_params[i][e_RTE_METER_RED].wq_log2);
1641  }
1642 #endif
1643 
1644 done:
1645  unformat_free (line_input);
1646 
1647  return error;
1648 }
1649 
1650 /*?
1651  * This command is used to display details of an output interface's HQoS
1652  * settings.
1653  *
1654  * @cliexpar
1655  * Example of how to display HQoS settings for an interfaces:
1656  * @cliexstart{show dpdk interface hqos GigabitEthernet0/8/0}
1657  * Thread:
1658  * Input SWQ size = 4096 packets
1659  * Enqueue burst size = 256 packets
1660  * Dequeue burst size = 220 packets
1661  * Packet field 0: slab position = 0, slab bitmask = 0x0000000000000000 (subport)
1662  * Packet field 1: slab position = 40, slab bitmask = 0x0000000fff000000 (pipe)
1663  * Packet field 2: slab position = 8, slab bitmask = 0x00000000000000fc (tc)
1664  * Packet field 2 tc translation table: ([Mapped Value Range]: tc/queue tc/queue ...)
1665  * [ 0 .. 15]: 0/0 0/1 0/2 0/3 1/0 1/1 1/2 1/3 2/0 2/1 2/2 2/3 3/0 3/1 3/2 3/3
1666  * [16 .. 31]: 0/0 0/1 0/2 0/3 1/0 1/1 1/2 1/3 2/0 2/1 2/2 2/3 3/0 3/1 3/2 3/3
1667  * [32 .. 47]: 0/0 0/1 0/2 0/3 1/0 1/1 1/2 1/3 2/0 2/1 2/2 2/3 3/0 3/1 3/2 3/3
1668  * [48 .. 63]: 0/0 0/1 0/2 0/3 1/0 1/1 1/2 1/3 2/0 2/1 2/2 2/3 3/0 3/1 3/2 3/3
1669  * Port:
1670  * Rate = 1250000000 bytes/second
1671  * MTU = 1514 bytes
1672  * Frame overhead = 24 bytes
1673  * Number of subports = 1
1674  * Number of pipes per subport = 4096
1675  * Packet queue size: TC0 = 64, TC1 = 64, TC2 = 64, TC3 = 64 packets
1676  * Number of pipe profiles = 2
1677  * Subport 0:
1678  * Rate = 1250000000 bytes/second
1679  * Token bucket size = 1000000 bytes
1680  * Traffic class rate: TC0 = 1250000000, TC1 = 1250000000, TC2 = 1250000000, TC3 = 1250000000 bytes/second
1681  * TC period = 10 milliseconds
1682  * Pipe profile 0:
1683  * Rate = 305175 bytes/second
1684  * Token bucket size = 1000000 bytes
1685  * Traffic class rate: TC0 = 305175, TC1 = 305175, TC2 = 305175, TC3 = 305175 bytes/second
1686  * TC period = 40 milliseconds
1687  * TC0 WRR weights: Q0 = 1, Q1 = 1, Q2 = 1, Q3 = 1
1688  * TC1 WRR weights: Q0 = 1, Q1 = 1, Q2 = 1, Q3 = 1
1689  * TC2 WRR weights: Q0 = 1, Q1 = 1, Q2 = 1, Q3 = 1
1690  * TC3 WRR weights: Q0 = 1, Q1 = 1, Q2 = 1, Q3 = 1
1691  * @cliexend
1692 ?*/
1693 /* *INDENT-OFF* */
1694 VLIB_CLI_COMMAND (cmd_show_dpdk_if_hqos, static) = {
1695  .path = "show dpdk interface hqos",
1696  .short_help = "show dpdk interface hqos <interface>",
1697  .function = show_dpdk_if_hqos,
1698 };
1699 
1700 /* *INDENT-ON* */
1701 
1702 static clib_error_t *
1704  vlib_cli_command_t * cmd)
1705 {
1706  unformat_input_t _line_input, *line_input = &_line_input;
1707  clib_error_t *error = NULL;
1708 #ifdef RTE_SCHED_COLLECT_STATS
1709  dpdk_main_t *dm = &dpdk_main;
1710  u32 hw_if_index = (u32) ~ 0;
1711  u32 subport = (u32) ~ 0;
1712  u32 pipe = (u32) ~ 0;
1713  u32 tc = (u32) ~ 0;
1714  u32 tc_q = (u32) ~ 0;
1715  vnet_hw_interface_t *hw;
1716  dpdk_device_t *xd;
1717  uword *p = 0;
1718  struct rte_eth_dev_info dev_info;
1719  dpdk_device_config_t *devconf = 0;
1720  u32 qindex;
1721  struct rte_sched_queue_stats stats;
1722  u16 qlen;
1723 
1724  if (!unformat_user (input, unformat_line_input, line_input))
1725  return 0;
1726 
1727  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1728  {
1729  if (unformat
1730  (line_input, "%U", unformat_vnet_hw_interface, dm->vnet_main,
1731  &hw_if_index))
1732  ;
1733 
1734  else if (unformat (line_input, "subport %d", &subport))
1735  ;
1736 
1737  else if (unformat (line_input, "pipe %d", &pipe))
1738  ;
1739 
1740  else if (unformat (line_input, "tc %d", &tc))
1741  ;
1742 
1743  else if (unformat (line_input, "tc_q %d", &tc_q))
1744  ;
1745 
1746  else
1747  {
1748  error = clib_error_return (0, "parse error: '%U'",
1749  format_unformat_error, line_input);
1750  goto done;
1751  }
1752  }
1753 
1754  if (hw_if_index == (u32) ~ 0)
1755  {
1756  error = clib_error_return (0, "please specify interface name!!");
1757  goto done;
1758  }
1759 
1760  hw = vnet_get_hw_interface (dm->vnet_main, hw_if_index);
1761  xd = vec_elt_at_index (dm->devices, hw->dev_instance);
1762 
1763  rte_eth_dev_info_get (xd->device_index, &dev_info);
1764  if (dev_info.pci_dev)
1765  { /* bonded interface has no pci info */
1766  vlib_pci_addr_t pci_addr;
1767 
1768  pci_addr.domain = dev_info.pci_dev->addr.domain;
1769  pci_addr.bus = dev_info.pci_dev->addr.bus;
1770  pci_addr.slot = dev_info.pci_dev->addr.devid;
1771  pci_addr.function = dev_info.pci_dev->addr.function;
1772 
1773  p =
1774  hash_get (dm->conf->device_config_index_by_pci_addr, pci_addr.as_u32);
1775  }
1776 
1777  if (p)
1778  devconf = pool_elt_at_index (dm->conf->dev_confs, p[0]);
1779  else
1780  devconf = &dm->conf->default_devconf;
1781 
1782  if (devconf->hqos_enabled == 0)
1783  {
1784  vlib_cli_output (vm, "HQoS disabled for this interface");
1785  goto done;
1786  }
1787 
1788  /*
1789  * Figure out which queue to query. cf rte_sched_port_qindex. (Not sure why
1790  * that method isn't made public by DPDK - how _should_ we get the queue ID?)
1791  */
1792  qindex = subport * devconf->hqos.port.n_pipes_per_subport + pipe;
1793  qindex = qindex * RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE + tc;
1794  qindex = qindex * RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS + tc_q;
1795 
1796  if (rte_sched_queue_read_stats (xd->hqos_ht->hqos, qindex, &stats, &qlen) !=
1797  0)
1798  {
1799  error = clib_error_return (0, "failed to read stats");
1800  goto done;
1801  }
1802 
1803  vlib_cli_output (vm, "%=24s%=16s", "Stats Parameter", "Value");
1804  vlib_cli_output (vm, "%=24s%=16d", "Packets", stats.n_pkts);
1805  vlib_cli_output (vm, "%=24s%=16d", "Packets dropped", stats.n_pkts_dropped);
1806 #ifdef RTE_SCHED_RED
1807  vlib_cli_output (vm, "%=24s%=16d", "Packets dropped (RED)",
1808  stats.n_pkts_red_dropped);
1809 #endif
1810  vlib_cli_output (vm, "%=24s%=16d", "Bytes", stats.n_bytes);
1811  vlib_cli_output (vm, "%=24s%=16d", "Bytes dropped", stats.n_bytes_dropped);
1812 
1813 #else
1814 
1815  /* Get a line of input */
1816  if (!unformat_user (input, unformat_line_input, line_input))
1817  return 0;
1818 
1819  vlib_cli_output (vm, "RTE_SCHED_COLLECT_STATS disabled in DPDK");
1820  goto done;
1821 
1822 #endif
1823 
1824 done:
1825  unformat_free (line_input);
1826 
1827  return error;
1828 }
1829 
1830 /*?
1831  * This command is used to display statistics associated with a HQoS traffic class
1832  * queue.
1833  *
1834  * @note
1835  * Statistic collection by the scheduler is disabled by default in DPDK. In order to
1836  * turn it on, add the following line to '<em>../vpp/dpdk/Makefile</em>':
1837  * - <b>$(call set,RTE_SCHED_COLLECT_STATS,y)</b>
1838  *
1839  * @cliexpar
1840  * Example of how to display statistics of HQoS a HQoS traffic class queue:
1841  * @cliexstart{show dpdk hqos queue GigabitEthernet0/9/0 subport 0 pipe 3181 tc 0 tc_q 0}
1842  * Stats Parameter Value
1843  * Packets 140
1844  * Packets dropped 0
1845  * Bytes 8400
1846  * Bytes dropped 0
1847  * @cliexend
1848 ?*/
1849 /* *INDENT-OFF* */
1850 VLIB_CLI_COMMAND (cmd_show_dpdk_hqos_queue_stats, static) = {
1851  .path = "show dpdk hqos queue",
1852  .short_help = "show dpdk hqos queue <interface> subport <subport_id> pipe <pipe_id> tc <tc_id> tc_q <queue_id>",
1853  .function = show_dpdk_hqos_queue_stats,
1854 };
1855 /* *INDENT-ON* */
1856 
1857 static clib_error_t *
1859  unformat_input_t * input,
1860  vlib_cli_command_t * cmd)
1861 {
1862 #define _(a,b,c) vlib_cli_output (vm, "%-25s " b, a ":", c);
1863  _("DPDK Version", "%s", rte_version ());
1864  _("DPDK EAL init args", "%s", dpdk_config_main.eal_init_args_str);
1865 #undef _
1866  return 0;
1867 }
1868 
1869 /*?
1870  * This command is used to display the current DPDK version and
1871  * the list of arguments passed to DPDK when started.
1872  *
1873  * @cliexpar
1874  * Example of how to display how many DPDK buffer test command has allcoated:
1875  * @cliexstart{show dpdk version}
1876  * DPDK Version: DPDK 16.11.0
1877  * DPDK EAL init args: -c 1 -n 4 --huge-dir /run/vpp/hugepages --file-prefix vpp -w 0000:00:08.0 -w 0000:00:09.0 --master-lcore 0 --socket-mem 256
1878  * @cliexend
1879 ?*/
1880 /* *INDENT-OFF* */
1881 VLIB_CLI_COMMAND (show_vpe_version_command, static) = {
1882  .path = "show dpdk version",
1883  .short_help = "show dpdk version",
1884  .function = show_dpdk_version_command_fn,
1885 };
1886 /* *INDENT-ON* */
1887 
1888 #if CLI_DEBUG
1889 
1890 static clib_error_t *
1891 dpdk_validate_buffers_fn (vlib_main_t * vm, unformat_input_t * input,
1892  vlib_cli_command_t * cmd_arg)
1893 {
1894  u32 n_invalid_bufs = 0, uninitialized = 0;
1895  u32 is_poison = 0, is_test = 0;
1896  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1897  {
1898  if (unformat (input, "poison"))
1899  is_poison = 1;
1900  else if (unformat (input, "trajectory"))
1901  is_test = 1;
1902  else
1903  return clib_error_return (0, "unknown input `%U'",
1904  format_unformat_error, input);
1905  }
1906 
1908  {
1909  vlib_cli_output (vm, "Trajectory not enabled. Recompile with "
1910  "VLIB_BUFFER_TRACE_TRAJECTORY 1");
1911  return 0;
1912  }
1913  if (is_poison)
1914  {
1915  dpdk_buffer_poison_trajectory_all ();
1916  }
1917  if (is_test)
1918  {
1919  n_invalid_bufs = dpdk_buffer_validate_trajectory_all (&uninitialized);
1920  if (!n_invalid_bufs)
1921  vlib_cli_output (vm, "All buffers are valid %d uninitialized",
1922  uninitialized);
1923  else
1924  vlib_cli_output (vm, "Found %d invalid buffers and %d uninitialized",
1925  n_invalid_bufs, uninitialized);
1926  }
1927  return 0;
1928 }
1929 
1930 /* *INDENT-OFF* */
1931 VLIB_CLI_COMMAND (test_dpdk_buffers_command, static) =
1932 {
1933  .path = "test dpdk buffers",
1934  .short_help = "test dpdk buffers [poison] [trajectory]",
1935  .function = dpdk_validate_buffers_fn,
1936 };
1937 /* *INDENT-ON* */
1938 
1939 #endif
1940 
1941 clib_error_t *
1943 {
1944  return 0;
1945 }
1946 
1948 
1949 /*
1950  * fd.io coding-style-patch-verification: ON
1951  *
1952  * Local Variables:
1953  * eval: (c-set-style "gnu")
1954  * End:
1955  */
unformat_function_t unformat_vnet_hw_interface
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:434
vmrglw vmrglh hi
char * file_name
File name of pcap output.
Definition: pcap.h:127
u8 * eal_init_args_str
Definition: dpdk.h:321
static clib_error_t * set_dpdk_if_hqos_placement(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:641
static void vlib_buffer_free(vlib_main_t *vm, u32 *buffers, u32 n_buffers)
Free buffers Frees the entire buffer chain for each buffer.
Definition: buffer_funcs.h:391
u32 n_packets_to_capture
Number of packets to capture.
Definition: pcap.h:130
static clib_error_t * set_dpdk_if_desc(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:476
dpdk_main_t dpdk_main
Definition: init.c:39
int dpdk_hqos_validate_mask(u64 mask, u32 n)
Definition: hqos.c:168
static clib_error_t * show_dpdk_if_hqos(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:1307
#define NULL
Definition: clib.h:55
u16 flags
Definition: dpdk.h:181
static vnet_hw_interface_t * vnet_get_hw_interface(vnet_main_t *vnm, u32 hw_if_index)
static clib_error_t * get_hqos(u32 hw_if_index, u32 subport_id, dpdk_device_t **xd, dpdk_device_config_t **devconf)
Definition: cli.c:38
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:520
dpdk_device_and_queue_t ** devices_by_hqos_cpu
Definition: dpdk.h:354
static clib_error_t * set_dpdk_if_hqos_pipe(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:746
clib_error_t * errors
Definition: dpdk.h:237
#define vec_add2(V, P, N)
Add N elements to end of vector V, return pointer to new elements in P.
Definition: vec.h:559
int i
struct rte_sched_port_params port
Definition: dpdk.h:277
static clib_error_t * show_dpdk_hqos_queue_stats(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:1703
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:983
struct rte_sched_port * hqos
Definition: dpdk.h:152
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
static clib_error_t * pcap_trace_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:87
unformat_function_t unformat_vnet_sw_interface
dpdk_device_config_hqos_t hqos
Definition: dpdk.h:313
u8 * pcap_filename
Definition: dpdk.h:368
format_function_t format_vnet_sw_if_index_name
#define DPDK_DEVICE_FLAG_PMD
Definition: dpdk.h:184
static clib_error_t * show_dpdk_buffer(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:342
struct rte_sched_pipe_params * pipe
Definition: dpdk.h:279
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:111
dpdk_config_main_t dpdk_config_main
Definition: init.c:40
dpdk_device_config_t default_devconf
Definition: dpdk.h:341
u32 pcap_pkts_to_capture
Definition: dpdk.h:370
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
#define clib_error_return(e, args...)
Definition: error.h:99
unsigned long u64
Definition: types.h:89
void dpdk_device_setup(dpdk_device_t *xd)
Definition: common.c:39
static clib_error_t * test_dpdk_buffer(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:388
dpdk_device_hqos_per_worker_thread_t * hqos_wt
Definition: dpdk.h:212
unformat_function_t unformat_line_input
Definition: format.h:281
static heap_elt_t * first(heap_header_t *h)
Definition: heap.c:59
u32 pcap_sw_if_index
Definition: dpdk.h:369
char * name
Definition: main.h:101
vlib_worker_thread_t * vlib_worker_threads
Definition: threads.c:35
#define hash_get(h, key)
Definition: hash.h:248
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:461
pcap_main_t pcap_main
Definition: dpdk.h:367
struct _unformat_input_t unformat_input_t
#define vec_del1(v, i)
Delete the element at index I.
Definition: vec.h:803
u16 nb_rx_desc
Definition: dpdk.h:205
u32 hw_if_index
Definition: dpdk.h:168
static int dpdk_device_queue_sort(void *a1, void *a2)
Definition: cli.c:570
#define UNFORMAT_END_OF_INPUT
Definition: format.h:143
dpdk_device_t * devices
Definition: dpdk.h:353
static clib_error_t * set_dpdk_if_hqos_tctbl(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:972
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:336
dpdk_device_config_t * dev_confs
Definition: dpdk.h:342
#define VLIB_BUFFER_TRACE_TRAJECTORY
Compile time buffer trajectory tracing option Turn this on if you run into "bad monkey" contexts...
Definition: buffer.h:544
format_function_t format_dpdk_device_errors
Definition: dpdk.h:453
clib_error_t * pcap_write(pcap_main_t *pm)
Write PCAP file.
Definition: pcap.c:89
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:154
unsigned int u32
Definition: types.h:88
int hqos_cpu_count
Definition: dpdk.h:380
struct rte_mempool ** pktmbuf_pools
Definition: dpdk.h:395
dpdk_device_hqos_per_hqos_thread_t * hqos_ht
Definition: dpdk.h:213
#define clib_error_report(e)
Definition: error.h:113
size_t count
Definition: vapi.c:42
uword * thread_registrations_by_name
Definition: threads.h:297
clib_error_t * dpdk_cli_init(vlib_main_t *vm)
Definition: cli.c:1942
dpdk_portid_t device_index
Definition: dpdk.h:166
u64 uword
Definition: types.h:112
static clib_error_t * set_dpdk_if_hqos_subport(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:834
#define PCAP_DEF_PKT_TO_CAPTURE
template key/value backing page structure
Definition: bihash_doc.h:44
pcap_packet_type_t packet_type
Packet type.
Definition: pcap.h:133
unsigned short u16
Definition: types.h:57
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
unsigned char u8
Definition: types.h:56
static clib_error_t * set_dpdk_if_hqos_pktfield(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:1087
#define vec_sort_with_function(vec, f)
Sort a vector using the supplied element comparison function.
Definition: vec.h:958
static void unformat_free(unformat_input_t *i)
Definition: format.h:161
#define hash_get_mem(h, key)
Definition: hash.h:268
struct clib_bihash_value offset
template key/value backing page structure
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
int hqos_cpu_first_index
Definition: dpdk.h:379
static vlib_thread_main_t * vlib_get_thread_main()
Definition: global_funcs.h:32
struct rte_sched_subport_params * subport
Definition: dpdk.h:278
#define vec_foreach(var, vec)
Vector iterator.
static clib_error_t * show_dpdk_version_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:1858
static u32 vlib_buffer_alloc(vlib_main_t *vm, u32 *buffers, u32 n_buffers)
Allocate buffers into supplied array.
Definition: buffer_funcs.h:347
int tx_pcap_enable
Definition: dpdk.h:366
vnet_main_t * vnet_main
Definition: dpdk.h:391
u16 nb_tx_desc
Definition: dpdk.h:194
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:680
uword * device_config_index_by_pci_addr
Definition: dpdk.h:343
u32 n_packets_captured
Number of packets currently captured.
Definition: pcap.h:136
static clib_error_t * show_dpdk_if_hqos_placement(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:589
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:972
CLIB vectors are ubiquitous dynamically resized arrays with by user defined "headers".
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:169
dpdk_config_main_t * conf
Definition: dpdk.h:392