interface.c 13.8 KB
Newer Older
Ian Campbell's avatar
Ian Campbell committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
/*
 * Network-device interface management.
 *
 * Copyright (c) 2004-2005, Keir Fraser
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version 2
 * as published by the Free Software Foundation; or, when distributed
 * separately from the Linux kernel or incorporated into other
 * software packages, subject to the following license:
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this source file (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy, modify,
 * merge, publish, distribute, sublicense, and/or sell copies of the Software,
 * and to permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */

#include "common.h"

33
#include <linux/kthread.h>
Ian Campbell's avatar
Ian Campbell committed
34
35
36
#include <linux/ethtool.h>
#include <linux/rtnetlink.h>
#include <linux/if_vlan.h>
37
#include <linux/vmalloc.h>
Ian Campbell's avatar
Ian Campbell committed
38
39
40

#include <xen/events.h>
#include <asm/xen/hypercall.h>
41
#include <xen/balloon.h>
Ian Campbell's avatar
Ian Campbell committed
42
43

#define XENVIF_QUEUE_LENGTH 32
44
#define XENVIF_NAPI_WEIGHT  64
Ian Campbell's avatar
Ian Campbell committed
45
46
47
48
49
50

int xenvif_schedulable(struct xenvif *vif)
{
	return netif_running(vif->dev) && netif_carrier_ok(vif->dev);
}

51
static irqreturn_t xenvif_tx_interrupt(int irq, void *dev_id)
Ian Campbell's avatar
Ian Campbell committed
52
53
54
{
	struct xenvif *vif = dev_id;

55
56
	if (RING_HAS_UNCONSUMED_REQUESTS(&vif->tx))
		napi_schedule(&vif->napi);
Ian Campbell's avatar
Ian Campbell committed
57

58
59
60
	return IRQ_HANDLED;
}

61
62
63
64
65
static int xenvif_poll(struct napi_struct *napi, int budget)
{
	struct xenvif *vif = container_of(napi, struct xenvif, napi);
	int work_done;

Wei Liu's avatar
Wei Liu committed
66
	work_done = xenvif_tx_action(vif, budget);
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

	if (work_done < budget) {
		int more_to_do = 0;
		unsigned long flags;

		/* It is necessary to disable IRQ before calling
		 * RING_HAS_UNCONSUMED_REQUESTS. Otherwise we might
		 * lose event from the frontend.
		 *
		 * Consider:
		 *   RING_HAS_UNCONSUMED_REQUESTS
		 *   <frontend generates event to trigger napi_schedule>
		 *   __napi_complete
		 *
		 * This handler is still in scheduled state so the
		 * event has no effect at all. After __napi_complete
		 * this handler is descheduled and cannot get
		 * scheduled again. We lose event in this case and the ring
		 * will be completely stalled.
		 */

		local_irq_save(flags);

		RING_FINAL_CHECK_FOR_REQUESTS(&vif->tx, more_to_do);
91
92
		if (!(more_to_do &&
		      xenvif_tx_pending_slots_available(vif)))
93
94
95
96
97
98
99
100
			__napi_complete(napi);

		local_irq_restore(flags);
	}

	return work_done;
}

101
102
103
104
static irqreturn_t xenvif_rx_interrupt(int irq, void *dev_id)
{
	struct xenvif *vif = dev_id;

105
	xenvif_kick_thread(vif);
Ian Campbell's avatar
Ian Campbell committed
106
107
108
109

	return IRQ_HANDLED;
}

110
111
112
113
114
115
116
117
static irqreturn_t xenvif_interrupt(int irq, void *dev_id)
{
	xenvif_tx_interrupt(irq, dev_id);
	xenvif_rx_interrupt(irq, dev_id);

	return IRQ_HANDLED;
}

Ian Campbell's avatar
Ian Campbell committed
118
119
120
static int xenvif_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
	struct xenvif *vif = netdev_priv(dev);
121
	int min_slots_needed;
Ian Campbell's avatar
Ian Campbell committed
122
123
124

	BUG_ON(skb->dev != dev);

125
	/* Drop the packet if vif is not ready */
126
127
128
	if (vif->task == NULL ||
	    vif->dealloc_task == NULL ||
	    !xenvif_schedulable(vif))
Ian Campbell's avatar
Ian Campbell committed
129
130
		goto drop;

131
132
133
134
	/* At best we'll need one slot for the header and one for each
	 * frag.
	 */
	min_slots_needed = 1 + skb_shinfo(skb)->nr_frags;
