1/*
   2 * Virtual network driver for conversing with remote driver backends.
   3 *
   4 * Copyright (c) 2002-2005, K A Fraser
   5 * Copyright (c) 2005, XenSource Ltd
   6 *
   7 * This program is free software; you can redistribute it and/or
   8 * modify it under the terms of the GNU General Public License version 2
   9 * as published by the Free Software Foundation; or, when distributed
  10 * separately from the Linux kernel or incorporated into other
  11 * software packages, subject to the following license:
  12 *
  13 * Permission is hereby granted, free of charge, to any person obtaining a copy
  14 * of this source file (the "Software"), to deal in the Software without
  15 * restriction, including without limitation the rights to use, copy, modify,
  16 * merge, publish, distribute, sublicense, and/or sell copies of the Software,
  17 * and to permit persons to whom the Software is furnished to do so, subject to
  18 * the following conditions:
  19 *
  20 * The above copyright notice and this permission notice shall be included in
  21 * all copies or substantial portions of the Software.
  22 *
  23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  24 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  25 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  26 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  27 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  28 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  29 * IN THE SOFTWARE.
  30 */
  31
  32#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  33
  34#include <linux/module.h>
  35#include <linux/kernel.h>
  36#include <linux/netdevice.h>
  37#include <linux/etherdevice.h>
  38#include <linux/skbuff.h>
  39#include <linux/ethtool.h>
  40#include <linux/if_ether.h>
  41#include <net/tcp.h>
  42#include <linux/udp.h>
  43#include <linux/moduleparam.h>
  44#include <linux/mm.h>
  45#include <linux/slab.h>
  46#include <net/ip.h>
  47#include <linux/bpf.h>
  48#include <net/page_pool.h>
  49#include <linux/bpf_trace.h>
  50
  51#include <xen/xen.h>
  52#include <xen/xenbus.h>
  53#include <xen/events.h>
  54#include <xen/page.h>
  55#include <xen/platform_pci.h>
  56#include <xen/grant_table.h>
  57
  58#include <xen/interface/io/netif.h>
  59#include <xen/interface/memory.h>
  60#include <xen/interface/grant_table.h>
  61
  62/* Module parameters */
  63#define MAX_QUEUES_DEFAULT 8
  64static unsigned int xennet_max_queues;
  65module_param_named(max_queues, xennet_max_queues, uint, 0644);
  66MODULE_PARM_DESC(max_queues,
  67		 "Maximum number of queues per virtual interface");
  68
  69#define XENNET_TIMEOUT  (5 * HZ)
  70
  71static const struct ethtool_ops xennet_ethtool_ops;
  72
  73struct netfront_cb {
  74	int pull_to;
 
  75};
  76
  77#define NETFRONT_SKB_CB(skb)	((struct netfront_cb *)((skb)->cb))
  78
  79#define RX_COPY_THRESHOLD 256
  80
  81#define GRANT_INVALID_REF	0
  82
  83#define NET_TX_RING_SIZE __CONST_RING_SIZE(xen_netif_tx, XEN_PAGE_SIZE)
  84#define NET_RX_RING_SIZE __CONST_RING_SIZE(xen_netif_rx, XEN_PAGE_SIZE)
  85
  86/* Minimum number of Rx slots (includes slot for GSO metadata). */
  87#define NET_RX_SLOTS_MIN (XEN_NETIF_NR_SLOTS_MIN + 1)
  88
  89/* Queue name is interface name with "-qNNN" appended */
  90#define QUEUE_NAME_SIZE (IFNAMSIZ + 6)
  91
  92/* IRQ name is queue name with "-tx" or "-rx" appended */
  93#define IRQ_NAME_SIZE (QUEUE_NAME_SIZE + 3)
  94
  95static DECLARE_WAIT_QUEUE_HEAD(module_wq);
  96
  97struct netfront_stats {
  98	u64			packets;
  99	u64			bytes;
 
 
 100	struct u64_stats_sync	syncp;
 101};
 102
 103struct netfront_info;
 104
 105struct netfront_queue {
 106	unsigned int id; /* Queue ID, 0-based */
 107	char name[QUEUE_NAME_SIZE]; /* DEVNAME-qN */
 108	struct netfront_info *info;
 109
 110	struct bpf_prog __rcu *xdp_prog;
 111
 112	struct napi_struct napi;
 113
 114	/* Split event channels support, tx_* == rx_* when using
 115	 * single event channel.
 116	 */
 117	unsigned int tx_evtchn, rx_evtchn;
 118	unsigned int tx_irq, rx_irq;
 119	/* Only used when split event channels support is enabled */
 120	char tx_irq_name[IRQ_NAME_SIZE]; /* DEVNAME-qN-tx */
 121	char rx_irq_name[IRQ_NAME_SIZE]; /* DEVNAME-qN-rx */
 122
 123	spinlock_t   tx_lock;
 124	struct xen_netif_tx_front_ring tx;
 125	int tx_ring_ref;
 126
 127	/*
 128	 * {tx,rx}_skbs store outstanding skbuffs. Free tx_skb entries
 129	 * are linked from tx_skb_freelist through skb_entry.link.
 130	 *
 131	 *  NB. Freelist index entries are always going to be less than
 132	 *  PAGE_OFFSET, whereas pointers to skbs will always be equal or
 133	 *  greater than PAGE_OFFSET: we use this property to distinguish
 134	 *  them.
 135	 */
 136	union skb_entry {
 137		struct sk_buff *skb;
 138		unsigned long link;
 139	} tx_skbs[NET_TX_RING_SIZE];
 140	grant_ref_t gref_tx_head;
 141	grant_ref_t grant_tx_ref[NET_TX_RING_SIZE];
 142	struct page *grant_tx_page[NET_TX_RING_SIZE];
 143	unsigned tx_skb_freelist;
 144
 145	spinlock_t   rx_lock ____cacheline_aligned_in_smp;
 146	struct xen_netif_rx_front_ring rx;
 147	int rx_ring_ref;
 148
 
 
 
 
 
 
 
 149	struct timer_list rx_refill_timer;
 150
 151	struct sk_buff *rx_skbs[NET_RX_RING_SIZE];
 152	grant_ref_t gref_rx_head;
 153	grant_ref_t grant_rx_ref[NET_RX_RING_SIZE];
 154
 155	struct page_pool *page_pool;
 156	struct xdp_rxq_info xdp_rxq;
 157};
 158
 159struct netfront_info {
 160	struct list_head list;
 161	struct net_device *netdev;
 162
 163	struct xenbus_device *xbdev;
 164
 165	/* Multi-queue support */
 166	struct netfront_queue *queues;
 167
 168	/* Statistics */
 169	struct netfront_stats __percpu *rx_stats;
 170	struct netfront_stats __percpu *tx_stats;
 171
 172	/* XDP state */
 173	bool netback_has_xdp_headroom;
 174	bool netfront_xdp_enabled;
 175
 176	atomic_t rx_gso_checksum_fixup;
 177};
 178
 179struct netfront_rx_info {
 180	struct xen_netif_rx_response rx;
 181	struct xen_netif_extra_info extras[XEN_NETIF_EXTRA_TYPE_MAX - 1];
 182};
 183
 184static void skb_entry_set_link(union skb_entry *list, unsigned short id)
 185{
 186	list->link = id;
 187}
 188
 189static int skb_entry_is_link(const union skb_entry *list)
 190{
 191	BUILD_BUG_ON(sizeof(list->skb) != sizeof(list->link));
 192	return (unsigned long)list->skb < PAGE_OFFSET;
 193}
 194
 195/*
 196 * Access macros for acquiring freeing slots in tx_skbs[].
 197 */
 198
 199static void add_id_to_freelist(unsigned *head, union skb_entry *list,
 200			       unsigned short id)
 201{
 202	skb_entry_set_link(&list[id], *head);
 203	*head = id;
 204}
 205
 206static unsigned short get_id_from_freelist(unsigned *head,
 207					   union skb_entry *list)
 208{
 209	unsigned int id = *head;
 210	*head = list[id].link;
 211	return id;
 212}
 213
 214static int xennet_rxidx(RING_IDX idx)
 215{
 216	return idx & (NET_RX_RING_SIZE - 1);
 217}
 218
 219static struct sk_buff *xennet_get_rx_skb(struct netfront_queue *queue,
 220					 RING_IDX ri)
 221{
 222	int i = xennet_rxidx(ri);
 223	struct sk_buff *skb = queue->rx_skbs[i];
 224	queue->rx_skbs[i] = NULL;
 225	return skb;
 226}
 227
 228static grant_ref_t xennet_get_rx_ref(struct netfront_queue *queue,
 229					    RING_IDX ri)
 230{
 231	int i = xennet_rxidx(ri);
 232	grant_ref_t ref = queue->grant_rx_ref[i];
 233	queue->grant_rx_ref[i] = GRANT_INVALID_REF;
 234	return ref;
 235}
 236
 237#ifdef CONFIG_SYSFS
 238static const struct attribute_group xennet_dev_group;
 
 
 
 
 239#endif
 240
 241static bool xennet_can_sg(struct net_device *dev)
 242{
 243	return dev->features & NETIF_F_SG;
 244}
 245
 246
 247static void rx_refill_timeout(struct timer_list *t)
 248{
 249	struct netfront_queue *queue = from_timer(queue, t, rx_refill_timer);
 250	napi_schedule(&queue->napi);
 
 251}
 252
 253static int netfront_tx_slot_available(struct netfront_queue *queue)
 254{
 255	return (queue->tx.req_prod_pvt - queue->tx.rsp_cons) <
 256		(NET_TX_RING_SIZE - XEN_NETIF_NR_SLOTS_MIN - 1);
 257}
 258
 259static void xennet_maybe_wake_tx(struct netfront_queue *queue)
 260{
 261	struct net_device *dev = queue->info->netdev;
 262	struct netdev_queue *dev_queue = netdev_get_tx_queue(dev, queue->id);
 263
 264	if (unlikely(netif_tx_queue_stopped(dev_queue)) &&
 265	    netfront_tx_slot_available(queue) &&
 266	    likely(netif_running(dev)))
 267		netif_tx_wake_queue(netdev_get_tx_queue(dev, queue->id));
 268}
 269
 270
 271static struct sk_buff *xennet_alloc_one_rx_buffer(struct netfront_queue *queue)
 272{
 
 
 273	struct sk_buff *skb;
 274	struct page *page;
 
 
 
 
 
 
 275
 276	skb = __netdev_alloc_skb(queue->info->netdev,
 277				 RX_COPY_THRESHOLD + NET_IP_ALIGN,
 278				 GFP_ATOMIC | __GFP_NOWARN);
 279	if (unlikely(!skb))
 280		return NULL;
 281
 282	page = page_pool_dev_alloc_pages(queue->page_pool);
 283	if (unlikely(!page)) {
 284		kfree_skb(skb);
 285		return NULL;
 286	}
 287	skb_add_rx_frag(skb, 0, page, 0, 0, PAGE_SIZE);
 288
 289	/* Align ip header to a 16 bytes boundary */
 290	skb_reserve(skb, NET_IP_ALIGN);
 291	skb->dev = queue->info->netdev;
 292
 293	return skb;
 294}
 
 
 
 
 
 
 
 
 
 
 295
 
 
 296
 297static void xennet_alloc_rx_buffers(struct netfront_queue *queue)
 298{
 299	RING_IDX req_prod = queue->rx.req_prod_pvt;
 300	int notify;
 301	int err = 0;
 
 
 
 
 
 
 
 302
 303	if (unlikely(!netif_carrier_ok(queue->info->netdev)))
 304		return;
 
 
 305
 306	for (req_prod = queue->rx.req_prod_pvt;
 307	     req_prod - queue->rx.rsp_cons < NET_RX_RING_SIZE;
 308	     req_prod++) {
 309		struct sk_buff *skb;
 310		unsigned short id;
 311		grant_ref_t ref;
 312		struct page *page;
 313		struct xen_netif_rx_request *req;
 314
 315		skb = xennet_alloc_one_rx_buffer(queue);
 316		if (!skb) {
 317			err = -ENOMEM;
 
 
 
 
 
 
 318			break;
 319		}
 320
 321		id = xennet_rxidx(req_prod);
 
 
 
 
 
 
 
 
 
 
 
 
 322
 323		BUG_ON(queue->rx_skbs[id]);
 324		queue->rx_skbs[id] = skb;
 
 
 
 325
 326		ref = gnttab_claim_grant_reference(&queue->gref_rx_head);
 327		WARN_ON_ONCE(IS_ERR_VALUE((unsigned long)(int)ref));
 328		queue->grant_rx_ref[id] = ref;
 329
 330		page = skb_frag_page(&skb_shinfo(skb)->frags[0]);
 331
 332		req = RING_GET_REQUEST(&queue->rx, req_prod);
 333		gnttab_page_grant_foreign_access_ref_one(ref,
 334							 queue->info->xbdev->otherend_id,
 335							 page,
 336							 0);
 337		req->id = id;
 338		req->gref = ref;
 339	}
 340
 341	queue->rx.req_prod_pvt = req_prod;
 342
 343	/* Try again later if there are not enough requests or skb allocation
 344	 * failed.
 345	 * Enough requests is quantified as the sum of newly created slots and
 346	 * the unconsumed slots at the backend.
 347	 */
 348	if (req_prod - queue->rx.rsp_cons < NET_RX_SLOTS_MIN ||
 349	    unlikely(err)) {
 350		mod_timer(&queue->rx_refill_timer, jiffies + (HZ/10));
 351		return;
 352	}
 353
 354	RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(&queue->rx, notify);
 
 
 
 355	if (notify)
 356		notify_remote_via_irq(queue->rx_irq);
 357}
 358
 359static int xennet_open(struct net_device *dev)
 360{
 361	struct netfront_info *np = netdev_priv(dev);
 362	unsigned int num_queues = dev->real_num_tx_queues;
 363	unsigned int i = 0;
 364	struct netfront_queue *queue = NULL;
 365
 366	if (!np->queues)
 367		return -ENODEV;
 368
 369	for (i = 0; i < num_queues; ++i) {
 370		queue = &np->queues[i];
 371		napi_enable(&queue->napi);
 372
 373		spin_lock_bh(&queue->rx_lock);
 374		if (netif_carrier_ok(dev)) {
 375			xennet_alloc_rx_buffers(queue);
 376			queue->rx.sring->rsp_event = queue->rx.rsp_cons + 1;
 377			if (RING_HAS_UNCONSUMED_RESPONSES(&queue->rx))
 378				napi_schedule(&queue->napi);
 379		}
 380		spin_unlock_bh(&queue->rx_lock);
 381	}
 
 382
 383	netif_tx_start_all_queues(dev);
 384
 385	return 0;
 386}
 387
 388static void xennet_tx_buf_gc(struct netfront_queue *queue)
 389{
 390	RING_IDX cons, prod;
 391	unsigned short id;
 
 392	struct sk_buff *skb;
 393	bool more_to_do;
 394
 395	BUG_ON(!netif_carrier_ok(queue->info->netdev));
 396
 397	do {
 398		prod = queue->tx.sring->rsp_prod;
 399		rmb(); /* Ensure we see responses up to 'rp'. */
 400
 401		for (cons = queue->tx.rsp_cons; cons != prod; cons++) {
 402			struct xen_netif_tx_response *txrsp;
 403
 404			txrsp = RING_GET_RESPONSE(&queue->tx, cons);
 405			if (txrsp->status == XEN_NETIF_RSP_NULL)
 406				continue;
 407
 408			id  = txrsp->id;
 409			skb = queue->tx_skbs[id].skb;
 410			if (unlikely(gnttab_query_foreign_access(
 411				queue->grant_tx_ref[id]) != 0)) {
 412				pr_alert("%s: warning -- grant still in use by backend domain\n",
 413					 __func__);
 
 414				BUG();
 415			}
 416			gnttab_end_foreign_access_ref(
 417				queue->grant_tx_ref[id], GNTMAP_readonly);
 418			gnttab_release_grant_reference(
 419				&queue->gref_tx_head, queue->grant_tx_ref[id]);
 420			queue->grant_tx_ref[id] = GRANT_INVALID_REF;
 421			queue->grant_tx_page[id] = NULL;
 422			add_id_to_freelist(&queue->tx_skb_freelist, queue->tx_skbs, id);
 423			dev_kfree_skb_irq(skb);
 424		}
 425
 426		queue->tx.rsp_cons = prod;
 427
 428		RING_FINAL_CHECK_FOR_RESPONSES(&queue->tx, more_to_do);
 429	} while (more_to_do);
 
 
 
 
 
 
 
 
 
 
 430
 431	xennet_maybe_wake_tx(queue);
 432}
 433
 434struct xennet_gnttab_make_txreq {
 435	struct netfront_queue *queue;
 436	struct sk_buff *skb;
 437	struct page *page;
 438	struct xen_netif_tx_request *tx; /* Last request */
 439	unsigned int size;
 440};
 441
 442static void xennet_tx_setup_grant(unsigned long gfn, unsigned int offset,
 443				  unsigned int len, void *data)
 444{
 445	struct xennet_gnttab_make_txreq *info = data;
 
 
 
 
 
 
 446	unsigned int id;
 447	struct xen_netif_tx_request *tx;
 448	grant_ref_t ref;
 449	/* convenient aliases */
 450	struct page *page = info->page;
 451	struct netfront_queue *queue = info->queue;
 452	struct sk_buff *skb = info->skb;
 453
 454	id = get_id_from_freelist(&queue->tx_skb_freelist, queue->tx_skbs);
 455	tx = RING_GET_REQUEST(&queue->tx, queue->tx.req_prod_pvt++);
 456	ref = gnttab_claim_grant_reference(&queue->gref_tx_head);
 457	WARN_ON_ONCE(IS_ERR_VALUE((unsigned long)(int)ref));
 458
 459	gnttab_grant_foreign_access_ref(ref, queue->info->xbdev->otherend_id,
 460					gfn, GNTMAP_readonly);
 461
 462	queue->tx_skbs[id].skb = skb;
 463	queue->grant_tx_page[id] = page;
 464	queue->grant_tx_ref[id] = ref;
 465
 466	tx->id = id;
 467	tx->gref = ref;
 468	tx->offset = offset;
 469	tx->size = len;
 470	tx->flags = 0;
 471
 472	info->tx = tx;
 473	info->size += tx->size;
 474}
 475
 476static struct xen_netif_tx_request *xennet_make_first_txreq(
 477	struct netfront_queue *queue, struct sk_buff *skb,
 478	struct page *page, unsigned int offset, unsigned int len)
 479{
 480	struct xennet_gnttab_make_txreq info = {
 481		.queue = queue,
 482		.skb = skb,
 483		.page = page,
 484		.size = 0,
 485	};
 486
 487	gnttab_for_one_grant(page, offset, len, xennet_tx_setup_grant, &info);
 488
 489	return info.tx;
 490}
 491
 492static void xennet_make_one_txreq(unsigned long gfn, unsigned int offset,
 493				  unsigned int len, void *data)
 494{
 495	struct xennet_gnttab_make_txreq *info = data;
 496
 497	info->tx->flags |= XEN_NETTXF_more_data;
 498	skb_get(info->skb);
 499	xennet_tx_setup_grant(gfn, offset, len, data);
 500}
 501
 502static struct xen_netif_tx_request *xennet_make_txreqs(
 503	struct netfront_queue *queue, struct xen_netif_tx_request *tx,
 504	struct sk_buff *skb, struct page *page,
 505	unsigned int offset, unsigned int len)
 506{
 507	struct xennet_gnttab_make_txreq info = {
 508		.queue = queue,
 509		.skb = skb,
 510		.tx = tx,
 511	};
 512
 513	/* Skip unused frames from start of page */
 514	page += offset >> PAGE_SHIFT;
 515	offset &= ~PAGE_MASK;
 516
 517	while (len) {
 518		info.page = page;
 519		info.size = 0;
 520
 521		gnttab_foreach_grant_in_range(page, offset, len,
 522					      xennet_make_one_txreq,
 523					      &info);
 524
 525		page++;
 
 
 
 
 
 
 526		offset = 0;
 527		len -= info.size;
 528	}
 529
 530	return info.tx;
 531}
 532
 533/*
 534 * Count how many ring slots are required to send this skb. Each frag
 535 * might be a compound page.
 536 */
 537static int xennet_count_skb_slots(struct sk_buff *skb)
 538{
 539	int i, frags = skb_shinfo(skb)->nr_frags;
 540	int slots;
 541
 542	slots = gnttab_count_grant(offset_in_page(skb->data),
 543				   skb_headlen(skb));
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 544
 
 545	for (i = 0; i < frags; i++) {
 546		skb_frag_t *frag = skb_shinfo(skb)->frags + i;
 547		unsigned long size = skb_frag_size(frag);
 548		unsigned long offset = skb_frag_off(frag);
 549
 550		/* Skip unused frames from start of page */
 551		offset &= ~PAGE_MASK;
 552
 553		slots += gnttab_count_grant(offset, size);
 554	}
 
 
 
 
 555
 556	return slots;
 557}
 558
 559static u16 xennet_select_queue(struct net_device *dev, struct sk_buff *skb,
 560			       struct net_device *sb_dev)
 561{
 562	unsigned int num_queues = dev->real_num_tx_queues;
 563	u32 hash;
 564	u16 queue_idx;
 565
 566	/* First, check if there is only one queue */
 567	if (num_queues == 1) {
 568		queue_idx = 0;
 569	} else {
 570		hash = skb_get_hash(skb);
 571		queue_idx = hash % num_queues;
 572	}
 573
 574	return queue_idx;
 575}
 576
 577static int xennet_xdp_xmit_one(struct net_device *dev,
 578			       struct netfront_queue *queue,
 579			       struct xdp_frame *xdpf)
 580{
 581	struct netfront_info *np = netdev_priv(dev);
 582	struct netfront_stats *tx_stats = this_cpu_ptr(np->tx_stats);
 583	int notify;
 584
 585	xennet_make_first_txreq(queue, NULL,
 586				virt_to_page(xdpf->data),
 587				offset_in_page(xdpf->data),
 588				xdpf->len);
 589
 590	RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(&queue->tx, notify);
 591	if (notify)
 592		notify_remote_via_irq(queue->tx_irq);
 593
 594	u64_stats_update_begin(&tx_stats->syncp);
 595	tx_stats->bytes += xdpf->len;
 596	tx_stats->packets++;
 597	u64_stats_update_end(&tx_stats->syncp);
 598
 599	xennet_tx_buf_gc(queue);
 600
 601	return 0;
 602}
 603
 604static int xennet_xdp_xmit(struct net_device *dev, int n,
 605			   struct xdp_frame **frames, u32 flags)
 606{
 607	unsigned int num_queues = dev->real_num_tx_queues;
 608	struct netfront_info *np = netdev_priv(dev);
 609	struct netfront_queue *queue = NULL;
 610	unsigned long irq_flags;
 611	int nxmit = 0;
 612	int i;
 613
 614	if (unlikely(flags & ~XDP_XMIT_FLAGS_MASK))
 615		return -EINVAL;
 616
 617	queue = &np->queues[smp_processor_id() % num_queues];
 618
 619	spin_lock_irqsave(&queue->tx_lock, irq_flags);
 620	for (i = 0; i < n; i++) {
 621		struct xdp_frame *xdpf = frames[i];
 622
 623		if (!xdpf)
 624			continue;
 625		if (xennet_xdp_xmit_one(dev, queue, xdpf))
 626			break;
 627		nxmit++;
 628	}
 629	spin_unlock_irqrestore(&queue->tx_lock, irq_flags);
 630
 631	return nxmit;
 632}
 633
 634
 635#define MAX_XEN_SKB_FRAGS (65536 / XEN_PAGE_SIZE + 1)
 636
 637static netdev_tx_t xennet_start_xmit(struct sk_buff *skb, struct net_device *dev)
 638{
 
 639	struct netfront_info *np = netdev_priv(dev);
 640	struct netfront_stats *tx_stats = this_cpu_ptr(np->tx_stats);
 641	struct xen_netif_tx_request *tx, *first_tx;
 642	unsigned int i;
 
 
 
 
 643	int notify;
 644	int slots;
 645	struct page *page;
 646	unsigned int offset;
 647	unsigned int len;
 648	unsigned long flags;
 649	struct netfront_queue *queue = NULL;
 650	unsigned int num_queues = dev->real_num_tx_queues;
 651	u16 queue_index;
 652	struct sk_buff *nskb;
 653
 654	/* Drop the packet if no queues are set up */
 655	if (num_queues < 1)
 656		goto drop;
 657	/* Determine which queue to transmit this SKB on */
 658	queue_index = skb_get_queue_mapping(skb);
 659	queue = &np->queues[queue_index];
 660
 661	/* If skb->len is too big for wire format, drop skb and alert
 662	 * user about misconfiguration.
 663	 */
 664	if (unlikely(skb->len > XEN_NETIF_MAX_TX_SIZE)) {
 665		net_alert_ratelimited(
 666			"xennet: skb->len = %u, too big for wire format\n",
 667			skb->len);
 668		goto drop;
 669	}
 670
 671	slots = xennet_count_skb_slots(skb);
 672	if (unlikely(slots > MAX_XEN_SKB_FRAGS + 1)) {
 673		net_dbg_ratelimited("xennet: skb rides the rocket: %d slots, %d bytes\n",
 674				    slots, skb->len);
 675		if (skb_linearize(skb))
 676			goto drop;
 677	}
 678
 679	page = virt_to_page(skb->data);
 680	offset = offset_in_page(skb->data);
 681
 682	/* The first req should be at least ETH_HLEN size or the packet will be
 683	 * dropped by netback.
 684	 */
 685	if (unlikely(PAGE_SIZE - offset < ETH_HLEN)) {
 686		nskb = skb_copy(skb, GFP_ATOMIC);
 687		if (!nskb)
 688			goto drop;
 689		dev_consume_skb_any(skb);
 690		skb = nskb;
 691		page = virt_to_page(skb->data);
 692		offset = offset_in_page(skb->data);
 693	}
 694
 695	len = skb_headlen(skb);
 696
 697	spin_lock_irqsave(&queue->tx_lock, flags);
 698
 699	if (unlikely(!netif_carrier_ok(dev) ||
 700		     (slots > 1 && !xennet_can_sg(dev)) ||
 701		     netif_needs_gso(skb, netif_skb_features(skb)))) {
 702		spin_unlock_irqrestore(&queue->tx_lock, flags);
 703		goto drop;
 704	}
 705
 706	/* First request for the linear area. */
 707	first_tx = tx = xennet_make_first_txreq(queue, skb,
 708						page, offset, len);
 709	offset += tx->size;
 710	if (offset == PAGE_SIZE) {
 711		page++;
 712		offset = 0;
 713	}
 714	len -= tx->size;
 
 
 
 
 
 
 
 
 715
 
 716	if (skb->ip_summed == CHECKSUM_PARTIAL)
 717		/* local packet? */
 718		tx->flags |= XEN_NETTXF_csum_blank | XEN_NETTXF_data_validated;
 719	else if (skb->ip_summed == CHECKSUM_UNNECESSARY)
 720		/* remote but checksummed. */
 721		tx->flags |= XEN_NETTXF_data_validated;
 722
 723	/* Optional extra info after the first request. */
 724	if (skb_shinfo(skb)->gso_size) {
 725		struct xen_netif_extra_info *gso;
 726
 727		gso = (struct xen_netif_extra_info *)
 728			RING_GET_REQUEST(&queue->tx, queue->tx.req_prod_pvt++);
 729
 730		tx->flags |= XEN_NETTXF_extra_info;
 
 
 
 731
 732		gso->u.gso.size = skb_shinfo(skb)->gso_size;
 733		gso->u.gso.type = (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6) ?
 734			XEN_NETIF_GSO_TYPE_TCPV6 :
 735			XEN_NETIF_GSO_TYPE_TCPV4;
 736		gso->u.gso.pad = 0;
 737		gso->u.gso.features = 0;
 738
 739		gso->type = XEN_NETIF_EXTRA_TYPE_GSO;
 740		gso->flags = 0;
 
 741	}
 742
 743	/* Requests for the rest of the linear area. */
 744	tx = xennet_make_txreqs(queue, tx, skb, page, offset, len);
 745
 746	/* Requests for all the frags. */
 747	for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
 748		skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
 749		tx = xennet_make_txreqs(queue, tx, skb, skb_frag_page(frag),
 750					skb_frag_off(frag),
 751					skb_frag_size(frag));
 752	}
 753
 754	/* First request has the packet length. */
 755	first_tx->size = skb->len;
 756
 757	/* timestamp packet in software */
 758	skb_tx_timestamp(skb);
 759
 760	RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(&queue->tx, notify);
 761	if (notify)
 762		notify_remote_via_irq(queue->tx_irq);
 763
 764	u64_stats_update_begin(&tx_stats->syncp);
 765	tx_stats->bytes += skb->len;
 766	tx_stats->packets++;
 767	u64_stats_update_end(&tx_stats->syncp);
 768
 769	/* Note: It is not safe to access skb after xennet_tx_buf_gc()! */
 770	xennet_tx_buf_gc(queue);
 771
 772	if (!netfront_tx_slot_available(queue))
 773		netif_tx_stop_queue(netdev_get_tx_queue(dev, queue->id));
 774
 775	spin_unlock_irqrestore(&queue->tx_lock, flags);
 776
 777	return NETDEV_TX_OK;
 778
 779 drop:
 780	dev->stats.tx_dropped++;
 781	dev_kfree_skb_any(skb);
 782	return NETDEV_TX_OK;
 783}
 784
 785static int xennet_close(struct net_device *dev)
 786{
 787	struct netfront_info *np = netdev_priv(dev);
 788	unsigned int num_queues = dev->real_num_tx_queues;
 789	unsigned int i;
 790	struct netfront_queue *queue;
 791	netif_tx_stop_all_queues(np->netdev);
 792	for (i = 0; i < num_queues; ++i) {
 793		queue = &np->queues[i];
 794		napi_disable(&queue->napi);
 795	}
 796	return 0;
 797}
 798
 799static void xennet_move_rx_slot(struct netfront_queue *queue, struct sk_buff *skb,
 800				grant_ref_t ref)
 801{
 802	int new = xennet_rxidx(queue->rx.req_prod_pvt);
 803
 804	BUG_ON(queue->rx_skbs[new]);
 805	queue->rx_skbs[new] = skb;
 806	queue->grant_rx_ref[new] = ref;
 807	RING_GET_REQUEST(&queue->rx, queue->rx.req_prod_pvt)->id = new;
 808	RING_GET_REQUEST(&queue->rx, queue->rx.req_prod_pvt)->gref = ref;
 809	queue->rx.req_prod_pvt++;
 810}
 811
 812static int xennet_get_extras(struct netfront_queue *queue,
 813			     struct xen_netif_extra_info *extras,
 814			     RING_IDX rp)
 815
 816{
 817	struct xen_netif_extra_info *extra;
 818	struct device *dev = &queue->info->netdev->dev;
 819	RING_IDX cons = queue->rx.rsp_cons;
 820	int err = 0;
 821
 822	do {
 823		struct sk_buff *skb;
 824		grant_ref_t ref;
 825
 826		if (unlikely(cons + 1 == rp)) {
 827			if (net_ratelimit())
 828				dev_warn(dev, "Missing extra info\n");
 829			err = -EBADR;
 830			break;
 831		}
 832
 833		extra = (struct xen_netif_extra_info *)
 834			RING_GET_RESPONSE(&queue->rx, ++cons);
 835
 836		if (unlikely(!extra->type ||
 837			     extra->type >= XEN_NETIF_EXTRA_TYPE_MAX)) {
 838			if (net_ratelimit())
 839				dev_warn(dev, "Invalid extra type: %d\n",
 840					extra->type);
 841			err = -EINVAL;
 842		} else {
 843			memcpy(&extras[extra->type - 1], extra,
 844			       sizeof(*extra));
 845		}
 846
 847		skb = xennet_get_rx_skb(queue, cons);
 848		ref = xennet_get_rx_ref(queue, cons);
 849		xennet_move_rx_slot(queue, skb, ref);
 850	} while (extra->flags & XEN_NETIF_EXTRA_FLAG_MORE);
 851
 852	queue->rx.rsp_cons = cons;
 853	return err;
 854}
 855
 856static u32 xennet_run_xdp(struct netfront_queue *queue, struct page *pdata,
 857		   struct xen_netif_rx_response *rx, struct bpf_prog *prog,
 858		   struct xdp_buff *xdp, bool *need_xdp_flush)
 859{
 860	struct xdp_frame *xdpf;
 861	u32 len = rx->status;
 862	u32 act;
 863	int err;
 864
 865	xdp_init_buff(xdp, XEN_PAGE_SIZE - XDP_PACKET_HEADROOM,
 866		      &queue->xdp_rxq);
 867	xdp_prepare_buff(xdp, page_address(pdata), XDP_PACKET_HEADROOM,
 868			 len, false);
 869
 870	act = bpf_prog_run_xdp(prog, xdp);
 871	switch (act) {
 872	case XDP_TX:
 873		get_page(pdata);
 874		xdpf = xdp_convert_buff_to_frame(xdp);
 875		err = xennet_xdp_xmit(queue->info->netdev, 1, &xdpf, 0);
 876		if (unlikely(!err))
 877			xdp_return_frame_rx_napi(xdpf);
 878		else if (unlikely(err < 0))
 879			trace_xdp_exception(queue->info->netdev, prog, act);
 880		break;
 881	case XDP_REDIRECT:
 882		get_page(pdata);
 883		err = xdp_do_redirect(queue->info->netdev, xdp, prog);
 884		*need_xdp_flush = true;
 885		if (unlikely(err))
 886			trace_xdp_exception(queue->info->netdev, prog, act);
 887		break;
 888	case XDP_PASS:
 889	case XDP_DROP:
 890		break;
 891
 892	case XDP_ABORTED:
 893		trace_xdp_exception(queue->info->netdev, prog, act);
 894		break;
 895
 896	default:
 897		bpf_warn_invalid_xdp_action(act);
 898	}
 899
 900	return act;
 901}
 902
 903static int xennet_get_responses(struct netfront_queue *queue,
 904				struct netfront_rx_info *rinfo, RING_IDX rp,
 905				struct sk_buff_head *list,
 906				bool *need_xdp_flush)
 907{
 908	struct xen_netif_rx_response *rx = &rinfo->rx;
 909	int max = XEN_NETIF_NR_SLOTS_MIN + (rx->status <= RX_COPY_THRESHOLD);
 910	RING_IDX cons = queue->rx.rsp_cons;
 911	struct sk_buff *skb = xennet_get_rx_skb(queue, cons);
 912	struct xen_netif_extra_info *extras = rinfo->extras;
 913	grant_ref_t ref = xennet_get_rx_ref(queue, cons);
 914	struct device *dev = &queue->info->netdev->dev;
 915	struct bpf_prog *xdp_prog;
 916	struct xdp_buff xdp;
 917	unsigned long ret;
 918	int slots = 1;
 919	int err = 0;
 920	u32 verdict;
 921
 922	if (rx->flags & XEN_NETRXF_extra_info) {
 923		err = xennet_get_extras(queue, extras, rp);
 924		if (!err) {
 925			if (extras[XEN_NETIF_EXTRA_TYPE_XDP - 1].type) {
 926				struct xen_netif_extra_info *xdp;
 927
 928				xdp = &extras[XEN_NETIF_EXTRA_TYPE_XDP - 1];
 929				rx->offset = xdp->u.xdp.headroom;
 930			}
 931		}
 932		cons = queue->rx.rsp_cons;
 933	}
 934
 935	for (;;) {
 936		if (unlikely(rx->status < 0 ||
 937			     rx->offset + rx->status > XEN_PAGE_SIZE)) {
 938			if (net_ratelimit())
 939				dev_warn(dev, "rx->offset: %u, size: %d\n",
 940					 rx->offset, rx->status);
 941			xennet_move_rx_slot(queue, skb, ref);
 942			err = -EINVAL;
 943			goto next;
 944		}
 945
 946		/*
 947		 * This definitely indicates a bug, either in this driver or in
 948		 * the backend driver. In future this should flag the bad
 949		 * situation to the system controller to reboot the backend.
 950		 */
 951		if (ref == GRANT_INVALID_REF) {
 952			if (net_ratelimit())
 953				dev_warn(dev, "Bad rx response id %d.\n",
 954					 rx->id);
 955			err = -EINVAL;
 956			goto next;
 957		}
 958
 959		ret = gnttab_end_foreign_access_ref(ref, 0);
 960		BUG_ON(!ret);
 961
 962		gnttab_release_grant_reference(&queue->gref_rx_head, ref);
 963
 964		rcu_read_lock();
 965		xdp_prog = rcu_dereference(queue->xdp_prog);
 966		if (xdp_prog) {
 967			if (!(rx->flags & XEN_NETRXF_more_data)) {
 968				/* currently only a single page contains data */
 969				verdict = xennet_run_xdp(queue,
 970							 skb_frag_page(&skb_shinfo(skb)->frags[0]),
 971							 rx, xdp_prog, &xdp, need_xdp_flush);
 972				if (verdict != XDP_PASS)
 973					err = -EINVAL;
 974			} else {
 975				/* drop the frame */
 976				err = -EINVAL;
 977			}
 978		}
 979		rcu_read_unlock();
 980next:
 981		__skb_queue_tail(list, skb);
 
 
 982		if (!(rx->flags & XEN_NETRXF_more_data))
 983			break;
 984
 985		if (cons + slots == rp) {
 986			if (net_ratelimit())
 987				dev_warn(dev, "Need more slots\n");
 988			err = -ENOENT;
 989			break;
 990		}
 991
 992		rx = RING_GET_RESPONSE(&queue->rx, cons + slots);
 993		skb = xennet_get_rx_skb(queue, cons + slots);
 994		ref = xennet_get_rx_ref(queue, cons + slots);
 995		slots++;
 996	}
 997
 998	if (unlikely(slots > max)) {
 999		if (net_ratelimit())
1000			dev_warn(dev, "Too many slots\n");
1001		err = -E2BIG;
1002	}
1003
1004	if (unlikely(err))
1005		queue->rx.rsp_cons = cons + slots;
1006
1007	return err;
1008}
1009
1010static int xennet_set_skb_gso(struct sk_buff *skb,
1011			      struct xen_netif_extra_info *gso)
1012{
1013	if (!gso->u.gso.size) {
1014		if (net_ratelimit())
1015			pr_warn("GSO size must not be zero\n");
1016		return -EINVAL;
1017	}
1018
1019	if (gso->u.gso.type != XEN_NETIF_GSO_TYPE_TCPV4 &&
1020	    gso->u.gso.type != XEN_NETIF_GSO_TYPE_TCPV6) {
1021		if (net_ratelimit())
1022			pr_warn("Bad GSO type %d\n", gso->u.gso.type);
1023		return -EINVAL;
1024	}
1025
1026	skb_shinfo(skb)->gso_size = gso->u.gso.size;
1027	skb_shinfo(skb)->gso_type =
1028		(gso->u.gso.type == XEN_NETIF_GSO_TYPE_TCPV4) ?
1029		SKB_GSO_TCPV4 :
1030		SKB_GSO_TCPV6;
1031
1032	/* Header must be checked, and gso_segs computed. */
1033	skb_shinfo(skb)->gso_type |= SKB_GSO_DODGY;
1034	skb_shinfo(skb)->gso_segs = 0;
1035
1036	return 0;
1037}
1038
1039static int xennet_fill_frags(struct netfront_queue *queue,
1040			     struct sk_buff *skb,
1041			     struct sk_buff_head *list)
1042{
1043	RING_IDX cons = queue->rx.rsp_cons;
 
 
1044	struct sk_buff *nskb;
1045
1046	while ((nskb = __skb_dequeue(list))) {
1047		struct xen_netif_rx_response *rx =
1048			RING_GET_RESPONSE(&queue->rx, ++cons);
1049		skb_frag_t *nfrag = &skb_shinfo(nskb)->frags[0];
1050
1051		if (skb_shinfo(skb)->nr_frags == MAX_SKB_FRAGS) {
1052			unsigned int pull_to = NETFRONT_SKB_CB(skb)->pull_to;
 
1053
1054			BUG_ON(pull_to < skb_headlen(skb));
1055			__pskb_pull_tail(skb, pull_to - skb_headlen(skb));
1056		}
1057		if (unlikely(skb_shinfo(skb)->nr_frags >= MAX_SKB_FRAGS)) {
1058			queue->rx.rsp_cons = ++cons + skb_queue_len(list);
1059			kfree_skb(nskb);
1060			return -ENOENT;
1061		}
1062
1063		skb_add_rx_frag(skb, skb_shinfo(skb)->nr_frags,
1064				skb_frag_page(nfrag),
1065				rx->offset, rx->status, PAGE_SIZE);
1066
1067		skb_shinfo(nskb)->nr_frags = 0;
1068		kfree_skb(nskb);
1069	}
1070
1071	queue->rx.rsp_cons = cons;
 
1072
1073	return 0;
 
1074}
1075
1076static int checksum_setup(struct net_device *dev, struct sk_buff *skb)
1077{
1078	bool recalculate_partial_csum = false;
 
 
 
1079
1080	/*
1081	 * A GSO SKB must be CHECKSUM_PARTIAL. However some buggy
1082	 * peers can fail to set NETRXF_csum_blank when sending a GSO
1083	 * frame. In this case force the SKB to CHECKSUM_PARTIAL and
1084	 * recalculate the partial checksum.
1085	 */
1086	if (skb->ip_summed != CHECKSUM_PARTIAL && skb_is_gso(skb)) {
1087		struct netfront_info *np = netdev_priv(dev);
1088		atomic_inc(&np->rx_gso_checksum_fixup);
1089		skb->ip_summed = CHECKSUM_PARTIAL;
1090		recalculate_partial_csum = true;
1091	}
1092
1093	/* A non-CHECKSUM_PARTIAL SKB does not require setup. */
1094	if (skb->ip_summed != CHECKSUM_PARTIAL)
1095		return 0;
1096
1097	return skb_checksum_setup(skb, recalculate_partial_csum);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1098}
1099
1100static int handle_incoming_queue(struct netfront_queue *queue,
1101				 struct sk_buff_head *rxq)
1102{
1103	struct netfront_stats *rx_stats = this_cpu_ptr(queue->info->rx_stats);
 
1104	int packets_dropped = 0;
1105	struct sk_buff *skb;
1106
1107	while ((skb = __skb_dequeue(rxq)) != NULL) {
1108		int pull_to = NETFRONT_SKB_CB(skb)->pull_to;
 
 
 
 
 
1109
1110		if (pull_to > skb_headlen(skb))
1111			__pskb_pull_tail(skb, pull_to - skb_headlen(skb));
1112
1113		/* Ethernet work: Delayed to here as it peeks the header. */
1114		skb->protocol = eth_type_trans(skb, queue->info->netdev);
1115		skb_reset_network_header(skb);
1116
1117		if (checksum_setup(queue->info->netdev, skb)) {
1118			kfree_skb(skb);
1119			packets_dropped++;
1120			queue->info->netdev->stats.rx_errors++;
1121			continue;
1122		}
1123
1124		u64_stats_update_begin(&rx_stats->syncp);
1125		rx_stats->packets++;
1126		rx_stats->bytes += skb->len;
1127		u64_stats_update_end(&rx_stats->syncp);
1128
1129		/* Pass it up. */
1130		napi_gro_receive(&queue->napi, skb);
1131	}
1132
1133	return packets_dropped;
1134}
1135
1136static int xennet_poll(struct napi_struct *napi, int budget)
1137{
1138	struct netfront_queue *queue = container_of(napi, struct netfront_queue, napi);
1139	struct net_device *dev = queue->info->netdev;
1140	struct sk_buff *skb;
1141	struct netfront_rx_info rinfo;
1142	struct xen_netif_rx_response *rx = &rinfo.rx;
1143	struct xen_netif_extra_info *extras = rinfo.extras;
1144	RING_IDX i, rp;
1145	int work_done;
1146	struct sk_buff_head rxq;
1147	struct sk_buff_head errq;
1148	struct sk_buff_head tmpq;
 
 
1149	int err;
1150	bool need_xdp_flush = false;
1151
1152	spin_lock(&queue->rx_lock);
1153
1154	skb_queue_head_init(&rxq);
1155	skb_queue_head_init(&errq);
1156	skb_queue_head_init(&tmpq);
1157
1158	rp = queue->rx.sring->rsp_prod;
1159	rmb(); /* Ensure we see queued responses up to 'rp'. */
1160
1161	i = queue->rx.rsp_cons;
1162	work_done = 0;
1163	while ((i != rp) && (work_done < budget)) {
1164		memcpy(rx, RING_GET_RESPONSE(&queue->rx, i), sizeof(*rx));
1165		memset(extras, 0, sizeof(rinfo.extras));
1166
1167		err = xennet_get_responses(queue, &rinfo, rp, &tmpq,
1168					   &need_xdp_flush);
1169
1170		if (unlikely(err)) {
1171err:
1172			while ((skb = __skb_dequeue(&tmpq)))
1173				__skb_queue_tail(&errq, skb);
1174			dev->stats.rx_errors++;
1175			i = queue->rx.rsp_cons;
1176			continue;
1177		}
1178
1179		skb = __skb_dequeue(&tmpq);
1180
1181		if (extras[XEN_NETIF_EXTRA_TYPE_GSO - 1].type) {
1182			struct xen_netif_extra_info *gso;
1183			gso = &extras[XEN_NETIF_EXTRA_TYPE_GSO - 1];
1184
1185			if (unlikely(xennet_set_skb_gso(skb, gso))) {
1186				__skb_queue_head(&tmpq, skb);
1187				queue->rx.rsp_cons += skb_queue_len(&tmpq);
1188				goto err;
1189			}
1190		}
1191
1192		NETFRONT_SKB_CB(skb)->pull_to = rx->status;
1193		if (NETFRONT_SKB_CB(skb)->pull_to > RX_COPY_THRESHOLD)
1194			NETFRONT_SKB_CB(skb)->pull_to = RX_COPY_THRESHOLD;
1195
1196		skb_frag_off_set(&skb_shinfo(skb)->frags[0], rx->offset);
1197		skb_frag_size_set(&skb_shinfo(skb)->frags[0], rx->status);
1198		skb->data_len = rx->status;
1199		skb->len += rx->status;
 
 
 
 
 
 
 
 
 
 
1200
1201		if (unlikely(xennet_fill_frags(queue, skb, &tmpq)))
1202			goto err;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1203
1204		if (rx->flags & XEN_NETRXF_csum_blank)
1205			skb->ip_summed = CHECKSUM_PARTIAL;
1206		else if (rx->flags & XEN_NETRXF_data_validated)
1207			skb->ip_summed = CHECKSUM_UNNECESSARY;
1208
1209		__skb_queue_tail(&rxq, skb);
1210
1211		i = ++queue->rx.rsp_cons;
1212		work_done++;
1213	}
1214	if (need_xdp_flush)
1215		xdp_do_flush();
1216
1217	__skb_queue_purge(&errq);
1218
1219	work_done -= handle_incoming_queue(queue, &rxq);
 
 
 
 
 
 
 
1220
1221	xennet_alloc_rx_buffers(queue);
1222
1223	if (work_done < budget) {
1224		int more_to_do = 0;
1225
1226		napi_complete_done(napi, work_done);
 
 
 
 
1227
1228		RING_FINAL_CHECK_FOR_RESPONSES(&queue->rx, more_to_do);
1229		if (more_to_do)
1230			napi_schedule(napi);
1231	}
1232
1233	spin_unlock(&queue->rx_lock);
1234
1235	return work_done;
1236}
1237
1238static int xennet_change_mtu(struct net_device *dev, int mtu)
1239{
1240	int max = xennet_can_sg(dev) ? XEN_NETIF_MAX_TX_SIZE : ETH_DATA_LEN;
1241
1242	if (mtu > max)
1243		return -EINVAL;
1244	dev->mtu = mtu;
1245	return 0;
1246}
1247
1248static void xennet_get_stats64(struct net_device *dev,
1249			       struct rtnl_link_stats64 *tot)
1250{
1251	struct netfront_info *np = netdev_priv(dev);
1252	int cpu;
1253
1254	for_each_possible_cpu(cpu) {
1255		struct netfront_stats *rx_stats = per_cpu_ptr(np->rx_stats, cpu);
1256		struct netfront_stats *tx_stats = per_cpu_ptr(np->tx_stats, cpu);
1257		u64 rx_packets, rx_bytes, tx_packets, tx_bytes;
1258		unsigned int start;
1259
1260		do {
1261			start = u64_stats_fetch_begin_irq(&tx_stats->syncp);
1262			tx_packets = tx_stats->packets;
1263			tx_bytes = tx_stats->bytes;
1264		} while (u64_stats_fetch_retry_irq(&tx_stats->syncp, start));
1265
1266		do {
1267			start = u64_stats_fetch_begin_irq(&rx_stats->syncp);
1268			rx_packets = rx_stats->packets;
1269			rx_bytes = rx_stats->bytes;
1270		} while (u64_stats_fetch_retry_irq(&rx_stats->syncp, start));
1271
1272		tot->rx_packets += rx_packets;
1273		tot->tx_packets += tx_packets;
1274		tot->rx_bytes   += rx_bytes;
1275		tot->tx_bytes   += tx_bytes;
1276	}
1277
1278	tot->rx_errors  = dev->stats.rx_errors;
1279	tot->tx_dropped = dev->stats.tx_dropped;
 
 
1280}
1281
1282static void xennet_release_tx_bufs(struct netfront_queue *queue)
1283{
1284	struct sk_buff *skb;
1285	int i;
1286
1287	for (i = 0; i < NET_TX_RING_SIZE; i++) {
1288		/* Skip over entries which are actually freelist references */
1289		if (skb_entry_is_link(&queue->tx_skbs[i]))
1290			continue;
1291
1292		skb = queue->tx_skbs[i].skb;
1293		get_page(queue->grant_tx_page[i]);
1294		gnttab_end_foreign_access(queue->grant_tx_ref[i],
1295					  GNTMAP_readonly,
1296					  (unsigned long)page_address(queue->grant_tx_page[i]));
1297		queue->grant_tx_page[i] = NULL;
1298		queue->grant_tx_ref[i] = GRANT_INVALID_REF;
1299		add_id_to_freelist(&queue->tx_skb_freelist, queue->tx_skbs, i);
1300		dev_kfree_skb_irq(skb);
1301	}
1302}
1303
1304static void xennet_release_rx_bufs(struct netfront_queue *queue)
1305{
 
 
 
 
 
 
1306	int id, ref;
1307
1308	spin_lock_bh(&queue->rx_lock);
 
 
1309
1310	for (id = 0; id < NET_RX_RING_SIZE; id++) {
1311		struct sk_buff *skb;
1312		struct page *page;
1313
1314		skb = queue->rx_skbs[id];
1315		if (!skb)
 
 
 
 
1316			continue;
 
1317
1318		ref = queue->grant_rx_ref[id];
1319		if (ref == GRANT_INVALID_REF)
 
 
 
 
 
 
 
1320			continue;
 
1321
1322		page = skb_frag_page(&skb_shinfo(skb)->frags[0]);
 
 
 
 
 
1323
1324		/* gnttab_end_foreign_access() needs a page ref until
1325		 * foreign access is ended (which may be deferred).
1326		 */
1327		get_page(page);
1328		gnttab_end_foreign_access(ref, 0,
1329					  (unsigned long)page_address(page));
1330		queue->grant_rx_ref[id] = GRANT_INVALID_REF;
 
1331
1332		kfree_skb(skb);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1333	}
1334
1335	spin_unlock_bh(&queue->rx_lock);
 
 
 
 
 
 
 
 
 
 
 
1336}
1337
1338static netdev_features_t xennet_fix_features(struct net_device *dev,
1339	netdev_features_t features)
1340{
1341	struct netfront_info *np = netdev_priv(dev);
 
1342
1343	if (features & NETIF_F_SG &&
1344	    !xenbus_read_unsigned(np->xbdev->otherend, "feature-sg", 0))
1345		features &= ~NETIF_F_SG;
1346
1347	if (features & NETIF_F_IPV6_CSUM &&
1348	    !xenbus_read_unsigned(np->xbdev->otherend,
1349				  "feature-ipv6-csum-offload", 0))
1350		features &= ~NETIF_F_IPV6_CSUM;
1351
1352	if (features & NETIF_F_TSO &&
1353	    !xenbus_read_unsigned(np->xbdev->otherend, "feature-gso-tcpv4", 0))
1354		features &= ~NETIF_F_TSO;
1355
1356	if (features & NETIF_F_TSO6 &&
1357	    !xenbus_read_unsigned(np->xbdev->otherend, "feature-gso-tcpv6", 0))
1358		features &= ~NETIF_F_TSO6;
 
1359
1360	return features;
1361}
1362
1363static int xennet_set_features(struct net_device *dev,
1364	netdev_features_t features)
1365{
1366	if (!(features & NETIF_F_SG) && dev->mtu > ETH_DATA_LEN) {
1367		netdev_info(dev, "Reducing MTU because no SG offload");
1368		dev->mtu = ETH_DATA_LEN;
1369	}
1370
1371	return 0;
1372}
1373
1374static irqreturn_t xennet_tx_interrupt(int irq, void *dev_id)
1375{
1376	struct netfront_queue *queue = dev_id;
 
1377	unsigned long flags;
1378
1379	spin_lock_irqsave(&queue->tx_lock, flags);
1380	xennet_tx_buf_gc(queue);
1381	spin_unlock_irqrestore(&queue->tx_lock, flags);
1382
1383	return IRQ_HANDLED;
1384}
1385
1386static irqreturn_t xennet_rx_interrupt(int irq, void *dev_id)
1387{
1388	struct netfront_queue *queue = dev_id;
1389	struct net_device *dev = queue->info->netdev;
1390
1391	if (likely(netif_carrier_ok(dev) &&
1392		   RING_HAS_UNCONSUMED_RESPONSES(&queue->rx)))
1393		napi_schedule(&queue->napi);
 
 
 
1394
1395	return IRQ_HANDLED;
1396}
1397
1398static irqreturn_t xennet_interrupt(int irq, void *dev_id)
1399{
1400	xennet_tx_interrupt(irq, dev_id);
1401	xennet_rx_interrupt(irq, dev_id);
1402	return IRQ_HANDLED;
1403}
1404
1405#ifdef CONFIG_NET_POLL_CONTROLLER
1406static void xennet_poll_controller(struct net_device *dev)
1407{
1408	/* Poll each queue */
1409	struct netfront_info *info = netdev_priv(dev);
1410	unsigned int num_queues = dev->real_num_tx_queues;
1411	unsigned int i;
1412	for (i = 0; i < num_queues; ++i)
1413		xennet_interrupt(0, &info->queues[i]);
1414}
1415#endif
1416
1417#define NETBACK_XDP_HEADROOM_DISABLE	0
1418#define NETBACK_XDP_HEADROOM_ENABLE	1
1419
1420static int talk_to_netback_xdp(struct netfront_info *np, int xdp)
1421{
1422	int err;
1423	unsigned short headroom;
1424
1425	headroom = xdp ? XDP_PACKET_HEADROOM : 0;
1426	err = xenbus_printf(XBT_NIL, np->xbdev->nodename,
1427			    "xdp-headroom", "%hu",
1428			    headroom);
1429	if (err)
1430		pr_warn("Error writing xdp-headroom\n");
1431
1432	return err;
1433}
1434
1435static int xennet_xdp_set(struct net_device *dev, struct bpf_prog *prog,
1436			  struct netlink_ext_ack *extack)
1437{
1438	unsigned long max_mtu = XEN_PAGE_SIZE - XDP_PACKET_HEADROOM;
1439	struct netfront_info *np = netdev_priv(dev);
1440	struct bpf_prog *old_prog;
1441	unsigned int i, err;
1442
1443	if (dev->mtu > max_mtu) {
1444		netdev_warn(dev, "XDP requires MTU less than %lu\n", max_mtu);
1445		return -EINVAL;
1446	}
1447
1448	if (!np->netback_has_xdp_headroom)
1449		return 0;
1450
1451	xenbus_switch_state(np->xbdev, XenbusStateReconfiguring);
1452
1453	err = talk_to_netback_xdp(np, prog ? NETBACK_XDP_HEADROOM_ENABLE :
1454				  NETBACK_XDP_HEADROOM_DISABLE);
1455	if (err)
1456		return err;
1457
1458	/* avoid the race with XDP headroom adjustment */
1459	wait_event(module_wq,
1460		   xenbus_read_driver_state(np->xbdev->otherend) ==
1461		   XenbusStateReconfigured);
1462	np->netfront_xdp_enabled = true;
1463
1464	old_prog = rtnl_dereference(np->queues[0].xdp_prog);
1465
1466	if (prog)
1467		bpf_prog_add(prog, dev->real_num_tx_queues);
1468
1469	for (i = 0; i < dev->real_num_tx_queues; ++i)
1470		rcu_assign_pointer(np->queues[i].xdp_prog, prog);
1471
1472	if (old_prog)
1473		for (i = 0; i < dev->real_num_tx_queues; ++i)
1474			bpf_prog_put(old_prog);
1475
1476	xenbus_switch_state(np->xbdev, XenbusStateConnected);
1477
1478	return 0;
1479}
1480
1481static int xennet_xdp(struct net_device *dev, struct netdev_bpf *xdp)
1482{
1483	switch (xdp->command) {
1484	case XDP_SETUP_PROG:
1485		return xennet_xdp_set(dev, xdp->prog, xdp->extack);
1486	default:
1487		return -EINVAL;
1488	}
1489}
1490
1491static const struct net_device_ops xennet_netdev_ops = {
1492	.ndo_open            = xennet_open,
 
1493	.ndo_stop            = xennet_close,
1494	.ndo_start_xmit      = xennet_start_xmit,
1495	.ndo_change_mtu	     = xennet_change_mtu,
1496	.ndo_get_stats64     = xennet_get_stats64,
1497	.ndo_set_mac_address = eth_mac_addr,
1498	.ndo_validate_addr   = eth_validate_addr,
1499	.ndo_fix_features    = xennet_fix_features,
1500	.ndo_set_features    = xennet_set_features,
1501	.ndo_select_queue    = xennet_select_queue,
1502	.ndo_bpf            = xennet_xdp,
1503	.ndo_xdp_xmit	    = xennet_xdp_xmit,
1504#ifdef CONFIG_NET_POLL_CONTROLLER
1505	.ndo_poll_controller = xennet_poll_controller,
1506#endif
1507};
1508
1509static void xennet_free_netdev(struct net_device *netdev)
1510{
1511	struct netfront_info *np = netdev_priv(netdev);
1512
1513	free_percpu(np->rx_stats);
1514	free_percpu(np->tx_stats);
1515	free_netdev(netdev);
1516}
1517
1518static struct net_device *xennet_create_dev(struct xenbus_device *dev)
1519{
1520	int err;
1521	struct net_device *netdev;
1522	struct netfront_info *np;
1523
1524	netdev = alloc_etherdev_mq(sizeof(struct netfront_info), xennet_max_queues);
1525	if (!netdev)
1526		return ERR_PTR(-ENOMEM);
1527
1528	np                   = netdev_priv(netdev);
1529	np->xbdev            = dev;
1530
1531	np->queues = NULL;
 
 
 
 
 
 
 
 
 
 
1532
1533	err = -ENOMEM;
1534	np->rx_stats = netdev_alloc_pcpu_stats(struct netfront_stats);
1535	if (np->rx_stats == NULL)
1536		goto exit;
1537	np->tx_stats = netdev_alloc_pcpu_stats(struct netfront_stats);
1538	if (np->tx_stats == NULL)
1539		goto exit;
1540
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1541	netdev->netdev_ops	= &xennet_netdev_ops;
1542
 
1543	netdev->features        = NETIF_F_IP_CSUM | NETIF_F_RXCSUM |
1544				  NETIF_F_GSO_ROBUST;
1545	netdev->hw_features	= NETIF_F_SG |
1546				  NETIF_F_IPV6_CSUM |
1547				  NETIF_F_TSO | NETIF_F_TSO6;
1548
1549	/*
1550         * Assume that all hw features are available for now. This set
1551         * will be adjusted by the call to netdev_update_features() in
1552         * xennet_connect() which is the earliest point where we can
1553         * negotiate with the backend regarding supported features.
1554         */
1555	netdev->features |= netdev->hw_features;
1556
1557	netdev->ethtool_ops = &xennet_ethtool_ops;
1558	netdev->min_mtu = ETH_MIN_MTU;
1559	netdev->max_mtu = XEN_NETIF_MAX_TX_SIZE;
1560	SET_NETDEV_DEV(netdev, &dev->dev);
1561
1562	np->netdev = netdev;
1563	np->netfront_xdp_enabled = false;
1564
1565	netif_carrier_off(netdev);
1566
1567	do {
1568		xenbus_switch_state(dev, XenbusStateInitialising);
1569		err = wait_event_timeout(module_wq,
1570				 xenbus_read_driver_state(dev->otherend) !=
1571				 XenbusStateClosed &&
1572				 xenbus_read_driver_state(dev->otherend) !=
1573				 XenbusStateUnknown, XENNET_TIMEOUT);
1574	} while (!err);
1575
1576	return netdev;
1577
 
 
 
 
1578 exit:
1579	xennet_free_netdev(netdev);
1580	return ERR_PTR(err);
1581}
1582
1583/*
1584 * Entry point to this code when a new device is created.  Allocate the basic
1585 * structures and the ring buffers for communication with the backend, and
1586 * inform the backend of the appropriate details for those.
1587 */
1588static int netfront_probe(struct xenbus_device *dev,
1589			  const struct xenbus_device_id *id)
1590{
1591	int err;
1592	struct net_device *netdev;
1593	struct netfront_info *info;
1594
1595	netdev = xennet_create_dev(dev);
1596	if (IS_ERR(netdev)) {
1597		err = PTR_ERR(netdev);
1598		xenbus_dev_fatal(dev, err, "creating netdev");
1599		return err;
1600	}
1601
1602	info = netdev_priv(netdev);
1603	dev_set_drvdata(&dev->dev, info);
1604#ifdef CONFIG_SYSFS
1605	info->netdev->sysfs_groups[0] = &xennet_dev_group;
1606#endif
 
 
 
 
 
 
 
 
 
 
 
 
1607
1608	return 0;
 
 
 
 
 
1609}
1610
1611static void xennet_end_access(int ref, void *page)
1612{
1613	/* This frees the page as a side-effect */
1614	if (ref != GRANT_INVALID_REF)
1615		gnttab_end_foreign_access(ref, 0, (unsigned long)page);
1616}
1617
1618static void xennet_disconnect_backend(struct netfront_info *info)
1619{
1620	unsigned int i = 0;
1621	unsigned int num_queues = info->netdev->real_num_tx_queues;
1622
1623	netif_carrier_off(info->netdev);
 
 
1624
1625	for (i = 0; i < num_queues && info->queues; ++i) {
1626		struct netfront_queue *queue = &info->queues[i];
1627
1628		del_timer_sync(&queue->rx_refill_timer);
1629
1630		if (queue->tx_irq && (queue->tx_irq == queue->rx_irq))
1631			unbind_from_irqhandler(queue->tx_irq, queue);
1632		if (queue->tx_irq && (queue->tx_irq != queue->rx_irq)) {
1633			unbind_from_irqhandler(queue->tx_irq, queue);
1634			unbind_from_irqhandler(queue->rx_irq, queue);
1635		}
1636		queue->tx_evtchn = queue->rx_evtchn = 0;
1637		queue->tx_irq = queue->rx_irq = 0;
1638
1639		if (netif_running(info->netdev))
1640			napi_synchronize(&queue->napi);
 
1641
1642		xennet_release_tx_bufs(queue);
1643		xennet_release_rx_bufs(queue);
1644		gnttab_free_grant_references(queue->gref_tx_head);
1645		gnttab_free_grant_references(queue->gref_rx_head);
1646
1647		/* End access and free the pages */
1648		xennet_end_access(queue->tx_ring_ref, queue->tx.sring);
1649		xennet_end_access(queue->rx_ring_ref, queue->rx.sring);
1650
1651		queue->tx_ring_ref = GRANT_INVALID_REF;
1652		queue->rx_ring_ref = GRANT_INVALID_REF;
1653		queue->tx.sring = NULL;
1654		queue->rx.sring = NULL;
1655
1656		page_pool_destroy(queue->page_pool);
1657	}
1658}
1659
1660/*
1661 * We are reconnecting to the backend, due to a suspend/resume, or a backend
1662 * driver restart.  We tear down our netif structure and recreate it, but
1663 * leave the device-layer structures intact so that this is transparent to the
1664 * rest of the kernel.
1665 */
1666static int netfront_resume(struct xenbus_device *dev)
1667{
1668	struct netfront_info *info = dev_get_drvdata(&dev->dev);
1669
1670	dev_dbg(&dev->dev, "%s\n", dev->nodename);
1671
1672	xennet_disconnect_backend(info);
1673	return 0;
1674}
1675
1676static int xen_net_read_mac(struct xenbus_device *dev, u8 mac[])
1677{
1678	char *s, *e, *macstr;
1679	int i;
1680
1681	macstr = s = xenbus_read(XBT_NIL, dev->nodename, "mac", NULL);
1682	if (IS_ERR(macstr))
1683		return PTR_ERR(macstr);
1684
1685	for (i = 0; i < ETH_ALEN; i++) {
1686		mac[i] = simple_strtoul(s, &e, 16);
1687		if ((s == e) || (*e != ((i == ETH_ALEN-1) ? '\0' : ':'))) {
1688			kfree(macstr);
1689			return -ENOENT;
1690		}
1691		s = e+1;
1692	}
1693
1694	kfree(macstr);
1695	return 0;
1696}
1697
1698static int setup_netfront_single(struct netfront_queue *queue)
1699{
1700	int err;
1701
1702	err = xenbus_alloc_evtchn(queue->info->xbdev, &queue->tx_evtchn);
1703	if (err < 0)
1704		goto fail;
1705
1706	err = bind_evtchn_to_irqhandler(queue->tx_evtchn,
1707					xennet_interrupt,
1708					0, queue->info->netdev->name, queue);
1709	if (err < 0)
1710		goto bind_fail;
1711	queue->rx_evtchn = queue->tx_evtchn;
1712	queue->rx_irq = queue->tx_irq = err;
1713
1714	return 0;
1715
1716bind_fail:
1717	xenbus_free_evtchn(queue->info->xbdev, queue->tx_evtchn);
1718	queue->tx_evtchn = 0;
1719fail:
1720	return err;
1721}
1722
1723static int setup_netfront_split(struct netfront_queue *queue)
1724{
1725	int err;
1726
1727	err = xenbus_alloc_evtchn(queue->info->xbdev, &queue->tx_evtchn);
1728	if (err < 0)
1729		goto fail;
1730	err = xenbus_alloc_evtchn(queue->info->xbdev, &queue->rx_evtchn);
1731	if (err < 0)
1732		goto alloc_rx_evtchn_fail;
1733
1734	snprintf(queue->tx_irq_name, sizeof(queue->tx_irq_name),
1735		 "%s-tx", queue->name);
1736	err = bind_evtchn_to_irqhandler(queue->tx_evtchn,
1737					xennet_tx_interrupt,
1738					0, queue->tx_irq_name, queue);
1739	if (err < 0)
1740		goto bind_tx_fail;
1741	queue->tx_irq = err;
1742
1743	snprintf(queue->rx_irq_name, sizeof(queue->rx_irq_name),
1744		 "%s-rx", queue->name);
1745	err = bind_evtchn_to_irqhandler(queue->rx_evtchn,
1746					xennet_rx_interrupt,
1747					0, queue->rx_irq_name, queue);
1748	if (err < 0)
1749		goto bind_rx_fail;
1750	queue->rx_irq = err;
1751
1752	return 0;
1753
1754bind_rx_fail:
1755	unbind_from_irqhandler(queue->tx_irq, queue);
1756	queue->tx_irq = 0;
1757bind_tx_fail:
1758	xenbus_free_evtchn(queue->info->xbdev, queue->rx_evtchn);
1759	queue->rx_evtchn = 0;
1760alloc_rx_evtchn_fail:
1761	xenbus_free_evtchn(queue->info->xbdev, queue->tx_evtchn);
1762	queue->tx_evtchn = 0;
1763fail:
1764	return err;
1765}
1766
1767static int setup_netfront(struct xenbus_device *dev,
1768			struct netfront_queue *queue, unsigned int feature_split_evtchn)
1769{
1770	struct xen_netif_tx_sring *txs;
1771	struct xen_netif_rx_sring *rxs;
1772	grant_ref_t gref;
1773	int err;
 
1774
1775	queue->tx_ring_ref = GRANT_INVALID_REF;
1776	queue->rx_ring_ref = GRANT_INVALID_REF;
1777	queue->rx.sring = NULL;
1778	queue->tx.sring = NULL;
 
 
 
 
 
 
 
1779
1780	txs = (struct xen_netif_tx_sring *)get_zeroed_page(GFP_NOIO | __GFP_HIGH);
1781	if (!txs) {
1782		err = -ENOMEM;
1783		xenbus_dev_fatal(dev, err, "allocating tx ring page");
1784		goto fail;
1785	}
1786	SHARED_RING_INIT(txs);
1787	FRONT_RING_INIT(&queue->tx, txs, XEN_PAGE_SIZE);
1788
1789	err = xenbus_grant_ring(dev, txs, 1, &gref);
1790	if (err < 0)
1791		goto grant_tx_ring_fail;
1792	queue->tx_ring_ref = gref;
 
1793
 
1794	rxs = (struct xen_netif_rx_sring *)get_zeroed_page(GFP_NOIO | __GFP_HIGH);
1795	if (!rxs) {
1796		err = -ENOMEM;
1797		xenbus_dev_fatal(dev, err, "allocating rx ring page");
1798		goto alloc_rx_ring_fail;
1799	}
1800	SHARED_RING_INIT(rxs);
1801	FRONT_RING_INIT(&queue->rx, rxs, XEN_PAGE_SIZE);
1802
1803	err = xenbus_grant_ring(dev, rxs, 1, &gref);
1804	if (err < 0)
1805		goto grant_rx_ring_fail;
1806	queue->rx_ring_ref = gref;
1807
1808	if (feature_split_evtchn)
1809		err = setup_netfront_split(queue);
1810	/* setup single event channel if
1811	 *  a) feature-split-event-channels == 0
1812	 *  b) feature-split-event-channels == 1 but failed to setup
1813	 */
1814	if (!feature_split_evtchn || err)
1815		err = setup_netfront_single(queue);
1816
1817	if (err)
1818		goto alloc_evtchn_fail;
1819
1820	return 0;
1821
1822	/* If we fail to setup netfront, it is safe to just revoke access to
1823	 * granted pages because backend is not accessing it at this point.
1824	 */
1825alloc_evtchn_fail:
1826	gnttab_end_foreign_access_ref(queue->rx_ring_ref, 0);
1827grant_rx_ring_fail:
1828	free_page((unsigned long)rxs);
1829alloc_rx_ring_fail:
1830	gnttab_end_foreign_access_ref(queue->tx_ring_ref, 0);
1831grant_tx_ring_fail:
1832	free_page((unsigned long)txs);
1833fail:
1834	return err;
1835}
1836
1837/* Queue-specific initialisation
1838 * This used to be done in xennet_create_dev() but must now
1839 * be run per-queue.
1840 */
1841static int xennet_init_queue(struct netfront_queue *queue)
1842{
1843	unsigned short i;
1844	int err = 0;
1845	char *devid;
1846
1847	spin_lock_init(&queue->tx_lock);
1848	spin_lock_init(&queue->rx_lock);
1849
1850	timer_setup(&queue->rx_refill_timer, rx_refill_timeout, 0);
1851
1852	devid = strrchr(queue->info->xbdev->nodename, '/') + 1;
1853	snprintf(queue->name, sizeof(queue->name), "vif%s-q%u",
1854		 devid, queue->id);
1855
1856	/* Initialise tx_skbs as a free chain containing every entry. */
1857	queue->tx_skb_freelist = 0;
1858	for (i = 0; i < NET_TX_RING_SIZE; i++) {
1859		skb_entry_set_link(&queue->tx_skbs[i], i+1);
1860		queue->grant_tx_ref[i] = GRANT_INVALID_REF;
1861		queue->grant_tx_page[i] = NULL;
1862	}
1863
1864	/* Clear out rx_skbs */
1865	for (i = 0; i < NET_RX_RING_SIZE; i++) {
1866		queue->rx_skbs[i] = NULL;
1867		queue->grant_rx_ref[i] = GRANT_INVALID_REF;
1868	}
1869
1870	/* A grant for every tx ring slot */
1871	if (gnttab_alloc_grant_references(NET_TX_RING_SIZE,
1872					  &queue->gref_tx_head) < 0) {
1873		pr_alert("can't alloc tx grant refs\n");
1874		err = -ENOMEM;
1875		goto exit;
1876	}
1877
1878	/* A grant for every rx ring slot */
1879	if (gnttab_alloc_grant_references(NET_RX_RING_SIZE,
1880					  &queue->gref_rx_head) < 0) {
1881		pr_alert("can't alloc rx grant refs\n");
1882		err = -ENOMEM;
1883		goto exit_free_tx;
1884	}
1885
1886	return 0;
1887
1888 exit_free_tx:
1889	gnttab_free_grant_references(queue->gref_tx_head);
1890 exit:
1891	return err;
1892}
1893
1894static int write_queue_xenstore_keys(struct netfront_queue *queue,
1895			   struct xenbus_transaction *xbt, int write_hierarchical)
1896{
1897	/* Write the queue-specific keys into XenStore in the traditional
1898	 * way for a single queue, or in a queue subkeys for multiple
1899	 * queues.
1900	 */
1901	struct xenbus_device *dev = queue->info->xbdev;
1902	int err;
1903	const char *message;
1904	char *path;
1905	size_t pathsize;
1906
1907	/* Choose the correct place to write the keys */
1908	if (write_hierarchical) {
1909		pathsize = strlen(dev->nodename) + 10;
1910		path = kzalloc(pathsize, GFP_KERNEL);
1911		if (!path) {
1912			err = -ENOMEM;
1913			message = "out of memory while writing ring references";
1914			goto error;
1915		}
1916		snprintf(path, pathsize, "%s/queue-%u",
1917				dev->nodename, queue->id);
1918	} else {
1919		path = (char *)dev->nodename;
1920	}
1921
1922	/* Write ring references */
1923	err = xenbus_printf(*xbt, path, "tx-ring-ref", "%u",
1924			queue->tx_ring_ref);
1925	if (err) {
1926		message = "writing tx-ring-ref";
1927		goto error;
1928	}
1929
1930	err = xenbus_printf(*xbt, path, "rx-ring-ref", "%u",
1931			queue->rx_ring_ref);
1932	if (err) {
1933		message = "writing rx-ring-ref";
1934		goto error;
1935	}
1936
1937	/* Write event channels; taking into account both shared
1938	 * and split event channel scenarios.
1939	 */
1940	if (queue->tx_evtchn == queue->rx_evtchn) {
1941		/* Shared event channel */
1942		err = xenbus_printf(*xbt, path,
1943				"event-channel", "%u", queue->tx_evtchn);
1944		if (err) {
1945			message = "writing event-channel";
1946			goto error;
1947		}
1948	} else {
1949		/* Split event channels */
1950		err = xenbus_printf(*xbt, path,
1951				"event-channel-tx", "%u", queue->tx_evtchn);
1952		if (err) {
1953			message = "writing event-channel-tx";
1954			goto error;
1955		}
1956
1957		err = xenbus_printf(*xbt, path,
1958				"event-channel-rx", "%u", queue->rx_evtchn);
1959		if (err) {
1960			message = "writing event-channel-rx";
1961			goto error;
1962		}
1963	}
1964
1965	if (write_hierarchical)
1966		kfree(path);
1967	return 0;
1968
1969error:
1970	if (write_hierarchical)
1971		kfree(path);
1972	xenbus_dev_fatal(dev, err, "%s", message);
1973	return err;
1974}
1975
1976static void xennet_destroy_queues(struct netfront_info *info)
1977{
1978	unsigned int i;
1979
1980	for (i = 0; i < info->netdev->real_num_tx_queues; i++) {
1981		struct netfront_queue *queue = &info->queues[i];
1982
1983		if (netif_running(info->netdev))
1984			napi_disable(&queue->napi);
1985		netif_napi_del(&queue->napi);
1986	}
1987
1988	kfree(info->queues);
1989	info->queues = NULL;
1990}
1991
1992
1993
1994static int xennet_create_page_pool(struct netfront_queue *queue)
1995{
1996	int err;
1997	struct page_pool_params pp_params = {
1998		.order = 0,
1999		.flags = 0,
2000		.pool_size = NET_RX_RING_SIZE,
2001		.nid = NUMA_NO_NODE,
2002		.dev = &queue->info->netdev->dev,
2003		.offset = XDP_PACKET_HEADROOM,
2004		.max_len = XEN_PAGE_SIZE - XDP_PACKET_HEADROOM,
2005	};
2006
2007	queue->page_pool = page_pool_create(&pp_params);
2008	if (IS_ERR(queue->page_pool)) {
2009		err = PTR_ERR(queue->page_pool);
2010		queue->page_pool = NULL;
2011		return err;
2012	}
 
2013
2014	err = xdp_rxq_info_reg(&queue->xdp_rxq, queue->info->netdev,
2015			       queue->id, 0);
2016	if (err) {
2017		netdev_err(queue->info->netdev, "xdp_rxq_info_reg failed\n");
2018		goto err_free_pp;
2019	}
2020
2021	err = xdp_rxq_info_reg_mem_model(&queue->xdp_rxq,
2022					 MEM_TYPE_PAGE_POOL, queue->page_pool);
2023	if (err) {
2024		netdev_err(queue->info->netdev, "xdp_rxq_info_reg_mem_model failed\n");
2025		goto err_unregister_rxq;
2026	}
2027	return 0;
2028
2029err_unregister_rxq:
2030	xdp_rxq_info_unreg(&queue->xdp_rxq);
2031err_free_pp:
2032	page_pool_destroy(queue->page_pool);
2033	queue->page_pool = NULL;
2034	return err;
2035}
2036
2037static int xennet_create_queues(struct netfront_info *info,
2038				unsigned int *num_queues)
2039{
2040	unsigned int i;
2041	int ret;
2042
2043	info->queues = kcalloc(*num_queues, sizeof(struct netfront_queue),
2044			       GFP_KERNEL);
2045	if (!info->queues)
2046		return -ENOMEM;
2047
2048	for (i = 0; i < *num_queues; i++) {
2049		struct netfront_queue *queue = &info->queues[i];
2050
2051		queue->id = i;
2052		queue->info = info;
2053
2054		ret = xennet_init_queue(queue);
2055		if (ret < 0) {
2056			dev_warn(&info->xbdev->dev,
2057				 "only created %d queues\n", i);
2058			*num_queues = i;
2059			break;
2060		}
2061
2062		/* use page pool recycling instead of buddy allocator */
2063		ret = xennet_create_page_pool(queue);
2064		if (ret < 0) {
2065			dev_err(&info->xbdev->dev, "can't allocate page pool\n");
2066			*num_queues = i;
2067			return ret;
2068		}
2069
2070		netif_napi_add(queue->info->netdev, &queue->napi,
2071			       xennet_poll, 64);
2072		if (netif_running(info->netdev))
2073			napi_enable(&queue->napi);
2074	}
2075
2076	netif_set_real_num_tx_queues(info->netdev, *num_queues);
2077
2078	if (*num_queues == 0) {
2079		dev_err(&info->xbdev->dev, "no queues\n");
2080		return -EINVAL;
2081	}
2082	return 0;
2083}
2084
2085/* Common code used when first setting up, and when resuming. */
2086static int talk_to_netback(struct xenbus_device *dev,
2087			   struct netfront_info *info)
2088{
2089	const char *message;
2090	struct xenbus_transaction xbt;
2091	int err;
2092	unsigned int feature_split_evtchn;
2093	unsigned int i = 0;
2094	unsigned int max_queues = 0;
2095	struct netfront_queue *queue = NULL;
2096	unsigned int num_queues = 1;
2097
2098	info->netdev->irq = 0;
2099
2100	/* Check if backend supports multiple queues */
2101	max_queues = xenbus_read_unsigned(info->xbdev->otherend,
2102					  "multi-queue-max-queues", 1);
2103	num_queues = min(max_queues, xennet_max_queues);
2104
2105	/* Check feature-split-event-channels */
2106	feature_split_evtchn = xenbus_read_unsigned(info->xbdev->otherend,
2107					"feature-split-event-channels", 0);
2108
2109	/* Read mac addr. */
2110	err = xen_net_read_mac(dev, info->netdev->dev_addr);
2111	if (err) {
2112		xenbus_dev_fatal(dev, err, "parsing %s/mac", dev->nodename);
2113		goto out_unlocked;
2114	}
2115
2116	info->netback_has_xdp_headroom = xenbus_read_unsigned(info->xbdev->otherend,
2117							      "feature-xdp-headroom", 0);
2118	if (info->netback_has_xdp_headroom) {
2119		/* set the current xen-netfront xdp state */
2120		err = talk_to_netback_xdp(info, info->netfront_xdp_enabled ?
2121					  NETBACK_XDP_HEADROOM_ENABLE :
2122					  NETBACK_XDP_HEADROOM_DISABLE);
2123		if (err)
2124			goto out_unlocked;
2125	}
2126
2127	rtnl_lock();
2128	if (info->queues)
2129		xennet_destroy_queues(info);
2130
2131	err = xennet_create_queues(info, &num_queues);
2132	if (err < 0) {
2133		xenbus_dev_fatal(dev, err, "creating queues");
2134		kfree(info->queues);
2135		info->queues = NULL;
2136		goto out;
2137	}
2138	rtnl_unlock();
2139
2140	/* Create shared ring, alloc event channel -- for each queue */
2141	for (i = 0; i < num_queues; ++i) {
2142		queue = &info->queues[i];
2143		err = setup_netfront(dev, queue, feature_split_evtchn);
2144		if (err)
2145			goto destroy_ring;
2146	}
2147
2148again:
2149	err = xenbus_transaction_start(&xbt);
2150	if (err) {
2151		xenbus_dev_fatal(dev, err, "starting transaction");
2152		goto destroy_ring;
2153	}
2154
2155	if (xenbus_exists(XBT_NIL,
2156			  info->xbdev->otherend, "multi-queue-max-queues")) {
2157		/* Write the number of queues */
2158		err = xenbus_printf(xbt, dev->nodename,
2159				    "multi-queue-num-queues", "%u", num_queues);
2160		if (err) {
2161			message = "writing multi-queue-num-queues";
2162			goto abort_transaction_no_dev_fatal;
2163		}
2164	}
2165
2166	if (num_queues == 1) {
2167		err = write_queue_xenstore_keys(&info->queues[0], &xbt, 0); /* flat */
2168		if (err)
2169			goto abort_transaction_no_dev_fatal;
2170	} else {
2171		/* Write the keys for each queue */
2172		for (i = 0; i < num_queues; ++i) {
2173			queue = &info->queues[i];
2174			err = write_queue_xenstore_keys(queue, &xbt, 1); /* hierarchical */
2175			if (err)
2176				goto abort_transaction_no_dev_fatal;
2177		}
2178	}
2179
2180	/* The remaining keys are not queue-specific */
2181	err = xenbus_printf(xbt, dev->nodename, "request-rx-copy", "%u",
2182			    1);
2183	if (err) {
2184		message = "writing request-rx-copy";
2185		goto abort_transaction;
2186	}
2187
2188	err = xenbus_printf(xbt, dev->nodename, "feature-rx-notify", "%d", 1);
2189	if (err) {
2190		message = "writing feature-rx-notify";
2191		goto abort_transaction;
2192	}
2193
2194	err = xenbus_printf(xbt, dev->nodename, "feature-sg", "%d", 1);
2195	if (err) {
2196		message = "writing feature-sg";
2197		goto abort_transaction;
2198	}
2199
2200	err = xenbus_printf(xbt, dev->nodename, "feature-gso-tcpv4", "%d", 1);
2201	if (err) {
2202		message = "writing feature-gso-tcpv4";
2203		goto abort_transaction;
2204	}
2205
2206	err = xenbus_write(xbt, dev->nodename, "feature-gso-tcpv6", "1");
2207	if (err) {
2208		message = "writing feature-gso-tcpv6";
2209		goto abort_transaction;
2210	}
2211
2212	err = xenbus_write(xbt, dev->nodename, "feature-ipv6-csum-offload",
2213			   "1");
2214	if (err) {
2215		message = "writing feature-ipv6-csum-offload";
2216		goto abort_transaction;
2217	}
2218
2219	err = xenbus_transaction_end(xbt, 0);
2220	if (err) {
2221		if (err == -EAGAIN)
2222			goto again;
2223		xenbus_dev_fatal(dev, err, "completing transaction");
2224		goto destroy_ring;
2225	}
2226
2227	return 0;
2228
2229 abort_transaction:
2230	xenbus_dev_fatal(dev, err, "%s", message);
2231abort_transaction_no_dev_fatal:
2232	xenbus_transaction_end(xbt, 1);
 
2233 destroy_ring:
2234	xennet_disconnect_backend(info);
2235	rtnl_lock();
2236	xennet_destroy_queues(info);
2237 out:
2238	rtnl_unlock();
2239out_unlocked:
2240	device_unregister(&dev->dev);
2241	return err;
2242}
2243
2244static int xennet_connect(struct net_device *dev)
2245{
2246	struct netfront_info *np = netdev_priv(dev);
2247	unsigned int num_queues = 0;
2248	int err;
2249	unsigned int j = 0;
2250	struct netfront_queue *queue = NULL;
 
2251
2252	if (!xenbus_read_unsigned(np->xbdev->otherend, "feature-rx-copy", 0)) {
 
 
 
 
 
2253		dev_info(&dev->dev,
2254			 "backend does not support copying receive path\n");
2255		return -ENODEV;
2256	}
2257
2258	err = talk_to_netback(np->xbdev, np);
2259	if (err)
2260		return err;
2261	if (np->netback_has_xdp_headroom)
2262		pr_info("backend supports XDP headroom\n");
2263
2264	/* talk_to_netback() sets the correct number of queues */
2265	num_queues = dev->real_num_tx_queues;
2266
2267	if (dev->reg_state == NETREG_UNINITIALIZED) {
2268		err = register_netdev(dev);
2269		if (err) {
2270			pr_warn("%s: register_netdev err=%d\n", __func__, err);
2271			device_unregister(&np->xbdev->dev);
2272			return err;
2273		}
2274	}
2275
2276	rtnl_lock();
2277	netdev_update_features(dev);
2278	rtnl_unlock();
2279
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2280	/*
2281	 * All public and private state should now be sane.  Get
2282	 * ready to start sending and receiving packets and give the driver
2283	 * domain a kick because we've probably just requeued some
2284	 * packets.
2285	 */
2286	netif_carrier_on(np->netdev);
2287	for (j = 0; j < num_queues; ++j) {
2288		queue = &np->queues[j];
 
2289
2290		notify_remote_via_irq(queue->tx_irq);
2291		if (queue->tx_irq != queue->rx_irq)
2292			notify_remote_via_irq(queue->rx_irq);
2293
2294		spin_lock_irq(&queue->tx_lock);
2295		xennet_tx_buf_gc(queue);
2296		spin_unlock_irq(&queue->tx_lock);
2297
2298		spin_lock_bh(&queue->rx_lock);
2299		xennet_alloc_rx_buffers(queue);
2300		spin_unlock_bh(&queue->rx_lock);
2301	}
2302
2303	return 0;
2304}
2305
2306/*
2307 * Callback received when the backend's state changes.
2308 */
2309static void netback_changed(struct xenbus_device *dev,
2310			    enum xenbus_state backend_state)
2311{
2312	struct netfront_info *np = dev_get_drvdata(&dev->dev);
2313	struct net_device *netdev = np->netdev;
2314
2315	dev_dbg(&dev->dev, "%s\n", xenbus_strstate(backend_state));
2316
2317	wake_up_all(&module_wq);
2318
2319	switch (backend_state) {
2320	case XenbusStateInitialising:
2321	case XenbusStateInitialised:
2322	case XenbusStateReconfiguring:
2323	case XenbusStateReconfigured:
2324	case XenbusStateUnknown:
 
2325		break;
2326
2327	case XenbusStateInitWait:
2328		if (dev->state != XenbusStateInitialising)
2329			break;
2330		if (xennet_connect(netdev) != 0)
2331			break;
2332		xenbus_switch_state(dev, XenbusStateConnected);
2333		break;
2334
2335	case XenbusStateConnected:
2336		netdev_notify_peers(netdev);
2337		break;
2338
2339	case XenbusStateClosed:
2340		if (dev->state == XenbusStateClosed)
2341			break;
2342		fallthrough;	/* Missed the backend's CLOSING state */
2343	case XenbusStateClosing:
2344		xenbus_frontend_closed(dev);
2345		break;
2346	}
2347}
2348
2349static const struct xennet_stat {
2350	char name[ETH_GSTRING_LEN];
2351	u16 offset;
2352} xennet_stats[] = {
2353	{
2354		"rx_gso_checksum_fixup",
2355		offsetof(struct netfront_info, rx_gso_checksum_fixup)
2356	},
2357};
2358
2359static int xennet_get_sset_count(struct net_device *dev, int string_set)
2360{
2361	switch (string_set) {
2362	case ETH_SS_STATS:
2363		return ARRAY_SIZE(xennet_stats);
2364	default:
2365		return -EINVAL;
2366	}
2367}
2368
2369static void xennet_get_ethtool_stats(struct net_device *dev,
2370				     struct ethtool_stats *stats, u64 * data)
2371{
2372	void *np = netdev_priv(dev);
2373	int i;
2374
2375	for (i = 0; i < ARRAY_SIZE(xennet_stats); i++)
2376		data[i] = atomic_read((atomic_t *)(np + xennet_stats[i].offset));
2377}
2378
2379static void xennet_get_strings(struct net_device *dev, u32 stringset, u8 * data)
2380{
2381	int i;
2382
2383	switch (stringset) {
2384	case ETH_SS_STATS:
2385		for (i = 0; i < ARRAY_SIZE(xennet_stats); i++)
2386			memcpy(data + i * ETH_GSTRING_LEN,
2387			       xennet_stats[i].name, ETH_GSTRING_LEN);
2388		break;
2389	}
2390}
2391
2392static const struct ethtool_ops xennet_ethtool_ops =
2393{
2394	.get_link = ethtool_op_get_link,
2395
2396	.get_sset_count = xennet_get_sset_count,
2397	.get_ethtool_stats = xennet_get_ethtool_stats,
2398	.get_strings = xennet_get_strings,
2399	.get_ts_info = ethtool_op_get_ts_info,
2400};
2401
2402#ifdef CONFIG_SYSFS
2403static ssize_t show_rxbuf(struct device *dev,
2404			  struct device_attribute *attr, char *buf)
2405{
2406	return sprintf(buf, "%lu\n", NET_RX_RING_SIZE);
 
 
 
2407}
2408
2409static ssize_t store_rxbuf(struct device *dev,
2410			   struct device_attribute *attr,
2411			   const char *buf, size_t len)
2412{
 
 
2413	char *endp;
 
2414
2415	if (!capable(CAP_NET_ADMIN))
2416		return -EPERM;
2417
2418	simple_strtoul(buf, &endp, 0);
2419	if (endp == buf)
2420		return -EBADMSG;
2421
2422	/* rxbuf_min and rxbuf_max are no longer configurable. */
 
 
 
 
 
 
 
 
 
 
 
 
2423
 
2424	return len;
2425}
2426
2427static DEVICE_ATTR(rxbuf_min, 0644, show_rxbuf, store_rxbuf);
2428static DEVICE_ATTR(rxbuf_max, 0644, show_rxbuf, store_rxbuf);
2429static DEVICE_ATTR(rxbuf_cur, 0444, show_rxbuf, NULL);
2430
2431static struct attribute *xennet_dev_attrs[] = {
2432	&dev_attr_rxbuf_min.attr,
2433	&dev_attr_rxbuf_max.attr,
2434	&dev_attr_rxbuf_cur.attr,
2435	NULL
2436};
2437
2438static const struct attribute_group xennet_dev_group = {
2439	.attrs = xennet_dev_attrs
2440};
2441#endif /* CONFIG_SYSFS */
2442
2443static void xennet_bus_close(struct xenbus_device *dev)
 
 
2444{
2445	int ret;
 
 
 
2446
2447	if (xenbus_read_driver_state(dev->otherend) == XenbusStateClosed)
2448		return;
2449	do {
2450		xenbus_switch_state(dev, XenbusStateClosing);
2451		ret = wait_event_timeout(module_wq,
2452				   xenbus_read_driver_state(dev->otherend) ==
2453				   XenbusStateClosing ||
2454				   xenbus_read_driver_state(dev->otherend) ==
2455				   XenbusStateClosed ||
2456				   xenbus_read_driver_state(dev->otherend) ==
2457				   XenbusStateUnknown,
2458				   XENNET_TIMEOUT);
2459	} while (!ret);
2460
2461	if (xenbus_read_driver_state(dev->otherend) == XenbusStateClosed)
2462		return;
 
2463
2464	do {
2465		xenbus_switch_state(dev, XenbusStateClosed);
2466		ret = wait_event_timeout(module_wq,
2467				   xenbus_read_driver_state(dev->otherend) ==
2468				   XenbusStateClosed ||
2469				   xenbus_read_driver_state(dev->otherend) ==
2470				   XenbusStateUnknown,
2471				   XENNET_TIMEOUT);
2472	} while (!ret);
 
 
 
 
 
 
 
2473}
2474
2475static int xennet_remove(struct xenbus_device *dev)
 
