proxmox-mirrors/mirror_frr
1
0
Fork 0
mirror of https://git.proxmox.com/git/mirror_frr synced 2025-04-29 02:37:00 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #11992 from pguibert6WIND/pathd_debug

Browse Source 
Pathd debug
This commit is contained in:
Russ White 2022-11-16 21:41:33 -05:00 committed by GitHub
commit 54b3d90a4b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 188 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
doc/user/pathd.rst
View File

@ -175,7 +175,7 @@ controller and obtain those by means of the PCEP protocol.
.. image:: images/pathd_initiated_multi.png
Starting
=============
========
Default configuration file for *pathd* is :file:`pathd.conf`. The typical
location of :file:`pathd.conf` is |INSTALL_PREFIX_ETC|/pathd.conf.
@ -480,6 +480,12 @@ Configuration Commands
Specify a peer and its precedence in a PCC definition.
Debugging
---------
.. clicmd:: debug pathd policy
Enable or disable Pathd policy information.
Introspection Commands
----------------------

2
lib/ipaddr.h
View File

@ -61,6 +61,8 @@ struct ipaddr {
#define IPADDRSZ(p) \
(IS_IPADDR_V4((p)) ? sizeof(struct in_addr) : sizeof(struct in6_addr))
#define IPADDR_STRING_SIZE 46
static inline int ipaddr_family(const struct ipaddr *ip)
{
switch (ip->ipa_type) {

50
pathd/path_cli.c
View File

@ -126,7 +126,7 @@ DEFPY(show_srte_policy,
ttable_rowseps(tt, 0, BOTTOM, true, '-');
RB_FOREACH (policy, srte_policy_head, &srte_policies) {
char endpoint[46];
char endpoint[ENDPOINT_STR_LENGTH];
char binding_sid[16] = "-";
ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
@ -173,7 +173,7 @@ DEFPY(show_srte_policy_detail,
vty_out(vty, "\n");
RB_FOREACH (policy, srte_policy_head, &srte_policies) {
struct srte_candidate *candidate;
char endpoint[46];
char endpoint[ENDPOINT_STR_LENGTH];
char binding_sid[16] = "-";
char *segment_list_info;
static char undefined_info[] = "(undefined)";
@ -1091,8 +1091,25 @@ DEFPY_NOSH(show_debugging_pathd, show_debugging_pathd_cmd,
"pathd module debugging\n")
{
vty_out(vty, "Path debugging status:\n");
cmd_show_lib_debugs(vty);
/* nothing to do here */
path_ted_show_debugging(vty);
path_policy_show_debugging(vty);
return CMD_SUCCESS;
}
DEFPY(debug_path_policy, debug_path_policy_cmd, "[no] debug pathd policy",
NO_STR DEBUG_STR
"path debugging\n"
"policy debugging\n")
{
uint32_t mode = DEBUG_NODE2MODE(vty->node);
bool no_debug = no;
DEBUG_MODE_SET(&path_policy_debug, mode, !no);
DEBUG_FLAGS_SET(&path_policy_debug, PATH_POLICY_DEBUG_BASIC, !no_debug);
return CMD_SUCCESS;
}
@ -1291,8 +1308,34 @@ int config_write_segment_routing(struct vty *vty)
return 1;
}
static int path_policy_cli_debug_config_write(struct vty *vty)
{
if (DEBUG_MODE_CHECK(&path_policy_debug, DEBUG_MODE_CONF)) {
if (DEBUG_FLAGS_CHECK(&path_policy_debug,
PATH_POLICY_DEBUG_BASIC))
vty_out(vty, "debug pathd policy\n");
return 1;
}
return 0;
}
static int path_policy_cli_debug_set_all(uint32_t flags, bool set)
{
DEBUG_FLAGS_SET(&path_policy_debug, flags, set);
/* If all modes have been turned off, don't preserve options. */
if (!DEBUG_MODE_CHECK(&path_policy_debug, DEBUG_MODE_ALL))
DEBUG_CLEAR(&path_policy_debug);
return 0;
}
void path_cli_init(void)
{
hook_register(nb_client_debug_config_write,
path_policy_cli_debug_config_write);
hook_register(nb_client_debug_set_all, path_policy_cli_debug_set_all);
install_node(&segment_routing_node);
install_node(&sr_traffic_eng_node);
install_node(&srte_segment_list_node);
@ -1308,6 +1351,9 @@ void path_cli_init(void)
install_element(ENABLE_NODE, &show_srte_policy_cmd);
install_element(ENABLE_NODE, &show_srte_policy_detail_cmd);
install_element(ENABLE_NODE, &debug_path_policy_cmd);
install_element(CONFIG_NODE, &debug_path_policy_cmd);
install_element(CONFIG_NODE, &segment_routing_cmd);
install_element(SEGMENT_ROUTING_NODE, &sr_traffic_eng_cmd);
install_element(SR_TRAFFIC_ENG_NODE, &srte_segment_list_cmd);

6
pathd/path_ted.c
View File

@ -488,6 +488,12 @@ int path_ted_cli_debug_config_write(struct vty *vty)
return 0;
}
void path_ted_show_debugging(struct vty *vty)
{
if (DEBUG_FLAGS_CHECK(&ted_state_g.dbg, PATH_TED_DEBUG_BASIC))
vty_out(vty, " Path TED debugging is on\n");
}
int path_ted_cli_debug_set_all(uint32_t flags, bool set)
{
DEBUG_FLAGS_SET(&ted_state_g.dbg, flags, set);

1
pathd/path_ted.h
View File

@ -101,6 +101,7 @@ int path_ted_segment_list_refresh(void);
/* TED configuration functions */
uint32_t path_ted_config_write(struct vty *vty);
void path_ted_show_debugging(struct vty *vty);
/* TED util functions */
/* clang-format off */

180
pathd/pathd.c
View File

@ -23,6 +23,8 @@
#include "lib_errors.h"
#include "network.h"
#include "libfrr.h"
#include <debug.h>
#include <hook.h>
#include "pathd/pathd.h"
#include "pathd/path_zebra.h"
@ -44,6 +46,17 @@ DEFINE_HOOK(pathd_candidate_updated, (struct srte_candidate * candidate),
DEFINE_HOOK(pathd_candidate_removed, (struct srte_candidate * candidate),
(candidate));
struct debug path_policy_debug;
#define PATH_POLICY_DEBUG(fmt, ...) \
do { \
if (DEBUG_FLAGS_CHECK(&path_policy_debug, \
PATH_POLICY_DEBUG_BASIC)) \
DEBUGD(&path_policy_debug, "policy: " fmt, \
##__VA_ARGS__); \
} while (0)
static void trigger_pathd_candidate_created(struct srte_candidate *candidate);
static void trigger_pathd_candidate_created_timer(struct thread *thread);
static void trigger_pathd_candidate_updated(struct srte_candidate *candidate);
@ -97,6 +110,20 @@ RB_GENERATE(srte_policy_head, srte_policy, entry, srte_policy_compare)
struct srte_policy_head srte_policies = RB_INITIALIZER(&srte_policies);
static void srte_policy_status_log(struct srte_policy *policy)
{
char endpoint[ENDPOINT_STR_LENGTH];
ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
if (policy->status == SRTE_POLICY_STATUS_DOWN) {
PATH_POLICY_DEBUG("SR-TE(%s, %u): policy is DOWN", endpoint,
policy->color);
} else if (policy->status == SRTE_POLICY_STATUS_UP) {
PATH_POLICY_DEBUG("SR-TE(%s, %u): policy is UP", endpoint,
policy->color);
}
}
/**
* Adds a segment list to pathd.
*
@ -531,6 +558,10 @@ void srte_apply_changes(void)
RB_FOREACH_SAFE (policy, srte_policy_head, &srte_policies, safe_pol) {
if (CHECK_FLAG(policy->flags, F_POLICY_DELETED)) {
if (policy->status != SRTE_POLICY_STATUS_DOWN) {
policy->status = SRTE_POLICY_STATUS_DOWN;
srte_policy_status_log(policy);
}
srte_policy_del(policy);
continue;
}
@ -565,7 +596,7 @@ void srte_policy_apply_changes(struct srte_policy *policy)
struct srte_candidate *candidate, *safe;
struct srte_candidate *old_best_candidate;
struct srte_candidate *new_best_candidate;
char endpoint[46];
char endpoint[ENDPOINT_STR_LENGTH];
ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
@ -574,8 +605,7 @@ void srte_policy_apply_changes(struct srte_policy *policy)
new_best_candidate = srte_policy_best_candidate(policy);
if (new_best_candidate != old_best_candidate) {
/* TODO: add debug guard. */
zlog_debug(
PATH_POLICY_DEBUG(
"SR-TE(%s, %u): best candidate changed from %s to %s",
endpoint, policy->color,
old_best_candidate ? old_best_candidate->name : "none",
@ -617,10 +647,10 @@ void srte_policy_apply_changes(struct srte_policy *policy)
F_SEGMENT_LIST_MODIFIED);
if (candidate_changed || segment_list_changed) {
/* TODO: add debug guard. */
zlog_debug("SR-TE(%s, %u): best candidate %s changed",
endpoint, policy->color,
new_best_candidate->name);
PATH_POLICY_DEBUG(
"SR-TE(%s, %u): best candidate %s changed",
endpoint, policy->color,
new_best_candidate->name);
path_zebra_add_sr_policy(
policy, new_best_candidate->lsp->segment_list);
@ -722,10 +752,10 @@ void srte_candidate_set_bandwidth(struct srte_candidate *candidate,
float bandwidth, bool required)
{
struct srte_policy *policy = candidate->policy;
char endpoint[46];
char endpoint[ENDPOINT_STR_LENGTH];
ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
zlog_debug(
PATH_POLICY_DEBUG(
"SR-TE(%s, %u): candidate %s %sconfig bandwidth set to %f B/s",
endpoint, policy->color, candidate->name,
required ? "required " : "", bandwidth);
@ -750,11 +780,13 @@ void srte_lsp_set_bandwidth(struct srte_lsp *lsp, float bandwidth,
{
struct srte_candidate *candidate = lsp->candidate;
struct srte_policy *policy = candidate->policy;
char endpoint[46];
char endpoint[ENDPOINT_STR_LENGTH];
ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
zlog_debug("SR-TE(%s, %u): candidate %s %slsp bandwidth set to %f B/s",
endpoint, policy->color, candidate->name,
required ? "required" : "", bandwidth);
PATH_POLICY_DEBUG(
"SR-TE(%s, %u): candidate %s %slsp bandwidth set to %f B/s",
endpoint, policy->color, candidate->name,
required ? "required" : "", bandwidth);
SET_FLAG(lsp->flags, F_CANDIDATE_HAS_BANDWIDTH);
COND_FLAG(lsp->flags, F_CANDIDATE_REQUIRED_BANDWIDTH, required);
lsp->bandwidth = bandwidth;
@ -770,10 +802,11 @@ void srte_lsp_set_bandwidth(struct srte_lsp *lsp, float bandwidth,
void srte_candidate_unset_bandwidth(struct srte_candidate *candidate)
{
struct srte_policy *policy = candidate->policy;
char endpoint[46];
char endpoint[ENDPOINT_STR_LENGTH];
ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
zlog_debug("SR-TE(%s, %u): candidate %s config bandwidth unset",
endpoint, policy->color, candidate->name);
PATH_POLICY_DEBUG("SR-TE(%s, %u): candidate %s config bandwidth unset",
endpoint, policy->color, candidate->name);
UNSET_FLAG(candidate->flags, F_CANDIDATE_HAS_BANDWIDTH);
UNSET_FLAG(candidate->flags, F_CANDIDATE_REQUIRED_BANDWIDTH);
candidate->bandwidth = 0;
@ -792,10 +825,11 @@ void srte_lsp_unset_bandwidth(struct srte_lsp *lsp)
{
struct srte_candidate *candidate = lsp->candidate;
struct srte_policy *policy = candidate->policy;
char endpoint[46];
char endpoint[ENDPOINT_STR_LENGTH];
ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
zlog_debug("SR-TE(%s, %u): candidate %s lsp bandwidth unset", endpoint,
policy->color, candidate->name);
PATH_POLICY_DEBUG("SR-TE(%s, %u): candidate %s lsp bandwidth unset",
endpoint, policy->color, candidate->name);
UNSET_FLAG(lsp->flags, F_CANDIDATE_HAS_BANDWIDTH);
UNSET_FLAG(lsp->flags, F_CANDIDATE_REQUIRED_BANDWIDTH);
SET_FLAG(candidate->flags, F_CANDIDATE_MODIFIED);
@ -820,9 +854,10 @@ void srte_candidate_set_metric(struct srte_candidate *candidate,
bool is_computed)
{
struct srte_policy *policy = candidate->policy;
char endpoint[46];
char endpoint[ENDPOINT_STR_LENGTH];
ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
zlog_debug(
PATH_POLICY_DEBUG(
"SR-TE(%s, %u): candidate %s %sconfig metric %s (%u) set to %f (is-bound: %s; is_computed: %s)",
endpoint, policy->color, candidate->name,
required ? "required " : "", srte_candidate_metric_name(type),
@ -854,9 +889,10 @@ void srte_lsp_set_metric(struct srte_lsp *lsp,
{
struct srte_candidate *candidate = lsp->candidate;
struct srte_policy *policy = candidate->policy;
char endpoint[46];
char endpoint[ENDPOINT_STR_LENGTH];
ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
zlog_debug(
PATH_POLICY_DEBUG(
"SR-TE(%s, %u): candidate %s %slsp metric %s (%u) set to %f (is-bound: %s; is_computed: %s)",
endpoint, policy->color, candidate->name,
required ? "required " : "", srte_candidate_metric_name(type),
@ -889,11 +925,13 @@ void srte_candidate_unset_metric(struct srte_candidate *candidate,
enum srte_candidate_metric_type type)
{
struct srte_policy *policy = candidate->policy;
char endpoint[46];
char endpoint[ENDPOINT_STR_LENGTH];
ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
zlog_debug("SR-TE(%s, %u): candidate %s config metric %s (%u) unset",
endpoint, policy->color, candidate->name,
srte_candidate_metric_name(type), type);
PATH_POLICY_DEBUG(
"SR-TE(%s, %u): candidate %s config metric %s (%u) unset",
endpoint, policy->color, candidate->name,
srte_candidate_metric_name(type), type);
assert((type > 0) && (type <= MAX_METRIC_TYPE));
srte_unset_metric(&candidate->metrics[type - 1]);
srte_lsp_unset_metric(candidate->lsp, type);
@ -913,11 +951,13 @@ void srte_lsp_unset_metric(struct srte_lsp *lsp,
{
struct srte_candidate *candidate = lsp->candidate;
struct srte_policy *policy = candidate->policy;
char endpoint[46];
char endpoint[ENDPOINT_STR_LENGTH];
ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
zlog_debug("SR-TE(%s, %u): candidate %s lsp metric %s (%u) unset",
endpoint, policy->color, candidate->name,
srte_candidate_metric_name(type), type);
PATH_POLICY_DEBUG(
"SR-TE(%s, %u): candidate %s lsp metric %s (%u) unset",
endpoint, policy->color, candidate->name,
srte_candidate_metric_name(type), type);
assert((type > 0) && (type <= MAX_METRIC_TYPE));
srte_unset_metric(&lsp->metrics[type - 1]);
}
@ -941,16 +981,18 @@ void srte_candidate_set_objfun(struct srte_candidate *candidate, bool required,
enum objfun_type type)
{
struct srte_policy *policy = candidate->policy;
char endpoint[46];
char endpoint[ENDPOINT_STR_LENGTH];
ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
candidate->objfun = type;
SET_FLAG(candidate->flags, F_CANDIDATE_HAS_OBJFUN);
COND_FLAG(candidate->flags, F_CANDIDATE_REQUIRED_OBJFUN, required);
SET_FLAG(candidate->flags, F_CANDIDATE_MODIFIED);
zlog_debug("SR-TE(%s, %u): candidate %s %sobjective function set to %s",
endpoint, policy->color, candidate->name,
required ? "required " : "", objfun_type_name(type));
PATH_POLICY_DEBUG(
"SR-TE(%s, %u): candidate %s %sobjective function set to %s",
endpoint, policy->color, candidate->name,
required ? "required " : "", objfun_type_name(type));
}
/**
@ -961,14 +1003,15 @@ void srte_candidate_set_objfun(struct srte_candidate *candidate, bool required,
void srte_candidate_unset_objfun(struct srte_candidate *candidate)
{
struct srte_policy *policy = candidate->policy;
char endpoint[46];
char endpoint[ENDPOINT_STR_LENGTH];
ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
UNSET_FLAG(candidate->flags, F_CANDIDATE_HAS_OBJFUN);
UNSET_FLAG(candidate->flags, F_CANDIDATE_REQUIRED_OBJFUN);
SET_FLAG(candidate->flags, F_CANDIDATE_MODIFIED);
candidate->objfun = OBJFUN_UNDEFINED;
zlog_debug(
PATH_POLICY_DEBUG(
"SR-TE(%s, %u): candidate %s objective functions preferences unset",
endpoint, policy->color, candidate->name);
}
@ -1013,7 +1056,8 @@ void srte_candidate_set_affinity_filter(struct srte_candidate *candidate,
uint32_t filter)
{
struct srte_policy *policy = candidate->policy;
char endpoint[46];
char endpoint[ENDPOINT_STR_LENGTH];
ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
assert(type > AFFINITY_FILTER_UNDEFINED);
@ -1021,7 +1065,7 @@ void srte_candidate_set_affinity_filter(struct srte_candidate *candidate,
SET_FLAG(candidate->flags, filter_type_to_flag(type));
SET_FLAG(candidate->flags, F_CANDIDATE_MODIFIED);
candidate->affinity_filters[type - 1] = filter;
zlog_debug(
PATH_POLICY_DEBUG(
"SR-TE(%s, %u): candidate %s affinity filter %s set to 0x%08x",
endpoint, policy->color, candidate->name,
filter_type_name(type), filter);
@ -1038,7 +1082,8 @@ void srte_candidate_unset_affinity_filter(struct srte_candidate *candidate,
enum affinity_filter_type type)
{
struct srte_policy *policy = candidate->policy;
char endpoint[46];
char endpoint[ENDPOINT_STR_LENGTH];
ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
assert(type > AFFINITY_FILTER_UNDEFINED);
@ -1046,9 +1091,10 @@ void srte_candidate_unset_affinity_filter(struct srte_candidate *candidate,
UNSET_FLAG(candidate->flags, filter_type_to_flag(type));
SET_FLAG(candidate->flags, F_CANDIDATE_MODIFIED);
candidate->affinity_filters[type - 1] = 0;
zlog_debug("SR-TE(%s, %u): candidate %s affinity filter %s unset",
endpoint, policy->color, candidate->name,
filter_type_name(type));
PATH_POLICY_DEBUG(
"SR-TE(%s, %u): candidate %s affinity filter %s unset",
endpoint, policy->color, candidate->name,
filter_type_name(type));
}
/**
@ -1093,10 +1139,11 @@ srte_segment_entry_find(struct srte_segment_list *segment_list, uint32_t index)
void srte_candidate_status_update(struct srte_candidate *candidate, int status)
{
struct srte_policy *policy = candidate->policy;
char endpoint[46];
char endpoint[ENDPOINT_STR_LENGTH];
ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
zlog_debug("SR-TE(%s, %u): zebra updated status to %d", endpoint,
policy->color, status);
PATH_POLICY_DEBUG("SR-TE(%s, %u): zebra updated status to %d", endpoint,
policy->color, status);
switch (status) {
case ZEBRA_SR_POLICY_DOWN:
switch (policy->status) {
@ -1109,9 +1156,8 @@ void srte_candidate_status_update(struct srte_candidate *candidate, int status)
case SRTE_POLICY_STATUS_DOWN:
return;
default:
zlog_debug("SR-TE(%s, %u): policy is DOWN", endpoint,
policy->color);
policy->status = SRTE_POLICY_STATUS_DOWN;
srte_policy_status_log(policy);
break;
}
break;
@ -1120,9 +1166,8 @@ void srte_candidate_status_update(struct srte_candidate *candidate, int status)
case SRTE_POLICY_STATUS_UP:
return;
default:
zlog_debug("SR-TE(%s, %u): policy is UP", endpoint,
policy->color);
policy->status = SRTE_POLICY_STATUS_UP;
srte_policy_status_log(policy);
break;
}
break;
@ -1148,19 +1193,20 @@ void srte_candidate_unset_segment_list(const char *originator, bool force)
return;
}
zlog_debug("Unset segment lists for originator %s", originator);
PATH_POLICY_DEBUG("Unset segment lists for originator %s", originator);
/* Iterate the policies, then iterate each policy's candidate path
* to check the candidate path's segment list originator */
struct srte_policy *policy;
RB_FOREACH (policy, srte_policy_head, &srte_policies) {
zlog_debug("Unset segment lists checking policy %s",
policy->name);
PATH_POLICY_DEBUG("Unset segment lists checking policy %s",
policy->name);
struct srte_candidate *candidate;
RB_FOREACH (candidate, srte_candidate_head,
&policy->candidate_paths) {
zlog_debug("Unset segment lists checking candidate %s",
candidate->name);
PATH_POLICY_DEBUG(
"Unset segment lists checking candidate %s",
candidate->name);
if (candidate->lsp == NULL) {
continue;
}
@ -1190,8 +1236,8 @@ void srte_candidate_unset_segment_list(const char *originator, bool force)
sizeof(segment_list->originator))
== 0
|| force) {
zlog_debug("Unset segment list %s",
segment_list->name);
PATH_POLICY_DEBUG("Unset segment list %s",
segment_list->name);
SET_FLAG(segment_list->flags,
F_SEGMENT_LIST_DELETED);
SET_FLAG(candidate->flags,
@ -1222,6 +1268,12 @@ const char *srte_origin2str(enum srte_protocol_origin origin)
}
}
void path_policy_show_debugging(struct vty *vty)
{
if (DEBUG_FLAGS_CHECK(&path_policy_debug, PATH_POLICY_DEBUG_BASIC))
vty_out(vty, " Path policy debugging is on\n");
}
void pathd_shutdown(void)
{
path_ted_teardown();
@ -1347,8 +1399,9 @@ int32_t srte_ted_do_query_type_c(struct srte_segment_entry *entry,
zlog_warn(" %s: PATHD-TED: SL: ERROR query C : ted-sid (%d)",
__func__, ted_sid);
} else {
zlog_debug("%s: PATHD-TED: SL: Success query C : ted-sid (%d)",
__func__, ted_sid);
PATH_TED_DEBUG(
"%s: PATHD-TED: SL: Success query C : ted-sid (%d)",
__func__, ted_sid);
}
if (CHECK_SID(entry->segment_list->protocol_origin, ted_sid,
entry->sid_value)) {
@ -1377,8 +1430,9 @@ int32_t srte_ted_do_query_type_e(struct srte_segment_entry *entry,
zlog_warn(" %s: PATHD-TED: SL: ERROR query E : ted-sid (%d)",
__func__, ted_sid);
} else {
zlog_debug("%s: PATHD-TED: SL: Success query E : ted-sid (%d)",
__func__, ted_sid);
PATH_TED_DEBUG(
"%s: PATHD-TED: SL: Success query E : ted-sid (%d)",
__func__, ted_sid);
}
if (CHECK_SID(entry->segment_list->protocol_origin, ted_sid,
entry->sid_value)) {
@ -1406,8 +1460,8 @@ int32_t srte_ted_do_query_type_f(struct srte_segment_entry *entry,
zlog_warn("%s:SL: ERROR query F : ted-sid (%d)", __func__,
ted_sid);
} else {
zlog_debug("%s:SL: Success query F : ted-sid (%d)", __func__,
ted_sid);
PATH_TED_DEBUG("%s:SL: Success query F : ted-sid (%d)",
__func__, ted_sid);
}
if (CHECK_SID(entry->segment_list->protocol_origin, ted_sid,
entry->sid_value)) {

7
pathd/pathd.h
View File

@ -43,6 +43,10 @@ enum srte_protocol_origin {
SRTE_ORIGIN_LOCAL = 3,
};
extern struct debug path_policy_debug;
#define PATH_POLICY_DEBUG_BASIC 0x01
enum srte_policy_status {
SRTE_POLICY_STATUS_UNKNOWN = 0,
SRTE_POLICY_STATUS_DOWN = 1,
@ -326,6 +330,8 @@ struct srte_candidate {
RB_HEAD(srte_candidate_head, srte_candidate);
RB_PROTOTYPE(srte_candidate_head, srte_candidate, entry, srte_candidate_compare)
#define ENDPOINT_STR_LENGTH IPADDR_STRING_SIZE
struct srte_policy {
RB_ENTRY(srte_policy) entry;
@ -444,6 +450,7 @@ void srte_candidate_status_update(struct srte_candidate *candidate, int status);
void srte_candidate_unset_segment_list(const char *originator, bool force);
const char *srte_origin2str(enum srte_protocol_origin origin);
void pathd_shutdown(void);
void path_policy_show_debugging(struct vty *vty);
/* path_cli.c */
void path_cli_init(void);