[linux-block.git] / net / ethtool / stats.c

// SPDX-License-Identifier: GPL-2.0-only

#include "netlink.h"
#include "common.h"
#include "bitset.h"

struct stats_req_info {
	struct ethnl_req_info		base;
	DECLARE_BITMAP(stat_mask, __ETHTOOL_STATS_CNT);
	enum ethtool_mac_stats_src	src;
};

#define STATS_REQINFO(__req_base) \
	container_of(__req_base, struct stats_req_info, base)

struct stats_reply_data {
	struct ethnl_reply_data		base;
	struct_group(stats,
		struct ethtool_eth_phy_stats	phy_stats;
		struct ethtool_eth_mac_stats	mac_stats;
		struct ethtool_eth_ctrl_stats	ctrl_stats;
		struct ethtool_rmon_stats	rmon_stats;
	);
	const struct ethtool_rmon_hist_range	*rmon_ranges;
};

#define STATS_REPDATA(__reply_base) \
	container_of(__reply_base, struct stats_reply_data, base)

const char stats_std_names[__ETHTOOL_STATS_CNT][ETH_GSTRING_LEN] = {
	[ETHTOOL_STATS_ETH_PHY]			= "eth-phy",
	[ETHTOOL_STATS_ETH_MAC]			= "eth-mac",
	[ETHTOOL_STATS_ETH_CTRL]		= "eth-ctrl",
	[ETHTOOL_STATS_RMON]			= "rmon",
};

const char stats_eth_phy_names[__ETHTOOL_A_STATS_ETH_PHY_CNT][ETH_GSTRING_LEN] = {
	[ETHTOOL_A_STATS_ETH_PHY_5_SYM_ERR]	= "SymbolErrorDuringCarrier",
};

const char stats_eth_mac_names[__ETHTOOL_A_STATS_ETH_MAC_CNT][ETH_GSTRING_LEN] = {
	[ETHTOOL_A_STATS_ETH_MAC_2_TX_PKT]	= "FramesTransmittedOK",
	[ETHTOOL_A_STATS_ETH_MAC_3_SINGLE_COL]	= "SingleCollisionFrames",
	[ETHTOOL_A_STATS_ETH_MAC_4_MULTI_COL]	= "MultipleCollisionFrames",
	[ETHTOOL_A_STATS_ETH_MAC_5_RX_PKT]	= "FramesReceivedOK",
	[ETHTOOL_A_STATS_ETH_MAC_6_FCS_ERR]	= "FrameCheckSequenceErrors",
	[ETHTOOL_A_STATS_ETH_MAC_7_ALIGN_ERR]	= "AlignmentErrors",
	[ETHTOOL_A_STATS_ETH_MAC_8_TX_BYTES]	= "OctetsTransmittedOK",
	[ETHTOOL_A_STATS_ETH_MAC_9_TX_DEFER]	= "FramesWithDeferredXmissions",
	[ETHTOOL_A_STATS_ETH_MAC_10_LATE_COL]	= "LateCollisions",
	[ETHTOOL_A_STATS_ETH_MAC_11_XS_COL]	= "FramesAbortedDueToXSColls",
	[ETHTOOL_A_STATS_ETH_MAC_12_TX_INT_ERR]	= "FramesLostDueToIntMACXmitError",
	[ETHTOOL_A_STATS_ETH_MAC_13_CS_ERR]	= "CarrierSenseErrors",
	[ETHTOOL_A_STATS_ETH_MAC_14_RX_BYTES]	= "OctetsReceivedOK",
	[ETHTOOL_A_STATS_ETH_MAC_15_RX_INT_ERR]	= "FramesLostDueToIntMACRcvError",
	[ETHTOOL_A_STATS_ETH_MAC_18_TX_MCAST]	= "MulticastFramesXmittedOK",
	[ETHTOOL_A_STATS_ETH_MAC_19_TX_BCAST]	= "BroadcastFramesXmittedOK",
	[ETHTOOL_A_STATS_ETH_MAC_20_XS_DEFER]	= "FramesWithExcessiveDeferral",
	[ETHTOOL_A_STATS_ETH_MAC_21_RX_MCAST]	= "MulticastFramesReceivedOK",
	[ETHTOOL_A_STATS_ETH_MAC_22_RX_BCAST]	= "BroadcastFramesReceivedOK",
	[ETHTOOL_A_STATS_ETH_MAC_23_IR_LEN_ERR]	= "InRangeLengthErrors",
	[ETHTOOL_A_STATS_ETH_MAC_24_OOR_LEN]	= "OutOfRangeLengthField",
	[ETHTOOL_A_STATS_ETH_MAC_25_TOO_LONG_ERR]	= "FrameTooLongErrors",
};

const char stats_eth_ctrl_names[__ETHTOOL_A_STATS_ETH_CTRL_CNT][ETH_GSTRING_LEN] = {
	[ETHTOOL_A_STATS_ETH_CTRL_3_TX]		= "MACControlFramesTransmitted",
	[ETHTOOL_A_STATS_ETH_CTRL_4_RX]		= "MACControlFramesReceived",
	[ETHTOOL_A_STATS_ETH_CTRL_5_RX_UNSUP]	= "UnsupportedOpcodesReceived",
};

const char stats_rmon_names[__ETHTOOL_A_STATS_RMON_CNT][ETH_GSTRING_LEN] = {
	[ETHTOOL_A_STATS_RMON_UNDERSIZE]	= "etherStatsUndersizePkts",
	[ETHTOOL_A_STATS_RMON_OVERSIZE]		= "etherStatsOversizePkts",
	[ETHTOOL_A_STATS_RMON_FRAG]		= "etherStatsFragments",
	[ETHTOOL_A_STATS_RMON_JABBER]		= "etherStatsJabbers",
};

const struct nla_policy ethnl_stats_get_policy[ETHTOOL_A_STATS_SRC + 1] = {
	[ETHTOOL_A_STATS_HEADER]	=
		NLA_POLICY_NESTED(ethnl_header_policy),
	[ETHTOOL_A_STATS_GROUPS]	= { .type = NLA_NESTED },
	[ETHTOOL_A_STATS_SRC]		=
		NLA_POLICY_MAX(NLA_U32, ETHTOOL_MAC_STATS_SRC_PMAC),
};

static int stats_parse_request(struct ethnl_req_info *req_base,
			       struct nlattr **tb,
			       struct netlink_ext_ack *extack)
{
	enum ethtool_mac_stats_src src = ETHTOOL_MAC_STATS_SRC_AGGREGATE;
	struct stats_req_info *req_info = STATS_REQINFO(req_base);
	bool mod = false;
	int err;

	err = ethnl_update_bitset(req_info->stat_mask, __ETHTOOL_STATS_CNT,
				  tb[ETHTOOL_A_STATS_GROUPS], stats_std_names,
				  extack, &mod);
	if (err)
		return err;

	if (!mod) {
		NL_SET_ERR_MSG(extack, "no stats requested");
		return -EINVAL;
	}

	if (tb[ETHTOOL_A_STATS_SRC])
		src = nla_get_u32(tb[ETHTOOL_A_STATS_SRC]);

	req_info->src = src;

	return 0;
}

