Commit 6df5713e authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'gve-jumbo-frame' 



Jeroen de Borst says:

====================
gve: Add jumbo-frame support for GQ

This patchset introduces jumbo-frame support for the GQ queue format.
The device already supports jumbo-frames on TX. This introduces
multi-descriptor RX packets using a packet continuation bit.

A widely deployed driver has a bug with causes it to fail to load
when a MTU greater than 2048 bytes is configured. A jumbo-frame device
option is introduced to pass a jumbo-frame MTU only to drivers that
support it.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 233cdfba 255489f5

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

+18 −3
Original line number Diff line number Diff line
@@ -142,6 +142,19 @@ struct gve_index_list { 
	s16 tail;

};



/* A single received packet split across multiple buffers may be

 * reconstructed using the information in this structure.

 */

struct gve_rx_ctx {

	/* head and tail of skb chain for the current packet or NULL if none */

	struct sk_buff *skb_head;

	struct sk_buff *skb_tail;

	u16 total_expected_size;

	u8 expected_frag_cnt;

	u8 curr_frag_cnt;

	u8 reuse_frags;

};



/* Contains datapath state used to represent an RX queue. */

struct gve_rx_ring {

	struct gve_priv *gve;
@@ -153,6 +166,7 @@ struct gve_rx_ring { 


			/* threshold for posting new buffs and descs */

			u32 db_threshold;

			u16 packet_buffer_size;

		};



		/* DQO fields. */
@@ -200,15 +214,16 @@ struct gve_rx_ring { 
	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 */

	u64 rx_cont_packet_cnt; /* free-running multi-fragment packets received */

	u64 rx_frag_flip_cnt; /* free-running count of rx segments where page_flip was used */

	u64 rx_frag_copy_cnt; /* free-running count of rx segments copied into skb linear portion */

	u32 q_num; /* queue index */

	u32 ntfy_id; /* notification block index */

	struct gve_queue_resources *q_resources; /* head and tail pointer idx */

	dma_addr_t q_resources_bus; /* dma address for the queue resources */

	struct u64_stats_sync statss; /* sync stats for 32bit archs */



	/* head and tail of skb chain for the current packet or NULL if none */

	struct sk_buff *skb_head;

	struct sk_buff *skb_tail;

	struct gve_rx_ctx ctx; /* Info for packet currently being processed in this ring. */

};



/* A TX desc ring entry */

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

+55 −4
Original line number Diff line number Diff line
@@ -38,7 +38,8 @@ void gve_parse_device_option(struct gve_priv *priv, 
			     struct gve_device_option *option,

			     struct gve_device_option_gqi_rda **dev_op_gqi_rda,

			     struct gve_device_option_gqi_qpl **dev_op_gqi_qpl,

			     struct gve_device_option_dqo_rda **dev_op_dqo_rda)

			     struct gve_device_option_dqo_rda **dev_op_dqo_rda,

			     struct gve_device_option_jumbo_frames **dev_op_jumbo_frames)

{

	u32 req_feat_mask = be32_to_cpu(option->required_features_mask);

	u16 option_length = be16_to_cpu(option->option_length);
@@ -111,6 +112,24 @@ void gve_parse_device_option(struct gve_priv *priv, 
		}

		*dev_op_dqo_rda = (void *)(option + 1);

		break;

	case GVE_DEV_OPT_ID_JUMBO_FRAMES:

		if (option_length < sizeof(**dev_op_jumbo_frames) ||

		    req_feat_mask != GVE_DEV_OPT_REQ_FEAT_MASK_JUMBO_FRAMES) {

			dev_warn(&priv->pdev->dev, GVE_DEVICE_OPTION_ERROR_FMT,

				 "Jumbo Frames",

				 (int)sizeof(**dev_op_jumbo_frames),

				 GVE_DEV_OPT_REQ_FEAT_MASK_JUMBO_FRAMES,

				 option_length, req_feat_mask);

			break;

		}



		if (option_length > sizeof(**dev_op_jumbo_frames)) {

			dev_warn(&priv->pdev->dev,

				 GVE_DEVICE_OPTION_TOO_BIG_FMT,

				 "Jumbo Frames");

		}

		*dev_op_jumbo_frames = (void *)(option + 1);

		break;

	default:

