[mirror_frr.git] / zebra / debug.c

/*
 * Zebra debug related function
 * Copyright (C) 1999 Kunihiro Ishiguro
 *
 * This file is part of GNU Zebra.
 *
 * GNU Zebra is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2, or (at your option) any
 * later version.
 *
 * GNU Zebra is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; see the file COPYING; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <zebra.h>
#include "command.h"
#include "debug.h"

/* For debug statement. */
unsigned long zebra_debug_event;
unsigned long zebra_debug_packet;
unsigned long zebra_debug_kernel;
unsigned long zebra_debug_rib;
unsigned long zebra_debug_fpm;
unsigned long zebra_debug_nht;
unsigned long zebra_debug_mpls;
unsigned long zebra_debug_vxlan;
unsigned long zebra_debug_pw;
unsigned long zebra_debug_dplane;

DEFINE_HOOK(zebra_debug_show_debugging, (struct vty *vty), (vty));

DEFUN_NOSH (show_debugging_zebra,
	    show_debugging_zebra_cmd,
	    "show debugging [zebra]",
	    SHOW_STR
	    "Debugging information\n"
	    "Zebra configuration\n")
{
	vty_out(vty, "Zebra debugging status:\n");

	if (IS_ZEBRA_DEBUG_EVENT)
		vty_out(vty, "  Zebra event debugging is on\n");

	if (IS_ZEBRA_DEBUG_PACKET) {
		if (IS_ZEBRA_DEBUG_SEND && IS_ZEBRA_DEBUG_RECV) {
			vty_out(vty, "  Zebra packet%s debugging is on\n",
				IS_ZEBRA_DEBUG_DETAIL ? " detail" : "");
		} else {
			if (IS_ZEBRA_DEBUG_SEND)
				vty_out(vty,
					"  Zebra packet send%s debugging is on\n",
					IS_ZEBRA_DEBUG_DETAIL ? " detail" : "");
			else
				vty_out(vty,
					"  Zebra packet receive%s debugging is on\n",
					IS_ZEBRA_DEBUG_DETAIL ? " detail" : "");
		}
	}

	if (IS_ZEBRA_DEBUG_KERNEL)
		vty_out(vty, "  Zebra kernel debugging is on\n");
	if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND)
		vty_out(vty,
			"  Zebra kernel netlink message dumps (send) are on\n");
	if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV)
		vty_out(vty,
			"  Zebra kernel netlink message dumps (recv) are on\n");

	/* Check here using flags as the 'macro' does an OR */
	if (CHECK_FLAG(zebra_debug_rib, ZEBRA_DEBUG_RIB_DETAILED))
		vty_out(vty, "  Zebra RIB detailed debugging is on\n");
	else if (CHECK_FLAG(zebra_debug_rib, ZEBRA_DEBUG_RIB))
		vty_out(vty, "  Zebra RIB debugging is on\n");

	if (IS_ZEBRA_DEBUG_FPM)
		vty_out(vty, "  Zebra FPM debugging is on\n");
	if (IS_ZEBRA_DEBUG_NHT)
		vty_out(vty, "  Zebra next-hop tracking debugging is on\n");
	if (IS_ZEBRA_DEBUG_MPLS)
		vty_out(vty, "  Zebra MPLS debugging is on\n");
	if (IS_ZEBRA_DEBUG_VXLAN)
		vty_out(vty, "  Zebra VXLAN debugging is on\n");
	if (IS_ZEBRA_DEBUG_PW)
		vty_out(vty, "  Zebra pseudowire debugging is on\n");
	if (IS_ZEBRA_DEBUG_DPLANE_DETAIL)
		vty_out(vty, "  Zebra detailed dataplane debugging is on\n");
	else if (IS_ZEBRA_DEBUG_DPLANE)
		vty_out(vty, "  Zebra dataplane debugging is on\n");

	hook_call(zebra_debug_show_debugging, vty);
	return CMD_SUCCESS;
}

DEFUN (debug_zebra_events,
       debug_zebra_events_cmd,
       "debug zebra events",
       DEBUG_STR
       "Zebra configuration\n"
       "Debug option set for zebra events\n")
{
	zebra_debug_event = ZEBRA_DEBUG_EVENT;
	return CMD_SUCCESS;
}

DEFUN (debug_zebra_nht,
       debug_zebra_nht_cmd,
       "debug zebra nht",
       DEBUG_STR
       "Zebra configuration\n"
       "Debug option set for zebra next hop tracking\n")
{
	zebra_debug_nht = ZEBRA_DEBUG_NHT;
	return CMD_SUCCESS;
}

DEFUN (debug_zebra_mpls,
       debug_zebra_mpls_cmd,
       "debug zebra mpls",
       DEBUG_STR
       "Zebra configuration\n"
       "Debug option set for zebra MPLS LSPs\n")
{
	zebra_debug_mpls = ZEBRA_DEBUG_MPLS;
	return CMD_SUCCESS;
}

DEFUN (debug_zebra_vxlan,
       debug_zebra_vxlan_cmd,
       "debug zebra vxlan",
       DEBUG_STR
       "Zebra configuration\n"
       "Debug option set for zebra VxLAN (EVPN)\n")
{
	zebra_debug_vxlan = ZEBRA_DEBUG_VXLAN;
	return CMD_SUCCESS;
}

DEFUN (debug_zebra_pw,
       debug_zebra_pw_cmd,
       "[no] debug zebra pseudowires",
       NO_STR
       DEBUG_STR
       "Zebra configuration\n"
       "Debug option set for zebra pseudowires\n")
{
	if (strmatch(argv[0]->text, "no"))
		UNSET_FLAG(zebra_debug_pw, ZEBRA_DEBUG_PW);
	else
		SET_FLAG(zebra_debug_pw, ZEBRA_DEBUG_PW);
	return CMD_SUCCESS;
}