static int stats_prepare_data(const struct ethnl_req_info *req_base,
			      struct ethnl_reply_data *reply_base,
			      struct genl_info *info)
{
	const struct stats_req_info *req_info = STATS_REQINFO(req_base);
	struct netlink_ext_ack *extack = info ? info->extack : NULL;
	struct stats_reply_data *data = STATS_REPDATA(reply_base);
	enum ethtool_mac_stats_src src = req_info->src;
	struct net_device *dev = reply_base->dev;
	int ret;

	ret = ethnl_ops_begin(dev);
	if (ret < 0)
		return ret;

	if ((src == ETHTOOL_MAC_STATS_SRC_EMAC ||
	     src == ETHTOOL_MAC_STATS_SRC_PMAC) &&
	    !__ethtool_dev_mm_supported(dev)) {
		NL_SET_ERR_MSG_MOD(extack,
				   "Device does not support MAC merge layer");
		ethnl_ops_complete(dev);
		return -EOPNOTSUPP;
	}

	/* Mark all stats as unset (see ETHTOOL_STAT_NOT_SET) to prevent them
	 * from being reported to user space in case driver did not set them.
	 */
	memset(&data->stats, 0xff, sizeof(data->stats));

	data->phy_stats.src = src;
	data->mac_stats.src = src;
	data->ctrl_stats.src = src;
	data->rmon_stats.src = src;

	if (test_bit(ETHTOOL_STATS_ETH_PHY, req_info->stat_mask) &&
	    dev->ethtool_ops->get_eth_phy_stats)
		dev->ethtool_ops->get_eth_phy_stats(dev, &data->phy_stats);
	if (test_bit(ETHTOOL_STATS_ETH_MAC, req_info->stat_mask) &&
	    dev->ethtool_ops->get_eth_mac_stats)
		dev->ethtool_ops->get_eth_mac_stats(dev, &data->mac_stats);
	if (test_bit(ETHTOOL_STATS_ETH_CTRL, req_info->stat_mask) &&
	    dev->ethtool_ops->get_eth_ctrl_stats)
		dev->ethtool_ops->get_eth_ctrl_stats(dev, &data->ctrl_stats);
	if (test_bit(ETHTOOL_STATS_RMON, req_info->stat_mask) &&
	    dev->ethtool_ops->get_rmon_stats)
		dev->ethtool_ops->get_rmon_stats(dev, &data->rmon_stats,
						 &data->rmon_ranges);

	ethnl_ops_complete(dev);
	return 0;
}

static int stats_reply_size(const struct ethnl_req_info *req_base,
			    const struct ethnl_reply_data *reply_base)
{
	const struct stats_req_info *req_info = STATS_REQINFO(req_base);
	unsigned int n_grps = 0, n_stats = 0;
	int len = 0;

	len += nla_total_size(sizeof(u32)); /* _STATS_SRC */

	if (test_bit(ETHTOOL_STATS_ETH_PHY, req_info->stat_mask)) {
		n_stats += sizeof(struct ethtool_eth_phy_stats) / sizeof(u64);
		n_grps++;
	}
	if (test_bit(ETHTOOL_STATS_ETH_MAC, req_info->stat_mask)) {
		n_stats += sizeof(struct ethtool_eth_mac_stats) / sizeof(u64);
		n_grps++;
	}
	if (test_bit(ETHTOOL_STATS_ETH_CTRL, req_info->stat_mask)) {
		n_stats += sizeof(struct ethtool_eth_ctrl_stats) / sizeof(u64);
		n_grps++;
	}
	if (test_bit(ETHTOOL_STATS_RMON, req_info->stat_mask)) {
		n_stats += sizeof(struct ethtool_rmon_stats) / sizeof(u64);
		n_grps++;
		/* Above includes the space for _A_STATS_GRP_HIST_VALs */

		len += (nla_total_size(0) +	/* _A_STATS_GRP_HIST */
			nla_total_size(4) +	/* _A_STATS_GRP_HIST_BKT_LOW */
			nla_total_size(4)) *	/* _A_STATS_GRP_HIST_BKT_HI */
			ETHTOOL_RMON_HIST_MAX * 2;
	}

	len += n_grps * (nla_total_size(0) + /* _A_STATS_GRP */
			 nla_total_size(4) + /* _A_STATS_GRP_ID */
			 nla_total_size(4)); /* _A_STATS_GRP_SS_ID */
	len += n_stats * (nla_total_size(0) + /* _A_STATS_GRP_STAT */
			  nla_total_size_64bit(sizeof(u64)));

	return len;
}

static int stat_put(struct sk_buff *skb, u16 attrtype, u64 val)
{
	struct nlattr *nest;
	int ret;

	if (val == ETHTOOL_STAT_NOT_SET)
		return 0;

	/* We want to start stats attr types from 0, so we don't have a type
	 * for pad inside ETHTOOL_A_STATS_GRP_STAT. Pad things on the outside
	 * of ETHTOOL_A_STATS_GRP_STAT. Since we're one nest away from the
	 * actual attr we're 4B off - nla_need_padding_for_64bit() & co.
	 * can't be used.
	 */
#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
	if (!IS_ALIGNED((unsigned long)skb_tail_pointer(skb), 8))
		if (!nla_reserve(skb, ETHTOOL_A_STATS_GRP_PAD, 0))
			return -EMSGSIZE;
#endif

	nest = nla_nest_start(skb, ETHTOOL_A_STATS_GRP_STAT);
	if (!nest)
		return -EMSGSIZE;

	ret = nla_put_u64_64bit(skb, attrtype, val, -1 /* not used */);
	if (ret) {
		nla_nest_cancel(skb, nest);
		return ret;
	}

	nla_nest_end(skb, nest);
	return 0;
}

static int stats_put_phy_stats(struct sk_buff *skb,
			       const struct stats_reply_data *data)
{
	if (stat_put(skb, ETHTOOL_A_STATS_ETH_PHY_5_SYM_ERR,
		     data->phy_stats.SymbolErrorDuringCarrier))
		return -EMSGSIZE;
	return 0;
}

static int stats_put_mac_stats(struct sk_buff *skb,
			       const struct stats_reply_data *data)
{
	if (stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_2_TX_PKT,
		     data->mac_stats.FramesTransmittedOK) ||
	    stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_3_SINGLE_COL,
		     data->mac_stats.SingleCollisionFrames) ||
	    stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_4_MULTI_COL,
		     data->mac_stats.MultipleCollisionFrames) ||
	    stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_5_RX_PKT,
		     data->mac_stats.FramesReceivedOK) ||
	    stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_6_FCS_ERR,
		     data->mac_stats.FrameCheckSequenceErrors) ||
	    stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_7_ALIGN_ERR,
		     data->mac_stats.AlignmentErrors) ||
	    stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_8_TX_BYTES,
		     data->mac_stats.OctetsTransmittedOK) ||
	    stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_9_TX_DEFER,
		     data->mac_stats.FramesWithDeferredXmissions) ||
	    stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_10_LATE_COL,
		     data->mac_stats.LateCollisions) ||
	    stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_11_XS_COL,
		     data->mac_stats.FramesAbortedDueToXSColls) ||
	    stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_12_TX_INT_ERR,
		     data->mac_stats.FramesLostDueToIntMACXmitError) ||
	    stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_13_CS_ERR,
		     data->mac_stats.CarrierSenseErrors) ||
	    stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_14_RX_BYTES,
		     data->mac_stats.OctetsReceivedOK) ||
	    stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_15_RX_INT_ERR,
		     data->mac_stats.FramesLostDueToIntMACRcvError) ||
	    stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_18_TX_MCAST,
		     data->mac_stats.MulticastFramesXmittedOK) ||
	    stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_19_TX_BCAST,
		     data->mac_stats.BroadcastFramesXmittedOK) ||
	    stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_20_XS_DEFER,
		     data->mac_stats.FramesWithExcessiveDeferral) ||
	    stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_21_RX_MCAST,
		     data->mac_stats.MulticastFramesReceivedOK) ||
	    stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_22_RX_BCAST,
		     data->mac_stats.BroadcastFramesReceivedOK) ||
	    stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_23_IR_LEN_ERR,
		     data->mac_stats.InRangeLengthErrors) ||
	    stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_24_OOR_LEN,
		     data->mac_stats.OutOfRangeLengthField) ||
	    stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_25_TOO_LONG_ERR,
		     data->mac_stats.FrameTooLongErrors))
		return -EMSGSIZE;
	return 0;
}

