Skip to content

Commit

Permalink
virtio_net: Remove command data from control_buf
Browse files Browse the repository at this point in the history 
Allocate memory for the data when it's used. Ideally the struct could
be on the stack, but we can't DMA stack memory. With this change only
the header and status memory are shared between commands, which will
allow using a tighter lock than RTNL.

Signed-off-by: Daniel Jurgens <danielj@nvidia.com>
Reviewed-by: Jiri Pirko <jiri@nvidia.com>
Reviewed-by: Heng Qi <hengqi@linux.alibaba.com>
Tested-by: Heng Qi <hengqi@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
Signed-off-by: Paolo Abeni <pabeni@redhat.com>
  • Loading branch information
Daniel Jurgens authored and Paolo Abeni committed May 7, 2024
1 parent fce2903 commit ff7c7d9
Showing 1 changed file with 85 additions and 39 deletions.
124 changes: 85 additions & 39 deletions drivers/net/virtio_net.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -368,15 +368,6 @@ struct virtio_net_ctrl_rss {
struct control_buf {
struct virtio_net_ctrl_hdr hdr;
virtio_net_ctrl_ack status;
struct virtio_net_ctrl_mq mq;
u8 promisc;
u8 allmulti;
__virtio16 vid;
__virtio64 offloads;
struct virtio_net_ctrl_coal_tx coal_tx;
struct virtio_net_ctrl_coal_rx coal_rx;
struct virtio_net_ctrl_coal_vq coal_vq;
struct virtio_net_stats_capabilities stats_cap;
};

struct virtnet_info {
Expand Down Expand Up @@ -2828,14 +2819,19 @@ static void virtnet_ack_link_announce(struct virtnet_info *vi)

static int _virtnet_set_queues(struct virtnet_info *vi, u16 queue_pairs)
{
struct virtio_net_ctrl_mq *mq __free(kfree) = NULL;
struct scatterlist sg;
struct net_device *dev = vi->dev;

if (!vi->has_cvq || !virtio_has_feature(vi->vdev, VIRTIO_NET_F_MQ))
return 0;

vi->ctrl->mq.virtqueue_pairs = cpu_to_virtio16(vi->vdev, queue_pairs);
sg_init_one(&sg, &vi->ctrl->mq, sizeof(vi->ctrl->mq));
mq = kzalloc(sizeof(*mq), GFP_KERNEL);
if (!mq)
return -ENOMEM;

mq->virtqueue_pairs = cpu_to_virtio16(vi->vdev, queue_pairs);
sg_init_one(&sg, mq, sizeof(*mq));

if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_MQ,
VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET, &sg)) {
Expand Down Expand Up @@ -2864,6 +2860,7 @@ static int virtnet_set_queues(struct virtnet_info *vi, u16 queue_pairs)

static int virtnet_close(struct net_device *dev)
{
u8 *promisc_allmulti __free(kfree) = NULL;
struct virtnet_info *vi = netdev_priv(dev);
int i;

Expand All @@ -2888,6 +2885,7 @@ static void virtnet_rx_mode_work(struct work_struct *work)
struct scatterlist sg[2];
struct virtio_net_ctrl_mac *mac_data;
struct netdev_hw_addr *ha;
u8 *promisc_allmulti;
int uc_count;
int mc_count;
void *buf;
Expand All @@ -2899,22 +2897,27 @@ static void virtnet_rx_mode_work(struct work_struct *work)

rtnl_lock();

vi->ctrl->promisc = ((dev->flags & IFF_PROMISC) != 0);
vi->ctrl->allmulti = ((dev->flags & IFF_ALLMULTI) != 0);
promisc_allmulti = kzalloc(sizeof(*promisc_allmulti), GFP_ATOMIC);
if (!promisc_allmulti) {
dev_warn(&dev->dev, "Failed to set RX mode, no memory.\n");
return;
}

sg_init_one(sg, &vi->ctrl->promisc, sizeof(vi->ctrl->promisc));
*promisc_allmulti = !!(dev->flags & IFF_PROMISC);
sg_init_one(sg, promisc_allmulti, sizeof(*promisc_allmulti));

if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_RX,
VIRTIO_NET_CTRL_RX_PROMISC, sg))
dev_warn(&dev->dev, "Failed to %sable promisc mode.\n",
vi->ctrl->promisc ? "en" : "dis");
*promisc_allmulti ? "en" : "dis");

sg_init_one(sg, &vi->ctrl->allmulti, sizeof(vi->ctrl->allmulti));
*promisc_allmulti = !!(dev->flags & IFF_ALLMULTI);
sg_init_one(sg, promisc_allmulti, sizeof(*promisc_allmulti));

