virtio-net: support rx netdim

	tristate "Virtio network driver"

	depends on VIRTIO

	select NET_FAILOVER

	select DIMLIB

	help

	  This is the virtual network driver for virtio.  It can be used with

	  QEMU based VMMs (like KVM or Xen).  Say Y or M.

#include <linux/average.h>

#include <linux/filter.h>

#include <linux/kernel.h>

#include <linux/dim.h>

#include <net/route.h>

#include <net/xdp.h>

#include <net/net_failover.h>

	struct virtnet_rq_stats stats;

	/* The number of rx notifications */

	u16 calls;

	/* Is dynamic interrupt moderation enabled? */

	bool dim_enabled;

	/* Dynamic Interrupt Moderation */

	struct dim dim;

	u32 packets_in_napi;

	struct virtnet_interrupt_coalesce intr_coal;

	/* Chain pages by the private ptr. */

	u8 duplex;

	u32 speed;

	/* Is rx dynamic interrupt moderation enabled? */

	bool rx_dim_enabled;

	/* Interrupt coalescing settings */

	struct virtnet_interrupt_coalesce intr_coal_tx;

	struct virtnet_interrupt_coalesce intr_coal_rx;

	struct virtnet_info *vi = rvq->vdev->priv;

	struct receive_queue *rq = &vi->rq[vq2rxq(rvq)];

	rq->calls++;

	virtqueue_napi_schedule(&rq->napi, rvq);

}

	}

}

static void virtnet_rx_dim_update(struct virtnet_info *vi, struct receive_queue *rq)

{

	struct dim_sample cur_sample = {};

	if (!rq->packets_in_napi)

		return;

	u64_stats_update_begin(&rq->stats.syncp);

	dim_update_sample(rq->calls,

			  u64_stats_read(&rq->stats.packets),

			  u64_stats_read(&rq->stats.bytes),

			  &cur_sample);

	u64_stats_update_end(&rq->stats.syncp);

	net_dim(&rq->dim, cur_sample);

	rq->packets_in_napi = 0;

}

static int virtnet_poll(struct napi_struct *napi, int budget)

{

	struct receive_queue *rq =

	struct send_queue *sq;

	unsigned int received;

	unsigned int xdp_xmit = 0;

	bool napi_complete;

	virtnet_poll_cleantx(rq);

	received = virtnet_receive(rq, budget, &xdp_xmit);

	rq->packets_in_napi += received;

	if (xdp_xmit & VIRTIO_XDP_REDIR)

		xdp_do_flush();

	/* Out of packets? */

	if (received < budget)

		virtqueue_napi_complete(napi, rq->vq, received);

	if (received < budget) {

		napi_complete = virtqueue_napi_complete(napi, rq->vq, received);

		if (napi_complete && rq->dim_enabled)

			virtnet_rx_dim_update(vi, rq);

	}

	if (xdp_xmit & VIRTIO_XDP_TX) {

		sq = virtnet_xdp_get_sq(vi);

	disable_delayed_refill(vi);

	cancel_delayed_work_sync(&vi->refill);

	for (i--; i >= 0; i--)

	for (i--; i >= 0; i--) {

		virtnet_disable_queue_pair(vi, i);

		cancel_work_sync(&vi->rq[i].dim.work);

	}

	return err;

}

	qindex = rq - vi->rq;

	if (running)

	if (running) {

		napi_disable(&rq->napi);

		cancel_work_sync(&rq->dim.work);

	}

	err = virtqueue_resize(rq->vq, ring_num, virtnet_rq_free_unused_buf);

	if (err)

	/* Make sure refill_work doesn't re-enable napi! */

	cancel_delayed_work_sync(&vi->refill);

	for (i = 0; i < vi->max_queue_pairs; i++)

	for (i = 0; i < vi->max_queue_pairs; i++) {

		virtnet_disable_queue_pair(vi, i);

		cancel_work_sync(&vi->rq[i].dim.work);

	}

	return 0;

}

	ring->tx_pending = virtqueue_get_vring_size(vi->sq[0].vq);

}