static int stats_put_ctrl_stats(struct sk_buff *skb,
				const struct stats_reply_data *data)
{
	if (stat_put(skb, ETHTOOL_A_STATS_ETH_CTRL_3_TX,
		     data->ctrl_stats.MACControlFramesTransmitted) ||
	    stat_put(skb, ETHTOOL_A_STATS_ETH_CTRL_4_RX,
		     data->ctrl_stats.MACControlFramesReceived) ||
	    stat_put(skb, ETHTOOL_A_STATS_ETH_CTRL_5_RX_UNSUP,
		     data->ctrl_stats.UnsupportedOpcodesReceived))
		return -EMSGSIZE;
	return 0;
}

static int stats_put_rmon_hist(struct sk_buff *skb, u32 attr, const u64 *hist,
			       const struct ethtool_rmon_hist_range *ranges)
{
	struct nlattr *nest;
	int i;

	if (!ranges)
		return 0;

	for (i = 0; i <	ETHTOOL_RMON_HIST_MAX; i++) {
		if (!ranges[i].low && !ranges[i].high)
			break;
		if (hist[i] == ETHTOOL_STAT_NOT_SET)
			continue;

		nest = nla_nest_start(skb, attr);
		if (!nest)
			return -EMSGSIZE;

		if (nla_put_u32(skb, ETHTOOL_A_STATS_GRP_HIST_BKT_LOW,
				ranges[i].low) ||
		    nla_put_u32(skb, ETHTOOL_A_STATS_GRP_HIST_BKT_HI,
				ranges[i].high) ||
		    nla_put_u64_64bit(skb, ETHTOOL_A_STATS_GRP_HIST_VAL,
				      hist[i], ETHTOOL_A_STATS_GRP_PAD))
			goto err_cancel_hist;

		nla_nest_end(skb, nest);
	}

	return 0;

err_cancel_hist:
	nla_nest_cancel(skb, nest);
	return -EMSGSIZE;
}

static int stats_put_rmon_stats(struct sk_buff *skb,
				const struct stats_reply_data *data)
{
	if (stats_put_rmon_hist(skb, ETHTOOL_A_STATS_GRP_HIST_RX,
				data->rmon_stats.hist, data->rmon_ranges) ||
	    stats_put_rmon_hist(skb, ETHTOOL_A_STATS_GRP_HIST_TX,
				data->rmon_stats.hist_tx, data->rmon_ranges))
		return -EMSGSIZE;

	if (stat_put(skb, ETHTOOL_A_STATS_RMON_UNDERSIZE,
		     data->rmon_stats.undersize_pkts) ||
	    stat_put(skb, ETHTOOL_A_STATS_RMON_OVERSIZE,
		     data->rmon_stats.oversize_pkts) ||
	    stat_put(skb, ETHTOOL_A_STATS_RMON_FRAG,
		     data->rmon_stats.fragments) ||
	    stat_put(skb, ETHTOOL_A_STATS_RMON_JABBER,
		     data->rmon_stats.jabbers))
		return -EMSGSIZE;

	return 0;
}

static int stats_put_stats(struct sk_buff *skb,
			   const struct stats_reply_data *data,
			   u32 id, u32 ss_id,
			   int (*cb)(struct sk_buff *skb,
				     const struct stats_reply_data *data))
{
	struct nlattr *nest;

	nest = nla_nest_start(skb, ETHTOOL_A_STATS_GRP);
	if (!nest)
		return -EMSGSIZE;

	if (nla_put_u32(skb, ETHTOOL_A_STATS_GRP_ID, id) ||
	    nla_put_u32(skb, ETHTOOL_A_STATS_GRP_SS_ID, ss_id))
		goto err_cancel;

	if (cb(skb, data))
		goto err_cancel;

	nla_nest_end(skb, nest);
	return 0;

err_cancel:
	nla_nest_cancel(skb, nest);
	return -EMSGSIZE;
}

static int stats_fill_reply(struct sk_buff *skb,
			    const struct ethnl_req_info *req_base,
			    const struct ethnl_reply_data *reply_base)
{
	const struct stats_req_info *req_info = STATS_REQINFO(req_base);
	const struct stats_reply_data *data = STATS_REPDATA(reply_base);
	int ret = 0;

	if (nla_put_u32(skb, ETHTOOL_A_STATS_SRC, req_info->src))
		return -EMSGSIZE;

	if (!ret && test_bit(ETHTOOL_STATS_ETH_PHY, req_info->stat_mask))
		ret = stats_put_stats(skb, data, ETHTOOL_STATS_ETH_PHY,
				      ETH_SS_STATS_ETH_PHY,
				      stats_put_phy_stats);
	if (!ret && test_bit(ETHTOOL_STATS_ETH_MAC, req_info->stat_mask))
		ret = stats_put_stats(skb, data, ETHTOOL_STATS_ETH_MAC,
				      ETH_SS_STATS_ETH_MAC,
				      stats_put_mac_stats);
	if (!ret && test_bit(ETHTOOL_STATS_ETH_CTRL, req_info->stat_mask))
		ret = stats_put_stats(skb, data, ETHTOOL_STATS_ETH_CTRL,
				      ETH_SS_STATS_ETH_CTRL,
				      stats_put_ctrl_stats);
	if (!ret && test_bit(ETHTOOL_STATS_RMON, req_info->stat_mask))
		ret = stats_put_stats(skb, data, ETHTOOL_STATS_RMON,
				      ETH_SS_STATS_RMON, stats_put_rmon_stats);

	return ret;
}

const struct ethnl_request_ops ethnl_stats_request_ops = {
	.request_cmd		= ETHTOOL_MSG_STATS_GET,
	.reply_cmd		= ETHTOOL_MSG_STATS_GET_REPLY,
	.hdr_attr		= ETHTOOL_A_STATS_HEADER,
	.req_info_size		= sizeof(struct stats_req_info),
	.reply_data_size	= sizeof(struct stats_reply_data),

	.parse_request		= stats_parse_request,
	.prepare_data		= stats_prepare_data,
	.reply_size		= stats_reply_size,
	.fill_reply		= stats_fill_reply,
};

static u64 ethtool_stats_sum(u64 a, u64 b)
{
	if (a == ETHTOOL_STAT_NOT_SET)
		return b;
	if (b == ETHTOOL_STAT_NOT_SET)
		return a;
	return a + b;
}