Ian Campbell's avatar
Ian Campbell committed
135

136
137
138
139
140
141
	/* If the skb is GSO then we'll also need an extra slot for the
	 * metadata.
	 */
	if (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV4 ||
	    skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6)
		min_slots_needed++;
Ian Campbell's avatar
Ian Campbell committed
142

143
144
145
146
147
148
	/* If the skb can't possibly fit in the remaining slots
	 * then turn off the queue to give the ring a chance to
	 * drain.
	 */
	if (!xenvif_rx_ring_slots_available(vif, min_slots_needed))
		xenvif_stop_queue(vif);
Ian Campbell's avatar
Ian Campbell committed
149

150
151
	skb_queue_tail(&vif->rx_queue, skb);
	xenvif_kick_thread(vif);
Ian Campbell's avatar
Ian Campbell committed
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168

	return NETDEV_TX_OK;

 drop:
	vif->dev->stats.tx_dropped++;
	dev_kfree_skb(skb);
	return NETDEV_TX_OK;
}

static struct net_device_stats *xenvif_get_stats(struct net_device *dev)
{
	struct xenvif *vif = netdev_priv(dev);
	return &vif->dev->stats;
}

static void xenvif_up(struct xenvif *vif)
{
169
	napi_enable(&vif->napi);
170
171
172
	enable_irq(vif->tx_irq);
	if (vif->tx_irq != vif->rx_irq)
		enable_irq(vif->rx_irq);
Wei Liu's avatar
Wei Liu committed
173
	xenvif_check_rx_xenvif(vif);
Ian Campbell's avatar
Ian Campbell committed
174
175
176
177
}

static void xenvif_down(struct xenvif *vif)
{
178
	napi_disable(&vif->napi);
179
180
181
	disable_irq(vif->tx_irq);
	if (vif->tx_irq != vif->rx_irq)
		disable_irq(vif->rx_irq);
182
	del_timer_sync(&vif->credit_timeout);
Ian Campbell's avatar
Ian Campbell committed
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
}

static int xenvif_open(struct net_device *dev)
{
	struct xenvif *vif = netdev_priv(dev);
	if (netif_carrier_ok(dev))
		xenvif_up(vif);
	netif_start_queue(dev);
	return 0;
}

static int xenvif_close(struct net_device *dev)
{
	struct xenvif *vif = netdev_priv(dev);
	if (netif_carrier_ok(dev))
		xenvif_down(vif);
	netif_stop_queue(dev);
	return 0;
}

static int xenvif_change_mtu(struct net_device *dev, int mtu)
{
	struct xenvif *vif = netdev_priv(dev);
	int max = vif->can_sg ? 65535 - VLAN_ETH_HLEN : ETH_DATA_LEN;

	if (mtu > max)
		return -EINVAL;
	dev->mtu = mtu;
	return 0;
}

214
215
static netdev_features_t xenvif_fix_features(struct net_device *dev,
	netdev_features_t features)
Ian Campbell's avatar
Ian Campbell committed
216
217
218
{
	struct xenvif *vif = netdev_priv(dev);

219
220
	if (!vif->can_sg)
		features &= ~NETIF_F_SG;
221
	if (~(vif->gso_mask | vif->gso_prefix_mask) & GSO_BIT(TCPV4))
222
		features &= ~NETIF_F_TSO;
223
224
	if (~(vif->gso_mask | vif->gso_prefix_mask) & GSO_BIT(TCPV6))
		features &= ~NETIF_F_TSO6;
225
	if (!vif->ip_csum)
226
		features &= ~NETIF_F_IP_CSUM;
227
228
	if (!vif->ipv6_csum)
		features &= ~NETIF_F_IPV6_CSUM;
Ian Campbell's avatar
Ian Campbell committed
229

230
	return features;
Ian Campbell's avatar
Ian Campbell committed
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
}

static const struct xenvif_stat {
	char name[ETH_GSTRING_LEN];
	u16 offset;
} xenvif_stats[] = {
	{
		"rx_gso_checksum_fixup",
		offsetof(struct xenvif, rx_gso_checksum_fixup)
	},
};

static int xenvif_get_sset_count(struct net_device *dev, int string_set)
{
	switch (string_set) {
	case ETH_SS_STATS:
		return ARRAY_SIZE(xenvif_stats);
	default:
		return -EINVAL;
	}
}

static void xenvif_get_ethtool_stats(struct net_device *dev,
				     struct ethtool_stats *stats, u64 * data)
{
	void *vif = netdev_priv(dev);
	int i;

