Commit a057e8e4 authored by Paolo Abeni's avatar Paolo Abeni
Browse files

Merge branch 'gve-implement-xdp-hw-rx-timestamping-support-for-dq' 

Tim Hostetler says:

====================
gve: Implement XDP HW RX Timestamping support for DQ

From: Tim Hostetler <thostet@google.com>

This patch series adds support for bpf_xdp_metadata_rx_timestamp from an
XDP program loaded into the driver on its own or bound to an XSK. This
is only supported for DQ.
====================

Link: https://patch.msgid.link/20251114211146.292068-1-joshwash@google.com


Signed-off-by: default avatarPaolo Abeni <pabeni@redhat.com>
parents 19f1d6c7 1b42e07a

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

+7 −0
Original line number Diff line number Diff line
@@ -205,6 +205,13 @@ struct gve_rx_buf_state_dqo { 
	s16 next;

};



/* Wrapper for XDP Rx metadata */

struct gve_xdp_buff {

	struct xdp_buff xdp;

	struct gve_priv *gve;

	const struct gve_rx_compl_desc_dqo *compl_desc;

};



/* `head` and `tail` are indices into an array, or -1 if empty. */

struct gve_index_list {

	s16 head;

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

+1 −0
Original line number Diff line number Diff line
@@ -36,6 +36,7 @@ netdev_tx_t gve_tx_dqo(struct sk_buff *skb, struct net_device *dev); 
netdev_features_t gve_features_check_dqo(struct sk_buff *skb,

					 struct net_device *dev,

					 netdev_features_t features);

int gve_xdp_rx_timestamp(const struct xdp_md *_ctx, u64 *timestamp);

bool gve_tx_poll_dqo(struct gve_notify_block *block, bool do_clean);

bool gve_xdp_poll_dqo(struct gve_notify_block *block);

bool gve_xsk_tx_poll_dqo(struct gve_notify_block *block, int budget);

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

+7 −4
Original line number Diff line number Diff line
@@ -2188,10 +2188,6 @@ static int gve_set_ts_config(struct net_device *dev, 
		}



		kernel_config->rx_filter = HWTSTAMP_FILTER_ALL;

		gve_clock_nic_ts_read(priv);

		ptp_schedule_worker(priv->ptp->clock, 0);

	} else {

		ptp_cancel_worker_sync(priv->ptp->clock);

	}



	priv->ts_config.rx_filter = kernel_config->rx_filter;
@@ -2352,6 +2348,10 @@ static void gve_set_netdev_xdp_features(struct gve_priv *priv) 
	xdp_set_features_flag_locked(priv->dev, xdp_features);

}



static const struct xdp_metadata_ops gve_xdp_metadata_ops = {

	.xmo_rx_timestamp	= gve_xdp_rx_timestamp,

};



static int gve_init_priv(struct gve_priv *priv, bool skip_describe_device)

{

	int num_ntfy;
@@ -2447,6 +2447,9 @@ static int gve_init_priv(struct gve_priv *priv, bool skip_describe_device) 
	}



	gve_set_netdev_xdp_features(priv);

	if (!gve_is_gqi(priv))

		priv->dev->xdp_metadata_ops = &gve_xdp_metadata_ops;



	err = gve_setup_device_resources(priv);

	if (err)

		goto err_free_xsk_bitmap;

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

+12 −0
Original line number Diff line number Diff line
@@ -133,9 +133,21 @@ int gve_init_clock(struct gve_priv *priv) 
		err = -ENOMEM;

		goto release_ptp;

	}

	err = gve_clock_nic_ts_read(priv);

	if (err) {

		dev_err(&priv->pdev->dev, "failed to read NIC clock %d\n", err);

		goto release_nic_ts_report;

	}

	ptp_schedule_worker(priv->ptp->clock,

			    msecs_to_jiffies(GVE_NIC_TS_SYNC_INTERVAL_MS));



	return 0;



release_nic_ts_report:

	dma_free_coherent(&priv->pdev->dev,

			  sizeof(struct gve_nic_ts_report),

			  priv->nic_ts_report, priv->nic_ts_report_bus);

	priv->nic_ts_report = NULL;

release_ptp:

	gve_ptp_release(priv);

	return err;

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

