1 files changed, 51 insertions, 34 deletions

diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
index 01f4eb5c8b78..7bab4de658a9 100644
--- a/drivers/net/virtio_net.c
+++ b/drivers/net/virtio_net.c
@@ -36,7 +36,10 @@ module_param(csum, bool, 0444);
 module_param(gso, bool, 0444);
 
 /* FIXME: MTU in config. */
-#define MAX_PACKET_LEN (ETH_HLEN + VLAN_HLEN + ETH_DATA_LEN)
+#define GOOD_PACKET_LEN (ETH_HLEN + VLAN_HLEN + ETH_DATA_LEN)
+#define MERGE_BUFFER_LEN (ALIGN(GOOD_PACKET_LEN + \
+                                sizeof(struct virtio_net_hdr_mrg_rxbuf), \
+                                L1_CACHE_BYTES))
 #define GOOD_COPY_LEN   128
 
 #define VIRTNET_DRIVER_VERSION "1.0.0"
@@ -314,10 +317,10 @@ static int receive_mergeable(struct receive_queue *rq, struct sk_buff *head_skb)
                         head_skb->dev->stats.rx_length_errors++;
                         return -EINVAL;
                 }
-                if (unlikely(len > MAX_PACKET_LEN)) {
+                if (unlikely(len > MERGE_BUFFER_LEN)) {
                         pr_debug("%s: rx error: merge buffer too long\n",
                                  head_skb->dev->name);
-                        len = MAX_PACKET_LEN;
+                        len = MERGE_BUFFER_LEN;
                 }
                 if (unlikely(num_skb_frags == MAX_SKB_FRAGS)) {
                         struct sk_buff *nskb = alloc_skb(0, GFP_ATOMIC);
@@ -336,18 +339,17 @@ static int receive_mergeable(struct receive_queue *rq, struct sk_buff *head_skb)
                 if (curr_skb != head_skb) {
                         head_skb->data_len += len;
                         head_skb->len += len;
-                        head_skb->truesize += MAX_PACKET_LEN;
+                        head_skb->truesize += MERGE_BUFFER_LEN;
                 }
                 page = virt_to_head_page(buf);
                 offset = buf - (char *)page_address(page);
                 if (skb_can_coalesce(curr_skb, num_skb_frags, page, offset)) {
                         put_page(page);
                         skb_coalesce_rx_frag(curr_skb, num_skb_frags - 1,
-                                             len, MAX_PACKET_LEN);
+                                             len, MERGE_BUFFER_LEN);
                 } else {
                         skb_add_rx_frag(curr_skb, num_skb_frags, page,
-                                        offset, len,
-                                        MAX_PACKET_LEN);
+                                        offset, len, MERGE_BUFFER_LEN);
                 }
                 --rq->num;
         }
