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);
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
16 struct 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
30 const 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
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
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
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
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
79 const 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
stats_parse_request(struct ethnl_req_info * req_base,struct nlattr ** tb,struct netlink_ext_ack * extack)87 static 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
stats_prepare_data(const struct ethnl_req_info * req_base,struct ethnl_reply_data * reply_base,struct genl_info * info)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);
120 struct netlink_ext_ack *extack = info ? info->extack : NULL;
121 struct stats_reply_data *data = STATS_REPDATA(reply_base);
122 enum ethtool_mac_stats_src src = req_info->src;
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
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
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 */
142 memset(&data->stats, 0xff, sizeof(data->stats));
143
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
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);
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);
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);
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);
162
163 ethnl_ops_complete(dev);
164 return 0;
165 }
166
stats_reply_size(const struct ethnl_req_info * req_base,const struct ethnl_reply_data * reply_base)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
174 len += nla_total_size(sizeof(u32)); /* _STATS_SRC */
175
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 }
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 }
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 }
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 }
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
stat_put(struct sk_buff * skb,u16 attrtype,u64 val)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
stats_put_phy_stats(struct sk_buff * skb,const struct stats_reply_data * data)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
stats_put_mac_stats(struct sk_buff * skb,const struct stats_reply_data * data)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
stats_put_ctrl_stats(struct sk_buff * skb,const struct stats_reply_data * data)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
stats_put_rmon_hist(struct sk_buff * skb,u32 attr,const u64 * hist,const struct ethtool_rmon_hist_range * ranges)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
stats_put_rmon_stats(struct sk_buff * skb,const struct stats_reply_data * data)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
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))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
stats_fill_reply(struct sk_buff * skb,const struct ethnl_req_info * req_base,const struct ethnl_reply_data * reply_base)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
409 if (nla_put_u32(skb, ETHTOOL_A_STATS_SRC, req_info->src))
410 return -EMSGSIZE;
411
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);
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);
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);
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);
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 };
443
ethtool_stats_sum(u64 a,u64 b)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 */
ethtool_aggregate_stats(void * aggr_stats,const void * emac_stats,const void * pmac_stats,size_t stats_size,size_t stats_offset)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
ethtool_aggregate_mac_stats(struct net_device * dev,struct ethtool_eth_mac_stats * mac_stats)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
ethtool_aggregate_phy_stats(struct net_device * dev,struct ethtool_eth_phy_stats * phy_stats)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
ethtool_aggregate_ctrl_stats(struct net_device * dev,struct ethtool_eth_ctrl_stats * ctrl_stats)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
ethtool_aggregate_pause_stats(struct net_device * dev,struct ethtool_pause_stats * pause_stats)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
ethtool_aggregate_rmon_stats(struct net_device * dev,struct ethtool_rmon_stats * rmon_stats)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);
570