DEFUN (debug_zebra_packet,
       debug_zebra_packet_cmd,
       "debug zebra packet [<recv|send>] [detail]",
       DEBUG_STR
       "Zebra configuration\n"
       "Debug option set for zebra packet\n"
       "Debug option set for receive packet\n"
       "Debug option set for send packet\n"
       "Debug option set for detailed info\n")
{
	int idx = 0;
	zebra_debug_packet = ZEBRA_DEBUG_PACKET;

	if (argv_find(argv, argc, "send", &idx))
		SET_FLAG(zebra_debug_packet, ZEBRA_DEBUG_SEND);
	else if (argv_find(argv, argc, "recv", &idx))
		SET_FLAG(zebra_debug_packet, ZEBRA_DEBUG_RECV);
	else {
		SET_FLAG(zebra_debug_packet, ZEBRA_DEBUG_SEND);
		SET_FLAG(zebra_debug_packet, ZEBRA_DEBUG_RECV);
	}

	if (argv_find(argv, argc, "detail", &idx))
		SET_FLAG(zebra_debug_packet, ZEBRA_DEBUG_DETAIL);

	return CMD_SUCCESS;
}

DEFUN (debug_zebra_kernel,
       debug_zebra_kernel_cmd,
       "debug zebra kernel",
       DEBUG_STR
       "Zebra configuration\n"
       "Debug option set for zebra between kernel interface\n")
{
	SET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL);

	if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV)
		UNSET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV);

	if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND)
		UNSET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND);

	return CMD_SUCCESS;
}

DEFUN (debug_zebra_kernel_msgdump,
       debug_zebra_kernel_msgdump_cmd,
       "debug zebra kernel msgdump [<recv|send>]",
       DEBUG_STR
       "Zebra configuration\n"
       "Debug option set for zebra between kernel interface\n"
       "Dump raw netlink messages, sent and received\n"
       "Dump raw netlink messages received\n"
       "Dump raw netlink messages sent\n")
{
	int idx = 0;

	if (argv_find(argv, argc, "recv", &idx)) {
		SET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV);

		if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND)
			UNSET_FLAG(zebra_debug_kernel,
				   ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND);

	} else if (argv_find(argv, argc, "send", &idx)) {
		SET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND);

		if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV)
			UNSET_FLAG(zebra_debug_kernel,
				   ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV);

	} else {
		SET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV);
		SET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND);
	}

	return CMD_SUCCESS;
}

DEFUN (debug_zebra_rib,
       debug_zebra_rib_cmd,
       "debug zebra rib [detailed]",
       DEBUG_STR
       "Zebra configuration\n"
       "Debug RIB events\n"
       "Detailed debugs\n")
{
	int idx = 0;
	SET_FLAG(zebra_debug_rib, ZEBRA_DEBUG_RIB);

	if (argv_find(argv, argc, "detailed", &idx))
		SET_FLAG(zebra_debug_rib, ZEBRA_DEBUG_RIB_DETAILED);

	return CMD_SUCCESS;
}

DEFUN (debug_zebra_fpm,
       debug_zebra_fpm_cmd,
       "debug zebra fpm",
       DEBUG_STR
       "Zebra configuration\n"
       "Debug zebra FPM events\n")
{
	SET_FLAG(zebra_debug_fpm, ZEBRA_DEBUG_FPM);
	return CMD_SUCCESS;
}

DEFUN (debug_zebra_dplane,
       debug_zebra_dplane_cmd,
       "debug zebra dplane [detailed]",
       DEBUG_STR
       "Zebra configuration\n"
       "Debug zebra dataplane events\n"
       "Detailed debug information\n")
{
	int idx = 0;

	SET_FLAG(zebra_debug_dplane, ZEBRA_DEBUG_DPLANE);

	if (argv_find(argv, argc, "detailed", &idx))
		SET_FLAG(zebra_debug_dplane, ZEBRA_DEBUG_DPLANE_DETAILED);

	return CMD_SUCCESS;
}

DEFUN (no_debug_zebra_events,
       no_debug_zebra_events_cmd,
       "no debug zebra events",
       NO_STR
       DEBUG_STR
       "Zebra configuration\n"
       "Debug option set for zebra events\n")
{
	zebra_debug_event = 0;
	return CMD_SUCCESS;
}

DEFUN (no_debug_zebra_nht,
       no_debug_zebra_nht_cmd,
       "no debug zebra nht",
       NO_STR
       DEBUG_STR
       "Zebra configuration\n"
       "Debug option set for zebra next hop tracking\n")
{
	zebra_debug_nht = 0;
	return CMD_SUCCESS;
}

DEFUN (no_debug_zebra_mpls,
       no_debug_zebra_mpls_cmd,
       "no debug zebra mpls",
       NO_STR
       DEBUG_STR
       "Zebra configuration\n"
       "Debug option set for zebra MPLS LSPs\n")
{
	zebra_debug_mpls = 0;
	return CMD_SUCCESS;
}

DEFUN (no_debug_zebra_vxlan,
       no_debug_zebra_vxlan_cmd,
       "no debug zebra vxlan",
       NO_STR
       DEBUG_STR
       "Zebra configuration\n"
       "Debug option set for zebra VxLAN (EVPN)\n")
{
	zebra_debug_vxlan = 0;
	return CMD_SUCCESS;
}

DEFUN (no_debug_zebra_packet,
       no_debug_zebra_packet_cmd,
       "no debug zebra packet [<recv|send>] [detail]",
       NO_STR
       DEBUG_STR
       "Zebra configuration\n"
       "Debug option set for zebra packet\n"
       "Debug option set for receive packet\n"
       "Debug option set for send packet\n"
       "Debug option set for detailed info\n")
{
	zebra_debug_packet = 0;
	return CMD_SUCCESS;
}

DEFUN (no_debug_zebra_kernel,
       no_debug_zebra_kernel_cmd,
       "no debug zebra kernel",
       NO_STR
       DEBUG_STR
       "Zebra configuration\n"
       "Debug option set for zebra between kernel interface\n")
{
	zebra_debug_kernel = 0;
	return CMD_SUCCESS;
}

