Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-12 23:23:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

net: rtnetlink: Stop assuming that IFLA_OFFLOAD_XSTATS_* are dev-backed

Browse Source 
The IFLA_STATS_LINK_OFFLOAD_XSTATS attribute is a nest whose child
attributes carry various special hardware statistics. The code that handles
this nest was written with the idea that all these statistics would be
exposed by the device driver of a physical netdevice.

In the following patches, a new attribute is added to the abovementioned
nest, which however can be defined for some soft netdevices. The NDO-based
approach to querying these does not work, because it is not the soft
netdevice driver that exposes these statistics, but an offloading NIC
driver that does so.

The current code does not scale well to this usage. Simply rewrite it back
to the pattern seen in other fill-like and get_size-like functions
elsewhere.

Extract to helpers the code that is concerned with handling specifically
NDO-backed statistics so that it can be easily reused should more such
statistics be added.

Signed-off-by: Petr Machata <petrm@nvidia.com>
Signed-off-by: Ido Schimmel <idosch@nvidia.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
Petr Machata 2022-03-02 18:31:16 +02:00 committed by David S. Miller
parent 6b524a1d01
commit f6e0fb8129
1 changed files with 52 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

107
net/core/rtnetlink.c
View File

@ -5048,13 +5048,45 @@ static bool stats_attr_valid(unsigned int mask, int attrid, int idxattr)
(!idxattr || idxattr == attrid);
}
#define IFLA_OFFLOAD_XSTATS_FIRST (IFLA_OFFLOAD_XSTATS_UNSPEC + 1)
static int rtnl_get_offload_stats_attr_size(int attr_id)
static bool
rtnl_offload_xstats_have_ndo(const struct net_device *dev, int attr_id)
{
switch (attr_id) {
case IFLA_OFFLOAD_XSTATS_CPU_HIT:
return sizeof(struct rtnl_link_stats64);
}
return dev->netdev_ops &&
dev->netdev_ops->ndo_has_offload_stats &&
dev->netdev_ops->ndo_get_offload_stats &&
dev->netdev_ops->ndo_has_offload_stats(dev, attr_id);
}
static unsigned int
rtnl_offload_xstats_get_size_ndo(const struct net_device *dev, int attr_id)
{
return rtnl_offload_xstats_have_ndo(dev, attr_id) ?
sizeof(struct rtnl_link_stats64) : 0;
}
static int
rtnl_offload_xstats_fill_ndo(struct net_device *dev, int attr_id,
struct sk_buff *skb)
{
unsigned int size = rtnl_offload_xstats_get_size_ndo(dev, attr_id);
struct nlattr *attr = NULL;
void *attr_data;
int err;
if (!size)
return -ENODATA;
attr = nla_reserve_64bit(skb, attr_id, size,
IFLA_OFFLOAD_XSTATS_UNSPEC);
if (!attr)
return -EMSGSIZE;
attr_data = nla_data(attr);
memset(attr_data, 0, size);
err = dev->netdev_ops->ndo_get_offload_stats(attr_id, dev, attr_data);
if (err)
return err;
return 0;
}
@ -5062,70 +5094,35 @@ static int rtnl_get_offload_stats_attr_size(int attr_id)
static int rtnl_offload_xstats_fill(struct sk_buff *skb, struct net_device *dev,
int *prividx)
{
struct nlattr *attr = NULL;
int attr_id, size;
void *attr_data;
int attr_id_cpu_hit = IFLA_OFFLOAD_XSTATS_CPU_HIT;
bool have_data = false;
int err;
if (!(dev->netdev_ops && dev->netdev_ops->ndo_has_offload_stats &&
dev->netdev_ops->ndo_get_offload_stats))
return -ENODATA;
for (attr_id = IFLA_OFFLOAD_XSTATS_FIRST;
attr_id <= IFLA_OFFLOAD_XSTATS_MAX; attr_id++) {
if (attr_id < *prividx)
continue;
size = rtnl_get_offload_stats_attr_size(attr_id);
if (!size)
continue;
if (!dev->netdev_ops->ndo_has_offload_stats(dev, attr_id))
continue;
attr = nla_reserve_64bit(skb, attr_id, size,
IFLA_OFFLOAD_XSTATS_UNSPEC);
if (!attr)
goto nla_put_failure;
attr_data = nla_data(attr);
memset(attr_data, 0, size);
err = dev->netdev_ops->ndo_get_offload_stats(attr_id, dev,
attr_data);
if (err)
goto get_offload_stats_failure;
if (*prividx <= attr_id_cpu_hit) {
err = rtnl_offload_xstats_fill_ndo(dev, attr_id_cpu_hit, skb);
if (!err) {
have_data = true;
} else if (err != -ENODATA) {
*prividx = attr_id_cpu_hit;
return err;
}
}
if (!attr)
if (!have_data)
return -ENODATA;
*prividx = 0;
return 0;
nla_put_failure:
err = -EMSGSIZE;
get_offload_stats_failure:
*prividx = attr_id;
return err;
}
static int rtnl_offload_xstats_get_size(const struct net_device *dev)
{
int attr_id_cpu_hit = IFLA_OFFLOAD_XSTATS_CPU_HIT;
int nla_size = 0;
int attr_id;
int size;
if (!(dev->netdev_ops && dev->netdev_ops->ndo_has_offload_stats &&
dev->netdev_ops->ndo_get_offload_stats))
return 0;
for (attr_id = IFLA_OFFLOAD_XSTATS_FIRST;
attr_id <= IFLA_OFFLOAD_XSTATS_MAX; attr_id++) {
if (!dev->netdev_ops->ndo_has_offload_stats(dev, attr_id))
continue;
size = rtnl_get_offload_stats_attr_size(attr_id);
nla_size += nla_total_size_64bit(size);
}
size = rtnl_offload_xstats_get_size_ndo(dev, attr_id_cpu_hit);
nla_size += nla_total_size_64bit(size);
if (nla_size != 0)
nla_size += nla_total_size(0);