		/* If we don't recognize the option just continue

		 * without doing anything.
@@ -126,7 +145,8 @@ gve_process_device_options(struct gve_priv *priv, 
			   struct gve_device_descriptor *descriptor,

			   struct gve_device_option_gqi_rda **dev_op_gqi_rda,

			   struct gve_device_option_gqi_qpl **dev_op_gqi_qpl,

			   struct gve_device_option_dqo_rda **dev_op_dqo_rda)

			   struct gve_device_option_dqo_rda **dev_op_dqo_rda,

			   struct gve_device_option_jumbo_frames **dev_op_jumbo_frames)

{

	const int num_options = be16_to_cpu(descriptor->num_device_options);

	struct gve_device_option *dev_opt;
@@ -146,7 +166,7 @@ gve_process_device_options(struct gve_priv *priv, 


		gve_parse_device_option(priv, descriptor, dev_opt,

					dev_op_gqi_rda, dev_op_gqi_qpl,

					dev_op_dqo_rda);

					dev_op_dqo_rda, dev_op_jumbo_frames);

		dev_opt = next_opt;

	}
@@ -530,6 +550,7 @@ static int gve_adminq_create_rx_queue(struct gve_priv *priv, u32 queue_index) 
			cpu_to_be64(rx->data.data_bus),

		cmd.create_rx_queue.index = cpu_to_be32(queue_index);

		cmd.create_rx_queue.queue_page_list_id = cpu_to_be32(qpl_id);

		cmd.create_rx_queue.packet_buffer_size = cpu_to_be16(rx->packet_buffer_size);

	} else {

		cmd.create_rx_queue.rx_ring_size =

			cpu_to_be16(priv->rx_desc_cnt);
@@ -660,12 +681,31 @@ gve_set_desc_cnt_dqo(struct gve_priv *priv, 
	return 0;

}



static void gve_enable_supported_features(struct gve_priv *priv,

					  u32 supported_features_mask,

					  const struct gve_device_option_jumbo_frames

						  *dev_op_jumbo_frames)

{

	/* Before control reaches this point, the page-size-capped max MTU from

	 * the gve_device_descriptor field has already been stored in

	 * priv->dev->max_mtu. We overwrite it with the true max MTU below.

	 */

	if (dev_op_jumbo_frames &&

	    (supported_features_mask & GVE_SUP_JUMBO_FRAMES_MASK)) {

		dev_info(&priv->pdev->dev,

			 "JUMBO FRAMES device option enabled.\n");

		priv->dev->max_mtu = be16_to_cpu(dev_op_jumbo_frames->max_mtu);

	}

}



int gve_adminq_describe_device(struct gve_priv *priv)

{

	struct gve_device_option_jumbo_frames *dev_op_jumbo_frames = NULL;

	struct gve_device_option_gqi_rda *dev_op_gqi_rda = NULL;

	struct gve_device_option_gqi_qpl *dev_op_gqi_qpl = NULL;

	struct gve_device_option_dqo_rda *dev_op_dqo_rda = NULL;

	struct gve_device_descriptor *descriptor;

	u32 supported_features_mask = 0;

	union gve_adminq_command cmd;

	dma_addr_t descriptor_bus;

	int err = 0;
@@ -689,7 +729,8 @@ int gve_adminq_describe_device(struct gve_priv *priv) 
		goto free_device_descriptor;



	err = gve_process_device_options(priv, descriptor, &dev_op_gqi_rda,

					 &dev_op_gqi_qpl, &dev_op_dqo_rda);

					 &dev_op_gqi_qpl, &dev_op_dqo_rda,

					 &dev_op_jumbo_frames);

	if (err)

		goto free_device_descriptor;
@@ -704,12 +745,19 @@ int gve_adminq_describe_device(struct gve_priv *priv) 
		priv->queue_format = GVE_DQO_RDA_FORMAT;

		dev_info(&priv->pdev->dev,

			 "Driver is running with DQO RDA queue format.\n");

		supported_features_mask =

			be32_to_cpu(dev_op_dqo_rda->supported_features_mask);

	} else if (dev_op_gqi_rda) {

		priv->queue_format = GVE_GQI_RDA_FORMAT;

		dev_info(&priv->pdev->dev,

			 "Driver is running with GQI RDA queue format.\n");

		supported_features_mask =

			be32_to_cpu(dev_op_gqi_rda->supported_features_mask);

	} else {

		priv->queue_format = GVE_GQI_QPL_FORMAT;

		if (dev_op_gqi_qpl)

			supported_features_mask =

				be32_to_cpu(dev_op_gqi_qpl->supported_features_mask);

		dev_info(&priv->pdev->dev,

			 "Driver is running with GQI QPL queue format.\n");

	}