DEFUN (no_debug_zebra_kernel_msgdump,
       no_debug_zebra_kernel_msgdump_cmd,
       "no debug zebra kernel msgdump [<recv|send>]",
       NO_STR
       DEBUG_STR
       "Zebra configuration\n"
       "Debug option set for zebra between kernel interface\n"
       "Dump raw netlink messages, sent and received\n"
       "Dump raw netlink messages received\n"
       "Dump raw netlink messages sent\n")
{
	zebra_debug_kernel = 0;
	return CMD_SUCCESS;
}

DEFUN (no_debug_zebra_rib,
       no_debug_zebra_rib_cmd,
       "no debug zebra rib [detailed]",
       NO_STR
       DEBUG_STR
       "Zebra configuration\n"
       "Debug zebra RIB\n"
       "Detailed debugs\n")
{
	zebra_debug_rib = 0;
	return CMD_SUCCESS;
}

DEFUN (no_debug_zebra_fpm,
       no_debug_zebra_fpm_cmd,
       "no debug zebra fpm",
       NO_STR
       DEBUG_STR
       "Zebra configuration\n"
       "Debug zebra FPM events\n")
{
	zebra_debug_fpm = 0;
	return CMD_SUCCESS;
}

DEFUN (no_debug_zebra_dplane,
       no_debug_zebra_dplane_cmd,
       "no debug zebra dplane",
       NO_STR
       DEBUG_STR
       "Zebra configuration\n"
       "Debug zebra dataplane events\n")
{
	zebra_debug_dplane = 0;
	return CMD_SUCCESS;
}

/* Debug node. */
struct cmd_node debug_node = {DEBUG_NODE, "", /* Debug node has no interface. */
			      1};

static int config_write_debug(struct vty *vty)
{
	int write = 0;

	if (IS_ZEBRA_DEBUG_EVENT) {
		vty_out(vty, "debug zebra events\n");
		write++;
	}
	if (IS_ZEBRA_DEBUG_PACKET) {
		if (IS_ZEBRA_DEBUG_SEND && IS_ZEBRA_DEBUG_RECV) {
			vty_out(vty, "debug zebra packet%s\n",
				IS_ZEBRA_DEBUG_DETAIL ? " detail" : "");
			write++;
		} else {
			if (IS_ZEBRA_DEBUG_SEND)
				vty_out(vty, "debug zebra packet send%s\n",
					IS_ZEBRA_DEBUG_DETAIL ? " detail" : "");
			else
				vty_out(vty, "debug zebra packet recv%s\n",
					IS_ZEBRA_DEBUG_DETAIL ? " detail" : "");
			write++;
		}
	}

	if (IS_ZEBRA_DEBUG_KERNEL) {
		if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND
		    && IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV) {
			vty_out(vty, "debug zebra kernel msgdump\n");
			write++;
		} else if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV) {
			vty_out(vty, "debug zebra kernel msgdump recv\n");
			write++;
		} else if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND) {
			vty_out(vty, "debug zebra kernel msgdump send\n");
			write++;
		} else {
			vty_out(vty, "debug zebra kernel\n");
			write++;
		}
	}

	if (CHECK_FLAG(zebra_debug_rib, ZEBRA_DEBUG_RIB_DETAILED)) {
		vty_out(vty, "debug zebra rib detailed\n");
		write++;
	} else if (CHECK_FLAG(zebra_debug_rib, ZEBRA_DEBUG_RIB)) {
		vty_out(vty, "debug zebra rib\n");
		write++;
	}

	if (IS_ZEBRA_DEBUG_FPM) {
		vty_out(vty, "debug zebra fpm\n");
		write++;
	}
	if (IS_ZEBRA_DEBUG_NHT) {
		vty_out(vty, "debug zebra nht\n");
		write++;
	}
	if (IS_ZEBRA_DEBUG_MPLS) {
		vty_out(vty, "debug zebra mpls\n");
		write++;
	}
	if (IS_ZEBRA_DEBUG_VXLAN) {
		vty_out(vty, "debug zebra vxlan\n");
		write++;
	}
	if (IS_ZEBRA_DEBUG_PW) {
		vty_out(vty, "debug zebra pseudowires\n");
		write++;
	}

	if (CHECK_FLAG(zebra_debug_dplane, ZEBRA_DEBUG_DPLANE_DETAILED)) {
		vty_out(vty, "debug zebra dplane detailed\n");
		write++;
	} else if (CHECK_FLAG(zebra_debug_dplane, ZEBRA_DEBUG_DPLANE)) {
		vty_out(vty, "debug zebra dplane\n");
		write++;
	}

	return write;
}