/* Avoid modifying the aggregation procedure every time a new counter is added
 * by treating the structures as an array of u64 statistics.
 */
static void ethtool_aggregate_stats(void *aggr_stats, const void *emac_stats,
				    const void *pmac_stats, size_t stats_size,
				    size_t stats_offset)
{
	size_t num_stats = stats_size / sizeof(u64);
	const u64 *s1 = emac_stats + stats_offset;
	const u64 *s2 = pmac_stats + stats_offset;
	u64 *s = aggr_stats + stats_offset;
	int i;

	for (i = 0; i < num_stats; i++)
		s[i] = ethtool_stats_sum(s1[i], s2[i]);
}

void ethtool_aggregate_mac_stats(struct net_device *dev,
				 struct ethtool_eth_mac_stats *mac_stats)
{
	const struct ethtool_ops *ops = dev->ethtool_ops;
	struct ethtool_eth_mac_stats pmac, emac;

	memset(&emac, 0xff, sizeof(emac));
	memset(&pmac, 0xff, sizeof(pmac));
	emac.src = ETHTOOL_MAC_STATS_SRC_EMAC;
	pmac.src = ETHTOOL_MAC_STATS_SRC_PMAC;

	ops->get_eth_mac_stats(dev, &emac);
	ops->get_eth_mac_stats(dev, &pmac);

	ethtool_aggregate_stats(mac_stats, &emac, &pmac,
				sizeof(mac_stats->stats),
				offsetof(struct ethtool_eth_mac_stats, stats));
}
EXPORT_SYMBOL(ethtool_aggregate_mac_stats);

void ethtool_aggregate_phy_stats(struct net_device *dev,
				 struct ethtool_eth_phy_stats *phy_stats)
{
	const struct ethtool_ops *ops = dev->ethtool_ops;
	struct ethtool_eth_phy_stats pmac, emac;

	memset(&emac, 0xff, sizeof(emac));
	memset(&pmac, 0xff, sizeof(pmac));
	emac.src = ETHTOOL_MAC_STATS_SRC_EMAC;
	pmac.src = ETHTOOL_MAC_STATS_SRC_PMAC;

	ops->get_eth_phy_stats(dev, &emac);
	ops->get_eth_phy_stats(dev, &pmac);

	ethtool_aggregate_stats(phy_stats, &emac, &pmac,
				sizeof(phy_stats->stats),
				offsetof(struct ethtool_eth_phy_stats, stats));
}
EXPORT_SYMBOL(ethtool_aggregate_phy_stats);

void ethtool_aggregate_ctrl_stats(struct net_device *dev,
				  struct ethtool_eth_ctrl_stats *ctrl_stats)
{
	const struct ethtool_ops *ops = dev->ethtool_ops;
	struct ethtool_eth_ctrl_stats pmac, emac;

	memset(&emac, 0xff, sizeof(emac));
	memset(&pmac, 0xff, sizeof(pmac));
	emac.src = ETHTOOL_MAC_STATS_SRC_EMAC;
	pmac.src = ETHTOOL_MAC_STATS_SRC_PMAC;

	ops->get_eth_ctrl_stats(dev, &emac);
	ops->get_eth_ctrl_stats(dev, &pmac);

	ethtool_aggregate_stats(ctrl_stats, &emac, &pmac,
				sizeof(ctrl_stats->stats),
				offsetof(struct ethtool_eth_ctrl_stats, stats));
}
EXPORT_SYMBOL(ethtool_aggregate_ctrl_stats);

void ethtool_aggregate_pause_stats(struct net_device *dev,
				   struct ethtool_pause_stats *pause_stats)
{
	const struct ethtool_ops *ops = dev->ethtool_ops;
	struct ethtool_pause_stats pmac, emac;

	memset(&emac, 0xff, sizeof(emac));
	memset(&pmac, 0xff, sizeof(pmac));
	emac.src = ETHTOOL_MAC_STATS_SRC_EMAC;
	pmac.src = ETHTOOL_MAC_STATS_SRC_PMAC;

	ops->get_pause_stats(dev, &emac);
	ops->get_pause_stats(dev, &pmac);

	ethtool_aggregate_stats(pause_stats, &emac, &pmac,
				sizeof(pause_stats->stats),
				offsetof(struct ethtool_pause_stats, stats));
}
EXPORT_SYMBOL(ethtool_aggregate_pause_stats);

void ethtool_aggregate_rmon_stats(struct net_device *dev,
				  struct ethtool_rmon_stats *rmon_stats)
{
	const struct ethtool_ops *ops = dev->ethtool_ops;
	const struct ethtool_rmon_hist_range *dummy;
	struct ethtool_rmon_stats pmac, emac;

	memset(&emac, 0xff, sizeof(emac));
	memset(&pmac, 0xff, sizeof(pmac));
	emac.src = ETHTOOL_MAC_STATS_SRC_EMAC;
	pmac.src = ETHTOOL_MAC_STATS_SRC_PMAC;

	ops->get_rmon_stats(dev, &emac, &dummy);
	ops->get_rmon_stats(dev, &pmac, &dummy);

	ethtool_aggregate_stats(rmon_stats, &emac, &pmac,
				sizeof(rmon_stats->stats),
				offsetof(struct ethtool_rmon_stats, stats));
}
EXPORT_SYMBOL(ethtool_aggregate_rmon_stats);
Commit	Line	Data
f09ea6fb JK	1	// SPDX-License-Identifier: GPL-2.0-only
	2
	3	#include "netlink.h"
	4	#include "common.h"
	5	#include "bitset.h"
	6
	7	struct stats_req_info {
	8	struct ethnl_req_info base;
	9	DECLARE_BITMAP(stat_mask, __ETHTOOL_STATS_CNT);
04692c90	10	enum ethtool_mac_stats_src src;
f09ea6fb JK	11	};
	12
	13	#define STATS_REQINFO(__req_base) \
	14	container_of(__req_base, struct stats_req_info, base)
	15
	16	struct stats_reply_data {
	17	struct ethnl_reply_data base;
812ad3d2 KC	18	struct_group(stats,
	19	struct ethtool_eth_phy_stats phy_stats;
	20	struct ethtool_eth_mac_stats mac_stats;
	21	struct ethtool_eth_ctrl_stats ctrl_stats;
	22	struct ethtool_rmon_stats rmon_stats;
	23	);
a8b06e9d	24	const struct ethtool_rmon_hist_range *rmon_ranges;
f09ea6fb JK	25	};
	26
	27	#define STATS_REPDATA(__reply_base) \
	28	container_of(__reply_base, struct stats_reply_data, base)
	29
	30	const char stats_std_names[__ETHTOOL_STATS_CNT][ETH_GSTRING_LEN] = {
	31	[ETHTOOL_STATS_ETH_PHY] = "eth-phy",
ca224454	32	[ETHTOOL_STATS_ETH_MAC] = "eth-mac",
bfad2b97	33	[ETHTOOL_STATS_ETH_CTRL] = "eth-ctrl",
a8b06e9d	34	[ETHTOOL_STATS_RMON] = "rmon",
f09ea6fb JK	35	};
	36
	37	const char stats_eth_phy_names[__ETHTOOL_A_STATS_ETH_PHY_CNT][ETH_GSTRING_LEN] = {
	38	[ETHTOOL_A_STATS_ETH_PHY_5_SYM_ERR] = "SymbolErrorDuringCarrier",
	39	};
	40
