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