Skip to content
Permalink
Browse files
drivers/net/virtio_net: Added basic RSS support. 
Added features for RSS and RSS hash report.
Added initialization, RXHASH feature and ethtool ops.
By default RSS/RXHASH is disabled.
Added ethtools ops to set key and indirection table.

Signed-off-by: Andrew Melnychenko <andrew@daynix.com>
  • Loading branch information
@AndrewAtDaynix @intel-lab-lkp
AndrewAtDaynix authored and intel-lab-lkp committed Aug 18, 2021
1 parent 665e321 commit e731fc592ef2151e3a1fe044fa182517adb1e47e
Showing 1 changed file with 203 additions and 12 deletions.
215 drivers/net/virtio_net.c
View file
@@ -167,6 +167,23 @@ struct receive_queue {
struct xdp_rxq_info xdp_rxq;
};

/* This structure can contain rss message with maximum settings for indirection table and keysize */
#define VIRTIO_NET_RSS_MAX_KEY_SIZE 40
#define VIRTIO_NET_RSS_MAX_TABLE_LEN 128
struct virtio_net_ctrl_rss {
struct {
__le32 hash_types;
__le16 indirection_table_mask;
__le16 unclassified_queue;
} __packed table_info;
u16 indirection_table[VIRTIO_NET_RSS_MAX_TABLE_LEN];
struct {
u16 max_tx_vq; /* queues */
u8 hash_key_length;
} __packed key_info;
u8 key[VIRTIO_NET_RSS_MAX_KEY_SIZE];
};

/* Control VQ buffers: protected by the rtnl lock */
struct control_buf {
struct virtio_net_ctrl_hdr hdr;
@@ -176,6 +193,7 @@ struct control_buf {
u8 allmulti;
__virtio16 vid;
__virtio64 offloads;
struct virtio_net_ctrl_rss rss;
};

struct virtnet_info {
@@ -204,6 +222,14 @@ struct virtnet_info {
/* Host will merge rx buffers for big packets (shake it! shake it!) */
bool mergeable_rx_bufs;

/* Host supports rss and/or hash report */
bool has_rss;
bool has_rss_hash_report;
u8 rss_key_size;
u16 rss_indir_table_size;
u32 rss_hash_types_supported;
u32 rss_hash_types_saved;

/* Has control virtqueue */
bool has_cvq;

@@ -393,7 +419,9 @@ static struct sk_buff *page_to_skb(struct virtnet_info *vi,
hdr_p = p;

hdr_len = vi->hdr_len;
if (vi->mergeable_rx_bufs)
if (vi->has_rss_hash_report)
hdr_padded_len = sizeof(struct virtio_net_hdr_v1_hash);
else if (vi->mergeable_rx_bufs)
hdr_padded_len = sizeof(*hdr);
else
hdr_padded_len = sizeof(struct padded_vnet_hdr);
@@ -2171,6 +2199,56 @@ static void virtnet_get_ringparam(struct net_device *dev,
ring->tx_pending = ring->tx_max_pending;
}

static bool virtnet_commit_rss_command(struct virtnet_info *vi)
{
struct net_device *dev = vi->dev;
struct scatterlist sgs[4];
unsigned int sg_buf_size;

/* prepare sgs */
sg_init_table(sgs, 4);

sg_buf_size = sizeof(vi->ctrl->rss.table_info);
sg_set_buf(&sgs[0], &vi->ctrl->rss.table_info, sg_buf_size);

sg_buf_size = sizeof(uint16_t) * vi->rss_indir_table_size;
sg_set_buf(&sgs[1], vi->ctrl->rss.indirection_table, sg_buf_size);

sg_buf_size = sizeof(vi->ctrl->rss.key_info);
sg_set_buf(&sgs[2], &vi->ctrl->rss.key_info, sg_buf_size);

sg_buf_size = vi->rss_key_size;
sg_set_buf(&sgs[3], vi->ctrl->rss.key, sg_buf_size);

if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_MQ,
vi->has_rss ? VIRTIO_NET_CTRL_MQ_RSS_CONFIG
: VIRTIO_NET_CTRL_MQ_HASH_CONFIG, sgs)) {
dev_warn(&dev->dev, "VIRTIONET issue with committing RSS sgs\n");
return false;
}
return true;
}

static void virtnet_init_default_rss(struct virtnet_info *vi)
{
u32 indir_val = 0;
int i = 0;

vi->ctrl->rss.table_info.hash_types = vi->rss_hash_types_supported;
vi->rss_hash_types_saved = vi->rss_hash_types_supported;
vi->ctrl->rss.table_info.indirection_table_mask = vi->rss_indir_table_size - 1;
vi->ctrl->rss.table_info.unclassified_queue = 0;

for (; i < vi->rss_indir_table_size; ++i) {
indir_val = ethtool_rxfh_indir_default(i, vi->max_queue_pairs);
vi->ctrl->rss.indirection_table[i] = indir_val;
}

vi->ctrl->rss.key_info.max_tx_vq = vi->curr_queue_pairs;
vi->ctrl->rss.key_info.hash_key_length = vi->rss_key_size;

netdev_rss_key_fill(vi->ctrl->rss.key, vi->rss_key_size);
}

static void virtnet_get_drvinfo(struct net_device *dev,
struct ethtool_drvinfo *info)
@@ -2395,6 +2473,72 @@ static void virtnet_update_settings(struct virtnet_info *vi)
vi->duplex = duplex;
}

u32 virtnet_get_rxfh_key_size(struct net_device *dev)
{
return ((struct virtnet_info *)netdev_priv(dev))->rss_key_size;
}

u32 virtnet_get_rxfh_indir_size(struct net_device *dev)
{
return ((struct virtnet_info *)netdev_priv(dev))->rss_indir_table_size;
}

int virtnet_get_rxfh(struct net_device *dev, u32 *indir, u8 *key, u8 *hfunc)
{
struct virtnet_info *vi = netdev_priv(dev);
int i;

if (indir) {
for (i = 0; i < vi->rss_indir_table_size; ++i)
indir[i] = vi->ctrl->rss.indirection_table[i];
}

if (key)
memcpy(key, vi->ctrl->rss.key, vi->rss_key_size);

if (hfunc)
*hfunc = ETH_RSS_HASH_TOP;

return 0;
}

int virtnet_set_rxfh(struct net_device *dev, const u32 *indir, const u8 *key, const u8 hfunc)
{
struct virtnet_info *vi = netdev_priv(dev);
int i;

if (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP)
return -EOPNOTSUPP;

if (indir) {
for (i = 0; i < vi->rss_indir_table_size; ++i)
vi->ctrl->rss.indirection_table[i] = indir[i];
}
if (key)
memcpy(vi->ctrl->rss.key, key, vi->rss_key_size);

virtnet_commit_rss_command(vi);

return 0;
}

int virtnet_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *info, u32 *rule_locs)
{
struct virtnet_info *vi = netdev_priv(dev);
int rc = 0;

switch (info->cmd) {
case ETHTOOL_GRXRINGS:
info->data = vi->curr_queue_pairs;
rc = -EOPNOTSUPP;
}
default:
rc = -EOPNOTSUPP;
}

