1 /* 2 * This file and its contents are supplied under the terms of the 3 * Common Development and Distribution License ("CDDL"), version 1.0. 4 * You may only use this file in accordance with the terms of version 5 * 1.0 of the CDDL. 6 * 7 * A full copy of the text of the CDDL should have accompanied this 8 * source. A copy of the CDDL is also available via the Internet at 9 * http://www.illumos.org/license/CDDL. 10 */ 11 12 /* 13 * Copyright 2015 OmniTI Computer Consulting, Inc. All rights reserved. 14 * Copyright 2019 Joyent, Inc. 15 */ 16 17 #include "i40e_sw.h" 18 19 /* 20 * ------------------- 21 * Statistics Overview 22 * ------------------- 23 * 24 * As part of managing the driver and understanding what's going on, we keep 25 * track of statistics from two different sources: 26 * 27 * - Statistics from the device 28 * - Statistics maintained by the driver 29 * 30 * Generally, the hardware provides us traditional IETF and MIB Ethernet 31 * statistics, for example, the total packets in and out, various errors in 32 * packets, the negotiated status etc. The driver, on the other hand, primarily 33 * contains statistics around driver-specific issues, such as information about 34 * checksumming on receive and transmit and the data in and out of a specific 35 * ring. 36 * 37 * We export statistics in two different forms. The first form is the required 38 * GLDv3 endpoints, specifically: 39 * 40 * - The general GLDv3 mc_getstat interface 41 * - The GLDv3 ring mri_stat interface 42 * 43 * The second form that we export statistics is through kstats. kstats are 44 * exported in different ways. Particularly we arrange the kstats to monitor the 45 * layout of the device. Currently we have kstats which capture both the IEEE 46 * and driver-implementation specific stats. There are kstats for each of the 47 * following structures: 48 * 49 * - Each physical function 50 * - Each VSI 51 * - Each Queue 52 * 53 * The PF's kstat is called 'pfstats' so as not to collide with other system 54 * provided kstats. Thus, for instance 0, usually the first PF, the full kstat 55 * would be: i40e:0:pfstats:. 56 * 57 * The kstat for each VSI is called vsi_%instance. So for the first PF, which is 58 * instance zero and the first vsi, which has id 0, it will be named vsi_0 and 59 * the full kstat would be i40e:0:vsi_0:. 60 * 61 * The kstat for each queue is trqpair_tx_%queue and trqpair_rx_%queue. Note 62 * that these are labeled based on their local index, which may mean that 63 * different instances have overlapping sets of queues. This isn't a problem as 64 * the kstats will always use the instance number of the pf to distinguish it in 65 * the kstat tuple. 66 * 67 * --------------------- 68 * Hardware Arrangements 69 * --------------------- 70 * 71 * The hardware keeps statistics at each physical function/MAC (PF) and it keeps 72 * statistics on each virtual station interface (VSI). 73 * 74 * The hardware keeps these statistics as 32-bit and 48-bit counters. We are 75 * required to read them and then compute the differences between them. The 76 * 48-bit counters span more than one 32-bit register in the BAR. The hardware 77 * suggests that to read them, we perform 64-bit reads of the lower of the two 78 * registers that make up a 48-bit stat. The hardware guarantees that the reads 79 * of those two registers will be atomic and we'll get a consistent value, not a 80 * property it has for every read of two registers. 81 * 82 * For every kstat we have based on this, we have a corresponding uint64_t that 83 * we keep around as a base value in a separate structure. Whenever we read a 84 * value, we end up grabbing the current value, calculating a difference between 85 * the previously stored value and the current one, and updating the kstat with 86 * that difference. After which, we go through and update the base value that we 87 * stored. This is all encapsulated in i40e_stat_get_uint32() and 88 * i40e_stat_get_uint48(). 89 * 90 * The only unfortunate thing here is that the hardware doesn't give us any kind 91 * of overflow counter. It just tries to make sure that the uint32_t and 92 * uint48_t counters are large enough to hopefully not overflow right away. This 93 * isn't the most reassuring statement and we should investigate ways of 94 * ensuring that if a system is active, but not actively measured, we don't lose 95 * data. 96 * 97 * The pf kstats data is stored in the i40e_t`i40e_pf_kstat. It is backed by the 98 * i40e_t`i40e_pf_stat structure. Similarly the VSI related kstats are in 99 * i40e_t`i40e_vsis[idx].iv_kstats and the data is backed in the 100 * i40e_t`i40e_vsis[idx].iv_stats. All of this data is protected by the 101 * i40e_stat_lock, which should be taken last, when acquiring locks. 102 */ 103 104 static void 105 i40e_stat_get_uint48(i40e_t *i40e, uintptr_t reg, kstat_named_t *kstat, 106 uint64_t *base, boolean_t init) 107 { 108 i40e_hw_t *hw = &i40e->i40e_hw_space; 109 uint64_t raw, delta; 110 111 ASSERT(MUTEX_HELD(&i40e->i40e_stat_lock)); 112 113 raw = ddi_get64(i40e->i40e_osdep_space.ios_reg_handle, 114 (uint64_t *)((uintptr_t)hw->hw_addr + reg)); 115 116 if (init == B_TRUE) { 117 *base = raw; 118 return; 119 } 120 121 /* 122 * Check for wraparound, note that the counter is actually only 48-bits, 123 * even though it has two uint32_t regs present. 124 */ 125 if (raw >= *base) { 126 delta = raw - *base; 127 } else { 128 delta = 0x1000000000000ULL - *base + raw; 129 } 130 131 kstat->value.ui64 += delta; 132 *base = raw; 133 } 134 135 static void 136 i40e_stat_get_uint32(i40e_t *i40e, uintptr_t reg, kstat_named_t *kstat, 137 uint64_t *base, boolean_t init) 138 { 139 i40e_hw_t *hw = &i40e->i40e_hw_space; 140 uint64_t raw, delta; 141 142 ASSERT(MUTEX_HELD(&i40e->i40e_stat_lock)); 143 144 raw = ddi_get32(i40e->i40e_osdep_space.ios_reg_handle, 145 (uint32_t *)((uintptr_t)hw->hw_addr + reg)); 146 147 if (init == B_TRUE) { 148 *base = raw; 149 return; 150 } 151 152 /* 153 * Watch out for wraparound as we only have a 32-bit counter. 154 */ 155 if (raw >= *base) { 156 delta = raw - *base; 157 } else { 158 delta = 0x100000000ULL - *base + raw; 159 } 160 161 kstat->value.ui64 += delta; 162 *base = raw; 163 164 } 165 166 static void 167 i40e_stat_vsi_update(i40e_t *i40e, uint_t idx, boolean_t init) 168 { 169 i40e_vsi_stats_t *ivs; 170 i40e_vsi_kstats_t *ivk; 171 uint16_t id = i40e->i40e_vsis[idx].iv_stats_id; 172 173 ASSERT3P(i40e->i40e_vsis[idx].iv_kstats, !=, NULL); 174 ivs = &i40e->i40e_vsis[idx].iv_stats; 175 ivk = i40e->i40e_vsis[idx].iv_kstats->ks_data; 176 177 mutex_enter(&i40e->i40e_stat_lock); 178 179 i40e_stat_get_uint48(i40e, I40E_GLV_GORCL(id), &ivk->ivk_rx_bytes, 180 &ivs->ivs_rx_bytes, init); 181 i40e_stat_get_uint48(i40e, I40E_GLV_UPRCL(id), &ivk->ivk_rx_unicast, 182 &ivs->ivs_rx_unicast, init); 183 i40e_stat_get_uint48(i40e, I40E_GLV_MPRCL(id), &ivk->ivk_rx_multicast, 184 &ivs->ivs_rx_multicast, init); 185 i40e_stat_get_uint48(i40e, I40E_GLV_BPRCL(id), &ivk->ivk_rx_broadcast, 186 &ivs->ivs_rx_broadcast, init); 187 188 i40e_stat_get_uint32(i40e, I40E_GLV_RDPC(id), &ivk->ivk_rx_discards, 189 &ivs->ivs_rx_discards, init); 190 i40e_stat_get_uint32(i40e, I40E_GLV_RUPP(id), 191 &ivk->ivk_rx_unknown_protocol, 192 &ivs->ivs_rx_unknown_protocol, 193 init); 194 195 i40e_stat_get_uint48(i40e, I40E_GLV_GOTCL(id), &ivk->ivk_tx_bytes, 196 &ivs->ivs_tx_bytes, init); 197 i40e_stat_get_uint48(i40e, I40E_GLV_UPTCL(id), &ivk->ivk_tx_unicast, 198 &ivs->ivs_tx_unicast, init); 199 i40e_stat_get_uint48(i40e, I40E_GLV_MPTCL(id), &ivk->ivk_tx_multicast, 200 &ivs->ivs_tx_multicast, init); 201 i40e_stat_get_uint48(i40e, I40E_GLV_BPTCL(id), &ivk->ivk_tx_broadcast, 202 &ivs->ivs_tx_broadcast, init); 203 204 i40e_stat_get_uint32(i40e, I40E_GLV_TEPC(id), &ivk->ivk_tx_errors, 205 &ivs->ivs_tx_errors, init); 206 207 mutex_exit(&i40e->i40e_stat_lock); 208 209 /* 210 * We follow ixgbe's lead here and that if a kstat update didn't work 211 * 100% then we mark service unaffected as opposed to when fetching 212 * things for MAC directly. 213 */ 214 if (i40e_check_acc_handle(i40e->i40e_osdep_space.ios_reg_handle) != 215 DDI_FM_OK) { 216 ddi_fm_service_impact(i40e->i40e_dip, DDI_SERVICE_UNAFFECTED); 217 } 218 } 219 220 static int 221 i40e_stat_vsi_kstat_update(kstat_t *ksp, int rw) 222 { 223 i40e_t *i40e; 224 225 if (rw == KSTAT_WRITE) 226 return (EACCES); 227 228 i40e = ksp->ks_private; 229 for (uint_t i = 0; i < i40e->i40e_num_rx_groups; i++) 230 i40e_stat_vsi_update(i40e, i, B_FALSE); 231 232 return (0); 233 } 234 235 void 236 i40e_stat_vsi_fini(i40e_t *i40e, uint_t idx) 237 { 238 if (i40e->i40e_vsis[idx].iv_kstats != NULL) { 239 kstat_delete(i40e->i40e_vsis[idx].iv_kstats); 240 i40e->i40e_vsis[idx].iv_kstats = NULL; 241 } 242 } 243 244 boolean_t 245 i40e_stat_vsi_init(i40e_t *i40e, uint_t idx) 246 { 247 kstat_t *ksp; 248 i40e_vsi_kstats_t *ivk; 249 char buf[64]; 250 uint16_t vsi_id = i40e->i40e_vsis[idx].iv_seid; 251 252 (void) snprintf(buf, sizeof (buf), "vsi_%u", vsi_id); 253 254 ksp = kstat_create(I40E_MODULE_NAME, ddi_get_instance(i40e->i40e_dip), 255 buf, "net", KSTAT_TYPE_NAMED, 256 sizeof (i40e_vsi_kstats_t) / sizeof (kstat_named_t), 0); 257 258 if (ksp == NULL) { 259 i40e_error(i40e, "Failed to create kstats for VSI %u", vsi_id); 260 return (B_FALSE); 261 } 262 263 i40e->i40e_vsis[idx].iv_kstats = ksp; 264 ivk = ksp->ks_data; 265 ksp->ks_update = i40e_stat_vsi_kstat_update; 266 ksp->ks_private = i40e; 267 268 kstat_named_init(&ivk->ivk_rx_bytes, "rx_bytes", 269 KSTAT_DATA_UINT64); 270 kstat_named_init(&ivk->ivk_rx_unicast, "rx_unicast", 271 KSTAT_DATA_UINT64); 272 kstat_named_init(&ivk->ivk_rx_multicast, "rx_multicast", 273 KSTAT_DATA_UINT64); 274 kstat_named_init(&ivk->ivk_rx_broadcast, "rx_broadcast", 275 KSTAT_DATA_UINT64); 276 kstat_named_init(&ivk->ivk_rx_discards, "rx_discards", 277 KSTAT_DATA_UINT64); 278 kstat_named_init(&ivk->ivk_rx_unknown_protocol, "rx_unknown_protocol", 279 KSTAT_DATA_UINT64); 280 kstat_named_init(&ivk->ivk_tx_bytes, "tx_bytes", 281 KSTAT_DATA_UINT64); 282 kstat_named_init(&ivk->ivk_tx_unicast, "tx_unicast", 283 KSTAT_DATA_UINT64); 284 kstat_named_init(&ivk->ivk_tx_multicast, "tx_multicast", 285 KSTAT_DATA_UINT64); 286 kstat_named_init(&ivk->ivk_tx_broadcast, "tx_broadcast", 287 KSTAT_DATA_UINT64); 288 kstat_named_init(&ivk->ivk_tx_errors, "tx_errors", 289 KSTAT_DATA_UINT64); 290 291 bzero(&i40e->i40e_vsis[idx].iv_stats, sizeof (i40e_vsi_stats_t)); 292 i40e_stat_vsi_update(i40e, idx, B_TRUE); 293 kstat_install(i40e->i40e_vsis[idx].iv_kstats); 294 295 return (B_TRUE); 296 } 297 298 static void 299 i40e_stat_pf_update(i40e_t *i40e, boolean_t init) 300 { 301 i40e_pf_stats_t *ips; 302 i40e_pf_kstats_t *ipk; 303 int port = i40e->i40e_hw_space.port; 304 int i; 305 306 ASSERT(i40e->i40e_pf_kstat != NULL); 307 ips = &i40e->i40e_pf_stat; 308 ipk = i40e->i40e_pf_kstat->ks_data; 309 310 mutex_enter(&i40e->i40e_stat_lock); 311 312 /* 64-bit PCIe regs */ 313 i40e_stat_get_uint48(i40e, I40E_GLPRT_GORCL(port), 314 &ipk->ipk_rx_bytes, &ips->ips_rx_bytes, init); 315 i40e_stat_get_uint48(i40e, I40E_GLPRT_UPRCL(port), 316 &ipk->ipk_rx_unicast, &ips->ips_rx_unicast, init); 317 i40e_stat_get_uint48(i40e, I40E_GLPRT_MPRCL(port), 318 &ipk->ipk_rx_multicast, &ips->ips_rx_multicast, init); 319 i40e_stat_get_uint48(i40e, I40E_GLPRT_BPRCL(port), 320 &ipk->ipk_rx_broadcast, &ips->ips_rx_broadcast, init); 321 i40e_stat_get_uint48(i40e, I40E_GLPRT_GOTCL(port), 322 &ipk->ipk_tx_bytes, &ips->ips_tx_bytes, init); 323 i40e_stat_get_uint48(i40e, I40E_GLPRT_UPTCL(port), 324 &ipk->ipk_tx_unicast, &ips->ips_tx_unicast, init); 325 i40e_stat_get_uint48(i40e, I40E_GLPRT_MPTCL(port), 326 &ipk->ipk_tx_multicast, &ips->ips_tx_multicast, init); 327 i40e_stat_get_uint48(i40e, I40E_GLPRT_BPTCL(port), 328 &ipk->ipk_tx_broadcast, &ips->ips_tx_broadcast, init); 329 330 i40e_stat_get_uint48(i40e, I40E_GLPRT_PRC64L(port), 331 &ipk->ipk_rx_size_64, &ips->ips_rx_size_64, init); 332 i40e_stat_get_uint48(i40e, I40E_GLPRT_PRC127L(port), 333 &ipk->ipk_rx_size_127, &ips->ips_rx_size_127, init); 334 i40e_stat_get_uint48(i40e, I40E_GLPRT_PRC255L(port), 335 &ipk->ipk_rx_size_255, &ips->ips_rx_size_255, init); 336 i40e_stat_get_uint48(i40e, I40E_GLPRT_PRC511L(port), 337 &ipk->ipk_rx_size_511, &ips->ips_rx_size_511, init); 338 i40e_stat_get_uint48(i40e, I40E_GLPRT_PRC1023L(port), 339 &ipk->ipk_rx_size_1023, &ips->ips_rx_size_1023, init); 340 i40e_stat_get_uint48(i40e, I40E_GLPRT_PRC1522L(port), 341 &ipk->ipk_rx_size_1522, &ips->ips_rx_size_1522, init); 342 i40e_stat_get_uint48(i40e, I40E_GLPRT_PRC9522L(port), 343 &ipk->ipk_rx_size_9522, &ips->ips_rx_size_9522, init); 344 345 i40e_stat_get_uint48(i40e, I40E_GLPRT_PTC64L(port), 346 &ipk->ipk_tx_size_64, &ips->ips_tx_size_64, init); 347 i40e_stat_get_uint48(i40e, I40E_GLPRT_PTC127L(port), 348 &ipk->ipk_tx_size_127, &ips->ips_tx_size_127, init); 349 i40e_stat_get_uint48(i40e, I40E_GLPRT_PTC255L(port), 350 &ipk->ipk_tx_size_255, &ips->ips_tx_size_255, init); 351 i40e_stat_get_uint48(i40e, I40E_GLPRT_PTC511L(port), 352 &ipk->ipk_tx_size_511, &ips->ips_tx_size_511, init); 353 i40e_stat_get_uint48(i40e, I40E_GLPRT_PTC1023L(port), 354 &ipk->ipk_tx_size_1023, &ips->ips_tx_size_1023, init); 355 i40e_stat_get_uint48(i40e, I40E_GLPRT_PTC1522L(port), 356 &ipk->ipk_tx_size_1522, &ips->ips_tx_size_1522, init); 357 i40e_stat_get_uint48(i40e, I40E_GLPRT_PTC9522L(port), 358 &ipk->ipk_tx_size_9522, &ips->ips_tx_size_9522, init); 359 360 /* 32-bit PCIe regs */ 361 i40e_stat_get_uint32(i40e, I40E_GLPRT_LXONRXC(port), 362 &ipk->ipk_link_xon_rx, &ips->ips_link_xon_rx, init); 363 i40e_stat_get_uint32(i40e, I40E_GLPRT_LXOFFRXC(port), 364 &ipk->ipk_link_xoff_rx, &ips->ips_link_xoff_rx, init); 365 i40e_stat_get_uint32(i40e, I40E_GLPRT_LXONTXC(port), 366 &ipk->ipk_link_xon_tx, &ips->ips_link_xon_tx, init); 367 i40e_stat_get_uint32(i40e, I40E_GLPRT_LXOFFTXC(port), 368 &ipk->ipk_link_xoff_tx, &ips->ips_link_xoff_tx, init); 369 370 for (i = 0; i < 8; i++) { 371 i40e_stat_get_uint32(i40e, I40E_GLPRT_PXONRXC(port, i), 372 &ipk->ipk_priority_xon_rx[i], &ips->ips_priority_xon_rx[i], 373 init); 374 i40e_stat_get_uint32(i40e, I40E_GLPRT_PXOFFRXC(port, i), 375 &ipk->ipk_priority_xoff_rx[i], 376 &ips->ips_priority_xoff_rx[i], 377 init); 378 i40e_stat_get_uint32(i40e, I40E_GLPRT_PXONTXC(port, i), 379 &ipk->ipk_priority_xon_tx[i], &ips->ips_priority_xon_tx[i], 380 init); 381 i40e_stat_get_uint32(i40e, I40E_GLPRT_PXOFFTXC(port, i), 382 &ipk->ipk_priority_xoff_tx[i], 383 &ips->ips_priority_xoff_tx[i], 384 init); 385 i40e_stat_get_uint32(i40e, I40E_GLPRT_RXON2OFFCNT(port, i), 386 &ipk->ipk_priority_xon_2_xoff[i], 387 &ips->ips_priority_xon_2_xoff[i], 388 init); 389 } 390 391 i40e_stat_get_uint32(i40e, I40E_GLPRT_CRCERRS(port), 392 &ipk->ipk_crc_errors, &ips->ips_crc_errors, init); 393 i40e_stat_get_uint32(i40e, I40E_GLPRT_ILLERRC(port), 394 &ipk->ipk_illegal_bytes, &ips->ips_illegal_bytes, init); 395 i40e_stat_get_uint32(i40e, I40E_GLPRT_MLFC(port), 396 &ipk->ipk_mac_local_faults, &ips->ips_mac_local_faults, init); 397 i40e_stat_get_uint32(i40e, I40E_GLPRT_MRFC(port), 398 &ipk->ipk_mac_remote_faults, &ips->ips_mac_remote_faults, init); 399 i40e_stat_get_uint32(i40e, I40E_GLPRT_RLEC(port), 400 &ipk->ipk_rx_length_errors, &ips->ips_rx_length_errors, init); 401 i40e_stat_get_uint32(i40e, I40E_GLPRT_RUC(port), 402 &ipk->ipk_rx_undersize, &ips->ips_rx_undersize, init); 403 i40e_stat_get_uint32(i40e, I40E_GLPRT_RFC(port), 404 &ipk->ipk_rx_fragments, &ips->ips_rx_fragments, init); 405 i40e_stat_get_uint32(i40e, I40E_GLPRT_ROC(port), 406 &ipk->ipk_rx_oversize, &ips->ips_rx_oversize, init); 407 i40e_stat_get_uint32(i40e, I40E_GLPRT_RJC(port), 408 &ipk->ipk_rx_jabber, &ips->ips_rx_jabber, init); 409 i40e_stat_get_uint32(i40e, I40E_GLPRT_RDPC(port), 410 &ipk->ipk_rx_discards, &ips->ips_rx_discards, init); 411 i40e_stat_get_uint32(i40e, I40E_GLPRT_LDPC(port), 412 &ipk->ipk_rx_vm_discards, &ips->ips_rx_vm_discards, init); 413 i40e_stat_get_uint32(i40e, I40E_GLPRT_MSPDC(port), 414 &ipk->ipk_rx_short_discards, &ips->ips_rx_short_discards, init); 415 i40e_stat_get_uint32(i40e, I40E_GLPRT_TDOLD(port), 416 &ipk->ipk_tx_dropped_link_down, &ips->ips_tx_dropped_link_down, 417 init); 418 i40e_stat_get_uint32(i40e, I40E_GLPRT_RUPP(port), 419 &ipk->ipk_rx_unknown_protocol, &ips->ips_rx_unknown_protocol, init); 420 421 /* 64-bit */ 422 i40e_stat_get_uint48(i40e, I40E_GL_RXERR1_L(port), &ipk->ipk_rx_err1, 423 &ips->ips_rx_err1, init); 424 i40e_stat_get_uint48(i40e, I40E_GL_RXERR2_L(port), &ipk->ipk_rx_err2, 425 &ips->ips_rx_err2, init); 426 427 mutex_exit(&i40e->i40e_stat_lock); 428 429 /* 430 * We follow ixgbe's lead here and that if a kstat update didn't work 431 * 100% then we mark service unaffected as opposed to when fetching 432 * things for MAC directly. 433 */ 434 if (i40e_check_acc_handle(i40e->i40e_osdep_space.ios_reg_handle) != 435 DDI_FM_OK) { 436 ddi_fm_service_impact(i40e->i40e_dip, DDI_SERVICE_UNAFFECTED); 437 } 438 } 439 440 static int 441 i40e_stat_pf_kstat_update(kstat_t *ksp, int rw) 442 { 443 i40e_t *i40e; 444 445 if (rw == KSTAT_WRITE) 446 return (EACCES); 447 448 i40e = ksp->ks_private; 449 i40e_stat_pf_update(i40e, B_FALSE); 450 return (0); 451 } 452 453 454 static boolean_t 455 i40e_stat_pf_init(i40e_t *i40e) 456 { 457 kstat_t *ksp; 458 i40e_pf_kstats_t *ipk; 459 460 ksp = kstat_create(I40E_MODULE_NAME, ddi_get_instance(i40e->i40e_dip), 461 "pfstats", "net", KSTAT_TYPE_NAMED, 462 sizeof (i40e_pf_kstats_t) / sizeof (kstat_named_t), 0); 463 if (ksp == NULL) { 464 i40e_error(i40e, "Could not create kernel statistics."); 465 return (B_FALSE); 466 } 467 468 i40e->i40e_pf_kstat = ksp; 469 ipk = ksp->ks_data; 470 ksp->ks_update = i40e_stat_pf_kstat_update; 471 ksp->ks_private = i40e; 472 473 kstat_named_init(&ipk->ipk_rx_bytes, "rx_bytes", 474 KSTAT_DATA_UINT64); 475 kstat_named_init(&ipk->ipk_rx_unicast, "rx_unicast", 476 KSTAT_DATA_UINT64); 477 kstat_named_init(&ipk->ipk_rx_multicast, "rx_multicast", 478 KSTAT_DATA_UINT64); 479 kstat_named_init(&ipk->ipk_rx_broadcast, "rx_broadcast", 480 KSTAT_DATA_UINT64); 481 kstat_named_init(&ipk->ipk_tx_bytes, "tx_bytes", 482 KSTAT_DATA_UINT64); 483 kstat_named_init(&ipk->ipk_tx_unicast, "tx_unicast", 484 KSTAT_DATA_UINT64); 485 kstat_named_init(&ipk->ipk_tx_multicast, "tx_multicast", 486 KSTAT_DATA_UINT64); 487 kstat_named_init(&ipk->ipk_tx_broadcast, "tx_broadcast", 488 KSTAT_DATA_UINT64); 489 490 kstat_named_init(&ipk->ipk_rx_size_64, "rx_size_64", 491 KSTAT_DATA_UINT64); 492 kstat_named_init(&ipk->ipk_rx_size_127, "rx_size_127", 493 KSTAT_DATA_UINT64); 494 kstat_named_init(&ipk->ipk_rx_size_255, "rx_size_255", 495 KSTAT_DATA_UINT64); 496 kstat_named_init(&ipk->ipk_rx_size_511, "rx_size_511", 497 KSTAT_DATA_UINT64); 498 kstat_named_init(&ipk->ipk_rx_size_1023, "rx_size_1023", 499 KSTAT_DATA_UINT64); 500 kstat_named_init(&ipk->ipk_rx_size_1522, "rx_size_1522", 501 KSTAT_DATA_UINT64); 502 kstat_named_init(&ipk->ipk_rx_size_9522, "rx_size_9522", 503 KSTAT_DATA_UINT64); 504 505 kstat_named_init(&ipk->ipk_tx_size_64, "tx_size_64", 506 KSTAT_DATA_UINT64); 507 kstat_named_init(&ipk->ipk_tx_size_127, "tx_size_127", 508 KSTAT_DATA_UINT64); 509 kstat_named_init(&ipk->ipk_tx_size_255, "tx_size_255", 510 KSTAT_DATA_UINT64); 511 kstat_named_init(&ipk->ipk_tx_size_511, "tx_size_511", 512 KSTAT_DATA_UINT64); 513 kstat_named_init(&ipk->ipk_tx_size_1023, "tx_size_1023", 514 KSTAT_DATA_UINT64); 515 kstat_named_init(&ipk->ipk_tx_size_1522, "tx_size_1522", 516 KSTAT_DATA_UINT64); 517 kstat_named_init(&ipk->ipk_tx_size_9522, "tx_size_9522", 518 KSTAT_DATA_UINT64); 519 520 kstat_named_init(&ipk->ipk_link_xon_rx, "link_xon_rx", 521 KSTAT_DATA_UINT64); 522 kstat_named_init(&ipk->ipk_link_xoff_rx, "link_xoff_rx", 523 KSTAT_DATA_UINT64); 524 kstat_named_init(&ipk->ipk_link_xon_tx, "link_xon_tx", 525 KSTAT_DATA_UINT64); 526 kstat_named_init(&ipk->ipk_link_xoff_tx, "link_xoff_tx", 527 KSTAT_DATA_UINT64); 528 529 kstat_named_init(&ipk->ipk_priority_xon_rx[0], "priority_xon_rx[0]", 530 KSTAT_DATA_UINT64); 531 kstat_named_init(&ipk->ipk_priority_xoff_rx[0], "priority_xoff_rx[0]", 532 KSTAT_DATA_UINT64); 533 kstat_named_init(&ipk->ipk_priority_xon_tx[0], "priority_xon_tx[0]", 534 KSTAT_DATA_UINT64); 535 kstat_named_init(&ipk->ipk_priority_xoff_tx[0], "priority_xoff_tx[0]", 536 KSTAT_DATA_UINT64); 537 kstat_named_init(&ipk->ipk_priority_xon_2_xoff[0], 538 "priority_xon_2_xoff[0]", 539 KSTAT_DATA_UINT64); 540 541 kstat_named_init(&ipk->ipk_priority_xon_rx[1], "priority_xon_rx[1]", 542 KSTAT_DATA_UINT64); 543 kstat_named_init(&ipk->ipk_priority_xoff_rx[1], "priority_xoff_rx[1]", 544 KSTAT_DATA_UINT64); 545 kstat_named_init(&ipk->ipk_priority_xon_tx[1], "priority_xon_tx[1]", 546 KSTAT_DATA_UINT64); 547 kstat_named_init(&ipk->ipk_priority_xoff_tx[1], "priority_xoff_tx[1]", 548 KSTAT_DATA_UINT64); 549 kstat_named_init(&ipk->ipk_priority_xon_2_xoff[1], 550 "priority_xon_2_xoff[1]", 551 KSTAT_DATA_UINT64); 552 553 kstat_named_init(&ipk->ipk_priority_xon_rx[2], "priority_xon_rx[2]", 554 KSTAT_DATA_UINT64); 555 kstat_named_init(&ipk->ipk_priority_xoff_rx[2], "priority_xoff_rx[2]", 556 KSTAT_DATA_UINT64); 557 kstat_named_init(&ipk->ipk_priority_xon_tx[2], "priority_xon_tx[2]", 558 KSTAT_DATA_UINT64); 559 kstat_named_init(&ipk->ipk_priority_xoff_tx[2], "priority_xoff_tx[2]", 560 KSTAT_DATA_UINT64); 561 kstat_named_init(&ipk->ipk_priority_xon_2_xoff[2], 562 "priority_xon_2_xoff[2]", 563 KSTAT_DATA_UINT64); 564 565 kstat_named_init(&ipk->ipk_priority_xon_rx[3], "priority_xon_rx[3]", 566 KSTAT_DATA_UINT64); 567 kstat_named_init(&ipk->ipk_priority_xoff_rx[3], "priority_xoff_rx[3]", 568 KSTAT_DATA_UINT64); 569 kstat_named_init(&ipk->ipk_priority_xon_tx[3], "priority_xon_tx[3]", 570 KSTAT_DATA_UINT64); 571 kstat_named_init(&ipk->ipk_priority_xoff_tx[3], "priority_xoff_tx[3]", 572 KSTAT_DATA_UINT64); 573 kstat_named_init(&ipk->ipk_priority_xon_2_xoff[3], 574 "priority_xon_2_xoff[3]", 575 KSTAT_DATA_UINT64); 576 577 kstat_named_init(&ipk->ipk_priority_xon_rx[4], "priority_xon_rx[4]", 578 KSTAT_DATA_UINT64); 579 kstat_named_init(&ipk->ipk_priority_xoff_rx[4], "priority_xoff_rx[4]", 580 KSTAT_DATA_UINT64); 581 kstat_named_init(&ipk->ipk_priority_xon_tx[4], "priority_xon_tx[4]", 582 KSTAT_DATA_UINT64); 583 kstat_named_init(&ipk->ipk_priority_xoff_tx[4], "priority_xoff_tx[4]", 584 KSTAT_DATA_UINT64); 585 kstat_named_init(&ipk->ipk_priority_xon_2_xoff[4], 586 "priority_xon_2_xoff[4]", 587 KSTAT_DATA_UINT64); 588 589 kstat_named_init(&ipk->ipk_priority_xon_rx[5], "priority_xon_rx[5]", 590 KSTAT_DATA_UINT64); 591 kstat_named_init(&ipk->ipk_priority_xoff_rx[5], "priority_xoff_rx[5]", 592 KSTAT_DATA_UINT64); 593 kstat_named_init(&ipk->ipk_priority_xon_tx[5], "priority_xon_tx[5]", 594 KSTAT_DATA_UINT64); 595 kstat_named_init(&ipk->ipk_priority_xoff_tx[5], "priority_xoff_tx[5]", 596 KSTAT_DATA_UINT64); 597 kstat_named_init(&ipk->ipk_priority_xon_2_xoff[5], 598 "priority_xon_2_xoff[5]", 599 KSTAT_DATA_UINT64); 600 601 kstat_named_init(&ipk->ipk_priority_xon_rx[6], "priority_xon_rx[6]", 602 KSTAT_DATA_UINT64); 603 kstat_named_init(&ipk->ipk_priority_xoff_rx[6], "priority_xoff_rx[6]", 604 KSTAT_DATA_UINT64); 605 kstat_named_init(&ipk->ipk_priority_xon_tx[6], "priority_xon_tx[6]", 606 KSTAT_DATA_UINT64); 607 kstat_named_init(&ipk->ipk_priority_xoff_tx[6], "priority_xoff_tx[6]", 608 KSTAT_DATA_UINT64); 609 kstat_named_init(&ipk->ipk_priority_xon_2_xoff[6], 610 "priority_xon_2_xoff[6]", 611 KSTAT_DATA_UINT64); 612 613 kstat_named_init(&ipk->ipk_priority_xon_rx[7], "priority_xon_rx[7]", 614 KSTAT_DATA_UINT64); 615 kstat_named_init(&ipk->ipk_priority_xoff_rx[7], "priority_xoff_rx[7]", 616 KSTAT_DATA_UINT64); 617 kstat_named_init(&ipk->ipk_priority_xon_tx[7], "priority_xon_tx[7]", 618 KSTAT_DATA_UINT64); 619 kstat_named_init(&ipk->ipk_priority_xoff_tx[7], "priority_xoff_tx[7]", 620 KSTAT_DATA_UINT64); 621 kstat_named_init(&ipk->ipk_priority_xon_2_xoff[7], 622 "priority_xon_2_xoff[7]", 623 KSTAT_DATA_UINT64); 624 625 kstat_named_init(&ipk->ipk_crc_errors, "crc_errors", 626 KSTAT_DATA_UINT64); 627 kstat_named_init(&ipk->ipk_illegal_bytes, "illegal_bytes", 628 KSTAT_DATA_UINT64); 629 kstat_named_init(&ipk->ipk_mac_local_faults, "mac_local_faults", 630 KSTAT_DATA_UINT64); 631 kstat_named_init(&ipk->ipk_mac_remote_faults, "mac_remote_faults", 632 KSTAT_DATA_UINT64); 633 kstat_named_init(&ipk->ipk_rx_length_errors, "rx_length_errors", 634 KSTAT_DATA_UINT64); 635 kstat_named_init(&ipk->ipk_rx_undersize, "rx_undersize", 636 KSTAT_DATA_UINT64); 637 kstat_named_init(&ipk->ipk_rx_fragments, "rx_fragments", 638 KSTAT_DATA_UINT64); 639 kstat_named_init(&ipk->ipk_rx_oversize, "rx_oversize", 640 KSTAT_DATA_UINT64); 641 kstat_named_init(&ipk->ipk_rx_jabber, "rx_jabber", 642 KSTAT_DATA_UINT64); 643 kstat_named_init(&ipk->ipk_rx_discards, "rx_discards", 644 KSTAT_DATA_UINT64); 645 kstat_named_init(&ipk->ipk_rx_vm_discards, "rx_vm_discards", 646 KSTAT_DATA_UINT64); 647 kstat_named_init(&ipk->ipk_rx_short_discards, "rx_short_discards", 648 KSTAT_DATA_UINT64); 649 kstat_named_init(&ipk->ipk_tx_dropped_link_down, "tx_dropped_link_down", 650 KSTAT_DATA_UINT64); 651 kstat_named_init(&ipk->ipk_rx_unknown_protocol, "rx_unknown_protocol", 652 KSTAT_DATA_UINT64); 653 kstat_named_init(&ipk->ipk_rx_err1, "rx_err1", 654 KSTAT_DATA_UINT64); 655 kstat_named_init(&ipk->ipk_rx_err2, "rx_err2", 656 KSTAT_DATA_UINT64); 657 658 659 bzero(&i40e->i40e_pf_stat, sizeof (i40e_pf_stats_t)); 660 i40e_stat_pf_update(i40e, B_TRUE); 661 662 kstat_install(i40e->i40e_pf_kstat); 663 664 return (B_TRUE); 665 } 666 667 void 668 i40e_stats_fini(i40e_t *i40e) 669 { 670 #ifdef DEBUG 671 for (uint_t i = 0; i < i40e->i40e_num_rx_groups; i++) { 672 ASSERT3P(i40e->i40e_vsis[i].iv_kstats, ==, NULL); 673 } 674 #endif 675 676 if (i40e->i40e_pf_kstat != NULL) { 677 kstat_delete(i40e->i40e_pf_kstat); 678 i40e->i40e_pf_kstat = NULL; 679 } 680 681 mutex_destroy(&i40e->i40e_stat_lock); 682 } 683 684 boolean_t 685 i40e_stats_init(i40e_t *i40e) 686 { 687 mutex_init(&i40e->i40e_stat_lock, NULL, MUTEX_DRIVER, NULL); 688 if (i40e_stat_pf_init(i40e) == B_FALSE) { 689 mutex_destroy(&i40e->i40e_stat_lock); 690 return (B_FALSE); 691 } 692 693 return (B_TRUE); 694 } 695 696 /* 697 * For Nemo/GLDv3. 698 */ 699 int 700 i40e_m_stat(void *arg, uint_t stat, uint64_t *val) 701 { 702 i40e_t *i40e = (i40e_t *)arg; 703 i40e_hw_t *hw = &i40e->i40e_hw_space; 704 int port = i40e->i40e_hw_space.port; 705 i40e_pf_stats_t *ips; 706 i40e_pf_kstats_t *ipk; 707 708 709 ASSERT(i40e->i40e_pf_kstat != NULL); 710 ips = &i40e->i40e_pf_stat; 711 ipk = i40e->i40e_pf_kstat->ks_data; 712 713 /* 714 * We need both locks, as various stats are protected by different 715 * things here. 716 */ 717 mutex_enter(&i40e->i40e_general_lock); 718 719 if (i40e->i40e_state & I40E_SUSPENDED) { 720 mutex_exit(&i40e->i40e_general_lock); 721 return (ECANCELED); 722 } 723 724 mutex_enter(&i40e->i40e_stat_lock); 725 726 /* 727 * Unfortunately the GLDv3 conflates two rather different things here. 728 * We're combining statistics about the physical port represented by 729 * this instance with statistics that describe the properties of the 730 * logical interface. As such, we're going to use the various aspects of 731 * the port to describe these stats as they represent what the physical 732 * instance is doing, even though that that means some tools may be 733 * confused and that to see the logical traffic on the interface itself 734 * sans VNICs and the like will require more work. 735 * 736 * Stats which are not listed in this switch statement are unimplemented 737 * at this time in hardware or don't currently apply to the device. 738 */ 739 switch (stat) { 740 /* MIB-II stats (RFC 1213 and RFC 1573) */ 741 case MAC_STAT_IFSPEED: 742 *val = i40e->i40e_link_speed * 1000000ull; 743 break; 744 case MAC_STAT_MULTIRCV: 745 i40e_stat_get_uint48(i40e, I40E_GLPRT_MPRCL(port), 746 &ipk->ipk_rx_multicast, &ips->ips_rx_multicast, B_FALSE); 747 *val = ipk->ipk_rx_multicast.value.ui64; 748 break; 749 case MAC_STAT_BRDCSTRCV: 750 i40e_stat_get_uint48(i40e, I40E_GLPRT_BPRCL(port), 751 &ipk->ipk_rx_broadcast, &ips->ips_rx_broadcast, B_FALSE); 752 *val = ipk->ipk_rx_broadcast.value.ui64; 753 break; 754 case MAC_STAT_MULTIXMT: 755 i40e_stat_get_uint48(i40e, I40E_GLPRT_MPTCL(port), 756 &ipk->ipk_tx_multicast, &ips->ips_tx_multicast, B_FALSE); 757 *val = ipk->ipk_tx_multicast.value.ui64; 758 break; 759 case MAC_STAT_BRDCSTXMT: 760 i40e_stat_get_uint48(i40e, I40E_GLPRT_BPTCL(port), 761 &ipk->ipk_tx_broadcast, &ips->ips_tx_broadcast, B_FALSE); 762 *val = ipk->ipk_tx_broadcast.value.ui64; 763 break; 764 case MAC_STAT_NORCVBUF: 765 i40e_stat_get_uint32(i40e, I40E_GLPRT_RDPC(port), 766 &ipk->ipk_rx_discards, &ips->ips_rx_discards, B_FALSE); 767 i40e_stat_get_uint32(i40e, I40E_GLPRT_LDPC(port), 768 &ipk->ipk_rx_vm_discards, &ips->ips_rx_vm_discards, 769 B_FALSE); 770 *val = ipk->ipk_rx_discards.value.ui64 + 771 ipk->ipk_rx_vm_discards.value.ui64; 772 break; 773 /* 774 * Note, that some RXERR2 stats are also duplicated by the switch filter 775 * stats; however, since we're not using those at this time, it seems 776 * reasonable to include them. 777 */ 778 case MAC_STAT_IERRORS: 779 i40e_stat_get_uint32(i40e, I40E_GLPRT_CRCERRS(port), 780 &ipk->ipk_crc_errors, &ips->ips_crc_errors, B_FALSE); 781 i40e_stat_get_uint32(i40e, I40E_GLPRT_ILLERRC(port), 782 &ipk->ipk_illegal_bytes, &ips->ips_illegal_bytes, B_FALSE); 783 i40e_stat_get_uint32(i40e, I40E_GLPRT_RLEC(port), 784 &ipk->ipk_rx_length_errors, &ips->ips_rx_length_errors, 785 B_FALSE); 786 i40e_stat_get_uint48(i40e, I40E_GL_RXERR1_L(port), 787 &ipk->ipk_rx_err1, &ips->ips_rx_err1, B_FALSE); 788 i40e_stat_get_uint48(i40e, I40E_GL_RXERR2_L(port), 789 &ipk->ipk_rx_err2, &ips->ips_rx_err2, B_FALSE); 790 791 *val = ipk->ipk_crc_errors.value.ui64 + 792 ipk->ipk_illegal_bytes.value.ui64 + 793 ipk->ipk_rx_length_errors.value.ui64 + 794 ipk->ipk_rx_err1.value.ui64 + 795 ipk->ipk_rx_err2.value.ui64; 796 break; 797 case MAC_STAT_UNKNOWNS: 798 i40e_stat_get_uint32(i40e, I40E_GLPRT_RUPP(port), 799 &ipk->ipk_rx_unknown_protocol, 800 &ips->ips_rx_unknown_protocol, 801 B_FALSE); 802 *val = ipk->ipk_rx_unknown_protocol.value.ui64; 803 break; 804 case MAC_STAT_RBYTES: 805 i40e_stat_get_uint48(i40e, I40E_GLPRT_GORCL(port), 806 &ipk->ipk_rx_bytes, &ips->ips_rx_bytes, B_FALSE); 807 *val = ipk->ipk_rx_bytes.value.ui64; 808 break; 809 case MAC_STAT_IPACKETS: 810 i40e_stat_get_uint48(i40e, I40E_GLPRT_UPRCL(port), 811 &ipk->ipk_rx_unicast, &ips->ips_rx_unicast, B_FALSE); 812 i40e_stat_get_uint48(i40e, I40E_GLPRT_MPRCL(port), 813 &ipk->ipk_rx_multicast, &ips->ips_rx_multicast, B_FALSE); 814 i40e_stat_get_uint48(i40e, I40E_GLPRT_BPRCL(port), 815 &ipk->ipk_rx_broadcast, &ips->ips_rx_broadcast, B_FALSE); 816 *val = ipk->ipk_rx_unicast.value.ui64 + 817 ipk->ipk_rx_multicast.value.ui64 + 818 ipk->ipk_rx_broadcast.value.ui64; 819 break; 820 case MAC_STAT_OBYTES: 821 i40e_stat_get_uint48(i40e, I40E_GLPRT_GOTCL(port), 822 &ipk->ipk_tx_bytes, &ips->ips_tx_bytes, B_FALSE); 823 *val = ipk->ipk_tx_bytes.value.ui64; 824 break; 825 case MAC_STAT_OPACKETS: 826 i40e_stat_get_uint48(i40e, I40E_GLPRT_UPTCL(port), 827 &ipk->ipk_tx_unicast, &ips->ips_tx_unicast, B_FALSE); 828 i40e_stat_get_uint48(i40e, I40E_GLPRT_MPTCL(port), 829 &ipk->ipk_tx_multicast, &ips->ips_tx_multicast, B_FALSE); 830 i40e_stat_get_uint48(i40e, I40E_GLPRT_BPTCL(port), 831 &ipk->ipk_tx_broadcast, &ips->ips_tx_broadcast, B_FALSE); 832 *val = ipk->ipk_tx_unicast.value.ui64 + 833 ipk->ipk_tx_multicast.value.ui64 + 834 ipk->ipk_tx_broadcast.value.ui64; 835 break; 836 case MAC_STAT_UNDERFLOWS: 837 i40e_stat_get_uint32(i40e, I40E_GLPRT_RUC(port), 838 &ipk->ipk_rx_undersize, &ips->ips_rx_undersize, B_FALSE); 839 i40e_stat_get_uint32(i40e, I40E_GLPRT_RFC(port), 840 &ipk->ipk_rx_fragments, &ips->ips_rx_fragments, B_FALSE); 841 i40e_stat_get_uint32(i40e, I40E_GLPRT_MSPDC(port), 842 &ipk->ipk_rx_short_discards, &ips->ips_rx_short_discards, 843 B_FALSE); 844 *val = ipk->ipk_rx_undersize.value.ui64 + 845 ipk->ipk_rx_fragments.value.ui64 + 846 ipk->ipk_rx_short_discards.value.ui64; 847 break; 848 case MAC_STAT_OVERFLOWS: 849 i40e_stat_get_uint32(i40e, I40E_GLPRT_ROC(port), 850 &ipk->ipk_rx_oversize, &ips->ips_rx_oversize, B_FALSE); 851 i40e_stat_get_uint32(i40e, I40E_GLPRT_RJC(port), 852 &ipk->ipk_rx_jabber, &ips->ips_rx_jabber, B_FALSE); 853 *val = ipk->ipk_rx_oversize.value.ui64 + 854 ipk->ipk_rx_fragments.value.ui64; 855 break; 856 857 /* RFC 1643 stats */ 858 case ETHER_STAT_FCS_ERRORS: 859 i40e_stat_get_uint32(i40e, I40E_GLPRT_CRCERRS(port), 860 &ipk->ipk_crc_errors, &ips->ips_crc_errors, B_FALSE); 861 *val = ipk->ipk_crc_errors.value.ui64; 862 break; 863 case ETHER_STAT_TOOLONG_ERRORS: 864 i40e_stat_get_uint32(i40e, I40E_GLPRT_ROC(port), 865 &ipk->ipk_rx_oversize, &ips->ips_rx_oversize, B_FALSE); 866 *val = ipk->ipk_rx_oversize.value.ui64; 867 break; 868 case ETHER_STAT_MACRCV_ERRORS: 869 i40e_stat_get_uint32(i40e, I40E_GLPRT_ILLERRC(port), 870 &ipk->ipk_illegal_bytes, &ips->ips_illegal_bytes, B_FALSE); 871 i40e_stat_get_uint32(i40e, I40E_GLPRT_RLEC(port), 872 &ipk->ipk_rx_length_errors, &ips->ips_rx_length_errors, 873 B_FALSE); 874 i40e_stat_get_uint32(i40e, I40E_GLPRT_RFC(port), 875 &ipk->ipk_rx_fragments, &ips->ips_rx_fragments, B_FALSE); 876 *val = ipk->ipk_illegal_bytes.value.ui64 + 877 ipk->ipk_rx_length_errors.value.ui64 + 878 ipk->ipk_rx_fragments.value.ui64; 879 break; 880 /* MII/GMII stats */ 881 882 /* 883 * The receiver address is apparently the same as the port number. 884 */ 885 case ETHER_STAT_XCVR_ADDR: 886 /* The Receiver address is apparently the same as the port */ 887 *val = i40e->i40e_hw_space.port; 888 break; 889 case ETHER_STAT_XCVR_ID: 890 switch (hw->phy.media_type) { 891 case I40E_MEDIA_TYPE_BASET: 892 /* 893 * Transform the data here into the ID. Note, generally 894 * the revision is left out. 895 */ 896 *val = i40e->i40e_phy.phy_id[3] << 24 | 897 i40e->i40e_phy.phy_id[2] << 16 | 898 i40e->i40e_phy.phy_id[1] << 8; 899 break; 900 case I40E_MEDIA_TYPE_FIBER: 901 case I40E_MEDIA_TYPE_BACKPLANE: 902 case I40E_MEDIA_TYPE_CX4: 903 case I40E_MEDIA_TYPE_DA: 904 case I40E_MEDIA_TYPE_VIRTUAL: 905 *val = i40e->i40e_phy.phy_id[0] | 906 i40e->i40e_phy.phy_id[1] << 8 | 907 i40e->i40e_phy.phy_id[2] << 16; 908 break; 909 case I40E_MEDIA_TYPE_UNKNOWN: 910 default: 911 goto unimpl; 912 } 913 break; 914 case ETHER_STAT_XCVR_INUSE: 915 switch (hw->phy.link_info.phy_type) { 916 case I40E_PHY_TYPE_100BASE_TX: 917 *val = XCVR_100T2; 918 break; 919 case I40E_PHY_TYPE_1000BASE_T: 920 *val = XCVR_1000T; 921 break; 922 default: 923 *val = XCVR_UNDEFINED; 924 break; 925 } 926 break; 927 928 /* 929 * This group answers the question of do we support a given speed in 930 * theory. 931 */ 932 case ETHER_STAT_CAP_100FDX: 933 *val = (i40e->i40e_phy.link_speed & I40E_LINK_SPEED_100MB) != 0; 934 break; 935 case ETHER_STAT_CAP_1000FDX: 936 *val = (i40e->i40e_phy.link_speed & I40E_LINK_SPEED_1GB) != 0; 937 break; 938 case ETHER_STAT_CAP_10GFDX: 939 *val = (i40e->i40e_phy.link_speed & I40E_LINK_SPEED_10GB) != 0; 940 break; 941 case ETHER_STAT_CAP_25GFDX: 942 *val = (i40e->i40e_phy.link_speed & I40E_LINK_SPEED_25GB) != 0; 943 break; 944 case ETHER_STAT_CAP_40GFDX: 945 *val = (i40e->i40e_phy.link_speed & I40E_LINK_SPEED_40GB) != 0; 946 break; 947 948 /* 949 * These ask are we currently advertising these speeds and abilities. 950 * Until we support setting these because we're working with a copper 951 * PHY, then the only things we advertise are based on the link PHY 952 * speeds. In other words, we advertise everything we support. 953 */ 954 case ETHER_STAT_ADV_CAP_100FDX: 955 *val = (i40e->i40e_phy.link_speed & I40E_LINK_SPEED_100MB) != 0; 956 break; 957 case ETHER_STAT_ADV_CAP_1000FDX: 958 *val = (i40e->i40e_phy.link_speed & I40E_LINK_SPEED_1GB) != 0; 959 break; 960 case ETHER_STAT_ADV_CAP_10GFDX: 961 *val = (i40e->i40e_phy.link_speed & I40E_LINK_SPEED_10GB) != 0; 962 break; 963 case ETHER_STAT_ADV_CAP_25GFDX: 964 *val = (i40e->i40e_phy.link_speed & I40E_LINK_SPEED_25GB) != 0; 965 break; 966 case ETHER_STAT_ADV_CAP_40GFDX: 967 *val = (i40e->i40e_phy.link_speed & I40E_LINK_SPEED_40GB) != 0; 968 break; 969 970 /* 971 * These ask if the peer supports these speeds, e.g. what did they tell 972 * us in auto-negotiation. Unfortunately, hardware doesn't appear to 973 * give us a way to determine whether or not they actually support 974 * something, only what they have enabled. This means that all we can 975 * tell the user is the speed that we're currently at, unfortunately. 976 */ 977 case ETHER_STAT_LP_CAP_100FDX: 978 *val = i40e->i40e_link_speed == 100; 979 break; 980 case ETHER_STAT_LP_CAP_1000FDX: 981 *val = i40e->i40e_link_speed == 1000; 982 break; 983 case ETHER_STAT_LP_CAP_10GFDX: 984 *val = i40e->i40e_link_speed == 10000; 985 break; 986 case ETHER_STAT_LP_CAP_25GFDX: 987 *val = i40e->i40e_link_speed == 25000; 988 break; 989 case ETHER_STAT_LP_CAP_40GFDX: 990 *val = i40e->i40e_link_speed == 40000; 991 break; 992 993 /* 994 * Statistics for unsupported speeds. Note that these often have the 995 * same constraints as the other ones. For example, we can't answer the 996 * question of the ETHER_STAT_LP_CAP family because hardware doesn't 997 * give us any way of knowing whether or not it does. 998 */ 999 case ETHER_STAT_CAP_100HDX: 1000 case ETHER_STAT_CAP_1000HDX: 1001 case ETHER_STAT_CAP_10FDX: 1002 case ETHER_STAT_CAP_10HDX: 1003 case ETHER_STAT_CAP_100T4: 1004 case ETHER_STAT_CAP_100GFDX: 1005 case ETHER_STAT_CAP_50GFDX: 1006 case ETHER_STAT_CAP_2500FDX: 1007 case ETHER_STAT_CAP_5000FDX: 1008 case ETHER_STAT_ADV_CAP_1000HDX: 1009 case ETHER_STAT_ADV_CAP_100HDX: 1010 case ETHER_STAT_ADV_CAP_10FDX: 1011 case ETHER_STAT_ADV_CAP_10HDX: 1012 case ETHER_STAT_ADV_CAP_100T4: 1013 case ETHER_STAT_ADV_CAP_100GFDX: 1014 case ETHER_STAT_ADV_CAP_50GFDX: 1015 case ETHER_STAT_ADV_CAP_2500FDX: 1016 case ETHER_STAT_ADV_CAP_5000FDX: 1017 case ETHER_STAT_LP_CAP_1000HDX: 1018 case ETHER_STAT_LP_CAP_100HDX: 1019 case ETHER_STAT_LP_CAP_10FDX: 1020 case ETHER_STAT_LP_CAP_10HDX: 1021 case ETHER_STAT_LP_CAP_100T4: 1022 case ETHER_STAT_LP_CAP_100GFDX: 1023 case ETHER_STAT_LP_CAP_50GFDX: 1024 case ETHER_STAT_LP_CAP_2500FDX: 1025 case ETHER_STAT_LP_CAP_5000FDX: 1026 *val = 0; 1027 break; 1028 1029 case ETHER_STAT_LINK_DUPLEX: 1030 *val = i40e->i40e_link_duplex; 1031 break; 1032 case ETHER_STAT_TOOSHORT_ERRORS: 1033 i40e_stat_get_uint32(i40e, I40E_GLPRT_RUC(port), 1034 &ipk->ipk_rx_undersize, &ips->ips_rx_undersize, B_FALSE); 1035 1036 i40e_stat_get_uint32(i40e, I40E_GLPRT_MSPDC(port), 1037 &ipk->ipk_rx_short_discards, &ips->ips_rx_short_discards, 1038 B_FALSE); 1039 *val = ipk->ipk_rx_undersize.value.ui64 + 1040 ipk->ipk_rx_short_discards.value.ui64; 1041 break; 1042 case ETHER_STAT_JABBER_ERRORS: 1043 i40e_stat_get_uint32(i40e, I40E_GLPRT_RJC(port), 1044 &ipk->ipk_rx_jabber, &ips->ips_rx_jabber, B_FALSE); 1045 *val = ipk->ipk_rx_jabber.value.ui64; 1046 break; 1047 1048 /* 1049 * Non-Link speed related capabilities. 1050 */ 1051 case ETHER_STAT_CAP_AUTONEG: 1052 *val = 1; 1053 break; 1054 1055 case ETHER_STAT_ADV_CAP_AUTONEG: 1056 *val = 1; 1057 break; 1058 1059 case ETHER_STAT_LP_CAP_AUTONEG: 1060 *val = (hw->phy.link_info.an_info & I40E_AQ_LP_AN_ABILITY) != 0; 1061 break; 1062 1063 case ETHER_STAT_LINK_AUTONEG: 1064 *val = 1; 1065 break; 1066 1067 /* 1068 * Note that while the hardware does support the pause functionality, at 1069 * this time we do not use it at all and effectively disable it. 1070 */ 1071 case ETHER_STAT_CAP_ASMPAUSE: 1072 *val = (i40e->i40e_phy.abilities & 1073 I40E_AQ_PHY_FLAG_PAUSE_RX) != 0; 1074 break; 1075 case ETHER_STAT_CAP_PAUSE: 1076 *val = (i40e->i40e_phy.abilities & 1077 I40E_AQ_PHY_FLAG_PAUSE_TX) != 0; 1078 break; 1079 1080 /* 1081 * Because we don't support these at this time, they are always 1082 * hard-coded to zero. 1083 */ 1084 case ETHER_STAT_ADV_CAP_ASMPAUSE: 1085 case ETHER_STAT_ADV_CAP_PAUSE: 1086 *val = 0; 1087 break; 1088 1089 /* 1090 * Like the other LP fields, we can only answer the question have we 1091 * enabled it, not whether the other end actually supports it. 1092 */ 1093 case ETHER_STAT_LP_CAP_ASMPAUSE: 1094 case ETHER_STAT_LINK_ASMPAUSE: 1095 *val = (hw->phy.link_info.an_info & I40E_AQ_LINK_PAUSE_RX) != 0; 1096 break; 1097 case ETHER_STAT_LP_CAP_PAUSE: 1098 case ETHER_STAT_LINK_PAUSE: 1099 *val = (hw->phy.link_info.an_info & I40E_AQ_LINK_PAUSE_TX) != 0; 1100 break; 1101 1102 default: 1103 unimpl: 1104 mutex_exit(&i40e->i40e_stat_lock); 1105 mutex_exit(&i40e->i40e_general_lock); 1106 return (ENOTSUP); 1107 } 1108 1109 mutex_exit(&i40e->i40e_stat_lock); 1110 mutex_exit(&i40e->i40e_general_lock); 1111 1112 if (i40e_check_acc_handle(i40e->i40e_osdep_space.ios_reg_handle) != 1113 DDI_FM_OK) { 1114 ddi_fm_service_impact(i40e->i40e_dip, DDI_SERVICE_DEGRADED); 1115 return (EIO); 1116 } 1117 1118 return (0); 1119 } 1120 1121 int 1122 i40e_rx_ring_stat(mac_ring_driver_t rh, uint_t stat, uint64_t *val) 1123 { 1124 i40e_trqpair_t *itrq = (i40e_trqpair_t *)rh; 1125 i40e_t *i40e = itrq->itrq_i40e; 1126 1127 if (i40e->i40e_state & I40E_SUSPENDED) { 1128 return (ECANCELED); 1129 } 1130 1131 switch (stat) { 1132 case MAC_STAT_RBYTES: 1133 *val = itrq->itrq_rxstat.irxs_bytes.value.ui64; 1134 break; 1135 case MAC_STAT_IPACKETS: 1136 *val = itrq->itrq_rxstat.irxs_packets.value.ui64; 1137 break; 1138 default: 1139 *val = 0; 1140 return (ENOTSUP); 1141 } 1142 1143 return (0); 1144 } 1145 1146 int 1147 i40e_tx_ring_stat(mac_ring_driver_t rh, uint_t stat, uint64_t *val) 1148 { 1149 i40e_trqpair_t *itrq = (i40e_trqpair_t *)rh; 1150 i40e_t *i40e = itrq->itrq_i40e; 1151 1152 if (i40e->i40e_state & I40E_SUSPENDED) { 1153 return (ECANCELED); 1154 } 1155 1156 switch (stat) { 1157 case MAC_STAT_OBYTES: 1158 *val = itrq->itrq_txstat.itxs_bytes.value.ui64; 1159 break; 1160 case MAC_STAT_OPACKETS: 1161 *val = itrq->itrq_txstat.itxs_packets.value.ui64; 1162 break; 1163 default: 1164 *val = 0; 1165 return (ENOTSUP); 1166 } 1167 1168 return (0); 1169 } 1170 1171 /* 1172 * When we end up refactoring all off the queue assignments and have non-static 1173 * queue to VSI mappings, then we may need to revisit the general locking 1174 * strategy that we employ and have the kstat creation / deletion be part of the 1175 * ring start and stop routines. 1176 */ 1177 void 1178 i40e_stats_trqpair_fini(i40e_trqpair_t *itrq) 1179 { 1180 if (itrq->itrq_txkstat != NULL) { 1181 kstat_delete(itrq->itrq_txkstat); 1182 itrq->itrq_txkstat = NULL; 1183 } 1184 1185 if (itrq->itrq_rxkstat != NULL) { 1186 kstat_delete(itrq->itrq_rxkstat); 1187 itrq->itrq_rxkstat = NULL; 1188 } 1189 } 1190 1191 boolean_t 1192 i40e_stats_trqpair_init(i40e_trqpair_t *itrq) 1193 { 1194 char buf[128]; 1195 i40e_t *i40e = itrq->itrq_i40e; 1196 i40e_txq_stat_t *tsp = &itrq->itrq_txstat; 1197 i40e_rxq_stat_t *rsp = &itrq->itrq_rxstat; 1198 1199 (void) snprintf(buf, sizeof (buf), "trqpair_tx_%d", itrq->itrq_index); 1200 itrq->itrq_txkstat = kstat_create(I40E_MODULE_NAME, 1201 ddi_get_instance(i40e->i40e_dip), buf, "net", KSTAT_TYPE_NAMED, 1202 sizeof (i40e_txq_stat_t) / sizeof (kstat_named_t), 1203 KSTAT_FLAG_VIRTUAL); 1204 1205 if (itrq->itrq_txkstat == NULL) 1206 return (B_FALSE); 1207 1208 (void) snprintf(buf, sizeof (buf), "trqpair_rx_%d", itrq->itrq_index); 1209 itrq->itrq_rxkstat = kstat_create(I40E_MODULE_NAME, 1210 ddi_get_instance(i40e->i40e_dip), buf, "net", KSTAT_TYPE_NAMED, 1211 sizeof (i40e_rxq_stat_t) / sizeof (kstat_named_t), 1212 KSTAT_FLAG_VIRTUAL); 1213 1214 if (itrq->itrq_rxkstat == NULL) { 1215 kstat_delete(itrq->itrq_txkstat); 1216 itrq->itrq_txkstat = NULL; 1217 return (B_FALSE); 1218 } 1219 1220 itrq->itrq_txkstat->ks_data = &itrq->itrq_txstat; 1221 itrq->itrq_rxkstat->ks_data = &itrq->itrq_rxstat; 1222 1223 kstat_named_init(&tsp->itxs_bytes, "tx_bytes", 1224 KSTAT_DATA_UINT64); 1225 tsp->itxs_bytes.value.ui64 = 0; 1226 kstat_named_init(&tsp->itxs_packets, "tx_packets", 1227 KSTAT_DATA_UINT64); 1228 tsp->itxs_packets.value.ui64 = 0; 1229 kstat_named_init(&tsp->itxs_descriptors, "tx_descriptors", 1230 KSTAT_DATA_UINT64); 1231 tsp->itxs_descriptors.value.ui64 = 0; 1232 kstat_named_init(&tsp->itxs_recycled, "tx_recycled", 1233 KSTAT_DATA_UINT64); 1234 tsp->itxs_recycled.value.ui64 = 0; 1235 kstat_named_init(&tsp->itxs_force_copy, "tx_force_copy", 1236 KSTAT_DATA_UINT64); 1237 tsp->itxs_force_copy.value.ui64 = 0; 1238 kstat_named_init(&tsp->itxs_tso_force_copy, "tx_tso_force_copy", 1239 KSTAT_DATA_UINT64); 1240 tsp->itxs_tso_force_copy.value.ui64 = 0; 1241 1242 kstat_named_init(&tsp->itxs_hck_meoifail, "tx_hck_meoifail", 1243 KSTAT_DATA_UINT64); 1244 tsp->itxs_hck_meoifail.value.ui64 = 0; 1245 kstat_named_init(&tsp->itxs_hck_nol2info, "tx_hck_nol2info", 1246 KSTAT_DATA_UINT64); 1247 tsp->itxs_hck_nol2info.value.ui64 = 0; 1248 kstat_named_init(&tsp->itxs_hck_nol3info, "tx_hck_nol3info", 1249 KSTAT_DATA_UINT64); 1250 tsp->itxs_hck_nol3info.value.ui64 = 0; 1251 kstat_named_init(&tsp->itxs_hck_nol4info, "tx_hck_nol4info", 1252 KSTAT_DATA_UINT64); 1253 tsp->itxs_hck_nol4info.value.ui64 = 0; 1254 kstat_named_init(&tsp->itxs_hck_badl3, "tx_hck_badl3", 1255 KSTAT_DATA_UINT64); 1256 tsp->itxs_hck_badl3.value.ui64 = 0; 1257 kstat_named_init(&tsp->itxs_hck_badl4, "tx_hck_badl4", 1258 KSTAT_DATA_UINT64); 1259 tsp->itxs_hck_badl4.value.ui64 = 0; 1260 kstat_named_init(&tsp->itxs_lso_nohck, "tx_lso_nohck", 1261 KSTAT_DATA_UINT64); 1262 tsp->itxs_lso_nohck.value.ui64 = 0; 1263 kstat_named_init(&tsp->itxs_bind_fails, "tx_bind_fails", 1264 KSTAT_DATA_UINT64); 1265 tsp->itxs_bind_fails.value.ui64 = 0; 1266 kstat_named_init(&tsp->itxs_tx_short, "tx_short", 1267 KSTAT_DATA_UINT64); 1268 tsp->itxs_tx_short.value.ui64 = 0; 1269 kstat_named_init(&tsp->itxs_err_notcb, "tx_err_notcb", 1270 KSTAT_DATA_UINT64); 1271 tsp->itxs_err_notcb.value.ui64 = 0; 1272 kstat_named_init(&tsp->itxs_err_nodescs, "tx_err_nodescs", 1273 KSTAT_DATA_UINT64); 1274 tsp->itxs_err_nodescs.value.ui64 = 0; 1275 kstat_named_init(&tsp->itxs_err_context, "tx_err_context", 1276 KSTAT_DATA_UINT64); 1277 tsp->itxs_err_context.value.ui64 = 0; 1278 kstat_named_init(&tsp->itxs_num_unblocked, "tx_num_unblocked", 1279 KSTAT_DATA_UINT64); 1280 tsp->itxs_num_unblocked.value.ui64 = 0; 1281 1282 1283 kstat_named_init(&rsp->irxs_bytes, "rx_bytes", 1284 KSTAT_DATA_UINT64); 1285 rsp->irxs_bytes.value.ui64 = 0; 1286 kstat_named_init(&rsp->irxs_packets, "rx_packets", 1287 KSTAT_DATA_UINT64); 1288 rsp->irxs_packets.value.ui64 = 0; 1289 kstat_named_init(&rsp->irxs_rx_desc_error, "rx_desc_error", 1290 KSTAT_DATA_UINT64); 1291 rsp->irxs_rx_desc_error.value.ui64 = 0; 1292 kstat_named_init(&rsp->irxs_rx_intr_limit, "rx_intr_limit", 1293 KSTAT_DATA_UINT64); 1294 rsp->irxs_rx_intr_limit.value.ui64 = 0; 1295 kstat_named_init(&rsp->irxs_rx_bind_norcb, "rx_bind_norcb", 1296 KSTAT_DATA_UINT64); 1297 rsp->irxs_rx_bind_norcb.value.ui64 = 0; 1298 kstat_named_init(&rsp->irxs_rx_bind_nomp, "rx_bind_nomp", 1299 KSTAT_DATA_UINT64); 1300 rsp->irxs_rx_bind_nomp.value.ui64 = 0; 1301 kstat_named_init(&rsp->irxs_rx_copy_nomem, "rx_copy_nomem", 1302 KSTAT_DATA_UINT64); 1303 rsp->irxs_rx_copy_nomem.value.ui64 = 0; 1304 kstat_named_init(&rsp->irxs_hck_v4hdrok, "rx_hck_v4hdrok", 1305 KSTAT_DATA_UINT64); 1306 rsp->irxs_hck_v4hdrok.value.ui64 = 0; 1307 kstat_named_init(&rsp->irxs_hck_l4hdrok, "rx_hck_l4hdrok", 1308 KSTAT_DATA_UINT64); 1309 rsp->irxs_hck_l4hdrok.value.ui64 = 0; 1310 kstat_named_init(&rsp->irxs_hck_unknown, "rx_hck_unknown", 1311 KSTAT_DATA_UINT64); 1312 rsp->irxs_hck_unknown.value.ui64 = 0; 1313 kstat_named_init(&rsp->irxs_hck_nol3l4p, "rx_hck_nol3l4p", 1314 KSTAT_DATA_UINT64); 1315 rsp->irxs_hck_nol3l4p.value.ui64 = 0; 1316 kstat_named_init(&rsp->irxs_hck_iperr, "rx_hck_iperr", 1317 KSTAT_DATA_UINT64); 1318 rsp->irxs_hck_iperr.value.ui64 = 0; 1319 kstat_named_init(&rsp->irxs_hck_eiperr, "rx_hck_eiperr", 1320 KSTAT_DATA_UINT64); 1321 rsp->irxs_hck_eiperr.value.ui64 = 0; 1322 kstat_named_init(&rsp->irxs_hck_l4err, "rx_hck_l4err", 1323 KSTAT_DATA_UINT64); 1324 rsp->irxs_hck_l4err.value.ui64 = 0; 1325 kstat_named_init(&rsp->irxs_hck_v6skip, "rx_hck_v6skip", 1326 KSTAT_DATA_UINT64); 1327 rsp->irxs_hck_v6skip.value.ui64 = 0; 1328 kstat_named_init(&rsp->irxs_hck_set, "rx_hck_set", 1329 KSTAT_DATA_UINT64); 1330 rsp->irxs_hck_set.value.ui64 = 0; 1331 kstat_named_init(&rsp->irxs_hck_miss, "rx_hck_miss", 1332 KSTAT_DATA_UINT64); 1333 rsp->irxs_hck_miss.value.ui64 = 0; 1334 1335 kstat_install(itrq->itrq_txkstat); 1336 kstat_install(itrq->itrq_rxkstat); 1337 1338 return (B_TRUE); 1339 } 1340