void zebra_debug_init(void)
{
	zebra_debug_event = 0;
	zebra_debug_packet = 0;
	zebra_debug_kernel = 0;
	zebra_debug_rib = 0;
	zebra_debug_fpm = 0;
	zebra_debug_mpls = 0;
	zebra_debug_vxlan = 0;
	zebra_debug_pw = 0;
	zebra_debug_dplane = 0;

	install_node(&debug_node, config_write_debug);

	install_element(VIEW_NODE, &show_debugging_zebra_cmd);

	install_element(ENABLE_NODE, &debug_zebra_events_cmd);
	install_element(ENABLE_NODE, &debug_zebra_nht_cmd);
	install_element(ENABLE_NODE, &debug_zebra_mpls_cmd);
	install_element(ENABLE_NODE, &debug_zebra_vxlan_cmd);
	install_element(ENABLE_NODE, &debug_zebra_pw_cmd);
	install_element(ENABLE_NODE, &debug_zebra_packet_cmd);
	install_element(ENABLE_NODE, &debug_zebra_kernel_cmd);
	install_element(ENABLE_NODE, &debug_zebra_kernel_msgdump_cmd);
	install_element(ENABLE_NODE, &debug_zebra_rib_cmd);
	install_element(ENABLE_NODE, &debug_zebra_fpm_cmd);
	install_element(ENABLE_NODE, &debug_zebra_dplane_cmd);
	install_element(ENABLE_NODE, &no_debug_zebra_events_cmd);
	install_element(ENABLE_NODE, &no_debug_zebra_nht_cmd);
	install_element(ENABLE_NODE, &no_debug_zebra_mpls_cmd);
	install_element(ENABLE_NODE, &no_debug_zebra_vxlan_cmd);
	install_element(ENABLE_NODE, &no_debug_zebra_packet_cmd);
	install_element(ENABLE_NODE, &no_debug_zebra_kernel_cmd);
	install_element(ENABLE_NODE, &no_debug_zebra_kernel_msgdump_cmd);
	install_element(ENABLE_NODE, &no_debug_zebra_rib_cmd);
	install_element(ENABLE_NODE, &no_debug_zebra_fpm_cmd);
	install_element(ENABLE_NODE, &no_debug_zebra_dplane_cmd);

	install_element(CONFIG_NODE, &debug_zebra_events_cmd);
	install_element(CONFIG_NODE, &debug_zebra_nht_cmd);
	install_element(CONFIG_NODE, &debug_zebra_mpls_cmd);
	install_element(CONFIG_NODE, &debug_zebra_vxlan_cmd);
	install_element(CONFIG_NODE, &debug_zebra_pw_cmd);
	install_element(CONFIG_NODE, &debug_zebra_packet_cmd);
	install_element(CONFIG_NODE, &debug_zebra_kernel_cmd);
	install_element(CONFIG_NODE, &debug_zebra_kernel_msgdump_cmd);
	install_element(CONFIG_NODE, &debug_zebra_rib_cmd);
	install_element(CONFIG_NODE, &debug_zebra_fpm_cmd);
	install_element(CONFIG_NODE, &debug_zebra_dplane_cmd);
	install_element(CONFIG_NODE, &no_debug_zebra_events_cmd);
	install_element(CONFIG_NODE, &no_debug_zebra_nht_cmd);
	install_element(CONFIG_NODE, &no_debug_zebra_mpls_cmd);
	install_element(CONFIG_NODE, &no_debug_zebra_vxlan_cmd);
	install_element(CONFIG_NODE, &no_debug_zebra_packet_cmd);
	install_element(CONFIG_NODE, &no_debug_zebra_kernel_cmd);
	install_element(CONFIG_NODE, &no_debug_zebra_kernel_msgdump_cmd);
	install_element(CONFIG_NODE, &no_debug_zebra_rib_cmd);
	install_element(CONFIG_NODE, &no_debug_zebra_fpm_cmd);
	install_element(CONFIG_NODE, &no_debug_zebra_dplane_cmd);
}
Commit	Line	Data
718e3744	1	/*
	2	* Zebra debug related function
	3	* Copyright (C) 1999 Kunihiro Ishiguro
	4	*
	5	* This file is part of GNU Zebra.
	6	*
	7	* GNU Zebra is free software; you can redistribute it and/or modify it
	8	* under the terms of the GNU General Public License as published by the
	9	* Free Software Foundation; either version 2, or (at your option) any
	10	* later version.
	11	*
	12	* GNU Zebra is distributed in the hope that it will be useful, but
	13	* WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* General Public License for more details.
	16	*
896014f4 DL	17	* You should have received a copy of the GNU General Public License along
	18	* with this program; see the file COPYING; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
718e3744	20	*/
	21
	22	#include <zebra.h>
	23	#include "command.h"
	24	#include "debug.h"
	25
	26	/* For debug statement. */
	27	unsigned long zebra_debug_event;
	28	unsigned long zebra_debug_packet;
	29	unsigned long zebra_debug_kernel;
b0498dc6	30	unsigned long zebra_debug_rib;
5adc2528	31	unsigned long zebra_debug_fpm;
fb018d25	32	unsigned long zebra_debug_nht;
7758e3f3	33	unsigned long zebra_debug_mpls;
13d60d35	34	unsigned long zebra_debug_vxlan;
6833ae01	35	unsigned long zebra_debug_pw;
6582b002	36	unsigned long zebra_debug_dplane;
718e3744	37
77151b6f PG	38	DEFINE_HOOK(zebra_debug_show_debugging, (struct vty *vty), (vty));
77151b6f PG	39
87f6dc50 DS	40	DEFUN_NOSH (show_debugging_zebra,
	41	show_debugging_zebra_cmd,
	42	"show debugging [zebra]",
	43	SHOW_STR
	44	"Debugging information\n"
	45	"Zebra configuration\n")
718e3744	46	{
d62a17ae	47	vty_out(vty, "Zebra debugging status:\n");
	48
	49	if (IS_ZEBRA_DEBUG_EVENT)
	50	vty_out(vty, " Zebra event debugging is on\n");
	51
	52	if (IS_ZEBRA_DEBUG_PACKET) {
	53	if (IS_ZEBRA_DEBUG_SEND && IS_ZEBRA_DEBUG_RECV) {
	54	vty_out(vty, " Zebra packet%s debugging is on\n",
	55	IS_ZEBRA_DEBUG_DETAIL ? " detail" : "");
	56	} else {
	57	if (IS_ZEBRA_DEBUG_SEND)
	58	vty_out(vty,
	59	" Zebra packet send%s debugging is on\n",
	60	IS_ZEBRA_DEBUG_DETAIL ? " detail" : "");
	61	else
	62	vty_out(vty,
	63	" Zebra packet receive%s debugging is on\n",
	64	IS_ZEBRA_DEBUG_DETAIL ? " detail" : "");
	65	}
718e3744	66	}
d62a17ae	67
	68	if (IS_ZEBRA_DEBUG_KERNEL)
	69	vty_out(vty, " Zebra kernel debugging is on\n");
	70	if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND)
	71	vty_out(vty,
	72	" Zebra kernel netlink message dumps (send) are on\n");
	73	if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV)
	74	vty_out(vty,
	75	" Zebra kernel netlink message dumps (recv) are on\n");
	76
	77	/* Check here using flags as the 'macro' does an OR */