2476{
2477	struct netfront_info *info = dev_get_drvdata(&dev->dev);
 
2478
2479	xennet_bus_close(dev);
2480	xennet_disconnect_backend(info);
2481
2482	if (info->netdev->reg_state == NETREG_REGISTERED)
2483		unregister_netdev(info->netdev);
 
 
 
2484
2485	if (info->queues) {
2486		rtnl_lock();
2487		xennet_destroy_queues(info);
2488		rtnl_unlock();
2489	}
2490	xennet_free_netdev(info->netdev);
2491
 
 
 
 
 
 
2492	return 0;
 
 
 
 
 
2493}
2494
 
 
 
 
 
 
 
 
 
 
2495static const struct xenbus_device_id netfront_ids[] = {
2496	{ "vif" },
2497	{ "" }
2498};
2499
2500static struct xenbus_driver netfront_driver = {
2501	.ids = netfront_ids,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2502	.probe = netfront_probe,
2503	.remove = xennet_remove,
2504	.resume = netfront_resume,
2505	.otherend_changed = netback_changed,
2506};
2507
2508static int __init netif_init(void)
2509{
2510	if (!xen_domain())
2511		return -ENODEV;
2512
2513	if (!xen_has_pv_nic_devices())
2514		return -ENODEV;
2515
2516	pr_info("Initialising Xen virtual ethernet driver\n");
2517
2518	/* Allow as many queues as there are CPUs inut max. 8 if user has not
2519	 * specified a value.
2520	 */
2521	if (xennet_max_queues == 0)
2522		xennet_max_queues = min_t(unsigned int, MAX_QUEUES_DEFAULT,
2523					  num_online_cpus());
2524
2525	return xenbus_register_frontend(&netfront_driver);
2526}
2527module_init(netif_init);
2528
2529
2530static void __exit netif_exit(void)
2531{
2532	xenbus_unregister_driver(&netfront_driver);
2533}
2534module_exit(netif_exit);
2535
2536MODULE_DESCRIPTION("Xen virtual network device frontend");
2537MODULE_LICENSE("GPL");
2538MODULE_ALIAS("xen:vif");
2539MODULE_ALIAS("xennet");