aboutsummaryrefslogtreecommitdiffstats
path: root/stacks/lwip_stack/lwip_src/CMakeLists.txt
blob: 4425905f68117476142d9d1ab899954638c89259 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
#########################################################################
#
# Copyright (c) 2018 Huawei Technologies Co.,Ltd.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at:
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#########################################################################

SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O0 -g -fPIE -pie -fPIC -m64 -mssse3 -std=gnu89")
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Werror -Wshadow -Wfloat-equal -Wformat=2")
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fstack-protector -fstack-protector-all")
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wl,-z,relro,-z,now -Wl,--disable-new-dtags")
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wl,-z,noexecstack -mcmodel=medium")

ADD_DEFINITIONS(-D_GNU_SOURCE)
ADD_DEFINITIONS(-DDPDK_MODULE=0)
if(WITH_HAL_LIB)
SET(RTP_CONFIG ${CMAKE_CURRENT_LIST_DIR}/../src/include/rtp_config.h)
else()
    SET(PAL_H_DIRECTORIES "/usr/include/dpdk/")
    SET(RTP_CONFIG ${PROJECT_SOURCE_DIR}/../../src/framework/common/base/include/common/common_sys_config.h)
    INCLUDE_DIRECTORIES(
        ${PAL_H_DIRECTORIES}
    )
endif()
SET(COMPLE_CONFIG ${CMAKE_CURRENT_LIST_DIR}/../src/include/compile_config.h)
SET(MGR_COM ${CMAKE_CURRENT_LIST_DIR}/../src/include/mgr_com.h)
ADD_DEFINITIONS(-include ${RTP_CONFIG})
ADD_DEFINITIONS(-include ${COMPLE_CONFIG})
ADD_DEFINITIONS(-include ${MGR_COM})
if(WITH_SECUREC_LIB)
LINK_LIBRARIES(pthread rt securec)
else()
LINK_LIBRARIES(pthread rt)
endif()
LINK_DIRECTORIES(${LIB_PATH_SHARED} ${LIB_PATH_STATIC})
INCLUDE_DIRECTORIES(
	${CMAKE_CURRENT_LIST_DIR}/../../../SecureC/include
	${CMAKE_CURRENT_LIST_DIR}/../../../thirdparty/json/json-c-0.12.1/
	${CMAKE_CURRENT_LIST_DIR}/../../../thirdparty/glog/glog-0.3.4/src/
	${CMAKE_CURRENT_LIST_DIR}/../src/include/
	${CMAKE_CURRENT_LIST_DIR}/lwip/include/
	${CMAKE_CURRENT_LIST_DIR}/lwip/include/lwip/
)

