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