return rc;
}

static const struct ethtool_ops virtnet_ethtool_ops = {
.supported_coalesce_params = ETHTOOL_COALESCE_MAX_FRAMES,
.get_drvinfo = virtnet_get_drvinfo,
@@ -2410,6 +2554,11 @@ static const struct ethtool_ops virtnet_ethtool_ops = {
.set_link_ksettings = virtnet_set_link_ksettings,
.set_coalesce = virtnet_set_coalesce,
.get_coalesce = virtnet_get_coalesce,
.get_rxfh_key_size = virtnet_get_rxfh_key_size,
.get_rxfh_indir_size = virtnet_get_rxfh_indir_size,
.get_rxfh = virtnet_get_rxfh,
.set_rxfh = virtnet_set_rxfh,
.get_rxnfc = virtnet_get_rxnfc,
};

static void virtnet_freeze_down(struct virtio_device *vdev)
@@ -2662,6 +2811,16 @@ static int virtnet_set_features(struct net_device *dev,
vi->guest_offloads = offloads;
}

if ((dev->features ^ features) & NETIF_F_RXHASH) {
if (features & NETIF_F_RXHASH)
vi->ctrl->rss.table_info.hash_types = vi->rss_hash_types_saved;
else
vi->ctrl->rss.table_info.hash_types = 0;

if (!virtnet_commit_rss_command(vi))
return -EINVAL;
}

return 0;
}

@@ -3080,13 +3239,14 @@ static int virtnet_probe(struct virtio_device *vdev)
u16 max_queue_pairs;
int mtu;

/* Find if host supports multiqueue virtio_net device */
err = virtio_cread_feature(vdev, VIRTIO_NET_F_MQ,
struct virtio_net_config,
max_virtqueue_pairs, &max_queue_pairs);
/* Find if host supports multiqueue/rss virtio_net device */
max_queue_pairs = 0;
if (virtio_has_feature(vdev, VIRTIO_NET_F_MQ) || virtio_has_feature(vdev, VIRTIO_NET_F_RSS))
max_queue_pairs =
virtio_cread16(vdev, offsetof(struct virtio_net_config, max_virtqueue_pairs));

