zebra/debug.c

   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  *
  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
  20  */
  21
  22 #include <zebra.h>
  23 #include "command.h"
  24 #include "debug.h"
  25
  26 #ifndef VTYSH_EXTRACT_PL
  27 #include "zebra/debug_clippy.c"
  28 #endif
  29
  30 /* For debug statement. */
  31 unsigned long zebra_debug_event;
  32 unsigned long zebra_debug_packet;
  33 unsigned long zebra_debug_kernel;
  34 unsigned long zebra_debug_rib;
  35 unsigned long zebra_debug_fpm;
  36 unsigned long zebra_debug_nht;
  37 unsigned long zebra_debug_mpls;
  38 unsigned long zebra_debug_vxlan;
  39 unsigned long zebra_debug_pw;
  40 unsigned long zebra_debug_dplane;
  41 unsigned long zebra_debug_mlag;
  42 unsigned long zebra_debug_nexthop;
  43
  44 DEFINE_HOOK(zebra_debug_show_debugging, (struct vty *vty), (vty));
  45
  46 DEFUN_NOSH (show_debugging_zebra,
  47             show_debugging_zebra_cmd,
  48             "show debugging [zebra]",
  49             SHOW_STR
  50             "Debugging information\n"
  51             "Zebra configuration\n")
  52 {
  53         vty_out(vty, "Zebra debugging status:\n");
  54
  55         if (IS_ZEBRA_DEBUG_EVENT)
  56                 vty_out(vty, "  Zebra event debugging is on\n");
  57
  58         if (IS_ZEBRA_DEBUG_PACKET) {
  59                 if (IS_ZEBRA_DEBUG_SEND && IS_ZEBRA_DEBUG_RECV) {
  60                         vty_out(vty, "  Zebra packet%s debugging is on\n",
  61                                 IS_ZEBRA_DEBUG_DETAIL ? " detail" : "");
  62                 } else {
  63                         if (IS_ZEBRA_DEBUG_SEND)
  64                                 vty_out(vty,
  65                                         "  Zebra packet send%s debugging is on\n",
  66                                         IS_ZEBRA_DEBUG_DETAIL ? " detail" : "");
  67                         else
  68                                 vty_out(vty,
  69                                         "  Zebra packet receive%s debugging is on\n",
  70                                         IS_ZEBRA_DEBUG_DETAIL ? " detail" : "");
  71                 }
  72         }
  73
  74         if (IS_ZEBRA_DEBUG_KERNEL)
  75                 vty_out(vty, "  Zebra kernel debugging is on\n");
  76         if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND)
  77                 vty_out(vty,
  78                         "  Zebra kernel netlink message dumps (send) are on\n");
  79         if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV)
  80                 vty_out(vty,
  81                         "  Zebra kernel netlink message dumps (recv) are on\n");
  82
  83         /* Check here using flags as the 'macro' does an OR */
  84         if (CHECK_FLAG(zebra_debug_rib, ZEBRA_DEBUG_RIB_DETAILED))
  85                 vty_out(vty, "  Zebra RIB detailed debugging is on\n");
  86         else if (CHECK_FLAG(zebra_debug_rib, ZEBRA_DEBUG_RIB))
  87                 vty_out(vty, "  Zebra RIB debugging is on\n");
  88
  89         if (IS_ZEBRA_DEBUG_FPM)
  90                 vty_out(vty, "  Zebra FPM debugging is on\n");
  91         if (IS_ZEBRA_DEBUG_NHT_DETAILED)
  92                 vty_out(vty, "  Zebra detailed next-hop tracking debugging is on\n");
  93         else if (IS_ZEBRA_DEBUG_NHT)
  94                 vty_out(vty, "  Zebra next-hop tracking debugging is on\n");
  95         if (IS_ZEBRA_DEBUG_MPLS)
  96                 vty_out(vty, "  Zebra MPLS debugging is on\n");
  97         if (IS_ZEBRA_DEBUG_VXLAN)
  98                 vty_out(vty, "  Zebra VXLAN debugging is on\n");
  99         if (IS_ZEBRA_DEBUG_PW)
 100                 vty_out(vty, "  Zebra pseudowire debugging is on\n");
 101         if (IS_ZEBRA_DEBUG_DPLANE_DETAIL)
 102                 vty_out(vty, "  Zebra detailed dataplane debugging is on\n");
 103         else if (IS_ZEBRA_DEBUG_DPLANE)
 104                 vty_out(vty, "  Zebra dataplane debugging is on\n");
 105         if (IS_ZEBRA_DEBUG_MLAG)
 106                 vty_out(vty, "  Zebra mlag debugging is on\n");
 107         if (IS_ZEBRA_DEBUG_NHG_DETAIL)
 108                 vty_out(vty, "Zebra detailed nexthop debugging is on\n");
 109         else if (IS_ZEBRA_DEBUG_NHG)
 110                 vty_out(vty, "Zebra nexthop debugging is on\n");
 111
 112         hook_call(zebra_debug_show_debugging, vty);
 113         return CMD_SUCCESS;
 114 }
 115
 116 DEFUN (debug_zebra_events,
 117        debug_zebra_events_cmd,
 118        "debug zebra events",
 119        DEBUG_STR
 120        "Zebra configuration\n"
 121        "Debug option set for zebra events\n")
 122 {
 123         zebra_debug_event = ZEBRA_DEBUG_EVENT;
 124         return CMD_SUCCESS;
 125 }
 126
 127 DEFUN (debug_zebra_nht,
 128        debug_zebra_nht_cmd,
 129        "debug zebra nht [detailed]",
 130        DEBUG_STR
 131        "Zebra configuration\n"
 132        "Debug option set for zebra next hop tracking\n"
 133        "Debug option set for detailed info\n")
 134 {
 135         int idx = 0;
 136
 137         zebra_debug_nht = ZEBRA_DEBUG_NHT;
 138
 139         if (argv_find(argv, argc, "detailed", &idx))
 140                 zebra_debug_nht |= ZEBRA_DEBUG_NHT_DETAILED;
 141
 142         return CMD_SUCCESS;
 143 }
 144
 145 DEFUN (debug_zebra_mpls,
 146        debug_zebra_mpls_cmd,
 147        "debug zebra mpls",
 148        DEBUG_STR
 149        "Zebra configuration\n"
 150        "Debug option set for zebra MPLS LSPs\n")
 151 {
 152         zebra_debug_mpls = ZEBRA_DEBUG_MPLS;
 153         return CMD_SUCCESS;
 154 }
 155
 156 DEFUN (debug_zebra_vxlan,
 157        debug_zebra_vxlan_cmd,
 158        "debug zebra vxlan",
 159        DEBUG_STR
 160        "Zebra configuration\n"
 161        "Debug option set for zebra VxLAN (EVPN)\n")
 162 {
 163         zebra_debug_vxlan = ZEBRA_DEBUG_VXLAN;
 164         return CMD_SUCCESS;
 165 }
 166
 167 DEFUN (debug_zebra_pw,
 168        debug_zebra_pw_cmd,
 169        "[no] debug zebra pseudowires",
 170        NO_STR
 171        DEBUG_STR
 172        "Zebra configuration\n"
 173        "Debug option set for zebra pseudowires\n")
 174 {
 175         if (strmatch(argv[0]->text, "no"))
 176                 UNSET_FLAG(zebra_debug_pw, ZEBRA_DEBUG_PW);
 177         else
 178                 SET_FLAG(zebra_debug_pw, ZEBRA_DEBUG_PW);
 179         return CMD_SUCCESS;
 180 }
 181
 182 DEFUN (debug_zebra_packet,
 183        debug_zebra_packet_cmd,
 184        "debug zebra packet [<recv|send>] [detail]",
 185        DEBUG_STR
 186        "Zebra configuration\n"
 187        "Debug option set for zebra packet\n"
 188        "Debug option set for receive packet\n"
 189        "Debug option set for send packet\n"
 190        "Debug option set for detailed info\n")
 191 {
 192         int idx = 0;
 193         zebra_debug_packet = ZEBRA_DEBUG_PACKET;
 194
 195         if (argv_find(argv, argc, "send", &idx))
 196                 SET_FLAG(zebra_debug_packet, ZEBRA_DEBUG_SEND);
 197         else if (argv_find(argv, argc, "recv", &idx))
 198                 SET_FLAG(zebra_debug_packet, ZEBRA_DEBUG_RECV);
 199         else {
 200                 SET_FLAG(zebra_debug_packet, ZEBRA_DEBUG_SEND);
 201                 SET_FLAG(zebra_debug_packet, ZEBRA_DEBUG_RECV);
 202         }
 203
 204         if (argv_find(argv, argc, "detail", &idx))
 205                 SET_FLAG(zebra_debug_packet, ZEBRA_DEBUG_DETAIL);
 206
 207         return CMD_SUCCESS;
 208 }
 209
 210 DEFUN (debug_zebra_kernel,
 211        debug_zebra_kernel_cmd,
 212        "debug zebra kernel",
 213        DEBUG_STR
 214        "Zebra configuration\n"
 215        "Debug option set for zebra between kernel interface\n")
 216 {
 217         SET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL);
 218
 219         if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV)
 220                 UNSET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV);
 221
 222         if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND)
 223                 UNSET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND);
 224
 225         return CMD_SUCCESS;
 226 }
 227
 228 DEFUN (debug_zebra_kernel_msgdump,
 229        debug_zebra_kernel_msgdump_cmd,
 230        "debug zebra kernel msgdump [<recv|send>]",
 231        DEBUG_STR
 232        "Zebra configuration\n"
 233        "Debug option set for zebra between kernel interface\n"
 234        "Dump raw netlink messages, sent and received\n"
 235        "Dump raw netlink messages received\n"
 236        "Dump raw netlink messages sent\n")
 237 {
 238         int idx = 0;
 239
 240         if (argv_find(argv, argc, "recv", &idx)) {
 241                 SET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV);
 242
 243                 if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND)
 244                         UNSET_FLAG(zebra_debug_kernel,
 245                                    ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND);
 246
 247         } else if (argv_find(argv, argc, "send", &idx)) {
 248                 SET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND);
 249
 250                 if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV)
 251                         UNSET_FLAG(zebra_debug_kernel,
 252                                    ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV);
 253
 254         } else {
 255                 SET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV);
 256                 SET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND);
 257         }
 258
 259         return CMD_SUCCESS;
 260 }
 261
 262 DEFUN (debug_zebra_rib,
 263        debug_zebra_rib_cmd,
 264        "debug zebra rib [detailed]",
 265        DEBUG_STR
 266        "Zebra configuration\n"
 267        "Debug RIB events\n"
 268        "Detailed debugs\n")
 269 {
 270         int idx = 0;
 271         SET_FLAG(zebra_debug_rib, ZEBRA_DEBUG_RIB);
 272
 273         if (argv_find(argv, argc, "detailed", &idx))
 274                 SET_FLAG(zebra_debug_rib, ZEBRA_DEBUG_RIB_DETAILED);
 275
 276         return CMD_SUCCESS;
 277 }
 278
 279 DEFUN (debug_zebra_fpm,
 280        debug_zebra_fpm_cmd,
 281        "debug zebra fpm",
 282        DEBUG_STR
 283        "Zebra configuration\n"
 284        "Debug zebra FPM events\n")
 285 {
 286         SET_FLAG(zebra_debug_fpm, ZEBRA_DEBUG_FPM);
 287         return CMD_SUCCESS;
 288 }
 289
 290 DEFUN (debug_zebra_dplane,
 291        debug_zebra_dplane_cmd,
 292        "debug zebra dplane [detailed]",
 293        DEBUG_STR
 294        "Zebra configuration\n"
 295        "Debug zebra dataplane events\n"
 296        "Detailed debug information\n")
 297 {
 298         int idx = 0;
 299
 300         SET_FLAG(zebra_debug_dplane, ZEBRA_DEBUG_DPLANE);
 301
 302         if (argv_find(argv, argc, "detailed", &idx))
 303                 SET_FLAG(zebra_debug_dplane, ZEBRA_DEBUG_DPLANE_DETAILED);
 304
 305         return CMD_SUCCESS;
 306 }
 307
 308 DEFPY (debug_zebra_mlag,
 309        debug_zebra_mlag_cmd,
 310        "[no$no] debug zebra mlag",
 311        NO_STR
 312        DEBUG_STR
 313        "Zebra configuration\n"
 314        "Debug option set for mlag events\n")
 315 {
 316         if (no)
 317                 UNSET_FLAG(zebra_debug_mlag, ZEBRA_DEBUG_MLAG);
 318         else
 319                 SET_FLAG(zebra_debug_mlag, ZEBRA_DEBUG_MLAG);
 320         return CMD_SUCCESS;
 321 }
 322
 323 DEFUN (no_debug_zebra_events,
 324        no_debug_zebra_events_cmd,
 325        "no debug zebra events",
 326        NO_STR
 327        DEBUG_STR
 328        "Zebra configuration\n"
 329        "Debug option set for zebra events\n")
 330 {
 331         zebra_debug_event = 0;
 332         return CMD_SUCCESS;
 333 }
 334
 335 DEFUN (no_debug_zebra_nht,
 336        no_debug_zebra_nht_cmd,
 337        "no debug zebra nht [detailed]",
 338        NO_STR
 339        DEBUG_STR
 340        "Zebra configuration\n"
 341        "Debug option set for zebra next hop tracking\n"
 342        "Debug option set for detailed info\n")
 343 {
 344         zebra_debug_nht = 0;
 345         return CMD_SUCCESS;
 346 }
 347
 348 DEFUN (no_debug_zebra_mpls,
 349        no_debug_zebra_mpls_cmd,
 350        "no debug zebra mpls",
 351        NO_STR
 352        DEBUG_STR
 353        "Zebra configuration\n"
 354        "Debug option set for zebra MPLS LSPs\n")
 355 {
 356         zebra_debug_mpls = 0;
 357         return CMD_SUCCESS;
 358 }
 359
 360 DEFUN (no_debug_zebra_vxlan,
 361        no_debug_zebra_vxlan_cmd,
 362        "no debug zebra vxlan",
 363        NO_STR
 364        DEBUG_STR
 365        "Zebra configuration\n"
 366        "Debug option set for zebra VxLAN (EVPN)\n")
 367 {
 368         zebra_debug_vxlan = 0;
 369         return CMD_SUCCESS;
 370 }
 371
 372 DEFUN (no_debug_zebra_packet,
 373        no_debug_zebra_packet_cmd,
 374        "no debug zebra packet [<recv|send>] [detail]",
 375        NO_STR
 376        DEBUG_STR
 377        "Zebra configuration\n"
 378        "Debug option set for zebra packet\n"
 379        "Debug option set for receive packet\n"
 380        "Debug option set for send packet\n"
 381        "Debug option set for detailed info\n")
 382 {
 383         zebra_debug_packet = 0;
 384         return CMD_SUCCESS;
 385 }
 386
 387 DEFUN (no_debug_zebra_kernel,
 388        no_debug_zebra_kernel_cmd,
 389        "no debug zebra kernel",
 390        NO_STR
 391        DEBUG_STR
 392        "Zebra configuration\n"
 393        "Debug option set for zebra between kernel interface\n")
 394 {
 395         zebra_debug_kernel = 0;
 396         return CMD_SUCCESS;
 397 }
 398
 399 DEFUN (no_debug_zebra_kernel_msgdump,
 400        no_debug_zebra_kernel_msgdump_cmd,
 401        "no debug zebra kernel msgdump [<recv|send>]",
 402        NO_STR
 403        DEBUG_STR
 404        "Zebra configuration\n"
 405        "Debug option set for zebra between kernel interface\n"
 406        "Dump raw netlink messages, sent and received\n"
 407        "Dump raw netlink messages received\n"
 408        "Dump raw netlink messages sent\n")
 409 {
 410         zebra_debug_kernel = 0;
 411         return CMD_SUCCESS;
 412 }
 413
 414 DEFUN (no_debug_zebra_rib,
 415        no_debug_zebra_rib_cmd,
 416        "no debug zebra rib [detailed]",
 417        NO_STR
 418        DEBUG_STR
 419        "Zebra configuration\n"
 420        "Debug zebra RIB\n"
 421        "Detailed debugs\n")
 422 {
 423         zebra_debug_rib = 0;
 424         return CMD_SUCCESS;
 425 }
 426
 427 DEFUN (no_debug_zebra_fpm,
 428        no_debug_zebra_fpm_cmd,
 429        "no debug zebra fpm",
 430        NO_STR
 431        DEBUG_STR
 432        "Zebra configuration\n"
 433        "Debug zebra FPM events\n")
 434 {
 435         zebra_debug_fpm = 0;
 436         return CMD_SUCCESS;
 437 }
 438
 439 DEFUN (no_debug_zebra_dplane,
 440        no_debug_zebra_dplane_cmd,
 441        "no debug zebra dplane",
 442        NO_STR
 443        DEBUG_STR
 444        "Zebra configuration\n"
 445        "Debug zebra dataplane events\n")
 446 {
 447         zebra_debug_dplane = 0;
 448         return CMD_SUCCESS;
 449 }
 450
 451 DEFPY (debug_zebra_nexthop,
 452        debug_zebra_nexthop_cmd,
 453        "[no$no] debug zebra nexthop [detail$detail]",
 454        NO_STR
 455        DEBUG_STR
 456        "Zebra configuration\n"
 457        "Debug zebra nexthop events\n"
 458        "Detailed information\n")
 459 {
 460         if (no)
 461                 zebra_debug_nexthop = 0;
 462         else {
 463                 SET_FLAG(zebra_debug_nexthop, ZEBRA_DEBUG_NHG);
 464
 465                 if (detail)
 466                         SET_FLAG(zebra_debug_nexthop,
 467                                  ZEBRA_DEBUG_NHG_DETAILED);
 468         }
 469
 470         return CMD_SUCCESS;
 471 }
 472
 473 /* Debug node. */
 474 struct cmd_node debug_node = {DEBUG_NODE, "", /* Debug node has no interface. */
 475                               1};
 476
 477 static int config_write_debug(struct vty *vty)
 478 {
 479         int write = 0;
 480
 481         if (IS_ZEBRA_DEBUG_EVENT) {
 482                 vty_out(vty, "debug zebra events\n");
 483                 write++;
 484         }
 485         if (IS_ZEBRA_DEBUG_PACKET) {
 486                 if (IS_ZEBRA_DEBUG_SEND && IS_ZEBRA_DEBUG_RECV) {
 487                         vty_out(vty, "debug zebra packet%s\n",
 488                                 IS_ZEBRA_DEBUG_DETAIL ? " detail" : "");
 489                         write++;
 490                 } else {
 491                         if (IS_ZEBRA_DEBUG_SEND)
 492                                 vty_out(vty, "debug zebra packet send%s\n",
 493                                         IS_ZEBRA_DEBUG_DETAIL ? " detail" : "");
 494                         else
 495                                 vty_out(vty, "debug zebra packet recv%s\n",
 496                                         IS_ZEBRA_DEBUG_DETAIL ? " detail" : "");
 497                         write++;
 498                 }
 499         }
 500
 501         if (IS_ZEBRA_DEBUG_KERNEL) {
 502                 if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND
 503                     && IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV) {
 504                         vty_out(vty, "debug zebra kernel msgdump\n");
 505                         write++;
 506                 } else if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV) {
 507                         vty_out(vty, "debug zebra kernel msgdump recv\n");
 508                         write++;
 509                 } else if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND) {
 510                         vty_out(vty, "debug zebra kernel msgdump send\n");
 511                         write++;
 512                 } else {
 513                         vty_out(vty, "debug zebra kernel\n");
 514                         write++;
 515                 }
 516         }
 517
 518         if (CHECK_FLAG(zebra_debug_rib, ZEBRA_DEBUG_RIB_DETAILED)) {
 519                 vty_out(vty, "debug zebra rib detailed\n");
 520                 write++;
 521         } else if (CHECK_FLAG(zebra_debug_rib, ZEBRA_DEBUG_RIB)) {
 522                 vty_out(vty, "debug zebra rib\n");
 523                 write++;
 524         }
 525
 526         if (IS_ZEBRA_DEBUG_FPM) {
 527                 vty_out(vty, "debug zebra fpm\n");
 528                 write++;
 529         }
 530
 531         if (IS_ZEBRA_DEBUG_NHT_DETAILED) {
 532                 vty_out(vty, "debug zebra nht detailed\n");
 533                 write++;
 534         } else if (IS_ZEBRA_DEBUG_NHT) {
 535                 vty_out(vty, "debug zebra nht\n");
 536                 write++;
 537         }
 538
 539         if (IS_ZEBRA_DEBUG_MPLS) {
 540                 vty_out(vty, "debug zebra mpls\n");
 541                 write++;
 542         }
 543         if (IS_ZEBRA_DEBUG_VXLAN) {
 544                 vty_out(vty, "debug zebra vxlan\n");
 545                 write++;
 546         }
 547         if (IS_ZEBRA_DEBUG_PW) {
 548                 vty_out(vty, "debug zebra pseudowires\n");
 549                 write++;
 550         }
 551
 552         if (CHECK_FLAG(zebra_debug_dplane, ZEBRA_DEBUG_DPLANE_DETAILED)) {
 553                 vty_out(vty, "debug zebra dplane detailed\n");
 554                 write++;
 555         } else if (CHECK_FLAG(zebra_debug_dplane, ZEBRA_DEBUG_DPLANE)) {
 556                 vty_out(vty, "debug zebra dplane\n");
 557                 write++;
 558         }
 559
 560         return write;
 561 }
 562
 563 void zebra_debug_init(void)
 564 {
 565         zebra_debug_event = 0;
 566         zebra_debug_packet = 0;
 567         zebra_debug_kernel = 0;
 568         zebra_debug_rib = 0;
 569         zebra_debug_fpm = 0;
 570         zebra_debug_mpls = 0;
 571         zebra_debug_vxlan = 0;
 572         zebra_debug_pw = 0;
 573         zebra_debug_dplane = 0;
 574         zebra_debug_mlag = 0;
 575         zebra_debug_nht = 0;
 576         zebra_debug_nexthop = 0;
 577
 578         install_node(&debug_node, config_write_debug);
 579
 580         install_element(VIEW_NODE, &show_debugging_zebra_cmd);
 581
 582         install_element(ENABLE_NODE, &debug_zebra_events_cmd);
 583         install_element(ENABLE_NODE, &debug_zebra_nht_cmd);
 584         install_element(ENABLE_NODE, &debug_zebra_mpls_cmd);
 585         install_element(ENABLE_NODE, &debug_zebra_vxlan_cmd);
 586         install_element(ENABLE_NODE, &debug_zebra_pw_cmd);
 587         install_element(ENABLE_NODE, &debug_zebra_packet_cmd);
 588         install_element(ENABLE_NODE, &debug_zebra_kernel_cmd);
 589         install_element(ENABLE_NODE, &debug_zebra_kernel_msgdump_cmd);
 590         install_element(ENABLE_NODE, &debug_zebra_rib_cmd);
 591         install_element(ENABLE_NODE, &debug_zebra_fpm_cmd);
 592         install_element(ENABLE_NODE, &debug_zebra_dplane_cmd);
 593         install_element(ENABLE_NODE, &debug_zebra_mlag_cmd);
 594         install_element(ENABLE_NODE, &debug_zebra_nexthop_cmd);
 595         install_element(ENABLE_NODE, &no_debug_zebra_events_cmd);
 596         install_element(ENABLE_NODE, &no_debug_zebra_nht_cmd);
 597         install_element(ENABLE_NODE, &no_debug_zebra_mpls_cmd);
 598         install_element(ENABLE_NODE, &no_debug_zebra_vxlan_cmd);
 599         install_element(ENABLE_NODE, &no_debug_zebra_packet_cmd);
 600         install_element(ENABLE_NODE, &no_debug_zebra_kernel_cmd);
 601         install_element(ENABLE_NODE, &no_debug_zebra_kernel_msgdump_cmd);
 602         install_element(ENABLE_NODE, &no_debug_zebra_rib_cmd);
 603         install_element(ENABLE_NODE, &no_debug_zebra_fpm_cmd);
 604         install_element(ENABLE_NODE, &no_debug_zebra_dplane_cmd);
 605
 606         install_element(CONFIG_NODE, &debug_zebra_events_cmd);
 607         install_element(CONFIG_NODE, &debug_zebra_nht_cmd);
 608         install_element(CONFIG_NODE, &debug_zebra_mpls_cmd);
 609         install_element(CONFIG_NODE, &debug_zebra_vxlan_cmd);
 610         install_element(CONFIG_NODE, &debug_zebra_pw_cmd);
 611         install_element(CONFIG_NODE, &debug_zebra_packet_cmd);
 612         install_element(CONFIG_NODE, &debug_zebra_kernel_cmd);
 613         install_element(CONFIG_NODE, &debug_zebra_kernel_msgdump_cmd);
 614         install_element(CONFIG_NODE, &debug_zebra_rib_cmd);
 615         install_element(CONFIG_NODE, &debug_zebra_fpm_cmd);
 616         install_element(CONFIG_NODE, &debug_zebra_dplane_cmd);
 617         install_element(CONFIG_NODE, &debug_zebra_nexthop_cmd);
 618         install_element(CONFIG_NODE, &no_debug_zebra_events_cmd);
 619         install_element(CONFIG_NODE, &no_debug_zebra_nht_cmd);
 620         install_element(CONFIG_NODE, &no_debug_zebra_mpls_cmd);
 621         install_element(CONFIG_NODE, &no_debug_zebra_vxlan_cmd);
 622         install_element(CONFIG_NODE, &no_debug_zebra_packet_cmd);
 623         install_element(CONFIG_NODE, &no_debug_zebra_kernel_cmd);
 624         install_element(CONFIG_NODE, &no_debug_zebra_kernel_msgdump_cmd);
 625         install_element(CONFIG_NODE, &no_debug_zebra_rib_cmd);
 626         install_element(CONFIG_NODE, &no_debug_zebra_fpm_cmd);
 627         install_element(CONFIG_NODE, &no_debug_zebra_dplane_cmd);
 628 }