ca224454 JK	41	const char stats_eth_mac_names[__ETHTOOL_A_STATS_ETH_MAC_CNT][ETH_GSTRING_LEN] = {
	42	[ETHTOOL_A_STATS_ETH_MAC_2_TX_PKT] = "FramesTransmittedOK",
	43	[ETHTOOL_A_STATS_ETH_MAC_3_SINGLE_COL] = "SingleCollisionFrames",
	44	[ETHTOOL_A_STATS_ETH_MAC_4_MULTI_COL] = "MultipleCollisionFrames",
	45	[ETHTOOL_A_STATS_ETH_MAC_5_RX_PKT] = "FramesReceivedOK",
	46	[ETHTOOL_A_STATS_ETH_MAC_6_FCS_ERR] = "FrameCheckSequenceErrors",
	47	[ETHTOOL_A_STATS_ETH_MAC_7_ALIGN_ERR] = "AlignmentErrors",
	48	[ETHTOOL_A_STATS_ETH_MAC_8_TX_BYTES] = "OctetsTransmittedOK",
	49	[ETHTOOL_A_STATS_ETH_MAC_9_TX_DEFER] = "FramesWithDeferredXmissions",
	50	[ETHTOOL_A_STATS_ETH_MAC_10_LATE_COL] = "LateCollisions",
	51	[ETHTOOL_A_STATS_ETH_MAC_11_XS_COL] = "FramesAbortedDueToXSColls",
	52	[ETHTOOL_A_STATS_ETH_MAC_12_TX_INT_ERR] = "FramesLostDueToIntMACXmitError",
	53	[ETHTOOL_A_STATS_ETH_MAC_13_CS_ERR] = "CarrierSenseErrors",
	54	[ETHTOOL_A_STATS_ETH_MAC_14_RX_BYTES] = "OctetsReceivedOK",
	55	[ETHTOOL_A_STATS_ETH_MAC_15_RX_INT_ERR] = "FramesLostDueToIntMACRcvError",
	56	[ETHTOOL_A_STATS_ETH_MAC_18_TX_MCAST] = "MulticastFramesXmittedOK",
	57	[ETHTOOL_A_STATS_ETH_MAC_19_TX_BCAST] = "BroadcastFramesXmittedOK",
	58	[ETHTOOL_A_STATS_ETH_MAC_20_XS_DEFER] = "FramesWithExcessiveDeferral",
	59	[ETHTOOL_A_STATS_ETH_MAC_21_RX_MCAST] = "MulticastFramesReceivedOK",
	60	[ETHTOOL_A_STATS_ETH_MAC_22_RX_BCAST] = "BroadcastFramesReceivedOK",
	61	[ETHTOOL_A_STATS_ETH_MAC_23_IR_LEN_ERR] = "InRangeLengthErrors",
	62	[ETHTOOL_A_STATS_ETH_MAC_24_OOR_LEN] = "OutOfRangeLengthField",
	63	[ETHTOOL_A_STATS_ETH_MAC_25_TOO_LONG_ERR] = "FrameTooLongErrors",
	64	};
	65
bfad2b97 JK	66	const char stats_eth_ctrl_names[__ETHTOOL_A_STATS_ETH_CTRL_CNT][ETH_GSTRING_LEN] = {
	67	[ETHTOOL_A_STATS_ETH_CTRL_3_TX] = "MACControlFramesTransmitted",
	68	[ETHTOOL_A_STATS_ETH_CTRL_4_RX] = "MACControlFramesReceived",
	69	[ETHTOOL_A_STATS_ETH_CTRL_5_RX_UNSUP] = "UnsupportedOpcodesReceived",
	70	};
	71
a8b06e9d JK	72	const char stats_rmon_names[__ETHTOOL_A_STATS_RMON_CNT][ETH_GSTRING_LEN] = {
	73	[ETHTOOL_A_STATS_RMON_UNDERSIZE] = "etherStatsUndersizePkts",
	74	[ETHTOOL_A_STATS_RMON_OVERSIZE] = "etherStatsOversizePkts",
	75	[ETHTOOL_A_STATS_RMON_FRAG] = "etherStatsFragments",
	76	[ETHTOOL_A_STATS_RMON_JABBER] = "etherStatsJabbers",
	77	};
	78