/* We need at least 2 queue's */
if (err || max_queue_pairs < VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MIN ||
if (max_queue_pairs < VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MIN ||
max_queue_pairs > VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX ||
!virtio_has_feature(vdev, VIRTIO_NET_F_CTRL_VQ))
max_queue_pairs = 1;
@@ -3160,6 +3320,9 @@ static int virtnet_probe(struct virtio_device *vdev)

INIT_WORK(&vi->config_work, virtnet_config_changed_work);

if (virtio_has_feature(vdev, VIRTIO_NET_F_CTRL_VQ))
vi->has_cvq = true;

/* If we can receive ANY GSO packets, we must allocate large ones. */
if (virtio_has_feature(vdev, VIRTIO_NET_F_GUEST_TSO4) ||
virtio_has_feature(vdev, VIRTIO_NET_F_GUEST_TSO6) ||
@@ -3170,8 +3333,32 @@ static int virtnet_probe(struct virtio_device *vdev)
if (virtio_has_feature(vdev, VIRTIO_NET_F_MRG_RXBUF))
vi->mergeable_rx_bufs = true;

if (virtio_has_feature(vdev, VIRTIO_NET_F_MRG_RXBUF) ||
virtio_has_feature(vdev, VIRTIO_F_VERSION_1))
if (vi->has_cvq && virtio_has_feature(vdev, VIRTIO_NET_F_HASH_REPORT)) {
vi->has_rss_hash_report = true;
vi->rss_indir_table_size = 1;
vi->rss_key_size = VIRTIO_NET_RSS_MAX_KEY_SIZE;
}

if (vi->has_cvq && virtio_has_feature(vdev, VIRTIO_NET_F_RSS)) {
vi->has_rss = true;
vi->rss_indir_table_size =
virtio_cread16(vdev, offsetof(struct virtio_net_config,
rss_max_indirection_table_length));
vi->rss_key_size =
virtio_cread8(vdev, offsetof(struct virtio_net_config, rss_max_key_size));
}

if (vi->has_rss || vi->has_rss_hash_report) {
vi->rss_hash_types_supported =
virtio_cread32(vdev, offsetof(struct virtio_net_config, supported_hash_types));

dev->hw_features |= NETIF_F_RXHASH;
}

if (vi->has_cvq && vi->has_rss_hash_report)
vi->hdr_len = sizeof(struct virtio_net_hdr_v1_hash);
else if (virtio_has_feature(vdev, VIRTIO_NET_F_MRG_RXBUF) ||
virtio_has_feature(vdev, VIRTIO_F_VERSION_1))
vi->hdr_len = sizeof(struct virtio_net_hdr_mrg_rxbuf);
else
vi->hdr_len = sizeof(struct virtio_net_hdr);
@@ -3180,9 +3367,6 @@ static int virtnet_probe(struct virtio_device *vdev)
virtio_has_feature(vdev, VIRTIO_F_VERSION_1))
vi->any_header_sg = true;

if (virtio_has_feature(vdev, VIRTIO_NET_F_CTRL_VQ))
vi->has_cvq = true;

if (virtio_has_feature(vdev, VIRTIO_NET_F_MTU)) {
mtu = virtio_cread16(vdev,
offsetof(struct virtio_net_config,
@@ -3254,6 +3438,12 @@ static int virtnet_probe(struct virtio_device *vdev)

virtnet_set_queues(vi, vi->curr_queue_pairs);

if (vi->has_rss || vi->has_rss_hash_report) {
rtnl_lock();
virtnet_init_default_rss(vi);
rtnl_unlock();
}

/* Assume link up if device can't report link status,
otherwise get link status from config. */
netif_carrier_off(dev);
@@ -3369,7 +3559,8 @@ static struct virtio_device_id id_table[] = {
VIRTIO_NET_F_GUEST_ANNOUNCE, VIRTIO_NET_F_MQ, \
VIRTIO_NET_F_CTRL_MAC_ADDR, \
VIRTIO_NET_F_MTU, VIRTIO_NET_F_CTRL_GUEST_OFFLOADS, \
VIRTIO_NET_F_SPEED_DUPLEX, VIRTIO_NET_F_STANDBY
VIRTIO_NET_F_SPEED_DUPLEX, VIRTIO_NET_F_STANDBY, \
VIRTIO_NET_F_RSS, VIRTIO_NET_F_HASH_REPORT

static unsigned int features[] = {
VIRTNET_FEATURES,

0 comments on commit e731fc5

Please sign in to comment.