| // SPDX-License-Identifier: GPL-2.0-only | |
| #include <linux/dim.h> | |
| #include "common.h" | |
| #include "netlink.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 */ | |
| nla_total_size(sizeof(u32)) + /* _RX_CQE_FRAMES */ | |
| nla_total_size(sizeof(u32)) + /* _RX_CQE_NSECS */ | |
| 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) || | |
| coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_CQE_FRAMES, | |
| kcoal->rx_cqe_frames, supported) || | |
| coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_CQE_NSECS, | |
| kcoal->rx_cqe_nsecs, 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_CQE_FRAMES] = { .type = NLA_U32 }, | |
| [ETHTOOL_A_COALESCE_RX_CQE_NSECS] = { .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) { | |
| if (i >= NET_DIM_PARAMS_NUM_PROFILES) { | |
| NL_SET_BAD_ATTR(extack, nest); | |
| ret = -E2BIG; | |
| goto err_out; | |
| } | |
| 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); | |
| ethnl_update_u32(&kernel_coalesce.rx_cqe_frames, | |
| tb[ETHTOOL_A_COALESCE_RX_CQE_FRAMES], &mod); | |
| ethnl_update_u32(&kernel_coalesce.rx_cqe_nsecs, | |
| tb[ETHTOOL_A_COALESCE_RX_CQE_NSECS], &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, | |
| }; |