@@ -383,7 +385,7 @@ static void receive_buf(struct receive_queue *rq, void *buf, unsigned int len)
                 struct page *page = virt_to_head_page(buf);
                 skb = page_to_skb(rq, page,
                                   (char *)buf - (char *)page_address(page),
-                                  len, MAX_PACKET_LEN);
+                                  len, MERGE_BUFFER_LEN);
                 if (unlikely(!skb)) {
                         dev->stats.rx_dropped++;
                         put_page(page);
@@ -471,11 +473,11 @@ static int add_recvbuf_small(struct receive_queue *rq, gfp_t gfp)
         struct skb_vnet_hdr *hdr;
         int err;
 
-        skb = __netdev_alloc_skb_ip_align(vi->dev, MAX_PACKET_LEN, gfp);
+        skb = __netdev_alloc_skb_ip_align(vi->dev, GOOD_PACKET_LEN, gfp);
         if (unlikely(!skb))
                 return -ENOMEM;
 
-        skb_put(skb, MAX_PACKET_LEN);
+        skb_put(skb, GOOD_PACKET_LEN);
 
         hdr = skb_vnet_hdr(skb);
         sg_set_buf(rq->sg, &hdr->hdr, sizeof hdr->hdr);
@@ -542,20 +544,20 @@ static int add_recvbuf_mergeable(struct receive_queue *rq, gfp_t gfp)
         int err;
 
         if (gfp & __GFP_WAIT) {
-                if (skb_page_frag_refill(MAX_PACKET_LEN, &vi->alloc_frag,
+                if (skb_page_frag_refill(MERGE_BUFFER_LEN, &vi->alloc_frag,
                                          gfp)) {
                         buf = (char *)page_address(vi->alloc_frag.page) +
                               vi->alloc_frag.offset;
                         get_page(vi->alloc_frag.page);
-                        vi->alloc_frag.offset += MAX_PACKET_LEN;
+                        vi->alloc_frag.offset += MERGE_BUFFER_LEN;
                 }
         } else {
-                buf = netdev_alloc_frag(MAX_PACKET_LEN);
+                buf = netdev_alloc_frag(MERGE_BUFFER_LEN);
         }
         if (!buf)
                 return -ENOMEM;
 
-        sg_init_one(rq->sg, buf, MAX_PACKET_LEN);
+        sg_init_one(rq->sg, buf, MERGE_BUFFER_LEN);
         err = virtqueue_add_inbuf(rq->vq, rq->sg, 1, buf, gfp);
         if (err < 0)
                 put_page(virt_to_head_page(buf));
@@ -591,7 +593,8 @@ static bool try_fill_recv(struct receive_queue *rq, gfp_t gfp)
         } while (rq->vq->num_free);
         if (unlikely(rq->num > rq->max))
                 rq->max = rq->num;
-        virtqueue_kick(rq->vq);
+        if (unlikely(!virtqueue_kick(rq->vq)))
+                return false;
         return !oom;
 }
 
@@ -797,7 +800,7 @@ static netdev_tx_t start_xmit(struct sk_buff *skb, struct net_device *dev)
         err = xmit_skb(sq, skb);
 
         /* This should not happen! */
-        if (unlikely(err)) {
+        if (unlikely(err) || unlikely(!virtqueue_kick(sq->vq))) {
                 dev->stats.tx_fifo_errors++;
                 if (net_ratelimit())
                         dev_warn(&dev->dev,
@@ -806,7 +809,6 @@ static netdev_tx_t start_xmit(struct sk_buff *skb, struct net_device *dev)
                 kfree_skb(skb);
                 return NETDEV_TX_OK;
         }
-        virtqueue_kick(sq->vq);
 
         /* Don't wait up for transmitted skbs to be freed. */
         skb_orphan(skb);
@@ -865,12 +867,14 @@ static bool virtnet_send_command(struct virtnet_info *vi, u8 class, u8 cmd,
         BUG_ON(virtqueue_add_sgs(vi->cvq, sgs, out_num, in_num, vi, GFP_ATOMIC)
                < 0);
 
-        virtqueue_kick(vi->cvq);
+        if (unlikely(!virtqueue_kick(vi->cvq)))
+                return status == VIRTIO_NET_OK;
 
         /* Spin for a response, the kick causes an ioport write, trapping
          * into the hypervisor, so the request should be handled immediately.
          */
-        while (!virtqueue_get_buf(vi->cvq, &tmp))
+        while (!virtqueue_get_buf(vi->cvq, &tmp) &&
+               !virtqueue_is_broken(vi->cvq))
                 cpu_relax();
 
         return status == VIRTIO_NET_OK;
@@ -898,8 +902,13 @@ static int virtnet_set_mac_address(struct net_device *dev, void *p)
                         return -EINVAL;
                 }
         } else if (virtio_has_feature(vdev, VIRTIO_NET_F_MAC)) {
-                vdev->config->set(vdev, offsetof(struct virtio_net_config, mac),
-                                  addr->sa_data, dev->addr_len);
+                unsigned int i;
+
+                /* Naturally, this has an atomicity problem. */
+                for (i = 0; i < dev->addr_len; i++)
+                        virtio_cwrite8(vdev,
+                                       offsetof(struct virtio_net_config, mac) +
+                                       i, addr->sa_data[i]);
         }
 
         eth_commit_mac_addr_change(dev, p);
@@ -1281,9 +1290,8 @@ static void virtnet_config_changed_work(struct work_struct *work)
         if (!vi->config_enable)
                 goto done;
 
-        if (virtio_config_val(vi->vdev, VIRTIO_NET_F_STATUS,
-                              offsetof(struct virtio_net_config, status),
-                              &v) < 0)
+        if (virtio_cread_feature(vi->vdev, VIRTIO_NET_F_STATUS,
+                                 struct virtio_net_config, status, &v) < 0)
                 goto done;
 
         if (v & VIRTIO_NET_S_ANNOUNCE) {
@@ -1507,9 +1515,9 @@ static int virtnet_probe(struct virtio_device *vdev)
         u16 max_queue_pairs;
 
         /* Find if host supports multiqueue virtio_net device */
-        err = virtio_config_val(vdev, VIRTIO_NET_F_MQ,
-                                offsetof(struct virtio_net_config,
-                                max_virtqueue_pairs), &max_queue_pairs);
+        err = virtio_cread_feature(vdev, VIRTIO_NET_F_MQ,
+                                   struct virtio_net_config,
+                                   max_virtqueue_pairs, &max_queue_pairs);
 
         /* We need at least 2 queue's */
         if (err || max_queue_pairs < VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MIN ||
@@ -1561,9 +1569,11 @@ static int virtnet_probe(struct virtio_device *vdev)
         dev->vlan_features = dev->features;
 
         /* Configuration may specify what MAC to use.  Otherwise random. */
-        if (virtio_config_val_len(vdev, VIRTIO_NET_F_MAC,
-                                  offsetof(struct virtio_net_config, mac),
-                                  dev->dev_addr, dev->addr_len) < 0)
+        if (virtio_has_feature(vdev, VIRTIO_NET_F_MAC))
+                virtio_cread_bytes(vdev,
+                                   offsetof(struct virtio_net_config, mac),
+                                   dev->dev_addr, dev->addr_len);
+        else
                 eth_hw_addr_random(dev);
 
         /* Set up our device-specific information */
@@ -1576,6 +1586,13 @@ static int virtnet_probe(struct virtio_device *vdev)
         if (vi->stats == NULL)
                 goto free;
 
+        for_each_possible_cpu(i) {
+                struct virtnet_stats *virtnet_stats;
+                virtnet_stats = per_cpu_ptr(vi->stats, i);
+                u64_stats_init(&virtnet_stats->tx_syncp);
+                u64_stats_init(&virtnet_stats->rx_syncp);
+        }
+
         mutex_init(&vi->config_lock);
         vi->config_enable = true;
         INIT_WORK(&vi->config_work, virtnet_config_changed_work);
@@ -1604,8 +1621,8 @@ static int virtnet_probe(struct virtio_device *vdev)
         if (err)
                 goto free_stats;
 
-        netif_set_real_num_tx_queues(dev, 1);
-        netif_set_real_num_rx_queues(dev, 1);
+        netif_set_real_num_tx_queues(dev, vi->curr_queue_pairs);
+        netif_set_real_num_rx_queues(dev, vi->curr_queue_pairs);
 
         err = register_netdev(dev);
         if (err) {
@@ -1697,7 +1714,7 @@ static void virtnet_remove(struct virtio_device *vdev)
         free_netdev(vi->dev);
 }
 
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 static int virtnet_freeze(struct virtio_device *vdev)
 {
         struct virtnet_info *vi = vdev->priv;
@@ -1788,7 +1805,7 @@ static struct virtio_driver virtio_net_driver = {
         .probe =        virtnet_probe,
         .remove =       virtnet_remove,
         .config_changed = virtnet_config_changed,
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
         .freeze =       virtnet_freeze,
         .restore =      virtnet_restore,
 #endif