From 7560918629eb11aa7bdaee5f4856243b38c77f93 Mon Sep 17 00:00:00 2001 From: Mauro Sardara Date: Mon, 16 Jan 2023 20:18:23 +0000 Subject: feat: local-remote strategy Ticket: HICN-824 Change-Id: Iea285cb499b13c943a142fa39328ee36c91ae913 Signed-off-by: Mauro Sardara --- hicn-plugin/src/strategies/dpo_lr.c | 139 +++++++++++++++++++++++++++++++ hicn-plugin/src/strategies/dpo_lr.h | 122 +++++++++++++++++++++++++++ hicn-plugin/src/strategies/dpo_mw.c | 29 ++----- hicn-plugin/src/strategies/dpo_mw.h | 28 +------ hicn-plugin/src/strategies/dpo_rp.c | 26 ++---- hicn-plugin/src/strategies/dpo_rp.h | 28 +------ hicn-plugin/src/strategies/dpo_rr.c | 26 ++---- hicn-plugin/src/strategies/dpo_rr.h | 28 +------ hicn-plugin/src/strategies/strategy_lr.c | 136 ++++++++++++++++++++++++++++++ hicn-plugin/src/strategies/strategy_lr.h | 35 ++++++++ hicn-plugin/src/strategies/strategy_mw.c | 15 +++- hicn-plugin/src/strategies/strategy_rp.c | 14 +++- hicn-plugin/src/strategies/strategy_rr.c | 14 +++- 13 files changed, 500 insertions(+), 140 deletions(-) create mode 100644 hicn-plugin/src/strategies/dpo_lr.c create mode 100644 hicn-plugin/src/strategies/dpo_lr.h create mode 100644 hicn-plugin/src/strategies/strategy_lr.c create mode 100644 hicn-plugin/src/strategies/strategy_lr.h (limited to 'hicn-plugin/src/strategies') diff --git a/hicn-plugin/src/strategies/dpo_lr.c b/hicn-plugin/src/strategies/dpo_lr.c new file mode 100644 index 000000000..59409e25e --- /dev/null +++ b/hicn-plugin/src/strategies/dpo_lr.c @@ -0,0 +1,139 @@ +/* + * Copyright (c) 2023 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "dpo_lr.h" +#include "strategy_lr.h" +#include "../strategy_dpo_manager.h" +#include "../strategy_dpo_ctx.h" + +/** + * @brief DPO type value for the lr_strategy + */ +static dpo_type_t hicn_dpo_type_lr; + +static const hicn_dpo_vft_t hicn_dpo_lr_vft = { + .hicn_dpo_is_type = &hicn_dpo_is_type_strategy_lr, + .hicn_dpo_get_type = &hicn_dpo_strategy_lr_get_type, + .hicn_dpo_module_init = &hicn_dpo_strategy_lr_module_init, + .hicn_dpo_create = &hicn_strategy_lr_ctx_create, + .hicn_dpo_update_type = &hicn_strategy_lr_update_ctx_type, + .hicn_dpo_add_update_nh = &hicn_strategy_lr_ctx_add_nh, + .hicn_dpo_del_nh = &hicn_strategy_lr_ctx_del_nh, + .hicn_dpo_format = &hicn_dpo_strategy_lr_format +}; + +const static dpo_vft_t dpo_strategy_lr_ctx_vft = { + .dv_lock = hicn_strategy_dpo_ctx_lock, + .dv_unlock = hicn_strategy_dpo_ctx_unlock, + .dv_format = hicn_strategy_dpo_format, +}; + +int +hicn_dpo_is_type_strategy_lr (const dpo_id_t *dpo) +{ + return dpo->dpoi_type == hicn_dpo_type_lr; +} + +void +hicn_dpo_strategy_lr_module_init (void) +{ + /* + * Register our type of dpo + */ + hicn_dpo_type_lr = hicn_dpo_register_new_type ( + hicn_nodes_strategy, &hicn_dpo_lr_vft, hicn_lr_strategy_get_vft (), + &dpo_strategy_lr_ctx_vft); +} + +dpo_type_t +hicn_dpo_strategy_lr_get_type (void) +{ + return hicn_dpo_type_lr; +} + +////////////////////////////////////////////////////////////////////////////////////////////////// + +u8 * +hicn_dpo_strategy_lr_format (u8 *s, hicn_dpo_ctx_t *dpo_ctx, u32 indent) +{ + int i = 0; + + s = format (s, "hicn-lr"); + + for (i = 0; i < HICN_PARAM_FIB_ENTRY_NHOPS_MAX; i++) + { + u8 *buf = NULL; + if (i < dpo_ctx->entry_count) + buf = format (NULL, "FIB"); + else if (i >= HICN_PARAM_FIB_ENTRY_NHOPS_MAX - dpo_ctx->tfib_entry_count) + buf = format (NULL, "TFIB"); + else + continue; + + s = format (s, "\n"); + s = format (s, "%U ", format_hicn_face, dpo_ctx->next_hops[i], indent); + s = format (s, " %s", buf); + } + + return (s); +} + +void +hicn_strategy_lr_ctx_create (fib_protocol_t proto, + const hicn_face_id_t *next_hop, int nh_len, + index_t *dpo_idx) +{ + hicn_dpo_ctx_t *hicn_strategy_ctx; + + /* Allocate a hicn_dpo_ctx on the vpp pool and initialize it */ + hicn_strategy_ctx = hicn_strategy_dpo_ctx_alloc (); + + *dpo_idx = hicn_strategy_dpo_ctx_get_index (hicn_strategy_ctx); + + init_dpo_ctx (hicn_strategy_ctx, next_hop, nh_len, hicn_dpo_type_lr, + (dpo_proto_t) proto); +} + +void +hicn_strategy_lr_update_ctx_type (hicn_dpo_ctx_t *hicn_strategy_ctx) +{ + hicn_strategy_ctx->dpo_type = hicn_dpo_type_lr; + // don't care to reset data, it is not used +} + +int +hicn_strategy_lr_ctx_add_nh (hicn_face_id_t nh, index_t dpo_idx) +{ + hicn_dpo_ctx_t *hicn_strategy_dpo_ctx = hicn_strategy_dpo_ctx_get (dpo_idx); + u8 pos = 0; + + if (hicn_strategy_dpo_ctx == NULL) + { + return HICN_ERROR_STRATEGY_NOT_FOUND; + } + + hicn_strategy_dpo_ctx_add_nh (nh, hicn_strategy_dpo_ctx, &pos); + // nothing else to initialize in this strategy + return HICN_ERROR_NONE; +} + +int +hicn_strategy_lr_ctx_del_nh (hicn_face_id_t face_id, index_t dpo_idx) +{ + hicn_dpo_ctx_t *hicn_strategy_dpo_ctx = hicn_strategy_dpo_ctx_get (dpo_idx); + // No need to change the current_nhop. It will be updated at the next + // selection. + return hicn_strategy_dpo_ctx_del_nh (face_id, hicn_strategy_dpo_ctx); +} diff --git a/hicn-plugin/src/strategies/dpo_lr.h b/hicn-plugin/src/strategies/dpo_lr.h new file mode 100644 index 000000000..757b96db6 --- /dev/null +++ b/hicn-plugin/src/strategies/dpo_lr.h @@ -0,0 +1,122 @@ +/* + * Copyright (c) 2023 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __HICN_DPO_LR_H__ +#define __HICN_DPO_LR_H__ + +#include +#include "../strategy_dpo_ctx.h" + +/** + * @file dpo_lr.h + * + * This file implements the strategy vtf (see strategy.h) and + * the dpo vft (see strategy_dpo_manager.h) for the strategy + * local-remote. + */ + +typedef struct hicn_strategy_lr_ctx_s +{ +} hicn_strategy_lr_ctx_t; + +/** + * @brief Format the dpo ctx for a human-readable string + * + * @param s String to which to append the formatted dpo ctx + * @param dpo_ctx DPO context + * @param indent Indentation + * + * @result The string with the formatted dpo ctx + */ +u8 *hicn_dpo_strategy_lr_format (u8 *s, hicn_dpo_ctx_t *dpo_ctx, u32 indent); + +/** + * @brief Retrieve an hicn_strategy_lr_ctx object + * + * @param indext Index of the hicn_dpo_ctx to retrieve + * @return The hicn_dpo_ctx object or NULL + */ +hicn_dpo_ctx_t *hicn_strategy_lr_ctx_get (index_t index); + +/** + * @brief Create a new local-remote ctx + * + * @param proto The protocol to which the dpo is meant for (see vpp docs) + * @param next_hop A list of next hops to be inserted in the dpo ctx + * @param nh_len Size of the list + * @param dpo_idx index_t that will hold the index of the created dpo ctx + * @return HICN_ERROR_NONE if the creation was fine, otherwise EINVAL + */ +void hicn_strategy_lr_ctx_create (fib_protocol_t proto, + const hicn_face_id_t *next_hop, int nh_len, + index_t *dpo_idx); + +/** + * @brief Update existing ctx setting it to local-remote + * + * @param hicn_strategy_ctx pointer to the ctx to update + */ +void hicn_strategy_lr_update_ctx_type (hicn_dpo_ctx_t *hicn_strategy_ctx); + +/** + * @brief Add or update a next hop in the dpo ctx. + * + * This function is meant to be used in the control plane and not in the data + * plane, as it is not optimized for the latter. + * + * @param nh Next hop to insert in the dpo ctx + * @param dpo_idx Index of the dpo ctx to update with the new or updated next + * hop + * @return HICN_ERROR_NONE if the update or insert was fine, + * otherwise HICN_ERROR_DPO_CTX_NOT_FOUND + */ +int hicn_strategy_lr_ctx_add_nh (hicn_face_id_t nh, index_t dpo_idx); + +/** + * @brief Delete a next hop in the dpo ctx. + * + * @param face_id Face identifier of the next hop + * @param dpo_idx Index of the dpo ctx to update with the new or updated next + * hop + * @return HICN_ERROR_NONE if the update or insert was fine, + * otherwise HICN_ERROR_DPO_CTS_NOT_FOUND + */ +int hicn_strategy_lr_ctx_del_nh (hicn_face_id_t face_id, index_t dpo_idx); + +/** + * @brief Prefetch a dpo + * + * @param dpo_idx Index of the dpo ctx to prefetch + */ +void hicn_strategy_lr_ctx_prefetch (index_t dpo_idx); + +/** + * @brief Return true if the dpo is of type strategy local-remote + * + * @param dpo Dpo to check the type + */ +int hicn_dpo_is_type_strategy_lr (const dpo_id_t *dpo); + +/** + * @brief Initialize the local-remote strategy + */ +void hicn_dpo_strategy_lr_module_init (void); + +/** + * @brief Return the dpo type for the local-remote strategy + */ +dpo_type_t hicn_dpo_strategy_lr_get_type (void); + +#endif // __HICN_DPO_LR_H__ diff --git a/hicn-plugin/src/strategies/dpo_mw.c b/hicn-plugin/src/strategies/dpo_mw.c index 1a7d2e495..9283f6a43 100644 --- a/hicn-plugin/src/strategies/dpo_mw.c +++ b/hicn-plugin/src/strategies/dpo_mw.c @@ -31,7 +31,13 @@ static const hicn_dpo_vft_t hicn_dpo_mw_vft = { .hicn_dpo_update_type = &hicn_strategy_mw_update_ctx_type, .hicn_dpo_add_update_nh = &hicn_strategy_mw_ctx_add_nh, .hicn_dpo_del_nh = &hicn_strategy_mw_ctx_del_nh, - .hicn_dpo_format = &hicn_strategy_mw_format_ctx + .hicn_dpo_format = &hicn_dpo_strategy_mw_format +}; + +const static dpo_vft_t dpo_strategy_mw_ctx_vft = { + .dv_lock = &hicn_strategy_dpo_ctx_lock, + .dv_unlock = &hicn_strategy_dpo_ctx_unlock, + .dv_format = &hicn_strategy_dpo_format }; int @@ -60,27 +66,10 @@ hicn_dpo_strategy_mw_get_type (void) ////////////////////////////////////////////////////////////////////////////////////////////////// u8 * -hicn_strategy_mw_format_ctx (u8 *s, int n, ...) +hicn_dpo_strategy_mw_format (u8 *s, hicn_dpo_ctx_t *dpo_ctx, u32 indent) { - va_list args; - va_start (args, n); - s = format_hicn_strategy_mw_ctx (s, &args); - return s; -} - -u8 * -format_hicn_strategy_mw_ctx (u8 *s, va_list *ap) -{ - int i = 0; - index_t index = va_arg (*ap, index_t); - hicn_dpo_ctx_t *dpo_ctx = NULL; hicn_strategy_mw_ctx_t *mw_dpo_ctx = NULL; - u32 indent = va_arg (*ap, u32); - ; - - dpo_ctx = hicn_strategy_dpo_ctx_get (index); - if (dpo_ctx == NULL) - return s; + int i = 0; mw_dpo_ctx = (hicn_strategy_mw_ctx_t *) dpo_ctx->data; diff --git a/hicn-plugin/src/strategies/dpo_mw.h b/hicn-plugin/src/strategies/dpo_mw.h index d2807d1a5..f3ccf7e30 100644 --- a/hicn-plugin/src/strategies/dpo_mw.h +++ b/hicn-plugin/src/strategies/dpo_mw.h @@ -38,17 +38,12 @@ typedef struct hicn_strategy_mw_ctx_s * @brief Format the dpo ctx for a human-readable string * * @param s String to which to append the formatted dpo ctx - * @param ap List of parameters for the formatting + * @param dpo_ctx DPO context + * @param indent Indentation * * @result The string with the formatted dpo ctx */ -u8 *format_hicn_strategy_mw_ctx (u8 *s, va_list *ap); - -const static dpo_vft_t dpo_strategy_mw_ctx_vft = { - .dv_lock = hicn_strategy_dpo_ctx_lock, - .dv_unlock = hicn_strategy_dpo_ctx_unlock, - .dv_format = format_hicn_strategy_mw_ctx, -}; +u8 *hicn_dpo_strategy_mw_format (u8 *s, hicn_dpo_ctx_t *dpo_ctx, u32 indent); /** * @brief Retrieve an hicn_strategy_mw_ctx object @@ -127,23 +122,6 @@ void hicn_dpo_strategy_mw_module_init (void); */ dpo_type_t hicn_dpo_strategy_mw_get_type (void); -/** - * @brief Format the dpo ctx for the strategy Maximum Weight - * - * @param s String to append the formatted dpo ctx - * @param ap List of arguments to format - */ -u8 *format_hicn_dpo_strategy_mw (u8 *s, va_list *ap); - -/** - * @brief Format the dpo ctx for the strategy Maximum Weight. To - * call from other functions - * - * @param s String to append the formatted dpo ctx - * @param ... List of arguments to format - */ -u8 *hicn_strategy_mw_format_ctx (u8 *s, int n, ...); - #endif // __HICN_DPO_MW_H__ /* diff --git a/hicn-plugin/src/strategies/dpo_rp.c b/hicn-plugin/src/strategies/dpo_rp.c index 7f527cdb6..eb32083b9 100644 --- a/hicn-plugin/src/strategies/dpo_rp.c +++ b/hicn-plugin/src/strategies/dpo_rp.c @@ -31,7 +31,13 @@ static const hicn_dpo_vft_t hicn_dpo_rp_vft = { .hicn_dpo_update_type = &hicn_strategy_rp_update_ctx_type, .hicn_dpo_add_update_nh = &hicn_strategy_rp_ctx_add_nh, .hicn_dpo_del_nh = &hicn_strategy_rp_ctx_del_nh, - .hicn_dpo_format = &hicn_strategy_rp_format_ctx + .hicn_dpo_format = &hicn_dpo_strategy_rp_format +}; + +const static dpo_vft_t dpo_strategy_rp_ctx_vft = { + .dv_lock = hicn_strategy_dpo_ctx_lock, + .dv_unlock = hicn_strategy_dpo_ctx_unlock, + .dv_format = hicn_strategy_dpo_format, }; int @@ -60,25 +66,9 @@ hicn_dpo_strategy_rp_get_type (void) ////////////////////////////////////////////////////////////////////////////////////////////////// u8 * -hicn_strategy_rp_format_ctx (u8 *s, int n, ...) -{ - va_list args; - va_start (args, n); - s = format_hicn_strategy_rp_ctx (s, &args); - return s; -} - -u8 * -format_hicn_strategy_rp_ctx (u8 *s, va_list *ap) +hicn_dpo_strategy_rp_format (u8 *s, hicn_dpo_ctx_t *dpo_ctx, u32 indent) { int i = 0; - index_t index = va_arg (*ap, index_t); - hicn_dpo_ctx_t *dpo_ctx = NULL; - u32 indent = va_arg (*ap, u32); - - dpo_ctx = hicn_strategy_dpo_ctx_get (index); - if (dpo_ctx == NULL) - return s; for (i = 0; i < HICN_PARAM_FIB_ENTRY_NHOPS_MAX; i++) { diff --git a/hicn-plugin/src/strategies/dpo_rp.h b/hicn-plugin/src/strategies/dpo_rp.h index 4fe645add..bc3384b63 100644 --- a/hicn-plugin/src/strategies/dpo_rp.h +++ b/hicn-plugin/src/strategies/dpo_rp.h @@ -35,17 +35,12 @@ typedef struct hicn_strategy_rp_ctx_s * @brief Format the dpo ctx for a human-readable string * * @param s String to which to append the formatted dpo ctx - * @param ap List of parameters for the formatting + * @param dpo_ctx DPO context + * @param indent Indentation * * @result The string with the formatted dpo ctx */ -u8 *format_hicn_strategy_rp_ctx (u8 *s, va_list *ap); - -const static dpo_vft_t dpo_strategy_rp_ctx_vft = { - .dv_lock = hicn_strategy_dpo_ctx_lock, - .dv_unlock = hicn_strategy_dpo_ctx_unlock, - .dv_format = format_hicn_strategy_rp_ctx, -}; +u8 *hicn_dpo_strategy_rp_format (u8 *s, hicn_dpo_ctx_t *dpo_ctx, u32 indent); /** * @brief Retrieve an hicn_strategy_rp_ctx object @@ -124,23 +119,6 @@ void hicn_dpo_strategy_rp_module_init (void); */ dpo_type_t hicn_dpo_strategy_rp_get_type (void); -/** - * @brief Format the dpo ctx for the strategy Replication - * - * @param s String to append the formatted dpo ctx - * @param ap List of arguments to format - */ -u8 *format_hicn_dpo_strategy_rp (u8 *s, va_list *ap); - -/** - * @brief Format the dpo ctx for the strategy Replication. To - * call from other functions - * - * @param s String to append the formatted dpo ctx - * @param ... List of arguments to format - */ -u8 *hicn_strategy_rp_format_ctx (u8 *s, int n, ...); - #endif // __HICN_DPO_RP_H__ /* diff --git a/hicn-plugin/src/strategies/dpo_rr.c b/hicn-plugin/src/strategies/dpo_rr.c index 86b68186b..1fb72b953 100644 --- a/hicn-plugin/src/strategies/dpo_rr.c +++ b/hicn-plugin/src/strategies/dpo_rr.c @@ -31,7 +31,13 @@ static const hicn_dpo_vft_t hicn_dpo_rr_vft = { .hicn_dpo_update_type = &hicn_strategy_rr_update_ctx_type, .hicn_dpo_add_update_nh = &hicn_strategy_rr_ctx_add_nh, .hicn_dpo_del_nh = &hicn_strategy_rr_ctx_del_nh, - .hicn_dpo_format = &hicn_strategy_rr_format_ctx + .hicn_dpo_format = &hicn_dpo_strategy_rr_format +}; + +const static dpo_vft_t dpo_strategy_rr_ctx_vft = { + .dv_lock = hicn_strategy_dpo_ctx_lock, + .dv_unlock = hicn_strategy_dpo_ctx_unlock, + .dv_format = hicn_strategy_dpo_format, }; int @@ -60,26 +66,10 @@ hicn_dpo_strategy_rr_get_type (void) ////////////////////////////////////////////////////////////////////////////////////////////////// u8 * -hicn_strategy_rr_format_ctx (u8 *s, int n, ...) -{ - va_list args; - va_start (args, n); - s = format_hicn_strategy_rr_ctx (s, &args); - return s; -} - -u8 * -format_hicn_strategy_rr_ctx (u8 *s, va_list *ap) +hicn_dpo_strategy_rr_format (u8 *s, hicn_dpo_ctx_t *dpo_ctx, u32 indent) { int i = 0; - index_t index = va_arg (*ap, index_t); - hicn_dpo_ctx_t *dpo_ctx = NULL; hicn_strategy_rr_ctx_t *rr_dpo_ctx = NULL; - u32 indent = va_arg (*ap, u32); - - dpo_ctx = hicn_strategy_dpo_ctx_get (index); - if (dpo_ctx == NULL) - return s; rr_dpo_ctx = (hicn_strategy_rr_ctx_t *) dpo_ctx->data; diff --git a/hicn-plugin/src/strategies/dpo_rr.h b/hicn-plugin/src/strategies/dpo_rr.h index 72ec7b5df..363174bb2 100644 --- a/hicn-plugin/src/strategies/dpo_rr.h +++ b/hicn-plugin/src/strategies/dpo_rr.h @@ -40,17 +40,12 @@ typedef struct hicn_strategy_rr_ctx_s * @brief Format the dpo ctx for a human-readable string * * @param s String to which to append the formatted dpo ctx - * @param ap List of parameters for the formatting + * @param dpo_ctx DPO context + * @param indent Indentation * * @result The string with the formatted dpo ctx */ -u8 *format_hicn_strategy_rr_ctx (u8 *s, va_list *ap); - -const static dpo_vft_t dpo_strategy_rr_ctx_vft = { - .dv_lock = hicn_strategy_dpo_ctx_lock, - .dv_unlock = hicn_strategy_dpo_ctx_unlock, - .dv_format = format_hicn_strategy_rr_ctx, -}; +u8 *hicn_dpo_strategy_rr_format (u8 *s, hicn_dpo_ctx_t *dpo_ctx, u32 indent); /** * @brief Retrieve an hicn_strategy_rr_ctx object @@ -129,23 +124,6 @@ void hicn_dpo_strategy_rr_module_init (void); */ dpo_type_t hicn_dpo_strategy_rr_get_type (void); -/** - * @brief Format the dpo ctx for the strategy Round Robin - * - * @param s String to append the formatted dpo ctx - * @param ap List of arguments to format - */ -u8 *format_hicn_dpo_strategy_rr (u8 *s, va_list *ap); - -/** - * @brief Format the dpo ctx for the strategy Round Robin. To - * call from other functions - * - * @param s String to append the formatted dpo ctx - * @param ... List of arguments to format - */ -u8 *hicn_strategy_rr_format_ctx (u8 *s, int n, ...); - #endif // __HICN_DPO_RR_H__ /* diff --git a/hicn-plugin/src/strategies/strategy_lr.c b/hicn-plugin/src/strategies/strategy_lr.c new file mode 100644 index 000000000..6bb4097ec --- /dev/null +++ b/hicn-plugin/src/strategies/strategy_lr.c @@ -0,0 +1,136 @@ +/* + * Copyright (c) 2021 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "dpo_lr.h" +#include "../strategy.h" +#include "../strategy_dpo_ctx.h" +#include "../faces/face.h" +#include "../strategy_dpo_manager.h" + +/* Simple strategy that forwards intertests to all next hops */ +/* It does not require to exend the hicn_dpo */ +void hicn_receive_data_lr (index_t dpo_idx, int nh_idx); +void hicn_add_interest_lr (index_t dpo_idx); +int hicn_send_after_aggregation_lr (index_t dpo_idx, hicn_face_id_t in_face); +void hicn_on_interest_timeout_lr (index_t dpo_idx); +u32 hicn_select_next_hop_lr (index_t dpo_idx, hicn_face_id_t in_face, + hicn_face_id_t *outfaces, u16 *len); +u8 *hicn_strategy_format_trace_lr (u8 *s, hicn_strategy_trace_t *t); +u8 *hicn_strategy_format_lr (u8 *s, va_list *ap); + +static hicn_strategy_vft_t hicn_strategy_lr_vft = { + .hicn_receive_data = &hicn_receive_data_lr, + .hicn_add_interest = &hicn_add_interest_lr, + .hicn_send_after_aggregation = &hicn_send_after_aggregation_lr, + .hicn_on_interest_timeout = &hicn_on_interest_timeout_lr, + .hicn_select_next_hop = &hicn_select_next_hop_lr, + .hicn_format_strategy_trace = &hicn_strategy_format_trace_lr, + .hicn_format_strategy = &hicn_strategy_format_lr +}; + +/* + * Return the vft of the strategy. + */ +hicn_strategy_vft_t * +hicn_lr_strategy_get_vft (void) +{ + return &hicn_strategy_lr_vft; +} + +/* DPO should be given in input as it containes all the information to + * calculate the next hops*/ +u32 +hicn_select_next_hop_lr (index_t dpo_idx, hicn_face_id_t in_face, + hicn_face_id_t *outfaces, u16 *len) +{ + hicn_dpo_ctx_t *dpo_ctx = hicn_strategy_dpo_ctx_get (dpo_idx); + + *len = 0; + + if (dpo_ctx == NULL || dpo_ctx->entry_count == 0) + { + return HICN_ERROR_STRATEGY_NOT_FOUND; + } + + // Check if input face is local face + int in_is_local = hicn_face_is_local (in_face); + + int i = 0; + while (i < MAX_OUT_FACES && i < dpo_ctx->entry_count) + { + if (hicn_face_is_local (dpo_ctx->next_hops[i]) != in_is_local) + { + outfaces[0] = dpo_ctx->next_hops[i]; + *len = 1; + break; + } + + i++; + } + + return HICN_ERROR_NONE; +} + +void +hicn_add_interest_lr (index_t dpo_ctx_idx) +{ + /* Nothing to do */ +} + +int +hicn_send_after_aggregation_lr (index_t dpo_idx, hicn_face_id_t in_face) +{ + if (hicn_face_is_local (in_face)) + { + return true; + } + + return false; +} + +void +hicn_on_interest_timeout_lr (index_t dpo_idx) +{ + /* Nothing to do in the lr strategy when we receive an interest */ +} + +void +hicn_receive_data_lr (index_t dpo_idx, int nh_idx) +{ + /* nothing to do */ +} + +/* packet trace format function */ +u8 * +hicn_strategy_format_trace_lr (u8 *s, hicn_strategy_trace_t *t) +{ + s = format (s, + "Strategy_lr: pkt: %d, sw_if_index %d, next index %d, dpo_type " + "%d, out_face %d", + (int) t->pkt_type, t->sw_if_index, t->next_index, t->dpo_type, + t->out_face); + return (s); +} + +u8 * +hicn_strategy_format_lr (u8 *s, va_list *ap) +{ + + u32 indent = va_arg (*ap, u32); + s = format ( + s, "Local-Remote: send from local face to remote only and viceversa \n", + indent); + return (s); +} diff --git a/hicn-plugin/src/strategies/strategy_lr.h b/hicn-plugin/src/strategies/strategy_lr.h new file mode 100644 index 000000000..826eb89a0 --- /dev/null +++ b/hicn-plugin/src/strategies/strategy_lr.h @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2021 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __HICN_STRATEGY_LR_H__ +#define __HICN_STRATEGY_LR_H__ + +#include "../strategy.h" + +/** + * @file strategy_lr.h + * + * This file implements the local-remote strategy. In this + * strategy, if the interest is received from an application (local) + * face, it is then sent to a remote next hop. Viceversa, when an interest + * is received from a remote face, it is then sent to a local face. + */ + +/** + * @brief Return the vft for the local-remote strategy + */ +hicn_strategy_vft_t *hicn_lr_strategy_get_vft (void); + +#endif // __HICN_STRATEGY_LR_H__ diff --git a/hicn-plugin/src/strategies/strategy_mw.c b/hicn-plugin/src/strategies/strategy_mw.c index 81c757f70..1f0210fbe 100644 --- a/hicn-plugin/src/strategies/strategy_mw.c +++ b/hicn-plugin/src/strategies/strategy_mw.c @@ -22,9 +22,10 @@ /* It does not require to exend the hicn_dpo */ void hicn_receive_data_mw (index_t dpo_idx, int nh_idx); void hicn_add_interest_mw (index_t dpo_idx); +int hicn_send_after_aggregation_mw (index_t dpo_idx, hicn_face_id_t in_face); void hicn_on_interest_timeout_mw (index_t dpo_idx); -u32 hicn_select_next_hop_mw (index_t dpo_idx, hicn_face_id_t *outfaces, - u16 *len); +u32 hicn_select_next_hop_mw (index_t dpo_idx, hicn_face_id_t in_face, + hicn_face_id_t *outfaces, u16 *len); u32 get_strategy_node_index_mw (void); u8 *hicn_strategy_format_trace_mw (u8 *s, hicn_strategy_trace_t *t); u8 *hicn_strategy_format_mw (u8 *s, va_list *ap); @@ -32,6 +33,7 @@ u8 *hicn_strategy_format_mw (u8 *s, va_list *ap); static hicn_strategy_vft_t hicn_strategy_mw_vft = { .hicn_receive_data = &hicn_receive_data_mw, .hicn_add_interest = &hicn_add_interest_mw, + .hicn_send_after_aggregation = &hicn_send_after_aggregation_mw, .hicn_on_interest_timeout = &hicn_on_interest_timeout_mw, .hicn_select_next_hop = &hicn_select_next_hop_mw, .hicn_format_strategy_trace = hicn_strategy_format_trace_mw, @@ -50,7 +52,8 @@ hicn_mw_strategy_get_vft (void) /* DPO should be give in input as it containes all the information to calculate * the next hops*/ u32 -hicn_select_next_hop_mw (index_t dpo_idx, hicn_face_id_t *outfaces, u16 *len) +hicn_select_next_hop_mw (index_t dpo_idx, hicn_face_id_t in_face, + hicn_face_id_t *outfaces, u16 *len) { hicn_dpo_ctx_t *dpo_ctx = hicn_strategy_dpo_ctx_get (dpo_idx); @@ -84,6 +87,12 @@ hicn_add_interest_mw (index_t dpo_ctx_idx) { } +int +hicn_send_after_aggregation_mw (index_t dpo_idx, hicn_face_id_t in_face) +{ + return false; +} + void hicn_on_interest_timeout_mw (index_t dpo_idx) { diff --git a/hicn-plugin/src/strategies/strategy_rp.c b/hicn-plugin/src/strategies/strategy_rp.c index eb495ff91..a44da1323 100644 --- a/hicn-plugin/src/strategies/strategy_rp.c +++ b/hicn-plugin/src/strategies/strategy_rp.c @@ -23,9 +23,10 @@ /* It does not require to exend the hicn_dpo */ void hicn_receive_data_rp (index_t dpo_idx, int nh_idx); void hicn_add_interest_rp (index_t dpo_idx); +int hicn_send_after_aggregation_rp (index_t dpo_idx, hicn_face_id_t in_face); void hicn_on_interest_timeout_rp (index_t dpo_idx); -u32 hicn_select_next_hop_rp (index_t dpo_idx, hicn_face_id_t *outfaces, - u16 *len); +u32 hicn_select_next_hop_rp (index_t dpo_idx, hicn_face_id_t in_face, + hicn_face_id_t *outfaces, u16 *len); u8 *hicn_strategy_format_trace_rp (u8 *s, hicn_strategy_trace_t *t); u8 *hicn_strategy_format_rp (u8 *s, va_list *ap); @@ -50,7 +51,8 @@ hicn_rp_strategy_get_vft (void) /* DPO should be give in input as it containes all the information to calculate * the next hops*/ u32 -hicn_select_next_hop_rp (index_t dpo_idx, hicn_face_id_t *outfaces, u16 *len) +hicn_select_next_hop_rp (index_t dpo_idx, hicn_face_id_t in_face, + hicn_face_id_t *outfaces, u16 *len) { hicn_dpo_ctx_t *dpo_ctx = hicn_strategy_dpo_ctx_get (dpo_idx); @@ -77,6 +79,12 @@ hicn_add_interest_rp (index_t dpo_ctx_idx) /* Nothing to do */ } +int +hicn_send_after_aggregation_rp (index_t dpo_idx, hicn_face_id_t in_face) +{ + return false; +} + void hicn_on_interest_timeout_rp (index_t dpo_idx) { diff --git a/hicn-plugin/src/strategies/strategy_rr.c b/hicn-plugin/src/strategies/strategy_rr.c index ef5dc3fc1..af3cb320a 100644 --- a/hicn-plugin/src/strategies/strategy_rr.c +++ b/hicn-plugin/src/strategies/strategy_rr.c @@ -23,9 +23,10 @@ /* It does not require to exend the hicn_dpo */ void hicn_receive_data_rr (index_t dpo_idx, int nh_idx); void hicn_add_interest_rr (index_t dpo_idx); +int hicn_send_after_aggregation_rr (index_t dpo_idx, hicn_face_id_t in_face); void hicn_on_interest_timeout_rr (index_t dpo_idx); -u32 hicn_select_next_hop_rr (index_t dpo_idx, hicn_face_id_t *outfaces, - u16 *len); +u32 hicn_select_next_hop_rr (index_t dpo_idx, hicn_face_id_t in_face, + hicn_face_id_t *outfaces, u16 *len); u8 *hicn_strategy_format_trace_rr (u8 *s, hicn_strategy_trace_t *t); u8 *hicn_strategy_format_rr (u8 *s, va_list *ap); @@ -50,7 +51,8 @@ hicn_rr_strategy_get_vft (void) /* DPO should be give in input as it containes all the information to calculate * the next hops*/ u32 -hicn_select_next_hop_rr (index_t dpo_idx, hicn_face_id_t *outfaces, u16 *len) +hicn_select_next_hop_rr (index_t dpo_idx, hicn_face_id_t in_face, + hicn_face_id_t *outfaces, u16 *len) { hicn_dpo_ctx_t *dpo_ctx = hicn_strategy_dpo_ctx_get (dpo_idx); @@ -77,6 +79,12 @@ hicn_add_interest_rr (index_t dpo_ctx_idx) { } +int +hicn_send_after_aggregation_rr (index_t dpo_idx, hicn_face_id_t in_face) +{ + return false; +} + void hicn_on_interest_timeout_rr (index_t dpo_idx) { -- cgit 1.2.3-korg