1 // SPDX-License-Identifier: (GPL-2.0 OR MIT) 2 /* Google virtual Ethernet (gve) driver 3 * 4 * Copyright (C) 2015-2021 Google, Inc. 5 */ 6 7 #include <linux/rtnetlink.h> 8 #include "gve.h" 9 #include "gve_adminq.h" 10 #include "gve_dqo.h" 11 12 static void gve_get_drvinfo(struct net_device *netdev, 13 struct ethtool_drvinfo *info) 14 { 15 struct gve_priv *priv = netdev_priv(netdev); 16 17 strscpy(info->driver, gve_driver_name, sizeof(info->driver)); 18 strscpy(info->version, gve_version_str, sizeof(info->version)); 19 strscpy(info->bus_info, pci_name(priv->pdev), sizeof(info->bus_info)); 20 } 21 22 static void gve_set_msglevel(struct net_device *netdev, u32 value) 23 { 24 struct gve_priv *priv = netdev_priv(netdev); 25 26 priv->msg_enable = value; 27 } 28 29 static u32 gve_get_msglevel(struct net_device *netdev) 30 { 31 struct gve_priv *priv = netdev_priv(netdev); 32 33 return priv->msg_enable; 34 } 35 36 /* For the following stats column string names, make sure the order 37 * matches how it is filled in the code. For xdp_aborted, xdp_drop, 38 * xdp_pass, xdp_tx, xdp_redirect, make sure it also matches the order 39 * as declared in enum xdp_action inside file uapi/linux/bpf.h . 40 */ 41 static const char gve_gstrings_main_stats[][ETH_GSTRING_LEN] = { 42 "rx_packets", "rx_hsplit_pkt", "tx_packets", "rx_bytes", 43 "tx_bytes", "rx_dropped", "tx_dropped", "tx_timeouts", 44 "rx_skb_alloc_fail", "rx_buf_alloc_fail", "rx_desc_err_dropped_pkt", 45 "rx_hsplit_unsplit_pkt", 46 "interface_up_cnt", "interface_down_cnt", "reset_cnt", 47 "page_alloc_fail", "dma_mapping_error", "stats_report_trigger_cnt", 48 }; 49 50 static const char gve_gstrings_rx_stats[][ETH_GSTRING_LEN] = { 51 "rx_posted_desc[%u]", "rx_completed_desc[%u]", "rx_consumed_desc[%u]", 52 "rx_bytes[%u]", "rx_hsplit_bytes[%u]", "rx_cont_packet_cnt[%u]", 53 "rx_frag_flip_cnt[%u]", "rx_frag_copy_cnt[%u]", "rx_frag_alloc_cnt[%u]", 54 "rx_dropped_pkt[%u]", "rx_copybreak_pkt[%u]", "rx_copied_pkt[%u]", 55 "rx_queue_drop_cnt[%u]", "rx_no_buffers_posted[%u]", 56 "rx_drops_packet_over_mru[%u]", "rx_drops_invalid_checksum[%u]", 57 "rx_xdp_aborted[%u]", "rx_xdp_drop[%u]", "rx_xdp_pass[%u]", 58 "rx_xdp_tx[%u]", "rx_xdp_redirect[%u]", 59 "rx_xdp_tx_errors[%u]", "rx_xdp_redirect_errors[%u]", "rx_xdp_alloc_fails[%u]", 60 }; 61 62 static const char gve_gstrings_tx_stats[][ETH_GSTRING_LEN] = { 63 "tx_posted_desc[%u]", "tx_completed_desc[%u]", "tx_consumed_desc[%u]", "tx_bytes[%u]", 64 "tx_wake[%u]", "tx_stop[%u]", "tx_event_counter[%u]", 65 "tx_dma_mapping_error[%u]", "tx_xsk_wakeup[%u]", 66 "tx_xsk_done[%u]", "tx_xsk_sent[%u]", "tx_xdp_xmit[%u]", "tx_xdp_xmit_errors[%u]" 67 }; 68 69 static const char gve_gstrings_adminq_stats[][ETH_GSTRING_LEN] = { 70 "adminq_prod_cnt", "adminq_cmd_fail", "adminq_timeouts", 71 "adminq_describe_device_cnt", "adminq_cfg_device_resources_cnt", 72 "adminq_register_page_list_cnt", "adminq_unregister_page_list_cnt", 73 "adminq_create_tx_queue_cnt", "adminq_create_rx_queue_cnt", 74 "adminq_destroy_tx_queue_cnt", "adminq_destroy_rx_queue_cnt", 75 "adminq_dcfg_device_resources_cnt", "adminq_set_driver_parameter_cnt", 76 "adminq_report_stats_cnt", "adminq_report_link_speed_cnt", "adminq_get_ptype_map_cnt" 77 }; 78 79 static const char gve_gstrings_priv_flags[][ETH_GSTRING_LEN] = { 80 "report-stats", 81 }; 82 83 #define GVE_MAIN_STATS_LEN ARRAY_SIZE(gve_gstrings_main_stats) 84 #define GVE_ADMINQ_STATS_LEN ARRAY_SIZE(gve_gstrings_adminq_stats) 85 #define NUM_GVE_TX_CNTS ARRAY_SIZE(gve_gstrings_tx_stats) 86 #define NUM_GVE_RX_CNTS ARRAY_SIZE(gve_gstrings_rx_stats) 87 #define GVE_PRIV_FLAGS_STR_LEN ARRAY_SIZE(gve_gstrings_priv_flags) 88 89 static void gve_get_strings(struct net_device *netdev, u32 stringset, u8 *data) 90 { 91 struct gve_priv *priv = netdev_priv(netdev); 92 char *s = (char *)data; 93 int num_tx_queues; 94 int i, j; 95 96 num_tx_queues = gve_num_tx_queues(priv); 97 switch (stringset) { 98 case ETH_SS_STATS: 99 memcpy(s, *gve_gstrings_main_stats, 100 sizeof(gve_gstrings_main_stats)); 101 s += sizeof(gve_gstrings_main_stats); 102 103 for (i = 0; i < priv->rx_cfg.num_queues; i++) { 104 for (j = 0; j < NUM_GVE_RX_CNTS; j++) { 105 snprintf(s, ETH_GSTRING_LEN, 106 gve_gstrings_rx_stats[j], i); 107 s += ETH_GSTRING_LEN; 108 } 109 } 110 111 for (i = 0; i < num_tx_queues; i++) { 112 for (j = 0; j < NUM_GVE_TX_CNTS; j++) { 113 snprintf(s, ETH_GSTRING_LEN, 114 gve_gstrings_tx_stats[j], i); 115 s += ETH_GSTRING_LEN; 116 } 117 } 118 119 memcpy(s, *gve_gstrings_adminq_stats, 120 sizeof(gve_gstrings_adminq_stats)); 121 s += sizeof(gve_gstrings_adminq_stats); 122 break; 123 124 case ETH_SS_PRIV_FLAGS: 125 memcpy(s, *gve_gstrings_priv_flags, 126 sizeof(gve_gstrings_priv_flags)); 127 s += sizeof(gve_gstrings_priv_flags); 128 break; 129 130 default: 131 break; 132 } 133 } 134 135 static int gve_get_sset_count(struct net_device *netdev, int sset) 136 { 137 struct gve_priv *priv = netdev_priv(netdev); 138 int num_tx_queues; 139 140 num_tx_queues = gve_num_tx_queues(priv); 141 switch (sset) { 142 case ETH_SS_STATS: 143 return GVE_MAIN_STATS_LEN + GVE_ADMINQ_STATS_LEN + 144 (priv->rx_cfg.num_queues * NUM_GVE_RX_CNTS) + 145 (num_tx_queues * NUM_GVE_TX_CNTS); 146 case ETH_SS_PRIV_FLAGS: 147 return GVE_PRIV_FLAGS_STR_LEN; 148 default: 149 return -EOPNOTSUPP; 150 } 151 } 152 153 static void 154 gve_get_ethtool_stats(struct net_device *netdev, 155 struct ethtool_stats *stats, u64 *data) 156 { 157 u64 tmp_rx_pkts, tmp_rx_hsplit_pkt, tmp_rx_bytes, tmp_rx_hsplit_bytes, 158 tmp_rx_skb_alloc_fail, tmp_rx_buf_alloc_fail, 159 tmp_rx_desc_err_dropped_pkt, tmp_rx_hsplit_unsplit_pkt, 160 tmp_tx_pkts, tmp_tx_bytes; 161 u64 rx_buf_alloc_fail, rx_desc_err_dropped_pkt, rx_hsplit_unsplit_pkt, 162 rx_pkts, rx_hsplit_pkt, rx_skb_alloc_fail, rx_bytes, tx_pkts, tx_bytes, 163 tx_dropped; 164 int stats_idx, base_stats_idx, max_stats_idx; 165 struct stats *report_stats; 166 int *rx_qid_to_stats_idx; 167 int *tx_qid_to_stats_idx; 168 struct gve_priv *priv; 169 bool skip_nic_stats; 170 unsigned int start; 171 int num_tx_queues; 172 int ring; 173 int i, j; 174 175 ASSERT_RTNL(); 176 177 priv = netdev_priv(netdev); 178 num_tx_queues = gve_num_tx_queues(priv); 179 report_stats = priv->stats_report->stats; 180 rx_qid_to_stats_idx = kmalloc_array(priv->rx_cfg.num_queues, 181 sizeof(int), GFP_KERNEL); 182 if (!rx_qid_to_stats_idx) 183 return; 184 tx_qid_to_stats_idx = kmalloc_array(num_tx_queues, 185 sizeof(int), GFP_KERNEL); 186 if (!tx_qid_to_stats_idx) { 187 kfree(rx_qid_to_stats_idx); 188 return; 189 } 190 for (rx_pkts = 0, rx_bytes = 0, rx_hsplit_pkt = 0, 191 rx_skb_alloc_fail = 0, rx_buf_alloc_fail = 0, 192 rx_desc_err_dropped_pkt = 0, rx_hsplit_unsplit_pkt = 0, 193 ring = 0; 194 ring < priv->rx_cfg.num_queues; ring++) { 195 if (priv->rx) { 196 do { 197 struct gve_rx_ring *rx = &priv->rx[ring]; 198 199 start = 200 u64_stats_fetch_begin(&priv->rx[ring].statss); 201 tmp_rx_pkts = rx->rpackets; 202 tmp_rx_hsplit_pkt = rx->rx_hsplit_pkt; 203 tmp_rx_bytes = rx->rbytes; 204 tmp_rx_skb_alloc_fail = rx->rx_skb_alloc_fail; 205 tmp_rx_buf_alloc_fail = rx->rx_buf_alloc_fail; 206 tmp_rx_desc_err_dropped_pkt = 207 rx->rx_desc_err_dropped_pkt; 208 tmp_rx_hsplit_unsplit_pkt = 209 rx->rx_hsplit_unsplit_pkt; 210 } while (u64_stats_fetch_retry(&priv->rx[ring].statss, 211 start)); 212 rx_pkts += tmp_rx_pkts; 213 rx_hsplit_pkt += tmp_rx_hsplit_pkt; 214 rx_bytes += tmp_rx_bytes; 215 rx_skb_alloc_fail += tmp_rx_skb_alloc_fail; 216 rx_buf_alloc_fail += tmp_rx_buf_alloc_fail; 217 rx_desc_err_dropped_pkt += tmp_rx_desc_err_dropped_pkt; 218 rx_hsplit_unsplit_pkt += tmp_rx_hsplit_unsplit_pkt; 219 } 220 } 221 for (tx_pkts = 0, tx_bytes = 0, tx_dropped = 0, ring = 0; 222 ring < num_tx_queues; ring++) { 223 if (priv->tx) { 224 do { 225 start = 226 u64_stats_fetch_begin(&priv->tx[ring].statss); 227 tmp_tx_pkts = priv->tx[ring].pkt_done; 228 tmp_tx_bytes = priv->tx[ring].bytes_done; 229 } while (u64_stats_fetch_retry(&priv->tx[ring].statss, 230 start)); 231 tx_pkts += tmp_tx_pkts; 232 tx_bytes += tmp_tx_bytes; 233 tx_dropped += priv->tx[ring].dropped_pkt; 234 } 235 } 236 237 i = 0; 238 data[i++] = rx_pkts; 239 data[i++] = rx_hsplit_pkt; 240 data[i++] = tx_pkts; 241 data[i++] = rx_bytes; 242 data[i++] = tx_bytes; 243 /* total rx dropped packets */ 244 data[i++] = rx_skb_alloc_fail + rx_buf_alloc_fail + 245 rx_desc_err_dropped_pkt; 246 data[i++] = tx_dropped; 247 data[i++] = priv->tx_timeo_cnt; 248 data[i++] = rx_skb_alloc_fail; 249 data[i++] = rx_buf_alloc_fail; 250 data[i++] = rx_desc_err_dropped_pkt; 251 data[i++] = rx_hsplit_unsplit_pkt; 252 data[i++] = priv->interface_up_cnt; 253 data[i++] = priv->interface_down_cnt; 254 data[i++] = priv->reset_cnt; 255 data[i++] = priv->page_alloc_fail; 256 data[i++] = priv->dma_mapping_error; 257 data[i++] = priv->stats_report_trigger_cnt; 258 i = GVE_MAIN_STATS_LEN; 259 260 /* For rx cross-reporting stats, start from nic rx stats in report */ 261 base_stats_idx = GVE_TX_STATS_REPORT_NUM * num_tx_queues + 262 GVE_RX_STATS_REPORT_NUM * priv->rx_cfg.num_queues; 263 max_stats_idx = NIC_RX_STATS_REPORT_NUM * priv->rx_cfg.num_queues + 264 base_stats_idx; 265 /* Preprocess the stats report for rx, map queue id to start index */ 266 skip_nic_stats = false; 267 for (stats_idx = base_stats_idx; stats_idx < max_stats_idx; 268 stats_idx += NIC_RX_STATS_REPORT_NUM) { 269 u32 stat_name = be32_to_cpu(report_stats[stats_idx].stat_name); 270 u32 queue_id = be32_to_cpu(report_stats[stats_idx].queue_id); 271 272 if (stat_name == 0) { 273 /* no stats written by NIC yet */ 274 skip_nic_stats = true; 275 break; 276 } 277 rx_qid_to_stats_idx[queue_id] = stats_idx; 278 } 279 /* walk RX rings */ 280 if (priv->rx) { 281 for (ring = 0; ring < priv->rx_cfg.num_queues; ring++) { 282 struct gve_rx_ring *rx = &priv->rx[ring]; 283 284 data[i++] = rx->fill_cnt; 285 data[i++] = rx->cnt; 286 data[i++] = rx->fill_cnt - rx->cnt; 287 do { 288 start = 289 u64_stats_fetch_begin(&priv->rx[ring].statss); 290 tmp_rx_bytes = rx->rbytes; 291 tmp_rx_hsplit_bytes = rx->rx_hsplit_bytes; 292 tmp_rx_skb_alloc_fail = rx->rx_skb_alloc_fail; 293 tmp_rx_buf_alloc_fail = rx->rx_buf_alloc_fail; 294 tmp_rx_desc_err_dropped_pkt = 295 rx->rx_desc_err_dropped_pkt; 296 } while (u64_stats_fetch_retry(&priv->rx[ring].statss, 297 start)); 298 data[i++] = tmp_rx_bytes; 299 data[i++] = tmp_rx_hsplit_bytes; 300 data[i++] = rx->rx_cont_packet_cnt; 301 data[i++] = rx->rx_frag_flip_cnt; 302 data[i++] = rx->rx_frag_copy_cnt; 303 data[i++] = rx->rx_frag_alloc_cnt; 304 /* rx dropped packets */ 305 data[i++] = tmp_rx_skb_alloc_fail + 306 tmp_rx_buf_alloc_fail + 307 tmp_rx_desc_err_dropped_pkt; 308 data[i++] = rx->rx_copybreak_pkt; 309 data[i++] = rx->rx_copied_pkt; 310 /* stats from NIC */ 311 if (skip_nic_stats) { 312 /* skip NIC rx stats */ 313 i += NIC_RX_STATS_REPORT_NUM; 314 } else { 315 stats_idx = rx_qid_to_stats_idx[ring]; 316 for (j = 0; j < NIC_RX_STATS_REPORT_NUM; j++) { 317 u64 value = 318 be64_to_cpu(report_stats[stats_idx + j].value); 319 320 data[i++] = value; 321 } 322 } 323 /* XDP rx counters */ 324 do { 325 start = u64_stats_fetch_begin(&priv->rx[ring].statss); 326 for (j = 0; j < GVE_XDP_ACTIONS; j++) 327 data[i + j] = rx->xdp_actions[j]; 328 data[i + j++] = rx->xdp_tx_errors; 329 data[i + j++] = rx->xdp_redirect_errors; 330 data[i + j++] = rx->xdp_alloc_fails; 331 } while (u64_stats_fetch_retry(&priv->rx[ring].statss, 332 start)); 333 i += GVE_XDP_ACTIONS + 3; /* XDP rx counters */ 334 } 335 } else { 336 i += priv->rx_cfg.num_queues * NUM_GVE_RX_CNTS; 337 } 338 339 /* For tx cross-reporting stats, start from nic tx stats in report */ 340 base_stats_idx = max_stats_idx; 341 max_stats_idx = NIC_TX_STATS_REPORT_NUM * num_tx_queues + 342 max_stats_idx; 343 /* Preprocess the stats report for tx, map queue id to start index */ 344 skip_nic_stats = false; 345 for (stats_idx = base_stats_idx; stats_idx < max_stats_idx; 346 stats_idx += NIC_TX_STATS_REPORT_NUM) { 347 u32 stat_name = be32_to_cpu(report_stats[stats_idx].stat_name); 348 u32 queue_id = be32_to_cpu(report_stats[stats_idx].queue_id); 349 350 if (stat_name == 0) { 351 /* no stats written by NIC yet */ 352 skip_nic_stats = true; 353 break; 354 } 355 tx_qid_to_stats_idx[queue_id] = stats_idx; 356 } 357 /* walk TX rings */ 358 if (priv->tx) { 359 for (ring = 0; ring < num_tx_queues; ring++) { 360 struct gve_tx_ring *tx = &priv->tx[ring]; 361 362 if (gve_is_gqi(priv)) { 363 data[i++] = tx->req; 364 data[i++] = tx->done; 365 data[i++] = tx->req - tx->done; 366 } else { 367 /* DQO doesn't currently support 368 * posted/completed descriptor counts; 369 */ 370 data[i++] = 0; 371 data[i++] = 0; 372 data[i++] = tx->dqo_tx.tail - tx->dqo_tx.head; 373 } 374 do { 375 start = 376 u64_stats_fetch_begin(&priv->tx[ring].statss); 377 tmp_tx_bytes = tx->bytes_done; 378 } while (u64_stats_fetch_retry(&priv->tx[ring].statss, 379 start)); 380 data[i++] = tmp_tx_bytes; 381 data[i++] = tx->wake_queue; 382 data[i++] = tx->stop_queue; 383 data[i++] = gve_tx_load_event_counter(priv, tx); 384 data[i++] = tx->dma_mapping_error; 385 /* stats from NIC */ 386 if (skip_nic_stats) { 387 /* skip NIC tx stats */ 388 i += NIC_TX_STATS_REPORT_NUM; 389 } else { 390 stats_idx = tx_qid_to_stats_idx[ring]; 391 for (j = 0; j < NIC_TX_STATS_REPORT_NUM; j++) { 392 u64 value = 393 be64_to_cpu(report_stats[stats_idx + j].value); 394 data[i++] = value; 395 } 396 } 397 /* XDP xsk counters */ 398 data[i++] = tx->xdp_xsk_wakeup; 399 data[i++] = tx->xdp_xsk_done; 400 do { 401 start = u64_stats_fetch_begin(&priv->tx[ring].statss); 402 data[i] = tx->xdp_xsk_sent; 403 data[i + 1] = tx->xdp_xmit; 404 data[i + 2] = tx->xdp_xmit_errors; 405 } while (u64_stats_fetch_retry(&priv->tx[ring].statss, 406 start)); 407 i += 3; /* XDP tx counters */ 408 } 409 } else { 410 i += num_tx_queues * NUM_GVE_TX_CNTS; 411 } 412 413 kfree(rx_qid_to_stats_idx); 414 kfree(tx_qid_to_stats_idx); 415 /* AQ Stats */ 416 data[i++] = priv->adminq_prod_cnt; 417 data[i++] = priv->adminq_cmd_fail; 418 data[i++] = priv->adminq_timeouts; 419 data[i++] = priv->adminq_describe_device_cnt; 420 data[i++] = priv->adminq_cfg_device_resources_cnt; 421 data[i++] = priv->adminq_register_page_list_cnt; 422 data[i++] = priv->adminq_unregister_page_list_cnt; 423 data[i++] = priv->adminq_create_tx_queue_cnt; 424 data[i++] = priv->adminq_create_rx_queue_cnt; 425 data[i++] = priv->adminq_destroy_tx_queue_cnt; 426 data[i++] = priv->adminq_destroy_rx_queue_cnt; 427 data[i++] = priv->adminq_dcfg_device_resources_cnt; 428 data[i++] = priv->adminq_set_driver_parameter_cnt; 429 data[i++] = priv->adminq_report_stats_cnt; 430 data[i++] = priv->adminq_report_link_speed_cnt; 431 data[i++] = priv->adminq_get_ptype_map_cnt; 432 } 433 434 static void gve_get_channels(struct net_device *netdev, 435 struct ethtool_channels *cmd) 436 { 437 struct gve_priv *priv = netdev_priv(netdev); 438 439 cmd->max_rx = priv->rx_cfg.max_queues; 440 cmd->max_tx = priv->tx_cfg.max_queues; 441 cmd->max_other = 0; 442 cmd->max_combined = 0; 443 cmd->rx_count = priv->rx_cfg.num_queues; 444 cmd->tx_count = priv->tx_cfg.num_queues; 445 cmd->other_count = 0; 446 cmd->combined_count = 0; 447 } 448 449 static int gve_set_channels(struct net_device *netdev, 450 struct ethtool_channels *cmd) 451 { 452 struct gve_priv *priv = netdev_priv(netdev); 453 struct gve_queue_config new_tx_cfg = priv->tx_cfg; 454 struct gve_queue_config new_rx_cfg = priv->rx_cfg; 455 struct ethtool_channels old_settings; 456 int new_tx = cmd->tx_count; 457 int new_rx = cmd->rx_count; 458 459 gve_get_channels(netdev, &old_settings); 460 461 /* Changing combined is not allowed */ 462 if (cmd->combined_count != old_settings.combined_count) 463 return -EINVAL; 464 465 if (!new_rx || !new_tx) 466 return -EINVAL; 467 468 if (priv->num_xdp_queues && 469 (new_tx != new_rx || (2 * new_tx > priv->tx_cfg.max_queues))) { 470 dev_err(&priv->pdev->dev, "XDP load failed: The number of configured RX queues should be equal to the number of configured TX queues and the number of configured RX/TX queues should be less than or equal to half the maximum number of RX/TX queues"); 471 return -EINVAL; 472 } 473 474 if (!netif_carrier_ok(netdev)) { 475 priv->tx_cfg.num_queues = new_tx; 476 priv->rx_cfg.num_queues = new_rx; 477 return 0; 478 } 479 480 new_tx_cfg.num_queues = new_tx; 481 new_rx_cfg.num_queues = new_rx; 482 483 return gve_adjust_queues(priv, new_rx_cfg, new_tx_cfg); 484 } 485 486 static void gve_get_ringparam(struct net_device *netdev, 487 struct ethtool_ringparam *cmd, 488 struct kernel_ethtool_ringparam *kernel_cmd, 489 struct netlink_ext_ack *extack) 490 { 491 struct gve_priv *priv = netdev_priv(netdev); 492 493 cmd->rx_max_pending = priv->max_rx_desc_cnt; 494 cmd->tx_max_pending = priv->max_tx_desc_cnt; 495 cmd->rx_pending = priv->rx_desc_cnt; 496 cmd->tx_pending = priv->tx_desc_cnt; 497 498 if (!gve_header_split_supported(priv)) 499 kernel_cmd->tcp_data_split = ETHTOOL_TCP_DATA_SPLIT_UNKNOWN; 500 else if (priv->header_split_enabled) 501 kernel_cmd->tcp_data_split = ETHTOOL_TCP_DATA_SPLIT_ENABLED; 502 else 503 kernel_cmd->tcp_data_split = ETHTOOL_TCP_DATA_SPLIT_DISABLED; 504 } 505 506 static int gve_adjust_ring_sizes(struct gve_priv *priv, 507 u16 new_tx_desc_cnt, 508 u16 new_rx_desc_cnt) 509 { 510 struct gve_tx_alloc_rings_cfg tx_alloc_cfg = {0}; 511 struct gve_rx_alloc_rings_cfg rx_alloc_cfg = {0}; 512 struct gve_qpls_alloc_cfg qpls_alloc_cfg = {0}; 513 int err; 514 515 /* get current queue configuration */ 516 gve_get_curr_alloc_cfgs(priv, &qpls_alloc_cfg, 517 &tx_alloc_cfg, &rx_alloc_cfg); 518 519 /* copy over the new ring_size from ethtool */ 520 tx_alloc_cfg.ring_size = new_tx_desc_cnt; 521 rx_alloc_cfg.ring_size = new_rx_desc_cnt; 522 523 if (netif_running(priv->dev)) { 524 err = gve_adjust_config(priv, &qpls_alloc_cfg, 525 &tx_alloc_cfg, &rx_alloc_cfg); 526 if (err) 527 return err; 528 } 529 530 /* Set new ring_size for the next up */ 531 priv->tx_desc_cnt = new_tx_desc_cnt; 532 priv->rx_desc_cnt = new_rx_desc_cnt; 533 534 return 0; 535 } 536 537 static int gve_validate_req_ring_size(struct gve_priv *priv, u16 new_tx_desc_cnt, 538 u16 new_rx_desc_cnt) 539 { 540 /* check for valid range */ 541 if (new_tx_desc_cnt < priv->min_tx_desc_cnt || 542 new_tx_desc_cnt > priv->max_tx_desc_cnt || 543 new_rx_desc_cnt < priv->min_rx_desc_cnt || 544 new_rx_desc_cnt > priv->max_rx_desc_cnt) { 545 dev_err(&priv->pdev->dev, "Requested descriptor count out of range\n"); 546 return -EINVAL; 547 } 548 549 if (!is_power_of_2(new_tx_desc_cnt) || !is_power_of_2(new_rx_desc_cnt)) { 550 dev_err(&priv->pdev->dev, "Requested descriptor count has to be a power of 2\n"); 551 return -EINVAL; 552 } 553 return 0; 554 } 555 556 static int gve_set_ringparam(struct net_device *netdev, 557 struct ethtool_ringparam *cmd, 558 struct kernel_ethtool_ringparam *kernel_cmd, 559 struct netlink_ext_ack *extack) 560 { 561 struct gve_priv *priv = netdev_priv(netdev); 562 u16 new_tx_cnt, new_rx_cnt; 563 int err; 564 565 err = gve_set_hsplit_config(priv, kernel_cmd->tcp_data_split); 566 if (err) 567 return err; 568 569 if (cmd->tx_pending == priv->tx_desc_cnt && cmd->rx_pending == priv->rx_desc_cnt) 570 return 0; 571 572 if (!priv->modify_ring_size_enabled) { 573 dev_err(&priv->pdev->dev, "Modify ring size is not supported.\n"); 574 return -EOPNOTSUPP; 575 } 576 577 new_tx_cnt = cmd->tx_pending; 578 new_rx_cnt = cmd->rx_pending; 579 580 if (gve_validate_req_ring_size(priv, new_tx_cnt, new_rx_cnt)) 581 return -EINVAL; 582 583 return gve_adjust_ring_sizes(priv, new_tx_cnt, new_rx_cnt); 584 } 585 586 static int gve_user_reset(struct net_device *netdev, u32 *flags) 587 { 588 struct gve_priv *priv = netdev_priv(netdev); 589 590 if (*flags == ETH_RESET_ALL) { 591 *flags = 0; 592 return gve_reset(priv, true); 593 } 594 595 return -EOPNOTSUPP; 596 } 597 598 static int gve_get_tunable(struct net_device *netdev, 599 const struct ethtool_tunable *etuna, void *value) 600 { 601 struct gve_priv *priv = netdev_priv(netdev); 602 603 switch (etuna->id) { 604 case ETHTOOL_RX_COPYBREAK: 605 *(u32 *)value = priv->rx_copybreak; 606 return 0; 607 default: 608 return -EOPNOTSUPP; 609 } 610 } 611 612 static int gve_set_tunable(struct net_device *netdev, 613 const struct ethtool_tunable *etuna, 614 const void *value) 615 { 616 struct gve_priv *priv = netdev_priv(netdev); 617 u32 len; 618 619 switch (etuna->id) { 620 case ETHTOOL_RX_COPYBREAK: 621 { 622 u32 max_copybreak = gve_is_gqi(priv) ? 623 GVE_DEFAULT_RX_BUFFER_SIZE : priv->data_buffer_size_dqo; 624 625 len = *(u32 *)value; 626 if (len > max_copybreak) 627 return -EINVAL; 628 priv->rx_copybreak = len; 629 return 0; 630 } 631 default: 632 return -EOPNOTSUPP; 633 } 634 } 635 636 static u32 gve_get_priv_flags(struct net_device *netdev) 637 { 638 struct gve_priv *priv = netdev_priv(netdev); 639 u32 ret_flags = 0; 640 641 /* Only 1 flag exists currently: report-stats (BIT(O)), so set that flag. */ 642 if (priv->ethtool_flags & BIT(0)) 643 ret_flags |= BIT(0); 644 return ret_flags; 645 } 646 647 static int gve_set_priv_flags(struct net_device *netdev, u32 flags) 648 { 649 struct gve_priv *priv = netdev_priv(netdev); 650 u64 ori_flags, new_flags; 651 int num_tx_queues; 652 653 num_tx_queues = gve_num_tx_queues(priv); 654 ori_flags = READ_ONCE(priv->ethtool_flags); 655 new_flags = ori_flags; 656 657 /* Only one priv flag exists: report-stats (BIT(0))*/ 658 if (flags & BIT(0)) 659 new_flags |= BIT(0); 660 else 661 new_flags &= ~(BIT(0)); 662 priv->ethtool_flags = new_flags; 663 /* start report-stats timer when user turns report stats on. */ 664 if (flags & BIT(0)) { 665 mod_timer(&priv->stats_report_timer, 666 round_jiffies(jiffies + 667 msecs_to_jiffies(priv->stats_report_timer_period))); 668 } 669 /* Zero off gve stats when report-stats turned off and */ 670 /* delete report stats timer. */ 671 if (!(flags & BIT(0)) && (ori_flags & BIT(0))) { 672 int tx_stats_num = GVE_TX_STATS_REPORT_NUM * 673 num_tx_queues; 674 int rx_stats_num = GVE_RX_STATS_REPORT_NUM * 675 priv->rx_cfg.num_queues; 676 677 memset(priv->stats_report->stats, 0, (tx_stats_num + rx_stats_num) * 678 sizeof(struct stats)); 679 del_timer_sync(&priv->stats_report_timer); 680 } 681 return 0; 682 } 683 684 static int gve_get_link_ksettings(struct net_device *netdev, 685 struct ethtool_link_ksettings *cmd) 686 { 687 struct gve_priv *priv = netdev_priv(netdev); 688 int err = 0; 689 690 if (priv->link_speed == 0) 691 err = gve_adminq_report_link_speed(priv); 692 693 cmd->base.speed = priv->link_speed; 694 695 cmd->base.duplex = DUPLEX_FULL; 696 697 return err; 698 } 699 700 static int gve_get_coalesce(struct net_device *netdev, 701 struct ethtool_coalesce *ec, 702 struct kernel_ethtool_coalesce *kernel_ec, 703 struct netlink_ext_ack *extack) 704 { 705 struct gve_priv *priv = netdev_priv(netdev); 706 707 if (gve_is_gqi(priv)) 708 return -EOPNOTSUPP; 709 ec->tx_coalesce_usecs = priv->tx_coalesce_usecs; 710 ec->rx_coalesce_usecs = priv->rx_coalesce_usecs; 711 712 return 0; 713 } 714 715 static int gve_set_coalesce(struct net_device *netdev, 716 struct ethtool_coalesce *ec, 717 struct kernel_ethtool_coalesce *kernel_ec, 718 struct netlink_ext_ack *extack) 719 { 720 struct gve_priv *priv = netdev_priv(netdev); 721 u32 tx_usecs_orig = priv->tx_coalesce_usecs; 722 u32 rx_usecs_orig = priv->rx_coalesce_usecs; 723 int idx; 724 725 if (gve_is_gqi(priv)) 726 return -EOPNOTSUPP; 727 728 if (ec->tx_coalesce_usecs > GVE_MAX_ITR_INTERVAL_DQO || 729 ec->rx_coalesce_usecs > GVE_MAX_ITR_INTERVAL_DQO) 730 return -EINVAL; 731 priv->tx_coalesce_usecs = ec->tx_coalesce_usecs; 732 priv->rx_coalesce_usecs = ec->rx_coalesce_usecs; 733 734 if (tx_usecs_orig != priv->tx_coalesce_usecs) { 735 for (idx = 0; idx < priv->tx_cfg.num_queues; idx++) { 736 int ntfy_idx = gve_tx_idx_to_ntfy(priv, idx); 737 struct gve_notify_block *block = &priv->ntfy_blocks[ntfy_idx]; 738 739 gve_set_itr_coalesce_usecs_dqo(priv, block, 740 priv->tx_coalesce_usecs); 741 } 742 } 743 744 if (rx_usecs_orig != priv->rx_coalesce_usecs) { 745 for (idx = 0; idx < priv->rx_cfg.num_queues; idx++) { 746 int ntfy_idx = gve_rx_idx_to_ntfy(priv, idx); 747 struct gve_notify_block *block = &priv->ntfy_blocks[ntfy_idx]; 748 749 gve_set_itr_coalesce_usecs_dqo(priv, block, 750 priv->rx_coalesce_usecs); 751 } 752 } 753 754 return 0; 755 } 756 757 const struct ethtool_ops gve_ethtool_ops = { 758 .supported_coalesce_params = ETHTOOL_COALESCE_USECS, 759 .supported_ring_params = ETHTOOL_RING_USE_TCP_DATA_SPLIT, 760 .get_drvinfo = gve_get_drvinfo, 761 .get_strings = gve_get_strings, 762 .get_sset_count = gve_get_sset_count, 763 .get_ethtool_stats = gve_get_ethtool_stats, 764 .set_msglevel = gve_set_msglevel, 765 .get_msglevel = gve_get_msglevel, 766 .set_channels = gve_set_channels, 767 .get_channels = gve_get_channels, 768 .get_link = ethtool_op_get_link, 769 .get_coalesce = gve_get_coalesce, 770 .set_coalesce = gve_set_coalesce, 771 .get_ringparam = gve_get_ringparam, 772 .set_ringparam = gve_set_ringparam, 773 .reset = gve_user_reset, 774 .get_tunable = gve_get_tunable, 775 .set_tunable = gve_set_tunable, 776 .get_priv_flags = gve_get_priv_flags, 777 .set_priv_flags = gve_set_priv_flags, 778 .get_link_ksettings = gve_get_link_ksettings, 779 .get_ts_info = ethtool_op_get_ts_info, 780 }; 781