static int virtnet_send_ctrl_coal_vq_cmd(struct virtnet_info *vi,

					 u16 vqn, u32 max_usecs, u32 max_packets);

static int virtnet_set_ringparam(struct net_device *dev,

				 struct ethtool_ringparam *ring,

				 struct kernel_ethtool_ringparam *kernel_ring,

				  &sgs_tx))

		return -EINVAL;

	/* Save parameters */

	vi->intr_coal_tx.max_usecs = ec->tx_coalesce_usecs;

	vi->intr_coal_tx.max_packets = ec->tx_max_coalesced_frames;

	for (i = 0; i < vi->max_queue_pairs; i++) {

static int virtnet_send_rx_notf_coal_cmds(struct virtnet_info *vi,

					  struct ethtool_coalesce *ec)

{

	bool rx_ctrl_dim_on = !!ec->use_adaptive_rx_coalesce;

	struct scatterlist sgs_rx;

	int i;

	if (rx_ctrl_dim_on && !virtio_has_feature(vi->vdev, VIRTIO_NET_F_VQ_NOTF_COAL))

		return -EOPNOTSUPP;

	if (rx_ctrl_dim_on && (ec->rx_coalesce_usecs != vi->intr_coal_rx.max_usecs ||

			       ec->rx_max_coalesced_frames != vi->intr_coal_rx.max_packets))

		return -EINVAL;

	if (rx_ctrl_dim_on && !vi->rx_dim_enabled) {

		vi->rx_dim_enabled = true;

		for (i = 0; i < vi->max_queue_pairs; i++)

			vi->rq[i].dim_enabled = true;

		return 0;

	}

	if (!rx_ctrl_dim_on && vi->rx_dim_enabled) {

		vi->rx_dim_enabled = false;

		for (i = 0; i < vi->max_queue_pairs; i++)

			vi->rq[i].dim_enabled = false;

	}

	/* Since the per-queue coalescing params can be set,

	 * we need apply the global new params even if they

	 * are not updated.

	 */

	vi->ctrl->coal_rx.rx_usecs = cpu_to_le32(ec->rx_coalesce_usecs);

	vi->ctrl->coal_rx.rx_max_packets = cpu_to_le32(ec->rx_max_coalesced_frames);

	sg_init_one(&sgs_rx, &vi->ctrl->coal_rx, sizeof(vi->ctrl->coal_rx));

				  &sgs_rx))

		return -EINVAL;

	/* Save parameters */

	vi->intr_coal_rx.max_usecs = ec->rx_coalesce_usecs;

	vi->intr_coal_rx.max_packets = ec->rx_max_coalesced_frames;

	for (i = 0; i < vi->max_queue_pairs; i++) {

	return 0;

}

