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