@@ -746,6 +794,9 @@ int gve_adminq_describe_device(struct gve_priv *priv) 
	}

	priv->default_num_queues = be16_to_cpu(descriptor->default_num_queues);



	gve_enable_supported_features(priv, supported_features_mask,

				      dev_op_jumbo_frames);



free_device_descriptor:

	dma_free_coherent(&priv->pdev->dev, PAGE_SIZE, descriptor,

			  descriptor_bus);

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

+14 −0
Original line number Diff line number Diff line
@@ -108,6 +108,14 @@ struct gve_device_option_dqo_rda { 


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



struct gve_device_option_jumbo_frames {

	__be32 supported_features_mask;

	__be16 max_mtu;

	u8 padding[2];

};



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



/* Terminology:

 *

 * RDA - Raw DMA Addressing - Buffers associated with SKBs are directly DMA
@@ -121,6 +129,7 @@ enum gve_dev_opt_id { 
	GVE_DEV_OPT_ID_GQI_RDA = 0x2,

	GVE_DEV_OPT_ID_GQI_QPL = 0x3,

	GVE_DEV_OPT_ID_DQO_RDA = 0x4,

	GVE_DEV_OPT_ID_JUMBO_FRAMES = 0x8,

};



enum gve_dev_opt_req_feat_mask {
@@ -128,6 +137,11 @@ enum gve_dev_opt_req_feat_mask { 
	GVE_DEV_OPT_REQ_FEAT_MASK_GQI_RDA = 0x0,

	GVE_DEV_OPT_REQ_FEAT_MASK_GQI_QPL = 0x0,

	GVE_DEV_OPT_REQ_FEAT_MASK_DQO_RDA = 0x0,

	GVE_DEV_OPT_REQ_FEAT_MASK_JUMBO_FRAMES = 0x0,

};



enum gve_sup_feature_mask {

	GVE_SUP_JUMBO_FRAMES_MASK = 1 << 2,

};



#define GVE_DEV_OPT_LEN_GQI_RAW_ADDRESSING 0x0

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

+7 −6
Original line number Diff line number Diff line
@@ -96,6 +96,7 @@ union gve_rx_data_slot { 
#define	GVE_RXF_TCP		GVE_RXFLG(6)	/* TCP Packet			*/

#define	GVE_RXF_UDP		GVE_RXFLG(7)	/* UDP Packet			*/

#define	GVE_RXF_ERR		GVE_RXFLG(8)	/* Packet Error Detected	*/

#define	GVE_RXF_PKT_CONT	GVE_RXFLG(10)	/* Multi Fragment RX packet	*/



/* GVE IRQ */

#define GVE_IRQ_ACK	BIT(31)

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

+4 −0
Original line number Diff line number Diff line
@@ -43,6 +43,7 @@ static const char gve_gstrings_main_stats[][ETH_GSTRING_LEN] = { 


static const char gve_gstrings_rx_stats[][ETH_GSTRING_LEN] = {

	"rx_posted_desc[%u]", "rx_completed_desc[%u]", "rx_bytes[%u]",

	"rx_cont_packet_cnt[%u]", "rx_frag_flip_cnt[%u]", "rx_frag_copy_cnt[%u]",

	"rx_dropped_pkt[%u]", "rx_copybreak_pkt[%u]", "rx_copied_pkt[%u]",

	"rx_queue_drop_cnt[%u]", "rx_no_buffers_posted[%u]",

	"rx_drops_packet_over_mru[%u]", "rx_drops_invalid_checksum[%u]",
@@ -265,6 +266,9 @@ gve_get_ethtool_stats(struct net_device *netdev, 
			} while (u64_stats_fetch_retry(&priv->rx[ring].statss,

						       start));

			data[i++] = tmp_rx_bytes;

			data[i++] = rx->rx_cont_packet_cnt;

			data[i++] = rx->rx_frag_flip_cnt;

			data[i++] = rx->rx_frag_copy_cnt;

			/* rx dropped packets */

			data[i++] = tmp_rx_skb_alloc_fail +

				tmp_rx_buf_alloc_fail +