FILE(GLOB API api/*.c)
FILE(GLOB_RECURSE CORE core/*.c)
FILE(GLOB INSTANCE instance/*.c)
FILE(GLOB IPMODULE ip_module/*.c)
FILE(GLOB NETIF netif/*.c)
FILE(GLOB RECYCLE recycle/*.c)
FILE(GLOB_RECURSE MAINTAIN maintain/*.c)
FILE(GLOB COMMON common/*.c)
FILE(GLOB_RECURSE LWIPSRC lwip/arch/*.c lwip/core/*.c lwip/netif/*.c)
FOREACH(item ${LWIPSRC})
  IF(${item} MATCHES "slipif.c")
    LIST(REMOVE_ITEM LWIPSRC ${item})
  ENDIF(${item} MATCHES "slipif.c")
ENDFOREACH(item)

ADD_LIBRARY(stacklwip STATIC ${API} ${ARCH} ${CORE} ${NETIF} ${NETTOOL} ${IPMODULE} ${COMMON} ${INSTANCE} ${RECYCLE} ${MAINTAIN} ${LWIPSRC})
ADD_DEPENDENCIES(stacklwip JSON GLOG DPDK)
TARGET_INCLUDE_DIRECTORIES(
	stacklwip
	BEFORE
	PRIVATE
	common/
	socket/
	include/
	include/util/
	include/log/
	include/ipv4/
	include/ipv4/stackx
	include/stackx/
	include/netif/
	include/nstack/
	include/ip_module/
	lwip/include/lwip/
	lwip/include/lwip/arch/
	lwip/include/lwip/apps/
	lwip/include/lwip/priv/
	lwip/include/lwip/prot/
	lwip/include/netif/
	lwip/include/netif/ppp/
	lwip/include/netif/ppp/polarssl/
	${CMAKE_CURRENT_LIST_DIR}/../src/sbr/
	${CMAKE_CURRENT_LIST_DIR}/../src/include/
	${CMAKE_CURRENT_LIST_DIR}/../src/alarm/
)
n454' href='#n454'>454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616
/*
 *------------------------------------------------------------------
 * Copyright (c) 2018 Cisco and/or its affiliates.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *------------------------------------------------------------------
 */
#include <stdint.h>
#include <net/if.h>
#include <sys/ioctl.h>
#include <inttypes.h>

#include <vlib/vlib.h>
#include <vlib/unix/unix.h>
#include <vlib/pci/pci.h>
#include <vnet/ethernet/ethernet.h>

#include <vmxnet3/vmxnet3.h>

static clib_error_t *
vmxnet3_create_command_fn (vlib_main_t * vm, unformat_input_t * input,
			   vlib_cli_command_t * cmd)
{
  unformat_input_t _line_input, *line_input = &_line_input;
  vmxnet3_create_if_args_t args;
  u32 size;

  /* Get a line of input. */
  if (!unformat_user (input, unformat_line_input, line_input))
    return 0;

  clib_memset (&args, 0, sizeof (args));
  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
    {
      if (unformat (line_input, "%U", unformat_vlib_pci_addr, &args.addr))
	;
      else if (unformat (line_input, "elog"))
	args.enable_elog = 1;
      else if (unformat (line_input, "bind"))
	args.bind = 1;
      else if (unformat (line_input, "rx-queue-size %u", &size))
	args.rxq_size = size;
      else if (unformat (line_input, "tx-queue-size %u", &size))
	args.txq_size = size;
      else if (unformat (line_input, "num-tx-queues %u", &size))
	args.txq_num = size;
      else if (unformat (line_input, "num-rx-queues %u", &size))
	args.rxq_num = size;
      else
	return clib_error_return (0, "unknown input `%U'",
				  format_unformat_error, input);
    }
  unformat_free (line_input);


  vmxnet3_create_if (vm, &args);

  return args.error;
}

/* *INDENT-OFF* */
VLIB_CLI_COMMAND (vmxnet3_create_command, static) = {
  .path = "create interface vmxnet3",
  .short_help = "create interface vmxnet3 <pci-address>"
                "[rx-queue-size <size>] [tx-queue-size <size>]"
                "[num-tx-queues <number>] [num-rx-queues <number>] [bind]",
  .function = vmxnet3_create_command_fn,
};
/* *INDENT-ON* */

static clib_error_t *
vmxnet3_delete_command_fn (vlib_main_t * vm, unformat_input_t * input,
			   vlib_cli_command_t * cmd)
{
  unformat_input_t _line_input, *line_input = &_line_input;
  u32 sw_if_index = ~0;
  vnet_hw_interface_t *hw;
  vmxnet3_main_t *vmxm = &vmxnet3_main;
  vmxnet3_device_t *vd;
  vnet_main_t *vnm = vnet_get_main ();

  /* Get a line of input. */
  if (!unformat_user (input, unformat_line_input, line_input))
    return 0;

  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
    {
      if (unformat (line_input, "sw_if_index %d", &sw_if_index))
	;
      else if (unformat (line_input, "%U", unformat_vnet_sw_interface,
			 vnm, &sw_if_index))
	;
      else
	return clib_error_return (0, "unknown input `%U'",
				  format_unformat_error, input);
    }
  unformat_free (line_input);

  if (sw_if_index == ~0)
    return clib_error_return (0,
			      "please specify interface name or sw_if_index");

  hw = vnet_get_sup_hw_interface_api_visible_or_null (vnm, sw_if_index);
  if (hw == NULL || vmxnet3_device_class.index != hw->dev_class_index)
    return clib_error_return (0, "not a vmxnet3 interface");

  vd = pool_elt_at_index (vmxm->devices, hw->dev_instance);

  vmxnet3_delete_if (vm, vd);

  return 0;
}

/* *INDENT-OFF* */
VLIB_CLI_COMMAND (vmxnet3_delete_command, static) = {
  .path = "delete interface vmxnet3",
  .short_help = "delete interface vmxnet3 "
    "{<interface> | sw_if_index <sw_idx>}",
  .function = vmxnet3_delete_command_fn,
};
/* *INDENT-ON* */

static clib_error_t *
vmxnet3_test_command_fn (vlib_main_t * vm, unformat_input_t * input,
			 vlib_cli_command_t * cmd)
{
  unformat_input_t _line_input, *line_input = &_line_input;
  u32 sw_if_index = ~0;
  vnet_hw_interface_t *hw;
  vmxnet3_main_t *vmxm = &vmxnet3_main;
  vmxnet3_device_t *vd;
  vnet_main_t *vnm = vnet_get_main ();
  int enable_elog = 0, disable_elog = 0;

  /* Get a line of input. */
  if (!unformat_user (input, unformat_line_input, line_input))
    return 0;

  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
    {
      if (unformat (line_input, "sw_if_index %d", &sw_if_index))
	;
      else if (unformat (line_input, "elog-on"))
	enable_elog = 1;
      else if (unformat (line_input, "elog-off"))
	disable_elog = 1;
      else if (unformat (line_input, "%U", unformat_vnet_sw_interface,
			 vnm, &sw_if_index))
	;
      else
	return clib_error_return (0, "unknown input `%U'",
				  format_unformat_error, input);
    }
  unformat_free (line_input);

  if (sw_if_index == ~0)
    return clib_error_return (0,
			      "please specify interface name or sw_if_index");

  hw = vnet_get_sup_hw_interface_api_visible_or_null (vnm, sw_if_index);
  if (hw == NULL || vmxnet3_device_class.index != hw->dev_class_index)
    return clib_error_return (0, "not a vmxnet3 interface");

  vd = pool_elt_at_index (vmxm->devices, hw->dev_instance);

  if (enable_elog)
    vd->flags |= VMXNET3_DEVICE_F_ELOG;

  if (disable_elog)
    vd->flags &= ~VMXNET3_DEVICE_F_ELOG;

  return 0;
}

/* *INDENT-OFF* */
VLIB_CLI_COMMAND (vmxnet3_test_command, static) = {
  .path = "test vmxnet3",
  .short_help = "test vmxnet3 <interface> | sw_if_index <sw_idx> [irq] "
    "[elog-on] [elog-off]",
  .function = vmxnet3_test_command_fn,
};
/* *INDENT-ON* */

static void
show_vmxnet3 (vlib_main_t * vm, u32 * hw_if_indices, u8 show_descr,
	      u8 show_one_table, u32 which, u8 show_one_slot, u32 slot)
{
  u32 i, desc_idx;
  vmxnet3_device_t *vd;
  vnet_main_t *vnm = &vnet_main;
  vmxnet3_main_t *vmxm = &vmxnet3_main;
  vnet_hw_interface_t *hi;
  vmxnet3_rxq_t *rxq;
  vmxnet3_rx_desc *rxd;
  vmxnet3_rx_comp *rx_comp;
  vmxnet3_txq_t *txq;
  vmxnet3_tx_desc *txd;
  vmxnet3_tx_comp *tx_comp;
  u16 qid;

  if (!hw_if_indices)
    return;

  vlib_cli_output (vm, "LRO/TSO configured: %u", vmxm->lro_configured);
  for (i = 0; i < vec_len (hw_if_indices); i++)
    {
      hi = vnet_get_hw_interface (vnm, hw_if_indices[i]);
      vd = vec_elt_at_index (vmxm->devices, hi->dev_instance);
      vlib_cli_output (vm, "Interface: %U (ifindex %d)",
		       format_vnet_hw_if_index_name, vnm, hw_if_indices[i],
		       hw_if_indices[i]);
      vlib_cli_output (vm, "  Version: %u", vd->version);
      vlib_cli_output (vm, "  LRO/TSO enable: %u", vd->lro_enable);
      vlib_cli_output (vm, "  PCI Address: %U", format_vlib_pci_addr,
		       &vd->pci_addr);
      vlib_cli_output (vm, "  Mac Address: %U", format_ethernet_address,
		       vd->mac_addr);
      vlib_cli_output (vm, "  hw if index: %u", vd->hw_if_index);
      vlib_cli_output (vm, "  Device instance: %u", vd->dev_instance);
      vlib_cli_output (vm, "  Number of interrupts: %u", vd->num_intrs);

      vec_foreach_index (qid, vd->rxqs)
      {
	rxq = vec_elt_at_index (vd->rxqs, qid);
	u16 rid;

	vlib_cli_output (vm, "  Queue %u (RX)", qid);
	vlib_cli_output (vm, "    RX completion next index %u",
			 rxq->rx_comp_ring.next);
	vlib_cli_output (vm, "    RX completion generation flag 0x%x",
			 rxq->rx_comp_ring.gen);

	/* RX descriptors tables */
	for (rid = 0; rid < VMXNET3_RX_RING_SIZE; rid++)
	  {
	    vmxnet3_rx_ring *ring = &rxq->rx_ring[rid];

	    vlib_cli_output (vm,
			     "    ring %u size %u fill %u "
			     "consume %u produce %u", rid,
			     rxq->size, ring->fill, ring->consume,
			     ring->produce);
	    if (show_descr)
	      {
		vlib_cli_output (vm, "RX descriptors table");
		vlib_cli_output (vm, "  %5s  %18s  %10s",
				 "slot", "address", "flags");
		for (desc_idx = 0; desc_idx < rxq->size; desc_idx++)
		  {
		    rxd = &rxq->rx_desc[rid][desc_idx];
		    vlib_cli_output (vm, "  %5u  0x%016llx  0x%08x",
				     desc_idx, rxd->address, rxd->flags);
		  }
	      }
	    else if (show_one_table)
	      {
		if (((which == VMXNET3_SHOW_RX_DESC0) && (rid == 0)) ||
		    ((which == VMXNET3_SHOW_RX_DESC1) && (rid == 1)))
		  {
		    vlib_cli_output (vm, "RX descriptors table");
		    vlib_cli_output (vm, "  %5s  %18s  %10s",
				     "slot", "address", "flags");
		    if (show_one_slot)
		      {
			rxd = &rxq->rx_desc[rid][slot];
			vlib_cli_output (vm, "  %5u  0x%016llx  0x%08x",
					 slot, rxd->address, rxd->flags);
		      }
		    else
		      for (desc_idx = 0; desc_idx < rxq->size; desc_idx++)
			{
			  rxd = &rxq->rx_desc[rid][desc_idx];
			  vlib_cli_output (vm, "  %5u  0x%016llx  0x%08x",
					   desc_idx, rxd->address,
					   rxd->flags);
			}
		  }
	      }
	  }

	/* RX completion table */
	if (show_descr)
	  {
	    vlib_cli_output (vm, "RX completion descriptors table");
	    vlib_cli_output (vm, "  %5s  %10s  %10s  %10s  %10s",
			     "slot", "index", "rss", "len", "flags");
	    for (desc_idx = 0; desc_idx < rxq->size; desc_idx++)
	      {
		rx_comp = &rxq->rx_comp[desc_idx];
		vlib_cli_output (vm, "  %5u  0x%08x  %10u  %10u  0x%08x",
				 desc_idx, rx_comp->index, rx_comp->rss,
				 rx_comp->len, rx_comp->flags);
	      }
	  }
	else if (show_one_table)
	  {
	    if (which == VMXNET3_SHOW_RX_COMP)
	      {
		vlib_cli_output (vm, "RX completion descriptors table");
		vlib_cli_output (vm, "  %5s  %10s  %10s  %10s  %10s",
				 "slot", "index", "rss", "len", "flags");
		if (show_one_slot)
		  {
		    rx_comp = &rxq->rx_comp[slot];
		    vlib_cli_output (vm, "  %5u  0x%08x  %10u  %10u  0x%08x",
				     slot, rx_comp->index, rx_comp->rss,
				     rx_comp->len, rx_comp->flags);
		  }
		else
		  for (desc_idx = 0; desc_idx < rxq->size; desc_idx++)
		    {
		      rx_comp = &rxq->rx_comp[desc_idx];
		      vlib_cli_output (vm,
				       "  %5u  0x%08x  %10u  %10u  0x%08x",
				       desc_idx, rx_comp->index, rx_comp->rss,
				       rx_comp->len, rx_comp->flags);
		    }
	      }
	  }
      }

      vec_foreach_index (qid, vd->txqs)
      {
	txq = vec_elt_at_index (vd->txqs, qid);
	vlib_cli_output (vm, "  Queue %u (TX)", qid);
	vlib_cli_output (vm, "    TX completion next index %u",
			 txq->tx_comp_ring.next);
	vlib_cli_output (vm, "    TX completion generation flag 0x%x",
			 txq->tx_comp_ring.gen);
	vlib_cli_output (vm, "    size %u consume %u produce %u",
			 txq->size, txq->tx_ring.consume,
			 txq->tx_ring.produce);
	if (show_descr)
	  {
	    vlib_cli_output (vm, "TX descriptors table");
	    vlib_cli_output (vm, "  %5s  %18s  %10s  %10s",
			     "slot", "address", "flags0", "flags1");
	    for (desc_idx = 0; desc_idx < txq->size; desc_idx++)
	      {
		txd = &txq->tx_desc[desc_idx];
		vlib_cli_output (vm, "  %5u  0x%016llx  0x%08x  0x%08x",
				 desc_idx, txd->address, txd->flags[0],
				 txd->flags[1]);
	      }

	    vlib_cli_output (vm, "TX completion descriptors table");
	    vlib_cli_output (vm, "  %5s  %10s  %10s",
			     "slot", "index", "flags");
	    for (desc_idx = 0; desc_idx < txq->size; desc_idx++)
	      {
		tx_comp = &txq->tx_comp[desc_idx];
		vlib_cli_output (vm, "  %5u  0x%08x  0x%08x",
				 desc_idx, tx_comp->index, tx_comp->flags);
	      }
	  }
	else if (show_one_table)
	  {
	    if (which == VMXNET3_SHOW_TX_DESC)
	      {
		vlib_cli_output (vm, "TX descriptors table");
		vlib_cli_output (vm, "  %5s  %18s  %10s  %10s",
				 "slot", "address", "flags0", "flags1");
		if (show_one_slot)
		  {
		    txd = &txq->tx_desc[slot];
		    vlib_cli_output (vm, "  %5u  0x%016llx  0x%08x  0x%08x",
				     slot, txd->address, txd->flags[0],
				     txd->flags[1]);
		  }
		else
		  for (desc_idx = 0; desc_idx < txq->size; desc_idx++)
		    {
		      txd = &txq->tx_desc[desc_idx];
		      vlib_cli_output (vm, "  %5u  0x%016llx  0x%08x  0x%08x",
				       desc_idx, txd->address, txd->flags[0],
				       txd->flags[1]);
		    }
	      }
	    else if (which == VMXNET3_SHOW_TX_COMP)
	      {
		vlib_cli_output (vm, "TX completion descriptors table");
		vlib_cli_output (vm, "  %5s  %10s  %10s",
				 "slot", "index", "flags");
		if (show_one_slot)
		  {
		    tx_comp = &txq->tx_comp[slot];
		    vlib_cli_output (vm, "  %5u  0x%08x  0x%08x",
				     slot, tx_comp->index, tx_comp->flags);
		  }
		else
		  for (desc_idx = 0; desc_idx < txq->size; desc_idx++)
		    {
		      tx_comp = &txq->tx_comp[desc_idx];
		      vlib_cli_output (vm, "  %5u  0x%08x  0x%08x",
				       desc_idx, tx_comp->index,
				       tx_comp->flags);
		    }
	      }
	  }
      }
    }
}

static clib_error_t *
show_vmxnet3_fn (vlib_main_t * vm, unformat_input_t * input,
		 vlib_cli_command_t * cmd)
{
  vmxnet3_main_t *vmxm = &vmxnet3_main;
  vnet_main_t *vnm = &vnet_main;
  vmxnet3_device_t *vd;
  clib_error_t *error = 0;
  u32 hw_if_index, *hw_if_indices = 0;
  vnet_hw_interface_t *hi = 0;
  u8 show_descr = 0, show_one_table = 0, show_one_slot = 0;
  u32 which = ~0, slot;

  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
    {
      if (unformat
	  (input, "%U", unformat_vnet_hw_interface, vnm, &hw_if_index))
	{
	  hi = vnet_get_hw_interface (vnm, hw_if_index);
	  if (vmxnet3_device_class.index != hi->dev_class_index)
	    {
	      error = clib_error_return (0, "unknown input `%U'",
					 format_unformat_error, input);
	      goto done;
	    }
	  vec_add1 (hw_if_indices, hw_if_index);
	}
      else if (unformat (input, "desc"))
	show_descr = 1;
      else if (hi)
	{
	  vmxnet3_device_t *vd =
	    vec_elt_at_index (vmxm->devices, hi->dev_instance);

	  if (unformat (input, "rx-comp"))
	    {
	      show_one_table = 1;
	      which = VMXNET3_SHOW_RX_COMP;
	      if (unformat (input, "%u", &slot))
		{
		  vmxnet3_rxq_t *rxq = vec_elt_at_index (vd->rxqs, 0);

		  if (slot >= rxq->size)
		    {
		      error = clib_error_return (0,
						 "slot size must be < rx queue "
						 "size %u", rxq->size);
		      goto done;
		    }
		  show_one_slot = 1;
		}
	    }
	  else if (unformat (input, "rx-desc-0"))
	    {
	      show_one_table = 1;
	      which = VMXNET3_SHOW_RX_DESC0;
	      if (unformat (input, "%u", &slot))
		{
		  vmxnet3_rxq_t *rxq = vec_elt_at_index (vd->rxqs, 0);

		  if (slot >= rxq->size)
		    {
		      error = clib_error_return (0,
						 "slot size must be < rx queue "
						 "size %u", rxq->size);
		      goto done;
		    }
		  show_one_slot = 1;
		}
	    }
	  else if (unformat (input, "rx-desc-1"))
	    {
	      show_one_table = 1;
	      which = VMXNET3_SHOW_RX_DESC1;
	      if (unformat (input, "%u", &slot))
		{
		  vmxnet3_rxq_t *rxq = vec_elt_at_index (vd->rxqs, 0);

		  if (slot >= rxq->size)
		    {
		      error = clib_error_return (0,
						 "slot size must be < rx queue "
						 "size %u", rxq->size);
		      goto done;
		    }
		  show_one_slot = 1;
		}
	    }
	  else if (unformat (input, "tx-comp"))
	    {
	      show_one_table = 1;
	      which = VMXNET3_SHOW_TX_COMP;
	      if (unformat (input, "%u", &slot))
		{
		  vmxnet3_txq_t *txq = vec_elt_at_index (vd->txqs, 0);

		  if (slot >= txq->size)
		    {
		      error = clib_error_return (0,
						 "slot size must be < tx queue "
						 "size %u", txq->size);
		      goto done;
		    }
		  show_one_slot = 1;
		}
	    }
	  else if (unformat (input, "tx-desc"))
	    {
	      show_one_table = 1;
	      which = VMXNET3_SHOW_TX_DESC;
	      if (unformat (input, "%u", &slot))
		{
		  vmxnet3_txq_t *txq = vec_elt_at_index (vd->txqs, 0);

		  if (slot >= txq->size)
		    {
		      error = clib_error_return (0,
						 "slot size must be < tx queue "
						 "size %u", txq->size);
		      goto done;
		    }
		  show_one_slot = 1;
		}
	    }
	  else
	    {
	      error = clib_error_return (0, "unknown input `%U'",
					 format_unformat_error, input);
	      goto done;
	    }
	}
      else
	{
	  error = clib_error_return (0, "unknown input `%U'",
				     format_unformat_error, input);
	  goto done;
	}
    }

  if (vec_len (hw_if_indices) == 0)
    {
      pool_foreach (vd, vmxm->devices,
		    vec_add1 (hw_if_indices, vd->hw_if_index);
	);
    }

  show_vmxnet3 (vm, hw_if_indices, show_descr, show_one_table, which,
		show_one_slot, slot);

done:
  vec_free (hw_if_indices);
  return error;
}

/* *INDENT-OFF* */
VLIB_CLI_COMMAND (show_vmxnet3_command, static) = {
  .path = "show vmxnet3",
  .short_help = "show vmxnet3 [[<interface>] ([desc] | ([rx-comp] | "
  "[rx-desc-0] | [rx-desc-1] | [tx-comp] | [tx-desc]) [<slot>])]",
  .function = show_vmxnet3_fn,
};
/* *INDENT-ON* */

clib_error_t *
vmxnet3_cli_init (vlib_main_t * vm)
{
  vmxnet3_main_t *vmxm = &vmxnet3_main;

  /* initialize binary API */
  vmxnet3_plugin_api_hookup (vm);

  vmxm->log_default = vlib_log_register_class ("vmxnet3", 0);
  return 0;
}

VLIB_INIT_FUNCTION (vmxnet3_cli_init);

static clib_error_t *
vmxnet3_config (vlib_main_t * vm, unformat_input_t * input)
{
  vmxnet3_main_t *vmxm = &vmxnet3_main;

  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
    {
      if (unformat (input, "lro"))
	vmxm->lro_configured = 1;
      else
	return clib_error_return (0, "unknown input `%U'",
				  format_unformat_error, input);
    }

  return 0;
}

/* vmxnet3 { ... } configuration. */
VLIB_CONFIG_FUNCTION (vmxnet3_config, "vmxnet3");

/*
 * fd.io coding-style-patch-verification: ON
 *
 * Local Variables:
 * eval: (c-set-style "gnu")
 * End:
 */