d62a17ae	78	if (CHECK_FLAG(zebra_debug_rib, ZEBRA_DEBUG_RIB_DETAILED))
d62a17ae	79	vty_out(vty, " Zebra RIB detailed debugging is on\n");
ba9d46ff DW	80	else if (CHECK_FLAG(zebra_debug_rib, ZEBRA_DEBUG_RIB))
ba9d46ff DW	81	vty_out(vty, " Zebra RIB debugging is on\n");
d62a17ae	82
	83	if (IS_ZEBRA_DEBUG_FPM)
	84	vty_out(vty, " Zebra FPM debugging is on\n");
	85	if (IS_ZEBRA_DEBUG_NHT)
	86	vty_out(vty, " Zebra next-hop tracking debugging is on\n");
	87	if (IS_ZEBRA_DEBUG_MPLS)
	88	vty_out(vty, " Zebra MPLS debugging is on\n");
95744ad8 DS	89	if (IS_ZEBRA_DEBUG_VXLAN)
95744ad8 DS	90	vty_out(vty, " Zebra VXLAN debugging is on\n");
6833ae01	91	if (IS_ZEBRA_DEBUG_PW)
6833ae01	92	vty_out(vty, " Zebra pseudowire debugging is on\n");
6582b002 MS	93	if (IS_ZEBRA_DEBUG_DPLANE_DETAIL)
	94	vty_out(vty, " Zebra detailed dataplane debugging is on\n");
	95	else if (IS_ZEBRA_DEBUG_DPLANE)
	96	vty_out(vty, " Zebra dataplane debugging is on\n");
d62a17ae	97
77151b6f	98	hook_call(zebra_debug_show_debugging, vty);
d62a17ae	99	return CMD_SUCCESS;
718e3744	100	}
	101
	102	DEFUN (debug_zebra_events,
	103	debug_zebra_events_cmd,
	104	"debug zebra events",
	105	DEBUG_STR
	106	"Zebra configuration\n"
	107	"Debug option set for zebra events\n")
	108	{
d62a17ae	109	zebra_debug_event = ZEBRA_DEBUG_EVENT;
8527ce3a	110	return CMD_SUCCESS;
718e3744	111	}
718e3744	112
fb018d25 DS	113	DEFUN (debug_zebra_nht,
	114	debug_zebra_nht_cmd,
	115	"debug zebra nht",
	116	DEBUG_STR
	117	"Zebra configuration\n"
	118	"Debug option set for zebra next hop tracking\n")
	119	{
d62a17ae	120	zebra_debug_nht = ZEBRA_DEBUG_NHT;
8527ce3a	121	return CMD_SUCCESS;
fb018d25 DS	122	}
fb018d25 DS	123
7758e3f3	124	DEFUN (debug_zebra_mpls,
	125	debug_zebra_mpls_cmd,
	126	"debug zebra mpls",
	127	DEBUG_STR
	128	"Zebra configuration\n"
	129	"Debug option set for zebra MPLS LSPs\n")
	130	{
d62a17ae	131	zebra_debug_mpls = ZEBRA_DEBUG_MPLS;
8527ce3a	132	return CMD_SUCCESS;
7758e3f3	133	}
7758e3f3	134
13d60d35	135	DEFUN (debug_zebra_vxlan,
	136	debug_zebra_vxlan_cmd,
	137	"debug zebra vxlan",
	138	DEBUG_STR
	139	"Zebra configuration\n"
	140	"Debug option set for zebra VxLAN (EVPN)\n")
	141	{
d62a17ae	142	zebra_debug_vxlan = ZEBRA_DEBUG_VXLAN;
8527ce3a	143	return CMD_SUCCESS;
13d60d35	144	}
13d60d35	145
6833ae01	146	DEFUN (debug_zebra_pw,
	147	debug_zebra_pw_cmd,
	148	"[no] debug zebra pseudowires",
efd7904e	149	NO_STR
6833ae01	150	DEBUG_STR
	151	"Zebra configuration\n"
	152	"Debug option set for zebra pseudowires\n")
	153	{
	154	if (strmatch(argv[0]->text, "no"))
	155	UNSET_FLAG(zebra_debug_pw, ZEBRA_DEBUG_PW);
	156	else
	157	SET_FLAG(zebra_debug_pw, ZEBRA_DEBUG_PW);
8527ce3a	158	return CMD_SUCCESS;
6833ae01	159	}
6833ae01	160
718e3744	161	DEFUN (debug_zebra_packet,
718e3744	162	debug_zebra_packet_cmd,
16cedbb0	163	"debug zebra packet [<recv\|send>] [detail]",
718e3744	164	DEBUG_STR
	165	"Zebra configuration\n"
	166	"Debug option set for zebra packet\n"
	167	"Debug option set for receive packet\n"
16cedbb0 QY	168	"Debug option set for send packet\n"
16cedbb0 QY	169	"Debug option set for detailed info\n")
718e3744	170	{
d62a17ae	171	int idx = 0;
	172	zebra_debug_packet = ZEBRA_DEBUG_PACKET;
	173
	174	if (argv_find(argv, argc, "send", &idx))
	175	SET_FLAG(zebra_debug_packet, ZEBRA_DEBUG_SEND);
ba9d46ff	176	else if (argv_find(argv, argc, "recv", &idx))
d62a17ae	177	SET_FLAG(zebra_debug_packet, ZEBRA_DEBUG_RECV);
ba9d46ff	178	else {
d62a17ae	179	SET_FLAG(zebra_debug_packet, ZEBRA_DEBUG_SEND);
	180	SET_FLAG(zebra_debug_packet, ZEBRA_DEBUG_RECV);
	181	}
ba9d46ff DW	182
	183	if (argv_find(argv, argc, "detail", &idx))
	184	SET_FLAG(zebra_debug_packet, ZEBRA_DEBUG_DETAIL);
	185
d62a17ae	186	return CMD_SUCCESS;
718e3744	187	}
	188
	189	DEFUN (debug_zebra_kernel,
	190	debug_zebra_kernel_cmd,
	191	"debug zebra kernel",
	192	DEBUG_STR
	193	"Zebra configuration\n"
	194	"Debug option set for zebra between kernel interface\n")
	195	{
d62a17ae	196	SET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL);
ba9d46ff DW	197
	198	if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV)
	199	UNSET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV);
	200
	201	if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND)
	202	UNSET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND);
	203