04692c90	79	const struct nla_policy ethnl_stats_get_policy[ETHTOOL_A_STATS_SRC + 1] = {
f09ea6fb JK	80	[ETHTOOL_A_STATS_HEADER] =
	81	NLA_POLICY_NESTED(ethnl_header_policy),
	82	[ETHTOOL_A_STATS_GROUPS] = { .type = NLA_NESTED },
04692c90 VO	83	[ETHTOOL_A_STATS_SRC] =
04692c90 VO	84	NLA_POLICY_MAX(NLA_U32, ETHTOOL_MAC_STATS_SRC_PMAC),
f09ea6fb JK	85	};
	86
	87	static int stats_parse_request(struct ethnl_req_info *req_base,
	88	struct nlattr **tb,
	89	struct netlink_ext_ack *extack)
	90	{
04692c90	91	enum ethtool_mac_stats_src src = ETHTOOL_MAC_STATS_SRC_AGGREGATE;
f09ea6fb JK	92	struct stats_req_info *req_info = STATS_REQINFO(req_base);
	93	bool mod = false;
	94	int err;
	95
	96	err = ethnl_update_bitset(req_info->stat_mask, __ETHTOOL_STATS_CNT,
	97	tb[ETHTOOL_A_STATS_GROUPS], stats_std_names,
	98	extack, &mod);
	99	if (err)
	100	return err;
	101
	102	if (!mod) {
	103	NL_SET_ERR_MSG(extack, "no stats requested");
	104	return -EINVAL;
	105	}
	106
04692c90 VO	107	if (tb[ETHTOOL_A_STATS_SRC])
	108	src = nla_get_u32(tb[ETHTOOL_A_STATS_SRC]);
	109
	110	req_info->src = src;
	111
f09ea6fb JK	112	return 0;
	113	}
	114
	115	static int stats_prepare_data(const struct ethnl_req_info *req_base,
	116	struct ethnl_reply_data *reply_base,
	117	struct genl_info *info)
	118	{
	119	const struct stats_req_info *req_info = STATS_REQINFO(req_base);
c96de136	120	struct netlink_ext_ack *extack = info ? info->extack : NULL;
f09ea6fb	121	struct stats_reply_data *data = STATS_REPDATA(reply_base);
04692c90	122	enum ethtool_mac_stats_src src = req_info->src;
f09ea6fb JK	123	struct net_device *dev = reply_base->dev;
	124	int ret;
	125
	126	ret = ethnl_ops_begin(dev);
	127	if (ret < 0)
	128	return ret;
	129
04692c90 VO	130	if ((src == ETHTOOL_MAC_STATS_SRC_EMAC \|\|
	131	src == ETHTOOL_MAC_STATS_SRC_PMAC) &&
	132	!__ethtool_dev_mm_supported(dev)) {
	133	NL_SET_ERR_MSG_MOD(extack,
	134	"Device does not support MAC merge layer");
	135	ethnl_ops_complete(dev);
	136	return -EOPNOTSUPP;
	137	}
	138
d1f0a5e1 JK	139	/* Mark all stats as unset (see ETHTOOL_STAT_NOT_SET) to prevent them
	140	* from being reported to user space in case driver did not set them.
	141	*/
812ad3d2	142	memset(&data->stats, 0xff, sizeof(data->stats));
f09ea6fb	143
04692c90 VO	144	data->phy_stats.src = src;
	145	data->mac_stats.src = src;
	146	data->ctrl_stats.src = src;
	147	data->rmon_stats.src = src;
	148
f09ea6fb JK	149	if (test_bit(ETHTOOL_STATS_ETH_PHY, req_info->stat_mask) &&
	150	dev->ethtool_ops->get_eth_phy_stats)
	151	dev->ethtool_ops->get_eth_phy_stats(dev, &data->phy_stats);
ca224454 JK	152	if (test_bit(ETHTOOL_STATS_ETH_MAC, req_info->stat_mask) &&
	153	dev->ethtool_ops->get_eth_mac_stats)
	154	dev->ethtool_ops->get_eth_mac_stats(dev, &data->mac_stats);
bfad2b97 JK	155	if (test_bit(ETHTOOL_STATS_ETH_CTRL, req_info->stat_mask) &&
	156	dev->ethtool_ops->get_eth_ctrl_stats)
	157	dev->ethtool_ops->get_eth_ctrl_stats(dev, &data->ctrl_stats);
a8b06e9d JK	158	if (test_bit(ETHTOOL_STATS_RMON, req_info->stat_mask) &&
	159	dev->ethtool_ops->get_rmon_stats)
	160	dev->ethtool_ops->get_rmon_stats(dev, &data->rmon_stats,
	161	&data->rmon_ranges);
f09ea6fb JK	162
	163	ethnl_ops_complete(dev);
	164	return 0;
	165	}
	166
	167	static int stats_reply_size(const struct ethnl_req_info *req_base,
	168	const struct ethnl_reply_data *reply_base)
	169	{
	170	const struct stats_req_info *req_info = STATS_REQINFO(req_base);
	171	unsigned int n_grps = 0, n_stats = 0;
	172	int len = 0;
	173
04692c90 VO	174	len += nla_total_size(sizeof(u32)); /* _STATS_SRC */
04692c90 VO	175
f09ea6fb JK	176	if (test_bit(ETHTOOL_STATS_ETH_PHY, req_info->stat_mask)) {
	177	n_stats += sizeof(struct ethtool_eth_phy_stats) / sizeof(u64);
	178	n_grps++;
	179	}
ca224454 JK	180	if (test_bit(ETHTOOL_STATS_ETH_MAC, req_info->stat_mask)) {
	181	n_stats += sizeof(struct ethtool_eth_mac_stats) / sizeof(u64);
	182	n_grps++;
	183	}
bfad2b97 JK	184	if (test_bit(ETHTOOL_STATS_ETH_CTRL, req_info->stat_mask)) {
	185	n_stats += sizeof(struct ethtool_eth_ctrl_stats) / sizeof(u64);
	186	n_grps++;
	187	}
a8b06e9d JK	188	if (test_bit(ETHTOOL_STATS_RMON, req_info->stat_mask)) {
	189	n_stats += sizeof(struct ethtool_rmon_stats) / sizeof(u64);
	190	n_grps++;
	191	/* Above includes the space for _A_STATS_GRP_HIST_VALs */
	192
	193	len += (nla_total_size(0) + /* _A_STATS_GRP_HIST */
	194	nla_total_size(4) + /* _A_STATS_GRP_HIST_BKT_LOW */
	195	nla_total_size(4)) * /* _A_STATS_GRP_HIST_BKT_HI */
	196	ETHTOOL_RMON_HIST_MAX * 2;
	197	}
f09ea6fb JK	198
	199	len += n_grps * (nla_total_size(0) + /* _A_STATS_GRP */
	200	nla_total_size(4) + /* _A_STATS_GRP_ID */
	201	nla_total_size(4)); /* _A_STATS_GRP_SS_ID */
	202	len += n_stats * (nla_total_size(0) + /* _A_STATS_GRP_STAT */
	203	nla_total_size_64bit(sizeof(u64)));
	204
	205	return len;
	206	}
	207
	208	static int stat_put(struct sk_buff *skb, u16 attrtype, u64 val)
	209	{
	210	struct nlattr *nest;
	211	int ret;
	212
	213	if (val == ETHTOOL_STAT_NOT_SET)
	214	return 0;
	215
	216	/* We want to start stats attr types from 0, so we don't have a type
	217	* for pad inside ETHTOOL_A_STATS_GRP_STAT. Pad things on the outside
	218	* of ETHTOOL_A_STATS_GRP_STAT. Since we're one nest away from the
	219	* actual attr we're 4B off - nla_need_padding_for_64bit() & co.
	220	* can't be used.
	221	*/
	222	#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
	223	if (!IS_ALIGNED((unsigned long)skb_tail_pointer(skb), 8))
	224	if (!nla_reserve(skb, ETHTOOL_A_STATS_GRP_PAD, 0))
	225	return -EMSGSIZE;
	226	#endif
	227
	228	nest = nla_nest_start(skb, ETHTOOL_A_STATS_GRP_STAT);
	229	if (!nest)
	230	return -EMSGSIZE;
	231
	232	ret = nla_put_u64_64bit(skb, attrtype, val, -1 /* not used */);
	233	if (ret) {
	234	nla_nest_cancel(skb, nest);
	235	return ret;
	236	}
	237
	238	nla_nest_end(skb, nest);
	239	return 0;
	240	}
	241
	242	static int stats_put_phy_stats(struct sk_buff *skb,
	243	const struct stats_reply_data *data)
	244	{
	245	if (stat_put(skb, ETHTOOL_A_STATS_ETH_PHY_5_SYM_ERR,
	246	data->phy_stats.SymbolErrorDuringCarrier))
	247	return -EMSGSIZE;
	248	return 0;
	249	}
	250
