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 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 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 stats_reply_data *data = STATS_REPDATA(reply_base); 121 enum ethtool_mac_stats_src src = req_info->src; 122 struct netlink_ext_ack *extack = info->extack; 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 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 208 static int stat_put(struct sk_buff *skb, u16 attrtype, u64 val) 209 { 210 struct nlattr *nest; 211 int ret; 212 213 if (val == ETHTOOL_STAT_NOT_SET) 214 return 0; 215 216 /* We want to start stats attr types from 0, so we don't have a type 217 * for pad inside ETHTOOL_A_STATS_GRP_STAT. Pad things on the outside 218 * of ETHTOOL_A_STATS_GRP_STAT. Since we're one nest away from the 219 * actual attr we're 4B off - nla_need_padding_for_64bit() & co. 220 * can't be used. 221 */ 222 #ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS 223 if (!IS_ALIGNED((unsigned long)skb_tail_pointer(skb), 8)) 224 if (!nla_reserve(skb, ETHTOOL_A_STATS_GRP_PAD, 0)) 225 return -EMSGSIZE; 226 #endif 227 228 nest = nla_nest_start(skb, ETHTOOL_A_STATS_GRP_STAT); 229 if (!nest) 230 return -EMSGSIZE; 231 232 ret = nla_put_u64_64bit(skb, attrtype, val, -1 /* not used */); 233 if (ret) { 234 nla_nest_cancel(skb, nest); 235 return ret; 236 } 237 238 nla_nest_end(skb, nest); 239 return 0; 240 } 241 242 static int stats_put_phy_stats(struct sk_buff *skb, 243 const struct stats_reply_data *data) 244 { 245 if (stat_put(skb, ETHTOOL_A_STATS_ETH_PHY_5_SYM_ERR, 246 data->phy_stats.SymbolErrorDuringCarrier)) 247 return -EMSGSIZE; 248 return 0; 249 } 250 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 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 315 static int stats_put_rmon_hist(struct sk_buff *skb, u32 attr, const u64 *hist, 316 const struct ethtool_rmon_hist_range *ranges) 317 { 318 struct nlattr *nest; 319 int i; 320 321 if (!ranges) 322 return 0; 323 324 for (i = 0; i < ETHTOOL_RMON_HIST_MAX; i++) { 325 if (!ranges[i].low && !ranges[i].high) 326 break; 327 if (hist[i] == ETHTOOL_STAT_NOT_SET) 328 continue; 329 330 nest = nla_nest_start(skb, attr); 331 if (!nest) 332 return -EMSGSIZE; 333 334 if (nla_put_u32(skb, ETHTOOL_A_STATS_GRP_HIST_BKT_LOW, 335 ranges[i].low) || 336 nla_put_u32(skb, ETHTOOL_A_STATS_GRP_HIST_BKT_HI, 337 ranges[i].high) || 338 nla_put_u64_64bit(skb, ETHTOOL_A_STATS_GRP_HIST_VAL, 339 hist[i], ETHTOOL_A_STATS_GRP_PAD)) 340 goto err_cancel_hist; 341 342 nla_nest_end(skb, nest); 343 } 344 345 return 0; 346 347 err_cancel_hist: 348 nla_nest_cancel(skb, nest); 349 return -EMSGSIZE; 350 } 351 352 static int stats_put_rmon_stats(struct sk_buff *skb, 353 const struct stats_reply_data *data) 354 { 355 if (stats_put_rmon_hist(skb, ETHTOOL_A_STATS_GRP_HIST_RX, 356 data->rmon_stats.hist, data->rmon_ranges) || 357 stats_put_rmon_hist(skb, ETHTOOL_A_STATS_GRP_HIST_TX, 358 data->rmon_stats.hist_tx, data->rmon_ranges)) 359 return -EMSGSIZE; 360 361 if (stat_put(skb, ETHTOOL_A_STATS_RMON_UNDERSIZE, 362 data->rmon_stats.undersize_pkts) || 363 stat_put(skb, ETHTOOL_A_STATS_RMON_OVERSIZE, 364 data->rmon_stats.oversize_pkts) || 365 stat_put(skb, ETHTOOL_A_STATS_RMON_FRAG, 366 data->rmon_stats.fragments) || 367 stat_put(skb, ETHTOOL_A_STATS_RMON_JABBER, 368 data->rmon_stats.jabbers)) 369 return -EMSGSIZE; 370 371 return 0; 372 } 373 374 static int stats_put_stats(struct sk_buff *skb, 375 const struct stats_reply_data *data, 376 u32 id, u32 ss_id, 377 int (*cb)(struct sk_buff *skb, 378 const struct stats_reply_data *data)) 379 { 380 struct nlattr *nest; 381 382 nest = nla_nest_start(skb, ETHTOOL_A_STATS_GRP); 383 if (!nest) 384 return -EMSGSIZE; 385 386 if (nla_put_u32(skb, ETHTOOL_A_STATS_GRP_ID, id) || 387 nla_put_u32(skb, ETHTOOL_A_STATS_GRP_SS_ID, ss_id)) 388 goto err_cancel; 389 390 if (cb(skb, data)) 391 goto err_cancel; 392 393 nla_nest_end(skb, nest); 394 return 0; 395 396 err_cancel: 397 nla_nest_cancel(skb, nest); 398 return -EMSGSIZE; 399 } 400 401 static int stats_fill_reply(struct sk_buff *skb, 402 const struct ethnl_req_info *req_base, 403 const struct ethnl_reply_data *reply_base) 404 { 405 const struct stats_req_info *req_info = STATS_REQINFO(req_base); 406 const struct stats_reply_data *data = STATS_REPDATA(reply_base); 407 int ret = 0; 408 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