[PATCH net v5 3/5] net: qualcomm: rmnet: Fix MTU underflow and clamp to the maximum packet size

From: Subash Abhinov Kasiviswanathan

Date: Tue Nov 17 2026 - 01:09:16 EST


The MTU helpers subtract the egress headroom from the real device MTU
using unsigned arithmetic. A real device MTU smaller than the headroom
underflows and results in a huge target MTU instead of an error.

Additionally, a real device with a jumbo MTU makes the creation of the
first rmnet device fail since the unclamped value exceeds
RMNET_MAX_PACKET_SIZE, while resizing an existing device clamps it.

Add a helper which computes the largest MTU usable on top of the real
device for a data format, rejects real device MTUs below the headroom
before doing any arithmetic and clamps the result to
RMNET_MAX_PACKET_SIZE. Use it for both new and existing devices and add
the same underflow check to the other helpers.

Fixes: b7f5eb6ba21b ("net: qualcomm: rmnet: Update rmnet device MTU based on real device")
Co-developed-by: Sean Tranchetti <sean.tranchetti@xxxxxxxxxxxxxxxx>
Signed-off-by: Sean Tranchetti <sean.tranchetti@xxxxxxxxxxxxxxxx>
Signed-off-by: Subash Abhinov Kasiviswanathan <subash.a.kasiviswanathan@xxxxxxxxxxxxxxxx>
---
.../net/ethernet/qualcomm/rmnet/rmnet_vnd.c | 58 +++++++++++++------
1 file changed, 41 insertions(+), 17 deletions(-)

diff --git a/drivers/net/ethernet/qualcomm/rmnet/rmnet_vnd.c b/drivers/net/ethernet/qualcomm/rmnet/rmnet_vnd.c
index 984c66bee863..2f3fefe58bce 100644
--- a/drivers/net/ethernet/qualcomm/rmnet/rmnet_vnd.c
+++ b/drivers/net/ethernet/qualcomm/rmnet/rmnet_vnd.c
@@ -80,6 +80,20 @@ static int rmnet_vnd_headroom(u32 data_format)
return headroom;
}

+/* Largest MTU an rmnet device can use on top of real_dev for the given data
+ * format, or -EINVAL if real_dev cannot even fit the headers.
+ */
+static int rmnet_vnd_target_mtu(struct net_device *real_dev, u32 data_format)
+{
+ u32 headroom;
+
+ headroom = rmnet_vnd_headroom(data_format);
+ if (real_dev->mtu < headroom)
+ return -EINVAL;
+
+ return min_t(int, real_dev->mtu - headroom, RMNET_MAX_PACKET_SIZE);
+}
+
static int rmnet_vnd_change_mtu_with_format(struct net_device *rmnet_dev,
int new_mtu, u32 data_format)
{
@@ -88,7 +102,8 @@ static int rmnet_vnd_change_mtu_with_format(struct net_device *rmnet_dev,

headroom = rmnet_vnd_headroom(data_format);

- if (new_mtu < 0 || new_mtu > RMNET_MAX_PACKET_SIZE ||
+ if (priv->real_dev->mtu < headroom ||
+ new_mtu < 0 || new_mtu > RMNET_MAX_PACKET_SIZE ||
new_mtu > (priv->real_dev->mtu - headroom))
return -EINVAL;

@@ -322,7 +337,7 @@ int rmnet_vnd_newlink(u8 id, struct net_device *rmnet_dev,
struct netlink_ext_ack *extack, u32 data_format)
{
struct rmnet_priv *priv = netdev_priv(rmnet_dev);
- u32 headroom;
+ int new_mtu;
int rc;

if (rmnet_get_endpoint(port, id)) {
@@ -336,11 +351,9 @@ int rmnet_vnd_newlink(u8 id, struct net_device *rmnet_dev,

priv->real_dev = real_dev;

- headroom = rmnet_vnd_headroom(data_format);
-
- if (rmnet_vnd_change_mtu_with_format(rmnet_dev,
- real_dev->mtu - headroom,
- data_format)) {
+ new_mtu = rmnet_vnd_target_mtu(real_dev, data_format);
+ if (new_mtu < 0 ||
+ rmnet_vnd_change_mtu_with_format(rmnet_dev, new_mtu, data_format)) {
NL_SET_ERR_MSG_MOD(extack, "Invalid MTU on real dev");
return -EINVAL;
}
@@ -387,17 +400,17 @@ int rmnet_vnd_do_flow_control(struct net_device *rmnet_dev, int enable)
return 0;
}

-int rmnet_vnd_validate_real_dev_mtu(struct net_device *real_dev)
+static int rmnet_vnd_validate_mtu(struct rmnet_port *port,
+ struct net_device *real_dev, u32 data_format)
{
struct hlist_node *tmp_ep;
struct rmnet_endpoint *ep;
- struct rmnet_port *port;
unsigned long bkt_ep;
u32 headroom;

- port = rmnet_get_port_rtnl(real_dev);
-
- headroom = rmnet_vnd_headroom(READ_ONCE(port->data_format));
+ headroom = rmnet_vnd_headroom(data_format);
+ if (real_dev->mtu < headroom)
+ return -EINVAL;

hash_for_each_safe(port->muxed_ep, bkt_ep, tmp_ep, ep, hlnode) {
if (ep->egress_dev->mtu > (real_dev->mtu - headroom))
@@ -407,22 +420,33 @@ int rmnet_vnd_validate_real_dev_mtu(struct net_device *real_dev)
return 0;
}

+int rmnet_vnd_validate_real_dev_mtu(struct net_device *real_dev)
+{
+ struct rmnet_port *port;
+
+ port = rmnet_get_port_rtnl(real_dev);
+
+ return rmnet_vnd_validate_mtu(port, real_dev,
+ READ_ONCE(port->data_format));
+}
+
int rmnet_vnd_update_dev_mtu(struct rmnet_port *port,
struct net_device *real_dev)
{
struct hlist_node *tmp_ep;
struct rmnet_endpoint *ep;
unsigned long bkt_ep;
- u32 headroom;
+ int new_mtu;

- headroom = rmnet_vnd_headroom(READ_ONCE(port->data_format));
+ new_mtu = rmnet_vnd_target_mtu(real_dev, READ_ONCE(port->data_format));
+ if (new_mtu < 0)
+ return new_mtu;

hash_for_each_safe(port->muxed_ep, bkt_ep, tmp_ep, ep, hlnode) {
- if (ep->egress_dev->mtu <= (real_dev->mtu - headroom))
+ if (ep->egress_dev->mtu <= new_mtu)
continue;

- if (rmnet_vnd_change_mtu(ep->egress_dev,
- real_dev->mtu - headroom))
+ if (rmnet_vnd_change_mtu(ep->egress_dev, new_mtu))
return -1;
}

--
2.34.1