Mirror/frr
0
0
Fork 1
mirror of https://github.com/FRRouting/frr.git synced 2025-05-01 05:57:15 +02:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

mgmtd: fully implement debug flags for mgmtd and clients

Browse source 
Signed-off-by: Christian Hopps <chopps@labn.net>
This commit is contained in:
Christian Hopps 2023-04-26 17:50:46 -04:00
parent 13c426150f
commit cfa0facbf9
18 changed files with 304 additions and 202 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

43
doc/user/mgmtd.rst
View file

@ -364,3 +364,46 @@ MGMT Show commands
.. clicmd:: show mgmt commit-history .. clicmd:: show mgmt commit-history
This command dumps details of upto last 10 commits handled by MGMTd. This command dumps details of upto last 10 commits handled by MGMTd.
MGMT Daemon debug commands
==========================
The following debug commands enable debugging within the management daemon:
.. clicmd:: [no] debug mgmt backend
Enable[/Disable] debugging messages related to backend operations within the
management daemon.
.. clicmd:: [no] debug mgmt datastore
Enable[/Disable] debugging messages related to YANG datastore operations
within the management daemon.
.. clicmd:: [no] debug mgmt frontend
Enable[/Disable] debugging messages related to frontend operations within the
management daemon.
.. clicmd:: [no] debug mgmt transaction
Enable[/Disable] debugging messages related to transactions within the
management daemon.
MGMT Client debug commands
==========================
The following debug commands enable debugging within the management front and
backend clients:
.. clicmd:: [no] debug mgmt client backend
Enable[/Disable] debugging messages related to backend operations inside the
backend mgmtd clients.
.. clicmd:: [no] debug mgmt client frontend
Enable[/Disable] debugging messages related to frontend operations inside the
frontend mgmtd clients.

4
lib/command.c
View file

@ -31,6 +31,8 @@
#include "jhash.h" #include "jhash.h"
#include "hook.h" #include "hook.h"
#include "lib_errors.h" #include "lib_errors.h"
#include "mgmt_be_client.h"
#include "mgmt_fe_client.h"
#include "northbound_cli.h" #include "northbound_cli.h"
#include "network.h" #include "network.h"
#include "routemap.h" #include "routemap.h"
@ -2438,6 +2440,8 @@ const char *host_config_get(void)
void cmd_show_lib_debugs(struct vty *vty) void cmd_show_lib_debugs(struct vty *vty)
{ {
route_map_show_debug(vty); route_map_show_debug(vty);
mgmt_debug_be_client_show_debug(vty);
mgmt_debug_fe_client_show_debug(vty);
} }
void install_default(enum node_type node) void install_default(enum node_type node)

165
lib/mgmt_be_client.c
View file

