From fbe9f5e51f0c77cbb12e169680ef1e62bd901364 Mon Sep 17 00:00:00 2001 From: Aaron Bernardino Date: Sun, 5 Jul 2026 04:59:35 +0000 Subject: [PATCH 1/3] [vpp][sonic_ext] Add RIF loopback packet action to the sonic_ext plugin Fold the router-interface loopback (hairpin) packet action feature into the consolidated sonic_ext plugin instead of a standalone plugin, so all custom SONiC VPP dataplane nodes live in one place (see sonic-platform-vpp #255). - Add ip4/ip6 loopback output-arc nodes (sonic-ext-ip4-loopback / sonic-ext-ip6-loopback): a routed packet whose egress interface equals its ingress interface is dropped and the interface tx-error counter incremented when the per-interface action is DROP; otherwise it continues on the arc. - Add the first binary API to sonic_ext (sonic_ext.api: iface_loopback_set_action) with the msg-id-base setup and reply handler, and a per-sw_if_index action vector in sonic_ext_main_t. - sonic_ext_iface_loopback_set_action() toggles the output arcs only on an actual FORWARD<->DROP transition (VPP feature enable/disable is ref-counted), and rolls back both the arc state and the stored action on failure. - Reset the action on interface delete so a recycled sw_if_index cannot inherit a stale DROP. - Bump VPP_VERSION 2606-0.3 -> 2606-0.4 (plugin content changed). Signed-off-by: Aaron Bernardino Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- rules/vpp.mk | 5 +- vppbld/plugins/sonic_ext/CMakeLists.txt | 5 + vppbld/plugins/sonic_ext/FEATURE.yaml | 2 + vppbld/plugins/sonic_ext/ip4_loopback_node.c | 145 +++++++++++++++++++ vppbld/plugins/sonic_ext/ip6_loopback_node.c | 145 +++++++++++++++++++ vppbld/plugins/sonic_ext/sonic_ext.api | 36 +++++ vppbld/plugins/sonic_ext/sonic_ext.c | 89 ++++++++++++ vppbld/plugins/sonic_ext/sonic_ext.h | 18 +++ 8 files changed, 443 insertions(+), 2 deletions(-) create mode 100644 vppbld/plugins/sonic_ext/ip4_loopback_node.c create mode 100644 vppbld/plugins/sonic_ext/ip6_loopback_node.c create mode 100644 vppbld/plugins/sonic_ext/sonic_ext.api diff --git a/rules/vpp.mk b/rules/vpp.mk index 56ee659f..3a3033d2 100644 --- a/rules/vpp.mk +++ b/rules/vpp.mk @@ -2,12 +2,13 @@ VPP_VERSION_BASE = 2606 # Bump the minor suffix whenever vppbld/patches/series or any patch file -# under vppbld/patches/*.patch changes content. The VPP_VERSION_SONIC string +# under vppbld/patches/*.patch -- or any plugin under vppbld/plugins/* -- changes +# content. The VPP_VERSION_SONIC string # is the cache key used by vppbld/Makefile to fetch pre-built debs from # https://packages.buildkite.com/sonic-vpp/vpp; if the suffix isn't bumped, # downstream sonic-buildimage builds will silently pull stale debs that # pre-date the new patch series and end up with VPP/SAI CRC drift. -VPP_VERSION = $(VPP_VERSION_BASE)-0.3 +VPP_VERSION = $(VPP_VERSION_BASE)-0.4 VPP_VERSION_SONIC = $(VPP_VERSION)+b1sonic1 VPP_SRC_PATH = platform/vpp/vppbld diff --git a/vppbld/plugins/sonic_ext/CMakeLists.txt b/vppbld/plugins/sonic_ext/CMakeLists.txt index 40562f6e..32a026c8 100644 --- a/vppbld/plugins/sonic_ext/CMakeLists.txt +++ b/vppbld/plugins/sonic_ext/CMakeLists.txt @@ -18,8 +18,13 @@ add_vpp_plugin(sonic_ext aggr_tap_redirect_node.c host_xc_node.c l2_trap_fixup_node.c + ip4_loopback_node.c + ip6_loopback_node.c cli.c + API_FILES + sonic_ext.api + LINK_LIBRARIES lcp ) diff --git a/vppbld/plugins/sonic_ext/FEATURE.yaml b/vppbld/plugins/sonic_ext/FEATURE.yaml index d544f3fe..375cd6d5 100644 --- a/vppbld/plugins/sonic_ext/FEATURE.yaml +++ b/vppbld/plugins/sonic_ext/FEATURE.yaml @@ -3,6 +3,8 @@ maintainer: SONiC-VPP contributors features: - punt-via-member: redirect BVI-RX punted unicast/ARP to the original member tap - host-xc: bypass ethernet-input for packets injected from the linux-cp host tap + - iface-loopback: drop and count routed hairpin packets (RIF loopback packet + action) whose egress interface equals their ingress interface description: "SONiC VPP extensions for BVI/L2 punt and host-side cross-connect" state: experimental properties: [API, CLI] diff --git a/vppbld/plugins/sonic_ext/ip4_loopback_node.c b/vppbld/plugins/sonic_ext/ip4_loopback_node.c new file mode 100644 index 00000000..0c3b73c0 --- /dev/null +++ b/vppbld/plugins/sonic_ext/ip4_loopback_node.c @@ -0,0 +1,145 @@ +/* + * Copyright (c) 2026 SONiC-VPP contributors + * 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 +#include +#include +#include +#include + +typedef struct +{ + u32 rx_sw_if_index; + u32 tx_sw_if_index; + u32 next_index; + u8 dropped; +} ip4_loopback_trace_t; + +static u8 * +format_ip4_loopback_trace (u8 *s, va_list *args) +{ + CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *); + CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *); + ip4_loopback_trace_t *t = va_arg (*args, ip4_loopback_trace_t *); + + s = format (s, "SONIC-EXT-IP4-LOOPBACK: rx %d tx %d next %d %s", + t->rx_sw_if_index, t->tx_sw_if_index, t->next_index, + t->dropped ? "(hairpin-drop)" : ""); + return s; +} + +#define foreach_ip4_loopback_error _ (HAIRPIN_DROP, "hairpin packets dropped") + +typedef enum +{ +#define _(sym, str) IP4_LOOPBACK_ERROR_##sym, + foreach_ip4_loopback_error +#undef _ + IP4_LOOPBACK_N_ERROR, +} ip4_loopback_error_t; + +static char *ip4_loopback_error_strings[] = { +#define _(sym, string) string, + foreach_ip4_loopback_error +#undef _ +}; + +typedef enum +{ + IP4_LOOPBACK_NEXT_DROP, + IP4_LOOPBACK_NEXT_INTERFACE_OUTPUT, + IP4_LOOPBACK_N_NEXT, +} ip4_loopback_next_t; + +VLIB_NODE_FN (sonic_ext_ip4_loopback_node) +(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame) +{ + sonic_ext_main_t *sem = &sonic_ext_main; + vnet_main_t *vnm = vnet_get_main (); + u32 thread_index = vm->thread_index; + u32 n_left_from, *from; + vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b; + u16 nexts[VLIB_FRAME_SIZE], *next; + + from = vlib_frame_vector_args (frame); + n_left_from = frame->n_vectors; + + vlib_get_buffers (vm, from, bufs, n_left_from); + b = bufs; + next = nexts; + + while (n_left_from > 0) + { + u32 rx = vnet_buffer (b[0])->sw_if_index[VLIB_RX]; + u32 tx = vnet_buffer (b[0])->sw_if_index[VLIB_TX]; + u8 action = (tx < vec_len (sem->loopback_action_by_sw_if_index)) + ? sem->loopback_action_by_sw_if_index[tx] + : SONIC_EXT_LOOPBACK_ACTION_FORWARD; + u8 dropped = 0; + + if (PREDICT_FALSE (rx == tx && action == SONIC_EXT_LOOPBACK_ACTION_DROP)) + { + next[0] = IP4_LOOPBACK_NEXT_DROP; + b[0]->error = node->errors[IP4_LOOPBACK_ERROR_HAIRPIN_DROP]; + vlib_increment_simple_counter ( + vnm->interface_main.sw_if_counters + VNET_INTERFACE_COUNTER_TX_ERROR, + thread_index, tx, 1); + dropped = 1; + } + else + { + u32 fnext = 0; + vnet_feature_next (&fnext, b[0]); + next[0] = (u16) fnext; + } + + if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) && + (b[0]->flags & VLIB_BUFFER_IS_TRACED))) + { + ip4_loopback_trace_t *t = vlib_add_trace (vm, node, b[0], sizeof (*t)); + t->rx_sw_if_index = rx; + t->tx_sw_if_index = tx; + t->next_index = next[0]; + t->dropped = dropped; + } + + b += 1; + next += 1; + n_left_from -= 1; + } + + vlib_buffer_enqueue_to_next (vm, node, from, nexts, frame->n_vectors); + + return frame->n_vectors; +} + +VLIB_REGISTER_NODE (sonic_ext_ip4_loopback_node) = { + .name = "sonic-ext-ip4-loopback", + .vector_size = sizeof (u32), + .format_trace = format_ip4_loopback_trace, + .type = VLIB_NODE_TYPE_INTERNAL, + .n_errors = ARRAY_LEN (ip4_loopback_error_strings), + .error_strings = ip4_loopback_error_strings, + .n_next_nodes = IP4_LOOPBACK_N_NEXT, + .next_nodes = { + [IP4_LOOPBACK_NEXT_DROP] = "error-drop", + [IP4_LOOPBACK_NEXT_INTERFACE_OUTPUT] = "interface-output", + }, +}; + +VNET_FEATURE_INIT (sonic_ext_ip4_loopback_feat, static) = { + .arc_name = "ip4-output", + .node_name = "sonic-ext-ip4-loopback", + .runs_before = VNET_FEATURES ("interface-output"), +}; diff --git a/vppbld/plugins/sonic_ext/ip6_loopback_node.c b/vppbld/plugins/sonic_ext/ip6_loopback_node.c new file mode 100644 index 00000000..ea8ac3b8 --- /dev/null +++ b/vppbld/plugins/sonic_ext/ip6_loopback_node.c @@ -0,0 +1,145 @@ +/* + * Copyright (c) 2026 SONiC-VPP contributors + * 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 +#include +#include +#include +#include + +typedef struct +{ + u32 rx_sw_if_index; + u32 tx_sw_if_index; + u32 next_index; + u8 dropped; +} ip6_loopback_trace_t; + +static u8 * +format_ip6_loopback_trace (u8 *s, va_list *args) +{ + CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *); + CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *); + ip6_loopback_trace_t *t = va_arg (*args, ip6_loopback_trace_t *); + + s = format (s, "SONIC-EXT-IP6-LOOPBACK: rx %d tx %d next %d %s", + t->rx_sw_if_index, t->tx_sw_if_index, t->next_index, + t->dropped ? "(hairpin-drop)" : ""); + return s; +} + +#define foreach_ip6_loopback_error _ (HAIRPIN_DROP, "hairpin packets dropped") + +typedef enum +{ +#define _(sym, str) IP6_LOOPBACK_ERROR_##sym, + foreach_ip6_loopback_error +#undef _ + IP6_LOOPBACK_N_ERROR, +} ip6_loopback_error_t; + +static char *ip6_loopback_error_strings[] = { +#define _(sym, string) string, + foreach_ip6_loopback_error +#undef _ +}; + +typedef enum +{ + IP6_LOOPBACK_NEXT_DROP, + IP6_LOOPBACK_NEXT_INTERFACE_OUTPUT, + IP6_LOOPBACK_N_NEXT, +} ip6_loopback_next_t; + +VLIB_NODE_FN (sonic_ext_ip6_loopback_node) +(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame) +{ + sonic_ext_main_t *sem = &sonic_ext_main; + vnet_main_t *vnm = vnet_get_main (); + u32 thread_index = vm->thread_index; + u32 n_left_from, *from; + vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b; + u16 nexts[VLIB_FRAME_SIZE], *next; + + from = vlib_frame_vector_args (frame); + n_left_from = frame->n_vectors; + + vlib_get_buffers (vm, from, bufs, n_left_from); + b = bufs; + next = nexts; + + while (n_left_from > 0) + { + u32 rx = vnet_buffer (b[0])->sw_if_index[VLIB_RX]; + u32 tx = vnet_buffer (b[0])->sw_if_index[VLIB_TX]; + u8 action = (tx < vec_len (sem->loopback_action_by_sw_if_index)) + ? sem->loopback_action_by_sw_if_index[tx] + : SONIC_EXT_LOOPBACK_ACTION_FORWARD; + u8 dropped = 0; + + if (PREDICT_FALSE (rx == tx && action == SONIC_EXT_LOOPBACK_ACTION_DROP)) + { + next[0] = IP6_LOOPBACK_NEXT_DROP; + b[0]->error = node->errors[IP6_LOOPBACK_ERROR_HAIRPIN_DROP]; + vlib_increment_simple_counter ( + vnm->interface_main.sw_if_counters + VNET_INTERFACE_COUNTER_TX_ERROR, + thread_index, tx, 1); + dropped = 1; + } + else + { + u32 fnext = 0; + vnet_feature_next (&fnext, b[0]); + next[0] = (u16) fnext; + } + + if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) && + (b[0]->flags & VLIB_BUFFER_IS_TRACED))) + { + ip6_loopback_trace_t *t = vlib_add_trace (vm, node, b[0], sizeof (*t)); + t->rx_sw_if_index = rx; + t->tx_sw_if_index = tx; + t->next_index = next[0]; + t->dropped = dropped; + } + + b += 1; + next += 1; + n_left_from -= 1; + } + + vlib_buffer_enqueue_to_next (vm, node, from, nexts, frame->n_vectors); + + return frame->n_vectors; +} + +VLIB_REGISTER_NODE (sonic_ext_ip6_loopback_node) = { + .name = "sonic-ext-ip6-loopback", + .vector_size = sizeof (u32), + .format_trace = format_ip6_loopback_trace, + .type = VLIB_NODE_TYPE_INTERNAL, + .n_errors = ARRAY_LEN (ip6_loopback_error_strings), + .error_strings = ip6_loopback_error_strings, + .n_next_nodes = IP6_LOOPBACK_N_NEXT, + .next_nodes = { + [IP6_LOOPBACK_NEXT_DROP] = "error-drop", + [IP6_LOOPBACK_NEXT_INTERFACE_OUTPUT] = "interface-output", + }, +}; + +VNET_FEATURE_INIT (sonic_ext_ip6_loopback_feat, static) = { + .arc_name = "ip6-output", + .node_name = "sonic-ext-ip6-loopback", + .runs_before = VNET_FEATURES ("interface-output"), +}; diff --git a/vppbld/plugins/sonic_ext/sonic_ext.api b/vppbld/plugins/sonic_ext/sonic_ext.api new file mode 100644 index 00000000..55b79a4d --- /dev/null +++ b/vppbld/plugins/sonic_ext/sonic_ext.api @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2026 SONiC-VPP contributors + * 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. + */ + +option version = "1.0.0"; +import "vnet/interface_types.api"; + +/** \brief Set the loopback (hairpin) packet action on a router interface + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param sw_if_index - the interface the action applies to + @param action - 0 = FORWARD (default), 1 = DROP + + When action is DROP, a routed packet whose ingress interface equals its + egress interface (a hairpin) is dropped on the ip4-output / ip6-output arc + and the interface tx-error counter is incremented. The node is enabled on + the interface's output arcs only while the action is DROP. +*/ +autoreply define iface_loopback_set_action +{ + u32 client_index; + u32 context; + vl_api_interface_index_t sw_if_index; + u8 action; +}; diff --git a/vppbld/plugins/sonic_ext/sonic_ext.c b/vppbld/plugins/sonic_ext/sonic_ext.c index 53b7e127..c92b02ef 100644 --- a/vppbld/plugins/sonic_ext/sonic_ext.c +++ b/vppbld/plugins/sonic_ext/sonic_ext.c @@ -23,6 +23,15 @@ #include #include +#include +#include + +#include +#include + +#define REPLY_MSG_ID_BASE sonic_ext_main.msg_id_base +#include + sonic_ext_main_t sonic_ext_main; VLIB_PLUGIN_REGISTER () = { @@ -202,6 +211,16 @@ sonic_ext_set_host_xc (u8 is_enable) static clib_error_t * sonic_ext_sw_interface_add_del (vnet_main_t *vnm, u32 sw_if_index, u32 is_add) { + sonic_ext_main_t *sem = &sonic_ext_main; + + /* On interface delete, reset the loopback action so a recycled sw_if_index + * does not inherit a stale DROP. The output-arc features are torn down by + * VPP. */ + if (!is_add + && sw_if_index < vec_len (sem->loopback_action_by_sw_if_index)) + sem->loopback_action_by_sw_if_index[sw_if_index] = + SONIC_EXT_LOOPBACK_ACTION_FORWARD; + return 0; } @@ -255,6 +274,75 @@ sonic_ext_lcp_pair_del_cb (lcp_itf_pair_t *lip) sonic_ext_aggr_tap_redirect_enable_disable (lip->lip_host_sw_if_index, 0); } +int +sonic_ext_iface_loopback_set_action (u32 sw_if_index, u8 action) +{ + sonic_ext_main_t *sem = &sonic_ext_main; + int enable = (action == SONIC_EXT_LOOPBACK_ACTION_DROP); + u8 prev; + int rv; + + /* loopback_action_by_sw_if_index is written only here, from the main/API + * thread. The ip4/ip6-loopback nodes read it on worker threads, but + * vnet_feature_enable_disable() below performs a worker barrier sync, so the + * vector growth/update is visible before the feature (and thus the node) is + * enabled on this interface. */ + vec_validate_init_empty (sem->loopback_action_by_sw_if_index, sw_if_index, + SONIC_EXT_LOOPBACK_ACTION_FORWARD); + prev = sem->loopback_action_by_sw_if_index[sw_if_index]; + + /* Idempotent: VPP feature enable/disable is ref-counted, so a repeated SET to + * the same action (e.g. a SAI attribute replay) would enable the output-arc + * feature more than once and a single later disable would leave the drop node + * installed. Only toggle the arcs on an actual FORWARD<->DROP transition. */ + if (prev == action) + return 0; + + /* Set the action before enabling so the node sees DROP the moment the arc is + * live; on DROP->FORWARD the node keeps forwarding until it is disabled. */ + sem->loopback_action_by_sw_if_index[sw_if_index] = action; + + rv = vnet_feature_enable_disable ("ip4-output", "sonic-ext-ip4-loopback", + sw_if_index, enable, 0, 0); + if (rv) + { + sem->loopback_action_by_sw_if_index[sw_if_index] = prev; + return rv; + } + + rv = vnet_feature_enable_disable ("ip6-output", "sonic-ext-ip6-loopback", + sw_if_index, enable, 0, 0); + if (rv) + { + /* Roll back the ip4 arc and the stored action to avoid a half-enabled + * state. */ + vnet_feature_enable_disable ("ip4-output", "sonic-ext-ip4-loopback", + sw_if_index, !enable, 0, 0); + sem->loopback_action_by_sw_if_index[sw_if_index] = prev; + } + + return rv; +} + +static void +vl_api_iface_loopback_set_action_t_handler ( + vl_api_iface_loopback_set_action_t *mp) +{ + vl_api_iface_loopback_set_action_reply_t *rmp; + int rv = 0; + u32 sw_if_index = ntohl (mp->sw_if_index); + + VALIDATE_SW_IF_INDEX (mp); + + rv = sonic_ext_iface_loopback_set_action (sw_if_index, mp->action); + + BAD_SW_IF_INDEX_LABEL; + REPLY_MACRO (VL_API_IFACE_LOOPBACK_SET_ACTION_REPLY); +} + +/* API definitions */ +#include + static clib_error_t * sonic_ext_init (vlib_main_t *vm) { @@ -264,6 +352,7 @@ sonic_ext_init (vlib_main_t *vm) .pair_del_fn = sonic_ext_lcp_pair_del_cb, }; clib_memset (sem, 0, sizeof (*sem)); + sem->msg_id_base = setup_message_id_table (); lcp_itf_pair_register_vft (&sonic_ext_lcp_vft); /* Default-on: capture + aggr-tap-redirect (punt-via-member) and diff --git a/vppbld/plugins/sonic_ext/sonic_ext.h b/vppbld/plugins/sonic_ext/sonic_ext.h index b35a02ff..48aee227 100644 --- a/vppbld/plugins/sonic_ext/sonic_ext.h +++ b/vppbld/plugins/sonic_ext/sonic_ext.h @@ -25,6 +25,10 @@ #define SONIC_EXT_PLUGIN_BUILD_VER "1.0" +/* Router-interface loopback (hairpin) packet action values. */ +#define SONIC_EXT_LOOPBACK_ACTION_FORWARD 0 +#define SONIC_EXT_LOOPBACK_ACTION_DROP 1 + /* * Per-buffer metadata stash, overlaid on vnet_buffer2(b)->unused[]. * @@ -114,6 +118,14 @@ typedef struct u64 aggr_tap_redirects; u64 host_xc_direct; u64 l2_trap_fixups; + + /* Binary API message-id base (registered in sonic_ext_init). */ + u16 msg_id_base; + + /* Per-sw_if_index RIF loopback action, SONIC_EXT_LOOPBACK_ACTION_* + * (default FORWARD). Written only from the main/API thread; read by the + * ip4/ip6-loopback output-arc nodes on worker threads. */ + u8 *loopback_action_by_sw_if_index; } sonic_ext_main_t; extern sonic_ext_main_t sonic_ext_main; @@ -122,6 +134,12 @@ extern vlib_node_registration_t sonic_ext_capture_node; extern vlib_node_registration_t sonic_ext_aggr_tap_redirect_node; extern vlib_node_registration_t sonic_ext_host_xc_node; extern vlib_node_registration_t sonic_ext_l2_trap_fixup_node; +extern vlib_node_registration_t sonic_ext_ip4_loopback_node; +extern vlib_node_registration_t sonic_ext_ip6_loopback_node; + +/* Set the per-interface RIF loopback (hairpin) action and enable/disable the + * ip4-output / ip6-output arc nodes accordingly. Returns 0 on success. */ +int sonic_ext_iface_loopback_set_action (u32 sw_if_index, u8 action); /* Enable / disable sonic-ext-capture on a given interface. No-op if * the capture sidecar is not yet initialized. */ From 004ee0a288c574a0c68bf59e3d4153504b79f4f8 Mon Sep 17 00:00:00 2001 From: Aaron Bernardino Date: Tue, 21 Jul 2026 11:51:09 +0000 Subject: [PATCH 2/3] [vpp] Bump VPP_VERSION to 2606-0.5 after merging sflow patch series Merging upstream/master brought in the sflow VPP patches (0012-0014), changing vppbld/patches/series on this branch. Per the VPP_VERSION convention, bump the minor suffix (0.4 -> 0.5) so CI rebuilds the VPP and sonic_ext plugin debs against the new series instead of reusing a stale cached 0.4 deb that predates the sflow patches. Part of sonic-net/sonic-buildimage#25788. Signed-off-by: Aaron Bernardino --- rules/vpp.mk | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rules/vpp.mk b/rules/vpp.mk index 3a3033d2..3fe92aa0 100644 --- a/rules/vpp.mk +++ b/rules/vpp.mk @@ -8,7 +8,7 @@ VPP_VERSION_BASE = 2606 # https://packages.buildkite.com/sonic-vpp/vpp; if the suffix isn't bumped, # downstream sonic-buildimage builds will silently pull stale debs that # pre-date the new patch series and end up with VPP/SAI CRC drift. -VPP_VERSION = $(VPP_VERSION_BASE)-0.4 +VPP_VERSION = $(VPP_VERSION_BASE)-0.5 VPP_VERSION_SONIC = $(VPP_VERSION)+b1sonic1 VPP_SRC_PATH = platform/vpp/vppbld From 4d3ebef379131158b8898724768f608b5f99dd3c Mon Sep 17 00:00:00 2001 From: Aaron Bernardino Date: Tue, 28 Jul 2026 16:59:20 +0000 Subject: [PATCH 3/3] [vpp] Bump VPP_VERSION to 2606-0.8 after merging updated sflow patch 0012 Merging upstream/master pulled the sflow phase-three change to 0012-sflow-per-port-sample-rate.patch. Since the patch series content changed, bump the VPP_VERSION suffix so CI does not reuse a stale cached .deb keyed on the old 0.5 content. 0.6 and 0.7 are in use by the VXLAN branches, so 0.8 is the next free suffix. Signed-off-by: Aaron Bernardino --- rules/vpp.mk | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rules/vpp.mk b/rules/vpp.mk index 3fe92aa0..54d5a31d 100644 --- a/rules/vpp.mk +++ b/rules/vpp.mk @@ -8,7 +8,7 @@ VPP_VERSION_BASE = 2606 # https://packages.buildkite.com/sonic-vpp/vpp; if the suffix isn't bumped, # downstream sonic-buildimage builds will silently pull stale debs that # pre-date the new patch series and end up with VPP/SAI CRC drift. -VPP_VERSION = $(VPP_VERSION_BASE)-0.5 +VPP_VERSION = $(VPP_VERSION_BASE)-0.8 VPP_VERSION_SONIC = $(VPP_VERSION)+b1sonic1 VPP_SRC_PATH = platform/vpp/vppbld