On 3 Nov 2026, at 15:38, Numan via dev wrote:
> From: Loke Berne <[email protected]>
>
> The tc flow dump translates each tc flower rule into odp actions inside a
> fixed-size OFPBUF_STACK buffer of ODPUTIL_FLOW_KEY_BYTES. Unlike the key
> and the mask, the actions have no such bound: a single flower rule can
> carry up to TCA_ACT_MAX_PRIO actions, and a tunnel_push plus output pair
> alone takes about 100 bytes. When a rule does not fit, ofpbuf_resize__()
> hits OVS_NOT_REACHED() and ovs-vswitchd aborts.
>
> This was hit in production with flood rules that output to many remote
> tunnel endpoints. Every non-terse "ovs-appctl dpctl/dump-flows" (every
> type= except "ovs") walks this path, so a monitoring agent polling the
> flows crash-looped ovs-vswitchd on each poll. Revalidators use terse
> dumps and are not affected.
>
> Use a stub buffer per batch slot instead, so the actions grow onto the
> heap when needed. The stub is set up once per dump thread and a grown
> slot keeps its heap buffer for the lifetime of the thread, which is safe
> because parse_tc_flower_to_match() clears the buffer before writing to
> it. tc_parse_flow_get() has the same problem with its 1024-byte buffer
> and is fixed the same way.
>
> The added test sends a flow to four Geneve tunnels with a 124-byte
> option each, which dumps back as about 750 bytes of odp actions, and
> dumps it with type=tc. Without the fix ovs-vswitchd aborts on the dump.
>
> CC: Paul Blakey <[email protected]>
> Fixes: f2280b419860 ("dpif-netlink: Dump netdevs flows on flow dump")
> Assisted-by: Claude Fable 5.1, Claude Code
> Signed-off-by: Loke Berne <[email protected]>
Hi Numan/Loke,
Thanks for finding and fixing this issue. See my comments below.
//Eelco
> ---
> lib/dpif-offload-tc.c | 25 ++++++++++++---
> tests/system-offloads-traffic.at | 52 ++++++++++++++++++++++++++++++++
> 2 files changed, 72 insertions(+), 5 deletions(-)
>
> diff --git a/lib/dpif-offload-tc.c b/lib/dpif-offload-tc.c
> index 3b84d9f20..60822c1d8 100644
> --- a/lib/dpif-offload-tc.c
> +++ b/lib/dpif-offload-tc.c
> @@ -62,7 +62,13 @@ struct tc_flow_dump_thread {
> struct ofpbuf nl_flows;
> struct odputil_keybuf keybuf[FLOW_DUMP_MAX_BATCH];
> struct odputil_keybuf maskbuf[FLOW_DUMP_MAX_BATCH];
> + /* Actions have no upper bound comparable to ODPUTIL_FLOW_KEY_BYTES: a
> + * single tc flower rule may carry up to TCA_ACT_MAX_PRIO actions, each
> + * translating into a tunnel push, a masked set, a ct or an output. The
> + * fixed-size 'actbuf' is therefore only a stub; 'act' grows onto the
> + * heap when a flow does not fit. */
Please remove the comment; it does not add any value.
> struct odputil_keybuf actbuf[FLOW_DUMP_MAX_BATCH];
> + struct ofpbuf act[FLOW_DUMP_MAX_BATCH];
Maybe we should rename it as follows, to stay in line with other code:
struct odputil_keybuf actbuf_stub[FLOW_DUMP_MAX_BATCH];
struct ofpbuf actbuf[FLOW_DUMP_MAX_BATCH];
> };
>
> static struct tc_offload *
> @@ -413,13 +419,13 @@ tc_flow_dump_next(struct dpif_offload_flow_dump_thread
> *thread_,
> while (!thread->netdev_dump_done && n_flows < max_flows) {
> struct odputil_keybuf *maskbuf = &thread->maskbuf[n_flows];
> struct odputil_keybuf *keybuf = &thread->keybuf[n_flows];
> - struct odputil_keybuf *actbuf = &thread->actbuf[n_flows];
> struct netdev_tc_flow_dump *netdev_dump;
> struct dpif_flow *f = &flows[n_flows];
> int cur = thread->netdev_dump_index;
> - struct ofpbuf key, mask, act;
> + struct ofpbuf *act = &thread->act[n_flows];
Move this up to keep reverse Christmas tree aligned.
> struct dpif_flow_stats stats;
> struct dpif_flow_attrs attrs;
> + struct ofpbuf key, mask;
> struct nlattr *actions;
> struct match match;
> ovs_u128 ufid;
> @@ -427,11 +433,10 @@ tc_flow_dump_next(struct dpif_offload_flow_dump_thread
> *thread_,
>
> netdev_dump = thread->dump->netdev_dumps[cur];
> ofpbuf_use_stack(&key, keybuf, sizeof *keybuf);
> - ofpbuf_use_stack(&act, actbuf, sizeof *actbuf);
> ofpbuf_use_stack(&mask, maskbuf, sizeof *maskbuf);
I would explicitly clear the buffer here (although it's done later), i.e.
ofpbuf_clear(act);
> has_next = tc_netdev_flow_dump_next(netdev_dump, &match, &actions,
> &stats, &attrs, &ufid,
> - &thread->nl_flows, &act);
> + &thread->nl_flows, act);
> if (has_next) {
> tc_match_to_dpif_flow(&match, &key, &mask, actions, &stats,
> &attrs, &ufid, f,
> thread->dump->dump.terse);
> @@ -473,6 +478,10 @@ tc_flow_dump_thread_create(struct dpif_offload_flow_dump
> *dump)
> thread->netdev_dump_index = 0;
> thread->netdev_dump_done = !thread->dump->netdev_dump_count;
> ofpbuf_init(&thread->nl_flows, NL_DUMP_BUFSIZE);
> + for (int i = 0; i < FLOW_DUMP_MAX_BATCH; i++) {
> + ofpbuf_use_stub(&thread->act[i], &thread->actbuf[i],
> + sizeof thread->actbuf[i]);
> + }
> return &thread->thread;
> }
>
> @@ -481,6 +490,9 @@ tc_flow_dump_thread_destroy(struct
> dpif_offload_flow_dump_thread *thread_)
> {
> struct tc_flow_dump_thread *thread = tc_flow_dump_thread_cast(thread_);
>
> + for (int i = 0; i < FLOW_DUMP_MAX_BATCH; i++) {
> + ofpbuf_uninit(&thread->act[i]);
> + }
> ofpbuf_uninit(&thread->nl_flows);
> free(thread);
> }
> @@ -628,7 +640,8 @@ tc_parse_flow_get(struct tc_offload *offload_tc, struct
> dpif_flow_get *get)
> struct ofpbuf buf;
> int err = ENOENT;
>
> - ofpbuf_use_stack(&buf, &act_buf, sizeof act_buf);
> + /* Stub, not stack: the translated actions may exceed 'act_buf'. */
No need for comments like this.
> + ofpbuf_use_stub(&buf, &act_buf, sizeof act_buf);
>
> DPIF_OFFLOAD_PORT_FOR_EACH (port, &offload_tc->offload) {
> if (!tc_netdev_flow_get(port->netdev, &match, &actions, get->ufid,
> @@ -639,6 +652,7 @@ tc_parse_flow_get(struct tc_offload *offload_tc, struct
> dpif_flow_get *get)
> }
>
> if (err) {
> + ofpbuf_uninit(&buf);
Maybe use a goto out here, and return err below. This avoids multiple
ofpbuf_uninit() calls.
> return err;
> }
>
> @@ -652,6 +666,7 @@ tc_parse_flow_get(struct tc_offload *offload_tc, struct
> dpif_flow_get *get)
> ofpbuf_put(get->buffer, nl_attr_get(actions), nl_attr_get_size(actions));
> dpif_flow->actions = ofpbuf_at(get->buffer, 0, 0);
> dpif_flow->actions_len = nl_attr_get_size(actions);
> + ofpbuf_uninit(&buf);
>
out:
return err;
> return 0;
> }
> diff --git a/tests/system-offloads-traffic.at
> b/tests/system-offloads-traffic.at
> index cfcc5bd6c..44f0c840d 100644
> --- a/tests/system-offloads-traffic.at
> +++ b/tests/system-offloads-traffic.at
> @@ -1285,3 +1285,55 @@ m4_for([id], [2], [17], [1], [
>
> OVS_TRAFFIC_VSWITCHD_STOP
> AT_CLEANUP
> +
> +AT_SETUP([offloads - dump flow with large actions])
> +OVS_CHECK_GENEVE()
> +OVS_TRAFFIC_VSWITCHD_START([], [],
> + [-- set Open_vSwitch . other_config:hw-offload=true])
New line.
> +AT_CHECK([ovs-appctl vlog/set tc:file:dbg dpif_offload_tc:file:dbg])
Maybe add a general comment here, and remove all the other comments?
dnl Send traffic from p1 to four Geneve tunnels, each carrying a 124-byte
dnl option. The resulting odp actions exceed the 640-byte
dnl ODPUTIL_FLOW_KEY_BYTES buffer that the dump path used to allocate on
dnl the stack. A static ARP entry is needed because nothing answers for
dnl 10.1.1.2; without it the kernel never sends IP packets.
> +ADD_BR([br-underlay])
> +AT_CHECK([ovs-ofctl add-flow br-underlay "actions=normal"])
> +
> +ADD_NAMESPACES(at_ns0, at_ns1)
> +
> +dnl Underlay: the namespace side owns the four remote tunnel endpoints.
Remove comments here and below.
> +ADD_VETH(p0, at_ns0, br-underlay, "172.31.1.1/24")
> +m4_for([id], [2], [4], [1], [
> + NS_CHECK_EXEC([at_ns0], [ip addr add 172.31.1.id/24 dev p0])
> +])
> +AT_CHECK([ip addr add dev br-underlay "172.31.1.100/24"])
> +AT_CHECK([ip link set dev br-underlay up])
> +
> +m4_for([id], [1], [4], [1], [
> + AT_CHECK([ovs-vsctl add-port br0 at_gnv[]id -- \
> + set int at_gnv[]id type=geneve options:remote_ip=172.31.1.id \
> + options:key=id])
> +])
> +
> +dnl Overlay source. Nothing answers for 10.1.1.2, so resolve it statically.
> +ADD_VETH(p1, at_ns1, br0, "10.1.1.1/24")
> +NS_CHECK_EXEC([at_ns1], [ip neigh replace 10.1.1.2 lladdr 02:00:00:00:00:02
> dev p1])
Split the line
NS_CHECK_EXEC([at_ns1],
[ip neigh replace 10.1.1.2 lladdr 02:00:00:00:00:02 dev p1])
> +
> +dnl Send every packet from p1 to the four tunnels with a 124-byte Geneve
> +dnl option. That is only 8 tc actions (tunnel_key set + mirred per output),
> +dnl but each output dumps back as set(tunnel(...geneve(...))) + output, about
> +dnl 190 bytes, so the odp actions of the flow are over 750 bytes. The dump
> +dnl used to parse them into an ODPUTIL_FLOW_KEY_BYTES (640) sized stack
> +dnl buffer and abort on overflow.
> +AT_CHECK([ovs-ofctl add-tlv-map br0
> "{class=0xffff,type=0,len=124}->tun_metadata0"])
> +AT_CHECK([ovs-ofctl add-flow br0
> "priority=10,in_port=ovs-p1,ip,actions=set_field:0x1234->tun_metadata0,output:at_gnv1,output:at_gnv2,output:at_gnv3,output:at_gnv4"])
> +
> +dnl No reply is expected, the copies go out through the tunnels.
> +NS_CHECK_EXEC([at_ns1], [ping -q -c 3 -i 0.3 -W 1 10.1.1.2], [ignore],
> [ignore])
> +AT_CHECK([ovs-appctl revalidator/wait])
> +
> +AT_CHECK([ovs-appctl dpctl/dump-flows --names type=tc], [0], [stdout])
> +AT_CHECK([grep "in_port(ovs-p1)" stdout | grep "eth_type(0x0800)" | head -1
> | \
> + grep -o "set[[(]]tunnel[[(]]" | wc -l], [0], [dnl
> +4
> +])
> +AT_CHECK([grep "in_port(ovs-p1)" stdout | grep -q
> "geneve[[(]][[{]]class=0xffff,type=0,len=124,"])
Split the line;
AT_CHECK([grep "in_port(ovs-p1)" stdout | \
grep -q "geneve[[(]][[{]]class=0xffff,type=0,len=124,"])
> +OVS_TRAFFIC_VSWITCHD_STOP
> +AT_CLEANUP
_______________________________________________
dev mailing list
[email protected]
https://mail.openvswitch.org/mailman/listinfo/ovs-dev