ca224454 JK	251	static int stats_put_mac_stats(struct sk_buff *skb,
	252	const struct stats_reply_data *data)
	253	{
	254	if (stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_2_TX_PKT,
	255	data->mac_stats.FramesTransmittedOK) \|\|
	256	stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_3_SINGLE_COL,
	257	data->mac_stats.SingleCollisionFrames) \|\|
	258	stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_4_MULTI_COL,
	259	data->mac_stats.MultipleCollisionFrames) \|\|
	260	stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_5_RX_PKT,
	261	data->mac_stats.FramesReceivedOK) \|\|
	262	stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_6_FCS_ERR,
	263	data->mac_stats.FrameCheckSequenceErrors) \|\|
	264	stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_7_ALIGN_ERR,
	265	data->mac_stats.AlignmentErrors) \|\|
	266	stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_8_TX_BYTES,
	267	data->mac_stats.OctetsTransmittedOK) \|\|
	268	stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_9_TX_DEFER,
	269	data->mac_stats.FramesWithDeferredXmissions) \|\|
	270	stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_10_LATE_COL,
	271	data->mac_stats.LateCollisions) \|\|
	272	stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_11_XS_COL,
	273	data->mac_stats.FramesAbortedDueToXSColls) \|\|
	274	stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_12_TX_INT_ERR,
	275	data->mac_stats.FramesLostDueToIntMACXmitError) \|\|
	276	stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_13_CS_ERR,
	277	data->mac_stats.CarrierSenseErrors) \|\|
	278	stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_14_RX_BYTES,
	279	data->mac_stats.OctetsReceivedOK) \|\|
	280	stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_15_RX_INT_ERR,
	281	data->mac_stats.FramesLostDueToIntMACRcvError) \|\|
	282	stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_18_TX_MCAST,
	283	data->mac_stats.MulticastFramesXmittedOK) \|\|
	284	stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_19_TX_BCAST,
	285	data->mac_stats.BroadcastFramesXmittedOK) \|\|
	286	stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_20_XS_DEFER,
	287	data->mac_stats.FramesWithExcessiveDeferral) \|\|
	288	stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_21_RX_MCAST,
	289	data->mac_stats.MulticastFramesReceivedOK) \|\|
	290	stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_22_RX_BCAST,
	291	data->mac_stats.BroadcastFramesReceivedOK) \|\|
	292	stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_23_IR_LEN_ERR,
	293	data->mac_stats.InRangeLengthErrors) \|\|
	294	stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_24_OOR_LEN,
	295	data->mac_stats.OutOfRangeLengthField) \|\|
	296	stat_put(skb, ETHTOOL_A_STATS_ETH_MAC_25_TOO_LONG_ERR,
	297	data->mac_stats.FrameTooLongErrors))
	298	return -EMSGSIZE;
	299	return 0;
	300	}
	301
bfad2b97 JK	302	static int stats_put_ctrl_stats(struct sk_buff *skb,
	303	const struct stats_reply_data *data)
	304	{
	305	if (stat_put(skb, ETHTOOL_A_STATS_ETH_CTRL_3_TX,
	306	data->ctrl_stats.MACControlFramesTransmitted) \|\|
	307	stat_put(skb, ETHTOOL_A_STATS_ETH_CTRL_4_RX,
	308	data->ctrl_stats.MACControlFramesReceived) \|\|
	309	stat_put(skb, ETHTOOL_A_STATS_ETH_CTRL_5_RX_UNSUP,
	310	data->ctrl_stats.UnsupportedOpcodesReceived))
	311	return -EMSGSIZE;
	312	return 0;
	313	}
	314
a8b06e9d JK	315	static int stats_put_rmon_hist(struct sk_buff skb, u32 attr, const u64 hist,
	316	const struct ethtool_rmon_hist_range *ranges)
	317	{
	318	struct nlattr *nest;
	319	int i;
	320
	321	if (!ranges)
	322	return 0;
	323
	324	for (i = 0; i < ETHTOOL_RMON_HIST_MAX; i++) {
	325	if (!ranges[i].low && !ranges[i].high)
	326	break;
	327	if (hist[i] == ETHTOOL_STAT_NOT_SET)
	328	continue;
	329
	330	nest = nla_nest_start(skb, attr);
	331	if (!nest)
	332	return -EMSGSIZE;
	333
	334	if (nla_put_u32(skb, ETHTOOL_A_STATS_GRP_HIST_BKT_LOW,
	335	ranges[i].low) \|\|
	336	nla_put_u32(skb, ETHTOOL_A_STATS_GRP_HIST_BKT_HI,
	337	ranges[i].high) \|\|
	338	nla_put_u64_64bit(skb, ETHTOOL_A_STATS_GRP_HIST_VAL,
	339	hist[i], ETHTOOL_A_STATS_GRP_PAD))
	340	goto err_cancel_hist;
	341
	342	nla_nest_end(skb, nest);
	343	}
	344
	345	return 0;
	346
	347	err_cancel_hist:
	348	nla_nest_cancel(skb, nest);
	349	return -EMSGSIZE;
	350	}
	351
	352	static int stats_put_rmon_stats(struct sk_buff *skb,
	353	const struct stats_reply_data *data)
	354	{
	355	if (stats_put_rmon_hist(skb, ETHTOOL_A_STATS_GRP_HIST_RX,
	356	data->rmon_stats.hist, data->rmon_ranges) \|\|
	357	stats_put_rmon_hist(skb, ETHTOOL_A_STATS_GRP_HIST_TX,
	358	data->rmon_stats.hist_tx, data->rmon_ranges))
	359	return -EMSGSIZE;
	360
	361	if (stat_put(skb, ETHTOOL_A_STATS_RMON_UNDERSIZE,
	362	data->rmon_stats.undersize_pkts) \|\|
	363	stat_put(skb, ETHTOOL_A_STATS_RMON_OVERSIZE,
	364	data->rmon_stats.oversize_pkts) \|\|
	365	stat_put(skb, ETHTOOL_A_STATS_RMON_FRAG,
	366	data->rmon_stats.fragments) \|\|
	367	stat_put(skb, ETHTOOL_A_STATS_RMON_JABBER,
	368	data->rmon_stats.jabbers))
	369	return -EMSGSIZE;
	370
	371	return 0;
	372	}
	373
f09ea6fb JK	374	static int stats_put_stats(struct sk_buff *skb,
	375	const struct stats_reply_data *data,
	376	u32 id, u32 ss_id,
	377	int (cb)(struct sk_buff skb,
	378	const struct stats_reply_data *data))
	379	{
	380	struct nlattr *nest;
	381
	382	nest = nla_nest_start(skb, ETHTOOL_A_STATS_GRP);
	383	if (!nest)
	384	return -EMSGSIZE;
	385
	386	if (nla_put_u32(skb, ETHTOOL_A_STATS_GRP_ID, id) \|\|
	387	nla_put_u32(skb, ETHTOOL_A_STATS_GRP_SS_ID, ss_id))
	388	goto err_cancel;
	389
	390	if (cb(skb, data))
	391	goto err_cancel;
	392
	393	nla_nest_end(skb, nest);
	394	return 0;
	395
	396	err_cancel:
	397	nla_nest_cancel(skb, nest);
	398	return -EMSGSIZE;
	399	}
	400
	401	static int stats_fill_reply(struct sk_buff *skb,
	402	const struct ethnl_req_info *req_base,
	403	const struct ethnl_reply_data *reply_base)
	404	{
	405	const struct stats_req_info *req_info = STATS_REQINFO(req_base);
	406	const struct stats_reply_data *data = STATS_REPDATA(reply_base);
	407	int ret = 0;
	408
04692c90 VO	409	if (nla_put_u32(skb, ETHTOOL_A_STATS_SRC, req_info->src))
	410	return -EMSGSIZE;
	411
f09ea6fb JK	412	if (!ret && test_bit(ETHTOOL_STATS_ETH_PHY, req_info->stat_mask))
	413	ret = stats_put_stats(skb, data, ETHTOOL_STATS_ETH_PHY,
	414	ETH_SS_STATS_ETH_PHY,
	415	stats_put_phy_stats);
ca224454 JK	416	if (!ret && test_bit(ETHTOOL_STATS_ETH_MAC, req_info->stat_mask))
	417	ret = stats_put_stats(skb, data, ETHTOOL_STATS_ETH_MAC,
	418	ETH_SS_STATS_ETH_MAC,
	419	stats_put_mac_stats);
bfad2b97 JK	420	if (!ret && test_bit(ETHTOOL_STATS_ETH_CTRL, req_info->stat_mask))
	421	ret = stats_put_stats(skb, data, ETHTOOL_STATS_ETH_CTRL,
	422	ETH_SS_STATS_ETH_CTRL,
	423	stats_put_ctrl_stats);
a8b06e9d JK	424	if (!ret && test_bit(ETHTOOL_STATS_RMON, req_info->stat_mask))
	425	ret = stats_put_stats(skb, data, ETHTOOL_STATS_RMON,
	426	ETH_SS_STATS_RMON, stats_put_rmon_stats);
f09ea6fb JK	427
	428	return ret;
	429	}
	430
	431	const struct ethnl_request_ops ethnl_stats_request_ops = {
	432	.request_cmd = ETHTOOL_MSG_STATS_GET,
	433	.reply_cmd = ETHTOOL_MSG_STATS_GET_REPLY,
	434	.hdr_attr = ETHTOOL_A_STATS_HEADER,
	435	.req_info_size = sizeof(struct stats_req_info),
	436	.reply_data_size = sizeof(struct stats_reply_data),
	437
	438	.parse_request = stats_parse_request,
	439	.prepare_data = stats_prepare_data,
	440	.reply_size = stats_reply_size,
	441	.fill_reply = stats_fill_reply,
	442	};
