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

zebra: convert interface link-params bandwidth commands to NB

Browse Source 
Signed-off-by: Igor Ryzhov <iryzhov@nfware.com>
This commit is contained in:
Igor Ryzhov 2024-01-20 00:13:14 +02:00
parent e633296443
commit 93744dbe88
7 changed files with 546 additions and 199 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
lib/yang_wrappers.c
View File

@ -1046,6 +1046,17 @@ struct yang_data *yang_data_new_date_and_time(const char *xpath, time_t time)
return yang_data_new(xpath, timebuf);
}
float yang_dnode_get_bandwidth_ieee_float32(const struct lyd_node *dnode,
const char *xpath_fmt, ...)
{
const char *canon = YANG_DNODE_XPATH_GET_CANON(dnode, xpath_fmt);
float value;
assert(sscanf(canon, "%a", &value) == 1);
return value;
}
const char *yang_nexthop_type2str(uint32_t ntype)
{
switch (ntype) {

5
lib/yang_wrappers.h
View File

@ -200,6 +200,11 @@ extern void yang_str2mac(const char *value, struct ethaddr *mac);
extern struct yang_data *yang_data_new_date_and_time(const char *xpath,
time_t time);
/* rt-types:bandwidth-ieee-float32 */
extern float yang_dnode_get_bandwidth_ieee_float32(const struct lyd_node *dnode,
const char *xpath_fmt, ...)
PRINTFRR(2, 3);
/* nexthop enum2str */
extern const char *yang_nexthop_type2str(uint32_t ntype);

48
yang/frr-zebra.yang
View File

@ -2055,6 +2055,54 @@ module frr-zebra {
description
"Link metric for MPLS-TE purpose.";
}
leaf max-bandwidth {
type rt-types:bandwidth-ieee-float32;
description
"Maximum bandwidth.";
}
leaf max-reservable-bandwidth {
type rt-types:bandwidth-ieee-float32;
description
"Maximum reservable bandwidth.";
}
container unreserved-bandwidths {
description
"All unreserved bandwidths.";
list unreserved-bandwidth {
key "priority";
leaf priority {
type uint8 {
range "0 .. 7";
}
description
"Priority from 0 to 7.";
}
leaf unreserved-bandwidth {
type rt-types:bandwidth-ieee-float32;
mandatory true;
description
"Unreserved bandwidth.";
}
description
"List of unreserved bandwidths for different
priorities.";
}
}
leaf residual-bandwidth {
type rt-types:bandwidth-ieee-float32;
description
"Unidirectional residual bandwidth.";
}
leaf available-bandwidth {
type rt-types:bandwidth-ieee-float32;
description
"Unidirectional available bandwidth.";
}
leaf utilized-bandwidth {
type rt-types:bandwidth-ieee-float32;
description
"Unidirectional utilized bandwidth.";
}
choice admin-group-mode {
description "Admin-group mode";
case legacy {

270
zebra/interface.c
View File

@ -4021,125 +4021,73 @@ DEFPY_YANG (link_params_metric,
return nb_cli_apply_changes(vty, NULL);
}
DEFUN (link_params_maxbw,
DEFPY_YANG (link_params_maxbw,
link_params_maxbw_cmd,
"max-bw BANDWIDTH",
"Maximum bandwidth that can be used\n"
"Bytes/second (IEEE floating point format)\n")
{
int idx_bandwidth = 1;
VTY_DECLVAR_CONTEXT(interface, ifp);
struct if_link_params *iflp = if_link_params_get(ifp);
char value[YANG_VALUE_MAXLEN];
float bw;
if (sscanf(argv[idx_bandwidth]->arg, "%g", &bw) != 1) {
vty_out(vty, "link_params_maxbw: fscanf: %s\n",
safe_strerror(errno));
if (sscanf(bandwidth, "%g", &bw) != 1) {
vty_out(vty, "Invalid bandwidth value\n");
return CMD_WARNING_CONFIG_FAILED;
}
/* Check that Maximum bandwidth is not lower than other bandwidth
* parameters */
if (iflp && ((bw <= iflp->max_rsv_bw) || (bw <= iflp->unrsv_bw[0]) ||
(bw <= iflp->unrsv_bw[1]) || (bw <= iflp->unrsv_bw[2]) ||
(bw <= iflp->unrsv_bw[3]) || (bw <= iflp->unrsv_bw[4]) ||
(bw <= iflp->unrsv_bw[5]) || (bw <= iflp->unrsv_bw[6]) ||
(bw <= iflp->unrsv_bw[7]) || (bw <= iflp->ava_bw) ||
(bw <= iflp->res_bw) || (bw <= iflp->use_bw))) {
vty_out(vty,
"Maximum Bandwidth could not be lower than others bandwidth\n");
return CMD_WARNING_CONFIG_FAILED;
snprintf(value, sizeof(value), "%a", bw);
nb_cli_enqueue_change(vty, "./max-bandwidth", NB_OP_MODIFY, value);
return nb_cli_apply_changes(vty, NULL);
}
if (!iflp)
iflp = if_link_params_enable(ifp);
/* Update Maximum Bandwidth if needed */
link_param_cmd_set_float(ifp, &iflp->max_bw, LP_MAX_BW, bw);
return CMD_SUCCESS;
}
DEFUN (link_params_max_rsv_bw,
DEFPY_YANG (link_params_max_rsv_bw,
link_params_max_rsv_bw_cmd,
"max-rsv-bw BANDWIDTH",
"Maximum bandwidth that may be reserved\n"
"Bytes/second (IEEE floating point format)\n")
{
int idx_bandwidth = 1;
VTY_DECLVAR_CONTEXT(interface, ifp);
struct if_link_params *iflp = if_link_params_get(ifp);
char value[YANG_VALUE_MAXLEN];
float bw;
if (sscanf(argv[idx_bandwidth]->arg, "%g", &bw) != 1) {
vty_out(vty, "link_params_max_rsv_bw: fscanf: %s\n",
safe_strerror(errno));
if (sscanf(bandwidth, "%g", &bw) != 1) {
vty_out(vty, "Invalid bandwidth value\n");
return CMD_WARNING_CONFIG_FAILED;
}
/* Check that bandwidth is not greater than maximum bandwidth parameter
*/
if (iflp && bw > iflp->max_bw) {
vty_out(vty,
"Maximum Reservable Bandwidth could not be greater than Maximum Bandwidth (%g)\n",
iflp->max_bw);
return CMD_WARNING_CONFIG_FAILED;
snprintf(value, sizeof(value), "%a", bw);
nb_cli_enqueue_change(vty, "./max-reservable-bandwidth", NB_OP_MODIFY,
value);
return nb_cli_apply_changes(vty, NULL);
}
if (!iflp)
iflp = if_link_params_enable(ifp);
/* Update Maximum Reservable Bandwidth if needed */
link_param_cmd_set_float(ifp, &iflp->max_rsv_bw, LP_MAX_RSV_BW, bw);
return CMD_SUCCESS;
}
DEFUN (link_params_unrsv_bw,
DEFPY_YANG (link_params_unrsv_bw,
link_params_unrsv_bw_cmd,
"unrsv-bw (0-7) BANDWIDTH",
"unrsv-bw (0-7)$priority BANDWIDTH",
"Unreserved bandwidth at each priority level\n"
"Priority\n"
"Bytes/second (IEEE floating point format)\n")
{
int idx_number = 1;
int idx_bandwidth = 2;
VTY_DECLVAR_CONTEXT(interface, ifp);
struct if_link_params *iflp = if_link_params_get(ifp);
int priority;
char xpath[XPATH_MAXLEN];
char value[YANG_VALUE_MAXLEN];
float bw;
/* We don't have to consider about range check here. */
if (sscanf(argv[idx_number]->arg, "%d", &priority) != 1) {
vty_out(vty, "link_params_unrsv_bw: fscanf: %s\n",
safe_strerror(errno));
if (sscanf(bandwidth, "%g", &bw) != 1) {
vty_out(vty, "Invalid bandwidth value\n");
return CMD_WARNING_CONFIG_FAILED;
}
if (sscanf(argv[idx_bandwidth]->arg, "%g", &bw) != 1) {
vty_out(vty, "link_params_unrsv_bw: fscanf: %s\n",
safe_strerror(errno));
return CMD_WARNING_CONFIG_FAILED;
}
snprintf(xpath, sizeof(xpath),
"./unreserved-bandwidths/unreserved-bandwidth[priority='%s']/unreserved-bandwidth",
priority_str);
snprintf(value, sizeof(value), "%a", bw);
/* Check that bandwidth is not greater than maximum bandwidth parameter
*/
if (iflp && bw > iflp->max_bw) {
vty_out(vty,
"UnReserved Bandwidth could not be greater than Maximum Bandwidth (%g)\n",
iflp->max_bw);
return CMD_WARNING_CONFIG_FAILED;
}
nb_cli_enqueue_change(vty, xpath, NB_OP_MODIFY, value);
if (!iflp)
iflp = if_link_params_enable(ifp);
/* Update Unreserved Bandwidth if needed */
link_param_cmd_set_float(ifp, &iflp->unrsv_bw[priority], LP_UNRSV_BW,
bw);
return CMD_SUCCESS;
return nb_cli_apply_changes(vty, NULL);
}
DEFPY_YANG(link_params_admin_grp, link_params_admin_grp_cmd,
@ -4449,151 +4397,88 @@ DEFUN (no_link_params_pkt_loss,
return CMD_SUCCESS;
}
DEFUN (link_params_res_bw,
DEFPY_YANG (link_params_res_bw,
link_params_res_bw_cmd,
"res-bw BANDWIDTH",
"[no] res-bw ![BANDWIDTH]",
NO_STR
"Unidirectional Residual Bandwidth\n"
"Bytes/second (IEEE floating point format)\n")
{
int idx_bandwidth = 1;
VTY_DECLVAR_CONTEXT(interface, ifp);
struct if_link_params *iflp = if_link_params_get(ifp);
char value[YANG_VALUE_MAXLEN];
float bw;
if (sscanf(argv[idx_bandwidth]->arg, "%g", &bw) != 1) {
vty_out(vty, "link_params_res_bw: fscanf: %s\n",
safe_strerror(errno));
if (!no) {
if (sscanf(bandwidth, "%g", &bw) != 1) {
vty_out(vty, "Invalid bandwidth value\n");
return CMD_WARNING_CONFIG_FAILED;
}
/* Check that bandwidth is not greater than maximum bandwidth parameter
*/
if (iflp && bw > iflp->max_bw) {
vty_out(vty,
"Residual Bandwidth could not be greater than Maximum Bandwidth (%g)\n",
iflp->max_bw);
return CMD_WARNING_CONFIG_FAILED;
snprintf(value, sizeof(value), "%a", bw);
nb_cli_enqueue_change(vty, "./residual-bandwidth", NB_OP_MODIFY,
value);
} else {
nb_cli_enqueue_change(vty, "./residual-bandwidth",
NB_OP_DESTROY, NULL);
}
if (!iflp)
iflp = if_link_params_enable(ifp);
/* Update Residual Bandwidth if needed */
link_param_cmd_set_float(ifp, &iflp->res_bw, LP_RES_BW, bw);
return CMD_SUCCESS;
return nb_cli_apply_changes(vty, NULL);
}
DEFUN (no_link_params_res_bw,
no_link_params_res_bw_cmd,
"no res-bw",
NO_STR
"Disable Unidirectional Residual Bandwidth on this interface\n")
{
VTY_DECLVAR_CONTEXT(interface, ifp);
/* Unset Residual Bandwidth */
link_param_cmd_unset(ifp, LP_RES_BW);
return CMD_SUCCESS;
}
DEFUN (link_params_ava_bw,
DEFPY_YANG (link_params_ava_bw,
link_params_ava_bw_cmd,
"ava-bw BANDWIDTH",
"[no] ava-bw ![BANDWIDTH]",
NO_STR
"Unidirectional Available Bandwidth\n"
"Bytes/second (IEEE floating point format)\n")
{
int idx_bandwidth = 1;
VTY_DECLVAR_CONTEXT(interface, ifp);
struct if_link_params *iflp = if_link_params_get(ifp);
char value[YANG_VALUE_MAXLEN];
float bw;
if (sscanf(argv[idx_bandwidth]->arg, "%g", &bw) != 1) {
vty_out(vty, "link_params_ava_bw: fscanf: %s\n",
safe_strerror(errno));
if (!no) {
if (sscanf(bandwidth, "%g", &bw) != 1) {
vty_out(vty, "Invalid bandwidth value\n");
return CMD_WARNING_CONFIG_FAILED;
}
/* Check that bandwidth is not greater than maximum bandwidth parameter
*/
if (iflp && bw > iflp->max_bw) {
vty_out(vty,
"Available Bandwidth could not be greater than Maximum Bandwidth (%g)\n",
iflp->max_bw);
return CMD_WARNING_CONFIG_FAILED;
snprintf(value, sizeof(value), "%a", bw);
nb_cli_enqueue_change(vty, "./available-bandwidth",
NB_OP_MODIFY, value);
} else {
nb_cli_enqueue_change(vty, "./available-bandwidth",
NB_OP_DESTROY, NULL);
}
if (!iflp)
iflp = if_link_params_enable(ifp);
/* Update Residual Bandwidth if needed */
link_param_cmd_set_float(ifp, &iflp->ava_bw, LP_AVA_BW, bw);
return CMD_SUCCESS;
return nb_cli_apply_changes(vty, NULL);
}
DEFUN (no_link_params_ava_bw,
no_link_params_ava_bw_cmd,
"no ava-bw",
NO_STR
"Disable Unidirectional Available Bandwidth on this interface\n")
{
VTY_DECLVAR_CONTEXT(interface, ifp);
/* Unset Available Bandwidth */
link_param_cmd_unset(ifp, LP_AVA_BW);
return CMD_SUCCESS;
}
DEFUN (link_params_use_bw,
DEFPY_YANG (link_params_use_bw,
link_params_use_bw_cmd,
"use-bw BANDWIDTH",
"[no] use-bw ![BANDWIDTH]",
NO_STR
"Unidirectional Utilised Bandwidth\n"
"Bytes/second (IEEE floating point format)\n")
{
int idx_bandwidth = 1;
VTY_DECLVAR_CONTEXT(interface, ifp);
struct if_link_params *iflp = if_link_params_get(ifp);
char value[YANG_VALUE_MAXLEN];
float bw;
if (sscanf(argv[idx_bandwidth]->arg, "%g", &bw) != 1) {
vty_out(vty, "link_params_use_bw: fscanf: %s\n",
safe_strerror(errno));
if (!no) {
if (sscanf(bandwidth, "%g", &bw) != 1) {
vty_out(vty, "Invalid bandwidth value\n");
return CMD_WARNING_CONFIG_FAILED;
}
/* Check that bandwidth is not greater than maximum bandwidth parameter
*/
if (iflp && bw > iflp->max_bw) {
vty_out(vty,
"Utilised Bandwidth could not be greater than Maximum Bandwidth (%g)\n",
iflp->max_bw);
return CMD_WARNING_CONFIG_FAILED;
snprintf(value, sizeof(value), "%a", bw);
nb_cli_enqueue_change(vty, "./utilized-bandwidth", NB_OP_MODIFY,
value);
} else {
nb_cli_enqueue_change(vty, "./utilized-bandwidth",
NB_OP_DESTROY, NULL);
}
if (!iflp)
iflp = if_link_params_enable(ifp);
/* Update Utilized Bandwidth if needed */
link_param_cmd_set_float(ifp, &iflp->use_bw, LP_USE_BW, bw);
return CMD_SUCCESS;
}
DEFUN (no_link_params_use_bw,
no_link_params_use_bw_cmd,
"no use-bw",
NO_STR
"Disable Unidirectional Utilised Bandwidth on this interface\n")
{
VTY_DECLVAR_CONTEXT(interface, ifp);
/* Unset Utilised Bandwidth */
link_param_cmd_unset(ifp, LP_USE_BW);
return CMD_SUCCESS;
return nb_cli_apply_changes(vty, NULL);
}
static int ag_change(struct vty *vty, int argc, struct cmd_token **argv,
@ -5167,11 +5052,8 @@ void zebra_if_init(void)
install_element(LINK_PARAMS_NODE, &link_params_pkt_loss_cmd);
install_element(LINK_PARAMS_NODE, &no_link_params_pkt_loss_cmd);
install_element(LINK_PARAMS_NODE, &link_params_ava_bw_cmd);
install_element(LINK_PARAMS_NODE, &no_link_params_ava_bw_cmd);
install_element(LINK_PARAMS_NODE, &link_params_res_bw_cmd);
install_element(LINK_PARAMS_NODE, &no_link_params_res_bw_cmd);
install_element(LINK_PARAMS_NODE, &link_params_use_bw_cmd);
install_element(LINK_PARAMS_NODE, &no_link_params_use_bw_cmd);
install_element(LINK_PARAMS_NODE, &link_params_affinity_cmd);
install_element(LINK_PARAMS_NODE, &link_params_affinity_mode_cmd);
install_element(LINK_PARAMS_NODE, &no_link_params_affinity_mode_cmd);

48
zebra/zebra_nb.c
View File

@ -372,6 +372,54 @@ const struct frr_yang_module_info frr_zebra_info = {
.destroy = lib_interface_zebra_link_params_metric_destroy,
}
},
{
.xpath = "/frr-interface:lib/interface/frr-zebra:zebra/link-params/max-bandwidth",
.cbs = {
.modify = lib_interface_zebra_link_params_max_bandwidth_modify,
.destroy = lib_interface_zebra_link_params_max_bandwidth_destroy,
}
},
{
.xpath = "/frr-interface:lib/interface/frr-zebra:zebra/link-params/max-reservable-bandwidth",
.cbs = {
.modify = lib_interface_zebra_link_params_max_reservable_bandwidth_modify,
.destroy = lib_interface_zebra_link_params_max_reservable_bandwidth_destroy,
}
},
{
.xpath = "/frr-interface:lib/interface/frr-zebra:zebra/link-params/unreserved-bandwidths/unreserved-bandwidth",
.cbs = {
.create = lib_interface_zebra_link_params_unreserved_bandwidths_unreserved_bandwidth_create,
.destroy = lib_interface_zebra_link_params_unreserved_bandwidths_unreserved_bandwidth_destroy,
}
},
{
.xpath = "/frr-interface:lib/interface/frr-zebra:zebra/link-params/unreserved-bandwidths/unreserved-bandwidth/unreserved-bandwidth",
.cbs = {
.modify = lib_interface_zebra_link_params_unreserved_bandwidths_unreserved_bandwidth_unreserved_bandwidth_modify,
}
},
{
.xpath = "/frr-interface:lib/interface/frr-zebra:zebra/link-params/residual-bandwidth",
.cbs = {
.modify = lib_interface_zebra_link_params_residual_bandwidth_modify,
.destroy = lib_interface_zebra_link_params_residual_bandwidth_destroy,
}
},
{
.xpath = "/frr-interface:lib/interface/frr-zebra:zebra/link-params/available-bandwidth",
.cbs = {
.modify = lib_interface_zebra_link_params_available_bandwidth_modify,
.destroy = lib_interface_zebra_link_params_available_bandwidth_destroy,
}
},
{
.xpath = "/frr-interface:lib/interface/frr-zebra:zebra/link-params/utilized-bandwidth",
.cbs = {
.modify = lib_interface_zebra_link_params_utilized_bandwidth_modify,
.destroy = lib_interface_zebra_link_params_utilized_bandwidth_destroy,
}
},
{
.xpath = "/frr-interface:lib/interface/frr-zebra:zebra/link-params/legacy-admin-group",
.cbs = {

26
zebra/zebra_nb.h
View File

@ -106,6 +106,32 @@ int lib_interface_zebra_link_params_destroy(struct nb_cb_destroy_args *args);
int lib_interface_zebra_link_params_metric_modify(struct nb_cb_modify_args *args);
int lib_interface_zebra_link_params_metric_destroy(
struct nb_cb_destroy_args *args);
int lib_interface_zebra_link_params_max_bandwidth_modify(
struct nb_cb_modify_args *args);
int lib_interface_zebra_link_params_max_bandwidth_destroy(
struct nb_cb_destroy_args *args);
int lib_interface_zebra_link_params_max_reservable_bandwidth_modify(
struct nb_cb_modify_args *args);
int lib_interface_zebra_link_params_max_reservable_bandwidth_destroy(
struct nb_cb_destroy_args *args);
int lib_interface_zebra_link_params_unreserved_bandwidths_unreserved_bandwidth_create(
struct nb_cb_create_args *args);
int lib_interface_zebra_link_params_unreserved_bandwidths_unreserved_bandwidth_destroy(
struct nb_cb_destroy_args *args);
int lib_interface_zebra_link_params_unreserved_bandwidths_unreserved_bandwidth_unreserved_bandwidth_modify(
struct nb_cb_modify_args *args);
int lib_interface_zebra_link_params_residual_bandwidth_modify(
struct nb_cb_modify_args *args);
int lib_interface_zebra_link_params_residual_bandwidth_destroy(
struct nb_cb_destroy_args *args);
int lib_interface_zebra_link_params_available_bandwidth_modify(
struct nb_cb_modify_args *args);
int lib_interface_zebra_link_params_available_bandwidth_destroy(
struct nb_cb_destroy_args *args);
int lib_interface_zebra_link_params_utilized_bandwidth_modify(
struct nb_cb_modify_args *args);
int lib_interface_zebra_link_params_utilized_bandwidth_destroy(
struct nb_cb_destroy_args *args);
int lib_interface_zebra_legacy_admin_group_modify(
struct nb_cb_modify_args *args);
int lib_interface_zebra_legacy_admin_group_destroy(

327
zebra/zebra_nb_config.c
View File

@ -1339,6 +1339,333 @@ int lib_interface_zebra_link_params_metric_destroy(struct nb_cb_destroy_args *ar
return NB_OK;
}
/*
* XPath: /frr-interface:lib/interface/frr-zebra:zebra/link-params/max-bandwidth
*/
int lib_interface_zebra_link_params_max_bandwidth_modify(
struct nb_cb_modify_args *args)
{
struct interface *ifp;
struct if_link_params *iflp;
float max_bw, res_bw, ava_bw, use_bw;
max_bw = yang_dnode_get_bandwidth_ieee_float32(args->dnode, NULL);
switch (args->event) {
case NB_EV_VALIDATE:
if (yang_dnode_exists(args->dnode, "../residual-bandwidth")) {
res_bw = yang_dnode_get_bandwidth_ieee_float32(
args->dnode, "../residual-bandwidth");
if (max_bw < res_bw) {
snprintfrr(args->errmsg, args->errmsg_len,
"max-bandwidth %f is less than residual-bandwidth %f",
max_bw, res_bw);
return NB_ERR_VALIDATION;
}
}
if (yang_dnode_exists(args->dnode, "../available-bandwidth")) {
ava_bw = yang_dnode_get_bandwidth_ieee_float32(
args->dnode, "../available-bandwidth");
if (max_bw < ava_bw) {
snprintfrr(args->errmsg, args->errmsg_len,
"max-bandwidth %f is less than available-bandwidth %f",
max_bw, ava_bw);
return NB_ERR_VALIDATION;
}
}
if (yang_dnode_exists(args->dnode, "../utilized-bandwidth")) {
use_bw = yang_dnode_get_bandwidth_ieee_float32(
args->dnode, "../utilized-bandwidth");
if (max_bw < use_bw) {
snprintfrr(args->errmsg, args->errmsg_len,
"max-bandwidth %f is less than utilized-bandwidth %f",
max_bw, use_bw);
return NB_ERR_VALIDATION;
}
}
break;
case NB_EV_PREPARE:
case NB_EV_ABORT:
break;
case NB_EV_APPLY:
ifp = nb_running_get_entry(args->dnode, NULL, true);
iflp = if_link_params_get(ifp);
link_param_cmd_set_float(ifp, &iflp->max_bw, LP_MAX_BW, max_bw);
break;
}
return NB_OK;
}
int lib_interface_zebra_link_params_max_bandwidth_destroy(
struct nb_cb_destroy_args *args)
{
if (args->event == NB_EV_VALIDATE) {
snprintfrr(args->errmsg, args->errmsg_len,
"Removing max-bandwidth is not allowed");
return NB_ERR_VALIDATION;
}
return NB_OK;
}
/*
* XPath: /frr-interface:lib/interface/frr-zebra:zebra/link-params/max-reservable-bandwidth
*/
int lib_interface_zebra_link_params_max_reservable_bandwidth_modify(
struct nb_cb_modify_args *args)
{
struct interface *ifp;
struct if_link_params *iflp;
float max_rsv_bw;
if (args->event != NB_EV_APPLY)
return NB_OK;
max_rsv_bw = yang_dnode_get_bandwidth_ieee_float32(args->dnode, NULL);
ifp = nb_running_get_entry(args->dnode, NULL, true);
iflp = if_link_params_get(ifp);
link_param_cmd_set_float(ifp, &iflp->max_rsv_bw, LP_MAX_RSV_BW,
max_rsv_bw);
return NB_OK;
}
int lib_interface_zebra_link_params_max_reservable_bandwidth_destroy(
struct nb_cb_destroy_args *args)
{
if (args->event == NB_EV_VALIDATE) {
snprintfrr(args->errmsg, args->errmsg_len,
"Removing max-reservable-bandwidth is not allowed");
return NB_ERR_VALIDATION;
}
return NB_OK;
}
/*
* XPath: /frr-interface:lib/interface/frr-zebra:zebra/link-params/unreserved-bandwidths/unreserved-bandwidth
*/
int lib_interface_zebra_link_params_unreserved_bandwidths_unreserved_bandwidth_create(
struct nb_cb_create_args *args)
{
struct interface *ifp;
struct if_link_params *iflp;
uint8_t priority;
float unrsv_bw;
if (args->event != NB_EV_APPLY)
return NB_OK;
priority = yang_dnode_get_uint8(args->dnode, "priority");
unrsv_bw = yang_dnode_get_bandwidth_ieee_float32(args->dnode,
"unreserved-bandwidth");
ifp = nb_running_get_entry(args->dnode, NULL, true);
iflp = if_link_params_get(ifp);
link_param_cmd_set_float(ifp, &iflp->unrsv_bw[priority], LP_UNRSV_BW,
unrsv_bw);
return NB_OK;
}
int lib_interface_zebra_link_params_unreserved_bandwidths_unreserved_bandwidth_destroy(
struct nb_cb_destroy_args *args)
{
if (args->event == NB_EV_VALIDATE) {
snprintfrr(args->errmsg, args->errmsg_len,
"Removing unreserved-bandwidth is not allowed");
return NB_ERR_VALIDATION;
}
return NB_OK;
}
/*
* XPath: /frr-interface:lib/interface/frr-zebra:zebra/link-params/unreserved-bandwidths/unreserved-bandwidth/unreserved-bandwidth
*/
int lib_interface_zebra_link_params_unreserved_bandwidths_unreserved_bandwidth_unreserved_bandwidth_modify(
struct nb_cb_modify_args *args)
{
struct interface *ifp;
struct if_link_params *iflp;
uint8_t priority;
float unrsv_bw;
if (args->event != NB_EV_APPLY)
return NB_OK;
priority = yang_dnode_get_uint8(args->dnode, "../priority");
unrsv_bw = yang_dnode_get_bandwidth_ieee_float32(args->dnode, NULL);
ifp = nb_running_get_entry(args->dnode, NULL, true);
iflp = if_link_params_get(ifp);
link_param_cmd_set_float(ifp, &iflp->unrsv_bw[priority], LP_UNRSV_BW,
unrsv_bw);
return NB_OK;
}
/*
* XPath: /frr-interface:lib/interface/frr-zebra:zebra/link-params/residual-bandwidth
*/
int lib_interface_zebra_link_params_residual_bandwidth_modify(
struct nb_cb_modify_args *args)
{
struct interface *ifp;
struct if_link_params *iflp;
float max_bw, res_bw;
res_bw = yang_dnode_get_bandwidth_ieee_float32(args->dnode, NULL);
switch (args->event) {
case NB_EV_VALIDATE:
if (yang_dnode_exists(args->dnode, "../max-bandwidth")) {
max_bw =
yang_dnode_get_bandwidth_ieee_float32(args->dnode,
"../max-bandwidth");
if (max_bw < res_bw) {
snprintfrr(args->errmsg, args->errmsg_len,
"max-bandwidth %f is less than residual-bandwidth %f",
max_bw, res_bw);
return NB_ERR_VALIDATION;
}
}
break;
case NB_EV_PREPARE:
case NB_EV_ABORT:
break;
case NB_EV_APPLY:
ifp = nb_running_get_entry(args->dnode, NULL, true);
iflp = if_link_params_get(ifp);
link_param_cmd_set_float(ifp, &iflp->res_bw, LP_RES_BW, res_bw);
break;
}
return NB_OK;
}
int lib_interface_zebra_link_params_residual_bandwidth_destroy(
struct nb_cb_destroy_args *args)
{
struct interface *ifp;
if (args->event != NB_EV_APPLY)
return NB_OK;
ifp = nb_running_get_entry(args->dnode, NULL, true);
link_param_cmd_unset(ifp, LP_RES_BW);
return NB_OK;
}
/*
* XPath: /frr-interface:lib/interface/frr-zebra:zebra/link-params/available-bandwidth
*/
int lib_interface_zebra_link_params_available_bandwidth_modify(
struct nb_cb_modify_args *args)
{
struct interface *ifp;
struct if_link_params *iflp;
float max_bw, ava_bw;
ava_bw = yang_dnode_get_bandwidth_ieee_float32(args->dnode, NULL);
switch (args->event) {
case NB_EV_VALIDATE:
if (yang_dnode_exists(args->dnode, "../max-bandwidth")) {
max_bw =
yang_dnode_get_bandwidth_ieee_float32(args->dnode,
"../max-bandwidth");
if (max_bw < ava_bw) {
snprintfrr(args->errmsg, args->errmsg_len,
"max-bandwidth %f is less than available-bandwidth %f",
max_bw, ava_bw);
return NB_ERR_VALIDATION;
}
}
break;
case NB_EV_PREPARE:
case NB_EV_ABORT:
break;
case NB_EV_APPLY:
ifp = nb_running_get_entry(args->dnode, NULL, true);
iflp = if_link_params_get(ifp);
link_param_cmd_set_float(ifp, &iflp->ava_bw, LP_AVA_BW, ava_bw);
break;
}
return NB_OK;
}
int lib_interface_zebra_link_params_available_bandwidth_destroy(
struct nb_cb_destroy_args *args)
{
struct interface *ifp;
if (args->event != NB_EV_APPLY)
return NB_OK;
ifp = nb_running_get_entry(args->dnode, NULL, true);
link_param_cmd_unset(ifp, LP_AVA_BW);
return NB_OK;
}
/*
* XPath: /frr-interface:lib/interface/frr-zebra:zebra/link-params/utilized-bandwidth
*/
int lib_interface_zebra_link_params_utilized_bandwidth_modify(
struct nb_cb_modify_args *args)
{
struct interface *ifp;
struct if_link_params *iflp;
float max_bw, use_bw;
use_bw = yang_dnode_get_bandwidth_ieee_float32(args->dnode, NULL);
switch (args->event) {
case NB_EV_VALIDATE:
if (yang_dnode_exists(args->dnode, "../max-bandwidth")) {
max_bw =
yang_dnode_get_bandwidth_ieee_float32(args->dnode,
"../max-bandwidth");
if (max_bw < use_bw) {
snprintfrr(args->errmsg, args->errmsg_len,
"max-bandwidth %f is less than utilized-bandwidth %f",
max_bw, use_bw);
return NB_ERR_VALIDATION;
}
}
break;
case NB_EV_PREPARE:
case NB_EV_ABORT:
break;
case NB_EV_APPLY:
ifp = nb_running_get_entry(args->dnode, NULL, true);
iflp = if_link_params_get(ifp);
link_param_cmd_set_float(ifp, &iflp->use_bw, LP_USE_BW, use_bw);
break;
}
return NB_OK;
}
int lib_interface_zebra_link_params_utilized_bandwidth_destroy(
struct nb_cb_destroy_args *args)
{
struct interface *ifp;
if (args->event != NB_EV_APPLY)
return NB_OK;
ifp = nb_running_get_entry(args->dnode, NULL, true);
link_param_cmd_unset(ifp, LP_USE_BW);
return NB_OK;
}
/*
* XPath:
* /frr-interface:lib/interface/frr-zebra:zebra/link-params/legacy-admin-group