	for (i = 0; i < ARRAY_SIZE(xenvif_stats); i++)
		data[i] = *(unsigned long *)(vif + xenvif_stats[i].offset);
}

static void xenvif_get_strings(struct net_device *dev, u32 stringset, u8 * data)
{
	int i;

	switch (stringset) {
	case ETH_SS_STATS:
		for (i = 0; i < ARRAY_SIZE(xenvif_stats); i++)
			memcpy(data + i * ETH_GSTRING_LEN,
			       xenvif_stats[i].name, ETH_GSTRING_LEN);
		break;
	}
}

276
static const struct ethtool_ops xenvif_ethtool_ops = {
Ian Campbell's avatar
Ian Campbell committed
277
278
279
280
281
282
283
	.get_link	= ethtool_op_get_link,

	.get_sset_count = xenvif_get_sset_count,
	.get_ethtool_stats = xenvif_get_ethtool_stats,
	.get_strings = xenvif_get_strings,
};

284
static const struct net_device_ops xenvif_netdev_ops = {
Ian Campbell's avatar
Ian Campbell committed
285
286
287
288
289
	.ndo_start_xmit	= xenvif_start_xmit,
	.ndo_get_stats	= xenvif_get_stats,
	.ndo_open	= xenvif_open,
	.ndo_stop	= xenvif_close,
	.ndo_change_mtu	= xenvif_change_mtu,
290
	.ndo_fix_features = xenvif_fix_features,
291
292
	.ndo_set_mac_address = eth_mac_addr,
	.ndo_validate_addr   = eth_validate_addr,
Ian Campbell's avatar
Ian Campbell committed
293
294
295
296
297
298
299
300
301
};

struct xenvif *xenvif_alloc(struct device *parent, domid_t domid,
			    unsigned int handle)
{
	int err;
	struct net_device *dev;
	struct xenvif *vif;
	char name[IFNAMSIZ] = {};
302
	int i;
Ian Campbell's avatar
Ian Campbell committed
303
304
305
306

	snprintf(name, IFNAMSIZ - 1, "vif%u.%u", domid, handle);
	dev = alloc_netdev(sizeof(struct xenvif), name, ether_setup);
	if (dev == NULL) {
307
		pr_warn("Could not allocate netdev for %s\n", name);
Ian Campbell's avatar
Ian Campbell committed
308
309
310
311
312
313
		return ERR_PTR(-ENOMEM);
	}

	SET_NETDEV_DEV(dev, parent);

	vif = netdev_priv(dev);
314
315
316
317
318
319
320
321
322

	vif->grant_copy_op = vmalloc(sizeof(struct gnttab_copy) *
				     MAX_GRANT_COPY_OPS);
	if (vif->grant_copy_op == NULL) {
		pr_warn("Could not allocate grant copy space for %s\n", name);
		free_netdev(dev);
		return ERR_PTR(-ENOMEM);
	}

Ian Campbell's avatar
Ian Campbell committed
323
324
325
	vif->domid  = domid;
	vif->handle = handle;
	vif->can_sg = 1;
326
	vif->ip_csum = 1;
Ian Campbell's avatar
Ian Campbell committed
327
328
329
330
331
	vif->dev = dev;

	vif->credit_bytes = vif->remaining_credit = ~0UL;
	vif->credit_usec  = 0UL;
	init_timer(&vif->credit_timeout);
332
	vif->credit_window_start = get_jiffies_64();
Ian Campbell's avatar
Ian Campbell committed
333
334

	dev->netdev_ops	= &xenvif_netdev_ops;
335
336
	dev->hw_features = NETIF_F_SG |
		NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
337
		NETIF_F_TSO | NETIF_F_TSO6;
338
	dev->features = dev->hw_features | NETIF_F_RXCSUM;
Ian Campbell's avatar
Ian Campbell committed
339
340
341
342
	SET_ETHTOOL_OPS(dev, &xenvif_ethtool_ops);

	dev->tx_queue_len = XENVIF_QUEUE_LENGTH;

343
344
345
346
347
348
349
	skb_queue_head_init(&vif->rx_queue);
	skb_queue_head_init(&vif->tx_queue);

	vif->pending_cons = 0;
	vif->pending_prod = MAX_PENDING_REQS;
	for (i = 0; i < MAX_PENDING_REQS; i++)
		vif->pending_ring[i] = i;
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
	spin_lock_init(&vif->callback_lock);
	spin_lock_init(&vif->response_lock);
	/* If ballooning is disabled, this will consume real memory, so you
	 * better enable it. The long term solution would be to use just a
	 * bunch of valid page descriptors, without dependency on ballooning
	 */
	err = alloc_xenballooned_pages(MAX_PENDING_REQS,
				       vif->mmap_pages,
				       false);
	if (err) {
		netdev_err(dev, "Could not reserve mmap_pages\n");
		return ERR_PTR(-ENOMEM);
	}
	for (i = 0; i < MAX_PENDING_REQS; i++) {
		vif->pending_tx_info[i].callback_struct = (struct ubuf_info)
			{ .callback = xenvif_zerocopy_callback,
			  .ctx = NULL,
			  .desc = i };
		vif->grant_tx_handle[i] = NETBACK_INVALID_HANDLE;
	}
370

Ian Campbell's avatar
Ian Campbell committed
371
372
373
374
375
376
377
378
379
	/*
	 * Initialise a dummy MAC address. We choose the numerically
	 * largest non-broadcast address to prevent the address getting
	 * stolen by an Ethernet bridge for STP purposes.
	 * (FE:FF:FF:FF:FF:FF)
	 */
	memset(dev->dev_addr, 0xFF, ETH_ALEN);
	dev->dev_addr[0] &= ~0x01;

380
381
	netif_napi_add(dev, &vif->napi, xenvif_poll, XENVIF_NAPI_WEIGHT);

Ian Campbell's avatar
Ian Campbell committed
382
383
384
385
386
387
388
389
390
391
	netif_carrier_off(dev);

	err = register_netdev(dev);
	if (err) {
		netdev_warn(dev, "Could not register device: err=%d\n", err);
		free_netdev(dev);
		return ERR_PTR(err);
	}

	netdev_dbg(dev, "Successfully created xenvif\n");
392
393
394

	__module_get(THIS_MODULE);

Ian Campbell's avatar
Ian Campbell committed
395
396
397
398
	return vif;
}

