Merge branch 'Add-GVE-Features' (5bc461fd) · Commits · 戴 / test

drivers/net/ethernet/google/gve/gve.h

+95 −11

Original line number	Diff line number	Diff line
		@@ -27,6 +27,17 @@
		/* 1 for management, 1 for rx, 1 for tx */
		#define GVE_MIN_MSIX 3

		/* Numbers of gve tx/rx stats in stats report. */
		#define GVE_TX_STATS_REPORT_NUM 5
		#define GVE_RX_STATS_REPORT_NUM 2

		/* Interval to schedule a stats report update, 20000ms. */
		#define GVE_STATS_REPORT_TIMER_PERIOD 20000

		/* Numbers of NIC tx/rx stats in stats report. */
		#define NIC_TX_STATS_REPORT_NUM 0
		#define NIC_RX_STATS_REPORT_NUM 4

		/* Each slot in the desc ring has a 1:1 mapping to a slot in the data ring */
		struct gve_rx_desc_queue {
		struct gve_rx_desc desc_ring; / the descriptor ring */
		@@ -71,6 +82,11 @@ struct gve_rx_ring {
		u32 cnt; /* free-running total number of completed packets */
		u32 fill_cnt; /* free-running total number of descs and buffs posted */
		u32 mask; /* masks the cnt and fill_cnt to the size of the ring */
		u64 rx_copybreak_pkt; /* free-running count of copybreak packets */
		u64 rx_copied_pkt; /* free-running total number of copied packets */
		u64 rx_skb_alloc_fail; /* free-running count of skb alloc fails */
		u64 rx_buf_alloc_fail; /* free-running count of buffer alloc fails */
		u64 rx_desc_err_dropped_pkt; /* free-running count of packets dropped by descriptor error */
		u32 q_num; /* queue index */
		u32 ntfy_id; /* notification block index */
		struct gve_queue_resources q_resources; / head and tail pointer idx */
		@@ -202,24 +218,63 @@ struct gve_priv {
		dma_addr_t adminq_bus_addr;
		u32 adminq_mask; /* masks prod_cnt to adminq size */
		u32 adminq_prod_cnt; /* free-running count of AQ cmds executed */

		u32 adminq_cmd_fail; /* free-running count of AQ cmds failed */
		u32 adminq_timeouts; /* free-running count of AQ cmds timeouts */
		/* free-running count of per AQ cmd executed */
		u32 adminq_describe_device_cnt;
		u32 adminq_cfg_device_resources_cnt;
		u32 adminq_register_page_list_cnt;
		u32 adminq_unregister_page_list_cnt;
		u32 adminq_create_tx_queue_cnt;
		u32 adminq_create_rx_queue_cnt;
		u32 adminq_destroy_tx_queue_cnt;
		u32 adminq_destroy_rx_queue_cnt;
		u32 adminq_dcfg_device_resources_cnt;
		u32 adminq_set_driver_parameter_cnt;
		u32 adminq_report_stats_cnt;
		u32 adminq_report_link_speed_cnt;

		/* Global stats */
		u32 interface_up_cnt; /* count of times interface turned up since last reset */
		u32 interface_down_cnt; /* count of times interface turned down since last reset */
		u32 reset_cnt; /* count of reset */
		u32 page_alloc_fail; /* count of page alloc fails */
		u32 dma_mapping_error; /* count of dma mapping errors */
		u32 stats_report_trigger_cnt; /* count of device-requested stats-reports since last reset */
		struct workqueue_struct *gve_wq;
		struct work_struct service_task;
		struct work_struct stats_report_task;
		unsigned long service_task_flags;
		unsigned long state_flags;

		struct gve_stats_report *stats_report;
		u64 stats_report_len;
		dma_addr_t stats_report_bus; /* dma address for the stats report */
		unsigned long ethtool_flags;

		unsigned long stats_report_timer_period;
		struct timer_list stats_report_timer;

		/* Gvnic device link speed from hypervisor. */
		u64 link_speed;
		};

		enum gve_service_task_flags {
		GVE_PRIV_FLAGS_DO_RESET = BIT(1),
		GVE_PRIV_FLAGS_RESET_IN_PROGRESS = BIT(2),
		GVE_PRIV_FLAGS_PROBE_IN_PROGRESS = BIT(3),
		enum gve_service_task_flags_bit {
		GVE_PRIV_FLAGS_DO_RESET = 1,
		GVE_PRIV_FLAGS_RESET_IN_PROGRESS = 2,
		GVE_PRIV_FLAGS_PROBE_IN_PROGRESS = 3,
		GVE_PRIV_FLAGS_DO_REPORT_STATS = 4,
		};

		enum gve_state_flags {
		GVE_PRIV_FLAGS_ADMIN_QUEUE_OK = BIT(1),
		GVE_PRIV_FLAGS_DEVICE_RESOURCES_OK = BIT(2),
		GVE_PRIV_FLAGS_DEVICE_RINGS_OK = BIT(3),
		GVE_PRIV_FLAGS_NAPI_ENABLED = BIT(4),
		enum gve_state_flags_bit {
		GVE_PRIV_FLAGS_ADMIN_QUEUE_OK = 1,
		GVE_PRIV_FLAGS_DEVICE_RESOURCES_OK = 2,
		GVE_PRIV_FLAGS_DEVICE_RINGS_OK = 3,
		GVE_PRIV_FLAGS_NAPI_ENABLED = 4,
		};

		enum gve_ethtool_flags_bit {
		GVE_PRIV_FLAGS_REPORT_STATS = 0,
		};

		static inline bool gve_get_do_reset(struct gve_priv *priv)
		@@ -269,6 +324,22 @@ static inline void gve_clear_probe_in_progress(struct gve_priv *priv)
		clear_bit(GVE_PRIV_FLAGS_PROBE_IN_PROGRESS, &priv->service_task_flags);
		}

		static inline bool gve_get_do_report_stats(struct gve_priv *priv)
		{
		return test_bit(GVE_PRIV_FLAGS_DO_REPORT_STATS,
		&priv->service_task_flags);
		}

		static inline void gve_set_do_report_stats(struct gve_priv *priv)
		{
		set_bit(GVE_PRIV_FLAGS_DO_REPORT_STATS, &priv->service_task_flags);
		}

		static inline void gve_clear_do_report_stats(struct gve_priv *priv)
		{
		clear_bit(GVE_PRIV_FLAGS_DO_REPORT_STATS, &priv->service_task_flags);
		}

		static inline bool gve_get_admin_queue_ok(struct gve_priv *priv)
		{
		return test_bit(GVE_PRIV_FLAGS_ADMIN_QUEUE_OK, &priv->state_flags);
		@@ -329,6 +400,16 @@ static inline void gve_clear_napi_enabled(struct gve_priv *priv)
		clear_bit(GVE_PRIV_FLAGS_NAPI_ENABLED, &priv->state_flags);
		}

		static inline bool gve_get_report_stats(struct gve_priv *priv)
		{
		return test_bit(GVE_PRIV_FLAGS_REPORT_STATS, &priv->ethtool_flags);
		}

		static inline void gve_clear_report_stats(struct gve_priv *priv)
		{
		clear_bit(GVE_PRIV_FLAGS_REPORT_STATS, &priv->ethtool_flags);
		}

		/* Returns the address of the ntfy_blocks irq doorbell
		*/
		static inline __be32 __iomem gve_irq_doorbell(struct gve_priv priv,
		@@ -426,7 +507,8 @@ static inline bool gve_can_recycle_pages(struct net_device *dev)
		}

		/* buffers */
		int gve_alloc_page(struct device dev, struct page page, dma_addr_t dma,
		int gve_alloc_page(struct gve_priv priv, struct device dev,
		struct page *page, dma_addr_t dma,
		enum dma_data_direction);
		void gve_free_page(struct device dev, struct page page, dma_addr_t dma,
		enum dma_data_direction);
		@@ -450,6 +532,8 @@ int gve_reset(struct gve_priv *priv, bool attempt_teardown);
		int gve_adjust_queues(struct gve_priv *priv,
		struct gve_queue_config new_rx_config,
		struct gve_queue_config new_tx_config);
		/* report stats handling */
		void gve_handle_report_stats(struct gve_priv *priv);
		/* exported by ethtool.c */
		extern const struct ethtool_ops gve_ethtool_ops;
		/* needed by ethtool */

drivers/net/ethernet/google/gve/gve_adminq.c

+278 −37

Original line number	Diff line number	Diff line
		@@ -23,6 +23,20 @@ int gve_adminq_alloc(struct device dev, struct gve_priv priv)

		priv->adminq_mask = (PAGE_SIZE / sizeof(union gve_adminq_command)) - 1;
		priv->adminq_prod_cnt = 0;
		priv->adminq_cmd_fail = 0;
		priv->adminq_timeouts = 0;
		priv->adminq_describe_device_cnt = 0;
		priv->adminq_cfg_device_resources_cnt = 0;
		priv->adminq_register_page_list_cnt = 0;
		priv->adminq_unregister_page_list_cnt = 0;
		priv->adminq_create_tx_queue_cnt = 0;
		priv->adminq_create_rx_queue_cnt = 0;
		priv->adminq_destroy_tx_queue_cnt = 0;
		priv->adminq_destroy_rx_queue_cnt = 0;
		priv->adminq_dcfg_device_resources_cnt = 0;
		priv->adminq_set_driver_parameter_cnt = 0;
		priv->adminq_report_stats_cnt = 0;
		priv->adminq_report_link_speed_cnt = 0;

		/* Setup Admin queue with the device */
		iowrite32be(priv->adminq_bus_addr / PAGE_SIZE,
		@@ -81,17 +95,18 @@ static bool gve_adminq_wait_for_cmd(struct gve_priv *priv, u32 prod_cnt)
		return false;
		}

		static int gve_adminq_parse_err(struct device *dev, u32 status)
		static int gve_adminq_parse_err(struct gve_priv *priv, u32 status)
		{
		if (status != GVE_ADMINQ_COMMAND_PASSED &&
		status != GVE_ADMINQ_COMMAND_UNSET)
		dev_err(dev, "AQ command failed with status %d\n", status);

		status != GVE_ADMINQ_COMMAND_UNSET) {
		dev_err(&priv->pdev->dev, "AQ command failed with status %d\n", status);
		priv->adminq_cmd_fail++;
		}
		switch (status) {
		case GVE_ADMINQ_COMMAND_PASSED:
		return 0;
		case GVE_ADMINQ_COMMAND_UNSET:
		dev_err(dev, "parse_aq_err: err and status both unset, this should not be possible.\n");
		dev_err(&priv->pdev->dev, "parse_aq_err: err and status both unset, this should not be possible.\n");
		return -EINVAL;
		case GVE_ADMINQ_COMMAND_ERROR_ABORTED:
		case GVE_ADMINQ_COMMAND_ERROR_CANCELLED:
		@@ -116,36 +131,145 @@ static int gve_adminq_parse_err(struct device *dev, u32 status)
		case GVE_ADMINQ_COMMAND_ERROR_UNIMPLEMENTED:
		return -ENOTSUPP;
		default:
		dev_err(dev, "parse_aq_err: unknown status code %d\n", status);
		dev_err(&priv->pdev->dev, "parse_aq_err: unknown status code %d\n", status);
		return -EINVAL;
		}
		}

		/* Flushes all AQ commands currently queued and waits for them to complete.
		* If there are failures, it will return the first error.
		*/
		static int gve_adminq_kick_and_wait(struct gve_priv *priv)
		{
		u32 tail, head;
		int i;

		tail = ioread32be(&priv->reg_bar0->adminq_event_counter);
		head = priv->adminq_prod_cnt;

		gve_adminq_kick_cmd(priv, head);
		if (!gve_adminq_wait_for_cmd(priv, head)) {
		dev_err(&priv->pdev->dev, "AQ commands timed out, need to reset AQ\n");
		priv->adminq_timeouts++;
		return -ENOTRECOVERABLE;
		}

		for (i = tail; i < head; i++) {
		union gve_adminq_command *cmd;
		u32 status, err;

		cmd = &priv->adminq[i & priv->adminq_mask];
		status = be32_to_cpu(READ_ONCE(cmd->status));
		err = gve_adminq_parse_err(priv, status);
		if (err)
		// Return the first error if we failed.
		return err;
		}

		return 0;
		}

		/* This function is not threadsafe - the caller is responsible for any
		* necessary locks.
		*/
		int gve_adminq_execute_cmd(struct gve_priv *priv,
		static int gve_adminq_issue_cmd(struct gve_priv *priv,
		union gve_adminq_command *cmd_orig)
		{
		union gve_adminq_command *cmd;
		u32 status = 0;
		u32 prod_cnt;
		u32 opcode;
		u32 tail;

		tail = ioread32be(&priv->reg_bar0->adminq_event_counter);

		// Check if next command will overflow the buffer.
		if (((priv->adminq_prod_cnt + 1) & priv->adminq_mask) == tail) {
		int err;

		// Flush existing commands to make room.
		err = gve_adminq_kick_and_wait(priv);
		if (err)
		return err;

		// Retry.
		tail = ioread32be(&priv->reg_bar0->adminq_event_counter);
		if (((priv->adminq_prod_cnt + 1) & priv->adminq_mask) == tail) {
		// This should never happen. We just flushed the
		// command queue so there should be enough space.
		return -ENOMEM;
		}
		}

		cmd = &priv->adminq[priv->adminq_prod_cnt & priv->adminq_mask];
		priv->adminq_prod_cnt++;
		prod_cnt = priv->adminq_prod_cnt;

		memcpy(cmd, cmd_orig, sizeof(*cmd_orig));
		opcode = be32_to_cpu(READ_ONCE(cmd->opcode));

		switch (opcode) {
		case GVE_ADMINQ_DESCRIBE_DEVICE:
		priv->adminq_describe_device_cnt++;
		break;
		case GVE_ADMINQ_CONFIGURE_DEVICE_RESOURCES:
		priv->adminq_cfg_device_resources_cnt++;
		break;
		case GVE_ADMINQ_REGISTER_PAGE_LIST:
		priv->adminq_register_page_list_cnt++;
		break;
		case GVE_ADMINQ_UNREGISTER_PAGE_LIST:
		priv->adminq_unregister_page_list_cnt++;
		break;
		case GVE_ADMINQ_CREATE_TX_QUEUE:
		priv->adminq_create_tx_queue_cnt++;
		break;
		case GVE_ADMINQ_CREATE_RX_QUEUE:
		priv->adminq_create_rx_queue_cnt++;
		break;
		case GVE_ADMINQ_DESTROY_TX_QUEUE:
		priv->adminq_destroy_tx_queue_cnt++;
		break;
		case GVE_ADMINQ_DESTROY_RX_QUEUE:
		priv->adminq_destroy_rx_queue_cnt++;
		break;
		case GVE_ADMINQ_DECONFIGURE_DEVICE_RESOURCES:
		priv->adminq_dcfg_device_resources_cnt++;
		break;
		case GVE_ADMINQ_SET_DRIVER_PARAMETER:
		priv->adminq_set_driver_parameter_cnt++;
		break;
		case GVE_ADMINQ_REPORT_STATS:
		priv->adminq_report_stats_cnt++;
		break;
		case GVE_ADMINQ_REPORT_LINK_SPEED:
		priv->adminq_report_link_speed_cnt++;
		break;
		default:
		dev_err(&priv->pdev->dev, "unknown AQ command opcode %d\n", opcode);
		}

		gve_adminq_kick_cmd(priv, prod_cnt);
		if (!gve_adminq_wait_for_cmd(priv, prod_cnt)) {
		dev_err(&priv->pdev->dev, "AQ command timed out, need to reset AQ\n");
		return -ENOTRECOVERABLE;
		return 0;
		}

		memcpy(cmd_orig, cmd, sizeof(*cmd));
		status = be32_to_cpu(READ_ONCE(cmd->status));
		return gve_adminq_parse_err(&priv->pdev->dev, status);
		/* This function is not threadsafe - the caller is responsible for any
		* necessary locks.
		* The caller is also responsible for making sure there are no commands
		* waiting to be executed.
		*/
		static int gve_adminq_execute_cmd(struct gve_priv priv, union gve_adminq_command cmd_orig)
		{
		u32 tail, head;
		int err;

		tail = ioread32be(&priv->reg_bar0->adminq_event_counter);
		head = priv->adminq_prod_cnt;
		if (tail != head)
		// This is not a valid path
		return -EINVAL;

		err = gve_adminq_issue_cmd(priv, cmd_orig);
		if (err)
		return err;

		return gve_adminq_kick_and_wait(priv);
		}

		/* The device specifies that the management vector can either be the first irq
		@@ -190,29 +314,50 @@ int gve_adminq_deconfigure_device_resources(struct gve_priv *priv)
		return gve_adminq_execute_cmd(priv, &cmd);
		}

		int gve_adminq_create_tx_queue(struct gve_priv *priv, u32 queue_index)
		static int gve_adminq_create_tx_queue(struct gve_priv *priv, u32 queue_index)
		{
		struct gve_tx_ring *tx = &priv->tx[queue_index];
		union gve_adminq_command cmd;
		int err;

		memset(&cmd, 0, sizeof(cmd));
		cmd.opcode = cpu_to_be32(GVE_ADMINQ_CREATE_TX_QUEUE);
		cmd.create_tx_queue = (struct gve_adminq_create_tx_queue) {
		.queue_id = cpu_to_be32(queue_index),
		.reserved = 0,
		.queue_resources_addr = cpu_to_be64(tx->q_resources_bus),
		.queue_resources_addr =
		cpu_to_be64(tx->q_resources_bus),
		.tx_ring_addr = cpu_to_be64(tx->bus),
		.queue_page_list_id = cpu_to_be32(tx->tx_fifo.qpl->id),
		.ntfy_id = cpu_to_be32(tx->ntfy_id),
		};

		return gve_adminq_execute_cmd(priv, &cmd);
		err = gve_adminq_issue_cmd(priv, &cmd);
		if (err)
		return err;

		return 0;
		}

		int gve_adminq_create_tx_queues(struct gve_priv *priv, u32 num_queues)
		{
		int err;
		int i;

		for (i = 0; i < num_queues; i++) {
		err = gve_adminq_create_tx_queue(priv, i);
		if (err)
		return err;
		}

		return gve_adminq_kick_and_wait(priv);
		}

		int gve_adminq_create_rx_queue(struct gve_priv *priv, u32 queue_index)
		static int gve_adminq_create_rx_queue(struct gve_priv *priv, u32 queue_index)
		{
		struct gve_rx_ring *rx = &priv->rx[queue_index];
		union gve_adminq_command cmd;
		int err;

		memset(&cmd, 0, sizeof(cmd));
		cmd.opcode = cpu_to_be32(GVE_ADMINQ_CREATE_RX_QUEUE);
		@@ -227,12 +372,31 @@ int gve_adminq_create_rx_queue(struct gve_priv *priv, u32 queue_index)
		.queue_page_list_id = cpu_to_be32(rx->data.qpl->id),
		};

		return gve_adminq_execute_cmd(priv, &cmd);
		err = gve_adminq_issue_cmd(priv, &cmd);
		if (err)
		return err;

		return 0;
		}

		int gve_adminq_destroy_tx_queue(struct gve_priv *priv, u32 queue_index)
		int gve_adminq_create_rx_queues(struct gve_priv *priv, u32 num_queues)
		{
		int err;
		int i;

		for (i = 0; i < num_queues; i++) {
		err = gve_adminq_create_rx_queue(priv, i);
		if (err)
		return err;
		}

		return gve_adminq_kick_and_wait(priv);
		}

		static int gve_adminq_destroy_tx_queue(struct gve_priv *priv, u32 queue_index)
		{
		union gve_adminq_command cmd;
		int err;

		memset(&cmd, 0, sizeof(cmd));
		cmd.opcode = cpu_to_be32(GVE_ADMINQ_DESTROY_TX_QUEUE);
		@@ -240,12 +404,31 @@ int gve_adminq_destroy_tx_queue(struct gve_priv *priv, u32 queue_index)
		.queue_id = cpu_to_be32(queue_index),
		};

		return gve_adminq_execute_cmd(priv, &cmd);
		err = gve_adminq_issue_cmd(priv, &cmd);
		if (err)
		return err;

		return 0;
		}

		int gve_adminq_destroy_tx_queues(struct gve_priv *priv, u32 num_queues)
		{
		int err;
		int i;

		for (i = 0; i < num_queues; i++) {
		err = gve_adminq_destroy_tx_queue(priv, i);
		if (err)
		return err;
		}

		return gve_adminq_kick_and_wait(priv);
		}

		int gve_adminq_destroy_rx_queue(struct gve_priv *priv, u32 queue_index)
		static int gve_adminq_destroy_rx_queue(struct gve_priv *priv, u32 queue_index)
		{
		union gve_adminq_command cmd;
		int err;

		memset(&cmd, 0, sizeof(cmd));
		cmd.opcode = cpu_to_be32(GVE_ADMINQ_DESTROY_RX_QUEUE);
		@@ -253,7 +436,25 @@ int gve_adminq_destroy_rx_queue(struct gve_priv *priv, u32 queue_index)
		.queue_id = cpu_to_be32(queue_index),
		};

		return gve_adminq_execute_cmd(priv, &cmd);
		err = gve_adminq_issue_cmd(priv, &cmd);
		if (err)
		return err;

		return 0;
		}

		int gve_adminq_destroy_rx_queues(struct gve_priv *priv, u32 num_queues)
		{
		int err;
		int i;

		for (i = 0; i < num_queues; i++) {
		err = gve_adminq_destroy_rx_queue(priv, i);
		if (err)
		return err;
		}

		return gve_adminq_kick_and_wait(priv);
		}

		int gve_adminq_describe_device(struct gve_priv *priv)
		@@ -283,8 +484,7 @@ int gve_adminq_describe_device(struct gve_priv *priv)

		priv->tx_desc_cnt = be16_to_cpu(descriptor->tx_queue_entries);
		if (priv->tx_desc_cnt * sizeof(priv->tx->desc[0]) < PAGE_SIZE) {
		netif_err(priv, drv, priv->dev, "Tx desc count %d too low\n",
		priv->tx_desc_cnt);
		dev_err(&priv->pdev->dev, "Tx desc count %d too low\n", priv->tx_desc_cnt);
		err = -EINVAL;
		goto free_device_descriptor;
		}
		@@ -293,8 +493,7 @@ int gve_adminq_describe_device(struct gve_priv *priv)
		< PAGE_SIZE \|\|
		priv->rx_desc_cnt * sizeof(priv->rx->data.data_ring[0])
		< PAGE_SIZE) {
		netif_err(priv, drv, priv->dev, "Rx desc count %d too low\n",
		priv->rx_desc_cnt);
		dev_err(&priv->pdev->dev, "Rx desc count %d too low\n", priv->rx_desc_cnt);
		err = -EINVAL;
		goto free_device_descriptor;
		}
		@@ -302,8 +501,7 @@ int gve_adminq_describe_device(struct gve_priv *priv)
		be64_to_cpu(descriptor->max_registered_pages);
		mtu = be16_to_cpu(descriptor->mtu);
		if (mtu < ETH_MIN_MTU) {
		netif_err(priv, drv, priv->dev, "MTU %d below minimum MTU\n",
		mtu);
		dev_err(&priv->pdev->dev, "MTU %d below minimum MTU\n", mtu);
		err = -EINVAL;
		goto free_device_descriptor;
		}
		@@ -311,11 +509,11 @@ int gve_adminq_describe_device(struct gve_priv *priv)
		priv->num_event_counters = be16_to_cpu(descriptor->counters);
		ether_addr_copy(priv->dev->dev_addr, descriptor->mac);
		mac = descriptor->mac;
		netif_info(priv, drv, priv->dev, "MAC addr: %pM\n", mac);
		dev_info(&priv->pdev->dev, "MAC addr: %pM\n", mac);
		priv->tx_pages_per_qpl = be16_to_cpu(descriptor->tx_pages_per_qpl);
		priv->rx_pages_per_qpl = be16_to_cpu(descriptor->rx_pages_per_qpl);
		if (priv->rx_pages_per_qpl < priv->rx_desc_cnt) {
		netif_err(priv, drv, priv->dev, "rx_pages_per_qpl cannot be smaller than rx_desc_cnt, setting rx_desc_cnt down to %d.\n",
		dev_err(&priv->pdev->dev, "rx_pages_per_qpl cannot be smaller than rx_desc_cnt, setting rx_desc_cnt down to %d.\n",
		priv->rx_pages_per_qpl);
		priv->rx_desc_cnt = priv->rx_pages_per_qpl;
		}
		@@ -385,3 +583,46 @@ int gve_adminq_set_mtu(struct gve_priv *priv, u64 mtu)

		return gve_adminq_execute_cmd(priv, &cmd);
		}

		int gve_adminq_report_stats(struct gve_priv *priv, u64 stats_report_len,
		dma_addr_t stats_report_addr, u64 interval)
		{
		union gve_adminq_command cmd;

		memset(&cmd, 0, sizeof(cmd));
		cmd.opcode = cpu_to_be32(GVE_ADMINQ_REPORT_STATS);
		cmd.report_stats = (struct gve_adminq_report_stats) {
		.stats_report_len = cpu_to_be64(stats_report_len),
		.stats_report_addr = cpu_to_be64(stats_report_addr),
		.interval = cpu_to_be64(interval),
		};

		return gve_adminq_execute_cmd(priv, &cmd);
		}

		int gve_adminq_report_link_speed(struct gve_priv *priv)
		{
		union gve_adminq_command gvnic_cmd;
		dma_addr_t link_speed_region_bus;
		__be64 *link_speed_region;
		int err;

		link_speed_region =
		dma_alloc_coherent(&priv->pdev->dev, sizeof(*link_speed_region),
		&link_speed_region_bus, GFP_KERNEL);

		if (!link_speed_region)
		return -ENOMEM;

		memset(&gvnic_cmd, 0, sizeof(gvnic_cmd));
		gvnic_cmd.opcode = cpu_to_be32(GVE_ADMINQ_REPORT_LINK_SPEED);
		gvnic_cmd.report_link_speed.link_speed_address =
		cpu_to_be64(link_speed_region_bus);

		err = gve_adminq_execute_cmd(priv, &gvnic_cmd);

		priv->link_speed = be64_to_cpu(*link_speed_region);
		dma_free_coherent(&priv->pdev->dev, sizeof(*link_speed_region), link_speed_region,
		link_speed_region_bus);
		return err;
		}

drivers/net/ethernet/google/gve/gve_adminq.h

+56 −6

Original line number	Diff line number	Diff line
		@@ -21,6 +21,8 @@ enum gve_adminq_opcodes {
		GVE_ADMINQ_DESTROY_RX_QUEUE = 0x8,
		GVE_ADMINQ_DECONFIGURE_DEVICE_RESOURCES = 0x9,
		GVE_ADMINQ_SET_DRIVER_PARAMETER = 0xB,
		GVE_ADMINQ_REPORT_STATS = 0xC,
		GVE_ADMINQ_REPORT_LINK_SPEED = 0xD
		};

		/* Admin queue status codes */
		@@ -172,6 +174,51 @@ struct gve_adminq_set_driver_parameter {

		static_assert(sizeof(struct gve_adminq_set_driver_parameter) == 16);

		struct gve_adminq_report_stats {
		__be64 stats_report_len;
		__be64 stats_report_addr;
		__be64 interval;
		};

		static_assert(sizeof(struct gve_adminq_report_stats) == 24);

		struct gve_adminq_report_link_speed {
		__be64 link_speed_address;
		};

		static_assert(sizeof(struct gve_adminq_report_link_speed) == 8);

		struct stats {
		__be32 stat_name;
		__be32 queue_id;
		__be64 value;
		};

		static_assert(sizeof(struct stats) == 16);

		struct gve_stats_report {
		__be64 written_count;
		struct stats stats[0];
		};

		static_assert(sizeof(struct gve_stats_report) == 8);

		enum gve_stat_names {
		// stats from gve
		TX_WAKE_CNT = 1,
		TX_STOP_CNT = 2,
		TX_FRAMES_SENT = 3,
		TX_BYTES_SENT = 4,
		TX_LAST_COMPLETION_PROCESSED = 5,
		RX_NEXT_EXPECTED_SEQUENCE = 6,
		RX_BUFFERS_POSTED = 7,
		// stats from NIC
		RX_QUEUE_DROP_CNT = 65,
		RX_NO_BUFFERS_POSTED = 66,
		RX_DROPS_PACKET_OVER_MRU = 67,
		RX_DROPS_INVALID_CHECKSUM = 68,
		};

		union gve_adminq_command {
		struct {
		__be32 opcode;
		@@ -187,6 +234,8 @@ union gve_adminq_command {
		struct gve_adminq_register_page_list reg_page_list;
		struct gve_adminq_unregister_page_list unreg_page_list;
		struct gve_adminq_set_driver_parameter set_driver_param;
		struct gve_adminq_report_stats report_stats;
		struct gve_adminq_report_link_speed report_link_speed;
		};
		};
		u8 reserved[64];
		@@ -197,8 +246,6 @@ static_assert(sizeof(union gve_adminq_command) == 64);
		int gve_adminq_alloc(struct device dev, struct gve_priv priv);
		void gve_adminq_free(struct device dev, struct gve_priv priv);
		void gve_adminq_release(struct gve_priv *priv);
		int gve_adminq_execute_cmd(struct gve_priv *priv,
		union gve_adminq_command *cmd_orig);
		int gve_adminq_describe_device(struct gve_priv *priv);
		int gve_adminq_configure_device_resources(struct gve_priv *priv,
		dma_addr_t counter_array_bus_addr,
		@@ -206,12 +253,15 @@ int gve_adminq_configure_device_resources(struct gve_priv *priv,
		dma_addr_t db_array_bus_addr,
		u32 num_ntfy_blks);
		int gve_adminq_deconfigure_device_resources(struct gve_priv *priv);
		int gve_adminq_create_tx_queue(struct gve_priv *priv, u32 queue_id);
		int gve_adminq_destroy_tx_queue(struct gve_priv *priv, u32 queue_id);
		int gve_adminq_create_rx_queue(struct gve_priv *priv, u32 queue_id);
		int gve_adminq_destroy_rx_queue(struct gve_priv *priv, u32 queue_id);
		int gve_adminq_create_tx_queues(struct gve_priv *priv, u32 num_queues);
		int gve_adminq_destroy_tx_queues(struct gve_priv *priv, u32 queue_id);
		int gve_adminq_create_rx_queues(struct gve_priv *priv, u32 num_queues);
		int gve_adminq_destroy_rx_queues(struct gve_priv *priv, u32 queue_id);
		int gve_adminq_register_page_list(struct gve_priv *priv,
		struct gve_queue_page_list *qpl);
		int gve_adminq_unregister_page_list(struct gve_priv *priv, u32 page_list_id);
		int gve_adminq_set_mtu(struct gve_priv *priv, u64 mtu);
		int gve_adminq_report_stats(struct gve_priv *priv, u64 stats_report_len,
		dma_addr_t stats_report_addr, u64 interval);
		int gve_adminq_report_link_speed(struct gve_priv *priv);
		#endif /* _GVE_ADMINQ_H */

drivers/net/ethernet/google/gve/gve_ethtool.c

+328 −37

File changed.

Preview size limit exceeded, changes collapsed.

drivers/net/ethernet/google/gve/gve_main.c

+236 −65

File changed.

Preview size limit exceeded, changes collapsed.

Admin message