d62a17ae	204	return CMD_SUCCESS;
556b904e QY	205	}
	206
	207	DEFUN (debug_zebra_kernel_msgdump,
	208	debug_zebra_kernel_msgdump_cmd,
6de69f83	209	"debug zebra kernel msgdump [<recv\|send>]",
556b904e QY	210	DEBUG_STR
	211	"Zebra configuration\n"
	212	"Debug option set for zebra between kernel interface\n"
	213	"Dump raw netlink messages, sent and received\n"
	214	"Dump raw netlink messages received\n"
	215	"Dump raw netlink messages sent\n")
	216	{
d62a17ae	217	int idx = 0;
ba9d46ff DW	218
ba9d46ff DW	219	if (argv_find(argv, argc, "recv", &idx)) {
d62a17ae	220	SET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV);
ba9d46ff DW	221
ba9d46ff DW	222	if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND)
996c9314 LB	223	UNSET_FLAG(zebra_debug_kernel,
996c9314 LB	224	ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND);
ba9d46ff DW	225
ba9d46ff DW	226	} else if (argv_find(argv, argc, "send", &idx)) {
d62a17ae	227	SET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND);
313605cb	228
ba9d46ff	229	if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV)
996c9314 LB	230	UNSET_FLAG(zebra_debug_kernel,
996c9314 LB	231	ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV);
ba9d46ff DW	232
	233	} else {
	234	SET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV);
	235	SET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND);
	236	}
	237
d62a17ae	238	return CMD_SUCCESS;
718e3744	239	}
718e3744	240
b0498dc6 PJ	241	DEFUN (debug_zebra_rib,
b0498dc6 PJ	242	debug_zebra_rib_cmd,
ba9d46ff	243	"debug zebra rib [detailed]",
b0498dc6 PJ	244	DEBUG_STR
	245	"Zebra configuration\n"
	246	"Debug RIB events\n"
41ec9222	247	"Detailed debugs\n")
b0498dc6	248	{
ba9d46ff DW	249	int idx = 0;
	250	SET_FLAG(zebra_debug_rib, ZEBRA_DEBUG_RIB);
	251
	252	if (argv_find(argv, argc, "detailed", &idx))
	253	SET_FLAG(zebra_debug_rib, ZEBRA_DEBUG_RIB_DETAILED);
	254
d62a17ae	255	return CMD_SUCCESS;
b0498dc6 PJ	256	}
b0498dc6 PJ	257
5adc2528 AS	258	DEFUN (debug_zebra_fpm,
	259	debug_zebra_fpm_cmd,
	260	"debug zebra fpm",
	261	DEBUG_STR
	262	"Zebra configuration\n"
	263	"Debug zebra FPM events\n")
	264	{
d62a17ae	265	SET_FLAG(zebra_debug_fpm, ZEBRA_DEBUG_FPM);
d62a17ae	266	return CMD_SUCCESS;
5adc2528 AS	267	}
5adc2528 AS	268
6582b002 MS	269	DEFUN (debug_zebra_dplane,
6582b002 MS	270	debug_zebra_dplane_cmd,
5be41a1c	271	"debug zebra dplane [detailed]",
6582b002 MS	272	DEBUG_STR
6582b002 MS	273	"Zebra configuration\n"
5be41a1c MS	274	"Debug zebra dataplane events\n"
5be41a1c MS	275	"Detailed debug information\n")
6582b002 MS	276	{
6582b002 MS	277	int idx = 0;
5709131c	278
6582b002 MS	279	SET_FLAG(zebra_debug_dplane, ZEBRA_DEBUG_DPLANE);
	280
	281	if (argv_find(argv, argc, "detailed", &idx))
	282	SET_FLAG(zebra_debug_dplane, ZEBRA_DEBUG_DPLANE_DETAILED);
	283
	284	return CMD_SUCCESS;
	285	}
	286