int xenvif_connect(struct xenvif *vif, unsigned long tx_ring_ref,
399
400
		   unsigned long rx_ring_ref, unsigned int tx_evtchn,
		   unsigned int rx_evtchn)
Ian Campbell's avatar
Ian Campbell committed
401
{
402
	struct task_struct *task;
Ian Campbell's avatar
Ian Campbell committed
403
404
	int err = -ENOMEM;

405
406
	BUG_ON(vif->tx_irq);
	BUG_ON(vif->task);
407
	BUG_ON(vif->dealloc_task);
Ian Campbell's avatar
Ian Campbell committed
408

Wei Liu's avatar
Wei Liu committed
409
	err = xenvif_map_frontend_rings(vif, tx_ring_ref, rx_ring_ref);
Ian Campbell's avatar
Ian Campbell committed
410
411
412
	if (err < 0)
		goto err;

413
	init_waitqueue_head(&vif->wq);
414
	init_waitqueue_head(&vif->dealloc_wq);
415

416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
	if (tx_evtchn == rx_evtchn) {
		/* feature-split-event-channels == 0 */
		err = bind_interdomain_evtchn_to_irqhandler(
			vif->domid, tx_evtchn, xenvif_interrupt, 0,
			vif->dev->name, vif);
		if (err < 0)
			goto err_unmap;
		vif->tx_irq = vif->rx_irq = err;
		disable_irq(vif->tx_irq);
	} else {
		/* feature-split-event-channels == 1 */
		snprintf(vif->tx_irq_name, sizeof(vif->tx_irq_name),
			 "%s-tx", vif->dev->name);
		err = bind_interdomain_evtchn_to_irqhandler(
			vif->domid, tx_evtchn, xenvif_tx_interrupt, 0,
			vif->tx_irq_name, vif);
		if (err < 0)
			goto err_unmap;
		vif->tx_irq = err;
		disable_irq(vif->tx_irq);

		snprintf(vif->rx_irq_name, sizeof(vif->rx_irq_name),
			 "%s-rx", vif->dev->name);
		err = bind_interdomain_evtchn_to_irqhandler(
			vif->domid, rx_evtchn, xenvif_rx_interrupt, 0,
			vif->rx_irq_name, vif);
		if (err < 0)
			goto err_tx_unbind;
		vif->rx_irq = err;
		disable_irq(vif->rx_irq);
	}
Ian Campbell's avatar
Ian Campbell committed
447

448
449
	task = kthread_create(xenvif_kthread_guest_rx,
			      (void *)vif, "%s-guest-rx", vif->dev->name);
450
	if (IS_ERR(task)) {
451
		pr_warn("Could not allocate kthread for %s\n", vif->dev->name);
452
		err = PTR_ERR(task);
453
454
		goto err_rx_unbind;
	}
Ian Campbell's avatar
Ian Campbell committed
455

456
457
	vif->task = task;

458
459
460
461
462
463
464
465
466
467
	task = kthread_create(xenvif_dealloc_kthread,
			      (void *)vif, "%s-dealloc", vif->dev->name);
	if (IS_ERR(task)) {
		pr_warn("Could not allocate kthread for %s\n", vif->dev->name);
		err = PTR_ERR(task);
		goto err_rx_unbind;
	}

	vif->dealloc_task = task;

Ian Campbell's avatar
Ian Campbell committed
468
	rtnl_lock();
469
470
471
472
	if (!vif->can_sg && vif->dev->mtu > ETH_DATA_LEN)
		dev_set_mtu(vif->dev, ETH_DATA_LEN);
	netdev_update_features(vif->dev);
	netif_carrier_on(vif->dev);
473
474
	if (netif_running(vif->dev))
		xenvif_up(vif);
Ian Campbell's avatar
Ian Campbell committed
475
476
	rtnl_unlock();

477
	wake_up_process(vif->task);
478
	wake_up_process(vif->dealloc_task);
479

Ian Campbell's avatar
Ian Campbell committed
480
	return 0;
481
482
483
484

err_rx_unbind:
	unbind_from_irqhandler(vif->rx_irq, vif);
	vif->rx_irq = 0;
485
486
487
err_tx_unbind:
	unbind_from_irqhandler(vif->tx_irq, vif);
	vif->tx_irq = 0;
Ian Campbell's avatar
Ian Campbell committed
488
err_unmap:
Wei Liu's avatar
Wei Liu committed
489
	xenvif_unmap_frontend_rings(vif);
Ian Campbell's avatar
Ian Campbell committed
490
err:
491
	module_put(THIS_MODULE);
Ian Campbell's avatar
Ian Campbell committed
492
493
494
	return err;
}