if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_RX,
VIRTIO_NET_CTRL_RX_ALLMULTI, sg))
dev_warn(&dev->dev, "Failed to %sable allmulti mode.\n",
vi->ctrl->allmulti ? "en" : "dis");
*promisc_allmulti ? "en" : "dis");

netif_addr_lock_bh(dev);

Expand Down Expand Up @@ -2975,10 +2978,15 @@ static int virtnet_vlan_rx_add_vid(struct net_device *dev,
__be16 proto, u16 vid)
{
struct virtnet_info *vi = netdev_priv(dev);
__virtio16 *_vid __free(kfree) = NULL;
struct scatterlist sg;

vi->ctrl->vid = cpu_to_virtio16(vi->vdev, vid);
sg_init_one(&sg, &vi->ctrl->vid, sizeof(vi->ctrl->vid));
_vid = kzalloc(sizeof(*_vid), GFP_KERNEL);
if (!_vid)
return -ENOMEM;

*_vid = cpu_to_virtio16(vi->vdev, vid);
sg_init_one(&sg, _vid, sizeof(*_vid));

if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_VLAN,
VIRTIO_NET_CTRL_VLAN_ADD, &sg))
Expand All @@ -2990,10 +2998,15 @@ static int virtnet_vlan_rx_kill_vid(struct net_device *dev,
__be16 proto, u16 vid)
{
struct virtnet_info *vi = netdev_priv(dev);
__virtio16 *_vid __free(kfree) = NULL;
struct scatterlist sg;

vi->ctrl->vid = cpu_to_virtio16(vi->vdev, vid);
sg_init_one(&sg, &vi->ctrl->vid, sizeof(vi->ctrl->vid));
_vid = kzalloc(sizeof(*_vid), GFP_KERNEL);
if (!_vid)
return -ENOMEM;

*_vid = cpu_to_virtio16(vi->vdev, vid);
sg_init_one(&sg, _vid, sizeof(*_vid));

if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_VLAN,
VIRTIO_NET_CTRL_VLAN_DEL, &sg))
Expand Down Expand Up @@ -3106,12 +3119,17 @@ static void virtnet_cpu_notif_remove(struct virtnet_info *vi)
static int virtnet_send_ctrl_coal_vq_cmd(struct virtnet_info *vi,
u16 vqn, u32 max_usecs, u32 max_packets)
{
struct virtio_net_ctrl_coal_vq *coal_vq __free(kfree) = NULL;
struct scatterlist sgs;

vi->ctrl->coal_vq.vqn = cpu_to_le16(vqn);
vi->ctrl->coal_vq.coal.max_usecs = cpu_to_le32(max_usecs);
vi->ctrl->coal_vq.coal.max_packets = cpu_to_le32(max_packets);
sg_init_one(&sgs, &vi->ctrl->coal_vq, sizeof(vi->ctrl->coal_vq));
coal_vq = kzalloc(sizeof(*coal_vq), GFP_KERNEL);
if (!coal_vq)
return -ENOMEM;

coal_vq->vqn = cpu_to_le16(vqn);
coal_vq->coal.max_usecs = cpu_to_le32(max_usecs);
coal_vq->coal.max_packets = cpu_to_le32(max_packets);
sg_init_one(&sgs, coal_vq, sizeof(*coal_vq));

if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_NOTF_COAL,
VIRTIO_NET_CTRL_NOTF_COAL_VQ_SET,
Expand Down Expand Up @@ -3257,11 +3275,15 @@ static bool virtnet_commit_rss_command(struct virtnet_info *vi)

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;
}
: VIRTIO_NET_CTRL_MQ_HASH_CONFIG, sgs))
goto err;

return true;

err:
dev_warn(&dev->dev, "VIRTIONET issue with committing RSS sgs\n");
return false;

}