+53 −20
Original line number Diff line number Diff line
@@ -240,6 +240,11 @@ int gve_rx_alloc_ring_dqo(struct gve_priv *priv, 
		rx->rx_headroom = 0;

	}



	/* struct gve_xdp_buff is overlaid on struct xdp_buff_xsk and utilizes

	 * the 24 byte field cb to store gve specific data.

	 */

	XSK_CHECK_PRIV_TYPE(struct gve_xdp_buff);



	rx->dqo.num_buf_states = cfg->raw_addressing ? buffer_queue_slots :

		gve_get_rx_pages_per_qpl_dqo(cfg->ring_size);

	rx->dqo.buf_states = kvcalloc_node(rx->dqo.num_buf_states,
@@ -456,20 +461,38 @@ static void gve_rx_skb_hash(struct sk_buff *skb, 
 * Note that this means if the time delta between packet reception and the last

 * clock read is greater than ~2 seconds, this will provide invalid results.

 */

static ktime_t gve_rx_get_hwtstamp(struct gve_priv *gve, u32 hwts)

{

	u64 last_read = READ_ONCE(gve->last_sync_nic_counter);

	u32 low = (u32)last_read;

	s32 diff = hwts - low;



	return ns_to_ktime(last_read + diff);

}



static void gve_rx_skb_hwtstamp(struct gve_rx_ring *rx,

				const struct gve_rx_compl_desc_dqo *desc)

{

	u64 last_read = READ_ONCE(rx->gve->last_sync_nic_counter);

	struct sk_buff *skb = rx->ctx.skb_head;

	u32 ts, low;

	s32 diff;



	if (desc->ts_sub_nsecs_low & GVE_DQO_RX_HWTSTAMP_VALID) {

		ts = le32_to_cpu(desc->ts);

		low = (u32)last_read;

		diff = ts - low;

		skb_hwtstamps(skb)->hwtstamp = ns_to_ktime(last_read + diff);

	if (desc->ts_sub_nsecs_low & GVE_DQO_RX_HWTSTAMP_VALID)

		skb_hwtstamps(skb)->hwtstamp =

			gve_rx_get_hwtstamp(rx->gve, le32_to_cpu(desc->ts));

}



int gve_xdp_rx_timestamp(const struct xdp_md *_ctx, u64 *timestamp)

{

	const struct gve_xdp_buff *ctx = (void *)_ctx;



	if (!ctx->gve->nic_ts_report)

		return -ENODATA;



	if (!(ctx->compl_desc->ts_sub_nsecs_low & GVE_DQO_RX_HWTSTAMP_VALID))

		return -ENODATA;



	*timestamp = gve_rx_get_hwtstamp(ctx->gve,

					 le32_to_cpu(ctx->compl_desc->ts));

	return 0;

}



static void gve_rx_free_skb(struct napi_struct *napi, struct gve_rx_ring *rx)
@@ -683,16 +706,23 @@ static void gve_xdp_done_dqo(struct gve_priv *priv, struct gve_rx_ring *rx, 
}



static int gve_rx_xsk_dqo(struct napi_struct *napi, struct gve_rx_ring *rx,

			  struct gve_rx_buf_state_dqo *buf_state, int buf_len,

			  const struct gve_rx_compl_desc_dqo *compl_desc,

			  struct gve_rx_buf_state_dqo *buf_state,

			  struct bpf_prog *xprog)

{

	struct xdp_buff *xdp = buf_state->xsk_buff;

	int buf_len = compl_desc->packet_len;

	struct gve_priv *priv = rx->gve;

	struct gve_xdp_buff *gve_xdp;

	int xdp_act;



	xdp->data_end = xdp->data + buf_len;

	xsk_buff_dma_sync_for_cpu(xdp);



	gve_xdp = (void *)xdp;

	gve_xdp->gve = priv;

	gve_xdp->compl_desc = compl_desc;



	if (xprog) {

		xdp_act = bpf_prog_run_xdp(xprog, xdp);

		buf_len = xdp->data_end - xdp->data;
@@ -782,7 +812,7 @@ static int gve_rx_dqo(struct napi_struct *napi, struct gve_rx_ring *rx, 


	xprog = READ_ONCE(priv->xdp_prog);

	if (buf_state->xsk_buff)

		return gve_rx_xsk_dqo(napi, rx, buf_state, buf_len, xprog);

		return gve_rx_xsk_dqo(napi, rx, compl_desc, buf_state, xprog);



	/* Page might have not been used for awhile and was likely last written

	 * by a different thread.
@@ -840,23 +870,26 @@ static int gve_rx_dqo(struct napi_struct *napi, struct gve_rx_ring *rx, 
	}



	if (xprog) {

		struct xdp_buff xdp;

		struct gve_xdp_buff gve_xdp;

		void *old_data;

		int xdp_act;



		xdp_init_buff(&xdp, buf_state->page_info.buf_size,

		xdp_init_buff(&gve_xdp.xdp, buf_state->page_info.buf_size,

			      &rx->xdp_rxq);

		xdp_prepare_buff(&xdp,

		xdp_prepare_buff(&gve_xdp.xdp,

				 buf_state->page_info.page_address +

				 buf_state->page_info.page_offset,

				 buf_state->page_info.pad,

				 buf_len, false);

		old_data = xdp.data;

		xdp_act = bpf_prog_run_xdp(xprog, &xdp);

		buf_state->page_info.pad += xdp.data - old_data;

		buf_len = xdp.data_end - xdp.data;

		gve_xdp.gve = priv;

		gve_xdp.compl_desc = compl_desc;



		old_data = gve_xdp.xdp.data;

		xdp_act = bpf_prog_run_xdp(xprog, &gve_xdp.xdp);

		buf_state->page_info.pad += gve_xdp.xdp.data - old_data;

		buf_len = gve_xdp.xdp.data_end - gve_xdp.xdp.data;

		if (xdp_act != XDP_PASS) {

			gve_xdp_done_dqo(priv, rx, &xdp, xprog, xdp_act,

			gve_xdp_done_dqo(priv, rx, &gve_xdp.xdp, xprog, xdp_act,

					 buf_state);

			return 0;

		}