495
void xenvif_carrier_off(struct xenvif *vif)
Ian Campbell's avatar
Ian Campbell committed
496
497
{
	struct net_device *dev = vif->dev;
498
499
500
501
502
503
504
505
506
507
508
509

	rtnl_lock();
	netif_carrier_off(dev); /* discard queued packets */
	if (netif_running(dev))
		xenvif_down(vif);
	rtnl_unlock();
}

void xenvif_disconnect(struct xenvif *vif)
{
	if (netif_carrier_ok(vif->dev))
		xenvif_carrier_off(vif);
Ian Campbell's avatar
Ian Campbell committed
510

511
	if (vif->task) {
512
		kthread_stop(vif->task);
513
514
		vif->task = NULL;
	}
515

516
517
518
519
520
	if (vif->dealloc_task) {
		kthread_stop(vif->dealloc_task);
		vif->dealloc_task = NULL;
	}

521
522
523
524
525
526
527
	if (vif->tx_irq) {
		if (vif->tx_irq == vif->rx_irq)
			unbind_from_irqhandler(vif->tx_irq, vif);
		else {
			unbind_from_irqhandler(vif->tx_irq, vif);
			unbind_from_irqhandler(vif->rx_irq, vif);
		}
528
		vif->tx_irq = 0;
529
	}
Ian Campbell's avatar
Ian Campbell committed
530

531
532
533
534
535
	xenvif_unmap_frontend_rings(vif);
}

void xenvif_free(struct xenvif *vif)
{
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
	int i, unmap_timeout = 0;

	for (i = 0; i < MAX_PENDING_REQS; ++i) {
		if (vif->grant_tx_handle[i] != NETBACK_INVALID_HANDLE) {
			unmap_timeout++;
			schedule_timeout(msecs_to_jiffies(1000));
			if (unmap_timeout > 9 &&
			    net_ratelimit())
				netdev_err(vif->dev,
					   "Page still granted! Index: %x\n",
					   i);
			i = -1;
		}
	}

	free_xenballooned_pages(MAX_PENDING_REQS, vif->mmap_pages);

553
554
	netif_napi_del(&vif->napi);

Ian Campbell's avatar
Ian Campbell committed
555
556
	unregister_netdev(vif->dev);

557
	vfree(vif->grant_copy_op);
Ian Campbell's avatar
Ian Campbell committed
558
	free_netdev(vif->dev);
559

560
	module_put(THIS_MODULE);
Ian Campbell's avatar
Ian Campbell committed
561
}