static int virtnet_send_notf_coal_vq_cmds(struct virtnet_info *vi,

static int virtnet_send_rx_notf_coal_vq_cmds(struct virtnet_info *vi,

					     struct ethtool_coalesce *ec,

					     u16 queue)

{

	bool rx_ctrl_dim_on = !!ec->use_adaptive_rx_coalesce;

	bool cur_rx_dim = vi->rq[queue].dim_enabled;

	u32 max_usecs, max_packets;

	int err;

	max_usecs = vi->rq[queue].intr_coal.max_usecs;

	max_packets = vi->rq[queue].intr_coal.max_packets;

	if (rx_ctrl_dim_on && (ec->rx_coalesce_usecs != max_usecs ||

			       ec->rx_max_coalesced_frames != max_packets))

		return -EINVAL;

	if (rx_ctrl_dim_on && !cur_rx_dim) {

		vi->rq[queue].dim_enabled = true;

		return 0;

	}

	if (!rx_ctrl_dim_on && cur_rx_dim)

		vi->rq[queue].dim_enabled = false;

	/* If no params are updated, userspace ethtool will

	 * reject the modification.

	 */

	err = virtnet_send_rx_ctrl_coal_vq_cmd(vi, queue,

					       ec->rx_coalesce_usecs,

					       ec->rx_max_coalesced_frames);

	if (err)

		return err;

	return 0;

}

static int virtnet_send_notf_coal_vq_cmds(struct virtnet_info *vi,

					  struct ethtool_coalesce *ec,

					  u16 queue)

{

	int err;

	err = virtnet_send_rx_notf_coal_vq_cmds(vi, ec, queue);

	if (err)

		return err;

	err = virtnet_send_tx_ctrl_coal_vq_cmd(vi, queue,

					       ec->tx_coalesce_usecs,

					       ec->tx_max_coalesced_frames);

	return 0;

}

static void virtnet_rx_dim_work(struct work_struct *work)

{

	struct dim *dim = container_of(work, struct dim, work);

	struct receive_queue *rq = container_of(dim,

			struct receive_queue, dim);

	struct virtnet_info *vi = rq->vq->vdev->priv;

	struct net_device *dev = vi->dev;

	struct dim_cq_moder update_moder;

	int i, qnum, err;

	if (!rtnl_trylock())

		return;

	/* Each rxq's work is queued by "net_dim()->schedule_work()"

	 * in response to NAPI traffic changes. Note that dim->profile_ix

	 * for each rxq is updated prior to the queuing action.

	 * So we only need to traverse and update profiles for all rxqs

	 * in the work which is holding rtnl_lock.

	 */

	for (i = 0; i < vi->curr_queue_pairs; i++) {

		rq = &vi->rq[i];

		dim = &rq->dim;

		qnum = rq - vi->rq;

		if (!rq->dim_enabled)

			continue;

		update_moder = net_dim_get_rx_moderation(dim->mode, dim->profile_ix);

		if (update_moder.usec != rq->intr_coal.max_usecs ||

		    update_moder.pkts != rq->intr_coal.max_packets) {

			err = virtnet_send_rx_ctrl_coal_vq_cmd(vi, qnum,

							       update_moder.usec,

							       update_moder.pkts);

			if (err)

				pr_debug("%s: Failed to send dim parameters on rxq%d\n",

					 dev->name, qnum);

			dim->state = DIM_START_MEASURE;

		}

	}

	rtnl_unlock();

}

static int virtnet_coal_params_supported(struct ethtool_coalesce *ec)

{

	/* usecs coalescing is supported only if VIRTIO_NET_F_NOTF_COAL

		ec->tx_coalesce_usecs = vi->intr_coal_tx.max_usecs;

		ec->tx_max_coalesced_frames = vi->intr_coal_tx.max_packets;

		ec->rx_max_coalesced_frames = vi->intr_coal_rx.max_packets;

		ec->use_adaptive_rx_coalesce = vi->rx_dim_enabled;

	} else {

		ec->rx_max_coalesced_frames = 1;

		ec->tx_coalesce_usecs = vi->sq[queue].intr_coal.max_usecs;

		ec->tx_max_coalesced_frames = vi->sq[queue].intr_coal.max_packets;

		ec->rx_max_coalesced_frames = vi->rq[queue].intr_coal.max_packets;

		ec->use_adaptive_rx_coalesce = vi->rq[queue].dim_enabled;

	} else {

		ec->rx_max_coalesced_frames = 1;

static const struct ethtool_ops virtnet_ethtool_ops = {

	.supported_coalesce_params = ETHTOOL_COALESCE_MAX_FRAMES |

		ETHTOOL_COALESCE_USECS,

		ETHTOOL_COALESCE_USECS | ETHTOOL_COALESCE_USE_ADAPTIVE_RX,

	.get_drvinfo = virtnet_get_drvinfo,

	.get_link = ethtool_op_get_link,

	.get_ringparam = virtnet_get_ringparam,

					 virtnet_poll_tx,

					 napi_tx ? napi_weight : 0);

		INIT_WORK(&vi->rq[i].dim.work, virtnet_rx_dim_work);

		vi->rq[i].dim.mode = DIM_CQ_PERIOD_MODE_START_FROM_EQE;

		sg_init_table(vi->rq[i].sg, ARRAY_SIZE(vi->rq[i].sg));

		ewma_pkt_len_init(&vi->rq[i].mrg_avg_pkt_len);

		sg_init_table(vi->sq[i].sg, ARRAY_SIZE(vi->sq[i].sg));