718e3744	287	DEFUN (no_debug_zebra_events,
	288	no_debug_zebra_events_cmd,
	289	"no debug zebra events",
	290	NO_STR
	291	DEBUG_STR
	292	"Zebra configuration\n"
	293	"Debug option set for zebra events\n")
	294	{
d62a17ae	295	zebra_debug_event = 0;
d62a17ae	296	return CMD_SUCCESS;
718e3744	297	}
718e3744	298
fb018d25 DS	299	DEFUN (no_debug_zebra_nht,
	300	no_debug_zebra_nht_cmd,
	301	"no debug zebra nht",
	302	NO_STR
	303	DEBUG_STR
	304	"Zebra configuration\n"
	305	"Debug option set for zebra next hop tracking\n")
	306	{
d62a17ae	307	zebra_debug_nht = 0;
d62a17ae	308	return CMD_SUCCESS;
fb018d25 DS	309	}
fb018d25 DS	310
7758e3f3	311	DEFUN (no_debug_zebra_mpls,
	312	no_debug_zebra_mpls_cmd,
	313	"no debug zebra mpls",
	314	NO_STR
	315	DEBUG_STR
	316	"Zebra configuration\n"
	317	"Debug option set for zebra MPLS LSPs\n")
	318	{
d62a17ae	319	zebra_debug_mpls = 0;
d62a17ae	320	return CMD_SUCCESS;
7758e3f3	321	}
7758e3f3	322
13d60d35	323	DEFUN (no_debug_zebra_vxlan,
	324	no_debug_zebra_vxlan_cmd,
	325	"no debug zebra vxlan",
	326	NO_STR
	327	DEBUG_STR
	328	"Zebra configuration\n"
	329	"Debug option set for zebra VxLAN (EVPN)\n")
	330	{
d62a17ae	331	zebra_debug_vxlan = 0;
d62a17ae	332	return CMD_SUCCESS;
13d60d35	333	}
13d60d35	334
718e3744	335	DEFUN (no_debug_zebra_packet,
718e3744	336	no_debug_zebra_packet_cmd,
ba9d46ff	337	"no debug zebra packet [<recv\|send>] [detail]",
718e3744	338	NO_STR
	339	DEBUG_STR
	340	"Zebra configuration\n"
	341	"Debug option set for zebra packet\n"
	342	"Debug option set for receive packet\n"
ba9d46ff DW	343	"Debug option set for send packet\n"
ba9d46ff DW	344	"Debug option set for detailed info\n")
718e3744	345	{
ba9d46ff	346	zebra_debug_packet = 0;
d62a17ae	347	return CMD_SUCCESS;
718e3744	348	}
	349
	350	DEFUN (no_debug_zebra_kernel,
	351	no_debug_zebra_kernel_cmd,
	352	"no debug zebra kernel",
	353	NO_STR
	354	DEBUG_STR
	355	"Zebra configuration\n"
	356	"Debug option set for zebra between kernel interface\n")
	357	{
ba9d46ff	358	zebra_debug_kernel = 0;
d62a17ae	359	return CMD_SUCCESS;
556b904e QY	360	}
	361
	362	DEFUN (no_debug_zebra_kernel_msgdump,
	363	no_debug_zebra_kernel_msgdump_cmd,
6de69f83	364	"no debug zebra kernel msgdump [<recv\|send>]",
16cedbb0	365	NO_STR
556b904e QY	366	DEBUG_STR
	367	"Zebra configuration\n"
	368	"Debug option set for zebra between kernel interface\n"
	369	"Dump raw netlink messages, sent and received\n"
	370	"Dump raw netlink messages received\n"
	371	"Dump raw netlink messages sent\n")
	372	{
ba9d46ff	373	zebra_debug_kernel = 0;
d62a17ae	374	return CMD_SUCCESS;
718e3744	375	}
718e3744	376
b0498dc6 PJ	377	DEFUN (no_debug_zebra_rib,
b0498dc6 PJ	378	no_debug_zebra_rib_cmd,
ba9d46ff	379	"no debug zebra rib [detailed]",
b0498dc6 PJ	380	NO_STR
	381	DEBUG_STR
	382	"Zebra configuration\n"
	383	"Debug zebra RIB\n"
41ec9222	384	"Detailed debugs\n")
b0498dc6	385	{
ba9d46ff	386	zebra_debug_rib = 0;
d62a17ae	387	return CMD_SUCCESS;
b0498dc6 PJ	388	}
b0498dc6 PJ	389
5adc2528 AS	390	DEFUN (no_debug_zebra_fpm,
	391	no_debug_zebra_fpm_cmd,
	392	"no debug zebra fpm",
	393	NO_STR
	394	DEBUG_STR
	395	"Zebra configuration\n"
	396	"Debug zebra FPM events\n")
	397	{
d62a17ae	398	zebra_debug_fpm = 0;
d62a17ae	399	return CMD_SUCCESS;
5adc2528 AS	400	}
5adc2528 AS	401
6582b002 MS	402	DEFUN (no_debug_zebra_dplane,
	403	no_debug_zebra_dplane_cmd,
	404	"no debug zebra dplane",
	405	NO_STR
	406	DEBUG_STR
	407	"Zebra configuration\n"
	408	"Debug zebra dataplane events\n")
	409	{
	410	zebra_debug_dplane = 0;
	411	return CMD_SUCCESS;
	412	}
	413
718e3744	414	/* Debug node. */
d62a17ae	415	struct cmd_node debug_node = {DEBUG_NODE, "", /* Debug node has no interface. */
d62a17ae	416	1};
718e3744	417
d62a17ae	418	static int config_write_debug(struct vty *vty)
718e3744	419	{
d62a17ae	420	int write = 0;
	421
	422	if (IS_ZEBRA_DEBUG_EVENT) {
	423	vty_out(vty, "debug zebra events\n");
	424	write++;
	425	}
	426	if (IS_ZEBRA_DEBUG_PACKET) {
	427	if (IS_ZEBRA_DEBUG_SEND && IS_ZEBRA_DEBUG_RECV) {
	428	vty_out(vty, "debug zebra packet%s\n",
	429	IS_ZEBRA_DEBUG_DETAIL ? " detail" : "");
	430	write++;
	431	} else {
	432	if (IS_ZEBRA_DEBUG_SEND)
	433	vty_out(vty, "debug zebra packet send%s\n",
	434	IS_ZEBRA_DEBUG_DETAIL ? " detail" : "");
	435	else
	436	vty_out(vty, "debug zebra packet recv%s\n",
	437	IS_ZEBRA_DEBUG_DETAIL ? " detail" : "");
	438	write++;
	439	}
	440	}
ba9d46ff	441
d62a17ae	442	if (IS_ZEBRA_DEBUG_KERNEL) {
996c9314 LB	443	if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND
996c9314 LB	444	&& IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV) {
ba9d46ff DW	445	vty_out(vty, "debug zebra kernel msgdump\n");
	446	write++;
	447	} else if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV) {
	448	vty_out(vty, "debug zebra kernel msgdump recv\n");
	449	write++;
	450	} else if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND) {
	451	vty_out(vty, "debug zebra kernel msgdump send\n");
	452	write++;
	453	} else {
	454	vty_out(vty, "debug zebra kernel\n");
	455	write++;
	456	}