449c5459 VO	443
	444	static u64 ethtool_stats_sum(u64 a, u64 b)
	445	{
	446	if (a == ETHTOOL_STAT_NOT_SET)
	447	return b;
	448	if (b == ETHTOOL_STAT_NOT_SET)
	449	return a;
	450	return a + b;
	451	}
	452
	453	/* Avoid modifying the aggregation procedure every time a new counter is added
	454	* by treating the structures as an array of u64 statistics.
	455	*/
	456	static void ethtool_aggregate_stats(void aggr_stats, const void emac_stats,
	457	const void *pmac_stats, size_t stats_size,
	458	size_t stats_offset)
	459	{
	460	size_t num_stats = stats_size / sizeof(u64);
	461	const u64 *s1 = emac_stats + stats_offset;
	462	const u64 *s2 = pmac_stats + stats_offset;
	463	u64 *s = aggr_stats + stats_offset;
	464	int i;
	465
	466	for (i = 0; i < num_stats; i++)
	467	s[i] = ethtool_stats_sum(s1[i], s2[i]);
	468	}
	469
	470	void ethtool_aggregate_mac_stats(struct net_device *dev,
	471	struct ethtool_eth_mac_stats *mac_stats)
	472	{
	473	const struct ethtool_ops *ops = dev->ethtool_ops;
	474	struct ethtool_eth_mac_stats pmac, emac;
	475
	476	memset(&emac, 0xff, sizeof(emac));
	477	memset(&pmac, 0xff, sizeof(pmac));
	478	emac.src = ETHTOOL_MAC_STATS_SRC_EMAC;
	479	pmac.src = ETHTOOL_MAC_STATS_SRC_PMAC;
	480
	481	ops->get_eth_mac_stats(dev, &emac);
	482	ops->get_eth_mac_stats(dev, &pmac);
	483
	484	ethtool_aggregate_stats(mac_stats, &emac, &pmac,
	485	sizeof(mac_stats->stats),
	486	offsetof(struct ethtool_eth_mac_stats, stats));
	487	}
	488	EXPORT_SYMBOL(ethtool_aggregate_mac_stats);
	489
	490	void ethtool_aggregate_phy_stats(struct net_device *dev,
	491	struct ethtool_eth_phy_stats *phy_stats)
	492	{
	493	const struct ethtool_ops *ops = dev->ethtool_ops;
	494	struct ethtool_eth_phy_stats pmac, emac;
	495
	496	memset(&emac, 0xff, sizeof(emac));
	497	memset(&pmac, 0xff, sizeof(pmac));
	498	emac.src = ETHTOOL_MAC_STATS_SRC_EMAC;
	499	pmac.src = ETHTOOL_MAC_STATS_SRC_PMAC;
	500
	501	ops->get_eth_phy_stats(dev, &emac);
	502	ops->get_eth_phy_stats(dev, &pmac);
	503
	504	ethtool_aggregate_stats(phy_stats, &emac, &pmac,
	505	sizeof(phy_stats->stats),
	506	offsetof(struct ethtool_eth_phy_stats, stats));
507	}
508	EXPORT_SYMBOL(ethtool_aggregate_phy_stats);
509
510	void ethtool_aggregate_ctrl_stats(struct net_device *dev,
511	struct ethtool_eth_ctrl_stats *ctrl_stats)
512	{
513	const struct ethtool_ops *ops = dev->ethtool_ops;
514	struct ethtool_eth_ctrl_stats pmac, emac;
515
516	memset(&emac, 0xff, sizeof(emac));
517	memset(&pmac, 0xff, sizeof(pmac));
518	emac.src = ETHTOOL_MAC_STATS_SRC_EMAC;
519	pmac.src = ETHTOOL_MAC_STATS_SRC_PMAC;
520
521	ops->get_eth_ctrl_stats(dev, &emac);
522	ops->get_eth_ctrl_stats(dev, &pmac);
523
524	ethtool_aggregate_stats(ctrl_stats, &emac, &pmac,
525	sizeof(ctrl_stats->stats),
526	offsetof(struct ethtool_eth_ctrl_stats, stats));
527	}
528	EXPORT_SYMBOL(ethtool_aggregate_ctrl_stats);
529
530	void ethtool_aggregate_pause_stats(struct net_device *dev,
531	struct ethtool_pause_stats *pause_stats)
532	{
533	const struct ethtool_ops *ops = dev->ethtool_ops;
534	struct ethtool_pause_stats pmac, emac;
535
536	memset(&emac, 0xff, sizeof(emac));
537	memset(&pmac, 0xff, sizeof(pmac));
538	emac.src = ETHTOOL_MAC_STATS_SRC_EMAC;
539	pmac.src = ETHTOOL_MAC_STATS_SRC_PMAC;
540
541	ops->get_pause_stats(dev, &emac);
542	ops->get_pause_stats(dev, &pmac);
543
544	ethtool_aggregate_stats(pause_stats, &emac, &pmac,
545	sizeof(pause_stats->stats),
546	offsetof(struct ethtool_pause_stats, stats));
547	}
548	EXPORT_SYMBOL(ethtool_aggregate_pause_stats);
549
550	void ethtool_aggregate_rmon_stats(struct net_device *dev,
551	struct ethtool_rmon_stats *rmon_stats)
552	{
553	const struct ethtool_ops *ops = dev->ethtool_ops;
554	const struct ethtool_rmon_hist_range *dummy;
555	struct ethtool_rmon_stats pmac, emac;
556
557	memset(&emac, 0xff, sizeof(emac));
558	memset(&pmac, 0xff, sizeof(pmac));
559	emac.src = ETHTOOL_MAC_STATS_SRC_EMAC;
560	pmac.src = ETHTOOL_MAC_STATS_SRC_PMAC;
561
562	ops->get_rmon_stats(dev, &emac, &dummy);
563	ops->get_rmon_stats(dev, &pmac, &dummy);
564
565	ethtool_aggregate_stats(rmon_stats, &emac, &pmac,
566	sizeof(rmon_stats->stats),
567	offsetof(struct ethtool_rmon_stats, stats));
568	}
569	EXPORT_SYMBOL(ethtool_aggregate_rmon_stats);