LCOV - code coverage report
Current view: top level - drivers/net - virtio_net.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 9 1533 0.6 %
Date: 2022-04-01 14:58:12 Functions: 1 75 1.3 %
Branches: 3 833 0.4 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-or-later
       2                 :            : /* A network driver using virtio.
       3                 :            :  *
       4                 :            :  * Copyright 2007 Rusty Russell <rusty@rustcorp.com.au> IBM Corporation
       5                 :            :  */
       6                 :            : //#define DEBUG
       7                 :            : #include <linux/netdevice.h>
       8                 :            : #include <linux/etherdevice.h>
       9                 :            : #include <linux/ethtool.h>
      10                 :            : #include <linux/module.h>
      11                 :            : #include <linux/virtio.h>
      12                 :            : #include <linux/virtio_net.h>
      13                 :            : #include <linux/bpf.h>
      14                 :            : #include <linux/bpf_trace.h>
      15                 :            : #include <linux/scatterlist.h>
      16                 :            : #include <linux/if_vlan.h>
      17                 :            : #include <linux/slab.h>
      18                 :            : #include <linux/cpu.h>
      19                 :            : #include <linux/average.h>
      20                 :            : #include <linux/filter.h>
      21                 :            : #include <linux/kernel.h>
      22                 :            : #include <net/route.h>
      23                 :            : #include <net/xdp.h>
      24                 :            : #include <net/net_failover.h>
      25                 :            : 
      26                 :            : static int napi_weight = NAPI_POLL_WEIGHT;
      27                 :            : module_param(napi_weight, int, 0444);
      28                 :            : 
      29                 :            : static bool csum = true, gso = true, napi_tx = true;
      30                 :            : module_param(csum, bool, 0444);
      31                 :            : module_param(gso, bool, 0444);
      32                 :            : module_param(napi_tx, bool, 0644);
      33                 :            : 
      34                 :            : /* FIXME: MTU in config. */
      35                 :            : #define GOOD_PACKET_LEN (ETH_HLEN + VLAN_HLEN + ETH_DATA_LEN)
      36                 :            : #define GOOD_COPY_LEN   128
      37                 :            : 
      38                 :            : #define VIRTNET_RX_PAD (NET_IP_ALIGN + NET_SKB_PAD)
      39                 :            : 
      40                 :            : /* Amount of XDP headroom to prepend to packets for use by xdp_adjust_head */
      41                 :            : #define VIRTIO_XDP_HEADROOM 256
      42                 :            : 
      43                 :            : /* Separating two types of XDP xmit */
      44                 :            : #define VIRTIO_XDP_TX           BIT(0)
      45                 :            : #define VIRTIO_XDP_REDIR        BIT(1)
      46                 :            : 
      47                 :            : #define VIRTIO_XDP_FLAG BIT(0)
      48                 :            : 
      49                 :            : /* RX packet size EWMA. The average packet size is used to determine the packet
      50                 :            :  * buffer size when refilling RX rings. As the entire RX ring may be refilled
      51                 :            :  * at once, the weight is chosen so that the EWMA will be insensitive to short-
      52                 :            :  * term, transient changes in packet size.
      53                 :            :  */
      54                 :          0 : DECLARE_EWMA(pkt_len, 0, 64)
      55                 :            : 
      56                 :            : #define VIRTNET_DRIVER_VERSION "1.0.0"
      57                 :            : 
      58                 :            : static const unsigned long guest_offloads[] = {
      59                 :            :         VIRTIO_NET_F_GUEST_TSO4,
      60                 :            :         VIRTIO_NET_F_GUEST_TSO6,
      61                 :            :         VIRTIO_NET_F_GUEST_ECN,
      62                 :            :         VIRTIO_NET_F_GUEST_UFO,
      63                 :            :         VIRTIO_NET_F_GUEST_CSUM
      64                 :            : };
      65                 :            : 
      66                 :            : struct virtnet_stat_desc {
      67                 :            :         char desc[ETH_GSTRING_LEN];
      68                 :            :         size_t offset;
      69                 :            : };
      70                 :            : 
      71                 :            : struct virtnet_sq_stats {
      72                 :            :         struct u64_stats_sync syncp;
      73                 :            :         u64 packets;
      74                 :            :         u64 bytes;
      75                 :            :         u64 xdp_tx;
      76                 :            :         u64 xdp_tx_drops;
      77                 :            :         u64 kicks;
      78                 :            : };
      79                 :            : 
      80                 :            : struct virtnet_rq_stats {
      81                 :            :         struct u64_stats_sync syncp;
      82                 :            :         u64 packets;
      83                 :            :         u64 bytes;
      84                 :            :         u64 drops;
      85                 :            :         u64 xdp_packets;
      86                 :            :         u64 xdp_tx;
      87                 :            :         u64 xdp_redirects;
      88                 :            :         u64 xdp_drops;
      89                 :            :         u64 kicks;
      90                 :            : };
      91                 :            : 
      92                 :            : #define VIRTNET_SQ_STAT(m)      offsetof(struct virtnet_sq_stats, m)
      93                 :            : #define VIRTNET_RQ_STAT(m)      offsetof(struct virtnet_rq_stats, m)
      94                 :            : 
      95                 :            : static const struct virtnet_stat_desc virtnet_sq_stats_desc[] = {
      96                 :            :         { "packets",          VIRTNET_SQ_STAT(packets) },
      97                 :            :         { "bytes",            VIRTNET_SQ_STAT(bytes) },
      98                 :            :         { "xdp_tx",           VIRTNET_SQ_STAT(xdp_tx) },
      99                 :            :         { "xdp_tx_drops",     VIRTNET_SQ_STAT(xdp_tx_drops) },
     100                 :            :         { "kicks",            VIRTNET_SQ_STAT(kicks) },
     101                 :            : };
     102                 :            : 
     103                 :            : static const struct virtnet_stat_desc virtnet_rq_stats_desc[] = {
     104                 :            :         { "packets",          VIRTNET_RQ_STAT(packets) },
     105                 :            :         { "bytes",            VIRTNET_RQ_STAT(bytes) },
     106                 :            :         { "drops",            VIRTNET_RQ_STAT(drops) },
     107                 :            :         { "xdp_packets",      VIRTNET_RQ_STAT(xdp_packets) },
     108                 :            :         { "xdp_tx",           VIRTNET_RQ_STAT(xdp_tx) },
     109                 :            :         { "xdp_redirects",    VIRTNET_RQ_STAT(xdp_redirects) },
     110                 :            :         { "xdp_drops",                VIRTNET_RQ_STAT(xdp_drops) },
     111                 :            :         { "kicks",            VIRTNET_RQ_STAT(kicks) },
     112                 :            : };
     113                 :            : 
     114                 :            : #define VIRTNET_SQ_STATS_LEN    ARRAY_SIZE(virtnet_sq_stats_desc)
     115                 :            : #define VIRTNET_RQ_STATS_LEN    ARRAY_SIZE(virtnet_rq_stats_desc)
     116                 :            : 
     117                 :            : /* Internal representation of a send virtqueue */
     118                 :            : struct send_queue {
     119                 :            :         /* Virtqueue associated with this send _queue */
     120                 :            :         struct virtqueue *vq;
     121                 :            : 
     122                 :            :         /* TX: fragments + linear part + virtio header */
     123                 :            :         struct scatterlist sg[MAX_SKB_FRAGS + 2];
     124                 :            : 
     125                 :            :         /* Name of the send queue: output.$index */
     126                 :            :         char name[40];
     127                 :            : 
     128                 :            :         struct virtnet_sq_stats stats;
     129                 :            : 
     130                 :            :         struct napi_struct napi;
     131                 :            : };
     132                 :            : 
     133                 :            : /* Internal representation of a receive virtqueue */
     134                 :            : struct receive_queue {
     135                 :            :         /* Virtqueue associated with this receive_queue */
     136                 :            :         struct virtqueue *vq;
     137                 :            : 
     138                 :            :         struct napi_struct napi;
     139                 :            : 
     140                 :            :         struct bpf_prog __rcu *xdp_prog;
     141                 :            : 
     142                 :            :         struct virtnet_rq_stats stats;
     143                 :            : 
     144                 :            :         /* Chain pages by the private ptr. */
     145                 :            :         struct page *pages;
     146                 :            : 
     147                 :            :         /* Average packet length for mergeable receive buffers. */
     148                 :            :         struct ewma_pkt_len mrg_avg_pkt_len;
     149                 :            : 
     150                 :            :         /* Page frag for packet buffer allocation. */
     151                 :            :         struct page_frag alloc_frag;
     152                 :            : 
     153                 :            :         /* RX: fragments + linear part + virtio header */
     154                 :            :         struct scatterlist sg[MAX_SKB_FRAGS + 2];
     155                 :            : 
     156                 :            :         /* Min single buffer size for mergeable buffers case. */
     157                 :            :         unsigned int min_buf_len;
     158                 :            : 
     159                 :            :         /* Name of this receive queue: input.$index */
     160                 :            :         char name[40];
     161                 :            : 
     162                 :            :         struct xdp_rxq_info xdp_rxq;
     163                 :            : };
     164                 :            : 
     165                 :            : /* Control VQ buffers: protected by the rtnl lock */
     166                 :            : struct control_buf {
     167                 :            :         struct virtio_net_ctrl_hdr hdr;
     168                 :            :         virtio_net_ctrl_ack status;
     169                 :            :         struct virtio_net_ctrl_mq mq;
     170                 :            :         u8 promisc;
     171                 :            :         u8 allmulti;
     172                 :            :         __virtio16 vid;
     173                 :            :         __virtio64 offloads;
     174                 :            : };
     175                 :            : 
     176                 :            : struct virtnet_info {
     177                 :            :         struct virtio_device *vdev;
     178                 :            :         struct virtqueue *cvq;
     179                 :            :         struct net_device *dev;
     180                 :            :         struct send_queue *sq;
     181                 :            :         struct receive_queue *rq;
     182                 :            :         unsigned int status;
     183                 :            : 
     184                 :            :         /* Max # of queue pairs supported by the device */
     185                 :            :         u16 max_queue_pairs;
     186                 :            : 
     187                 :            :         /* # of queue pairs currently used by the driver */
     188                 :            :         u16 curr_queue_pairs;
     189                 :            : 
     190                 :            :         /* # of XDP queue pairs currently used by the driver */
     191                 :            :         u16 xdp_queue_pairs;
     192                 :            : 
     193                 :            :         /* I like... big packets and I cannot lie! */
     194                 :            :         bool big_packets;
     195                 :            : 
     196                 :            :         /* Host will merge rx buffers for big packets (shake it! shake it!) */
     197                 :            :         bool mergeable_rx_bufs;
     198                 :            : 
     199                 :            :         /* Has control virtqueue */
     200                 :            :         bool has_cvq;
     201                 :            : 
     202                 :            :         /* Host can handle any s/g split between our header and packet data */
     203                 :            :         bool any_header_sg;
     204                 :            : 
     205                 :            :         /* Packet virtio header size */
     206                 :            :         u8 hdr_len;
     207                 :            : 
     208                 :            :         /* Work struct for refilling if we run low on memory. */
     209                 :            :         struct delayed_work refill;
     210                 :            : 
     211                 :            :         /* Work struct for config space updates */
     212                 :            :         struct work_struct config_work;
     213                 :            : 
     214                 :            :         /* Does the affinity hint is set for virtqueues? */
     215                 :            :         bool affinity_hint_set;
     216                 :            : 
     217                 :            :         /* CPU hotplug instances for online & dead */
     218                 :            :         struct hlist_node node;
     219                 :            :         struct hlist_node node_dead;
     220                 :            : 
     221                 :            :         struct control_buf *ctrl;
     222                 :            : 
     223                 :            :         /* Ethtool settings */
     224                 :            :         u8 duplex;
     225                 :            :         u32 speed;
     226                 :            : 
     227                 :            :         unsigned long guest_offloads;
     228                 :            :         unsigned long guest_offloads_capable;
     229                 :            : 
     230                 :            :         /* failover when STANDBY feature enabled */
     231                 :            :         struct failover *failover;
     232                 :            : };
     233                 :            : 
     234                 :            : struct padded_vnet_hdr {
     235                 :            :         struct virtio_net_hdr_mrg_rxbuf hdr;
     236                 :            :         /*
     237                 :            :          * hdr is in a separate sg buffer, and data sg buffer shares same page
     238                 :            :          * with this header sg. This padding makes next sg 16 byte aligned
     239                 :            :          * after the header.
     240                 :            :          */
     241                 :            :         char padding[4];
     242                 :            : };
     243                 :            : 
     244                 :          0 : static bool is_xdp_frame(void *ptr)
     245                 :            : {
     246                 :          0 :         return (unsigned long)ptr & VIRTIO_XDP_FLAG;
     247                 :            : }
     248                 :            : 
     249                 :            : static void *xdp_to_ptr(struct xdp_frame *ptr)
     250                 :            : {
     251                 :            :         return (void *)((unsigned long)ptr | VIRTIO_XDP_FLAG);
     252                 :            : }
     253                 :            : 
     254                 :          0 : static struct xdp_frame *ptr_to_xdp(void *ptr)
     255                 :            : {
     256                 :          0 :         return (struct xdp_frame *)((unsigned long)ptr & ~VIRTIO_XDP_FLAG);
     257                 :            : }
     258                 :            : 
     259                 :            : /* Converting between virtqueue no. and kernel tx/rx queue no.
     260                 :            :  * 0:rx0 1:tx0 2:rx1 3:tx1 ... 2N:rxN 2N+1:txN 2N+2:cvq
     261                 :            :  */
     262                 :          0 : static int vq2txq(struct virtqueue *vq)
     263                 :            : {
     264                 :          0 :         return (vq->index - 1) / 2;
     265                 :            : }
     266                 :            : 
     267                 :          0 : static int txq2vq(int txq)
     268                 :            : {
     269                 :          0 :         return txq * 2 + 1;
     270                 :            : }
     271                 :            : 
     272                 :          0 : static int vq2rxq(struct virtqueue *vq)
     273                 :            : {
     274                 :          0 :         return vq->index / 2;
     275                 :            : }
     276                 :            : 
     277                 :          0 : static int rxq2vq(int rxq)
     278                 :            : {
     279                 :          0 :         return rxq * 2;
     280                 :            : }
     281                 :            : 
     282                 :          0 : static inline struct virtio_net_hdr_mrg_rxbuf *skb_vnet_hdr(struct sk_buff *skb)
     283                 :            : {
     284                 :          0 :         return (struct virtio_net_hdr_mrg_rxbuf *)skb->cb;
     285                 :            : }
     286                 :            : 
     287                 :            : /*
     288                 :            :  * private is used to chain pages for big packets, put the whole
     289                 :            :  * most recent used list in the beginning for reuse
     290                 :            :  */
     291                 :          0 : static void give_pages(struct receive_queue *rq, struct page *page)
     292                 :            : {
     293                 :            :         struct page *end;
     294                 :            : 
     295                 :            :         /* Find end of list, sew whole thing into vi->rq.pages. */
     296   [ #  #  #  #  :          0 :         for (end = page; end->private; end = (struct page *)end->private);
                   #  # ]
     297                 :          0 :         end->private = (unsigned long)rq->pages;
     298                 :          0 :         rq->pages = page;
     299                 :          0 : }
     300                 :            : 
     301                 :            : static struct page *get_a_page(struct receive_queue *rq, gfp_t gfp_mask)
     302                 :            : {
     303                 :            :         struct page *p = rq->pages;
     304                 :            : 
     305                 :            :         if (p) {
     306                 :            :                 rq->pages = (struct page *)p->private;
     307                 :            :                 /* clear private here, it is used to chain pages */
     308                 :            :                 p->private = 0;
     309                 :            :         } else
     310                 :            :                 p = alloc_page(gfp_mask);
     311                 :            :         return p;
     312                 :            : }
     313                 :            : 
     314                 :          0 : static void virtqueue_napi_schedule(struct napi_struct *napi,
     315                 :            :                                     struct virtqueue *vq)
     316                 :            : {
     317         [ #  # ]:          0 :         if (napi_schedule_prep(napi)) {
     318                 :          0 :                 virtqueue_disable_cb(vq);
     319                 :          0 :                 __napi_schedule(napi);
     320                 :            :         }
     321                 :          0 : }
     322                 :            : 
     323                 :          0 : static void virtqueue_napi_complete(struct napi_struct *napi,
     324                 :            :                                     struct virtqueue *vq, int processed)
     325                 :            : {
     326                 :          0 :         int opaque;
     327                 :            : 
     328                 :          0 :         opaque = virtqueue_enable_cb_prepare(vq);
     329         [ #  # ]:          0 :         if (napi_complete_done(napi, processed)) {
     330         [ #  # ]:          0 :                 if (unlikely(virtqueue_poll(vq, opaque)))
     331                 :          0 :                         virtqueue_napi_schedule(napi, vq);
     332                 :            :         } else {
     333                 :          0 :                 virtqueue_disable_cb(vq);
     334                 :            :         }
     335                 :          0 : }
     336                 :            : 
     337                 :          0 : static void skb_xmit_done(struct virtqueue *vq)
     338                 :            : {
     339                 :          0 :         struct virtnet_info *vi = vq->vdev->priv;
     340                 :          0 :         struct napi_struct *napi = &vi->sq[vq2txq(vq)].napi;
     341                 :            : 
     342                 :            :         /* Suppress further interrupts. */
     343                 :          0 :         virtqueue_disable_cb(vq);
     344                 :            : 
     345         [ #  # ]:          0 :         if (napi->weight)
     346                 :          0 :                 virtqueue_napi_schedule(napi, vq);
     347                 :            :         else
     348                 :            :                 /* We were probably waiting for more output buffers. */
     349                 :          0 :                 netif_wake_subqueue(vi->dev, vq2txq(vq));
     350                 :          0 : }
     351                 :            : 
     352                 :            : #define MRG_CTX_HEADER_SHIFT 22
     353                 :          0 : static void *mergeable_len_to_ctx(unsigned int truesize,
     354                 :            :                                   unsigned int headroom)
     355                 :            : {
     356                 :          0 :         return (void *)(unsigned long)((headroom << MRG_CTX_HEADER_SHIFT) | truesize);
     357                 :            : }
     358                 :            : 
     359                 :          0 : static unsigned int mergeable_ctx_to_headroom(void *mrg_ctx)
     360                 :            : {
     361                 :          0 :         return (unsigned long)mrg_ctx >> MRG_CTX_HEADER_SHIFT;
     362                 :            : }
     363                 :            : 
     364                 :          0 : static unsigned int mergeable_ctx_to_truesize(void *mrg_ctx)
     365                 :            : {
     366                 :          0 :         return (unsigned long)mrg_ctx & ((1 << MRG_CTX_HEADER_SHIFT) - 1);
     367                 :            : }
     368                 :            : 
     369                 :            : /* Called from bottom half context */
     370                 :          0 : static struct sk_buff *page_to_skb(struct virtnet_info *vi,
     371                 :            :                                    struct receive_queue *rq,
     372                 :            :                                    struct page *page, unsigned int offset,
     373                 :            :                                    unsigned int len, unsigned int truesize,
     374                 :            :                                    bool hdr_valid)
     375                 :            : {
     376                 :          0 :         struct sk_buff *skb;
     377                 :          0 :         struct virtio_net_hdr_mrg_rxbuf *hdr;
     378                 :          0 :         unsigned int copy, hdr_len, hdr_padded_len;
     379                 :          0 :         char *p;
     380                 :            : 
     381                 :          0 :         p = page_address(page) + offset;
     382                 :            : 
     383                 :            :         /* copy small packet so we can reuse these pages for small data */
     384                 :          0 :         skb = napi_alloc_skb(&rq->napi, GOOD_COPY_LEN);
     385         [ #  # ]:          0 :         if (unlikely(!skb))
     386                 :            :                 return NULL;
     387                 :            : 
     388                 :          0 :         hdr = skb_vnet_hdr(skb);
     389                 :            : 
     390                 :          0 :         hdr_len = vi->hdr_len;
     391         [ #  # ]:          0 :         if (vi->mergeable_rx_bufs)
     392                 :            :                 hdr_padded_len = sizeof(*hdr);
     393                 :            :         else
     394                 :          0 :                 hdr_padded_len = sizeof(struct padded_vnet_hdr);
     395                 :            : 
     396         [ #  # ]:          0 :         if (hdr_valid)
     397                 :          0 :                 memcpy(hdr, p, hdr_len);
     398                 :            : 
     399                 :          0 :         len -= hdr_len;
     400                 :          0 :         offset += hdr_padded_len;
     401                 :          0 :         p += hdr_padded_len;
     402                 :            : 
     403                 :          0 :         copy = len;
     404         [ #  # ]:          0 :         if (copy > skb_tailroom(skb))
     405                 :            :                 copy = skb_tailroom(skb);
     406                 :          0 :         skb_put_data(skb, p, copy);
     407                 :            : 
     408                 :          0 :         len -= copy;
     409                 :          0 :         offset += copy;
     410                 :            : 
     411         [ #  # ]:          0 :         if (vi->mergeable_rx_bufs) {
     412         [ #  # ]:          0 :                 if (len)
     413                 :          0 :                         skb_add_rx_frag(skb, 0, page, offset, len, truesize);
     414                 :            :                 else
     415                 :          0 :                         put_page(page);
     416                 :          0 :                 return skb;
     417                 :            :         }
     418                 :            : 
     419                 :            :         /*
     420                 :            :          * Verify that we can indeed put this data into a skb.
     421                 :            :          * This is here to handle cases when the device erroneously
     422                 :            :          * tries to receive more than is possible. This is usually
     423                 :            :          * the case of a broken device.
     424                 :            :          */
     425         [ #  # ]:          0 :         if (unlikely(len > MAX_SKB_FRAGS * PAGE_SIZE)) {
     426                 :          0 :                 net_dbg_ratelimited("%s: too much data\n", skb->dev->name);
     427                 :          0 :                 dev_kfree_skb(skb);
     428                 :          0 :                 return NULL;
     429                 :            :         }
     430         [ #  # ]:          0 :         BUG_ON(offset >= PAGE_SIZE);
     431         [ #  # ]:          0 :         while (len) {
     432                 :          0 :                 unsigned int frag_size = min((unsigned)PAGE_SIZE - offset, len);
     433                 :          0 :                 skb_add_rx_frag(skb, skb_shinfo(skb)->nr_frags, page, offset,
     434                 :            :                                 frag_size, truesize);
     435                 :          0 :                 len -= frag_size;
     436                 :          0 :                 page = (struct page *)page->private;
     437                 :          0 :                 offset = 0;
     438                 :            :         }
     439                 :            : 
     440         [ #  # ]:          0 :         if (page)
     441                 :            :                 give_pages(rq, page);
     442                 :            : 
     443                 :            :         return skb;
     444                 :            : }
     445                 :            : 
     446                 :            : static int __virtnet_xdp_xmit_one(struct virtnet_info *vi,
     447                 :            :                                    struct send_queue *sq,
     448                 :            :                                    struct xdp_frame *xdpf)
     449                 :            : {
     450                 :            :         struct virtio_net_hdr_mrg_rxbuf *hdr;
     451                 :            :         int err;
     452                 :            : 
     453                 :            :         /* virtqueue want to use data area in-front of packet */
     454                 :            :         if (unlikely(xdpf->metasize > 0))
     455                 :            :                 return -EOPNOTSUPP;
     456                 :            : 
     457                 :            :         if (unlikely(xdpf->headroom < vi->hdr_len))
     458                 :            :                 return -EOVERFLOW;
     459                 :            : 
     460                 :            :         /* Make room for virtqueue hdr (also change xdpf->headroom?) */
     461                 :            :         xdpf->data -= vi->hdr_len;
     462                 :            :         /* Zero header and leave csum up to XDP layers */
     463                 :            :         hdr = xdpf->data;
     464                 :            :         memset(hdr, 0, vi->hdr_len);
     465                 :            :         xdpf->len   += vi->hdr_len;
     466                 :            : 
     467                 :            :         sg_init_one(sq->sg, xdpf->data, xdpf->len);
     468                 :            : 
     469                 :            :         err = virtqueue_add_outbuf(sq->vq, sq->sg, 1, xdp_to_ptr(xdpf),
     470                 :            :                                    GFP_ATOMIC);
     471                 :            :         if (unlikely(err))
     472                 :            :                 return -ENOSPC; /* Caller handle free/refcnt */
     473                 :            : 
     474                 :            :         return 0;
     475                 :            : }
     476                 :            : 
     477                 :          0 : static struct send_queue *virtnet_xdp_sq(struct virtnet_info *vi)
     478                 :            : {
     479                 :          0 :         unsigned int qp;
     480                 :            : 
     481                 :          0 :         qp = vi->curr_queue_pairs - vi->xdp_queue_pairs + smp_processor_id();
     482                 :          0 :         return &vi->sq[qp];
     483                 :            : }
     484                 :            : 
     485                 :          0 : static int virtnet_xdp_xmit(struct net_device *dev,
     486                 :            :                             int n, struct xdp_frame **frames, u32 flags)
     487                 :            : {
     488         [ #  # ]:          0 :         struct virtnet_info *vi = netdev_priv(dev);
     489                 :          0 :         struct receive_queue *rq = vi->rq;
     490                 :          0 :         struct bpf_prog *xdp_prog;
     491                 :          0 :         struct send_queue *sq;
     492                 :          0 :         unsigned int len;
     493                 :          0 :         int packets = 0;
     494                 :          0 :         int bytes = 0;
     495                 :          0 :         int drops = 0;
     496                 :          0 :         int kicks = 0;
     497                 :          0 :         int ret, err;
     498                 :          0 :         void *ptr;
     499                 :          0 :         int i;
     500                 :            : 
     501                 :            :         /* Only allow ndo_xdp_xmit if XDP is loaded on dev, as this
     502                 :            :          * indicate XDP resources have been successfully allocated.
     503                 :            :          */
     504         [ #  # ]:          0 :         xdp_prog = rcu_access_pointer(rq->xdp_prog);
     505         [ #  # ]:          0 :         if (!xdp_prog)
     506                 :            :                 return -ENXIO;
     507                 :            : 
     508         [ #  # ]:          0 :         sq = virtnet_xdp_sq(vi);
     509                 :            : 
     510         [ #  # ]:          0 :         if (unlikely(flags & ~XDP_XMIT_FLAGS_MASK)) {
     511                 :          0 :                 ret = -EINVAL;
     512                 :          0 :                 drops = n;
     513                 :          0 :                 goto out;
     514                 :            :         }
     515                 :            : 
     516                 :            :         /* Free up any pending old buffers before queueing new ones. */
     517         [ #  # ]:          0 :         while ((ptr = virtqueue_get_buf(sq->vq, &len)) != NULL) {
     518         [ #  # ]:          0 :                 if (likely(is_xdp_frame(ptr))) {
     519                 :          0 :                         struct xdp_frame *frame = ptr_to_xdp(ptr);
     520                 :            : 
     521                 :          0 :                         bytes += frame->len;
     522                 :          0 :                         xdp_return_frame(frame);
     523                 :            :                 } else {
     524                 :          0 :                         struct sk_buff *skb = ptr;
     525                 :            : 
     526                 :          0 :                         bytes += skb->len;
     527                 :          0 :                         napi_consume_skb(skb, false);
     528                 :            :                 }
     529                 :          0 :                 packets++;
     530                 :            :         }
     531                 :            : 
     532         [ #  # ]:          0 :         for (i = 0; i < n; i++) {
     533                 :          0 :                 struct xdp_frame *xdpf = frames[i];
     534                 :            : 
     535                 :          0 :                 err = __virtnet_xdp_xmit_one(vi, sq, xdpf);
     536         [ #  # ]:          0 :                 if (err) {
     537                 :          0 :                         xdp_return_frame_rx_napi(xdpf);
     538                 :          0 :                         drops++;
     539                 :            :                 }
     540                 :            :         }
     541                 :          0 :         ret = n - drops;
     542                 :            : 
     543         [ #  # ]:          0 :         if (flags & XDP_XMIT_FLUSH) {
     544   [ #  #  #  # ]:          0 :                 if (virtqueue_kick_prepare(sq->vq) && virtqueue_notify(sq->vq))
     545                 :          0 :                         kicks = 1;
     546                 :            :         }
     547                 :          0 : out:
     548                 :          0 :         u64_stats_update_begin(&sq->stats.syncp);
     549                 :          0 :         sq->stats.bytes += bytes;
     550                 :          0 :         sq->stats.packets += packets;
     551                 :          0 :         sq->stats.xdp_tx += n;
     552                 :          0 :         sq->stats.xdp_tx_drops += drops;
     553                 :          0 :         sq->stats.kicks += kicks;
     554                 :          0 :         u64_stats_update_end(&sq->stats.syncp);
     555                 :            : 
     556                 :          0 :         return ret;
     557                 :            : }
     558                 :            : 
     559                 :          0 : static unsigned int virtnet_get_headroom(struct virtnet_info *vi)
     560                 :            : {
     561                 :          0 :         return vi->xdp_queue_pairs ? VIRTIO_XDP_HEADROOM : 0;
     562                 :            : }
     563                 :            : 
     564                 :            : /* We copy the packet for XDP in the following cases:
     565                 :            :  *
     566                 :            :  * 1) Packet is scattered across multiple rx buffers.
     567                 :            :  * 2) Headroom space is insufficient.
     568                 :            :  *
     569                 :            :  * This is inefficient but it's a temporary condition that
     570                 :            :  * we hit right after XDP is enabled and until queue is refilled
     571                 :            :  * with large buffers with sufficient headroom - so it should affect
     572                 :            :  * at most queue size packets.
     573                 :            :  * Afterwards, the conditions to enable
     574                 :            :  * XDP should preclude the underlying device from sending packets
     575                 :            :  * across multiple buffers (num_buf > 1), and we make sure buffers
     576                 :            :  * have enough headroom.
     577                 :            :  */
     578                 :            : static struct page *xdp_linearize_page(struct receive_queue *rq,
     579                 :            :                                        u16 *num_buf,
     580                 :            :                                        struct page *p,
     581                 :            :                                        int offset,
     582                 :            :                                        int page_off,
     583                 :            :                                        unsigned int *len)
     584                 :            : {
     585                 :            :         struct page *page = alloc_page(GFP_ATOMIC);
     586                 :            : 
     587                 :            :         if (!page)
     588                 :            :                 return NULL;
     589                 :            : 
     590                 :            :         memcpy(page_address(page) + page_off, page_address(p) + offset, *len);
     591                 :            :         page_off += *len;
     592                 :            : 
     593                 :            :         while (--*num_buf) {
     594                 :            :                 int tailroom = SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
     595                 :            :                 unsigned int buflen;
     596                 :            :                 void *buf;
     597                 :            :                 int off;
     598                 :            : 
     599                 :            :                 buf = virtqueue_get_buf(rq->vq, &buflen);
     600                 :            :                 if (unlikely(!buf))
     601                 :            :                         goto err_buf;
     602                 :            : 
     603                 :            :                 p = virt_to_head_page(buf);
     604                 :            :                 off = buf - page_address(p);
     605                 :            : 
     606                 :            :                 /* guard against a misconfigured or uncooperative backend that
     607                 :            :                  * is sending packet larger than the MTU.
     608                 :            :                  */
     609                 :            :                 if ((page_off + buflen + tailroom) > PAGE_SIZE) {
     610                 :            :                         put_page(p);
     611                 :            :                         goto err_buf;
     612                 :            :                 }
     613                 :            : 
     614                 :            :                 memcpy(page_address(page) + page_off,
     615                 :            :                        page_address(p) + off, buflen);
     616                 :            :                 page_off += buflen;
     617                 :            :                 put_page(p);
     618                 :            :         }
     619                 :            : 
     620                 :            :         /* Headroom does not contribute to packet length */
     621                 :            :         *len = page_off - VIRTIO_XDP_HEADROOM;
     622                 :            :         return page;
     623                 :            : err_buf:
     624                 :            :         __free_pages(page, 0);
     625                 :            :         return NULL;
     626                 :            : }
     627                 :            : 
     628                 :          0 : static struct sk_buff *receive_small(struct net_device *dev,
     629                 :            :                                      struct virtnet_info *vi,
     630                 :            :                                      struct receive_queue *rq,
     631                 :            :                                      void *buf, void *ctx,
     632                 :            :                                      unsigned int len,
     633                 :            :                                      unsigned int *xdp_xmit,
     634                 :            :                                      struct virtnet_rq_stats *stats)
     635                 :            : {
     636                 :          0 :         struct sk_buff *skb;
     637                 :          0 :         struct bpf_prog *xdp_prog;
     638                 :          0 :         unsigned int xdp_headroom = (unsigned long)ctx;
     639                 :          0 :         unsigned int header_offset = VIRTNET_RX_PAD + xdp_headroom;
     640                 :          0 :         unsigned int headroom = vi->hdr_len + header_offset;
     641                 :          0 :         unsigned int buflen = SKB_DATA_ALIGN(GOOD_PACKET_LEN + headroom) +
     642                 :            :                               SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
     643         [ #  # ]:          0 :         struct page *page = virt_to_head_page(buf);
     644                 :          0 :         unsigned int delta = 0;
     645                 :          0 :         struct page *xdp_page;
     646                 :          0 :         int err;
     647                 :            : 
     648                 :          0 :         len -= vi->hdr_len;
     649                 :          0 :         stats->bytes += len;
     650                 :            : 
     651                 :          0 :         rcu_read_lock();
     652         [ #  # ]:          0 :         xdp_prog = rcu_dereference(rq->xdp_prog);
     653         [ #  # ]:          0 :         if (xdp_prog) {
     654                 :          0 :                 struct virtio_net_hdr_mrg_rxbuf *hdr = buf + header_offset;
     655                 :          0 :                 struct xdp_frame *xdpf;
     656                 :          0 :                 struct xdp_buff xdp;
     657                 :          0 :                 void *orig_data;
     658                 :          0 :                 u32 act;
     659                 :            : 
     660         [ #  # ]:          0 :                 if (unlikely(hdr->hdr.gso_type))
     661                 :          0 :                         goto err_xdp;
     662                 :            : 
     663   [ #  #  #  # ]:          0 :                 if (unlikely(xdp_headroom < virtnet_get_headroom(vi))) {
     664                 :          0 :                         int offset = buf - page_address(page) + header_offset;
     665                 :          0 :                         unsigned int tlen = len + vi->hdr_len;
     666                 :          0 :                         u16 num_buf = 1;
     667                 :            : 
     668                 :          0 :                         xdp_headroom = virtnet_get_headroom(vi);
     669                 :          0 :                         header_offset = VIRTNET_RX_PAD + xdp_headroom;
     670                 :          0 :                         headroom = vi->hdr_len + header_offset;
     671                 :          0 :                         buflen = SKB_DATA_ALIGN(GOOD_PACKET_LEN + headroom) +
     672                 :            :                                  SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
     673                 :          0 :                         xdp_page = xdp_linearize_page(rq, &num_buf, page,
     674                 :            :                                                       offset, header_offset,
     675                 :            :                                                       &tlen);
     676         [ #  # ]:          0 :                         if (!xdp_page)
     677                 :          0 :                                 goto err_xdp;
     678                 :            : 
     679                 :          0 :                         buf = page_address(xdp_page);
     680                 :          0 :                         put_page(page);
     681                 :          0 :                         page = xdp_page;
     682                 :            :                 }
     683                 :            : 
     684                 :          0 :                 xdp.data_hard_start = buf + VIRTNET_RX_PAD + vi->hdr_len;
     685                 :          0 :                 xdp.data = xdp.data_hard_start + xdp_headroom;
     686         [ #  # ]:          0 :                 xdp_set_data_meta_invalid(&xdp);
     687                 :          0 :                 xdp.data_end = xdp.data + len;
     688                 :          0 :                 xdp.rxq = &rq->xdp_rxq;
     689                 :          0 :                 orig_data = xdp.data;
     690         [ #  # ]:          0 :                 act = bpf_prog_run_xdp(xdp_prog, &xdp);
     691                 :          0 :                 stats->xdp_packets++;
     692                 :            : 
     693   [ #  #  #  #  :          0 :                 switch (act) {
                   #  # ]
     694                 :          0 :                 case XDP_PASS:
     695                 :            :                         /* Recalculate length in case bpf program changed it */
     696                 :          0 :                         delta = orig_data - xdp.data;
     697                 :          0 :                         len = xdp.data_end - xdp.data;
     698                 :          0 :                         break;
     699                 :          0 :                 case XDP_TX:
     700                 :          0 :                         stats->xdp_tx++;
     701                 :          0 :                         xdpf = convert_to_xdp_frame(&xdp);
     702         [ #  # ]:          0 :                         if (unlikely(!xdpf))
     703                 :          0 :                                 goto err_xdp;
     704                 :          0 :                         err = virtnet_xdp_xmit(dev, 1, &xdpf, 0);
     705         [ #  # ]:          0 :                         if (unlikely(err < 0)) {
     706                 :          0 :                                 trace_xdp_exception(vi->dev, xdp_prog, act);
     707                 :          0 :                                 goto err_xdp;
     708                 :            :                         }
     709                 :          0 :                         *xdp_xmit |= VIRTIO_XDP_TX;
     710                 :          0 :                         rcu_read_unlock();
     711                 :          0 :                         goto xdp_xmit;
     712                 :          0 :                 case XDP_REDIRECT:
     713                 :          0 :                         stats->xdp_redirects++;
     714                 :          0 :                         err = xdp_do_redirect(dev, &xdp, xdp_prog);
     715         [ #  # ]:          0 :                         if (err)
     716                 :          0 :                                 goto err_xdp;
     717                 :          0 :                         *xdp_xmit |= VIRTIO_XDP_REDIR;
     718                 :          0 :                         rcu_read_unlock();
     719                 :          0 :                         goto xdp_xmit;
     720                 :          0 :                 default:
     721                 :          0 :                         bpf_warn_invalid_xdp_action(act);
     722                 :            :                         /* fall through */
     723                 :          0 :                 case XDP_ABORTED:
     724                 :          0 :                         trace_xdp_exception(vi->dev, xdp_prog, act);
     725                 :          0 :                 case XDP_DROP:
     726                 :          0 :                         goto err_xdp;
     727                 :            :                 }
     728                 :            :         }
     729                 :          0 :         rcu_read_unlock();
     730                 :            : 
     731                 :          0 :         skb = build_skb(buf, buflen);
     732         [ #  # ]:          0 :         if (!skb) {
     733                 :          0 :                 put_page(page);
     734                 :          0 :                 goto err;
     735                 :            :         }
     736                 :          0 :         skb_reserve(skb, headroom - delta);
     737                 :          0 :         skb_put(skb, len);
     738         [ #  # ]:          0 :         if (!delta) {
     739                 :          0 :                 buf += header_offset;
     740                 :          0 :                 memcpy(skb_vnet_hdr(skb), buf, vi->hdr_len);
     741                 :            :         } /* keep zeroed vnet hdr since packet was changed by bpf */
     742                 :            : 
     743                 :          0 : err:
     744                 :            :         return skb;
     745                 :            : 
     746                 :            : err_xdp:
     747                 :          0 :         rcu_read_unlock();
     748                 :          0 :         stats->xdp_drops++;
     749                 :          0 :         stats->drops++;
     750                 :          0 :         put_page(page);
     751                 :            : xdp_xmit:
     752                 :            :         return NULL;
     753                 :            : }
     754                 :            : 
     755                 :            : static struct sk_buff *receive_big(struct net_device *dev,
     756                 :            :                                    struct virtnet_info *vi,
     757                 :            :                                    struct receive_queue *rq,
     758                 :            :                                    void *buf,
     759                 :            :                                    unsigned int len,
     760                 :            :                                    struct virtnet_rq_stats *stats)
     761                 :            : {
     762                 :            :         struct page *page = buf;
     763                 :            :         struct sk_buff *skb = page_to_skb(vi, rq, page, 0, len,
     764                 :            :                                           PAGE_SIZE, true);
     765                 :            : 
     766                 :            :         stats->bytes += len - vi->hdr_len;
     767                 :            :         if (unlikely(!skb))
     768                 :            :                 goto err;
     769                 :            : 
     770                 :            :         return skb;
     771                 :            : 
     772                 :            : err:
     773                 :            :         stats->drops++;
     774                 :            :         give_pages(rq, page);
     775                 :            :         return NULL;
     776                 :            : }
     777                 :            : 
     778                 :          0 : static struct sk_buff *receive_mergeable(struct net_device *dev,
     779                 :            :                                          struct virtnet_info *vi,
     780                 :            :                                          struct receive_queue *rq,
     781                 :            :                                          void *buf,
     782                 :            :                                          void *ctx,
     783                 :            :                                          unsigned int len,
     784                 :            :                                          unsigned int *xdp_xmit,
     785                 :            :                                          struct virtnet_rq_stats *stats)
     786                 :            : {
     787                 :          0 :         struct virtio_net_hdr_mrg_rxbuf *hdr = buf;
     788                 :          0 :         u16 num_buf = virtio16_to_cpu(vi->vdev, hdr->num_buffers);
     789         [ #  # ]:          0 :         struct page *page = virt_to_head_page(buf);
     790                 :          0 :         int offset = buf - page_address(page);
     791                 :          0 :         struct sk_buff *head_skb, *curr_skb;
     792                 :          0 :         struct bpf_prog *xdp_prog;
     793                 :          0 :         unsigned int truesize;
     794                 :          0 :         unsigned int headroom = mergeable_ctx_to_headroom(ctx);
     795                 :          0 :         int err;
     796                 :            : 
     797                 :          0 :         head_skb = NULL;
     798                 :          0 :         stats->bytes += len - vi->hdr_len;
     799                 :            : 
     800                 :          0 :         rcu_read_lock();
     801         [ #  # ]:          0 :         xdp_prog = rcu_dereference(rq->xdp_prog);
     802         [ #  # ]:          0 :         if (xdp_prog) {
     803                 :          0 :                 struct xdp_frame *xdpf;
     804                 :          0 :                 struct page *xdp_page;
     805                 :          0 :                 struct xdp_buff xdp;
     806                 :          0 :                 void *data;
     807                 :          0 :                 u32 act;
     808                 :            : 
     809                 :            :                 /* Transient failure which in theory could occur if
     810                 :            :                  * in-flight packets from before XDP was enabled reach
     811                 :            :                  * the receive path after XDP is loaded.
     812                 :            :                  */
     813         [ #  # ]:          0 :                 if (unlikely(hdr->hdr.gso_type))
     814                 :          0 :                         goto err_xdp;
     815                 :            : 
     816                 :            :                 /* This happens when rx buffer size is underestimated
     817                 :            :                  * or headroom is not enough because of the buffer
     818                 :            :                  * was refilled before XDP is set. This should only
     819                 :            :                  * happen for the first several packets, so we don't
     820                 :            :                  * care much about its performance.
     821                 :            :                  */
     822   [ #  #  #  #  :          0 :                 if (unlikely(num_buf > 1 ||
                   #  # ]
     823                 :            :                              headroom < virtnet_get_headroom(vi))) {
     824                 :            :                         /* linearize data for XDP */
     825                 :          0 :                         xdp_page = xdp_linearize_page(rq, &num_buf,
     826                 :            :                                                       page, offset,
     827                 :            :                                                       VIRTIO_XDP_HEADROOM,
     828                 :            :                                                       &len);
     829         [ #  # ]:          0 :                         if (!xdp_page)
     830                 :          0 :                                 goto err_xdp;
     831                 :            :                         offset = VIRTIO_XDP_HEADROOM;
     832                 :            :                 } else {
     833                 :            :                         xdp_page = page;
     834                 :            :                 }
     835                 :            : 
     836                 :            :                 /* Allow consuming headroom but reserve enough space to push
     837                 :            :                  * the descriptor on if we get an XDP_TX return code.
     838                 :            :                  */
     839         [ #  # ]:          0 :                 data = page_address(xdp_page) + offset;
     840                 :          0 :                 xdp.data_hard_start = data - VIRTIO_XDP_HEADROOM + vi->hdr_len;
     841                 :          0 :                 xdp.data = data + vi->hdr_len;
     842         [ #  # ]:          0 :                 xdp_set_data_meta_invalid(&xdp);
     843                 :          0 :                 xdp.data_end = xdp.data + (len - vi->hdr_len);
     844                 :          0 :                 xdp.rxq = &rq->xdp_rxq;
     845                 :            : 
     846         [ #  # ]:          0 :                 act = bpf_prog_run_xdp(xdp_prog, &xdp);
     847                 :          0 :                 stats->xdp_packets++;
     848                 :            : 
     849   [ #  #  #  #  :          0 :                 switch (act) {
                   #  # ]
     850                 :          0 :                 case XDP_PASS:
     851                 :            :                         /* recalculate offset to account for any header
     852                 :            :                          * adjustments. Note other cases do not build an
     853                 :            :                          * skb and avoid using offset
     854                 :            :                          */
     855         [ #  # ]:          0 :                         offset = xdp.data -
     856                 :          0 :                                         page_address(xdp_page) - vi->hdr_len;
     857                 :            : 
     858                 :            :                         /* recalculate len if xdp.data or xdp.data_end were
     859                 :            :                          * adjusted
     860                 :            :                          */
     861                 :          0 :                         len = xdp.data_end - xdp.data + vi->hdr_len;
     862                 :            :                         /* We can only create skb based on xdp_page. */
     863         [ #  # ]:          0 :                         if (unlikely(xdp_page != page)) {
     864                 :          0 :                                 rcu_read_unlock();
     865                 :          0 :                                 put_page(page);
     866                 :          0 :                                 head_skb = page_to_skb(vi, rq, xdp_page,
     867                 :            :                                                        offset, len,
     868                 :            :                                                        PAGE_SIZE, false);
     869                 :          0 :                                 return head_skb;
     870                 :            :                         }
     871                 :          0 :                         break;
     872                 :          0 :                 case XDP_TX:
     873                 :          0 :                         stats->xdp_tx++;
     874                 :          0 :                         xdpf = convert_to_xdp_frame(&xdp);
     875         [ #  # ]:          0 :                         if (unlikely(!xdpf))
     876                 :          0 :                                 goto err_xdp;
     877                 :          0 :                         err = virtnet_xdp_xmit(dev, 1, &xdpf, 0);
     878         [ #  # ]:          0 :                         if (unlikely(err < 0)) {
     879                 :          0 :                                 trace_xdp_exception(vi->dev, xdp_prog, act);
     880         [ #  # ]:          0 :                                 if (unlikely(xdp_page != page))
     881                 :          0 :                                         put_page(xdp_page);
     882                 :          0 :                                 goto err_xdp;
     883                 :            :                         }
     884                 :          0 :                         *xdp_xmit |= VIRTIO_XDP_TX;
     885         [ #  # ]:          0 :                         if (unlikely(xdp_page != page))
     886                 :          0 :                                 put_page(page);
     887                 :          0 :                         rcu_read_unlock();
     888                 :          0 :                         goto xdp_xmit;
     889                 :          0 :                 case XDP_REDIRECT:
     890                 :          0 :                         stats->xdp_redirects++;
     891                 :          0 :                         err = xdp_do_redirect(dev, &xdp, xdp_prog);
     892         [ #  # ]:          0 :                         if (err) {
     893         [ #  # ]:          0 :                                 if (unlikely(xdp_page != page))
     894                 :          0 :                                         put_page(xdp_page);
     895                 :          0 :                                 goto err_xdp;
     896                 :            :                         }
     897                 :          0 :                         *xdp_xmit |= VIRTIO_XDP_REDIR;
     898         [ #  # ]:          0 :                         if (unlikely(xdp_page != page))
     899                 :          0 :                                 put_page(page);
     900                 :          0 :                         rcu_read_unlock();
     901                 :          0 :                         goto xdp_xmit;
     902                 :          0 :                 default:
     903                 :          0 :                         bpf_warn_invalid_xdp_action(act);
     904                 :            :                         /* fall through */
     905                 :          0 :                 case XDP_ABORTED:
     906                 :          0 :                         trace_xdp_exception(vi->dev, xdp_prog, act);
     907                 :            :                         /* fall through */
     908                 :          0 :                 case XDP_DROP:
     909         [ #  # ]:          0 :                         if (unlikely(xdp_page != page))
     910                 :          0 :                                 __free_pages(xdp_page, 0);
     911                 :          0 :                         goto err_xdp;
     912                 :            :                 }
     913                 :            :         }
     914                 :          0 :         rcu_read_unlock();
     915                 :            : 
     916                 :          0 :         truesize = mergeable_ctx_to_truesize(ctx);
     917         [ #  # ]:          0 :         if (unlikely(len > truesize)) {
     918                 :          0 :                 pr_debug("%s: rx error: len %u exceeds truesize %lu\n",
     919                 :            :                          dev->name, len, (unsigned long)ctx);
     920                 :          0 :                 dev->stats.rx_length_errors++;
     921                 :          0 :                 goto err_skb;
     922                 :            :         }
     923                 :            : 
     924                 :          0 :         head_skb = page_to_skb(vi, rq, page, offset, len, truesize, !xdp_prog);
     925                 :          0 :         curr_skb = head_skb;
     926                 :            : 
     927         [ #  # ]:          0 :         if (unlikely(!curr_skb))
     928                 :          0 :                 goto err_skb;
     929         [ #  # ]:          0 :         while (--num_buf) {
     930                 :          0 :                 int num_skb_frags;
     931                 :            : 
     932                 :          0 :                 buf = virtqueue_get_buf_ctx(rq->vq, &len, &ctx);
     933         [ #  # ]:          0 :                 if (unlikely(!buf)) {
     934                 :          0 :                         pr_debug("%s: rx error: %d buffers out of %d missing\n",
     935                 :            :                                  dev->name, num_buf,
     936                 :            :                                  virtio16_to_cpu(vi->vdev,
     937                 :            :                                                  hdr->num_buffers));
     938                 :          0 :                         dev->stats.rx_length_errors++;
     939                 :          0 :                         goto err_buf;
     940                 :            :                 }
     941                 :            : 
     942                 :          0 :                 stats->bytes += len;
     943         [ #  # ]:          0 :                 page = virt_to_head_page(buf);
     944                 :            : 
     945                 :          0 :                 truesize = mergeable_ctx_to_truesize(ctx);
     946         [ #  # ]:          0 :                 if (unlikely(len > truesize)) {
     947                 :          0 :                         pr_debug("%s: rx error: len %u exceeds truesize %lu\n",
     948                 :            :                                  dev->name, len, (unsigned long)ctx);
     949                 :          0 :                         dev->stats.rx_length_errors++;
     950                 :          0 :                         goto err_skb;
     951                 :            :                 }
     952                 :            : 
     953         [ #  # ]:          0 :                 num_skb_frags = skb_shinfo(curr_skb)->nr_frags;
     954         [ #  # ]:          0 :                 if (unlikely(num_skb_frags == MAX_SKB_FRAGS)) {
     955                 :          0 :                         struct sk_buff *nskb = alloc_skb(0, GFP_ATOMIC);
     956                 :            : 
     957         [ #  # ]:          0 :                         if (unlikely(!nskb))
     958                 :          0 :                                 goto err_skb;
     959         [ #  # ]:          0 :                         if (curr_skb == head_skb)
     960                 :          0 :                                 skb_shinfo(curr_skb)->frag_list = nskb;
     961                 :            :                         else
     962                 :          0 :                                 curr_skb->next = nskb;
     963                 :          0 :                         curr_skb = nskb;
     964                 :          0 :                         head_skb->truesize += nskb->truesize;
     965                 :          0 :                         num_skb_frags = 0;
     966                 :            :                 }
     967         [ #  # ]:          0 :                 if (curr_skb != head_skb) {
     968                 :          0 :                         head_skb->data_len += len;
     969                 :          0 :                         head_skb->len += len;
     970                 :          0 :                         head_skb->truesize += truesize;
     971                 :            :                 }
     972         [ #  # ]:          0 :                 offset = buf - page_address(page);
     973         [ #  # ]:          0 :                 if (skb_can_coalesce(curr_skb, num_skb_frags, page, offset)) {
     974                 :          0 :                         put_page(page);
     975                 :          0 :                         skb_coalesce_rx_frag(curr_skb, num_skb_frags - 1,
     976                 :            :                                              len, truesize);
     977                 :            :                 } else {
     978                 :          0 :                         skb_add_rx_frag(curr_skb, num_skb_frags, page,
     979                 :            :                                         offset, len, truesize);
     980                 :            :                 }
     981                 :            :         }
     982                 :            : 
     983         [ #  # ]:          0 :         ewma_pkt_len_add(&rq->mrg_avg_pkt_len, head_skb->len);
     984                 :          0 :         return head_skb;
     985                 :            : 
     986                 :            : err_xdp:
     987                 :          0 :         rcu_read_unlock();
     988                 :          0 :         stats->xdp_drops++;
     989                 :          0 : err_skb:
     990                 :          0 :         put_page(page);
     991         [ #  # ]:          0 :         while (num_buf-- > 1) {
     992                 :          0 :                 buf = virtqueue_get_buf(rq->vq, &len);
     993         [ #  # ]:          0 :                 if (unlikely(!buf)) {
     994                 :          0 :                         pr_debug("%s: rx error: %d buffers missing\n",
     995                 :            :                                  dev->name, num_buf);
     996                 :          0 :                         dev->stats.rx_length_errors++;
     997                 :          0 :                         break;
     998                 :            :                 }
     999                 :          0 :                 stats->bytes += len;
    1000         [ #  # ]:          0 :                 page = virt_to_head_page(buf);
    1001                 :          0 :                 put_page(page);
    1002                 :            :         }
    1003                 :          0 : err_buf:
    1004                 :          0 :         stats->drops++;
    1005                 :          0 :         dev_kfree_skb(head_skb);
    1006                 :            : xdp_xmit:
    1007                 :            :         return NULL;
    1008                 :            : }
    1009                 :            : 
    1010                 :          0 : static void receive_buf(struct virtnet_info *vi, struct receive_queue *rq,
    1011                 :            :                         void *buf, unsigned int len, void **ctx,
    1012                 :            :                         unsigned int *xdp_xmit,
    1013                 :            :                         struct virtnet_rq_stats *stats)
    1014                 :            : {
    1015                 :          0 :         struct net_device *dev = vi->dev;
    1016                 :          0 :         struct sk_buff *skb;
    1017                 :          0 :         struct virtio_net_hdr_mrg_rxbuf *hdr;
    1018                 :            : 
    1019         [ #  # ]:          0 :         if (unlikely(len < vi->hdr_len + ETH_HLEN)) {
    1020                 :          0 :                 pr_debug("%s: short packet %i\n", dev->name, len);
    1021                 :          0 :                 dev->stats.rx_length_errors++;
    1022         [ #  # ]:          0 :                 if (vi->mergeable_rx_bufs) {
    1023         [ #  # ]:          0 :                         put_page(virt_to_head_page(buf));
    1024         [ #  # ]:          0 :                 } else if (vi->big_packets) {
    1025                 :            :                         give_pages(rq, buf);
    1026                 :            :                 } else {
    1027         [ #  # ]:          0 :                         put_page(virt_to_head_page(buf));
    1028                 :            :                 }
    1029                 :          0 :                 return;
    1030                 :            :         }
    1031                 :            : 
    1032         [ #  # ]:          0 :         if (vi->mergeable_rx_bufs)
    1033                 :          0 :                 skb = receive_mergeable(dev, vi, rq, buf, ctx, len, xdp_xmit,
    1034                 :            :                                         stats);
    1035         [ #  # ]:          0 :         else if (vi->big_packets)
    1036                 :          0 :                 skb = receive_big(dev, vi, rq, buf, len, stats);
    1037                 :            :         else
    1038                 :          0 :                 skb = receive_small(dev, vi, rq, buf, ctx, len, xdp_xmit, stats);
    1039                 :            : 
    1040         [ #  # ]:          0 :         if (unlikely(!skb))
    1041                 :            :                 return;
    1042                 :            : 
    1043                 :          0 :         hdr = skb_vnet_hdr(skb);
    1044                 :            : 
    1045         [ #  # ]:          0 :         if (hdr->hdr.flags & VIRTIO_NET_HDR_F_DATA_VALID)
    1046                 :          0 :                 skb->ip_summed = CHECKSUM_UNNECESSARY;
    1047                 :            : 
    1048         [ #  # ]:          0 :         if (virtio_net_hdr_to_skb(skb, &hdr->hdr,
    1049                 :          0 :                                   virtio_is_little_endian(vi->vdev))) {
    1050         [ #  # ]:          0 :                 net_warn_ratelimited("%s: bad gso: type: %u, size: %u\n",
    1051                 :            :                                      dev->name, hdr->hdr.gso_type,
    1052                 :            :                                      hdr->hdr.gso_size);
    1053                 :          0 :                 goto frame_err;
    1054                 :            :         }
    1055                 :            : 
    1056                 :          0 :         skb_record_rx_queue(skb, vq2rxq(rq->vq));
    1057                 :          0 :         skb->protocol = eth_type_trans(skb, dev);
    1058                 :          0 :         pr_debug("Receiving skb proto 0x%04x len %i type %i\n",
    1059                 :            :                  ntohs(skb->protocol), skb->len, skb->pkt_type);
    1060                 :            : 
    1061                 :          0 :         napi_gro_receive(&rq->napi, skb);
    1062                 :          0 :         return;
    1063                 :            : 
    1064                 :            : frame_err:
    1065                 :          0 :         dev->stats.rx_frame_errors++;
    1066                 :          0 :         dev_kfree_skb(skb);
    1067                 :            : }
    1068                 :            : 
    1069                 :            : /* Unlike mergeable buffers, all buffers are allocated to the
    1070                 :            :  * same size, except for the headroom. For this reason we do
    1071                 :            :  * not need to use  mergeable_len_to_ctx here - it is enough
    1072                 :            :  * to store the headroom as the context ignoring the truesize.
    1073                 :            :  */
    1074                 :          0 : static int add_recvbuf_small(struct virtnet_info *vi, struct receive_queue *rq,
    1075                 :            :                              gfp_t gfp)
    1076                 :            : {
    1077                 :          0 :         struct page_frag *alloc_frag = &rq->alloc_frag;
    1078                 :          0 :         char *buf;
    1079         [ #  # ]:          0 :         unsigned int xdp_headroom = virtnet_get_headroom(vi);
    1080                 :          0 :         void *ctx = (void *)(unsigned long)xdp_headroom;
    1081                 :          0 :         int len = vi->hdr_len + VIRTNET_RX_PAD + GOOD_PACKET_LEN + xdp_headroom;
    1082                 :          0 :         int err;
    1083                 :            : 
    1084                 :          0 :         len = SKB_DATA_ALIGN(len) +
    1085                 :            :               SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
    1086         [ #  # ]:          0 :         if (unlikely(!skb_page_frag_refill(len, alloc_frag, gfp)))
    1087                 :            :                 return -ENOMEM;
    1088                 :            : 
    1089         [ #  # ]:          0 :         buf = (char *)page_address(alloc_frag->page) + alloc_frag->offset;
    1090         [ #  # ]:          0 :         get_page(alloc_frag->page);
    1091                 :          0 :         alloc_frag->offset += len;
    1092                 :          0 :         sg_init_one(rq->sg, buf + VIRTNET_RX_PAD + xdp_headroom,
    1093                 :          0 :                     vi->hdr_len + GOOD_PACKET_LEN);
    1094                 :          0 :         err = virtqueue_add_inbuf_ctx(rq->vq, rq->sg, 1, buf, ctx, gfp);
    1095         [ #  # ]:          0 :         if (err < 0)
    1096         [ #  # ]:          0 :                 put_page(virt_to_head_page(buf));
    1097                 :            :         return err;
    1098                 :            : }
    1099                 :            : 
    1100                 :            : static int add_recvbuf_big(struct virtnet_info *vi, struct receive_queue *rq,
    1101                 :            :                            gfp_t gfp)
    1102                 :            : {
    1103                 :            :         struct page *first, *list = NULL;
    1104                 :            :         char *p;
    1105                 :            :         int i, err, offset;
    1106                 :            : 
    1107                 :            :         sg_init_table(rq->sg, MAX_SKB_FRAGS + 2);
    1108                 :            : 
    1109                 :            :         /* page in rq->sg[MAX_SKB_FRAGS + 1] is list tail */
    1110                 :            :         for (i = MAX_SKB_FRAGS + 1; i > 1; --i) {
    1111                 :            :                 first = get_a_page(rq, gfp);
    1112                 :            :                 if (!first) {
    1113                 :            :                         if (list)
    1114                 :            :                                 give_pages(rq, list);
    1115                 :            :                         return -ENOMEM;
    1116                 :            :                 }
    1117                 :            :                 sg_set_buf(&rq->sg[i], page_address(first), PAGE_SIZE);
    1118                 :            : 
    1119                 :            :                 /* chain new page in list head to match sg */
    1120                 :            :                 first->private = (unsigned long)list;
    1121                 :            :                 list = first;
    1122                 :            :         }
    1123                 :            : 
    1124                 :            :         first = get_a_page(rq, gfp);
    1125                 :            :         if (!first) {
    1126                 :            :                 give_pages(rq, list);
    1127                 :            :                 return -ENOMEM;
    1128                 :            :         }
    1129                 :            :         p = page_address(first);
    1130                 :            : 
    1131                 :            :         /* rq->sg[0], rq->sg[1] share the same page */
    1132                 :            :         /* a separated rq->sg[0] for header - required in case !any_header_sg */
    1133                 :            :         sg_set_buf(&rq->sg[0], p, vi->hdr_len);
    1134                 :            : 
    1135                 :            :         /* rq->sg[1] for data packet, from offset */
    1136                 :            :         offset = sizeof(struct padded_vnet_hdr);
    1137                 :            :         sg_set_buf(&rq->sg[1], p + offset, PAGE_SIZE - offset);
    1138                 :            : 
    1139                 :            :         /* chain first in list head */
    1140                 :            :         first->private = (unsigned long)list;
    1141                 :            :         err = virtqueue_add_inbuf(rq->vq, rq->sg, MAX_SKB_FRAGS + 2,
    1142                 :            :                                   first, gfp);
    1143                 :            :         if (err < 0)
    1144                 :            :                 give_pages(rq, first);
    1145                 :            : 
    1146                 :            :         return err;
    1147                 :            : }
    1148                 :            : 
    1149                 :          0 : static unsigned int get_mergeable_buf_len(struct receive_queue *rq,
    1150                 :            :                                           struct ewma_pkt_len *avg_pkt_len,
    1151                 :            :                                           unsigned int room)
    1152                 :            : {
    1153                 :          0 :         const size_t hdr_len = sizeof(struct virtio_net_hdr_mrg_rxbuf);
    1154                 :          0 :         unsigned int len;
    1155                 :            : 
    1156                 :          0 :         if (room)
    1157                 :          0 :                 return PAGE_SIZE - room;
    1158                 :            : 
    1159                 :          0 :         len = hdr_len + clamp_t(unsigned int, ewma_pkt_len_read(avg_pkt_len),
    1160                 :            :                                 rq->min_buf_len, PAGE_SIZE - hdr_len);
    1161                 :            : 
    1162                 :          0 :         return ALIGN(len, L1_CACHE_BYTES);
    1163                 :            : }
    1164                 :            : 
    1165                 :          0 : static int add_recvbuf_mergeable(struct virtnet_info *vi,
    1166                 :            :                                  struct receive_queue *rq, gfp_t gfp)
    1167                 :            : {
    1168                 :          0 :         struct page_frag *alloc_frag = &rq->alloc_frag;
    1169         [ #  # ]:          0 :         unsigned int headroom = virtnet_get_headroom(vi);
    1170                 :          0 :         unsigned int tailroom = headroom ? sizeof(struct skb_shared_info) : 0;
    1171                 :          0 :         unsigned int room = SKB_DATA_ALIGN(headroom + tailroom);
    1172                 :          0 :         char *buf;
    1173                 :          0 :         void *ctx;
    1174                 :          0 :         int err;
    1175                 :          0 :         unsigned int len, hole;
    1176                 :            : 
    1177                 :            :         /* Extra tailroom is needed to satisfy XDP's assumption. This
    1178                 :            :          * means rx frags coalescing won't work, but consider we've
    1179                 :            :          * disabled GSO for XDP, it won't be a big issue.
    1180                 :            :          */
    1181         [ #  # ]:          0 :         len = get_mergeable_buf_len(rq, &rq->mrg_avg_pkt_len, room);
    1182         [ #  # ]:          0 :         if (unlikely(!skb_page_frag_refill(len + room, alloc_frag, gfp)))
    1183                 :            :                 return -ENOMEM;
    1184                 :            : 
    1185         [ #  # ]:          0 :         buf = (char *)page_address(alloc_frag->page) + alloc_frag->offset;
    1186                 :          0 :         buf += headroom; /* advance address leaving hole at front of pkt */
    1187         [ #  # ]:          0 :         get_page(alloc_frag->page);
    1188                 :          0 :         alloc_frag->offset += len + room;
    1189                 :          0 :         hole = alloc_frag->size - alloc_frag->offset;
    1190         [ #  # ]:          0 :         if (hole < len + room) {
    1191                 :            :                 /* To avoid internal fragmentation, if there is very likely not
    1192                 :            :                  * enough space for another buffer, add the remaining space to
    1193                 :            :                  * the current buffer.
    1194                 :            :                  */
    1195                 :          0 :                 len += hole;
    1196                 :          0 :                 alloc_frag->offset += hole;
    1197                 :            :         }
    1198                 :            : 
    1199                 :          0 :         sg_init_one(rq->sg, buf, len);
    1200                 :          0 :         ctx = mergeable_len_to_ctx(len, headroom);
    1201                 :          0 :         err = virtqueue_add_inbuf_ctx(rq->vq, rq->sg, 1, buf, ctx, gfp);
    1202         [ #  # ]:          0 :         if (err < 0)
    1203         [ #  # ]:          0 :                 put_page(virt_to_head_page(buf));
    1204                 :            : 
    1205                 :            :         return err;
    1206                 :            : }
    1207                 :            : 
    1208                 :            : /*
    1209                 :            :  * Returns false if we couldn't fill entirely (OOM).
    1210                 :            :  *
    1211                 :            :  * Normally run in the receive path, but can also be run from ndo_open
    1212                 :            :  * before we're receiving packets, or from refill_work which is
    1213                 :            :  * careful to disable receiving (using napi_disable).
    1214                 :            :  */
    1215                 :          0 : static bool try_fill_recv(struct virtnet_info *vi, struct receive_queue *rq,
    1216                 :            :                           gfp_t gfp)
    1217                 :            : {
    1218                 :          0 :         int err;
    1219                 :          0 :         bool oom;
    1220                 :            : 
    1221                 :          0 :         do {
    1222         [ #  # ]:          0 :                 if (vi->mergeable_rx_bufs)
    1223                 :          0 :                         err = add_recvbuf_mergeable(vi, rq, gfp);
    1224         [ #  # ]:          0 :                 else if (vi->big_packets)
    1225                 :          0 :                         err = add_recvbuf_big(vi, rq, gfp);
    1226                 :            :                 else
    1227                 :          0 :                         err = add_recvbuf_small(vi, rq, gfp);
    1228                 :            : 
    1229                 :          0 :                 oom = err == -ENOMEM;
    1230         [ #  # ]:          0 :                 if (err)
    1231                 :            :                         break;
    1232         [ #  # ]:          0 :         } while (rq->vq->num_free);
    1233   [ #  #  #  # ]:          0 :         if (virtqueue_kick_prepare(rq->vq) && virtqueue_notify(rq->vq)) {
    1234                 :          0 :                 u64_stats_update_begin(&rq->stats.syncp);
    1235                 :          0 :                 rq->stats.kicks++;
    1236                 :          0 :                 u64_stats_update_end(&rq->stats.syncp);
    1237                 :            :         }
    1238                 :            : 
    1239                 :          0 :         return !oom;
    1240                 :            : }
    1241                 :            : 
    1242                 :          0 : static void skb_recv_done(struct virtqueue *rvq)
    1243                 :            : {
    1244                 :          0 :         struct virtnet_info *vi = rvq->vdev->priv;
    1245                 :          0 :         struct receive_queue *rq = &vi->rq[vq2rxq(rvq)];
    1246                 :            : 
    1247                 :          0 :         virtqueue_napi_schedule(&rq->napi, rvq);
    1248                 :          0 : }
    1249                 :            : 
    1250                 :          0 : static void virtnet_napi_enable(struct virtqueue *vq, struct napi_struct *napi)
    1251                 :            : {
    1252                 :          0 :         napi_enable(napi);
    1253                 :            : 
    1254                 :            :         /* If all buffers were filled by other side before we napi_enabled, we
    1255                 :            :          * won't get another interrupt, so process any outstanding packets now.
    1256                 :            :          * Call local_bh_enable after to trigger softIRQ processing.
    1257                 :            :          */
    1258                 :          0 :         local_bh_disable();
    1259                 :          0 :         virtqueue_napi_schedule(napi, vq);
    1260                 :          0 :         local_bh_enable();
    1261                 :          0 : }
    1262                 :            : 
    1263                 :          0 : static void virtnet_napi_tx_enable(struct virtnet_info *vi,
    1264                 :            :                                    struct virtqueue *vq,
    1265                 :            :                                    struct napi_struct *napi)
    1266                 :            : {
    1267                 :          0 :         if (!napi->weight)
    1268                 :            :                 return;
    1269                 :            : 
    1270                 :            :         /* Tx napi touches cachelines on the cpu handling tx interrupts. Only
    1271                 :            :          * enable the feature if this is likely affine with the transmit path.
    1272                 :            :          */
    1273   [ #  #  #  #  :          0 :         if (!vi->affinity_hint_set) {
             #  #  #  # ]
    1274                 :          0 :                 napi->weight = 0;
    1275                 :          0 :                 return;
    1276                 :            :         }
    1277                 :            : 
    1278                 :          0 :         return virtnet_napi_enable(vq, napi);
    1279                 :            : }
    1280                 :            : 
    1281                 :          0 : static void virtnet_napi_tx_disable(struct napi_struct *napi)
    1282                 :            : {
    1283                 :          0 :         if (napi->weight)
    1284                 :          0 :                 napi_disable(napi);
    1285                 :            : }
    1286                 :            : 
    1287                 :          0 : static void refill_work(struct work_struct *work)
    1288                 :            : {
    1289                 :          0 :         struct virtnet_info *vi =
    1290                 :          0 :                 container_of(work, struct virtnet_info, refill.work);
    1291                 :          0 :         bool still_empty;
    1292                 :          0 :         int i;
    1293                 :            : 
    1294         [ #  # ]:          0 :         for (i = 0; i < vi->curr_queue_pairs; i++) {
    1295                 :          0 :                 struct receive_queue *rq = &vi->rq[i];
    1296                 :            : 
    1297                 :          0 :                 napi_disable(&rq->napi);
    1298                 :          0 :                 still_empty = !try_fill_recv(vi, rq, GFP_KERNEL);
    1299                 :          0 :                 virtnet_napi_enable(rq->vq, &rq->napi);
    1300                 :            : 
    1301                 :            :                 /* In theory, this can happen: if we don't get any buffers in
    1302                 :            :                  * we will *never* try to fill again.
    1303                 :            :                  */
    1304         [ #  # ]:          0 :                 if (still_empty)
    1305                 :          0 :                         schedule_delayed_work(&vi->refill, HZ/2);
    1306                 :            :         }
    1307                 :          0 : }
    1308                 :            : 
    1309                 :          0 : static int virtnet_receive(struct receive_queue *rq, int budget,
    1310                 :            :                            unsigned int *xdp_xmit)
    1311                 :            : {
    1312                 :          0 :         struct virtnet_info *vi = rq->vq->vdev->priv;
    1313                 :          0 :         struct virtnet_rq_stats stats = {};
    1314                 :          0 :         unsigned int len;
    1315                 :          0 :         void *buf;
    1316                 :          0 :         int i;
    1317                 :            : 
    1318   [ #  #  #  # ]:          0 :         if (!vi->big_packets || vi->mergeable_rx_bufs) {
    1319                 :            :                 void *ctx;
    1320                 :            : 
    1321   [ #  #  #  # ]:          0 :                 while (stats.packets < budget &&
    1322                 :          0 :                        (buf = virtqueue_get_buf_ctx(rq->vq, &len, &ctx))) {
    1323                 :          0 :                         receive_buf(vi, rq, buf, len, ctx, xdp_xmit, &stats);
    1324                 :          0 :                         stats.packets++;
    1325                 :            :                 }
    1326                 :            :         } else {
    1327   [ #  #  #  # ]:          0 :                 while (stats.packets < budget &&
    1328                 :          0 :                        (buf = virtqueue_get_buf(rq->vq, &len)) != NULL) {
    1329                 :          0 :                         receive_buf(vi, rq, buf, len, NULL, xdp_xmit, &stats);
    1330                 :          0 :                         stats.packets++;
    1331                 :            :                 }
    1332                 :            :         }
    1333                 :            : 
    1334         [ #  # ]:          0 :         if (rq->vq->num_free > min((unsigned int)budget, virtqueue_get_vring_size(rq->vq)) / 2) {
    1335         [ #  # ]:          0 :                 if (!try_fill_recv(vi, rq, GFP_ATOMIC))
    1336                 :          0 :                         schedule_delayed_work(&vi->refill, 0);
    1337                 :            :         }
    1338                 :            : 
    1339                 :          0 :         u64_stats_update_begin(&rq->stats.syncp);
    1340         [ #  # ]:          0 :         for (i = 0; i < VIRTNET_RQ_STATS_LEN; i++) {
    1341                 :          0 :                 size_t offset = virtnet_rq_stats_desc[i].offset;
    1342                 :          0 :                 u64 *item;
    1343                 :            : 
    1344                 :          0 :                 item = (u64 *)((u8 *)&rq->stats + offset);
    1345                 :          0 :                 *item += *(u64 *)((u8 *)&stats + offset);
    1346                 :            :         }
    1347                 :          0 :         u64_stats_update_end(&rq->stats.syncp);
    1348                 :            : 
    1349                 :          0 :         return stats.packets;
    1350                 :            : }
    1351                 :            : 
    1352                 :          0 : static void free_old_xmit_skbs(struct send_queue *sq, bool in_napi)
    1353                 :            : {
    1354                 :          0 :         unsigned int len;
    1355                 :          0 :         unsigned int packets = 0;
    1356                 :          0 :         unsigned int bytes = 0;
    1357                 :          0 :         void *ptr;
    1358                 :            : 
    1359         [ #  # ]:          0 :         while ((ptr = virtqueue_get_buf(sq->vq, &len)) != NULL) {
    1360         [ #  # ]:          0 :                 if (likely(!is_xdp_frame(ptr))) {
    1361                 :          0 :                         struct sk_buff *skb = ptr;
    1362                 :            : 
    1363                 :          0 :                         pr_debug("Sent skb %p\n", skb);
    1364                 :            : 
    1365                 :          0 :                         bytes += skb->len;
    1366                 :          0 :                         napi_consume_skb(skb, in_napi);
    1367                 :            :                 } else {
    1368                 :          0 :                         struct xdp_frame *frame = ptr_to_xdp(ptr);
    1369                 :            : 
    1370                 :          0 :                         bytes += frame->len;
    1371                 :          0 :                         xdp_return_frame(frame);
    1372                 :            :                 }
    1373                 :          0 :                 packets++;
    1374                 :            :         }
    1375                 :            : 
    1376                 :            :         /* Avoid overhead when no packets have been processed
    1377                 :            :          * happens when called speculatively from start_xmit.
    1378                 :            :          */
    1379         [ #  # ]:          0 :         if (!packets)
    1380                 :          0 :                 return;
    1381                 :            : 
    1382                 :          0 :         u64_stats_update_begin(&sq->stats.syncp);
    1383                 :          0 :         sq->stats.bytes += bytes;
    1384                 :          0 :         sq->stats.packets += packets;
    1385                 :          0 :         u64_stats_update_end(&sq->stats.syncp);
    1386                 :            : }
    1387                 :            : 
    1388                 :          0 : static bool is_xdp_raw_buffer_queue(struct virtnet_info *vi, int q)
    1389                 :            : {
    1390                 :          0 :         if (q < (vi->curr_queue_pairs - vi->xdp_queue_pairs))
    1391                 :            :                 return false;
    1392         [ #  # ]:          0 :         else if (q < vi->curr_queue_pairs)
    1393                 :            :                 return true;
    1394                 :            :         else
    1395                 :          0 :                 return false;
    1396                 :            : }
    1397                 :            : 
    1398                 :            : static void virtnet_poll_cleantx(struct receive_queue *rq)
    1399                 :            : {
    1400                 :            :         struct virtnet_info *vi = rq->vq->vdev->priv;
    1401                 :            :         unsigned int index = vq2rxq(rq->vq);
    1402                 :            :         struct send_queue *sq = &vi->sq[index];
    1403                 :            :         struct netdev_queue *txq = netdev_get_tx_queue(vi->dev, index);
    1404                 :            : 
    1405                 :            :         if (!sq->napi.weight || is_xdp_raw_buffer_queue(vi, index))
    1406                 :            :                 return;
    1407                 :            : 
    1408                 :            :         if (__netif_tx_trylock(txq)) {
    1409                 :            :                 free_old_xmit_skbs(sq, true);
    1410                 :            :                 __netif_tx_unlock(txq);
    1411                 :            :         }
    1412                 :            : 
    1413                 :            :         if (sq->vq->num_free >= 2 + MAX_SKB_FRAGS)
    1414                 :            :                 netif_tx_wake_queue(txq);
    1415                 :            : }
    1416                 :            : 
    1417                 :          0 : static int virtnet_poll(struct napi_struct *napi, int budget)
    1418                 :            : {
    1419                 :          0 :         struct receive_queue *rq =
    1420                 :          0 :                 container_of(napi, struct receive_queue, napi);
    1421                 :          0 :         struct virtnet_info *vi = rq->vq->vdev->priv;
    1422                 :          0 :         struct send_queue *sq;
    1423                 :          0 :         unsigned int received;
    1424                 :          0 :         unsigned int xdp_xmit = 0;
    1425                 :            : 
    1426                 :          0 :         virtnet_poll_cleantx(rq);
    1427                 :            : 
    1428                 :          0 :         received = virtnet_receive(rq, budget, &xdp_xmit);
    1429                 :            : 
    1430                 :            :         /* Out of packets? */
    1431         [ #  # ]:          0 :         if (received < budget)
    1432                 :          0 :                 virtqueue_napi_complete(napi, rq->vq, received);
    1433                 :            : 
    1434         [ #  # ]:          0 :         if (xdp_xmit & VIRTIO_XDP_REDIR)
    1435                 :          0 :                 xdp_do_flush();
    1436                 :            : 
    1437         [ #  # ]:          0 :         if (xdp_xmit & VIRTIO_XDP_TX) {
    1438                 :          0 :                 sq = virtnet_xdp_sq(vi);
    1439   [ #  #  #  # ]:          0 :                 if (virtqueue_kick_prepare(sq->vq) && virtqueue_notify(sq->vq)) {
    1440                 :          0 :                         u64_stats_update_begin(&sq->stats.syncp);
    1441                 :          0 :                         sq->stats.kicks++;
    1442                 :          0 :                         u64_stats_update_end(&sq->stats.syncp);
    1443                 :            :                 }
    1444                 :            :         }
    1445                 :            : 
    1446                 :          0 :         return received;
    1447                 :            : }
    1448                 :            : 
    1449                 :          0 : static int virtnet_open(struct net_device *dev)
    1450                 :            : {
    1451                 :          0 :         struct virtnet_info *vi = netdev_priv(dev);
    1452                 :          0 :         int i, err;
    1453                 :            : 
    1454         [ #  # ]:          0 :         for (i = 0; i < vi->max_queue_pairs; i++) {
    1455         [ #  # ]:          0 :                 if (i < vi->curr_queue_pairs)
    1456                 :            :                         /* Make sure we have some buffers: if oom use wq. */
    1457         [ #  # ]:          0 :                         if (!try_fill_recv(vi, &vi->rq[i], GFP_KERNEL))
    1458                 :          0 :                                 schedule_delayed_work(&vi->refill, 0);
    1459                 :            : 
    1460                 :          0 :                 err = xdp_rxq_info_reg(&vi->rq[i].xdp_rxq, dev, i);
    1461         [ #  # ]:          0 :                 if (err < 0)
    1462                 :          0 :                         return err;
    1463                 :            : 
    1464                 :          0 :                 err = xdp_rxq_info_reg_mem_model(&vi->rq[i].xdp_rxq,
    1465                 :            :                                                  MEM_TYPE_PAGE_SHARED, NULL);
    1466         [ #  # ]:          0 :                 if (err < 0) {
    1467                 :          0 :                         xdp_rxq_info_unreg(&vi->rq[i].xdp_rxq);
    1468                 :          0 :                         return err;
    1469                 :            :                 }
    1470                 :            : 
    1471                 :          0 :                 virtnet_napi_enable(vi->rq[i].vq, &vi->rq[i].napi);
    1472         [ #  # ]:          0 :                 virtnet_napi_tx_enable(vi, vi->sq[i].vq, &vi->sq[i].napi);
    1473                 :            :         }
    1474                 :            : 
    1475                 :            :         return 0;
    1476                 :            : }
    1477                 :            : 
    1478                 :          0 : static int virtnet_poll_tx(struct napi_struct *napi, int budget)
    1479                 :            : {
    1480                 :          0 :         struct send_queue *sq = container_of(napi, struct send_queue, napi);
    1481                 :          0 :         struct virtnet_info *vi = sq->vq->vdev->priv;
    1482                 :          0 :         unsigned int index = vq2txq(sq->vq);
    1483                 :          0 :         struct netdev_queue *txq;
    1484                 :            : 
    1485   [ #  #  #  # ]:          0 :         if (unlikely(is_xdp_raw_buffer_queue(vi, index))) {
    1486                 :            :                 /* We don't need to enable cb for XDP */
    1487                 :          0 :                 napi_complete_done(napi, 0);
    1488                 :          0 :                 return 0;
    1489                 :            :         }
    1490                 :            : 
    1491                 :          0 :         txq = netdev_get_tx_queue(vi->dev, index);
    1492                 :          0 :         __netif_tx_lock(txq, raw_smp_processor_id());
    1493                 :          0 :         free_old_xmit_skbs(sq, true);
    1494                 :          0 :         __netif_tx_unlock(txq);
    1495                 :            : 
    1496                 :          0 :         virtqueue_napi_complete(napi, sq->vq, 0);
    1497                 :            : 
    1498         [ #  # ]:          0 :         if (sq->vq->num_free >= 2 + MAX_SKB_FRAGS)
    1499                 :          0 :                 netif_tx_wake_queue(txq);
    1500                 :            : 
    1501                 :            :         return 0;
    1502                 :            : }
    1503                 :            : 
    1504                 :          0 : static int xmit_skb(struct send_queue *sq, struct sk_buff *skb)
    1505                 :            : {
    1506                 :          0 :         struct virtio_net_hdr_mrg_rxbuf *hdr;
    1507                 :          0 :         const unsigned char *dest = ((struct ethhdr *)skb->data)->h_dest;
    1508                 :          0 :         struct virtnet_info *vi = sq->vq->vdev->priv;
    1509                 :          0 :         int num_sg;
    1510                 :          0 :         unsigned hdr_len = vi->hdr_len;
    1511                 :          0 :         bool can_push;
    1512                 :            : 
    1513                 :          0 :         pr_debug("%s: xmit %p %pM\n", vi->dev->name, skb, dest);
    1514                 :            : 
    1515                 :          0 :         can_push = vi->any_header_sg &&
    1516   [ #  #  #  # ]:          0 :                 !((unsigned long)skb->data & (__alignof__(*hdr) - 1)) &&
    1517   [ #  #  #  # ]:          0 :                 !skb_header_cloned(skb) && skb_headroom(skb) >= hdr_len;
    1518                 :            :         /* Even if we can, don't push here yet as this would skew
    1519                 :            :          * csum_start offset below. */
    1520         [ #  # ]:          0 :         if (can_push)
    1521                 :          0 :                 hdr = (struct virtio_net_hdr_mrg_rxbuf *)(skb->data - hdr_len);
    1522                 :            :         else
    1523                 :          0 :                 hdr = skb_vnet_hdr(skb);
    1524                 :            : 
    1525         [ #  # ]:          0 :         if (virtio_net_hdr_from_skb(skb, &hdr->hdr,
    1526                 :          0 :                                     virtio_is_little_endian(vi->vdev), false,
    1527                 :            :                                     0))
    1528                 :          0 :                 BUG();
    1529                 :            : 
    1530         [ #  # ]:          0 :         if (vi->mergeable_rx_bufs)
    1531                 :          0 :                 hdr->num_buffers = 0;
    1532                 :            : 
    1533         [ #  # ]:          0 :         sg_init_table(sq->sg, skb_shinfo(skb)->nr_frags + (can_push ? 1 : 2));
    1534         [ #  # ]:          0 :         if (can_push) {
    1535                 :          0 :                 __skb_push(skb, hdr_len);
    1536                 :          0 :                 num_sg = skb_to_sgvec(skb, sq->sg, 0, skb->len);
    1537         [ #  # ]:          0 :                 if (unlikely(num_sg < 0))
    1538                 :            :                         return num_sg;
    1539                 :            :                 /* Pull header back to avoid skew in tx bytes calculations. */
    1540         [ #  # ]:          0 :                 __skb_pull(skb, hdr_len);
    1541                 :            :         } else {
    1542                 :          0 :                 sg_set_buf(sq->sg, hdr, hdr_len);
    1543                 :          0 :                 num_sg = skb_to_sgvec(skb, sq->sg + 1, 0, skb->len);
    1544         [ #  # ]:          0 :                 if (unlikely(num_sg < 0))
    1545                 :            :                         return num_sg;
    1546                 :          0 :                 num_sg++;
    1547                 :            :         }
    1548                 :          0 :         return virtqueue_add_outbuf(sq->vq, sq->sg, num_sg, skb, GFP_ATOMIC);
    1549                 :            : }
    1550                 :            : 
    1551                 :          0 : static netdev_tx_t start_xmit(struct sk_buff *skb, struct net_device *dev)
    1552                 :            : {
    1553                 :          0 :         struct virtnet_info *vi = netdev_priv(dev);
    1554                 :          0 :         int qnum = skb_get_queue_mapping(skb);
    1555                 :          0 :         struct send_queue *sq = &vi->sq[qnum];
    1556                 :          0 :         int err;
    1557                 :          0 :         struct netdev_queue *txq = netdev_get_tx_queue(dev, qnum);
    1558                 :          0 :         bool kick = !netdev_xmit_more();
    1559                 :          0 :         bool use_napi = sq->napi.weight;
    1560                 :            : 
    1561                 :            :         /* Free up any pending old buffers before queueing new ones. */
    1562                 :          0 :         free_old_xmit_skbs(sq, false);
    1563                 :            : 
    1564         [ #  # ]:          0 :         if (use_napi && kick)
    1565                 :          0 :                 virtqueue_enable_cb_delayed(sq->vq);
    1566                 :            : 
    1567                 :            :         /* timestamp packet in software */
    1568         [ #  # ]:          0 :         skb_tx_timestamp(skb);
    1569                 :            : 
    1570                 :            :         /* Try to transmit */
    1571                 :          0 :         err = xmit_skb(sq, skb);
    1572                 :            : 
    1573                 :            :         /* This should not happen! */
    1574         [ #  # ]:          0 :         if (unlikely(err)) {
    1575                 :          0 :                 dev->stats.tx_fifo_errors++;
    1576         [ #  # ]:          0 :                 if (net_ratelimit())
    1577                 :          0 :                         dev_warn(&dev->dev,
    1578                 :            :                                  "Unexpected TXQ (%d) queue failure: %d\n",
    1579                 :            :                                  qnum, err);
    1580                 :          0 :                 dev->stats.tx_dropped++;
    1581                 :          0 :                 dev_kfree_skb_any(skb);
    1582                 :          0 :                 return NETDEV_TX_OK;
    1583                 :            :         }
    1584                 :            : 
    1585                 :            :         /* Don't wait up for transmitted skbs to be freed. */
    1586         [ #  # ]:          0 :         if (!use_napi) {
    1587                 :          0 :                 skb_orphan(skb);
    1588                 :          0 :                 nf_reset_ct(skb);
    1589                 :            :         }
    1590                 :            : 
    1591                 :            :         /* If running out of space, stop queue to avoid getting packets that we
    1592                 :            :          * are then unable to transmit.
    1593                 :            :          * An alternative would be to force queuing layer to requeue the skb by
    1594                 :            :          * returning NETDEV_TX_BUSY. However, NETDEV_TX_BUSY should not be
    1595                 :            :          * returned in a normal path of operation: it means that driver is not
    1596                 :            :          * maintaining the TX queue stop/start state properly, and causes
    1597                 :            :          * the stack to do a non-trivial amount of useless work.
    1598                 :            :          * Since most packets only take 1 or 2 ring slots, stopping the queue
    1599                 :            :          * early means 16 slots are typically wasted.
    1600                 :            :          */
    1601         [ #  # ]:          0 :         if (sq->vq->num_free < 2+MAX_SKB_FRAGS) {
    1602                 :          0 :                 netif_stop_subqueue(dev, qnum);
    1603         [ #  # ]:          0 :                 if (!use_napi &&
    1604         [ #  # ]:          0 :                     unlikely(!virtqueue_enable_cb_delayed(sq->vq))) {
    1605                 :            :                         /* More just got used, free them then recheck. */
    1606                 :          0 :                         free_old_xmit_skbs(sq, false);
    1607         [ #  # ]:          0 :                         if (sq->vq->num_free >= 2+MAX_SKB_FRAGS) {
    1608                 :          0 :                                 netif_start_subqueue(dev, qnum);
    1609                 :          0 :                                 virtqueue_disable_cb(sq->vq);
    1610                 :            :                         }
    1611                 :            :                 }
    1612                 :            :         }
    1613                 :            : 
    1614   [ #  #  #  # ]:          0 :         if (kick || netif_xmit_stopped(txq)) {
    1615   [ #  #  #  # ]:          0 :                 if (virtqueue_kick_prepare(sq->vq) && virtqueue_notify(sq->vq)) {
    1616                 :          0 :                         u64_stats_update_begin(&sq->stats.syncp);
    1617                 :          0 :                         sq->stats.kicks++;
    1618                 :          0 :                         u64_stats_update_end(&sq->stats.syncp);
    1619                 :            :                 }
    1620                 :            :         }
    1621                 :            : 
    1622                 :            :         return NETDEV_TX_OK;
    1623                 :            : }
    1624                 :            : 
    1625                 :            : /*
    1626                 :            :  * Send command via the control virtqueue and check status.  Commands
    1627                 :            :  * supported by the hypervisor, as indicated by feature bits, should
    1628                 :            :  * never fail unless improperly formatted.
    1629                 :            :  */
    1630                 :          0 : static bool virtnet_send_command(struct virtnet_info *vi, u8 class, u8 cmd,
    1631                 :            :                                  struct scatterlist *out)
    1632                 :            : {
    1633                 :          0 :         struct scatterlist *sgs[4], hdr, stat;
    1634                 :          0 :         unsigned out_num = 0, tmp;
    1635                 :            : 
    1636                 :            :         /* Caller should know better */
    1637         [ #  # ]:          0 :         BUG_ON(!virtio_has_feature(vi->vdev, VIRTIO_NET_F_CTRL_VQ));
    1638                 :            : 
    1639                 :          0 :         vi->ctrl->status = ~0;
    1640                 :          0 :         vi->ctrl->hdr.class = class;
    1641                 :          0 :         vi->ctrl->hdr.cmd = cmd;
    1642                 :            :         /* Add header */
    1643                 :          0 :         sg_init_one(&hdr, &vi->ctrl->hdr, sizeof(vi->ctrl->hdr));
    1644                 :          0 :         sgs[out_num++] = &hdr;
    1645                 :            : 
    1646         [ #  # ]:          0 :         if (out)
    1647                 :          0 :                 sgs[out_num++] = out;
    1648                 :            : 
    1649                 :            :         /* Add return status. */
    1650                 :          0 :         sg_init_one(&stat, &vi->ctrl->status, sizeof(vi->ctrl->status));
    1651                 :          0 :         sgs[out_num] = &stat;
    1652                 :            : 
    1653                 :          0 :         BUG_ON(out_num + 1 > ARRAY_SIZE(sgs));
    1654                 :          0 :         virtqueue_add_sgs(vi->cvq, sgs, out_num, 1, vi, GFP_ATOMIC);
    1655                 :            : 
    1656         [ #  # ]:          0 :         if (unlikely(!virtqueue_kick(vi->cvq)))
    1657                 :          0 :                 return vi->ctrl->status == VIRTIO_NET_OK;
    1658                 :            : 
    1659                 :            :         /* Spin for a response, the kick causes an ioport write, trapping
    1660                 :            :          * into the hypervisor, so the request should be handled immediately.
    1661                 :            :          */
    1662   [ #  #  #  # ]:          0 :         while (!virtqueue_get_buf(vi->cvq, &tmp) &&
    1663                 :          0 :                !virtqueue_is_broken(vi->cvq))
    1664                 :          0 :                 cpu_relax();
    1665                 :            : 
    1666                 :          0 :         return vi->ctrl->status == VIRTIO_NET_OK;
    1667                 :            : }
    1668                 :            : 
    1669                 :          0 : static int virtnet_set_mac_address(struct net_device *dev, void *p)
    1670                 :            : {
    1671                 :          0 :         struct virtnet_info *vi = netdev_priv(dev);
    1672                 :          0 :         struct virtio_device *vdev = vi->vdev;
    1673                 :          0 :         int ret;
    1674                 :          0 :         struct sockaddr *addr;
    1675                 :          0 :         struct scatterlist sg;
    1676                 :            : 
    1677         [ #  # ]:          0 :         if (virtio_has_feature(vi->vdev, VIRTIO_NET_F_STANDBY))
    1678                 :            :                 return -EOPNOTSUPP;
    1679                 :            : 
    1680                 :          0 :         addr = kmemdup(p, sizeof(*addr), GFP_KERNEL);
    1681         [ #  # ]:          0 :         if (!addr)
    1682                 :            :                 return -ENOMEM;
    1683                 :            : 
    1684                 :          0 :         ret = eth_prepare_mac_addr_change(dev, addr);
    1685         [ #  # ]:          0 :         if (ret)
    1686                 :          0 :                 goto out;
    1687                 :            : 
    1688         [ #  # ]:          0 :         if (virtio_has_feature(vdev, VIRTIO_NET_F_CTRL_MAC_ADDR)) {
    1689                 :          0 :                 sg_init_one(&sg, addr->sa_data, dev->addr_len);
    1690         [ #  # ]:          0 :                 if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_MAC,
    1691                 :            :                                           VIRTIO_NET_CTRL_MAC_ADDR_SET, &sg)) {
    1692                 :          0 :                         dev_warn(&vdev->dev,
    1693                 :            :                                  "Failed to set mac address by vq command.\n");
    1694                 :          0 :                         ret = -EINVAL;
    1695                 :          0 :                         goto out;
    1696                 :            :                 }
    1697   [ #  #  #  # ]:          0 :         } else if (virtio_has_feature(vdev, VIRTIO_NET_F_MAC) &&
    1698                 :            :                    !virtio_has_feature(vdev, VIRTIO_F_VERSION_1)) {
    1699                 :            :                 unsigned int i;
    1700                 :            : 
    1701                 :            :                 /* Naturally, this has an atomicity problem. */
    1702         [ #  # ]:          0 :                 for (i = 0; i < dev->addr_len; i++)
    1703                 :          0 :                         virtio_cwrite8(vdev,
    1704                 :            :                                        offsetof(struct virtio_net_config, mac) +
    1705                 :          0 :                                        i, addr->sa_data[i]);
    1706                 :            :         }
    1707                 :            : 
    1708                 :          0 :         eth_commit_mac_addr_change(dev, p);
    1709                 :          0 :         ret = 0;
    1710                 :            : 
    1711                 :          0 : out:
    1712                 :          0 :         kfree(addr);
    1713                 :          0 :         return ret;
    1714                 :            : }
    1715                 :            : 
    1716                 :          0 : static void virtnet_stats(struct net_device *dev,
    1717                 :            :                           struct rtnl_link_stats64 *tot)
    1718                 :            : {
    1719                 :          0 :         struct virtnet_info *vi = netdev_priv(dev);
    1720                 :          0 :         unsigned int start;
    1721                 :          0 :         int i;
    1722                 :            : 
    1723         [ #  # ]:          0 :         for (i = 0; i < vi->max_queue_pairs; i++) {
    1724                 :          0 :                 u64 tpackets, tbytes, rpackets, rbytes, rdrops;
    1725                 :          0 :                 struct receive_queue *rq = &vi->rq[i];
    1726                 :          0 :                 struct send_queue *sq = &vi->sq[i];
    1727                 :            : 
    1728                 :          0 :                 do {
    1729                 :          0 :                         start = u64_stats_fetch_begin_irq(&sq->stats.syncp);
    1730                 :          0 :                         tpackets = sq->stats.packets;
    1731                 :          0 :                         tbytes   = sq->stats.bytes;
    1732                 :          0 :                 } while (u64_stats_fetch_retry_irq(&sq->stats.syncp, start));
    1733                 :            : 
    1734                 :          0 :                 do {
    1735                 :          0 :                         start = u64_stats_fetch_begin_irq(&rq->stats.syncp);
    1736                 :          0 :                         rpackets = rq->stats.packets;
    1737                 :          0 :                         rbytes   = rq->stats.bytes;
    1738                 :          0 :                         rdrops   = rq->stats.drops;
    1739                 :          0 :                 } while (u64_stats_fetch_retry_irq(&rq->stats.syncp, start));
    1740                 :            : 
    1741                 :          0 :                 tot->rx_packets += rpackets;
    1742                 :          0 :                 tot->tx_packets += tpackets;
    1743                 :          0 :                 tot->rx_bytes   += rbytes;
    1744                 :          0 :                 tot->tx_bytes   += tbytes;
    1745                 :          0 :                 tot->rx_dropped += rdrops;
    1746                 :            :         }
    1747                 :            : 
    1748                 :          0 :         tot->tx_dropped = dev->stats.tx_dropped;
    1749                 :          0 :         tot->tx_fifo_errors = dev->stats.tx_fifo_errors;
    1750                 :          0 :         tot->rx_length_errors = dev->stats.rx_length_errors;
    1751                 :          0 :         tot->rx_frame_errors = dev->stats.rx_frame_errors;
    1752                 :          0 : }
    1753                 :            : 
    1754                 :          0 : static void virtnet_ack_link_announce(struct virtnet_info *vi)
    1755                 :            : {
    1756                 :          0 :         rtnl_lock();
    1757         [ #  # ]:          0 :         if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_ANNOUNCE,
    1758                 :            :                                   VIRTIO_NET_CTRL_ANNOUNCE_ACK, NULL))
    1759                 :          0 :                 dev_warn(&vi->dev->dev, "Failed to ack link announce.\n");
    1760                 :          0 :         rtnl_unlock();
    1761                 :          0 : }
    1762                 :            : 
    1763                 :          0 : static int _virtnet_set_queues(struct virtnet_info *vi, u16 queue_pairs)
    1764                 :            : {
    1765                 :          0 :         struct scatterlist sg;
    1766                 :          0 :         struct net_device *dev = vi->dev;
    1767                 :            : 
    1768   [ #  #  #  # ]:          0 :         if (!vi->has_cvq || !virtio_has_feature(vi->vdev, VIRTIO_NET_F_MQ))
    1769                 :          0 :                 return 0;
    1770                 :            : 
    1771                 :          0 :         vi->ctrl->mq.virtqueue_pairs = cpu_to_virtio16(vi->vdev, queue_pairs);
    1772                 :          0 :         sg_init_one(&sg, &vi->ctrl->mq, sizeof(vi->ctrl->mq));
    1773                 :            : 
    1774         [ #  # ]:          0 :         if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_MQ,
    1775                 :            :                                   VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET, &sg)) {
    1776                 :          0 :                 dev_warn(&dev->dev, "Fail to set num of queue pairs to %d\n",
    1777                 :            :                          queue_pairs);
    1778                 :          0 :                 return -EINVAL;
    1779                 :            :         } else {
    1780                 :          0 :                 vi->curr_queue_pairs = queue_pairs;
    1781                 :            :                 /* virtnet_open() will refill when device is going to up. */
    1782         [ #  # ]:          0 :                 if (dev->flags & IFF_UP)
    1783                 :          0 :                         schedule_delayed_work(&vi->refill, 0);
    1784                 :            :         }
    1785                 :            : 
    1786                 :            :         return 0;
    1787                 :            : }
    1788                 :            : 
    1789                 :          0 : static int virtnet_set_queues(struct virtnet_info *vi, u16 queue_pairs)
    1790                 :            : {
    1791                 :          0 :         int err;
    1792                 :            : 
    1793                 :          0 :         rtnl_lock();
    1794                 :          0 :         err = _virtnet_set_queues(vi, queue_pairs);
    1795                 :          0 :         rtnl_unlock();
    1796                 :          0 :         return err;
    1797                 :            : }
    1798                 :            : 
    1799                 :          0 : static int virtnet_close(struct net_device *dev)
    1800                 :            : {
    1801                 :          0 :         struct virtnet_info *vi = netdev_priv(dev);
    1802                 :          0 :         int i;
    1803                 :            : 
    1804                 :            :         /* Make sure refill_work doesn't re-enable napi! */
    1805                 :          0 :         cancel_delayed_work_sync(&vi->refill);
    1806                 :            : 
    1807         [ #  # ]:          0 :         for (i = 0; i < vi->max_queue_pairs; i++) {
    1808                 :          0 :                 xdp_rxq_info_unreg(&vi->rq[i].xdp_rxq);
    1809                 :          0 :                 napi_disable(&vi->rq[i].napi);
    1810         [ #  # ]:          0 :                 virtnet_napi_tx_disable(&vi->sq[i].napi);
    1811                 :            :         }
    1812                 :            : 
    1813                 :          0 :         return 0;
    1814                 :            : }
    1815                 :            : 
    1816                 :          0 : static void virtnet_set_rx_mode(struct net_device *dev)
    1817                 :            : {
    1818                 :          0 :         struct virtnet_info *vi = netdev_priv(dev);
    1819                 :          0 :         struct scatterlist sg[2];
    1820                 :          0 :         struct virtio_net_ctrl_mac *mac_data;
    1821                 :          0 :         struct netdev_hw_addr *ha;
    1822                 :          0 :         int uc_count;
    1823                 :          0 :         int mc_count;
    1824                 :          0 :         void *buf;
    1825                 :          0 :         int i;
    1826                 :            : 
    1827                 :            :         /* We can't dynamically set ndo_set_rx_mode, so return gracefully */
    1828         [ #  # ]:          0 :         if (!virtio_has_feature(vi->vdev, VIRTIO_NET_F_CTRL_RX))
    1829                 :          0 :                 return;
    1830                 :            : 
    1831                 :          0 :         vi->ctrl->promisc = ((dev->flags & IFF_PROMISC) != 0);
    1832                 :          0 :         vi->ctrl->allmulti = ((dev->flags & IFF_ALLMULTI) != 0);
    1833                 :            : 
    1834                 :          0 :         sg_init_one(sg, &vi->ctrl->promisc, sizeof(vi->ctrl->promisc));
    1835                 :            : 
    1836         [ #  # ]:          0 :         if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_RX,
    1837                 :            :                                   VIRTIO_NET_CTRL_RX_PROMISC, sg))
    1838         [ #  # ]:          0 :                 dev_warn(&dev->dev, "Failed to %sable promisc mode.\n",
    1839                 :            :                          vi->ctrl->promisc ? "en" : "dis");
    1840                 :            : 
    1841                 :          0 :         sg_init_one(sg, &vi->ctrl->allmulti, sizeof(vi->ctrl->allmulti));
    1842                 :            : 
    1843         [ #  # ]:          0 :         if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_RX,
    1844                 :            :                                   VIRTIO_NET_CTRL_RX_ALLMULTI, sg))
    1845         [ #  # ]:          0 :                 dev_warn(&dev->dev, "Failed to %sable allmulti mode.\n",
    1846                 :            :                          vi->ctrl->allmulti ? "en" : "dis");
    1847                 :            : 
    1848                 :          0 :         uc_count = netdev_uc_count(dev);
    1849                 :          0 :         mc_count = netdev_mc_count(dev);
    1850                 :            :         /* MAC filter - use one buffer for both lists */
    1851                 :          0 :         buf = kzalloc(((uc_count + mc_count) * ETH_ALEN) +
    1852                 :            :                       (2 * sizeof(mac_data->entries)), GFP_ATOMIC);
    1853                 :          0 :         mac_data = buf;
    1854         [ #  # ]:          0 :         if (!buf)
    1855                 :            :                 return;
    1856                 :            : 
    1857                 :          0 :         sg_init_table(sg, 2);
    1858                 :            : 
    1859                 :            :         /* Store the unicast list and count in the front of the buffer */
    1860                 :          0 :         mac_data->entries = cpu_to_virtio32(vi->vdev, uc_count);
    1861                 :          0 :         i = 0;
    1862         [ #  # ]:          0 :         netdev_for_each_uc_addr(ha, dev)
    1863                 :          0 :                 memcpy(&mac_data->macs[i++][0], ha->addr, ETH_ALEN);
    1864                 :            : 
    1865                 :          0 :         sg_set_buf(&sg[0], mac_data,
    1866                 :          0 :                    sizeof(mac_data->entries) + (uc_count * ETH_ALEN));
    1867                 :            : 
    1868                 :            :         /* multicast list and count fill the end */
    1869                 :          0 :         mac_data = (void *)&mac_data->macs[uc_count][0];
    1870                 :            : 
    1871                 :          0 :         mac_data->entries = cpu_to_virtio32(vi->vdev, mc_count);
    1872                 :          0 :         i = 0;
    1873         [ #  # ]:          0 :         netdev_for_each_mc_addr(ha, dev)
    1874                 :          0 :                 memcpy(&mac_data->macs[i++][0], ha->addr, ETH_ALEN);
    1875                 :            : 
    1876                 :          0 :         sg_set_buf(&sg[1], mac_data,
    1877                 :          0 :                    sizeof(mac_data->entries) + (mc_count * ETH_ALEN));
    1878                 :            : 
    1879         [ #  # ]:          0 :         if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_MAC,
    1880                 :            :                                   VIRTIO_NET_CTRL_MAC_TABLE_SET, sg))
    1881                 :          0 :                 dev_warn(&dev->dev, "Failed to set MAC filter table.\n");
    1882                 :            : 
    1883                 :          0 :         kfree(buf);
    1884                 :            : }
    1885                 :            : 
    1886                 :          0 : static int virtnet_vlan_rx_add_vid(struct net_device *dev,
    1887                 :            :                                    __be16 proto, u16 vid)
    1888                 :            : {
    1889                 :          0 :         struct virtnet_info *vi = netdev_priv(dev);
    1890                 :          0 :         struct scatterlist sg;
    1891                 :            : 
    1892                 :          0 :         vi->ctrl->vid = cpu_to_virtio16(vi->vdev, vid);
    1893                 :          0 :         sg_init_one(&sg, &vi->ctrl->vid, sizeof(vi->ctrl->vid));
    1894                 :            : 
    1895         [ #  # ]:          0 :         if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_VLAN,
    1896                 :            :                                   VIRTIO_NET_CTRL_VLAN_ADD, &sg))
    1897                 :          0 :                 dev_warn(&dev->dev, "Failed to add VLAN ID %d.\n", vid);
    1898                 :          0 :         return 0;
    1899                 :            : }
    1900                 :            : 
    1901                 :          0 : static int virtnet_vlan_rx_kill_vid(struct net_device *dev,
    1902                 :            :                                     __be16 proto, u16 vid)
    1903                 :            : {
    1904                 :          0 :         struct virtnet_info *vi = netdev_priv(dev);
    1905                 :          0 :         struct scatterlist sg;
    1906                 :            : 
    1907                 :          0 :         vi->ctrl->vid = cpu_to_virtio16(vi->vdev, vid);
    1908                 :          0 :         sg_init_one(&sg, &vi->ctrl->vid, sizeof(vi->ctrl->vid));
    1909                 :            : 
    1910         [ #  # ]:          0 :         if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_VLAN,
    1911                 :            :                                   VIRTIO_NET_CTRL_VLAN_DEL, &sg))
    1912                 :          0 :                 dev_warn(&dev->dev, "Failed to kill VLAN ID %d.\n", vid);
    1913                 :          0 :         return 0;
    1914                 :            : }
    1915                 :            : 
    1916                 :          0 : static void virtnet_clean_affinity(struct virtnet_info *vi)
    1917                 :            : {
    1918                 :          0 :         int i;
    1919                 :            : 
    1920         [ #  # ]:          0 :         if (vi->affinity_hint_set) {
    1921         [ #  # ]:          0 :                 for (i = 0; i < vi->max_queue_pairs; i++) {
    1922         [ #  # ]:          0 :                         virtqueue_set_affinity(vi->rq[i].vq, NULL);
    1923         [ #  # ]:          0 :                         virtqueue_set_affinity(vi->sq[i].vq, NULL);
    1924                 :            :                 }
    1925                 :            : 
    1926                 :          0 :                 vi->affinity_hint_set = false;
    1927                 :            :         }
    1928                 :          0 : }
    1929                 :            : 
    1930                 :          0 : static void virtnet_set_affinity(struct virtnet_info *vi)
    1931                 :            : {
    1932                 :          0 :         cpumask_var_t mask;
    1933                 :          0 :         int stragglers;
    1934                 :          0 :         int group_size;
    1935                 :          0 :         int i, j, cpu;
    1936                 :          0 :         int num_cpu;
    1937                 :          0 :         int stride;
    1938                 :            : 
    1939                 :          0 :         if (!zalloc_cpumask_var(&mask, GFP_KERNEL)) {
    1940                 :            :                 virtnet_clean_affinity(vi);
    1941                 :            :                 return;
    1942                 :            :         }
    1943                 :            : 
    1944                 :          0 :         num_cpu = num_online_cpus();
    1945                 :          0 :         stride = max_t(int, num_cpu / vi->curr_queue_pairs, 1);
    1946                 :          0 :         stragglers = num_cpu >= vi->curr_queue_pairs ?
    1947         [ #  # ]:          0 :                         num_cpu % vi->curr_queue_pairs :
    1948                 :            :                         0;
    1949                 :          0 :         cpu = cpumask_next(-1, cpu_online_mask);
    1950                 :            : 
    1951         [ #  # ]:          0 :         for (i = 0; i < vi->curr_queue_pairs; i++) {
    1952                 :          0 :                 group_size = stride + (i < stragglers ? 1 : 0);
    1953                 :            : 
    1954         [ #  # ]:          0 :                 for (j = 0; j < group_size; j++) {
    1955                 :          0 :                         cpumask_set_cpu(cpu, mask);
    1956                 :          0 :                         cpu = cpumask_next_wrap(cpu, cpu_online_mask,
    1957                 :            :                                                 nr_cpu_ids, false);
    1958                 :            :                 }
    1959         [ #  # ]:          0 :                 virtqueue_set_affinity(vi->rq[i].vq, mask);
    1960         [ #  # ]:          0 :                 virtqueue_set_affinity(vi->sq[i].vq, mask);
    1961                 :          0 :                 __netif_set_xps_queue(vi->dev, cpumask_bits(mask), i, false);
    1962                 :          0 :                 cpumask_clear(mask);
    1963                 :            :         }
    1964                 :            : 
    1965                 :          0 :         vi->affinity_hint_set = true;
    1966                 :          0 :         free_cpumask_var(mask);
    1967                 :            : }
    1968                 :            : 
    1969                 :          0 : static int virtnet_cpu_online(unsigned int cpu, struct hlist_node *node)
    1970                 :            : {
    1971         [ #  # ]:          0 :         struct virtnet_info *vi = hlist_entry_safe(node, struct virtnet_info,
    1972                 :            :                                                    node);
    1973                 :          0 :         virtnet_set_affinity(vi);
    1974                 :          0 :         return 0;
    1975                 :            : }
    1976                 :            : 
    1977                 :          0 : static int virtnet_cpu_dead(unsigned int cpu, struct hlist_node *node)
    1978                 :            : {
    1979         [ #  # ]:          0 :         struct virtnet_info *vi = hlist_entry_safe(node, struct virtnet_info,
    1980                 :            :                                                    node_dead);
    1981                 :          0 :         virtnet_set_affinity(vi);
    1982                 :          0 :         return 0;
    1983                 :            : }
    1984                 :            : 
    1985                 :          0 : static int virtnet_cpu_down_prep(unsigned int cpu, struct hlist_node *node)
    1986                 :            : {
    1987         [ #  # ]:          0 :         struct virtnet_info *vi = hlist_entry_safe(node, struct virtnet_info,
    1988                 :            :                                                    node);
    1989                 :            : 
    1990                 :          0 :         virtnet_clean_affinity(vi);
    1991                 :          0 :         return 0;
    1992                 :            : }
    1993                 :            : 
    1994                 :            : static enum cpuhp_state virtionet_online;
    1995                 :            : 
    1996                 :          0 : static int virtnet_cpu_notif_add(struct virtnet_info *vi)
    1997                 :            : {
    1998                 :          0 :         int ret;
    1999                 :            : 
    2000                 :          0 :         ret = cpuhp_state_add_instance_nocalls(virtionet_online, &vi->node);
    2001         [ #  # ]:          0 :         if (ret)
    2002                 :            :                 return ret;
    2003                 :          0 :         ret = cpuhp_state_add_instance_nocalls(CPUHP_VIRT_NET_DEAD,
    2004                 :            :                                                &vi->node_dead);
    2005         [ #  # ]:          0 :         if (!ret)
    2006                 :            :                 return ret;
    2007                 :          0 :         cpuhp_state_remove_instance_nocalls(virtionet_online, &vi->node);
    2008                 :          0 :         return ret;
    2009                 :            : }
    2010                 :            : 
    2011                 :          0 : static void virtnet_cpu_notif_remove(struct virtnet_info *vi)
    2012                 :            : {
    2013                 :          0 :         cpuhp_state_remove_instance_nocalls(virtionet_online, &vi->node);
    2014                 :          0 :         cpuhp_state_remove_instance_nocalls(CPUHP_VIRT_NET_DEAD,
    2015                 :            :                                             &vi->node_dead);
    2016                 :          0 : }
    2017                 :            : 
    2018                 :          0 : static void virtnet_get_ringparam(struct net_device *dev,
    2019                 :            :                                 struct ethtool_ringparam *ring)
    2020                 :            : {
    2021                 :          0 :         struct virtnet_info *vi = netdev_priv(dev);
    2022                 :            : 
    2023                 :          0 :         ring->rx_max_pending = virtqueue_get_vring_size(vi->rq[0].vq);
    2024                 :          0 :         ring->tx_max_pending = virtqueue_get_vring_size(vi->sq[0].vq);
    2025                 :          0 :         ring->rx_pending = ring->rx_max_pending;
    2026                 :          0 :         ring->tx_pending = ring->tx_max_pending;
    2027                 :          0 : }
    2028                 :            : 
    2029                 :            : 
    2030                 :          0 : static void virtnet_get_drvinfo(struct net_device *dev,
    2031                 :            :                                 struct ethtool_drvinfo *info)
    2032                 :            : {
    2033                 :          0 :         struct virtnet_info *vi = netdev_priv(dev);
    2034                 :          0 :         struct virtio_device *vdev = vi->vdev;
    2035                 :            : 
    2036                 :          0 :         strlcpy(info->driver, KBUILD_MODNAME, sizeof(info->driver));
    2037                 :          0 :         strlcpy(info->version, VIRTNET_DRIVER_VERSION, sizeof(info->version));
    2038         [ #  # ]:          0 :         strlcpy(info->bus_info, virtio_bus_name(vdev), sizeof(info->bus_info));
    2039                 :            : 
    2040                 :          0 : }
    2041                 :            : 
    2042                 :            : /* TODO: Eliminate OOO packets during switching */
    2043                 :          0 : static int virtnet_set_channels(struct net_device *dev,
    2044                 :            :                                 struct ethtool_channels *channels)
    2045                 :            : {
    2046         [ #  # ]:          0 :         struct virtnet_info *vi = netdev_priv(dev);
    2047                 :          0 :         u16 queue_pairs = channels->combined_count;
    2048                 :          0 :         int err;
    2049                 :            : 
    2050                 :            :         /* We don't support separate rx/tx channels.
    2051                 :            :          * We don't allow setting 'other' channels.
    2052                 :            :          */
    2053   [ #  #  #  #  :          0 :         if (channels->rx_count || channels->tx_count || channels->other_count)
                   #  # ]
    2054                 :            :                 return -EINVAL;
    2055                 :            : 
    2056   [ #  #  #  # ]:          0 :         if (queue_pairs > vi->max_queue_pairs || queue_pairs == 0)
    2057                 :            :                 return -EINVAL;
    2058                 :            : 
    2059                 :            :         /* For now we don't support modifying channels while XDP is loaded
    2060                 :            :          * also when XDP is loaded all RX queues have XDP programs so we only
    2061                 :            :          * need to check a single RX queue.
    2062                 :            :          */
    2063         [ #  # ]:          0 :         if (vi->rq[0].xdp_prog)
    2064                 :            :                 return -EINVAL;
    2065                 :            : 
    2066                 :          0 :         get_online_cpus();
    2067                 :          0 :         err = _virtnet_set_queues(vi, queue_pairs);
    2068         [ #  # ]:          0 :         if (!err) {
    2069                 :          0 :                 netif_set_real_num_tx_queues(dev, queue_pairs);
    2070                 :          0 :                 netif_set_real_num_rx_queues(dev, queue_pairs);
    2071                 :            : 
    2072                 :          0 :                 virtnet_set_affinity(vi);
    2073                 :            :         }
    2074                 :          0 :         put_online_cpus();
    2075                 :            : 
    2076                 :          0 :         return err;
    2077                 :            : }
    2078                 :            : 
    2079                 :          0 : static void virtnet_get_strings(struct net_device *dev, u32 stringset, u8 *data)
    2080                 :            : {
    2081         [ #  # ]:          0 :         struct virtnet_info *vi = netdev_priv(dev);
    2082                 :          0 :         char *p = (char *)data;
    2083                 :          0 :         unsigned int i, j;
    2084                 :            : 
    2085         [ #  # ]:          0 :         switch (stringset) {
    2086                 :            :         case ETH_SS_STATS:
    2087         [ #  # ]:          0 :                 for (i = 0; i < vi->curr_queue_pairs; i++) {
    2088         [ #  # ]:          0 :                         for (j = 0; j < VIRTNET_RQ_STATS_LEN; j++) {
    2089                 :          0 :                                 snprintf(p, ETH_GSTRING_LEN, "rx_queue_%u_%s",
    2090                 :          0 :                                          i, virtnet_rq_stats_desc[j].desc);
    2091                 :          0 :                                 p += ETH_GSTRING_LEN;
    2092                 :            :                         }
    2093                 :            :                 }
    2094                 :            : 
    2095         [ #  # ]:          0 :                 for (i = 0; i < vi->curr_queue_pairs; i++) {
    2096         [ #  # ]:          0 :                         for (j = 0; j < VIRTNET_SQ_STATS_LEN; j++) {
    2097                 :          0 :                                 snprintf(p, ETH_GSTRING_LEN, "tx_queue_%u_%s",
    2098                 :          0 :                                          i, virtnet_sq_stats_desc[j].desc);
    2099                 :          0 :                                 p += ETH_GSTRING_LEN;
    2100                 :            :                         }
    2101                 :            :                 }
    2102                 :            :                 break;
    2103                 :            :         }
    2104                 :          0 : }
    2105                 :            : 
    2106                 :          0 : static int virtnet_get_sset_count(struct net_device *dev, int sset)
    2107                 :            : {
    2108         [ #  # ]:          0 :         struct virtnet_info *vi = netdev_priv(dev);
    2109                 :            : 
    2110         [ #  # ]:          0 :         switch (sset) {
    2111                 :          0 :         case ETH_SS_STATS:
    2112                 :          0 :                 return vi->curr_queue_pairs * (VIRTNET_RQ_STATS_LEN +
    2113                 :            :                                                VIRTNET_SQ_STATS_LEN);
    2114                 :            :         default:
    2115                 :            :                 return -EOPNOTSUPP;
    2116                 :            :         }
    2117                 :            : }
    2118                 :            : 
    2119                 :          0 : static void virtnet_get_ethtool_stats(struct net_device *dev,
    2120                 :            :                                       struct ethtool_stats *stats, u64 *data)
    2121                 :            : {
    2122                 :          0 :         struct virtnet_info *vi = netdev_priv(dev);
    2123                 :          0 :         unsigned int idx = 0, start, i, j;
    2124                 :          0 :         const u8 *stats_base;
    2125                 :          0 :         size_t offset;
    2126                 :            : 
    2127         [ #  # ]:          0 :         for (i = 0; i < vi->curr_queue_pairs; i++) {
    2128                 :          0 :                 struct receive_queue *rq = &vi->rq[i];
    2129                 :            : 
    2130                 :          0 :                 stats_base = (u8 *)&rq->stats;
    2131                 :          0 :                 do {
    2132                 :          0 :                         start = u64_stats_fetch_begin_irq(&rq->stats.syncp);
    2133         [ #  # ]:          0 :                         for (j = 0; j < VIRTNET_RQ_STATS_LEN; j++) {
    2134                 :          0 :                                 offset = virtnet_rq_stats_desc[j].offset;
    2135                 :          0 :                                 data[idx + j] = *(u64 *)(stats_base + offset);
    2136                 :            :                         }
    2137                 :          0 :                 } while (u64_stats_fetch_retry_irq(&rq->stats.syncp, start));
    2138                 :          0 :                 idx += VIRTNET_RQ_STATS_LEN;
    2139                 :            :         }
    2140                 :            : 
    2141         [ #  # ]:          0 :         for (i = 0; i < vi->curr_queue_pairs; i++) {
    2142                 :          0 :                 struct send_queue *sq = &vi->sq[i];
    2143                 :            : 
    2144                 :          0 :                 stats_base = (u8 *)&sq->stats;
    2145                 :          0 :                 do {
    2146                 :          0 :                         start = u64_stats_fetch_begin_irq(&sq->stats.syncp);
    2147         [ #  # ]:          0 :                         for (j = 0; j < VIRTNET_SQ_STATS_LEN; j++) {
    2148                 :          0 :                                 offset = virtnet_sq_stats_desc[j].offset;
    2149                 :          0 :                                 data[idx + j] = *(u64 *)(stats_base + offset);
    2150                 :            :                         }
    2151                 :          0 :                 } while (u64_stats_fetch_retry_irq(&sq->stats.syncp, start));
    2152                 :          0 :                 idx += VIRTNET_SQ_STATS_LEN;
    2153                 :            :         }
    2154                 :          0 : }
    2155                 :            : 
    2156                 :          0 : static void virtnet_get_channels(struct net_device *dev,
    2157                 :            :                                  struct ethtool_channels *channels)
    2158                 :            : {
    2159                 :          0 :         struct virtnet_info *vi = netdev_priv(dev);
    2160                 :            : 
    2161                 :          0 :         channels->combined_count = vi->curr_queue_pairs;
    2162                 :          0 :         channels->max_combined = vi->max_queue_pairs;
    2163                 :          0 :         channels->max_other = 0;
    2164                 :          0 :         channels->rx_count = 0;
    2165                 :          0 :         channels->tx_count = 0;
    2166                 :          0 :         channels->other_count = 0;
    2167                 :          0 : }
    2168                 :            : 
    2169                 :            : /* Check if the user is trying to change anything besides speed/duplex */
    2170                 :            : static bool
    2171                 :          0 : virtnet_validate_ethtool_cmd(const struct ethtool_link_ksettings *cmd)
    2172                 :            : {
    2173                 :          0 :         struct ethtool_link_ksettings diff1 = *cmd;
    2174                 :          0 :         struct ethtool_link_ksettings diff2 = {};
    2175                 :            : 
    2176                 :            :         /* cmd is always set so we need to clear it, validate the port type
    2177                 :            :          * and also without autonegotiation we can ignore advertising
    2178                 :            :          */
    2179                 :          0 :         diff1.base.speed = 0;
    2180                 :          0 :         diff2.base.port = PORT_OTHER;
    2181         [ #  # ]:          0 :         ethtool_link_ksettings_zero_link_mode(&diff1, advertising);
    2182                 :          0 :         diff1.base.duplex = 0;
    2183                 :          0 :         diff1.base.cmd = 0;
    2184                 :          0 :         diff1.base.link_mode_masks_nwords = 0;
    2185                 :            : 
    2186         [ #  # ]:          0 :         return !memcmp(&diff1.base, &diff2.base, sizeof(diff1.base)) &&
    2187                 :            :                 bitmap_empty(diff1.link_modes.supported,
    2188         [ #  # ]:          0 :                              __ETHTOOL_LINK_MODE_MASK_NBITS) &&
    2189                 :            :                 bitmap_empty(diff1.link_modes.advertising,
    2190   [ #  #  #  # ]:          0 :                              __ETHTOOL_LINK_MODE_MASK_NBITS) &&
    2191                 :            :                 bitmap_empty(diff1.link_modes.lp_advertising,
    2192                 :            :                              __ETHTOOL_LINK_MODE_MASK_NBITS);
    2193                 :            : }
    2194                 :            : 
    2195                 :          0 : static int virtnet_set_link_ksettings(struct net_device *dev,
    2196                 :            :                                       const struct ethtool_link_ksettings *cmd)
    2197                 :            : {
    2198         [ #  # ]:          0 :         struct virtnet_info *vi = netdev_priv(dev);
    2199                 :          0 :         u32 speed;
    2200                 :            : 
    2201                 :          0 :         speed = cmd->base.speed;
    2202                 :            :         /* don't allow custom speed and duplex */
    2203         [ #  # ]:          0 :         if (!ethtool_validate_speed(speed) ||
    2204   [ #  #  #  # ]:          0 :             !ethtool_validate_duplex(cmd->base.duplex) ||
    2205                 :          0 :             !virtnet_validate_ethtool_cmd(cmd))
    2206                 :          0 :                 return -EINVAL;
    2207                 :          0 :         vi->speed = speed;
    2208                 :          0 :         vi->duplex = cmd->base.duplex;
    2209                 :            : 
    2210                 :          0 :         return 0;
    2211                 :            : }
    2212                 :            : 
    2213                 :          0 : static int virtnet_get_link_ksettings(struct net_device *dev,
    2214                 :            :                                       struct ethtool_link_ksettings *cmd)
    2215                 :            : {
    2216                 :          0 :         struct virtnet_info *vi = netdev_priv(dev);
    2217                 :            : 
    2218                 :          0 :         cmd->base.speed = vi->speed;
    2219                 :          0 :         cmd->base.duplex = vi->duplex;
    2220                 :          0 :         cmd->base.port = PORT_OTHER;
    2221                 :            : 
    2222                 :          0 :         return 0;
    2223                 :            : }
    2224                 :            : 
    2225                 :          0 : static int virtnet_set_coalesce(struct net_device *dev,
    2226                 :            :                                 struct ethtool_coalesce *ec)
    2227                 :            : {
    2228                 :          0 :         struct ethtool_coalesce ec_default = {
    2229                 :            :                 .cmd = ETHTOOL_SCOALESCE,
    2230                 :            :                 .rx_max_coalesced_frames = 1,
    2231                 :            :         };
    2232         [ #  # ]:          0 :         struct virtnet_info *vi = netdev_priv(dev);
    2233                 :          0 :         int i, napi_weight;
    2234                 :            : 
    2235         [ #  # ]:          0 :         if (ec->tx_max_coalesced_frames > 1)
    2236                 :            :                 return -EINVAL;
    2237                 :            : 
    2238                 :          0 :         ec_default.tx_max_coalesced_frames = ec->tx_max_coalesced_frames;
    2239         [ #  # ]:          0 :         napi_weight = ec->tx_max_coalesced_frames ? NAPI_POLL_WEIGHT : 0;
    2240                 :            : 
    2241                 :            :         /* disallow changes to fields not explicitly tested above */
    2242         [ #  # ]:          0 :         if (memcmp(ec, &ec_default, sizeof(ec_default)))
    2243                 :            :                 return -EINVAL;
    2244                 :            : 
    2245         [ #  # ]:          0 :         if (napi_weight ^ vi->sq[0].napi.weight) {
    2246         [ #  # ]:          0 :                 if (dev->flags & IFF_UP)
    2247                 :            :                         return -EBUSY;
    2248         [ #  # ]:          0 :                 for (i = 0; i < vi->max_queue_pairs; i++)
    2249                 :          0 :                         vi->sq[i].napi.weight = napi_weight;
    2250                 :            :         }
    2251                 :            : 
    2252                 :            :         return 0;
    2253                 :            : }
    2254                 :            : 
    2255                 :          0 : static int virtnet_get_coalesce(struct net_device *dev,
    2256                 :            :                                 struct ethtool_coalesce *ec)
    2257                 :            : {
    2258                 :          0 :         struct ethtool_coalesce ec_default = {
    2259                 :            :                 .cmd = ETHTOOL_GCOALESCE,
    2260                 :            :                 .rx_max_coalesced_frames = 1,
    2261                 :            :         };
    2262         [ #  # ]:          0 :         struct virtnet_info *vi = netdev_priv(dev);
    2263                 :            : 
    2264                 :          0 :         memcpy(ec, &ec_default, sizeof(ec_default));
    2265                 :            : 
    2266         [ #  # ]:          0 :         if (vi->sq[0].napi.weight)
    2267                 :          0 :                 ec->tx_max_coalesced_frames = 1;
    2268                 :            : 
    2269                 :          0 :         return 0;
    2270                 :            : }
    2271                 :            : 
    2272                 :          0 : static void virtnet_init_settings(struct net_device *dev)
    2273                 :            : {
    2274                 :          0 :         struct virtnet_info *vi = netdev_priv(dev);
    2275                 :            : 
    2276                 :          0 :         vi->speed = SPEED_UNKNOWN;
    2277                 :          0 :         vi->duplex = DUPLEX_UNKNOWN;
    2278                 :            : }
    2279                 :            : 
    2280                 :          0 : static void virtnet_update_settings(struct virtnet_info *vi)
    2281                 :            : {
    2282                 :          0 :         u32 speed;
    2283                 :          0 :         u8 duplex;
    2284                 :            : 
    2285         [ #  # ]:          0 :         if (!virtio_has_feature(vi->vdev, VIRTIO_NET_F_SPEED_DUPLEX))
    2286                 :            :                 return;
    2287                 :            : 
    2288                 :          0 :         speed = virtio_cread32(vi->vdev, offsetof(struct virtio_net_config,
    2289                 :            :                                                   speed));
    2290         [ #  # ]:          0 :         if (ethtool_validate_speed(speed))
    2291                 :          0 :                 vi->speed = speed;
    2292                 :          0 :         duplex = virtio_cread8(vi->vdev, offsetof(struct virtio_net_config,
    2293                 :            :                                                   duplex));
    2294         [ #  # ]:          0 :         if (ethtool_validate_duplex(duplex))
    2295                 :          0 :                 vi->duplex = duplex;
    2296                 :            : }
    2297                 :            : 
    2298                 :            : static const struct ethtool_ops virtnet_ethtool_ops = {
    2299                 :            :         .get_drvinfo = virtnet_get_drvinfo,
    2300                 :            :         .get_link = ethtool_op_get_link,
    2301                 :            :         .get_ringparam = virtnet_get_ringparam,
    2302                 :            :         .get_strings = virtnet_get_strings,
    2303                 :            :         .get_sset_count = virtnet_get_sset_count,
    2304                 :            :         .get_ethtool_stats = virtnet_get_ethtool_stats,
    2305                 :            :         .set_channels = virtnet_set_channels,
    2306                 :            :         .get_channels = virtnet_get_channels,
    2307                 :            :         .get_ts_info = ethtool_op_get_ts_info,
    2308                 :            :         .get_link_ksettings = virtnet_get_link_ksettings,
    2309                 :            :         .set_link_ksettings = virtnet_set_link_ksettings,
    2310                 :            :         .set_coalesce = virtnet_set_coalesce,
    2311                 :            :         .get_coalesce = virtnet_get_coalesce,
    2312                 :            : };
    2313                 :            : 
    2314                 :            : static void virtnet_freeze_down(struct virtio_device *vdev)
    2315                 :            : {
    2316                 :            :         struct virtnet_info *vi = vdev->priv;
    2317                 :            :         int i;
    2318                 :            : 
    2319                 :            :         /* Make sure no work handler is accessing the device */
    2320                 :            :         flush_work(&vi->config_work);
    2321                 :            : 
    2322                 :            :         netif_tx_lock_bh(vi->dev);
    2323                 :            :         netif_device_detach(vi->dev);
    2324                 :            :         netif_tx_unlock_bh(vi->dev);
    2325                 :            :         cancel_delayed_work_sync(&vi->refill);
    2326                 :            : 
    2327                 :            :         if (netif_running(vi->dev)) {
    2328                 :            :                 for (i = 0; i < vi->max_queue_pairs; i++) {
    2329                 :            :                         napi_disable(&vi->rq[i].napi);
    2330                 :            :                         virtnet_napi_tx_disable(&vi->sq[i].napi);
    2331                 :            :                 }
    2332                 :            :         }
    2333                 :            : }
    2334                 :            : 
    2335                 :            : static int init_vqs(struct virtnet_info *vi);
    2336                 :            : 
    2337                 :          0 : static int virtnet_restore_up(struct virtio_device *vdev)
    2338                 :            : {
    2339                 :          0 :         struct virtnet_info *vi = vdev->priv;
    2340                 :          0 :         int err, i;
    2341                 :            : 
    2342                 :          0 :         err = init_vqs(vi);
    2343         [ #  # ]:          0 :         if (err)
    2344                 :            :                 return err;
    2345                 :            : 
    2346                 :          0 :         virtio_device_ready(vdev);
    2347                 :            : 
    2348         [ #  # ]:          0 :         if (netif_running(vi->dev)) {
    2349         [ #  # ]:          0 :                 for (i = 0; i < vi->curr_queue_pairs; i++)
    2350         [ #  # ]:          0 :                         if (!try_fill_recv(vi, &vi->rq[i], GFP_KERNEL))
    2351                 :          0 :                                 schedule_delayed_work(&vi->refill, 0);
    2352                 :            : 
    2353         [ #  # ]:          0 :                 for (i = 0; i < vi->max_queue_pairs; i++) {
    2354                 :          0 :                         virtnet_napi_enable(vi->rq[i].vq, &vi->rq[i].napi);
    2355                 :          0 :                         virtnet_napi_tx_enable(vi, vi->sq[i].vq,
    2356         [ #  # ]:          0 :                                                &vi->sq[i].napi);
    2357                 :            :                 }
    2358                 :            :         }
    2359                 :            : 
    2360                 :          0 :         netif_tx_lock_bh(vi->dev);
    2361                 :          0 :         netif_device_attach(vi->dev);
    2362                 :          0 :         netif_tx_unlock_bh(vi->dev);
    2363                 :          0 :         return err;
    2364                 :            : }
    2365                 :            : 
    2366                 :          0 : static int virtnet_set_guest_offloads(struct virtnet_info *vi, u64 offloads)
    2367                 :            : {
    2368                 :          0 :         struct scatterlist sg;
    2369                 :          0 :         vi->ctrl->offloads = cpu_to_virtio64(vi->vdev, offloads);
    2370                 :            : 
    2371                 :          0 :         sg_init_one(&sg, &vi->ctrl->offloads, sizeof(vi->ctrl->offloads));
    2372                 :            : 
    2373         [ #  # ]:          0 :         if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_GUEST_OFFLOADS,
    2374                 :            :                                   VIRTIO_NET_CTRL_GUEST_OFFLOADS_SET, &sg)) {
    2375                 :          0 :                 dev_warn(&vi->dev->dev, "Fail to set guest offload.\n");
    2376                 :          0 :                 return -EINVAL;
    2377                 :            :         }
    2378                 :            : 
    2379                 :            :         return 0;
    2380                 :            : }
    2381                 :            : 
    2382                 :          0 : static int virtnet_clear_guest_offloads(struct virtnet_info *vi)
    2383                 :            : {
    2384                 :          0 :         u64 offloads = 0;
    2385                 :            : 
    2386                 :          0 :         if (!vi->guest_offloads)
    2387                 :            :                 return 0;
    2388                 :            : 
    2389                 :          0 :         return virtnet_set_guest_offloads(vi, offloads);
    2390                 :            : }
    2391                 :            : 
    2392                 :          0 : static int virtnet_restore_guest_offloads(struct virtnet_info *vi)
    2393                 :            : {
    2394                 :          0 :         u64 offloads = vi->guest_offloads;
    2395                 :            : 
    2396                 :          0 :         if (!vi->guest_offloads)
    2397                 :            :                 return 0;
    2398                 :            : 
    2399                 :          0 :         return virtnet_set_guest_offloads(vi, offloads);
    2400                 :            : }
    2401                 :            : 
    2402                 :          0 : static int virtnet_xdp_set(struct net_device *dev, struct bpf_prog *prog,
    2403                 :            :                            struct netlink_ext_ack *extack)
    2404                 :            : {
    2405                 :          0 :         unsigned long int max_sz = PAGE_SIZE - sizeof(struct padded_vnet_hdr);
    2406                 :          0 :         struct virtnet_info *vi = netdev_priv(dev);
    2407                 :          0 :         struct bpf_prog *old_prog;
    2408                 :          0 :         u16 xdp_qp = 0, curr_qp;
    2409                 :          0 :         int i, err;
    2410                 :            : 
    2411         [ #  # ]:          0 :         if (!virtio_has_feature(vi->vdev, VIRTIO_NET_F_CTRL_GUEST_OFFLOADS)
    2412   [ #  #  #  # ]:          0 :             && (virtio_has_feature(vi->vdev, VIRTIO_NET_F_GUEST_TSO4) ||
    2413         [ #  # ]:          0 :                 virtio_has_feature(vi->vdev, VIRTIO_NET_F_GUEST_TSO6) ||
    2414         [ #  # ]:          0 :                 virtio_has_feature(vi->vdev, VIRTIO_NET_F_GUEST_ECN) ||
    2415         [ #  # ]:          0 :                 virtio_has_feature(vi->vdev, VIRTIO_NET_F_GUEST_UFO) ||
    2416                 :          0 :                 virtio_has_feature(vi->vdev, VIRTIO_NET_F_GUEST_CSUM))) {
    2417         [ #  # ]:          0 :                 NL_SET_ERR_MSG_MOD(extack, "Can't set XDP while host is implementing LRO/CSUM, disable LRO/CSUM first");
    2418                 :          0 :                 return -EOPNOTSUPP;
    2419                 :            :         }
    2420                 :            : 
    2421   [ #  #  #  # ]:          0 :         if (vi->mergeable_rx_bufs && !vi->any_header_sg) {
    2422         [ #  # ]:          0 :                 NL_SET_ERR_MSG_MOD(extack, "XDP expects header/data in single page, any_header_sg required");
    2423                 :          0 :                 return -EINVAL;
    2424                 :            :         }
    2425                 :            : 
    2426         [ #  # ]:          0 :         if (dev->mtu > max_sz) {
    2427         [ #  # ]:          0 :                 NL_SET_ERR_MSG_MOD(extack, "MTU too large to enable XDP");
    2428                 :          0 :                 netdev_warn(dev, "XDP requires MTU less than %lu\n", max_sz);
    2429                 :          0 :                 return -EINVAL;
    2430                 :            :         }
    2431                 :            : 
    2432                 :          0 :         curr_qp = vi->curr_queue_pairs - vi->xdp_queue_pairs;
    2433         [ #  # ]:          0 :         if (prog)
    2434                 :          0 :                 xdp_qp = nr_cpu_ids;
    2435                 :            : 
    2436                 :            :         /* XDP requires extra queues for XDP_TX */
    2437         [ #  # ]:          0 :         if (curr_qp + xdp_qp > vi->max_queue_pairs) {
    2438         [ #  # ]:          0 :                 NL_SET_ERR_MSG_MOD(extack, "Too few free TX rings available");
    2439                 :          0 :                 netdev_warn(dev, "request %i queues but max is %i\n",
    2440                 :          0 :                             curr_qp + xdp_qp, vi->max_queue_pairs);
    2441                 :          0 :                 return -ENOMEM;
    2442                 :            :         }
    2443                 :            : 
    2444                 :          0 :         old_prog = rtnl_dereference(vi->rq[0].xdp_prog);
    2445         [ #  # ]:          0 :         if (!prog && !old_prog)
    2446                 :            :                 return 0;
    2447                 :            : 
    2448                 :          0 :         if (prog)
    2449                 :            :                 bpf_prog_add(prog, vi->max_queue_pairs - 1);
    2450                 :            : 
    2451                 :            :         /* Make sure NAPI is not using any XDP TX queues for RX. */
    2452         [ #  # ]:          0 :         if (netif_running(dev)) {
    2453         [ #  # ]:          0 :                 for (i = 0; i < vi->max_queue_pairs; i++) {
    2454                 :          0 :                         napi_disable(&vi->rq[i].napi);
    2455         [ #  # ]:          0 :                         virtnet_napi_tx_disable(&vi->sq[i].napi);
    2456                 :            :                 }
    2457                 :            :         }
    2458                 :            : 
    2459         [ #  # ]:          0 :         if (!prog) {
    2460         [ #  # ]:          0 :                 for (i = 0; i < vi->max_queue_pairs; i++) {
    2461         [ #  # ]:          0 :                         rcu_assign_pointer(vi->rq[i].xdp_prog, prog);
    2462         [ #  # ]:          0 :                         if (i == 0)
    2463         [ #  # ]:          0 :                                 virtnet_restore_guest_offloads(vi);
    2464                 :            :                 }
    2465                 :          0 :                 synchronize_net();
    2466                 :            :         }
    2467                 :            : 
    2468                 :          0 :         err = _virtnet_set_queues(vi, curr_qp + xdp_qp);
    2469         [ #  # ]:          0 :         if (err)
    2470                 :          0 :                 goto err;
    2471                 :          0 :         netif_set_real_num_rx_queues(dev, curr_qp + xdp_qp);
    2472                 :          0 :         vi->xdp_queue_pairs = xdp_qp;
    2473                 :            : 
    2474         [ #  # ]:          0 :         if (prog) {
    2475         [ #  # ]:          0 :                 for (i = 0; i < vi->max_queue_pairs; i++) {
    2476         [ #  # ]:          0 :                         rcu_assign_pointer(vi->rq[i].xdp_prog, prog);
    2477         [ #  # ]:          0 :                         if (i == 0 && !old_prog)
    2478         [ #  # ]:          0 :                                 virtnet_clear_guest_offloads(vi);
    2479                 :            :                 }
    2480                 :            :         }
    2481                 :            : 
    2482         [ #  # ]:          0 :         for (i = 0; i < vi->max_queue_pairs; i++) {
    2483                 :          0 :                 if (old_prog)
    2484                 :            :                         bpf_prog_put(old_prog);
    2485         [ #  # ]:          0 :                 if (netif_running(dev)) {
    2486                 :          0 :                         virtnet_napi_enable(vi->rq[i].vq, &vi->rq[i].napi);
    2487                 :          0 :                         virtnet_napi_tx_enable(vi, vi->sq[i].vq,
    2488         [ #  # ]:          0 :                                                &vi->sq[i].napi);
    2489                 :            :                 }
    2490                 :            :         }
    2491                 :            : 
    2492                 :            :         return 0;
    2493                 :            : 
    2494                 :            : err:
    2495         [ #  # ]:          0 :         if (!prog) {
    2496         [ #  # ]:          0 :                 virtnet_clear_guest_offloads(vi);
    2497         [ #  # ]:          0 :                 for (i = 0; i < vi->max_queue_pairs; i++)
    2498                 :          0 :                         rcu_assign_pointer(vi->rq[i].xdp_prog, old_prog);
    2499                 :            :         }
    2500                 :            : 
    2501         [ #  # ]:          0 :         if (netif_running(dev)) {
    2502         [ #  # ]:          0 :                 for (i = 0; i < vi->max_queue_pairs; i++) {
    2503                 :          0 :                         virtnet_napi_enable(vi->rq[i].vq, &vi->rq[i].napi);
    2504                 :          0 :                         virtnet_napi_tx_enable(vi, vi->sq[i].vq,
    2505         [ #  # ]:          0 :                                                &vi->sq[i].napi);
    2506                 :            :                 }
    2507                 :            :         }
    2508                 :          0 :         if (prog)
    2509                 :            :                 bpf_prog_sub(prog, vi->max_queue_pairs - 1);
    2510                 :            :         return err;
    2511                 :            : }
    2512                 :            : 
    2513                 :            : static u32 virtnet_xdp_query(struct net_device *dev)
    2514                 :            : {
    2515                 :            :         struct virtnet_info *vi = netdev_priv(dev);
    2516                 :            :         const struct bpf_prog *xdp_prog;
    2517                 :            :         int i;
    2518                 :            : 
    2519         [ #  # ]:          0 :         for (i = 0; i < vi->max_queue_pairs; i++) {
    2520                 :          0 :                 xdp_prog = rtnl_dereference(vi->rq[i].xdp_prog);
    2521         [ #  # ]:          0 :                 if (xdp_prog)
    2522                 :          0 :                         return xdp_prog->aux->id;
    2523                 :            :         }
    2524                 :            :         return 0;
    2525                 :            : }
    2526                 :            : 
    2527                 :          0 : static int virtnet_xdp(struct net_device *dev, struct netdev_bpf *xdp)
    2528                 :            : {
    2529      [ #  #  # ]:          0 :         switch (xdp->command) {
    2530                 :          0 :         case XDP_SETUP_PROG:
    2531                 :          0 :                 return virtnet_xdp_set(dev, xdp->prog, xdp->extack);
    2532                 :            :         case XDP_QUERY_PROG:
    2533                 :          0 :                 xdp->prog_id = virtnet_xdp_query(dev);
    2534                 :          0 :                 return 0;
    2535                 :            :         default:
    2536                 :            :                 return -EINVAL;
    2537                 :            :         }
    2538                 :            : }
    2539                 :            : 
    2540                 :          0 : static int virtnet_get_phys_port_name(struct net_device *dev, char *buf,
    2541                 :            :                                       size_t len)
    2542                 :            : {
    2543                 :          0 :         struct virtnet_info *vi = netdev_priv(dev);
    2544                 :          0 :         int ret;
    2545                 :            : 
    2546         [ #  # ]:          0 :         if (!virtio_has_feature(vi->vdev, VIRTIO_NET_F_STANDBY))
    2547                 :            :                 return -EOPNOTSUPP;
    2548                 :            : 
    2549                 :          0 :         ret = snprintf(buf, len, "sby");
    2550         [ #  # ]:          0 :         if (ret >= len)
    2551                 :          0 :                 return -EOPNOTSUPP;
    2552                 :            : 
    2553                 :            :         return 0;
    2554                 :            : }
    2555                 :            : 
    2556                 :          0 : static int virtnet_set_features(struct net_device *dev,
    2557                 :            :                                 netdev_features_t features)
    2558                 :            : {
    2559         [ #  # ]:          0 :         struct virtnet_info *vi = netdev_priv(dev);
    2560                 :          0 :         u64 offloads;
    2561                 :          0 :         int err;
    2562                 :            : 
    2563         [ #  # ]:          0 :         if ((dev->features ^ features) & NETIF_F_LRO) {
    2564         [ #  # ]:          0 :                 if (vi->xdp_queue_pairs)
    2565                 :            :                         return -EBUSY;
    2566                 :            : 
    2567         [ #  # ]:          0 :                 if (features & NETIF_F_LRO)
    2568                 :          0 :                         offloads = vi->guest_offloads_capable;
    2569                 :            :                 else
    2570                 :            :                         offloads = 0;
    2571                 :            : 
    2572                 :          0 :                 err = virtnet_set_guest_offloads(vi, offloads);
    2573         [ #  # ]:          0 :                 if (err)
    2574                 :            :                         return err;
    2575                 :          0 :                 vi->guest_offloads = offloads;
    2576                 :            :         }
    2577                 :            : 
    2578                 :            :         return 0;
    2579                 :            : }
    2580                 :            : 
    2581                 :            : static const struct net_device_ops virtnet_netdev = {
    2582                 :            :         .ndo_open            = virtnet_open,
    2583                 :            :         .ndo_stop            = virtnet_close,
    2584                 :            :         .ndo_start_xmit      = start_xmit,
    2585                 :            :         .ndo_validate_addr   = eth_validate_addr,
    2586                 :            :         .ndo_set_mac_address = virtnet_set_mac_address,
    2587                 :            :         .ndo_set_rx_mode     = virtnet_set_rx_mode,
    2588                 :            :         .ndo_get_stats64     = virtnet_stats,
    2589                 :            :         .ndo_vlan_rx_add_vid = virtnet_vlan_rx_add_vid,
    2590                 :            :         .ndo_vlan_rx_kill_vid = virtnet_vlan_rx_kill_vid,
    2591                 :            :         .ndo_bpf                = virtnet_xdp,
    2592                 :            :         .ndo_xdp_xmit           = virtnet_xdp_xmit,
    2593                 :            :         .ndo_features_check     = passthru_features_check,
    2594                 :            :         .ndo_get_phys_port_name = virtnet_get_phys_port_name,
    2595                 :            :         .ndo_set_features       = virtnet_set_features,
    2596                 :            : };
    2597                 :            : 
    2598                 :          0 : static void virtnet_config_changed_work(struct work_struct *work)
    2599                 :            : {
    2600                 :          0 :         struct virtnet_info *vi =
    2601                 :          0 :                 container_of(work, struct virtnet_info, config_work);
    2602                 :          0 :         u16 v;
    2603                 :            : 
    2604         [ #  # ]:          0 :         if (virtio_cread_feature(vi->vdev, VIRTIO_NET_F_STATUS,
    2605                 :            :                                  struct virtio_net_config, status, &v) < 0)
    2606                 :            :                 return;
    2607                 :            : 
    2608         [ #  # ]:          0 :         if (v & VIRTIO_NET_S_ANNOUNCE) {
    2609                 :          0 :                 netdev_notify_peers(vi->dev);
    2610                 :          0 :                 virtnet_ack_link_announce(vi);
    2611                 :            :         }
    2612                 :            : 
    2613                 :            :         /* Ignore unknown (future) status bits */
    2614                 :          0 :         v &= VIRTIO_NET_S_LINK_UP;
    2615                 :            : 
    2616         [ #  # ]:          0 :         if (vi->status == v)
    2617                 :            :                 return;
    2618                 :            : 
    2619                 :          0 :         vi->status = v;
    2620                 :            : 
    2621         [ #  # ]:          0 :         if (vi->status & VIRTIO_NET_S_LINK_UP) {
    2622                 :          0 :                 virtnet_update_settings(vi);
    2623                 :          0 :                 netif_carrier_on(vi->dev);
    2624                 :          0 :                 netif_tx_wake_all_queues(vi->dev);
    2625                 :            :         } else {
    2626                 :          0 :                 netif_carrier_off(vi->dev);
    2627                 :          0 :                 netif_tx_stop_all_queues(vi->dev);
    2628                 :            :         }
    2629                 :            : }
    2630                 :            : 
    2631                 :          0 : static void virtnet_config_changed(struct virtio_device *vdev)
    2632                 :            : {
    2633                 :          0 :         struct virtnet_info *vi = vdev->priv;
    2634                 :            : 
    2635                 :          0 :         schedule_work(&vi->config_work);
    2636                 :          0 : }
    2637                 :            : 
    2638                 :          0 : static void virtnet_free_queues(struct virtnet_info *vi)
    2639                 :            : {
    2640                 :          0 :         int i;
    2641                 :            : 
    2642         [ #  # ]:          0 :         for (i = 0; i < vi->max_queue_pairs; i++) {
    2643                 :          0 :                 napi_hash_del(&vi->rq[i].napi);
    2644                 :          0 :                 netif_napi_del(&vi->rq[i].napi);
    2645                 :          0 :                 netif_napi_del(&vi->sq[i].napi);
    2646                 :            :         }
    2647                 :            : 
    2648                 :            :         /* We called napi_hash_del() before netif_napi_del(),
    2649                 :            :          * we need to respect an RCU grace period before freeing vi->rq
    2650                 :            :          */
    2651                 :          0 :         synchronize_net();
    2652                 :            : 
    2653                 :          0 :         kfree(vi->rq);
    2654                 :          0 :         kfree(vi->sq);
    2655                 :          0 :         kfree(vi->ctrl);
    2656                 :          0 : }
    2657                 :            : 
    2658                 :            : static void _free_receive_bufs(struct virtnet_info *vi)
    2659                 :            : {
    2660                 :            :         struct bpf_prog *old_prog;
    2661                 :            :         int i;
    2662                 :            : 
    2663                 :            :         for (i = 0; i < vi->max_queue_pairs; i++) {
    2664                 :            :                 while (vi->rq[i].pages)
    2665                 :            :                         __free_pages(get_a_page(&vi->rq[i], GFP_KERNEL), 0);
    2666                 :            : 
    2667                 :            :                 old_prog = rtnl_dereference(vi->rq[i].xdp_prog);
    2668                 :            :                 RCU_INIT_POINTER(vi->rq[i].xdp_prog, NULL);
    2669                 :            :                 if (old_prog)
    2670                 :            :                         bpf_prog_put(old_prog);
    2671                 :            :         }
    2672                 :            : }
    2673                 :            : 
    2674                 :          0 : static void free_receive_bufs(struct virtnet_info *vi)
    2675                 :            : {
    2676                 :          0 :         rtnl_lock();
    2677                 :          0 :         _free_receive_bufs(vi);
    2678                 :          0 :         rtnl_unlock();
    2679                 :            : }
    2680                 :            : 
    2681                 :            : static void free_receive_page_frags(struct virtnet_info *vi)
    2682                 :            : {
    2683                 :            :         int i;
    2684                 :            :         for (i = 0; i < vi->max_queue_pairs; i++)
    2685                 :            :                 if (vi->rq[i].alloc_frag.page)
    2686                 :            :                         put_page(vi->rq[i].alloc_frag.page);
    2687                 :            : }
    2688                 :            : 
    2689                 :          0 : static void free_unused_bufs(struct virtnet_info *vi)
    2690                 :            : {
    2691                 :          0 :         void *buf;
    2692                 :          0 :         int i;
    2693                 :            : 
    2694         [ #  # ]:          0 :         for (i = 0; i < vi->max_queue_pairs; i++) {
    2695                 :          0 :                 struct virtqueue *vq = vi->sq[i].vq;
    2696         [ #  # ]:          0 :                 while ((buf = virtqueue_detach_unused_buf(vq)) != NULL) {
    2697         [ #  # ]:          0 :                         if (!is_xdp_frame(buf))
    2698                 :          0 :                                 dev_kfree_skb(buf);
    2699                 :            :                         else
    2700                 :          0 :                                 xdp_return_frame(ptr_to_xdp(buf));
    2701                 :            :                 }
    2702                 :            :         }
    2703                 :            : 
    2704         [ #  # ]:          0 :         for (i = 0; i < vi->max_queue_pairs; i++) {
    2705                 :          0 :                 struct virtqueue *vq = vi->rq[i].vq;
    2706                 :            : 
    2707         [ #  # ]:          0 :                 while ((buf = virtqueue_detach_unused_buf(vq)) != NULL) {
    2708         [ #  # ]:          0 :                         if (vi->mergeable_rx_bufs) {
    2709         [ #  # ]:          0 :                                 put_page(virt_to_head_page(buf));
    2710         [ #  # ]:          0 :                         } else if (vi->big_packets) {
    2711                 :          0 :                                 give_pages(&vi->rq[i], buf);
    2712                 :            :                         } else {
    2713         [ #  # ]:          0 :                                 put_page(virt_to_head_page(buf));
    2714                 :            :                         }
    2715                 :            :                 }
    2716                 :            :         }
    2717                 :          0 : }
    2718                 :            : 
    2719                 :          0 : static void virtnet_del_vqs(struct virtnet_info *vi)
    2720                 :            : {
    2721                 :          0 :         struct virtio_device *vdev = vi->vdev;
    2722                 :            : 
    2723                 :          0 :         virtnet_clean_affinity(vi);
    2724                 :            : 
    2725                 :          0 :         vdev->config->del_vqs(vdev);
    2726                 :            : 
    2727                 :          0 :         virtnet_free_queues(vi);
    2728                 :          0 : }
    2729                 :            : 
    2730                 :            : /* How large should a single buffer be so a queue full of these can fit at
    2731                 :            :  * least one full packet?
    2732                 :            :  * Logic below assumes the mergeable buffer header is used.
    2733                 :            :  */
    2734                 :            : static unsigned int mergeable_min_buf_len(struct virtnet_info *vi, struct virtqueue *vq)
    2735                 :            : {
    2736                 :            :         const unsigned int hdr_len = sizeof(struct virtio_net_hdr_mrg_rxbuf);
    2737                 :            :         unsigned int rq_size = virtqueue_get_vring_size(vq);
    2738                 :            :         unsigned int packet_len = vi->big_packets ? IP_MAX_MTU : vi->dev->max_mtu;
    2739                 :            :         unsigned int buf_len = hdr_len + ETH_HLEN + VLAN_HLEN + packet_len;
    2740                 :            :         unsigned int min_buf_len = DIV_ROUND_UP(buf_len, rq_size);
    2741                 :            : 
    2742                 :            :         return max(max(min_buf_len, hdr_len) - hdr_len,
    2743                 :            :                    (unsigned int)GOOD_PACKET_LEN);
    2744                 :            : }
    2745                 :            : 
    2746                 :          0 : static int virtnet_find_vqs(struct virtnet_info *vi)
    2747                 :            : {
    2748                 :          0 :         vq_callback_t **callbacks;
    2749                 :          0 :         struct virtqueue **vqs;
    2750                 :          0 :         int ret = -ENOMEM;
    2751                 :          0 :         int i, total_vqs;
    2752                 :          0 :         const char **names;
    2753                 :          0 :         bool *ctx;
    2754                 :            : 
    2755                 :            :         /* We expect 1 RX virtqueue followed by 1 TX virtqueue, followed by
    2756                 :            :          * possible N-1 RX/TX queue pairs used in multiqueue mode, followed by
    2757                 :            :          * possible control vq.
    2758                 :            :          */
    2759                 :          0 :         total_vqs = vi->max_queue_pairs * 2 +
    2760                 :          0 :                     virtio_has_feature(vi->vdev, VIRTIO_NET_F_CTRL_VQ);
    2761                 :            : 
    2762                 :            :         /* Allocate space for find_vqs parameters */
    2763                 :          0 :         vqs = kcalloc(total_vqs, sizeof(*vqs), GFP_KERNEL);
    2764         [ #  # ]:          0 :         if (!vqs)
    2765                 :          0 :                 goto err_vq;
    2766                 :          0 :         callbacks = kmalloc_array(total_vqs, sizeof(*callbacks), GFP_KERNEL);
    2767         [ #  # ]:          0 :         if (!callbacks)
    2768                 :          0 :                 goto err_callback;
    2769                 :          0 :         names = kmalloc_array(total_vqs, sizeof(*names), GFP_KERNEL);
    2770         [ #  # ]:          0 :         if (!names)
    2771                 :          0 :                 goto err_names;
    2772   [ #  #  #  # ]:          0 :         if (!vi->big_packets || vi->mergeable_rx_bufs) {
    2773                 :          0 :                 ctx = kcalloc(total_vqs, sizeof(*ctx), GFP_KERNEL);
    2774         [ #  # ]:          0 :                 if (!ctx)
    2775                 :          0 :                         goto err_ctx;
    2776                 :            :         } else {
    2777                 :            :                 ctx = NULL;
    2778                 :            :         }
    2779                 :            : 
    2780                 :            :         /* Parameters for control virtqueue, if any */
    2781         [ #  # ]:          0 :         if (vi->has_cvq) {
    2782                 :          0 :                 callbacks[total_vqs - 1] = NULL;
    2783                 :          0 :                 names[total_vqs - 1] = "control";
    2784                 :            :         }
    2785                 :            : 
    2786                 :            :         /* Allocate/initialize parameters for send/receive virtqueues */
    2787         [ #  # ]:          0 :         for (i = 0; i < vi->max_queue_pairs; i++) {
    2788                 :          0 :                 callbacks[rxq2vq(i)] = skb_recv_done;
    2789                 :          0 :                 callbacks[txq2vq(i)] = skb_xmit_done;
    2790                 :          0 :                 sprintf(vi->rq[i].name, "input.%d", i);
    2791                 :          0 :                 sprintf(vi->sq[i].name, "output.%d", i);
    2792                 :          0 :                 names[rxq2vq(i)] = vi->rq[i].name;
    2793                 :          0 :                 names[txq2vq(i)] = vi->sq[i].name;
    2794         [ #  # ]:          0 :                 if (ctx)
    2795                 :          0 :                         ctx[rxq2vq(i)] = true;
    2796                 :            :         }
    2797                 :            : 
    2798                 :          0 :         ret = vi->vdev->config->find_vqs(vi->vdev, total_vqs, vqs, callbacks,
    2799                 :            :                                          names, ctx, NULL);
    2800         [ #  # ]:          0 :         if (ret)
    2801                 :          0 :                 goto err_find;
    2802                 :            : 
    2803         [ #  # ]:          0 :         if (vi->has_cvq) {
    2804                 :          0 :                 vi->cvq = vqs[total_vqs - 1];
    2805         [ #  # ]:          0 :                 if (virtio_has_feature(vi->vdev, VIRTIO_NET_F_CTRL_VLAN))
    2806                 :          0 :                         vi->dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
    2807                 :            :         }
    2808                 :            : 
    2809         [ #  # ]:          0 :         for (i = 0; i < vi->max_queue_pairs; i++) {
    2810                 :          0 :                 vi->rq[i].vq = vqs[rxq2vq(i)];
    2811                 :          0 :                 vi->rq[i].min_buf_len = mergeable_min_buf_len(vi, vi->rq[i].vq);
    2812                 :          0 :                 vi->sq[i].vq = vqs[txq2vq(i)];
    2813                 :            :         }
    2814                 :            : 
    2815                 :            :         /* run here: ret == 0. */
    2816                 :            : 
    2817                 :            : 
    2818                 :          0 : err_find:
    2819                 :          0 :         kfree(ctx);
    2820                 :          0 : err_ctx:
    2821                 :          0 :         kfree(names);
    2822                 :          0 : err_names:
    2823                 :          0 :         kfree(callbacks);
    2824                 :          0 : err_callback:
    2825                 :          0 :         kfree(vqs);
    2826                 :          0 : err_vq:
    2827                 :          0 :         return ret;
    2828                 :            : }
    2829                 :            : 
    2830                 :          0 : static int virtnet_alloc_queues(struct virtnet_info *vi)
    2831                 :            : {
    2832                 :          0 :         int i;
    2833                 :            : 
    2834                 :          0 :         vi->ctrl = kzalloc(sizeof(*vi->ctrl), GFP_KERNEL);
    2835         [ #  # ]:          0 :         if (!vi->ctrl)
    2836                 :          0 :                 goto err_ctrl;
    2837                 :          0 :         vi->sq = kcalloc(vi->max_queue_pairs, sizeof(*vi->sq), GFP_KERNEL);
    2838         [ #  # ]:          0 :         if (!vi->sq)
    2839                 :          0 :                 goto err_sq;
    2840                 :          0 :         vi->rq = kcalloc(vi->max_queue_pairs, sizeof(*vi->rq), GFP_KERNEL);
    2841         [ #  # ]:          0 :         if (!vi->rq)
    2842                 :          0 :                 goto err_rq;
    2843                 :            : 
    2844                 :          0 :         INIT_DELAYED_WORK(&vi->refill, refill_work);
    2845         [ #  # ]:          0 :         for (i = 0; i < vi->max_queue_pairs; i++) {
    2846                 :          0 :                 vi->rq[i].pages = NULL;
    2847                 :          0 :                 netif_napi_add(vi->dev, &vi->rq[i].napi, virtnet_poll,
    2848                 :            :                                napi_weight);
    2849                 :          0 :                 netif_tx_napi_add(vi->dev, &vi->sq[i].napi, virtnet_poll_tx,
    2850         [ #  # ]:          0 :                                   napi_tx ? napi_weight : 0);
    2851                 :            : 
    2852                 :          0 :                 sg_init_table(vi->rq[i].sg, ARRAY_SIZE(vi->rq[i].sg));
    2853                 :          0 :                 ewma_pkt_len_init(&vi->rq[i].mrg_avg_pkt_len);
    2854                 :          0 :                 sg_init_table(vi->sq[i].sg, ARRAY_SIZE(vi->sq[i].sg));
    2855                 :            : 
    2856                 :          0 :                 u64_stats_init(&vi->rq[i].stats.syncp);
    2857                 :          0 :                 u64_stats_init(&vi->sq[i].stats.syncp);
    2858                 :            :         }
    2859                 :            : 
    2860                 :            :         return 0;
    2861                 :            : 
    2862                 :            : err_rq:
    2863                 :          0 :         kfree(vi->sq);
    2864                 :          0 : err_sq:
    2865                 :          0 :         kfree(vi->ctrl);
    2866                 :            : err_ctrl:
    2867                 :            :         return -ENOMEM;
    2868                 :            : }
    2869                 :            : 
    2870                 :          0 : static int init_vqs(struct virtnet_info *vi)
    2871                 :            : {
    2872                 :          0 :         int ret;
    2873                 :            : 
    2874                 :            :         /* Allocate send & receive queues */
    2875                 :          0 :         ret = virtnet_alloc_queues(vi);
    2876         [ #  # ]:          0 :         if (ret)
    2877                 :          0 :                 goto err;
    2878                 :            : 
    2879                 :          0 :         ret = virtnet_find_vqs(vi);
    2880         [ #  # ]:          0 :         if (ret)
    2881                 :          0 :                 goto err_free;
    2882                 :            : 
    2883                 :          0 :         get_online_cpus();
    2884                 :          0 :         virtnet_set_affinity(vi);
    2885                 :          0 :         put_online_cpus();
    2886                 :            : 
    2887                 :          0 :         return 0;
    2888                 :            : 
    2889                 :            : err_free:
    2890                 :          0 :         virtnet_free_queues(vi);
    2891                 :            : err:
    2892                 :            :         return ret;
    2893                 :            : }
    2894                 :            : 
    2895                 :            : #ifdef CONFIG_SYSFS
    2896                 :          0 : static ssize_t mergeable_rx_buffer_size_show(struct netdev_rx_queue *queue,
    2897                 :            :                 char *buf)
    2898                 :            : {
    2899         [ #  # ]:          0 :         struct virtnet_info *vi = netdev_priv(queue->dev);
    2900         [ #  # ]:          0 :         unsigned int queue_index = get_netdev_rx_queue_index(queue);
    2901         [ #  # ]:          0 :         unsigned int headroom = virtnet_get_headroom(vi);
    2902                 :          0 :         unsigned int tailroom = headroom ? sizeof(struct skb_shared_info) : 0;
    2903                 :          0 :         struct ewma_pkt_len *avg;
    2904                 :            : 
    2905         [ #  # ]:          0 :         BUG_ON(queue_index >= vi->max_queue_pairs);
    2906                 :          0 :         avg = &vi->rq[queue_index].mrg_avg_pkt_len;
    2907                 :          0 :         return sprintf(buf, "%u\n",
    2908                 :            :                        get_mergeable_buf_len(&vi->rq[queue_index], avg,
    2909         [ #  # ]:          0 :                                        SKB_DATA_ALIGN(headroom + tailroom)));
    2910                 :            : }
    2911                 :            : 
    2912                 :            : static struct rx_queue_attribute mergeable_rx_buffer_size_attribute =
    2913                 :            :         __ATTR_RO(mergeable_rx_buffer_size);
    2914                 :            : 
    2915                 :            : static struct attribute *virtio_net_mrg_rx_attrs[] = {
    2916                 :            :         &mergeable_rx_buffer_size_attribute.attr,
    2917                 :            :         NULL
    2918                 :            : };
    2919                 :            : 
    2920                 :            : static const struct attribute_group virtio_net_mrg_rx_group = {
    2921                 :            :         .name = "virtio_net",
    2922                 :            :         .attrs = virtio_net_mrg_rx_attrs
    2923                 :            : };
    2924                 :            : #endif
    2925                 :            : 
    2926                 :          0 : static bool virtnet_fail_on_feature(struct virtio_device *vdev,
    2927                 :            :                                     unsigned int fbit,
    2928                 :            :                                     const char *fname, const char *dname)
    2929                 :            : {
    2930         [ #  # ]:          0 :         if (!virtio_has_feature(vdev, fbit))
    2931                 :            :                 return false;
    2932                 :            : 
    2933                 :          0 :         dev_err(&vdev->dev, "device advertises feature %s but not %s",
    2934                 :            :                 fname, dname);
    2935                 :            : 
    2936                 :          0 :         return true;
    2937                 :            : }
    2938                 :            : 
    2939                 :            : #define VIRTNET_FAIL_ON(vdev, fbit, dbit)                       \
    2940                 :            :         virtnet_fail_on_feature(vdev, fbit, #fbit, dbit)
    2941                 :            : 
    2942                 :          0 : static bool virtnet_validate_features(struct virtio_device *vdev)
    2943                 :            : {
    2944   [ #  #  #  # ]:          0 :         if (!virtio_has_feature(vdev, VIRTIO_NET_F_CTRL_VQ) &&
    2945                 :          0 :             (VIRTNET_FAIL_ON(vdev, VIRTIO_NET_F_CTRL_RX,
    2946         [ #  # ]:          0 :                              "VIRTIO_NET_F_CTRL_VQ") ||
    2947                 :          0 :              VIRTNET_FAIL_ON(vdev, VIRTIO_NET_F_CTRL_VLAN,
    2948         [ #  # ]:          0 :                              "VIRTIO_NET_F_CTRL_VQ") ||
    2949                 :          0 :              VIRTNET_FAIL_ON(vdev, VIRTIO_NET_F_GUEST_ANNOUNCE,
    2950         [ #  # ]:          0 :                              "VIRTIO_NET_F_CTRL_VQ") ||
    2951         [ #  # ]:          0 :              VIRTNET_FAIL_ON(vdev, VIRTIO_NET_F_MQ, "VIRTIO_NET_F_CTRL_VQ") ||
    2952                 :          0 :              VIRTNET_FAIL_ON(vdev, VIRTIO_NET_F_CTRL_MAC_ADDR,
    2953                 :            :                              "VIRTIO_NET_F_CTRL_VQ"))) {
    2954                 :          0 :                 return false;
    2955                 :            :         }
    2956                 :            : 
    2957                 :            :         return true;
    2958                 :            : }
    2959                 :            : 
    2960                 :            : #define MIN_MTU ETH_MIN_MTU
    2961                 :            : #define MAX_MTU ETH_MAX_MTU
    2962                 :            : 
    2963                 :          0 : static int virtnet_validate(struct virtio_device *vdev)
    2964                 :            : {
    2965         [ #  # ]:          0 :         if (!vdev->config->get) {
    2966                 :          0 :                 dev_err(&vdev->dev, "%s failure: config access disabled\n",
    2967                 :            :                         __func__);
    2968                 :          0 :                 return -EINVAL;
    2969                 :            :         }
    2970                 :            : 
    2971         [ #  # ]:          0 :         if (!virtnet_validate_features(vdev))
    2972                 :            :                 return -EINVAL;
    2973                 :            : 
    2974         [ #  # ]:          0 :         if (virtio_has_feature(vdev, VIRTIO_NET_F_MTU)) {
    2975                 :          0 :                 int mtu = virtio_cread16(vdev,
    2976                 :            :                                          offsetof(struct virtio_net_config,
    2977                 :            :                                                   mtu));
    2978         [ #  # ]:          0 :                 if (mtu < MIN_MTU)
    2979                 :          0 :                         __virtio_clear_bit(vdev, VIRTIO_NET_F_MTU);
    2980                 :            :         }
    2981                 :            : 
    2982                 :            :         return 0;
    2983                 :            : }
    2984                 :            : 
    2985                 :          0 : static int virtnet_probe(struct virtio_device *vdev)
    2986                 :            : {
    2987                 :          0 :         int i, err = -ENOMEM;
    2988                 :          0 :         struct net_device *dev;
    2989                 :          0 :         struct virtnet_info *vi;
    2990                 :          0 :         u16 max_queue_pairs;
    2991                 :          0 :         int mtu;
    2992                 :            : 
    2993                 :            :         /* Find if host supports multiqueue virtio_net device */
    2994         [ #  # ]:          0 :         err = virtio_cread_feature(vdev, VIRTIO_NET_F_MQ,
    2995                 :            :                                    struct virtio_net_config,
    2996                 :            :                                    max_virtqueue_pairs, &max_queue_pairs);
    2997                 :            : 
    2998                 :            :         /* We need at least 2 queue's */
    2999   [ #  #  #  # ]:          0 :         if (err || max_queue_pairs < VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MIN ||
    3000         [ #  # ]:          0 :             max_queue_pairs > VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX ||
    3001                 :            :             !virtio_has_feature(vdev, VIRTIO_NET_F_CTRL_VQ))
    3002                 :            :                 max_queue_pairs = 1;
    3003                 :            : 
    3004                 :            :         /* Allocate ourselves a network device with room for our info */
    3005                 :          0 :         dev = alloc_etherdev_mq(sizeof(struct virtnet_info), max_queue_pairs);
    3006         [ #  # ]:          0 :         if (!dev)
    3007                 :            :                 return -ENOMEM;
    3008                 :            : 
    3009                 :            :         /* Set up network device as normal. */
    3010                 :          0 :         dev->priv_flags |= IFF_UNICAST_FLT | IFF_LIVE_ADDR_CHANGE;
    3011                 :          0 :         dev->netdev_ops = &virtnet_netdev;
    3012                 :          0 :         dev->features = NETIF_F_HIGHDMA;
    3013                 :            : 
    3014                 :          0 :         dev->ethtool_ops = &virtnet_ethtool_ops;
    3015                 :          0 :         SET_NETDEV_DEV(dev, &vdev->dev);
    3016                 :            : 
    3017                 :            :         /* Do we support "hardware" checksums? */
    3018         [ #  # ]:          0 :         if (virtio_has_feature(vdev, VIRTIO_NET_F_CSUM)) {
    3019                 :            :                 /* This opens up the world of extra features. */
    3020                 :          0 :                 dev->hw_features |= NETIF_F_HW_CSUM | NETIF_F_SG;
    3021         [ #  # ]:          0 :                 if (csum)
    3022                 :          0 :                         dev->features |= NETIF_F_HW_CSUM | NETIF_F_SG;
    3023                 :            : 
    3024         [ #  # ]:          0 :                 if (virtio_has_feature(vdev, VIRTIO_NET_F_GSO)) {
    3025                 :          0 :                         dev->hw_features |= NETIF_F_TSO
    3026                 :            :                                 | NETIF_F_TSO_ECN | NETIF_F_TSO6;
    3027                 :            :                 }
    3028                 :            :                 /* Individual feature bits: what can host handle? */
    3029         [ #  # ]:          0 :                 if (virtio_has_feature(vdev, VIRTIO_NET_F_HOST_TSO4))
    3030                 :          0 :                         dev->hw_features |= NETIF_F_TSO;
    3031         [ #  # ]:          0 :                 if (virtio_has_feature(vdev, VIRTIO_NET_F_HOST_TSO6))
    3032                 :          0 :                         dev->hw_features |= NETIF_F_TSO6;
    3033         [ #  # ]:          0 :                 if (virtio_has_feature(vdev, VIRTIO_NET_F_HOST_ECN))
    3034                 :          0 :                         dev->hw_features |= NETIF_F_TSO_ECN;
    3035                 :            : 
    3036                 :          0 :                 dev->features |= NETIF_F_GSO_ROBUST;
    3037                 :            : 
    3038         [ #  # ]:          0 :                 if (gso)
    3039                 :          0 :                         dev->features |= dev->hw_features & NETIF_F_ALL_TSO;
    3040                 :            :                 /* (!csum && gso) case will be fixed by register_netdev() */
    3041                 :            :         }
    3042         [ #  # ]:          0 :         if (virtio_has_feature(vdev, VIRTIO_NET_F_GUEST_CSUM))
    3043                 :          0 :                 dev->features |= NETIF_F_RXCSUM;
    3044   [ #  #  #  # ]:          0 :         if (virtio_has_feature(vdev, VIRTIO_NET_F_GUEST_TSO4) ||
    3045                 :            :             virtio_has_feature(vdev, VIRTIO_NET_F_GUEST_TSO6))
    3046                 :          0 :                 dev->features |= NETIF_F_LRO;
    3047         [ #  # ]:          0 :         if (virtio_has_feature(vdev, VIRTIO_NET_F_CTRL_GUEST_OFFLOADS))
    3048                 :          0 :                 dev->hw_features |= NETIF_F_LRO;
    3049                 :            : 
    3050                 :          0 :         dev->vlan_features = dev->features;
    3051                 :            : 
    3052                 :            :         /* MTU range: 68 - 65535 */
    3053                 :          0 :         dev->min_mtu = MIN_MTU;
    3054                 :          0 :         dev->max_mtu = MAX_MTU;
    3055                 :            : 
    3056                 :            :         /* Configuration may specify what MAC to use.  Otherwise random. */
    3057         [ #  # ]:          0 :         if (virtio_has_feature(vdev, VIRTIO_NET_F_MAC))
    3058                 :          0 :                 virtio_cread_bytes(vdev,
    3059                 :            :                                    offsetof(struct virtio_net_config, mac),
    3060                 :          0 :                                    dev->dev_addr, dev->addr_len);
    3061                 :            :         else
    3062                 :          0 :                 eth_hw_addr_random(dev);
    3063                 :            : 
    3064                 :            :         /* Set up our device-specific information */
    3065                 :          0 :         vi = netdev_priv(dev);
    3066                 :          0 :         vi->dev = dev;
    3067                 :          0 :         vi->vdev = vdev;
    3068                 :          0 :         vdev->priv = vi;
    3069                 :            : 
    3070                 :          0 :         INIT_WORK(&vi->config_work, virtnet_config_changed_work);
    3071                 :            : 
    3072                 :            :         /* If we can receive ANY GSO packets, we must allocate large ones. */
    3073   [ #  #  #  # ]:          0 :         if (virtio_has_feature(vdev, VIRTIO_NET_F_GUEST_TSO4) ||
    3074         [ #  # ]:          0 :             virtio_has_feature(vdev, VIRTIO_NET_F_GUEST_TSO6) ||
    3075         [ #  # ]:          0 :             virtio_has_feature(vdev, VIRTIO_NET_F_GUEST_ECN) ||
    3076                 :            :             virtio_has_feature(vdev, VIRTIO_NET_F_GUEST_UFO))
    3077                 :          0 :                 vi->big_packets = true;
    3078                 :            : 
    3079         [ #  # ]:          0 :         if (virtio_has_feature(vdev, VIRTIO_NET_F_MRG_RXBUF))
    3080                 :          0 :                 vi->mergeable_rx_bufs = true;
    3081                 :            : 
    3082   [ #  #  #  # ]:          0 :         if (virtio_has_feature(vdev, VIRTIO_NET_F_MRG_RXBUF) ||
    3083                 :            :             virtio_has_feature(vdev, VIRTIO_F_VERSION_1))
    3084                 :          0 :                 vi->hdr_len = sizeof(struct virtio_net_hdr_mrg_rxbuf);
    3085                 :            :         else
    3086                 :          0 :                 vi->hdr_len = sizeof(struct virtio_net_hdr);
    3087                 :            : 
    3088   [ #  #  #  # ]:          0 :         if (virtio_has_feature(vdev, VIRTIO_F_ANY_LAYOUT) ||
    3089                 :            :             virtio_has_feature(vdev, VIRTIO_F_VERSION_1))
    3090                 :          0 :                 vi->any_header_sg = true;
    3091                 :            : 
    3092         [ #  # ]:          0 :         if (virtio_has_feature(vdev, VIRTIO_NET_F_CTRL_VQ))
    3093                 :          0 :                 vi->has_cvq = true;
    3094                 :            : 
    3095         [ #  # ]:          0 :         if (virtio_has_feature(vdev, VIRTIO_NET_F_MTU)) {
    3096                 :          0 :                 mtu = virtio_cread16(vdev,
    3097                 :            :                                      offsetof(struct virtio_net_config,
    3098                 :            :                                               mtu));
    3099         [ #  # ]:          0 :                 if (mtu < dev->min_mtu) {
    3100                 :            :                         /* Should never trigger: MTU was previously validated
    3101                 :            :                          * in virtnet_validate.
    3102                 :            :                          */
    3103                 :          0 :                         dev_err(&vdev->dev,
    3104                 :            :                                 "device MTU appears to have changed it is now %d < %d",
    3105                 :            :                                 mtu, dev->min_mtu);
    3106                 :          0 :                         goto free;
    3107                 :            :                 }
    3108                 :            : 
    3109                 :          0 :                 dev->mtu = mtu;
    3110                 :          0 :                 dev->max_mtu = mtu;
    3111                 :            : 
    3112                 :            :                 /* TODO: size buffers correctly in this case. */
    3113         [ #  # ]:          0 :                 if (dev->mtu > ETH_DATA_LEN)
    3114                 :          0 :                         vi->big_packets = true;
    3115                 :            :         }
    3116                 :            : 
    3117         [ #  # ]:          0 :         if (vi->any_header_sg)
    3118                 :          0 :                 dev->needed_headroom = vi->hdr_len;
    3119                 :            : 
    3120                 :            :         /* Enable multiqueue by default */
    3121         [ #  # ]:          0 :         if (num_online_cpus() >= max_queue_pairs)
    3122                 :          0 :                 vi->curr_queue_pairs = max_queue_pairs;
    3123                 :            :         else
    3124                 :          0 :                 vi->curr_queue_pairs = num_online_cpus();
    3125                 :          0 :         vi->max_queue_pairs = max_queue_pairs;
    3126                 :            : 
    3127                 :            :         /* Allocate/initialize the rx/tx queues, and invoke find_vqs */
    3128                 :          0 :         err = init_vqs(vi);
    3129         [ #  # ]:          0 :         if (err)
    3130                 :          0 :                 goto free;
    3131                 :            : 
    3132                 :            : #ifdef CONFIG_SYSFS
    3133         [ #  # ]:          0 :         if (vi->mergeable_rx_bufs)
    3134                 :          0 :                 dev->sysfs_rx_queue_group = &virtio_net_mrg_rx_group;
    3135                 :            : #endif
    3136                 :          0 :         netif_set_real_num_tx_queues(dev, vi->curr_queue_pairs);
    3137                 :          0 :         netif_set_real_num_rx_queues(dev, vi->curr_queue_pairs);
    3138                 :            : 
    3139                 :          0 :         virtnet_init_settings(dev);
    3140                 :            : 
    3141         [ #  # ]:          0 :         if (virtio_has_feature(vdev, VIRTIO_NET_F_STANDBY)) {
    3142                 :          0 :                 vi->failover = net_failover_create(vi->dev);
    3143         [ #  # ]:          0 :                 if (IS_ERR(vi->failover)) {
    3144                 :          0 :                         err = PTR_ERR(vi->failover);
    3145                 :          0 :                         goto free_vqs;
    3146                 :            :                 }
    3147                 :            :         }
    3148                 :            : 
    3149                 :          0 :         err = register_netdev(dev);
    3150         [ #  # ]:          0 :         if (err) {
    3151                 :          0 :                 pr_debug("virtio_net: registering device failed\n");
    3152                 :          0 :                 goto free_failover;
    3153                 :            :         }
    3154                 :            : 
    3155                 :          0 :         virtio_device_ready(vdev);
    3156                 :            : 
    3157                 :          0 :         err = virtnet_cpu_notif_add(vi);
    3158         [ #  # ]:          0 :         if (err) {
    3159                 :          0 :                 pr_debug("virtio_net: registering cpu notifier failed\n");
    3160                 :          0 :                 goto free_unregister_netdev;
    3161                 :            :         }
    3162                 :            : 
    3163                 :          0 :         virtnet_set_queues(vi, vi->curr_queue_pairs);
    3164                 :            : 
    3165                 :            :         /* Assume link up if device can't report link status,
    3166                 :            :            otherwise get link status from config. */
    3167                 :          0 :         netif_carrier_off(dev);
    3168         [ #  # ]:          0 :         if (virtio_has_feature(vi->vdev, VIRTIO_NET_F_STATUS)) {
    3169                 :          0 :                 schedule_work(&vi->config_work);
    3170                 :            :         } else {
    3171                 :          0 :                 vi->status = VIRTIO_NET_S_LINK_UP;
    3172                 :          0 :                 virtnet_update_settings(vi);
    3173                 :          0 :                 netif_carrier_on(dev);
    3174                 :            :         }
    3175                 :            : 
    3176         [ #  # ]:          0 :         for (i = 0; i < ARRAY_SIZE(guest_offloads); i++)
    3177         [ #  # ]:          0 :                 if (virtio_has_feature(vi->vdev, guest_offloads[i]))
    3178                 :          0 :                         set_bit(guest_offloads[i], &vi->guest_offloads);
    3179                 :          0 :         vi->guest_offloads_capable = vi->guest_offloads;
    3180                 :            : 
    3181                 :          0 :         pr_debug("virtnet: registered device %s with %d RX and TX vq's\n",
    3182                 :            :                  dev->name, max_queue_pairs);
    3183                 :            : 
    3184                 :          0 :         return 0;
    3185                 :            : 
    3186                 :            : free_unregister_netdev:
    3187                 :          0 :         vi->vdev->config->reset(vdev);
    3188                 :            : 
    3189                 :          0 :         unregister_netdev(dev);
    3190                 :          0 : free_failover:
    3191                 :          0 :         net_failover_destroy(vi->failover);
    3192                 :          0 : free_vqs:
    3193                 :          0 :         cancel_delayed_work_sync(&vi->refill);
    3194                 :          0 :         free_receive_page_frags(vi);
    3195                 :          0 :         virtnet_del_vqs(vi);
    3196                 :          0 : free:
    3197                 :          0 :         free_netdev(dev);
    3198                 :          0 :         return err;
    3199                 :            : }
    3200                 :            : 
    3201                 :          0 : static void remove_vq_common(struct virtnet_info *vi)
    3202                 :            : {
    3203                 :          0 :         vi->vdev->config->reset(vi->vdev);
    3204                 :            : 
    3205                 :            :         /* Free unused buffers in both send and recv, if any. */
    3206                 :          0 :         free_unused_bufs(vi);
    3207                 :            : 
    3208                 :          0 :         free_receive_bufs(vi);
    3209                 :            : 
    3210                 :          0 :         free_receive_page_frags(vi);
    3211                 :            : 
    3212                 :          0 :         virtnet_del_vqs(vi);
    3213                 :          0 : }
    3214                 :            : 
    3215                 :          0 : static void virtnet_remove(struct virtio_device *vdev)
    3216                 :            : {
    3217                 :          0 :         struct virtnet_info *vi = vdev->priv;
    3218                 :            : 
    3219                 :          0 :         virtnet_cpu_notif_remove(vi);
    3220                 :            : 
    3221                 :            :         /* Make sure no work handler is accessing the device. */
    3222                 :          0 :         flush_work(&vi->config_work);
    3223                 :            : 
    3224                 :          0 :         unregister_netdev(vi->dev);
    3225                 :            : 
    3226                 :          0 :         net_failover_destroy(vi->failover);
    3227                 :            : 
    3228                 :          0 :         remove_vq_common(vi);
    3229                 :            : 
    3230                 :          0 :         free_netdev(vi->dev);
    3231                 :          0 : }
    3232                 :            : 
    3233                 :          0 : static __maybe_unused int virtnet_freeze(struct virtio_device *vdev)
    3234                 :            : {
    3235                 :          0 :         struct virtnet_info *vi = vdev->priv;
    3236                 :            : 
    3237                 :          0 :         virtnet_cpu_notif_remove(vi);
    3238                 :          0 :         virtnet_freeze_down(vdev);
    3239                 :          0 :         remove_vq_common(vi);
    3240                 :            : 
    3241                 :          0 :         return 0;
    3242                 :            : }
    3243                 :            : 
    3244                 :          0 : static __maybe_unused int virtnet_restore(struct virtio_device *vdev)
    3245                 :            : {
    3246                 :          0 :         struct virtnet_info *vi = vdev->priv;
    3247                 :          0 :         int err;
    3248                 :            : 
    3249                 :          0 :         err = virtnet_restore_up(vdev);
    3250         [ #  # ]:          0 :         if (err)
    3251                 :            :                 return err;
    3252                 :          0 :         virtnet_set_queues(vi, vi->curr_queue_pairs);
    3253                 :            : 
    3254                 :          0 :         err = virtnet_cpu_notif_add(vi);
    3255         [ #  # ]:          0 :         if (err)
    3256                 :          0 :                 return err;
    3257                 :            : 
    3258                 :            :         return 0;
    3259                 :            : }
    3260                 :            : 
    3261                 :            : static struct virtio_device_id id_table[] = {
    3262                 :            :         { VIRTIO_ID_NET, VIRTIO_DEV_ANY_ID },
    3263                 :            :         { 0 },
    3264                 :            : };
    3265                 :            : 
    3266                 :            : #define VIRTNET_FEATURES \
    3267                 :            :         VIRTIO_NET_F_CSUM, VIRTIO_NET_F_GUEST_CSUM, \
    3268                 :            :         VIRTIO_NET_F_MAC, \
    3269                 :            :         VIRTIO_NET_F_HOST_TSO4, VIRTIO_NET_F_HOST_UFO, VIRTIO_NET_F_HOST_TSO6, \
    3270                 :            :         VIRTIO_NET_F_HOST_ECN, VIRTIO_NET_F_GUEST_TSO4, VIRTIO_NET_F_GUEST_TSO6, \
    3271                 :            :         VIRTIO_NET_F_GUEST_ECN, VIRTIO_NET_F_GUEST_UFO, \
    3272                 :            :         VIRTIO_NET_F_MRG_RXBUF, VIRTIO_NET_F_STATUS, VIRTIO_NET_F_CTRL_VQ, \
    3273                 :            :         VIRTIO_NET_F_CTRL_RX, VIRTIO_NET_F_CTRL_VLAN, \
    3274                 :            :         VIRTIO_NET_F_GUEST_ANNOUNCE, VIRTIO_NET_F_MQ, \
    3275                 :            :         VIRTIO_NET_F_CTRL_MAC_ADDR, \
    3276                 :            :         VIRTIO_NET_F_MTU, VIRTIO_NET_F_CTRL_GUEST_OFFLOADS, \
    3277                 :            :         VIRTIO_NET_F_SPEED_DUPLEX, VIRTIO_NET_F_STANDBY
    3278                 :            : 
    3279                 :            : static unsigned int features[] = {
    3280                 :            :         VIRTNET_FEATURES,
    3281                 :            : };
    3282                 :            : 
    3283                 :            : static unsigned int features_legacy[] = {
    3284                 :            :         VIRTNET_FEATURES,
    3285                 :            :         VIRTIO_NET_F_GSO,
    3286                 :            :         VIRTIO_F_ANY_LAYOUT,
    3287                 :            : };
    3288                 :            : 
    3289                 :            : static struct virtio_driver virtio_net_driver = {
    3290                 :            :         .feature_table = features,
    3291                 :            :         .feature_table_size = ARRAY_SIZE(features),
    3292                 :            :         .feature_table_legacy = features_legacy,
    3293                 :            :         .feature_table_size_legacy = ARRAY_SIZE(features_legacy),
    3294                 :            :         .driver.name =  KBUILD_MODNAME,
    3295                 :            :         .driver.owner = THIS_MODULE,
    3296                 :            :         .id_table =     id_table,
    3297                 :            :         .validate =     virtnet_validate,
    3298                 :            :         .probe =        virtnet_probe,
    3299                 :            :         .remove =       virtnet_remove,
    3300                 :            :         .config_changed = virtnet_config_changed,
    3301                 :            : #ifdef CONFIG_PM_SLEEP
    3302                 :            :         .freeze =       virtnet_freeze,
    3303                 :            :         .restore =      virtnet_restore,
    3304                 :            : #endif
    3305                 :            : };
    3306                 :            : 
    3307                 :          3 : static __init int virtio_net_driver_init(void)
    3308                 :            : {
    3309                 :          3 :         int ret;
    3310                 :            : 
    3311                 :          3 :         ret = cpuhp_setup_state_multi(CPUHP_AP_ONLINE_DYN, "virtio/net:online",
    3312                 :            :                                       virtnet_cpu_online,
    3313                 :            :                                       virtnet_cpu_down_prep);
    3314         [ -  + ]:          3 :         if (ret < 0)
    3315                 :          0 :                 goto out;
    3316                 :          3 :         virtionet_online = ret;
    3317                 :          3 :         ret = cpuhp_setup_state_multi(CPUHP_VIRT_NET_DEAD, "virtio/net:dead",
    3318                 :            :                                       NULL, virtnet_cpu_dead);
    3319         [ -  + ]:          3 :         if (ret)
    3320                 :          0 :                 goto err_dead;
    3321                 :            : 
    3322                 :          3 :         ret = register_virtio_driver(&virtio_net_driver);
    3323         [ -  + ]:          3 :         if (ret)
    3324                 :          0 :                 goto err_virtio;
    3325                 :            :         return 0;
    3326                 :            : err_virtio:
    3327                 :          0 :         cpuhp_remove_multi_state(CPUHP_VIRT_NET_DEAD);
    3328                 :          0 : err_dead:
    3329                 :          0 :         cpuhp_remove_multi_state(virtionet_online);
    3330                 :            : out:
    3331                 :            :         return ret;
    3332                 :            : }
    3333                 :            : module_init(virtio_net_driver_init);
    3334                 :            : 
    3335                 :          0 : static __exit void virtio_net_driver_exit(void)
    3336                 :            : {
    3337                 :          0 :         unregister_virtio_driver(&virtio_net_driver);
    3338                 :          0 :         cpuhp_remove_multi_state(CPUHP_VIRT_NET_DEAD);
    3339                 :          0 :         cpuhp_remove_multi_state(virtionet_online);
    3340                 :          0 : }
    3341                 :            : module_exit(virtio_net_driver_exit);
    3342                 :            : 
    3343                 :            : MODULE_DEVICE_TABLE(virtio, id_table);
    3344                 :            : MODULE_DESCRIPTION("Virtio network driver");
    3345                 :            : MODULE_LICENSE("GPL");

Generated by: LCOV version 1.14