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/CMakeLists.txt | 4 + hicn-plugin/src/faces/face.h | 17 ++++ hicn-plugin/src/faces/face_flags.h | 2 +- hicn-plugin/src/interest_hitpit_node.c | 35 ++++++-- hicn-plugin/src/interest_pcslookup_node.c | 9 +- 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 ++- hicn-plugin/src/strategy.h | 6 +- hicn-plugin/src/strategy_dpo_ctx.c | 16 ---- hicn-plugin/src/strategy_dpo_manager.c | 26 ++++-- hicn-plugin/src/strategy_dpo_manager.h | 7 +- hicn-plugin/src/strategy_node.c | 7 +- 23 files changed, 586 insertions(+), 183 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') diff --git a/hicn-plugin/src/CMakeLists.txt b/hicn-plugin/src/CMakeLists.txt index 0ba683b11..9524b011a 100644 --- a/hicn-plugin/src/CMakeLists.txt +++ b/hicn-plugin/src/CMakeLists.txt @@ -65,7 +65,9 @@ set(HICN_PLUGIN_SOURCE_FILES ${CMAKE_CURRENT_SOURCE_DIR}/strategies/dpo_rr.c ${CMAKE_CURRENT_SOURCE_DIR}/strategies/strategy_rr.c ${CMAKE_CURRENT_SOURCE_DIR}/strategies/dpo_rp.c + ${CMAKE_CURRENT_SOURCE_DIR}/strategies/dpo_lr.c ${CMAKE_CURRENT_SOURCE_DIR}/strategies/strategy_rp.c + ${CMAKE_CURRENT_SOURCE_DIR}/strategies/strategy_lr.c ${CMAKE_CURRENT_SOURCE_DIR}/cache_policies/cs_lru.c ${CMAKE_CURRENT_SOURCE_DIR}/mapme_ack_node.c ${CMAKE_CURRENT_SOURCE_DIR}/mapme_ctrl_node.c @@ -113,7 +115,9 @@ set(HICN_PLUGIN_HEADER_FILES ${CMAKE_CURRENT_SOURCE_DIR}/strategies/dpo_rr.h ${CMAKE_CURRENT_SOURCE_DIR}/strategies/strategy_rr.h ${CMAKE_CURRENT_SOURCE_DIR}/strategies/dpo_rp.h + ${CMAKE_CURRENT_SOURCE_DIR}/strategies/dpo_lr.h ${CMAKE_CURRENT_SOURCE_DIR}/strategies/strategy_rp.h + ${CMAKE_CURRENT_SOURCE_DIR}/strategies/strategy_lr.h ${CMAKE_CURRENT_SOURCE_DIR}/cache_policies/cs_policy.h ${CMAKE_CURRENT_SOURCE_DIR}/cache_policies/cs_lru.h ${CMAKE_CURRENT_SOURCE_DIR}/mapme.h diff --git a/hicn-plugin/src/faces/face.h b/hicn-plugin/src/faces/face.h index e4b759bec..5ebec216c 100644 --- a/hicn-plugin/src/faces/face.h +++ b/hicn-plugin/src/faces/face.h @@ -692,6 +692,23 @@ hicn_face_ip6_add_and_lock (hicn_face_id_t *index, u8 *hicnb_flags, return ret; } +/** + * @brief Check if a face is an application face + * + * @param face_id: The id of the face + * @return 1 if application face, 0 otherwise + */ +always_inline int +hicn_face_is_local (hicn_face_id_t face_id) +{ + hicn_face_t *face; + face = hicn_dpoi_get_from_idx (face_id); + ASSERT (face != NULL); + + return face->flags & HICN_FACE_FLAGS_APPFACE_PROD || + face->flags & HICN_FACE_FLAGS_APPFACE_CONS; +} + #endif // __HICN_FACE_H__ /* diff --git a/hicn-plugin/src/faces/face_flags.h b/hicn-plugin/src/faces/face_flags.h index 61dee5465..69598ab1d 100644 --- a/hicn-plugin/src/faces/face_flags.h +++ b/hicn-plugin/src/faces/face_flags.h @@ -23,7 +23,7 @@ #define foreach_face_flag \ _ (0, FACE, "face") \ _ (1, IFACE, "iface") \ - _ (2, APPFACE_PROD, "face is consumer face") \ + _ (2, APPFACE_PROD, "face is producer face") \ _ (3, APPFACE_CONS, "face is consumer face") \ _ (4, DELETED, "face is deleted") \ _ (5, UDP, "face is udp") diff --git a/hicn-plugin/src/interest_hitpit_node.c b/hicn-plugin/src/interest_hitpit_node.c index a84aace9c..0b09711f7 100644 --- a/hicn-plugin/src/interest_hitpit_node.c +++ b/hicn-plugin/src/interest_hitpit_node.c @@ -61,7 +61,7 @@ hicn_interest_hitpit_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node, const hicn_strategy_vft_t *strategy_vft0; const hicn_dpo_vft_t *dpo_vft0; u8 dpo_ctx_id0; - u8 found = 0; + u8 forward = 0; hicn_face_id_t outfaces[MAX_OUT_FACES]; u32 clones[MAX_OUT_FACES]; u16 outfaces_len; @@ -147,15 +147,37 @@ hicn_interest_hitpit_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node, } else { - // Distinguish between aggregation or retransmission - found = + // Distinguish between aggregation, retransmission and + // additionally check if the strategy mandates to always send + // the interest + + // Retransmission + forward = hicn_pcs_entry_pit_search (pcs_entry, hicnb0->face_id); - if (found && hicnb0->payload_type != HPT_MANIFEST) + // Strategy mandates to force send after aggregation + if (!forward && strategy_vft0->hicn_send_after_aggregation ( + dpo_ctx_id0, hicnb0->face_id)) + { + forward = true; + hicn_pcs_entry_pit_add_face (pcs_entry, hicnb0->face_id); + } + + if (forward && hicnb0->payload_type != HPT_MANIFEST) { - // Retransmission + // Send interest strategy_vft0->hicn_select_next_hop ( - dpo_ctx_id0, outfaces, &outfaces_len); + dpo_ctx_id0, hicnb0->face_id, outfaces, &outfaces_len); + + // If no next hops, drop the packet + if (outfaces_len == 0) + { + drop_packet (&next0); + vlib_validate_buffer_enqueue_x1 ( + vm, node, next_index, to_next, n_left_to_next, bi0, + next0); + continue; + } // Prepare the packet for the forwarding next0 = isv6 ? HICN_INTEREST_HITPIT_NEXT_FACE6_OUTPUT : @@ -224,7 +246,6 @@ hicn_interest_hitpit_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node, // Aggregation hicn_pcs_entry_pit_add_face (pcs_entry, hicnb0->face_id); - /* Aggregation */ drop_packet (&next0); stats.interests_aggregated++; diff --git a/hicn-plugin/src/interest_pcslookup_node.c b/hicn-plugin/src/interest_pcslookup_node.c index 4947b67ff..e3668c565 100644 --- a/hicn-plugin/src/interest_pcslookup_node.c +++ b/hicn-plugin/src/interest_pcslookup_node.c @@ -99,7 +99,7 @@ hicn_interest_pcslookup_node_inline (vlib_main_t *vm, b0 = vlib_get_buffer (vm, bi0); - // By default we send the interest to drop + // By default we send the interest to strategy node next0 = HICN_INTEREST_PCSLOOKUP_NEXT_STRATEGY; // Update stats @@ -109,7 +109,6 @@ hicn_interest_pcslookup_node_inline (vlib_main_t *vm, hicn_name_t name; hicn_packet_get_name (&hicn_get_buffer (b0)->pkbuf, &name); ret = hicn_pcs_lookup_one (rt->pitcs, &name, &pcs_entry); - //&hicn_get_buffer (b0)->name, if (ret == HICN_ERROR_NONE) { @@ -389,9 +388,9 @@ hicn_interest_manifest_pcslookup_node_inline (vlib_main_t *vm, strategy->hicn_add_interest (hicnb0->dpo_ctx_id); // Check we have at least one next hop for the packet - ret = strategy->hicn_select_next_hop (hicnb0->dpo_ctx_id, - outfaces, &outfaces_len); - if (ret == HICN_ERROR_NONE) + ret = strategy->hicn_select_next_hop ( + hicnb0->dpo_ctx_id, hicnb0->face_id, outfaces, &outfaces_len); + if (ret == HICN_ERROR_NONE && outfaces_len > 0) { next0 = hicn_buffer_is_v6 (b0) ? HICN_INTEREST_MANIFEST_PCSLOOKUP_NEXT_FACE6 : 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) { diff --git a/hicn-plugin/src/strategy.h b/hicn-plugin/src/strategy.h index ffc529125..135aeea7b 100644 --- a/hicn-plugin/src/strategy.h +++ b/hicn-plugin/src/strategy.h @@ -44,6 +44,7 @@ typedef struct u32 sw_if_index; u8 pkt_type; dpo_type_t dpo_type; + hicn_face_id_t out_face; } hicn_strategy_trace_t; typedef struct hicn_strategy_vft_s @@ -51,8 +52,9 @@ typedef struct hicn_strategy_vft_s void (*hicn_receive_data) (index_t dpo_idx, int nh_idx); void (*hicn_on_interest_timeout) (index_t dpo_idx); void (*hicn_add_interest) (index_t dpo_idx); - u32 (*hicn_select_next_hop) (index_t dpo_idx, hicn_face_id_t *outfaces, - u16 *len); + int (*hicn_send_after_aggregation) (index_t dpo_idx, hicn_face_id_t in_face); + u32 (*hicn_select_next_hop) (index_t dpo_idx, hicn_face_id_t in_face, + hicn_face_id_t *outfaces, u16 *len); u8 *(*hicn_format_strategy_trace) (u8 *, hicn_strategy_trace_t *); u8 *(*hicn_format_strategy) (u8 *s, va_list *ap); /**< Format an hICN dpo*/ diff --git a/hicn-plugin/src/strategy_dpo_ctx.c b/hicn-plugin/src/strategy_dpo_ctx.c index d43b7315b..eb4173944 100644 --- a/hicn-plugin/src/strategy_dpo_ctx.c +++ b/hicn-plugin/src/strategy_dpo_ctx.c @@ -68,22 +68,6 @@ hicn_strategy_dpo_ctx_unlock (dpo_id_t *dpo) } } -u8 * -hicn_strategy_dpo_format_ctx (u8 *s, va_list *ap) -{ - index_t index = va_arg (*ap, index_t); - hicn_dpo_ctx_t *dpo = NULL; - u32 indent = va_arg (*ap, u32); - - dpo = (hicn_dpo_ctx_t *) hicn_strategy_dpo_ctx_get (index); - - const hicn_dpo_vft_t *dpo_vft = hicn_dpo_get_vft (dpo->dpo_type); - - s = dpo_vft->hicn_dpo_format (s, 2, index, indent); - - return (s); -} - index_t hicn_strategy_dpo_ctx_get_index (hicn_dpo_ctx_t *cd) { diff --git a/hicn-plugin/src/strategy_dpo_manager.c b/hicn-plugin/src/strategy_dpo_manager.c index 6c5767bc9..1e136b47b 100644 --- a/hicn-plugin/src/strategy_dpo_manager.c +++ b/hicn-plugin/src/strategy_dpo_manager.c @@ -20,6 +20,7 @@ #include "strategies/dpo_mw.h" #include "strategies/dpo_rr.h" #include "strategies/dpo_rp.h" +#include "strategies/dpo_lr.h" #include "strategy.h" #include "faces/face.h" @@ -93,6 +94,21 @@ hicn_dpo_get_strategy_vft_from_id (u8 vfts_id) return hicn_strategy_vfts[strategies_id[vfts_id]]; } +u8 * +hicn_strategy_dpo_format (u8 *s, va_list *ap) +{ + 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; + + return hicn_dpo_vfts[dpo_ctx->dpo_type]->hicn_dpo_format (s, dpo_ctx, + indent); +} + void hicn_dpos_init (void) { @@ -100,15 +116,9 @@ hicn_dpos_init (void) hicn_dpo_strategy_mw_module_init (); hicn_dpo_strategy_rr_module_init (); hicn_dpo_strategy_rp_module_init (); + hicn_dpo_strategy_lr_module_init (); - default_dpo.hicn_dpo_is_type = &hicn_dpo_is_type_strategy_mw; - default_dpo.hicn_dpo_get_type = &hicn_dpo_strategy_mw_get_type; - default_dpo.hicn_dpo_module_init = &hicn_dpo_strategy_mw_module_init; - default_dpo.hicn_dpo_create = &hicn_strategy_mw_ctx_create; - default_dpo.hicn_dpo_update_type = &hicn_strategy_mw_update_ctx_type; - default_dpo.hicn_dpo_add_update_nh = &hicn_strategy_mw_ctx_add_nh; - default_dpo.hicn_dpo_del_nh = &hicn_strategy_mw_ctx_del_nh; - default_dpo.hicn_dpo_format = &hicn_strategy_mw_format_ctx; + default_dpo = *hicn_dpo_vfts[hicn_dpo_strategy_mw_get_type ()]; } u8 * diff --git a/hicn-plugin/src/strategy_dpo_manager.h b/hicn-plugin/src/strategy_dpo_manager.h index b8a0c9e92..0163cd679 100644 --- a/hicn-plugin/src/strategy_dpo_manager.h +++ b/hicn-plugin/src/strategy_dpo_manager.h @@ -59,7 +59,7 @@ typedef struct hicn_dpo_vft_s hicn_face_id_t nh, index_t dpo_idx); /**< Add a next hop to the hICN dpo context */ int (*hicn_dpo_del_nh) (hicn_face_id_t face_id, index_t dpo_idx); - u8 *(*hicn_dpo_format) (u8 *s, int, ...); + u8 *(*hicn_dpo_format) (u8 *s, hicn_dpo_ctx_t *dpo_ctx, u32 indent); /**< Format an hICN dpo*/ } hicn_dpo_vft_t; @@ -189,6 +189,11 @@ int hicn_strategy_get_all_available (void); */ void hicn_dpo_register (const hicn_dpo_vft_t *hicn_dpo); +/** + * @brief Format strategy DPO. + */ +u8 *hicn_strategy_dpo_format (u8 *s, va_list *ap); + #endif /* // __HICN_STRATEGY_DPO_MANAGER_H__ */ /* diff --git a/hicn-plugin/src/strategy_node.c b/hicn-plugin/src/strategy_node.c index 31585077f..67ac1c140 100644 --- a/hicn-plugin/src/strategy_node.c +++ b/hicn-plugin/src/strategy_node.c @@ -145,8 +145,8 @@ hicn_strategy_fn (vlib_main_t *vm, vlib_node_runtime_t *node, strategy->hicn_add_interest (hicnb0->dpo_ctx_id); // Check we have at least one next hop for the packet - ret = strategy->hicn_select_next_hop (hicnb0->dpo_ctx_id, outfaces, - &outfaces_len); + ret = strategy->hicn_select_next_hop ( + hicnb0->dpo_ctx_id, hicnb0->face_id, outfaces, &outfaces_len); if (PREDICT_FALSE (ret != HICN_ERROR_NONE || outfaces_len == 0)) { @@ -224,11 +224,12 @@ hicn_strategy_fn (vlib_main_t *vm, vlib_node_runtime_t *node, { hicn_strategy_trace_t *t = vlib_add_trace (vm, node, local_b0, sizeof (*t)); - t->pkt_type = HICN_PACKET_TYPE_DATA; + t->pkt_type = HICN_PACKET_TYPE_INTEREST; t->sw_if_index = vnet_buffer (local_b0)->sw_if_index[VLIB_RX]; t->next_index = next0; t->dpo_type = hicnb0->vft_id; + t->out_face = outfaces[nh]; } /* -- cgit 1.2.3-korg