@ -6,29 +6,25 @@
*/ */
#include <zebra.h> #include <zebra.h>
#include "debug.h"
#include "libfrr.h" #include "libfrr.h"
#include "mgmtd/mgmt.h" #include "mgmtd/mgmt.h"
#include "mgmt_be_client.h" #include "mgmt_be_client.h"
#include "mgmt_msg.h" #include "mgmt_msg.h"
#include "mgmt_pb.h" #include "mgmt_pb.h"
#include "network.h" #include "network.h"
#include "northbound.h"
#include "stream.h" #include "stream.h"
#include "sockopt.h" #include "sockopt.h"
#ifdef REDIRECT_DEBUG_TO_STDERR #include "lib/mgmt_be_client_clippy.c"
#define MGMTD_BE_CLIENT_DBG(fmt, ...) \ #define MGMTD_BE_CLIENT_DBG(fmt, ...) \
fprintf(stderr, "%s: " fmt "\n", __func__, ##__VA_ARGS__) DEBUGD(&mgmt_dbg_be_client, "%s:" fmt, __func__, ##__VA_ARGS__)
#define MGMTD_BE_CLIENT_ERR(fmt, ...) \
fprintf(stderr, "%s: ERROR, " fmt "\n", __func__, ##__VA_ARGS__)
#else /* REDIRECT_DEBUG_TO_STDERR */
#define MGMTD_BE_CLIENT_DBG(fmt, ...) \
do { \
if (mgmt_debug_be_client) \
zlog_debug("%s: " fmt, __func__, ##__VA_ARGS__); \
} while (0)
#define MGMTD_BE_CLIENT_ERR(fmt, ...) \ #define MGMTD_BE_CLIENT_ERR(fmt, ...) \
zlog_err("%s: ERROR: " fmt, __func__, ##__VA_ARGS__) zlog_err("%s: ERROR: " fmt, __func__, ##__VA_ARGS__)
#endif /* REDIRECT_DEBUG_TO_STDERR */ #define MGMTD_DBG_BE_CLIENT_CHECK() \
DEBUG_MODE_CHECK(&mgmt_dbg_be_client, DEBUG_MODE_ALL)
DEFINE_MTYPE_STATIC(LIB, MGMTD_BE_BATCH, DEFINE_MTYPE_STATIC(LIB, MGMTD_BE_BATCH,
"MGMTD backend transaction batch data"); "MGMTD backend transaction batch data");
@ -118,8 +114,6 @@ struct mgmt_be_client_ctx {
struct nb_config *candidate_config; struct nb_config *candidate_config;
struct nb_config *running_config; struct nb_config *running_config;
unsigned long num_batch_find;
unsigned long avg_batch_find_tm;
unsigned long num_edit_nb_cfg; unsigned long num_edit_nb_cfg;
unsigned long avg_edit_nb_cfg_tm; unsigned long avg_edit_nb_cfg_tm;
unsigned long num_prep_nb_cfg; unsigned long num_prep_nb_cfg;
@ -136,7 +130,7 @@ struct mgmt_be_client_ctx {
#define FOREACH_BE_TXN_IN_LIST(client_ctx, txn) \ #define FOREACH_BE_TXN_IN_LIST(client_ctx, txn) \
frr_each_safe (mgmt_be_txns, &(client_ctx)->txn_head, (txn)) frr_each_safe (mgmt_be_txns, &(client_ctx)->txn_head, (txn))
static bool mgmt_debug_be_client; struct debug mgmt_dbg_be_client = {0, "Management backend client operations"};
static struct mgmt_be_client_ctx mgmt_be_client_ctx = { static struct mgmt_be_client_ctx mgmt_be_client_ctx = {
.conn_fd = -1, .conn_fd = -1,
@ -479,7 +473,6 @@ static int mgmt_be_txn_cfg_prepare(struct mgmt_be_txn_ctx *txn)
bool error; bool error;
char err_buf[BUFSIZ]; char err_buf[BUFSIZ];
size_t num_processed; size_t num_processed;
bool debug_be = mgmt_debug_be_client;
int err; int err;
assert(txn && txn->client_ctx); assert(txn && txn->client_ctx);
@ -499,8 +492,8 @@ static int mgmt_be_txn_cfg_prepare(struct mgmt_be_txn_ctx *txn)
* interested in validating it. * interested in validating it.
*/ */
error = false; error = false;
if (debug_be)
gettimeofday(&edit_nb_cfg_start, NULL); gettimeofday(&edit_nb_cfg_start, NULL);
nb_candidate_edit_config_changes( nb_candidate_edit_config_changes(
client_ctx->candidate_config, client_ctx->candidate_config,
txn_req->req.set_cfg.cfg_changes, txn_req->req.set_cfg.cfg_changes,
@ -516,16 +509,14 @@ static int mgmt_be_txn_cfg_prepare(struct mgmt_be_txn_ctx *txn)
err_buf); err_buf);
return -1; return -1;
} }
if (debug_be) { gettimeofday(&edit_nb_cfg_end, NULL);
gettimeofday(&edit_nb_cfg_end, NULL); edit_nb_cfg_tm = timeval_elapsed(edit_nb_cfg_end,
edit_nb_cfg_tm = timeval_elapsed( edit_nb_cfg_start);
edit_nb_cfg_end, edit_nb_cfg_start); client_ctx->avg_edit_nb_cfg_tm =
client_ctx->avg_edit_nb_cfg_tm = ((client_ctx->avg_edit_nb_cfg_tm *
((client_ctx->avg_edit_nb_cfg_tm client_ctx->num_edit_nb_cfg) +
* client_ctx->num_edit_nb_cfg) edit_nb_cfg_tm) /
+ edit_nb_cfg_tm) (client_ctx->num_edit_nb_cfg + 1);
/ (client_ctx->num_edit_nb_cfg + 1);
}
client_ctx->num_edit_nb_cfg++; client_ctx->num_edit_nb_cfg++;
} }
@ -540,8 +531,8 @@ static int mgmt_be_txn_cfg_prepare(struct mgmt_be_txn_ctx *txn)
*/ */
nb_ctx.client = NB_CLIENT_CLI; nb_ctx.client = NB_CLIENT_CLI;
nb_ctx.user = (void *)client_ctx->client_params.user_data; nb_ctx.user = (void *)client_ctx->client_params.user_data;
if (debug_be)
gettimeofday(&prep_nb_cfg_start, NULL); gettimeofday(&prep_nb_cfg_start, NULL);
err = nb_candidate_commit_prepare(nb_ctx, client_ctx->candidate_config, err = nb_candidate_commit_prepare(nb_ctx, client_ctx->candidate_config,
"MGMTD Backend Txn", &txn->nb_txn, "MGMTD Backend Txn", &txn->nb_txn,
#ifdef MGMTD_LOCAL_VALIDATIONS_ENABLED #ifdef MGMTD_LOCAL_VALIDATIONS_ENABLED
@ -569,16 +560,13 @@ static int mgmt_be_txn_cfg_prepare(struct mgmt_be_txn_ctx *txn)
"Prepared configs for Txn %llx, %u Batches! successfully!", "Prepared configs for Txn %llx, %u Batches! successfully!",
(unsigned long long)txn->txn_id, (unsigned long long)txn->txn_id,
(uint32_t)num_processed); (uint32_t)num_processed);
if (debug_be) {
gettimeofday(&prep_nb_cfg_end, NULL); gettimeofday(&prep_nb_cfg_end, NULL);
prep_nb_cfg_tm = prep_nb_cfg_tm = timeval_elapsed(prep_nb_cfg_end, prep_nb_cfg_start);
timeval_elapsed(prep_nb_cfg_end, prep_nb_cfg_start); client_ctx->avg_prep_nb_cfg_tm = ((client_ctx->avg_prep_nb_cfg_tm *
client_ctx->avg_prep_nb_cfg_tm = client_ctx->num_prep_nb_cfg) +
((client_ctx->avg_prep_nb_cfg_tm prep_nb_cfg_tm) /
* client_ctx->num_prep_nb_cfg) (client_ctx->num_prep_nb_cfg + 1);
+ prep_nb_cfg_tm)
/ (client_ctx->num_prep_nb_cfg + 1);
}
client_ctx->num_prep_nb_cfg++; client_ctx->num_prep_nb_cfg++;
FOREACH_BE_TXN_BATCH_IN_LIST (txn, batch) { FOREACH_BE_TXN_BATCH_IN_LIST (txn, batch) {
@ -593,12 +581,10 @@ static int mgmt_be_txn_cfg_prepare(struct mgmt_be_txn_ctx *txn)
} }
} }
if (debug_be) MGMTD_BE_CLIENT_DBG(
MGMTD_BE_CLIENT_DBG( "Avg-nb-edit-duration %lu uSec, nb-prep-duration %lu (avg: %lu) uSec, batch size %u",
"Avg-nb-edit-duration %lu uSec, nb-prep-duration %lu (avg: %lu) uSec, batch size %u", client_ctx->avg_edit_nb_cfg_tm, prep_nb_cfg_tm,
client_ctx->avg_edit_nb_cfg_tm, prep_nb_cfg_tm, client_ctx->avg_prep_nb_cfg_tm, (uint32_t)num_processed);
client_ctx->avg_prep_nb_cfg_tm,
(uint32_t)num_processed);
if (error) if (error)
mgmt_be_txn_cfg_abort(txn); mgmt_be_txn_cfg_abort(txn);
@ -736,7 +722,6 @@ static int mgmt_be_txn_proc_cfgapply(struct mgmt_be_txn_ctx *txn)
char err_buf[BUFSIZ]; char err_buf[BUFSIZ];
size_t num_processed; size_t num_processed;
static uint64_t batch_ids[MGMTD_BE_MAX_BATCH_IDS_IN_REQ]; static uint64_t batch_ids[MGMTD_BE_MAX_BATCH_IDS_IN_REQ];
bool debug_be = mgmt_debug_be_client;
assert(txn && txn->client_ctx); assert(txn && txn->client_ctx);
client_ctx = txn->client_ctx; client_ctx = txn->client_ctx;
@ -747,20 +732,16 @@ static int mgmt_be_txn_proc_cfgapply(struct mgmt_be_txn_ctx *txn)
/* /*
* Now apply all the batches we have applied in one go. * Now apply all the batches we have applied in one go.
*/ */
if (debug_be) gettimeofday(&apply_nb_cfg_start, NULL);
gettimeofday(&apply_nb_cfg_start, NULL);
(void)nb_candidate_commit_apply(txn->nb_txn, true, &txn->nb_txn_id, (void)nb_candidate_commit_apply(txn->nb_txn, true, &txn->nb_txn_id,
err_buf, sizeof(err_buf) - 1); err_buf, sizeof(err_buf) - 1);
if (debug_be) { gettimeofday(&apply_nb_cfg_end, NULL);
gettimeofday(&apply_nb_cfg_end, NULL);
apply_nb_cfg_tm = apply_nb_cfg_tm = timeval_elapsed(apply_nb_cfg_end, apply_nb_cfg_start);
timeval_elapsed(apply_nb_cfg_end, apply_nb_cfg_start); client_ctx->avg_apply_nb_cfg_tm = ((client_ctx->avg_apply_nb_cfg_tm *
client_ctx->avg_apply_nb_cfg_tm = client_ctx->num_apply_nb_cfg) +
((client_ctx->avg_apply_nb_cfg_tm apply_nb_cfg_tm) /
* client_ctx->num_apply_nb_cfg) (client_ctx->num_apply_nb_cfg + 1);
+ apply_nb_cfg_tm)
/ (client_ctx->num_apply_nb_cfg + 1);
}
client_ctx->num_apply_nb_cfg++; client_ctx->num_apply_nb_cfg++;
txn->nb_txn = NULL; txn->nb_txn = NULL;
@ -789,10 +770,8 @@ static int mgmt_be_txn_proc_cfgapply(struct mgmt_be_txn_ctx *txn)
mgmt_be_send_apply_reply(client_ctx, txn->txn_id, batch_ids, mgmt_be_send_apply_reply(client_ctx, txn->txn_id, batch_ids,
num_processed, true, NULL); num_processed, true, NULL);
if (debug_be) MGMTD_BE_CLIENT_DBG("Nb-apply-duration %lu (avg: %lu) uSec",
MGMTD_BE_CLIENT_DBG("Nb-apply-duration %lu (avg: %lu) uSec", apply_nb_cfg_tm, client_ctx->avg_apply_nb_cfg_tm);
apply_nb_cfg_tm,
client_ctx->avg_apply_nb_cfg_tm);
return 0; return 0;
} }
@ -903,7 +882,7 @@ static void mgmt_be_client_proc_msgbufs(struct event *thread)
struct mgmt_be_client_ctx *client_ctx = EVENT_ARG(thread); struct mgmt_be_client_ctx *client_ctx = EVENT_ARG(thread);
if (mgmt_msg_procbufs(&client_ctx->mstate, mgmt_be_client_process_msg, if (mgmt_msg_procbufs(&client_ctx->mstate, mgmt_be_client_process_msg,
client_ctx, mgmt_debug_be_client)) client_ctx, MGMTD_DBG_BE_CLIENT_CHECK()))
mgmt_be_client_register_event(client_ctx, MGMTD_BE_PROC_MSG); mgmt_be_client_register_event(client_ctx, MGMTD_BE_PROC_MSG);
} }
@ -913,7 +892,7 @@ static void mgmt_be_client_read(struct event *thread)
enum mgmt_msg_rsched rv; enum mgmt_msg_rsched rv;
rv = mgmt_msg_read(&client_ctx->mstate, client_ctx->conn_fd, rv = mgmt_msg_read(&client_ctx->mstate, client_ctx->conn_fd,
mgmt_debug_be_client); MGMTD_DBG_BE_CLIENT_CHECK());
if (rv == MSR_DISCONNECT) { if (rv == MSR_DISCONNECT) {
mgmt_be_server_disconnect(client_ctx, true); mgmt_be_server_disconnect(client_ctx, true);
return; return;
@ -958,7 +937,7 @@ static int mgmt_be_client_send_msg(struct mgmt_be_client_ctx *client_ctx,
&client_ctx->mstate, be_msg, &client_ctx->mstate, be_msg,
mgmtd__be_message__get_packed_size(be_msg), mgmtd__be_message__get_packed_size(be_msg),
(size_t(*)(void *, void *))mgmtd__be_message__pack, (size_t(*)(void *, void *))mgmtd__be_message__pack,
mgmt_debug_be_client); MGMTD_DBG_BE_CLIENT_CHECK());
mgmt_be_client_sched_msg_write(client_ctx); mgmt_be_client_sched_msg_write(client_ctx);
return rv; return rv;
} }
@ -969,7 +948,7 @@ static void mgmt_be_client_write(struct event *thread)
enum mgmt_msg_wsched rv; enum mgmt_msg_wsched rv;
rv = mgmt_msg_write(&client_ctx->mstate, client_ctx->conn_fd, rv = mgmt_msg_write(&client_ctx->mstate, client_ctx->conn_fd,
mgmt_debug_be_client); MGMTD_DBG_BE_CLIENT_CHECK());
if (rv == MSW_SCHED_STREAM) if (rv == MSW_SCHED_STREAM)
mgmt_be_client_register_event(client_ctx, MGMTD_BE_CONN_WRITE); mgmt_be_client_register_event(client_ctx, MGMTD_BE_CONN_WRITE);
else if (rv == MSW_DISCONNECT) else if (rv == MSW_DISCONNECT)
@ -1017,7 +996,7 @@ static int mgmt_be_send_subscr_req(struct mgmt_be_client_ctx *client_ctx,
static void mgmt_be_server_connect(struct mgmt_be_client_ctx *client_ctx) static void mgmt_be_server_connect(struct mgmt_be_client_ctx *client_ctx)
{ {
const char *dbgtag = mgmt_debug_be_client ? "BE-client" : NULL; const char *dbgtag = MGMTD_DBG_BE_CLIENT_CHECK() ? "BE-client" : NULL;
assert(client_ctx->conn_fd == -1); assert(client_ctx->conn_fd == -1);
client_ctx->conn_fd = mgmt_msg_connect( client_ctx->conn_fd = mgmt_msg_connect(
@ -1097,7 +1076,47 @@ mgmt_be_client_schedule_conn_retry(struct mgmt_be_client_ctx *client_ctx,
&client_ctx->conn_retry_tmr); &client_ctx->conn_retry_tmr);
} }
extern struct nb_config *running_config; DEFPY(debug_mgmt_client_be, debug_mgmt_client_be_cmd,
"[no] debug mgmt client backend",
NO_STR DEBUG_STR MGMTD_STR
"client\n"
"backend\n")
{
uint32_t mode = DEBUG_NODE2MODE(vty->node);
DEBUG_MODE_SET(&mgmt_dbg_be_client, mode, !no);
return CMD_SUCCESS;
}
static void mgmt_debug_client_be_set_all(uint32_t flags, bool set)
{
DEBUG_FLAGS_SET(&mgmt_dbg_be_client, flags, set);
}
static int mgmt_debug_be_client_config_write(struct vty *vty)
{
if (DEBUG_MODE_CHECK(&mgmt_dbg_be_client, DEBUG_MODE_CONF))
vty_out(vty, "debug mgmt client frontend\n");
return 1;
}
void mgmt_debug_be_client_show_debug(struct vty *vty)
{
if (MGMTD_DBG_BE_CLIENT_CHECK())
vty_out(vty, "debug mgmt client backend\n");
}
static struct debug_callbacks mgmt_dbg_be_client_cbs = {
.debug_set_all = mgmt_debug_client_be_set_all};
static struct cmd_node mgmt_dbg_node = {
.name = "mgmt backend client",
.node = DEBUG_NODE,
.prompt = "",
.config_write = mgmt_debug_be_client_config_write,
};
/* /*
* Initialize library and try connecting with MGMTD. * Initialize library and try connecting with MGMTD.
@ -1134,6 +1153,16 @@ uintptr_t mgmt_be_client_lib_init(struct mgmt_be_client_params *params,
return (uintptr_t)&mgmt_be_client_ctx; return (uintptr_t)&mgmt_be_client_ctx;
} }
void mgmt_be_client_lib_vty_init(void)
{
debug_init(&mgmt_dbg_be_client_cbs);
install_node(&mgmt_dbg_node);
install_element(ENABLE_NODE, &debug_mgmt_client_be_cmd);
install_element(CONFIG_NODE, &debug_mgmt_client_be_cmd);
}
/* /*
* Subscribe with MGMTD for one or more YANG subtree(s). * Subscribe with MGMTD for one or more YANG subtree(s).
*/ */

14
lib/mgmt_be_client.h
View file

@ -191,6 +191,20 @@ mgmt_be_client_name2id(const char *name)
extern uintptr_t mgmt_be_client_lib_init(struct mgmt_be_client_params *params, extern uintptr_t mgmt_be_client_lib_init(struct mgmt_be_client_params *params,
struct event_loop *master_thread); struct event_loop *master_thread);
/*
* Initialize library vty (adds debug support).
*
* This call should be added to your component when enabling other vty code to
* enable mgmtd client debugs. When adding, one needs to also add a their
* component in `xref2vtysh.py` as well.
*/
extern void mgmt_be_client_lib_vty_init(void);
/*
* Print enabled debugging commands.
*/
extern void mgmt_debug_be_client_show_debug(struct vty *vty);
/* /*
* Subscribe with MGMTD for one or more YANG subtree(s). * Subscribe with MGMTD for one or more YANG subtree(s).
* *

83
lib/mgmt_fe_client.c
View file

@ -6,6 +6,7 @@
*/ */
#include <zebra.h> #include <zebra.h>
#include "debug.h"
#include "memory.h" #include "memory.h"
#include "libfrr.h" #include "libfrr.h"
#include "mgmt_fe_client.h" #include "mgmt_fe_client.h"
@ -15,20 +16,14 @@
#include "stream.h" #include "stream.h"
#include "sockopt.h" #include "sockopt.h"
#ifdef REDIRECT_DEBUG_TO_STDERR #include "lib/mgmt_fe_client_clippy.c"
#define MGMTD_FE_CLIENT_DBG(fmt, ...) \
fprintf(stderr, "%s: " fmt "\n", __func__, ##__VA_ARGS__) #define MGMTD_FE_CLIENT_DBG(fmt, ...) \
#define MGMTD_FE_CLIENT_ERR(fmt, ...) \ DEBUGD(&mgmt_dbg_fe_client, "%s:" fmt, __func__, ##__VA_ARGS__)
fprintf(stderr, "%s: ERROR, " fmt "\n", __func__, ##__VA_ARGS__) #define MGMTD_FE_CLIENT_ERR(fmt, ...) \
#else /* REDIRECT_DEBUG_TO_STDERR */
#define MGMTD_FE_CLIENT_DBG(fmt, ...) \
do { \
if (mgmt_debug_fe_client) \
zlog_debug("%s: " fmt, __func__, ##__VA_ARGS__); \
} while (0)
#define MGMTD_FE_CLIENT_ERR(fmt, ...) \
zlog_err("%s: ERROR: " fmt, __func__, ##__VA_ARGS__) zlog_err("%s: ERROR: " fmt, __func__, ##__VA_ARGS__)
#endif /* REDIRECT_DEBUG_TO_STDERR */ #define MGMTD_DBG_FE_CLIENT_CHECK() \
DEBUG_MODE_CHECK(&mgmt_dbg_fe_client, DEBUG_MODE_ALL)
struct mgmt_fe_client_ctx; struct mgmt_fe_client_ctx;
@ -69,7 +64,7 @@ struct mgmt_fe_client_ctx {
#define FOREACH_SESSION_IN_LIST(client_ctx, session) \ #define FOREACH_SESSION_IN_LIST(client_ctx, session) \
frr_each_safe (mgmt_sessions, &(client_ctx)->client_sessions, (session)) frr_each_safe (mgmt_sessions, &(client_ctx)->client_sessions, (session))
static bool mgmt_debug_fe_client; struct debug mgmt_dbg_fe_client = {0, "Management frontend client operations"};
static struct mgmt_fe_client_ctx mgmt_fe_client_ctx = { static struct mgmt_fe_client_ctx mgmt_fe_client_ctx = {
.conn_fd = -1, .conn_fd = -1,
@ -169,7 +164,7 @@ static int mgmt_fe_client_send_msg(struct mgmt_fe_client_ctx *client_ctx,
&client_ctx->mstate, fe_msg, &client_ctx->mstate, fe_msg,
mgmtd__fe_message__get_packed_size(fe_msg), mgmtd__fe_message__get_packed_size(fe_msg),
(size_t(*)(void *, void *))mgmtd__fe_message__pack, (size_t(*)(void *, void *))mgmtd__fe_message__pack,
mgmt_debug_fe_client); MGMTD_DBG_FE_CLIENT_CHECK());
mgmt_fe_client_sched_msg_write(client_ctx); mgmt_fe_client_sched_msg_write(client_ctx);
return rv; return rv;
} }
@ -181,7 +176,7 @@ static void mgmt_fe_client_write(struct event *thread)
client_ctx = (struct mgmt_fe_client_ctx *)EVENT_ARG(thread); client_ctx = (struct mgmt_fe_client_ctx *)EVENT_ARG(thread);
rv = mgmt_msg_write(&client_ctx->mstate, client_ctx->conn_fd, rv = mgmt_msg_write(&client_ctx->mstate, client_ctx->conn_fd,
mgmt_debug_fe_client); MGMTD_DBG_FE_CLIENT_CHECK());
if (rv == MSW_SCHED_STREAM) if (rv == MSW_SCHED_STREAM)
mgmt_fe_client_register_event(client_ctx, MGMTD_FE_CONN_WRITE); mgmt_fe_client_register_event(client_ctx, MGMTD_FE_CONN_WRITE);
else if (rv == MSW_DISCONNECT) else if (rv == MSW_DISCONNECT)
@ -679,7 +674,7 @@ static void mgmt_fe_client_proc_msgbufs(struct event *thread)
client_ctx = (struct mgmt_fe_client_ctx *)EVENT_ARG(thread); client_ctx = (struct mgmt_fe_client_ctx *)EVENT_ARG(thread);
if (mgmt_msg_procbufs(&client_ctx->mstate, mgmt_fe_client_process_msg, if (mgmt_msg_procbufs(&client_ctx->mstate, mgmt_fe_client_process_msg,
client_ctx, mgmt_debug_fe_client)) client_ctx, MGMTD_DBG_FE_CLIENT_CHECK()))
mgmt_fe_client_register_event(client_ctx, MGMTD_FE_PROC_MSG); mgmt_fe_client_register_event(client_ctx, MGMTD_FE_PROC_MSG);
} }
@ -691,7 +686,7 @@ static void mgmt_fe_client_read(struct event *thread)
client_ctx = (struct mgmt_fe_client_ctx *)EVENT_ARG(thread); client_ctx = (struct mgmt_fe_client_ctx *)EVENT_ARG(thread);
rv = mgmt_msg_read(&client_ctx->mstate, client_ctx->conn_fd, rv = mgmt_msg_read(&client_ctx->mstate, client_ctx->conn_fd,
mgmt_debug_fe_client); MGMTD_DBG_FE_CLIENT_CHECK());
if (rv == MSR_DISCONNECT) { if (rv == MSR_DISCONNECT) {
mgmt_fe_server_disconnect(client_ctx, true); mgmt_fe_server_disconnect(client_ctx, true);
return; return;
@ -703,7 +698,7 @@ static void mgmt_fe_client_read(struct event *thread)
static void mgmt_fe_server_connect(struct mgmt_fe_client_ctx *client_ctx) static void mgmt_fe_server_connect(struct mgmt_fe_client_ctx *client_ctx)
{ {
const char *dbgtag = mgmt_debug_fe_client ? "FE-client" : NULL; const char *dbgtag = MGMTD_DBG_FE_CLIENT_CHECK() ? "FE-client" : NULL;
assert(client_ctx->conn_fd == -1); assert(client_ctx->conn_fd == -1);
client_ctx->conn_fd = mgmt_msg_connect( client_ctx->conn_fd = mgmt_msg_connect(
@ -779,6 +774,48 @@ static void mgmt_fe_client_schedule_conn_retry(
&client_ctx->conn_retry_tmr); &client_ctx->conn_retry_tmr);
} }
DEFPY(debug_mgmt_client_fe, debug_mgmt_client_fe_cmd,
"[no] debug mgmt client frontend",
NO_STR DEBUG_STR MGMTD_STR
"client\n"
"frontend\n")
{
uint32_t mode = DEBUG_NODE2MODE(vty->node);
DEBUG_MODE_SET(&mgmt_dbg_fe_client, mode, !no);
return CMD_SUCCESS;
}
static void mgmt_debug_client_fe_set_all(uint32_t flags, bool set)
{
DEBUG_FLAGS_SET(&mgmt_dbg_fe_client, flags, set);
}
static int mgmt_debug_fe_client_config_write(struct vty *vty)
{
if (DEBUG_MODE_CHECK(&mgmt_dbg_fe_client, DEBUG_MODE_CONF))
vty_out(vty, "debug mgmt client frontend\n");
return CMD_SUCCESS;
}
void mgmt_debug_fe_client_show_debug(struct vty *vty)
{
if (MGMTD_DBG_FE_CLIENT_CHECK())
vty_out(vty, "debug mgmt client frontend\n");
}
static struct debug_callbacks mgmt_dbg_fe_client_cbs = {
.debug_set_all = mgmt_debug_client_fe_set_all};
static struct cmd_node mgmt_dbg_node = {
.name = "mgmt client frontend",
.node = DEBUG_NODE,
.prompt = "",
.config_write = mgmt_debug_fe_client_config_write,
};
/* /*
* Initialize library and try connecting with MGMTD. * Initialize library and try connecting with MGMTD.
*/ */
@ -809,6 +846,14 @@ uintptr_t mgmt_fe_client_lib_init(struct mgmt_fe_client_params *params,
return (uintptr_t)&mgmt_fe_client_ctx; return (uintptr_t)&mgmt_fe_client_ctx;
} }
void mgmt_fe_client_lib_vty_init(void)
{
debug_init(&mgmt_dbg_fe_client_cbs);
install_node(&mgmt_dbg_node);
install_element(ENABLE_NODE, &debug_mgmt_client_fe_cmd);
install_element(CONFIG_NODE, &debug_mgmt_client_fe_cmd);
}
/* /*
* Create a new Session for a Frontend Client connection. * Create a new Session for a Frontend Client connection.
*/ */

14
lib/mgmt_fe_client.h
View file

@ -133,6 +133,20 @@ struct mgmt_fe_client_params {
extern uintptr_t mgmt_fe_client_lib_init(struct mgmt_fe_client_params *params, extern uintptr_t mgmt_fe_client_lib_init(struct mgmt_fe_client_params *params,
struct event_loop *master_thread); struct event_loop *master_thread);
/*
* Initialize library vty (adds debug support).
*
* This call should be added to your component when enabling other vty code to
* enable mgmtd client debugs. When adding, one needs to also add a their
* component in `xref2vtysh.py` as well.
*/
extern void mgmt_fe_client_lib_vty_init(void);
/*
* Print enabled debugging commands.
*/
extern void mgmt_debug_fe_client_show_debug(struct vty *vty);
/* /*
* Create a new Session for a Frontend Client connection. * Create a new Session for a Frontend Client connection.
* *

2
lib/subdir.am
View file

@ -179,6 +179,8 @@ clippy_scan += \
lib/filter_cli.c \ lib/filter_cli.c \
lib/if_rmap.c \ lib/if_rmap.c \
lib/log_vty.c \ lib/log_vty.c \
lib/mgmt_be_client.c \
lib/mgmt_fe_client.c \
lib/nexthop_group.c \ lib/nexthop_group.c \
lib/northbound_cli.c \ lib/northbound_cli.c \
lib/plist.c \ lib/plist.c \

9
mgmtd/mgmt.c
View file

@ -7,6 +7,7 @@
*/ */
#include <zebra.h> #include <zebra.h>
#include "debug.h"
#include "mgmtd/mgmt.h" #include "mgmtd/mgmt.h"
#include "mgmtd/mgmt_be_server.h" #include "mgmtd/mgmt_be_server.h"
#include "mgmtd/mgmt_be_adapter.h" #include "mgmtd/mgmt_be_adapter.h"
@ -16,10 +17,10 @@
#include "mgmtd/mgmt_history.h" #include "mgmtd/mgmt_history.h"
#include "mgmtd/mgmt_memory.h" #include "mgmtd/mgmt_memory.h"
bool mgmt_debug_be; struct debug mgmt_debug_be = {.desc = "Management backend adapater"};
bool mgmt_debug_fe; struct debug mgmt_debug_ds = {.desc = "Management datastore"};
bool mgmt_debug_ds; struct debug mgmt_debug_fe = {.desc = "Management frontend adapater"};
bool mgmt_debug_txn; struct debug mgmt_debug_txn = {.desc = "Management transaction"};
/* MGMTD process wide configuration. */ /* MGMTD process wide configuration. */
static struct mgmt_master mgmt_master; static struct mgmt_master mgmt_master;

14
mgmtd/mgmt.h
View file

@ -9,6 +9,7 @@
#ifndef _FRR_MGMTD_H #ifndef _FRR_MGMTD_H
#define _FRR_MGMTD_H #define _FRR_MGMTD_H
#include "debug.h"
#include "vrf.h" #include "vrf.h"
#include "defaults.h" #include "defaults.h"
#include "stream.h" #include "stream.h"
@ -23,10 +24,15 @@
#define MGMTD_SOCKET_BUF_SIZE 65535 #define MGMTD_SOCKET_BUF_SIZE 65535
#define MGMTD_MAX_COMMIT_LIST 10 #define MGMTD_MAX_COMMIT_LIST 10
extern bool mgmt_debug_be; extern struct debug mgmt_debug_be;
extern bool mgmt_debug_fe; extern struct debug mgmt_debug_ds;
extern bool mgmt_debug_ds; extern struct debug mgmt_debug_fe;
extern bool mgmt_debug_txn; extern struct debug mgmt_debug_txn;
#define MGMT_DEBUG_BE_CHECK() DEBUG_MODE_CHECK(&mgmt_debug_be, DEBUG_MODE_ALL)
#define MGMT_DEBUG_DS_CHECK() DEBUG_MODE_CHECK(&mgmt_debug_ds, DEBUG_MODE_ALL)
#define MGMT_DEBUG_FE_CHECK() DEBUG_MODE_CHECK(&mgmt_debug_fe, DEBUG_MODE_ALL)
#define MGMT_DEBUG_TXN_CHECK() DEBUG_MODE_CHECK(&mgmt_debug_tx, DEBUG_MODE_ALL)
struct mgmt_txn_ctx; struct mgmt_txn_ctx;

24
mgmtd/mgmt_be_adapter.c
View file

@ -18,20 +18,10 @@
#include "mgmt_be_client.h" #include "mgmt_be_client.h"
#include "mgmtd/mgmt_be_adapter.h" #include "mgmtd/mgmt_be_adapter.h"
#ifdef REDIRECT_DEBUG_TO_STDERR #define MGMTD_BE_ADAPTER_DBG(fmt, ...) \
#define MGMTD_BE_ADAPTER_DBG(fmt, ...) \ DEBUGD(&mgmt_debug_be, "%s:" fmt, __func__, ##__VA_ARGS__)
fprintf(stderr, "%s: " fmt "\n", __func__, ##__VA_ARGS__)
#define MGMTD_BE_ADAPTER_ERR(fmt, ...) \
fprintf(stderr, "%s: ERROR, " fmt "\n", __func__, ##__VA_ARGS__)
#else /* REDIRECT_DEBUG_TO_STDERR */
#define MGMTD_BE_ADAPTER_DBG(fmt, ...) \
do { \
if (mgmt_debug_be) \
zlog_debug("%s: " fmt, __func__, ##__VA_ARGS__); \
} while (0)
#define MGMTD_BE_ADAPTER_ERR(fmt, ...) \ #define MGMTD_BE_ADAPTER_ERR(fmt, ...) \
zlog_err("%s: ERROR: " fmt, __func__, ##__VA_ARGS__) zlog_err("%s: ERROR: " fmt, __func__, ##__VA_ARGS__)
#endif /* REDIRECT_DEBUG_TO_STDERR */
#define FOREACH_ADAPTER_IN_LIST(adapter) \ #define FOREACH_ADAPTER_IN_LIST(adapter) \
frr_each_safe (mgmt_be_adapters, &mgmt_be_adapters, (adapter)) frr_each_safe (mgmt_be_adapters, &mgmt_be_adapters, (adapter))
@ -521,7 +511,7 @@ static int mgmt_be_adapter_send_msg(struct mgmt_be_client_adapter *adapter,
&adapter->mstate, be_msg, &adapter->mstate, be_msg,
mgmtd__be_message__get_packed_size(be_msg), mgmtd__be_message__get_packed_size(be_msg),
(size_t(*)(void *, void *))mgmtd__be_message__pack, (size_t(*)(void *, void *))mgmtd__be_message__pack,
mgmt_debug_be); MGMT_DEBUG_BE_CHECK());
mgmt_be_adapter_sched_msg_write(adapter); mgmt_be_adapter_sched_msg_write(adapter);
return rv; return rv;
} }
@ -619,7 +609,7 @@ static void mgmt_be_adapter_proc_msgbufs(struct event *thread)
struct mgmt_be_client_adapter *adapter = EVENT_ARG(thread); struct mgmt_be_client_adapter *adapter = EVENT_ARG(thread);
if (mgmt_msg_procbufs(&adapter->mstate, mgmt_be_adapter_process_msg, if (mgmt_msg_procbufs(&adapter->mstate, mgmt_be_adapter_process_msg,
adapter, mgmt_debug_be)) adapter, MGMT_DEBUG_BE_CHECK()))
mgmt_be_adapter_register_event(adapter, MGMTD_BE_PROC_MSG); mgmt_be_adapter_register_event(adapter, MGMTD_BE_PROC_MSG);
} }
@ -630,7 +620,8 @@ static void mgmt_be_adapter_read(struct event *thread)
adapter = (struct mgmt_be_client_adapter *)EVENT_ARG(thread); adapter = (struct mgmt_be_client_adapter *)EVENT_ARG(thread);
rv = mgmt_msg_read(&adapter->mstate, adapter->conn_fd, mgmt_debug_be); rv = mgmt_msg_read(&adapter->mstate, adapter->conn_fd,
MGMT_DEBUG_BE_CHECK());
if (rv == MSR_DISCONNECT) { if (rv == MSR_DISCONNECT) {
mgmt_be_adapter_disconnect(adapter); mgmt_be_adapter_disconnect(adapter);
return; return;
@ -645,7 +636,8 @@ static void mgmt_be_adapter_write(struct event *thread)
struct mgmt_be_client_adapter *adapter = EVENT_ARG(thread); struct mgmt_be_client_adapter *adapter = EVENT_ARG(thread);
enum mgmt_msg_wsched rv; enum mgmt_msg_wsched rv;
rv = mgmt_msg_write(&adapter->mstate, adapter->conn_fd, mgmt_debug_be); rv = mgmt_msg_write(&adapter->mstate, adapter->conn_fd,
MGMT_DEBUG_BE_CHECK());
if (rv == MSW_SCHED_STREAM) if (rv == MSW_SCHED_STREAM)
mgmt_be_adapter_register_event(adapter, MGMTD_BE_CONN_WRITE); mgmt_be_adapter_register_event(adapter, MGMTD_BE_CONN_WRITE);
else if (rv == MSW_DISCONNECT) else if (rv == MSW_DISCONNECT)

12
mgmtd/mgmt_be_server.c
View file

@ -13,20 +13,10 @@
#include "mgmtd/mgmt_be_server.h" #include "mgmtd/mgmt_be_server.h"
#include "mgmtd/mgmt_be_adapter.h" #include "mgmtd/mgmt_be_adapter.h"
#ifdef REDIRECT_DEBUG_TO_STDERR
#define MGMTD_BE_SRVR_DBG(fmt, ...) \
fprintf(stderr, "%s: " fmt "\n", __func__, ##__VA_ARGS__)
#define MGMTD_BE_SRVR_ERR(fmt, ...) \
fprintf(stderr, "%s: ERROR, " fmt "\n", __func__, ##__VA_ARGS__)
#else /* REDIRECT_DEBUG_TO_STDERR */
#define MGMTD_BE_SRVR_DBG(fmt, ...) \ #define MGMTD_BE_SRVR_DBG(fmt, ...) \
do { \ DEBUGD(&mgmt_debug_be, "%s:" fmt, __func__, ##__VA_ARGS__)
if (mgmt_debug_be) \
zlog_debug("%s: " fmt, __func__, ##__VA_ARGS__); \
} while (0)
#define MGMTD_BE_SRVR_ERR(fmt, ...) \ #define MGMTD_BE_SRVR_ERR(fmt, ...) \
zlog_err("%s: ERROR: " fmt, __func__, ##__VA_ARGS__) zlog_err("%s: ERROR: " fmt, __func__, ##__VA_ARGS__)
#endif /* REDIRECT_DEBUG_TO_STDERR */
static int mgmt_be_listen_fd = -1; static int mgmt_be_listen_fd = -1;
static struct event_loop *mgmt_be_listen_tm; static struct event_loop *mgmt_be_listen_tm;

12
mgmtd/mgmt_ds.c
View file

@ -15,20 +15,10 @@
#include "mgmtd/mgmt_txn.h" #include "mgmtd/mgmt_txn.h"
#include "libyang/libyang.h" #include "libyang/libyang.h"
#ifdef REDIRECT_DEBUG_TO_STDERR
#define MGMTD_DS_DBG(fmt, ...) \ #define MGMTD_DS_DBG(fmt, ...) \
fprintf(stderr, "%s: " fmt "\n", __func__, ##__VA_ARGS__) DEBUGD(&mgmt_debug_ds, "%s:" fmt, __func__, ##__VA_ARGS__)
#define MGMTD_DS_ERR(fmt, ...) \
fprintf(stderr, "%s: ERROR, " fmt "\n", __func__, ##__VA_ARGS__)
#else /* REDIRECT_DEBUG_TO_STDERR */
#define MGMTD_DS_DBG(fmt, ...) \
do { \
if (mgmt_debug_ds) \
zlog_debug("%s: " fmt, __func__, ##__VA_ARGS__); \
} while (0)
#define MGMTD_DS_ERR(fmt, ...) \ #define MGMTD_DS_ERR(fmt, ...) \
zlog_err("%s: ERROR: " fmt, __func__, ##__VA_ARGS__) zlog_err("%s: ERROR: " fmt, __func__, ##__VA_ARGS__)
#endif /* REDIRECT_DEBUG_TO_STDERR */
struct mgmt_ds_ctx { struct mgmt_ds_ctx {
Mgmtd__DatastoreId ds_id; Mgmtd__DatastoreId ds_id;

24
mgmtd/mgmt_fe_adapter.c
View file

@ -19,20 +19,10 @@
#include "mgmtd/mgmt_memory.h" #include "mgmtd/mgmt_memory.h"
#include "mgmtd/mgmt_fe_adapter.h" #include "mgmtd/mgmt_fe_adapter.h"
#ifdef REDIRECT_DEBUG_TO_STDERR #define MGMTD_FE_ADAPTER_DBG(fmt, ...) \
#define MGMTD_FE_ADAPTER_DBG(fmt, ...) \ DEBUGD(&mgmt_debug_fe, "%s:" fmt, __func__, ##__VA_ARGS__)
fprintf(stderr, "%s: " fmt "\n", __func__, ##__VA_ARGS__)
#define MGMTD_FE_ADAPTER_ERR(fmt, ...) \
fprintf(stderr, "%s: ERROR, " fmt "\n", __func__, ##__VA_ARGS__)
#else /* REDIRECT_DEBUG_TO_STDERR */
#define MGMTD_FE_ADAPTER_DBG(fmt, ...) \
do { \
if (mgmt_debug_fe) \
zlog_debug("%s: " fmt, __func__, ##__VA_ARGS__); \
} while (0)
#define MGMTD_FE_ADAPTER_ERR(fmt, ...) \ #define MGMTD_FE_ADAPTER_ERR(fmt, ...) \
zlog_err("%s: ERROR: " fmt, __func__, ##__VA_ARGS__) zlog_err("%s: ERROR: " fmt, __func__, ##__VA_ARGS__)
#endif /* REDIRECT_DEBUG_TO_STDERR */
#define FOREACH_ADAPTER_IN_LIST(adapter) \ #define FOREACH_ADAPTER_IN_LIST(adapter) \
frr_each_safe (mgmt_fe_adapters, &mgmt_fe_adapters, (adapter)) frr_each_safe (mgmt_fe_adapters, &mgmt_fe_adapters, (adapter))
@ -399,7 +389,7 @@ mgmt_fe_adapter_send_msg(struct mgmt_fe_client_adapter *adapter,
&adapter->mstate, fe_msg, &adapter->mstate, fe_msg,
mgmtd__fe_message__get_packed_size(fe_msg), mgmtd__fe_message__get_packed_size(fe_msg),
(size_t(*)(void *, void *))mgmtd__fe_message__pack, (size_t(*)(void *, void *))mgmtd__fe_message__pack,
mgmt_debug_fe); MGMT_DEBUG_FE_CHECK());
mgmt_fe_adapter_sched_msg_write(adapter); mgmt_fe_adapter_sched_msg_write(adapter);
return rv; return rv;
} }
@ -1439,7 +1429,7 @@ static void mgmt_fe_adapter_proc_msgbufs(struct event *thread)
struct mgmt_fe_client_adapter *adapter = EVENT_ARG(thread); struct mgmt_fe_client_adapter *adapter = EVENT_ARG(thread);
if (mgmt_msg_procbufs(&adapter->mstate, mgmt_fe_adapter_process_msg, if (mgmt_msg_procbufs(&adapter->mstate, mgmt_fe_adapter_process_msg,
adapter, mgmt_debug_fe)) adapter, MGMT_DEBUG_FE_CHECK()))
mgmt_fe_adapter_register_event(adapter, MGMTD_FE_PROC_MSG); mgmt_fe_adapter_register_event(adapter, MGMTD_FE_PROC_MSG);
} }
@ -1448,7 +1438,8 @@ static void mgmt_fe_adapter_read(struct event *thread)
struct mgmt_fe_client_adapter *adapter = EVENT_ARG(thread); struct mgmt_fe_client_adapter *adapter = EVENT_ARG(thread);
enum mgmt_msg_rsched rv; enum mgmt_msg_rsched rv;
rv = mgmt_msg_read(&adapter->mstate, adapter->conn_fd, mgmt_debug_fe); rv = mgmt_msg_read(&adapter->mstate, adapter->conn_fd,
MGMT_DEBUG_FE_CHECK());
if (rv == MSR_DISCONNECT) { if (rv == MSR_DISCONNECT) {
mgmt_fe_adapter_disconnect(adapter); mgmt_fe_adapter_disconnect(adapter);
return; return;
@ -1463,7 +1454,8 @@ static void mgmt_fe_adapter_write(struct event *thread)
struct mgmt_fe_client_adapter *adapter = EVENT_ARG(thread); struct mgmt_fe_client_adapter *adapter = EVENT_ARG(thread);
enum mgmt_msg_wsched rv; enum mgmt_msg_wsched rv;
rv = mgmt_msg_write(&adapter->mstate, adapter->conn_fd, mgmt_debug_fe); rv = mgmt_msg_write(&adapter->mstate, adapter->conn_fd,
MGMT_DEBUG_FE_CHECK());
if (rv == MSW_SCHED_STREAM) if (rv == MSW_SCHED_STREAM)
mgmt_fe_adapter_register_event(adapter, MGMTD_FE_CONN_WRITE); mgmt_fe_adapter_register_event(adapter, MGMTD_FE_CONN_WRITE);
else if (rv == MSW_DISCONNECT) else if (rv == MSW_DISCONNECT)

12
mgmtd/mgmt_fe_server.c
View file

@ -13,20 +13,10 @@
#include "mgmtd/mgmt_fe_server.h" #include "mgmtd/mgmt_fe_server.h"
#include "mgmtd/mgmt_fe_adapter.h" #include "mgmtd/mgmt_fe_adapter.h"
#ifdef REDIRECT_DEBUG_TO_STDERR
#define MGMTD_FE_SRVR_DBG(fmt, ...) \
fprintf(stderr, "%s: " fmt "\n", __func__, ##__VA_ARGS__)
#define MGMTD_FE_SRVR_ERR(fmt, ...) \
fprintf(stderr, "%s: ERROR, " fmt "\n", __func__, ##__VA_ARGS__)
#else /* REDIRECT_DEBUG_TO_STDERR */
#define MGMTD_FE_SRVR_DBG(fmt, ...) \ #define MGMTD_FE_SRVR_DBG(fmt, ...) \
do { \ DEBUGD(&mgmt_debug_fe, "%s:" fmt, __func__, ##__VA_ARGS__)
if (mgmt_debug_fe) \
zlog_debug("%s: " fmt, __func__, ##__VA_ARGS__); \
} while (0)
#define MGMTD_FE_SRVR_ERR(fmt, ...) \ #define MGMTD_FE_SRVR_ERR(fmt, ...) \
zlog_err("%s: ERROR: " fmt, __func__, ##__VA_ARGS__) zlog_err("%s: ERROR: " fmt, __func__, ##__VA_ARGS__)
#endif /* REDIRECT_DEBUG_TO_STDERR */
static int mgmt_fe_listen_fd = -1; static int mgmt_fe_listen_fd = -1;
static struct event_loop *mgmt_fe_listen_tm; static struct event_loop *mgmt_fe_listen_tm;

14
mgmtd/mgmt_txn.c
View file

@ -14,20 +14,10 @@
#include "mgmtd/mgmt_memory.h" #include "mgmtd/mgmt_memory.h"
#include "mgmtd/mgmt_txn.h" #include "mgmtd/mgmt_txn.h"
#ifdef REDIRECT_DEBUG_TO_STDERR
#define MGMTD_TXN_DBG(fmt, ...) \
fprintf(stderr, "%s: " fmt "\n", __func__, ##__VA_ARGS__)
#define MGMTD_TXN_ERR(fmt, ...) \
fprintf(stderr, "%s: ERROR, " fmt "\n", __func__, ##__VA_ARGS__)
#else /* REDIRECT_DEBUG_TO_STDERR */
#define MGMTD_TXN_DBG(fmt, ...) \ #define MGMTD_TXN_DBG(fmt, ...) \
do { \ DEBUGD(&mgmt_debug_txn, "%s:" fmt, __func__, ##__VA_ARGS__)
if (mgmt_debug_txn) \ #define MGMTD_TXN_ERR(fmt, ...) \
zlog_debug("%s: " fmt, __func__, ##__VA_ARGS__); \
} while (0)
#define MGMTD_TXN_ERR(fmt, ...) \
zlog_err("%s: ERROR: " fmt, __func__, ##__VA_ARGS__) zlog_err("%s: ERROR: " fmt, __func__, ##__VA_ARGS__)
#endif /* REDIRECT_DEBUG_TO_STDERR */
#define MGMTD_TXN_LOCK(txn) mgmt_txn_lock(txn, __FILE__, __LINE__) #define MGMTD_TXN_LOCK(txn) mgmt_txn_lock(txn, __FILE__, __LINE__)
#define MGMTD_TXN_UNLOCK(txn) mgmt_txn_unlock(txn, __FILE__, __LINE__) #define MGMTD_TXN_UNLOCK(txn) mgmt_txn_unlock(txn, __FILE__, __LINE__)

55
mgmtd/mgmt_vty.c
View file

@ -380,7 +380,7 @@ DEFPY(mgmt_rollback,
return CMD_SUCCESS; return CMD_SUCCESS;
} }
static int config_write_mgmt_debug(struct vty *vty); int config_write_mgmt_debug(struct vty *vty);
static struct cmd_node debug_node = { static struct cmd_node debug_node = {
.name = "debug", .name = "debug",
.node = DEBUG_NODE, .node = DEBUG_NODE,
@ -388,27 +388,25 @@ static struct cmd_node debug_node = {
.config_write = config_write_mgmt_debug, .config_write = config_write_mgmt_debug,
}; };
static int config_write_mgmt_debug_helper(struct vty *vty, bool config) static int write_mgmt_debug_helper(struct vty *vty, bool config)
{ {
int n = mgmt_debug_be + mgmt_debug_fe + mgmt_debug_ds + mgmt_debug_txn; uint32_t mode = config ? DEBUG_MODE_CONF : DEBUG_MODE_ALL;
bool be = DEBUG_MODE_CHECK(&mgmt_debug_be, mode);
bool ds = DEBUG_MODE_CHECK(&mgmt_debug_ds, mode);
bool fe = DEBUG_MODE_CHECK(&mgmt_debug_fe, mode);
bool txn = DEBUG_MODE_CHECK(&mgmt_debug_txn, mode);
if (!n) if (!(be || ds || fe || txn))
return 0; return 0;
if (config && mgmt_debug_be && mgmt_debug_fe && mgmt_debug_ds &&
mgmt_debug_txn) {
vty_out(vty, "debug mgmt all\n");
return 0;
}
vty_out(vty, "debug mgmt"); vty_out(vty, "debug mgmt");
if (mgmt_debug_be) if (be)
vty_out(vty, " backend"); vty_out(vty, " backend");
if (mgmt_debug_ds) if (ds)
vty_out(vty, " datastore"); vty_out(vty, " datastore");
if (mgmt_debug_fe) if (fe)
vty_out(vty, " frontend"); vty_out(vty, " frontend");
if (mgmt_debug_txn) if (txn)
vty_out(vty, " transaction"); vty_out(vty, " transaction");
vty_out(vty, "\n"); vty_out(vty, "\n");
@ -416,17 +414,17 @@ static int config_write_mgmt_debug_helper(struct vty *vty, bool config)
return 0; return 0;
} }
static int config_write_mgmt_debug(struct vty *vty) int config_write_mgmt_debug(struct vty *vty)
{ {
return config_write_mgmt_debug_helper(vty, true); return write_mgmt_debug_helper(vty, true);
} }
DEFUN_NOSH(show_debugging_mgmt, show_debugging_mgmt_cmd, DEFPY_NOSH(show_debugging_mgmt, show_debugging_mgmt_cmd,
"show debugging [mgmt]", SHOW_STR DEBUG_STR "MGMT Information\n") "show debugging [mgmt]", SHOW_STR DEBUG_STR "MGMT Information\n")
{ {
vty_out(vty, "MGMT debugging status:\n"); vty_out(vty, "MGMT debugging status:\n");
config_write_mgmt_debug_helper(vty, false); write_mgmt_debug_helper(vty, false);
cmd_show_lib_debugs(vty); cmd_show_lib_debugs(vty);
@ -434,27 +432,23 @@ DEFUN_NOSH(show_debugging_mgmt, show_debugging_mgmt_cmd,
} }
DEFPY(debug_mgmt, debug_mgmt_cmd, DEFPY(debug_mgmt, debug_mgmt_cmd,
"[no$no] debug mgmt <all$all|{backend$be|datastore$ds|frontend$fe|transaction$txn}>", "[no$no] debug mgmt {backend$be|datastore$ds|frontend$fe|transaction$txn}",
NO_STR DEBUG_STR MGMTD_STR NO_STR DEBUG_STR MGMTD_STR
"All debug\n" "Backend debug\n"
"Back-end debug\n"
"Datastore debug\n" "Datastore debug\n"
"Front-end debug\n" "Frontend debug\n"
"Transaction debug\n") "Transaction debug\n")
{ {
bool set = !no; uint32_t mode = DEBUG_NODE2MODE(vty->node);
if (all)
be = fe = ds = txn = set ? all : NULL;
if (be) if (be)
mgmt_debug_be = set; DEBUG_MODE_SET(&mgmt_debug_be, mode, !no);
if (ds) if (ds)
mgmt_debug_ds = set; DEBUG_MODE_SET(&mgmt_debug_ds, mode, !no);
if (fe) if (fe)
mgmt_debug_fe = set; DEBUG_MODE_SET(&mgmt_debug_fe, mode, !no);
if (txn) if (txn)
mgmt_debug_txn = set; DEBUG_MODE_SET(&mgmt_debug_txn, mode, !no);
return CMD_SUCCESS; return CMD_SUCCESS;
} }
@ -530,6 +524,7 @@ void mgmt_vty_init(void)
install_element(ENABLE_NODE, &show_debugging_mgmt_cmd); install_element(ENABLE_NODE, &show_debugging_mgmt_cmd);
mgmt_fe_client_lib_vty_init();
/* /*
* TODO: Register and handlers for auto-completion here. * TODO: Register and handlers for auto-completion here.
*/ */

2
python/xref2vtysh.py
View file

@ -37,6 +37,8 @@ daemon_flags = {
"lib/filter_cli.c": "VTYSH_ACL", "lib/filter_cli.c": "VTYSH_ACL",
"lib/if.c": "VTYSH_INTERFACE", "lib/if.c": "VTYSH_INTERFACE",
"lib/keychain.c": "VTYSH_RIPD|VTYSH_EIGRPD|VTYSH_OSPF6D", "lib/keychain.c": "VTYSH_RIPD|VTYSH_EIGRPD|VTYSH_OSPF6D",
"lib/mgmt_be_client.c": "VTYSH_STATICD",
"lib/mgmt_fe_client.c": "VTYSH_MGMTD",
"lib/lib_vty.c": "VTYSH_ALL", "lib/lib_vty.c": "VTYSH_ALL",
"lib/log_vty.c": "VTYSH_ALL", "lib/log_vty.c": "VTYSH_ALL",
"lib/nexthop_group.c": "VTYSH_NH_GROUP", "lib/nexthop_group.c": "VTYSH_NH_GROUP",

3
staticd/static_vty.c
View file

@ -13,6 +13,7 @@
#include "nexthop.h" #include "nexthop.h"
#include "table.h" #include "table.h"
#include "srcdest_table.h" #include "srcdest_table.h"
#include "mgmt_be_client.h"
#include "mpls.h" #include "mpls.h"
#include "northbound.h" #include "northbound.h"
#include "libfrr.h" #include "libfrr.h"
@ -1553,4 +1554,6 @@ void static_vty_init(void)
install_element(ENABLE_NODE, &debug_staticd_cmd); install_element(ENABLE_NODE, &debug_staticd_cmd);
install_element(CONFIG_NODE, &debug_staticd_cmd); install_element(CONFIG_NODE, &debug_staticd_cmd);
mgmt_be_client_lib_vty_init();
} }