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