mirror of
https://github.com/torvalds/linux.git
synced 2024-11-24 21:21:41 +00:00
74d6529b78
syzbot reported a general protection fault caused by a null pointer
dereference in coalesce_fill_reply(). The issue occurs when req_base->dev
is null, leading to an invalid memory access.
This panic occurs if dumping coalesce when no device name is specified.
Fixes: f750dfe825 ("ethtool: provide customized dim profile management")
Reported-by: syzbot+e77327e34cdc8c36b7d3@syzkaller.appspotmail.com
Closes: https://syzkaller.appspot.com/bug?extid=e77327e34cdc8c36b7d3
Signed-off-by: Heng Qi <hengqi@linux.alibaba.com>
Reviewed-by: Simon Horman <horms@kernel.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
650 lines
23 KiB
C
650 lines
23 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
|
|
#include <linux/dim.h>
|
|
#include "netlink.h"
|
|
#include "common.h"
|
|
|
|
struct coalesce_req_info {
|
|
struct ethnl_req_info base;
|
|
};
|
|
|
|
struct coalesce_reply_data {
|
|
struct ethnl_reply_data base;
|
|
struct ethtool_coalesce coalesce;
|
|
struct kernel_ethtool_coalesce kernel_coalesce;
|
|
u32 supported_params;
|
|
};
|
|
|
|
#define COALESCE_REPDATA(__reply_base) \
|
|
container_of(__reply_base, struct coalesce_reply_data, base)
|
|
|
|
#define __SUPPORTED_OFFSET ETHTOOL_A_COALESCE_RX_USECS
|
|
static u32 attr_to_mask(unsigned int attr_type)
|
|
{
|
|
return BIT(attr_type - __SUPPORTED_OFFSET);
|
|
}
|
|
|
|
/* build time check that indices in ethtool_ops::supported_coalesce_params
|
|
* match corresponding attribute types with an offset
|
|
*/
|
|
#define __CHECK_SUPPORTED_OFFSET(x) \
|
|
static_assert((ETHTOOL_ ## x) == \
|
|
BIT((ETHTOOL_A_ ## x) - __SUPPORTED_OFFSET))
|
|
__CHECK_SUPPORTED_OFFSET(COALESCE_RX_USECS);
|
|
__CHECK_SUPPORTED_OFFSET(COALESCE_RX_MAX_FRAMES);
|
|
__CHECK_SUPPORTED_OFFSET(COALESCE_RX_USECS_IRQ);
|
|
__CHECK_SUPPORTED_OFFSET(COALESCE_RX_MAX_FRAMES_IRQ);
|
|
__CHECK_SUPPORTED_OFFSET(COALESCE_TX_USECS);
|
|
__CHECK_SUPPORTED_OFFSET(COALESCE_TX_MAX_FRAMES);
|
|
__CHECK_SUPPORTED_OFFSET(COALESCE_TX_USECS_IRQ);
|
|
__CHECK_SUPPORTED_OFFSET(COALESCE_TX_MAX_FRAMES_IRQ);
|
|
__CHECK_SUPPORTED_OFFSET(COALESCE_STATS_BLOCK_USECS);
|
|
__CHECK_SUPPORTED_OFFSET(COALESCE_USE_ADAPTIVE_RX);
|
|
__CHECK_SUPPORTED_OFFSET(COALESCE_USE_ADAPTIVE_TX);
|
|
__CHECK_SUPPORTED_OFFSET(COALESCE_PKT_RATE_LOW);
|
|
__CHECK_SUPPORTED_OFFSET(COALESCE_RX_USECS_LOW);
|
|
__CHECK_SUPPORTED_OFFSET(COALESCE_RX_MAX_FRAMES_LOW);
|
|
__CHECK_SUPPORTED_OFFSET(COALESCE_TX_USECS_LOW);
|
|
__CHECK_SUPPORTED_OFFSET(COALESCE_TX_MAX_FRAMES_LOW);
|
|
__CHECK_SUPPORTED_OFFSET(COALESCE_PKT_RATE_HIGH);
|
|
__CHECK_SUPPORTED_OFFSET(COALESCE_RX_USECS_HIGH);
|
|
__CHECK_SUPPORTED_OFFSET(COALESCE_RX_MAX_FRAMES_HIGH);
|
|
__CHECK_SUPPORTED_OFFSET(COALESCE_TX_USECS_HIGH);
|
|
__CHECK_SUPPORTED_OFFSET(COALESCE_TX_MAX_FRAMES_HIGH);
|
|
__CHECK_SUPPORTED_OFFSET(COALESCE_RATE_SAMPLE_INTERVAL);
|
|
|
|
const struct nla_policy ethnl_coalesce_get_policy[] = {
|
|
[ETHTOOL_A_COALESCE_HEADER] =
|
|
NLA_POLICY_NESTED(ethnl_header_policy),
|
|
};
|
|
|
|
static int coalesce_prepare_data(const struct ethnl_req_info *req_base,
|
|
struct ethnl_reply_data *reply_base,
|
|
const struct genl_info *info)
|
|
{
|
|
struct coalesce_reply_data *data = COALESCE_REPDATA(reply_base);
|
|
struct net_device *dev = reply_base->dev;
|
|
int ret;
|
|
|
|
if (!dev->ethtool_ops->get_coalesce)
|
|
return -EOPNOTSUPP;
|
|
data->supported_params = dev->ethtool_ops->supported_coalesce_params;
|
|
ret = ethnl_ops_begin(dev);
|
|
if (ret < 0)
|
|
return ret;
|
|
ret = dev->ethtool_ops->get_coalesce(dev, &data->coalesce,
|
|
&data->kernel_coalesce,
|
|
info->extack);
|
|
ethnl_ops_complete(dev);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int coalesce_reply_size(const struct ethnl_req_info *req_base,
|
|
const struct ethnl_reply_data *reply_base)
|
|
{
|
|
int modersz = nla_total_size(0) + /* _PROFILE_IRQ_MODERATION, nest */
|
|
nla_total_size(sizeof(u32)) + /* _IRQ_MODERATION_USEC */
|
|
nla_total_size(sizeof(u32)) + /* _IRQ_MODERATION_PKTS */
|
|
nla_total_size(sizeof(u32)); /* _IRQ_MODERATION_COMPS */
|
|
|
|
int total_modersz = nla_total_size(0) + /* _{R,T}X_PROFILE, nest */
|
|
modersz * NET_DIM_PARAMS_NUM_PROFILES;
|
|
|
|
return nla_total_size(sizeof(u32)) + /* _RX_USECS */
|
|
nla_total_size(sizeof(u32)) + /* _RX_MAX_FRAMES */
|
|
nla_total_size(sizeof(u32)) + /* _RX_USECS_IRQ */
|
|
nla_total_size(sizeof(u32)) + /* _RX_MAX_FRAMES_IRQ */
|
|
nla_total_size(sizeof(u32)) + /* _TX_USECS */
|
|
nla_total_size(sizeof(u32)) + /* _TX_MAX_FRAMES */
|
|
nla_total_size(sizeof(u32)) + /* _TX_USECS_IRQ */
|
|
nla_total_size(sizeof(u32)) + /* _TX_MAX_FRAMES_IRQ */
|
|
nla_total_size(sizeof(u32)) + /* _STATS_BLOCK_USECS */
|
|
nla_total_size(sizeof(u8)) + /* _USE_ADAPTIVE_RX */
|
|
nla_total_size(sizeof(u8)) + /* _USE_ADAPTIVE_TX */
|
|
nla_total_size(sizeof(u32)) + /* _PKT_RATE_LOW */
|
|
nla_total_size(sizeof(u32)) + /* _RX_USECS_LOW */
|
|
nla_total_size(sizeof(u32)) + /* _RX_MAX_FRAMES_LOW */
|
|
nla_total_size(sizeof(u32)) + /* _TX_USECS_LOW */
|
|
nla_total_size(sizeof(u32)) + /* _TX_MAX_FRAMES_LOW */
|
|
nla_total_size(sizeof(u32)) + /* _PKT_RATE_HIGH */
|
|
nla_total_size(sizeof(u32)) + /* _RX_USECS_HIGH */
|
|
nla_total_size(sizeof(u32)) + /* _RX_MAX_FRAMES_HIGH */
|
|
nla_total_size(sizeof(u32)) + /* _TX_USECS_HIGH */
|
|
nla_total_size(sizeof(u32)) + /* _TX_MAX_FRAMES_HIGH */
|
|
nla_total_size(sizeof(u32)) + /* _RATE_SAMPLE_INTERVAL */
|
|
nla_total_size(sizeof(u8)) + /* _USE_CQE_MODE_TX */
|
|
nla_total_size(sizeof(u8)) + /* _USE_CQE_MODE_RX */
|
|
nla_total_size(sizeof(u32)) + /* _TX_AGGR_MAX_BYTES */
|
|
nla_total_size(sizeof(u32)) + /* _TX_AGGR_MAX_FRAMES */
|
|
nla_total_size(sizeof(u32)) + /* _TX_AGGR_TIME_USECS */
|
|
total_modersz * 2; /* _{R,T}X_PROFILE */
|
|
}
|
|
|
|
static bool coalesce_put_u32(struct sk_buff *skb, u16 attr_type, u32 val,
|
|
u32 supported_params)
|
|
{
|
|
if (!val && !(supported_params & attr_to_mask(attr_type)))
|
|
return false;
|
|
return nla_put_u32(skb, attr_type, val);
|
|
}
|
|
|
|
static bool coalesce_put_bool(struct sk_buff *skb, u16 attr_type, u32 val,
|
|
u32 supported_params)
|
|
{
|
|
if (!val && !(supported_params & attr_to_mask(attr_type)))
|
|
return false;
|
|
return nla_put_u8(skb, attr_type, !!val);
|
|
}
|
|
|
|
/**
|
|
* coalesce_put_profile - fill reply with a nla nest with four child nla nests.
|
|
* @skb: socket buffer the message is stored in
|
|
* @attr_type: nest attr type ETHTOOL_A_COALESCE_*X_PROFILE
|
|
* @profile: data passed to userspace
|
|
* @coal_flags: modifiable parameters supported by the driver
|
|
*
|
|
* Put a dim profile nest attribute. Refer to ETHTOOL_A_PROFILE_IRQ_MODERATION.
|
|
*
|
|
* Return: 0 on success or a negative error code.
|
|
*/
|
|
static int coalesce_put_profile(struct sk_buff *skb, u16 attr_type,
|
|
const struct dim_cq_moder *profile,
|
|
u8 coal_flags)
|
|
{
|
|
struct nlattr *profile_attr, *moder_attr;
|
|
int i, ret;
|
|
|
|
if (!profile || !coal_flags)
|
|
return 0;
|
|
|
|
profile_attr = nla_nest_start(skb, attr_type);
|
|
if (!profile_attr)
|
|
return -EMSGSIZE;
|
|
|
|
for (i = 0; i < NET_DIM_PARAMS_NUM_PROFILES; i++) {
|
|
moder_attr = nla_nest_start(skb,
|
|
ETHTOOL_A_PROFILE_IRQ_MODERATION);
|
|
if (!moder_attr) {
|
|
ret = -EMSGSIZE;
|
|
goto cancel_profile;
|
|
}
|
|
|
|
if (coal_flags & DIM_COALESCE_USEC) {
|
|
ret = nla_put_u32(skb, ETHTOOL_A_IRQ_MODERATION_USEC,
|
|
profile[i].usec);
|
|
if (ret)
|
|
goto cancel_moder;
|
|
}
|
|
|
|
if (coal_flags & DIM_COALESCE_PKTS) {
|
|
ret = nla_put_u32(skb, ETHTOOL_A_IRQ_MODERATION_PKTS,
|
|
profile[i].pkts);
|
|
if (ret)
|
|
goto cancel_moder;
|
|
}
|
|
|
|
if (coal_flags & DIM_COALESCE_COMPS) {
|
|
ret = nla_put_u32(skb, ETHTOOL_A_IRQ_MODERATION_COMPS,
|
|
profile[i].comps);
|
|
if (ret)
|
|
goto cancel_moder;
|
|
}
|
|
|
|
nla_nest_end(skb, moder_attr);
|
|
}
|
|
|
|
nla_nest_end(skb, profile_attr);
|
|
|
|
return 0;
|
|
|
|
cancel_moder:
|
|
nla_nest_cancel(skb, moder_attr);
|
|
cancel_profile:
|
|
nla_nest_cancel(skb, profile_attr);
|
|
return ret;
|
|
}
|
|
|
|
static int coalesce_fill_reply(struct sk_buff *skb,
|
|
const struct ethnl_req_info *req_base,
|
|
const struct ethnl_reply_data *reply_base)
|
|
{
|
|
const struct coalesce_reply_data *data = COALESCE_REPDATA(reply_base);
|
|
const struct kernel_ethtool_coalesce *kcoal = &data->kernel_coalesce;
|
|
const struct ethtool_coalesce *coal = &data->coalesce;
|
|
u32 supported = data->supported_params;
|
|
struct dim_irq_moder *moder;
|
|
int ret = 0;
|
|
|
|
if (coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_USECS,
|
|
coal->rx_coalesce_usecs, supported) ||
|
|
coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_MAX_FRAMES,
|
|
coal->rx_max_coalesced_frames, supported) ||
|
|
coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_USECS_IRQ,
|
|
coal->rx_coalesce_usecs_irq, supported) ||
|
|
coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_MAX_FRAMES_IRQ,
|
|
coal->rx_max_coalesced_frames_irq, supported) ||
|
|
coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_USECS,
|
|
coal->tx_coalesce_usecs, supported) ||
|
|
coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_MAX_FRAMES,
|
|
coal->tx_max_coalesced_frames, supported) ||
|
|
coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_USECS_IRQ,
|
|
coal->tx_coalesce_usecs_irq, supported) ||
|
|
coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_MAX_FRAMES_IRQ,
|
|
coal->tx_max_coalesced_frames_irq, supported) ||
|
|
coalesce_put_u32(skb, ETHTOOL_A_COALESCE_STATS_BLOCK_USECS,
|
|
coal->stats_block_coalesce_usecs, supported) ||
|
|
coalesce_put_bool(skb, ETHTOOL_A_COALESCE_USE_ADAPTIVE_RX,
|
|
coal->use_adaptive_rx_coalesce, supported) ||
|
|
coalesce_put_bool(skb, ETHTOOL_A_COALESCE_USE_ADAPTIVE_TX,
|
|
coal->use_adaptive_tx_coalesce, supported) ||
|
|
coalesce_put_u32(skb, ETHTOOL_A_COALESCE_PKT_RATE_LOW,
|
|
coal->pkt_rate_low, supported) ||
|
|
coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_USECS_LOW,
|
|
coal->rx_coalesce_usecs_low, supported) ||
|
|
coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_MAX_FRAMES_LOW,
|
|
coal->rx_max_coalesced_frames_low, supported) ||
|
|
coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_USECS_LOW,
|
|
coal->tx_coalesce_usecs_low, supported) ||
|
|
coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_MAX_FRAMES_LOW,
|
|
coal->tx_max_coalesced_frames_low, supported) ||
|
|
coalesce_put_u32(skb, ETHTOOL_A_COALESCE_PKT_RATE_HIGH,
|
|
coal->pkt_rate_high, supported) ||
|
|
coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_USECS_HIGH,
|
|
coal->rx_coalesce_usecs_high, supported) ||
|
|
coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_MAX_FRAMES_HIGH,
|
|
coal->rx_max_coalesced_frames_high, supported) ||
|
|
coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_USECS_HIGH,
|
|
coal->tx_coalesce_usecs_high, supported) ||
|
|
coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_MAX_FRAMES_HIGH,
|
|
coal->tx_max_coalesced_frames_high, supported) ||
|
|
coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RATE_SAMPLE_INTERVAL,
|
|
coal->rate_sample_interval, supported) ||
|
|
coalesce_put_bool(skb, ETHTOOL_A_COALESCE_USE_CQE_MODE_TX,
|
|
kcoal->use_cqe_mode_tx, supported) ||
|
|
coalesce_put_bool(skb, ETHTOOL_A_COALESCE_USE_CQE_MODE_RX,
|
|
kcoal->use_cqe_mode_rx, supported) ||
|
|
coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_AGGR_MAX_BYTES,
|
|
kcoal->tx_aggr_max_bytes, supported) ||
|
|
coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_AGGR_MAX_FRAMES,
|
|
kcoal->tx_aggr_max_frames, supported) ||
|
|
coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_AGGR_TIME_USECS,
|
|
kcoal->tx_aggr_time_usecs, supported))
|
|
return -EMSGSIZE;
|
|
|
|
if (!req_base->dev || !req_base->dev->irq_moder)
|
|
return 0;
|
|
|
|
moder = req_base->dev->irq_moder;
|
|
rcu_read_lock();
|
|
if (moder->profile_flags & DIM_PROFILE_RX) {
|
|
ret = coalesce_put_profile(skb, ETHTOOL_A_COALESCE_RX_PROFILE,
|
|
rcu_dereference(moder->rx_profile),
|
|
moder->coal_flags);
|
|
if (ret)
|
|
goto out;
|
|
}
|
|
|
|
if (moder->profile_flags & DIM_PROFILE_TX)
|
|
ret = coalesce_put_profile(skb, ETHTOOL_A_COALESCE_TX_PROFILE,
|
|
rcu_dereference(moder->tx_profile),
|
|
moder->coal_flags);
|
|
|
|
out:
|
|
rcu_read_unlock();
|
|
return ret;
|
|
}
|
|
|
|
/* COALESCE_SET */
|
|
|
|
static const struct nla_policy coalesce_irq_moderation_policy[] = {
|
|
[ETHTOOL_A_IRQ_MODERATION_USEC] = { .type = NLA_U32 },
|
|
[ETHTOOL_A_IRQ_MODERATION_PKTS] = { .type = NLA_U32 },
|
|
[ETHTOOL_A_IRQ_MODERATION_COMPS] = { .type = NLA_U32 },
|
|
};
|
|
|
|
static const struct nla_policy coalesce_profile_policy[] = {
|
|
[ETHTOOL_A_PROFILE_IRQ_MODERATION] =
|
|
NLA_POLICY_NESTED(coalesce_irq_moderation_policy),
|
|
};
|
|
|
|
const struct nla_policy ethnl_coalesce_set_policy[] = {
|
|
[ETHTOOL_A_COALESCE_HEADER] =
|
|
NLA_POLICY_NESTED(ethnl_header_policy),
|
|
[ETHTOOL_A_COALESCE_RX_USECS] = { .type = NLA_U32 },
|
|
[ETHTOOL_A_COALESCE_RX_MAX_FRAMES] = { .type = NLA_U32 },
|
|
[ETHTOOL_A_COALESCE_RX_USECS_IRQ] = { .type = NLA_U32 },
|
|
[ETHTOOL_A_COALESCE_RX_MAX_FRAMES_IRQ] = { .type = NLA_U32 },
|
|
[ETHTOOL_A_COALESCE_TX_USECS] = { .type = NLA_U32 },
|
|
[ETHTOOL_A_COALESCE_TX_MAX_FRAMES] = { .type = NLA_U32 },
|
|
[ETHTOOL_A_COALESCE_TX_USECS_IRQ] = { .type = NLA_U32 },
|
|
[ETHTOOL_A_COALESCE_TX_MAX_FRAMES_IRQ] = { .type = NLA_U32 },
|
|
[ETHTOOL_A_COALESCE_STATS_BLOCK_USECS] = { .type = NLA_U32 },
|
|
[ETHTOOL_A_COALESCE_USE_ADAPTIVE_RX] = { .type = NLA_U8 },
|
|
[ETHTOOL_A_COALESCE_USE_ADAPTIVE_TX] = { .type = NLA_U8 },
|
|
[ETHTOOL_A_COALESCE_PKT_RATE_LOW] = { .type = NLA_U32 },
|
|
[ETHTOOL_A_COALESCE_RX_USECS_LOW] = { .type = NLA_U32 },
|
|
[ETHTOOL_A_COALESCE_RX_MAX_FRAMES_LOW] = { .type = NLA_U32 },
|
|
[ETHTOOL_A_COALESCE_TX_USECS_LOW] = { .type = NLA_U32 },
|
|
[ETHTOOL_A_COALESCE_TX_MAX_FRAMES_LOW] = { .type = NLA_U32 },
|
|
[ETHTOOL_A_COALESCE_PKT_RATE_HIGH] = { .type = NLA_U32 },
|
|
[ETHTOOL_A_COALESCE_RX_USECS_HIGH] = { .type = NLA_U32 },
|
|
[ETHTOOL_A_COALESCE_RX_MAX_FRAMES_HIGH] = { .type = NLA_U32 },
|
|
[ETHTOOL_A_COALESCE_TX_USECS_HIGH] = { .type = NLA_U32 },
|
|
[ETHTOOL_A_COALESCE_TX_MAX_FRAMES_HIGH] = { .type = NLA_U32 },
|
|
[ETHTOOL_A_COALESCE_RATE_SAMPLE_INTERVAL] = { .type = NLA_U32 },
|
|
[ETHTOOL_A_COALESCE_USE_CQE_MODE_TX] = NLA_POLICY_MAX(NLA_U8, 1),
|
|
[ETHTOOL_A_COALESCE_USE_CQE_MODE_RX] = NLA_POLICY_MAX(NLA_U8, 1),
|
|
[ETHTOOL_A_COALESCE_TX_AGGR_MAX_BYTES] = { .type = NLA_U32 },
|
|
[ETHTOOL_A_COALESCE_TX_AGGR_MAX_FRAMES] = { .type = NLA_U32 },
|
|
[ETHTOOL_A_COALESCE_TX_AGGR_TIME_USECS] = { .type = NLA_U32 },
|
|
[ETHTOOL_A_COALESCE_RX_PROFILE] =
|
|
NLA_POLICY_NESTED(coalesce_profile_policy),
|
|
[ETHTOOL_A_COALESCE_TX_PROFILE] =
|
|
NLA_POLICY_NESTED(coalesce_profile_policy),
|
|
};
|
|
|
|
static int
|
|
ethnl_set_coalesce_validate(struct ethnl_req_info *req_info,
|
|
struct genl_info *info)
|
|
{
|
|
const struct ethtool_ops *ops = req_info->dev->ethtool_ops;
|
|
struct dim_irq_moder *irq_moder = req_info->dev->irq_moder;
|
|
struct nlattr **tb = info->attrs;
|
|
u32 supported_params;
|
|
u16 a;
|
|
|
|
if (!ops->get_coalesce || !ops->set_coalesce)
|
|
return -EOPNOTSUPP;
|
|
|
|
/* make sure that only supported parameters are present */
|
|
supported_params = ops->supported_coalesce_params;
|
|
if (irq_moder && irq_moder->profile_flags & DIM_PROFILE_RX)
|
|
supported_params |= ETHTOOL_COALESCE_RX_PROFILE;
|
|
|
|
if (irq_moder && irq_moder->profile_flags & DIM_PROFILE_TX)
|
|
supported_params |= ETHTOOL_COALESCE_TX_PROFILE;
|
|
|
|
for (a = ETHTOOL_A_COALESCE_RX_USECS; a < __ETHTOOL_A_COALESCE_CNT; a++)
|
|
if (tb[a] && !(supported_params & attr_to_mask(a))) {
|
|
NL_SET_ERR_MSG_ATTR(info->extack, tb[a],
|
|
"cannot modify an unsupported parameter");
|
|
return -EINVAL;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* ethnl_update_irq_moder - update a specific field in the given profile
|
|
* @irq_moder: place that collects dim related information
|
|
* @irq_field: field in profile to modify
|
|
* @attr_type: attr type ETHTOOL_A_IRQ_MODERATION_*
|
|
* @tb: netlink attribute with new values or null
|
|
* @coal_bit: DIM_COALESCE_* bit from coal_flags
|
|
* @mod: pointer to bool for modification tracking
|
|
* @extack: netlink extended ack
|
|
*
|
|
* Return: 0 on success or a negative error code.
|
|
*/
|
|
static int ethnl_update_irq_moder(struct dim_irq_moder *irq_moder,
|
|
u16 *irq_field, u16 attr_type,
|
|
struct nlattr **tb,
|
|
u8 coal_bit, bool *mod,
|
|
struct netlink_ext_ack *extack)
|
|
{
|
|
int ret = 0;
|
|
u32 val;
|
|
|
|
if (!tb[attr_type])
|
|
return 0;
|
|
|
|
if (irq_moder->coal_flags & coal_bit) {
|
|
val = nla_get_u32(tb[attr_type]);
|
|
if (*irq_field == val)
|
|
return 0;
|
|
|
|
*irq_field = val;
|
|
*mod = true;
|
|
} else {
|
|
NL_SET_BAD_ATTR(extack, tb[attr_type]);
|
|
ret = -EOPNOTSUPP;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* ethnl_update_profile - get a profile nest with child nests from userspace.
|
|
* @dev: netdevice to update the profile
|
|
* @dst: profile get from the driver and modified by ethnl_update_profile.
|
|
* @nests: nest attr ETHTOOL_A_COALESCE_*X_PROFILE to set profile.
|
|
* @mod: pointer to bool for modification tracking
|
|
* @extack: Netlink extended ack
|
|
*
|
|
* Layout of nests:
|
|
* Nested ETHTOOL_A_COALESCE_*X_PROFILE attr
|
|
* Nested ETHTOOL_A_PROFILE_IRQ_MODERATION attr
|
|
* ETHTOOL_A_IRQ_MODERATION_USEC attr
|
|
* ETHTOOL_A_IRQ_MODERATION_PKTS attr
|
|
* ETHTOOL_A_IRQ_MODERATION_COMPS attr
|
|
* ...
|
|
* Nested ETHTOOL_A_PROFILE_IRQ_MODERATION attr
|
|
* ETHTOOL_A_IRQ_MODERATION_USEC attr
|
|
* ETHTOOL_A_IRQ_MODERATION_PKTS attr
|
|
* ETHTOOL_A_IRQ_MODERATION_COMPS attr
|
|
*
|
|
* Return: 0 on success or a negative error code.
|
|
*/
|
|
static int ethnl_update_profile(struct net_device *dev,
|
|
struct dim_cq_moder __rcu **dst,
|
|
const struct nlattr *nests,
|
|
bool *mod,
|
|
struct netlink_ext_ack *extack)
|
|
{
|
|
int len_irq_moder = ARRAY_SIZE(coalesce_irq_moderation_policy);
|
|
struct nlattr *tb[ARRAY_SIZE(coalesce_irq_moderation_policy)];
|
|
struct dim_irq_moder *irq_moder = dev->irq_moder;
|
|
struct dim_cq_moder *new_profile, *old_profile;
|
|
int ret, rem, i = 0, len;
|
|
struct nlattr *nest;
|
|
|
|
if (!nests)
|
|
return 0;
|
|
|
|
if (!*dst)
|
|
return -EOPNOTSUPP;
|
|
|
|
old_profile = rtnl_dereference(*dst);
|
|
len = NET_DIM_PARAMS_NUM_PROFILES * sizeof(*old_profile);
|
|
new_profile = kmemdup(old_profile, len, GFP_KERNEL);
|
|
if (!new_profile)
|
|
return -ENOMEM;
|
|
|
|
nla_for_each_nested_type(nest, ETHTOOL_A_PROFILE_IRQ_MODERATION,
|
|
nests, rem) {
|
|
ret = nla_parse_nested(tb, len_irq_moder - 1, nest,
|
|
coalesce_irq_moderation_policy,
|
|
extack);
|
|
if (ret)
|
|
goto err_out;
|
|
|
|
ret = ethnl_update_irq_moder(irq_moder, &new_profile[i].usec,
|
|
ETHTOOL_A_IRQ_MODERATION_USEC,
|
|
tb, DIM_COALESCE_USEC,
|
|
mod, extack);
|
|
if (ret)
|
|
goto err_out;
|
|
|
|
ret = ethnl_update_irq_moder(irq_moder, &new_profile[i].pkts,
|
|
ETHTOOL_A_IRQ_MODERATION_PKTS,
|
|
tb, DIM_COALESCE_PKTS,
|
|
mod, extack);
|
|
if (ret)
|
|
goto err_out;
|
|
|
|
ret = ethnl_update_irq_moder(irq_moder, &new_profile[i].comps,
|
|
ETHTOOL_A_IRQ_MODERATION_COMPS,
|
|
tb, DIM_COALESCE_COMPS,
|
|
mod, extack);
|
|
if (ret)
|
|
goto err_out;
|
|
|
|
i++;
|
|
}
|
|
|
|
/* After the profile is modified, dim itself is a dynamic
|
|
* mechanism and will quickly fit to the appropriate
|
|
* coalescing parameters according to the new profile.
|
|
*/
|
|
rcu_assign_pointer(*dst, new_profile);
|
|
kfree_rcu(old_profile, rcu);
|
|
|
|
return 0;
|
|
|
|
err_out:
|
|
kfree(new_profile);
|
|
return ret;
|
|
}
|
|
|
|
static int
|
|
__ethnl_set_coalesce(struct ethnl_req_info *req_info, struct genl_info *info,
|
|
bool *dual_change)
|
|
{
|
|
struct kernel_ethtool_coalesce kernel_coalesce = {};
|
|
struct net_device *dev = req_info->dev;
|
|
struct ethtool_coalesce coalesce = {};
|
|
bool mod_mode = false, mod = false;
|
|
struct nlattr **tb = info->attrs;
|
|
int ret;
|
|
|
|
ret = dev->ethtool_ops->get_coalesce(dev, &coalesce, &kernel_coalesce,
|
|
info->extack);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
/* Update values */
|
|
ethnl_update_u32(&coalesce.rx_coalesce_usecs,
|
|
tb[ETHTOOL_A_COALESCE_RX_USECS], &mod);
|
|
ethnl_update_u32(&coalesce.rx_max_coalesced_frames,
|
|
tb[ETHTOOL_A_COALESCE_RX_MAX_FRAMES], &mod);
|
|
ethnl_update_u32(&coalesce.rx_coalesce_usecs_irq,
|
|
tb[ETHTOOL_A_COALESCE_RX_USECS_IRQ], &mod);
|
|
ethnl_update_u32(&coalesce.rx_max_coalesced_frames_irq,
|
|
tb[ETHTOOL_A_COALESCE_RX_MAX_FRAMES_IRQ], &mod);
|
|
ethnl_update_u32(&coalesce.tx_coalesce_usecs,
|
|
tb[ETHTOOL_A_COALESCE_TX_USECS], &mod);
|
|
ethnl_update_u32(&coalesce.tx_max_coalesced_frames,
|
|
tb[ETHTOOL_A_COALESCE_TX_MAX_FRAMES], &mod);
|
|
ethnl_update_u32(&coalesce.tx_coalesce_usecs_irq,
|
|
tb[ETHTOOL_A_COALESCE_TX_USECS_IRQ], &mod);
|
|
ethnl_update_u32(&coalesce.tx_max_coalesced_frames_irq,
|
|
tb[ETHTOOL_A_COALESCE_TX_MAX_FRAMES_IRQ], &mod);
|
|
ethnl_update_u32(&coalesce.stats_block_coalesce_usecs,
|
|
tb[ETHTOOL_A_COALESCE_STATS_BLOCK_USECS], &mod);
|
|
ethnl_update_u32(&coalesce.pkt_rate_low,
|
|
tb[ETHTOOL_A_COALESCE_PKT_RATE_LOW], &mod);
|
|
ethnl_update_u32(&coalesce.rx_coalesce_usecs_low,
|
|
tb[ETHTOOL_A_COALESCE_RX_USECS_LOW], &mod);
|
|
ethnl_update_u32(&coalesce.rx_max_coalesced_frames_low,
|
|
tb[ETHTOOL_A_COALESCE_RX_MAX_FRAMES_LOW], &mod);
|
|
ethnl_update_u32(&coalesce.tx_coalesce_usecs_low,
|
|
tb[ETHTOOL_A_COALESCE_TX_USECS_LOW], &mod);
|
|
ethnl_update_u32(&coalesce.tx_max_coalesced_frames_low,
|
|
tb[ETHTOOL_A_COALESCE_TX_MAX_FRAMES_LOW], &mod);
|
|
ethnl_update_u32(&coalesce.pkt_rate_high,
|
|
tb[ETHTOOL_A_COALESCE_PKT_RATE_HIGH], &mod);
|
|
ethnl_update_u32(&coalesce.rx_coalesce_usecs_high,
|
|
tb[ETHTOOL_A_COALESCE_RX_USECS_HIGH], &mod);
|
|
ethnl_update_u32(&coalesce.rx_max_coalesced_frames_high,
|
|
tb[ETHTOOL_A_COALESCE_RX_MAX_FRAMES_HIGH], &mod);
|
|
ethnl_update_u32(&coalesce.tx_coalesce_usecs_high,
|
|
tb[ETHTOOL_A_COALESCE_TX_USECS_HIGH], &mod);
|
|
ethnl_update_u32(&coalesce.tx_max_coalesced_frames_high,
|
|
tb[ETHTOOL_A_COALESCE_TX_MAX_FRAMES_HIGH], &mod);
|
|
ethnl_update_u32(&coalesce.rate_sample_interval,
|
|
tb[ETHTOOL_A_COALESCE_RATE_SAMPLE_INTERVAL], &mod);
|
|
ethnl_update_u32(&kernel_coalesce.tx_aggr_max_bytes,
|
|
tb[ETHTOOL_A_COALESCE_TX_AGGR_MAX_BYTES], &mod);
|
|
ethnl_update_u32(&kernel_coalesce.tx_aggr_max_frames,
|
|
tb[ETHTOOL_A_COALESCE_TX_AGGR_MAX_FRAMES], &mod);
|
|
ethnl_update_u32(&kernel_coalesce.tx_aggr_time_usecs,
|
|
tb[ETHTOOL_A_COALESCE_TX_AGGR_TIME_USECS], &mod);
|
|
|
|
if (dev->irq_moder && dev->irq_moder->profile_flags & DIM_PROFILE_RX) {
|
|
ret = ethnl_update_profile(dev, &dev->irq_moder->rx_profile,
|
|
tb[ETHTOOL_A_COALESCE_RX_PROFILE],
|
|
&mod, info->extack);
|
|
if (ret < 0)
|
|
return ret;
|
|
}
|
|
|
|
if (dev->irq_moder && dev->irq_moder->profile_flags & DIM_PROFILE_TX) {
|
|
ret = ethnl_update_profile(dev, &dev->irq_moder->tx_profile,
|
|
tb[ETHTOOL_A_COALESCE_TX_PROFILE],
|
|
&mod, info->extack);
|
|
if (ret < 0)
|
|
return ret;
|
|
}
|
|
|
|
/* Update operation modes */
|
|
ethnl_update_bool32(&coalesce.use_adaptive_rx_coalesce,
|
|
tb[ETHTOOL_A_COALESCE_USE_ADAPTIVE_RX], &mod_mode);
|
|
ethnl_update_bool32(&coalesce.use_adaptive_tx_coalesce,
|
|
tb[ETHTOOL_A_COALESCE_USE_ADAPTIVE_TX], &mod_mode);
|
|
ethnl_update_u8(&kernel_coalesce.use_cqe_mode_tx,
|
|
tb[ETHTOOL_A_COALESCE_USE_CQE_MODE_TX], &mod_mode);
|
|
ethnl_update_u8(&kernel_coalesce.use_cqe_mode_rx,
|
|
tb[ETHTOOL_A_COALESCE_USE_CQE_MODE_RX], &mod_mode);
|
|
|
|
*dual_change = mod && mod_mode;
|
|
if (!mod && !mod_mode)
|
|
return 0;
|
|
|
|
ret = dev->ethtool_ops->set_coalesce(dev, &coalesce, &kernel_coalesce,
|
|
info->extack);
|
|
return ret < 0 ? ret : 1;
|
|
}
|
|
|
|
static int
|
|
ethnl_set_coalesce(struct ethnl_req_info *req_info, struct genl_info *info)
|
|
{
|
|
bool dual_change;
|
|
int err, ret;
|
|
|
|
/* SET_COALESCE may change operation mode and parameters in one call.
|
|
* Changing operation mode may cause the driver to reset the parameter
|
|
* values, and therefore ignore user input (driver does not know which
|
|
* parameters come from user and which are echoed back from ->get).
|
|
* To not complicate the drivers if user tries to change both the mode
|
|
* and parameters at once - call the driver twice.
|
|
*/
|
|
err = __ethnl_set_coalesce(req_info, info, &dual_change);
|
|
if (err < 0)
|
|
return err;
|
|
ret = err;
|
|
|
|
if (ret && dual_change) {
|
|
err = __ethnl_set_coalesce(req_info, info, &dual_change);
|
|
if (err < 0)
|
|
return err;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
const struct ethnl_request_ops ethnl_coalesce_request_ops = {
|
|
.request_cmd = ETHTOOL_MSG_COALESCE_GET,
|
|
.reply_cmd = ETHTOOL_MSG_COALESCE_GET_REPLY,
|
|
.hdr_attr = ETHTOOL_A_COALESCE_HEADER,
|
|
.req_info_size = sizeof(struct coalesce_req_info),
|
|
.reply_data_size = sizeof(struct coalesce_reply_data),
|
|
|
|
.prepare_data = coalesce_prepare_data,
|
|
.reply_size = coalesce_reply_size,
|
|
.fill_reply = coalesce_fill_reply,
|
|
|
|
.set_validate = ethnl_set_coalesce_validate,
|
|
.set = ethnl_set_coalesce,
|
|
.set_ntf_cmd = ETHTOOL_MSG_COALESCE_NTF,
|
|
};
|