d62a17ae	457	}
ba9d46ff	458
d62a17ae	459	if (CHECK_FLAG(zebra_debug_rib, ZEBRA_DEBUG_RIB_DETAILED)) {
	460	vty_out(vty, "debug zebra rib detailed\n");
	461	write++;
ba9d46ff DW	462	} else if (CHECK_FLAG(zebra_debug_rib, ZEBRA_DEBUG_RIB)) {
	463	vty_out(vty, "debug zebra rib\n");
	464	write++;
d62a17ae	465	}
ba9d46ff	466
d62a17ae	467	if (IS_ZEBRA_DEBUG_FPM) {
	468	vty_out(vty, "debug zebra fpm\n");
	469	write++;
	470	}
	471	if (IS_ZEBRA_DEBUG_NHT) {
	472	vty_out(vty, "debug zebra nht\n");
	473	write++;
	474	}
	475	if (IS_ZEBRA_DEBUG_MPLS) {
	476	vty_out(vty, "debug zebra mpls\n");
	477	write++;
718e3744	478	}
d62a17ae	479	if (IS_ZEBRA_DEBUG_VXLAN) {
	480	vty_out(vty, "debug zebra vxlan\n");
	481	write++;
718e3744	482	}
6833ae01	483	if (IS_ZEBRA_DEBUG_PW) {
69965f53	484	vty_out(vty, "debug zebra pseudowires\n");
6833ae01	485	write++;
6833ae01	486	}
6582b002 MS	487
	488	if (CHECK_FLAG(zebra_debug_dplane, ZEBRA_DEBUG_DPLANE_DETAILED)) {
	489	vty_out(vty, "debug zebra dplane detailed\n");
	490	write++;
	491	} else if (CHECK_FLAG(zebra_debug_dplane, ZEBRA_DEBUG_DPLANE)) {
	492	vty_out(vty, "debug zebra dplane\n");
	493	write++;
	494	}
	495
d62a17ae	496	return write;
718e3744	497	}
718e3744	498
d62a17ae	499	void zebra_debug_init(void)
718e3744	500	{
d62a17ae	501	zebra_debug_event = 0;
	502	zebra_debug_packet = 0;
	503	zebra_debug_kernel = 0;
	504	zebra_debug_rib = 0;
	505	zebra_debug_fpm = 0;
	506	zebra_debug_mpls = 0;
	507	zebra_debug_vxlan = 0;
6833ae01	508	zebra_debug_pw = 0;
6582b002	509	zebra_debug_dplane = 0;
d62a17ae	510
	511	install_node(&debug_node, config_write_debug);
	512
	513	install_element(VIEW_NODE, &show_debugging_zebra_cmd);
	514
	515	install_element(ENABLE_NODE, &debug_zebra_events_cmd);
	516	install_element(ENABLE_NODE, &debug_zebra_nht_cmd);
	517	install_element(ENABLE_NODE, &debug_zebra_mpls_cmd);
	518	install_element(ENABLE_NODE, &debug_zebra_vxlan_cmd);
6833ae01	519	install_element(ENABLE_NODE, &debug_zebra_pw_cmd);
d62a17ae	520	install_element(ENABLE_NODE, &debug_zebra_packet_cmd);
	521	install_element(ENABLE_NODE, &debug_zebra_kernel_cmd);
	522	install_element(ENABLE_NODE, &debug_zebra_kernel_msgdump_cmd);
	523	install_element(ENABLE_NODE, &debug_zebra_rib_cmd);
d62a17ae	524	install_element(ENABLE_NODE, &debug_zebra_fpm_cmd);
6582b002	525	install_element(ENABLE_NODE, &debug_zebra_dplane_cmd);
d62a17ae	526	install_element(ENABLE_NODE, &no_debug_zebra_events_cmd);
	527	install_element(ENABLE_NODE, &no_debug_zebra_nht_cmd);
	528	install_element(ENABLE_NODE, &no_debug_zebra_mpls_cmd);
	529	install_element(ENABLE_NODE, &no_debug_zebra_vxlan_cmd);
	530	install_element(ENABLE_NODE, &no_debug_zebra_packet_cmd);
	531	install_element(ENABLE_NODE, &no_debug_zebra_kernel_cmd);
	532	install_element(ENABLE_NODE, &no_debug_zebra_kernel_msgdump_cmd);
	533	install_element(ENABLE_NODE, &no_debug_zebra_rib_cmd);
d62a17ae	534	install_element(ENABLE_NODE, &no_debug_zebra_fpm_cmd);
6582b002	535	install_element(ENABLE_NODE, &no_debug_zebra_dplane_cmd);
d62a17ae	536
	537	install_element(CONFIG_NODE, &debug_zebra_events_cmd);
	538	install_element(CONFIG_NODE, &debug_zebra_nht_cmd);
	539	install_element(CONFIG_NODE, &debug_zebra_mpls_cmd);
	540	install_element(CONFIG_NODE, &debug_zebra_vxlan_cmd);
6833ae01	541	install_element(CONFIG_NODE, &debug_zebra_pw_cmd);
d62a17ae	542	install_element(CONFIG_NODE, &debug_zebra_packet_cmd);
	543	install_element(CONFIG_NODE, &debug_zebra_kernel_cmd);
	544	install_element(CONFIG_NODE, &debug_zebra_kernel_msgdump_cmd);
	545	install_element(CONFIG_NODE, &debug_zebra_rib_cmd);
d62a17ae	546	install_element(CONFIG_NODE, &debug_zebra_fpm_cmd);
6582b002	547	install_element(CONFIG_NODE, &debug_zebra_dplane_cmd);
d62a17ae	548	install_element(CONFIG_NODE, &no_debug_zebra_events_cmd);
	549	install_element(CONFIG_NODE, &no_debug_zebra_nht_cmd);
	550	install_element(CONFIG_NODE, &no_debug_zebra_mpls_cmd);
	551	install_element(CONFIG_NODE, &no_debug_zebra_vxlan_cmd);
	552	install_element(CONFIG_NODE, &no_debug_zebra_packet_cmd);
	553	install_element(CONFIG_NODE, &no_debug_zebra_kernel_cmd);
	554	install_element(CONFIG_NODE, &no_debug_zebra_kernel_msgdump_cmd);
	555	install_element(CONFIG_NODE, &no_debug_zebra_rib_cmd);
d62a17ae	556	install_element(CONFIG_NODE, &no_debug_zebra_fpm_cmd);
6582b002	557	install_element(CONFIG_NODE, &no_debug_zebra_dplane_cmd);
718e3744	558	}