static void virtnet_init_default_rss(struct virtnet_info *vi)
Expand Down Expand Up @@ -4193,12 +4215,17 @@ static int virtnet_get_link_ksettings(struct net_device *dev,
static int virtnet_send_tx_notf_coal_cmds(struct virtnet_info *vi,
struct ethtool_coalesce *ec)
{
struct virtio_net_ctrl_coal_tx *coal_tx __free(kfree) = NULL;
struct scatterlist sgs_tx;
int i;

vi->ctrl->coal_tx.tx_usecs = cpu_to_le32(ec->tx_coalesce_usecs);
vi->ctrl->coal_tx.tx_max_packets = cpu_to_le32(ec->tx_max_coalesced_frames);
sg_init_one(&sgs_tx, &vi->ctrl->coal_tx, sizeof(vi->ctrl->coal_tx));
coal_tx = kzalloc(sizeof(*coal_tx), GFP_KERNEL);
if (!coal_tx)
return -ENOMEM;

coal_tx->tx_usecs = cpu_to_le32(ec->tx_coalesce_usecs);
coal_tx->tx_max_packets = cpu_to_le32(ec->tx_max_coalesced_frames);
sg_init_one(&sgs_tx, coal_tx, sizeof(*coal_tx));

if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_NOTF_COAL,
VIRTIO_NET_CTRL_NOTF_COAL_TX_SET,
Expand All @@ -4218,6 +4245,7 @@ static int virtnet_send_tx_notf_coal_cmds(struct virtnet_info *vi,
static int virtnet_send_rx_notf_coal_cmds(struct virtnet_info *vi,
struct ethtool_coalesce *ec)
{
struct virtio_net_ctrl_coal_rx *coal_rx __free(kfree) = NULL;
bool rx_ctrl_dim_on = !!ec->use_adaptive_rx_coalesce;
struct scatterlist sgs_rx;
int i;
Expand All @@ -4236,6 +4264,10 @@ static int virtnet_send_rx_notf_coal_cmds(struct virtnet_info *vi,
return 0;
}

coal_rx = kzalloc(sizeof(*coal_rx), GFP_KERNEL);
if (!coal_rx)
return -ENOMEM;

if (!rx_ctrl_dim_on && vi->rx_dim_enabled) {
vi->rx_dim_enabled = false;
for (i = 0; i < vi->max_queue_pairs; i++)
Expand All @@ -4246,9 +4278,9 @@ static int virtnet_send_rx_notf_coal_cmds(struct virtnet_info *vi,
* 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));
coal_rx->rx_usecs = cpu_to_le32(ec->rx_coalesce_usecs);
coal_rx->rx_max_packets = cpu_to_le32(ec->rx_max_coalesced_frames);
sg_init_one(&sgs_rx, coal_rx, sizeof(*coal_rx));

if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_NOTF_COAL,
VIRTIO_NET_CTRL_NOTF_COAL_RX_SET,
Expand Down Expand Up @@ -4823,10 +4855,16 @@ static int virtnet_restore_up(struct virtio_device *vdev)

static int virtnet_set_guest_offloads(struct virtnet_info *vi, u64 offloads)
{
__virtio64 *_offloads __free(kfree) = NULL;
struct scatterlist sg;
vi->ctrl->offloads = cpu_to_virtio64(vi->vdev, offloads);

sg_init_one(&sg, &vi->ctrl->offloads, sizeof(vi->ctrl->offloads));
_offloads = kzalloc(sizeof(*_offloads), GFP_KERNEL);
if (!_offloads)
return -ENOMEM;

*_offloads = cpu_to_virtio64(vi->vdev, offloads);

sg_init_one(&sg, _offloads, sizeof(*_offloads));

if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_GUEST_OFFLOADS,
VIRTIO_NET_CTRL_GUEST_OFFLOADS_SET, &sg)) {
Expand Down Expand Up @@ -5810,10 +5848,18 @@ static int virtnet_probe(struct virtio_device *vdev)
}

if (virtio_has_feature(vi->vdev, VIRTIO_NET_F_DEVICE_STATS)) {
struct virtio_net_stats_capabilities *stats_cap __free(kfree) = NULL;
struct scatterlist sg;
__le64 v;

sg_init_one(&sg, &vi->ctrl->stats_cap, sizeof(vi->ctrl->stats_cap));
stats_cap = kzalloc(sizeof(*stats_cap), GFP_KERNEL);
if (!stats_cap) {
rtnl_unlock();
err = -ENOMEM;
goto free_unregister_netdev;
}

sg_init_one(&sg, stats_cap, sizeof(*stats_cap));

if (!virtnet_send_command_reply(vi, VIRTIO_NET_CTRL_STATS,
VIRTIO_NET_CTRL_STATS_QUERY,
Expand All @@ -5824,7 +5870,7 @@ static int virtnet_probe(struct virtio_device *vdev)
goto free_unregister_netdev;
}

v = vi->ctrl->stats_cap.supported_stats_types[0];
v = stats_cap->supported_stats_types[0];
vi->device_stats_cap = le64_to_cpu(v);
}

Expand Down

0 comments on commit ff7c7d9

Please sign in to comment.