interface.c 11.9 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
37
38
39
40
41
#include <linux/ethtool.h>
#include <linux/rtnetlink.h>
#include <linux/if_vlan.h>

#include <xen/events.h>
#include <asm/xen/hypercall.h>

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

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

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

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

56
57
58
	return IRQ_HANDLED;
}

59
60
61
62
63
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
64
	work_done = xenvif_tx_action(vif, budget);
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

	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);
		if (!more_to_do)
			__napi_complete(napi);

		local_irq_restore(flags);
	}

	return work_done;
}

98
99
100
101
static irqreturn_t xenvif_rx_interrupt(int irq, void *dev_id)
{
	struct xenvif *vif = dev_id;

102
103
	vif->rx_event = true;
	xenvif_kick_thread(vif);
Ian Campbell's avatar
Ian Campbell committed
104
105
106
107

	return IRQ_HANDLED;
}

108
109
110
111
112
113
114
115
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
116
117
118
static int xenvif_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
	struct xenvif *vif = netdev_priv(dev);
119
	int min_slots_needed;
Ian Campbell's avatar
Ian Campbell committed
120
121
122

	BUG_ON(skb->dev != dev);

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

127
128
129
130
	/* 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
131

132
133
134
135
136
137
	/* 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
138

139
140
141
142
143
144
	/* 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
145

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

	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)
{
165
	napi_enable(&vif->napi);
166
167
168
	enable_irq(vif->tx_irq);
	if (vif->tx_irq != vif->rx_irq)
		enable_irq(vif->rx_irq);
Wei Liu's avatar
Wei Liu committed
169
	xenvif_check_rx_xenvif(vif);
Ian Campbell's avatar
Ian Campbell committed
170
171
172
173
}

static void xenvif_down(struct xenvif *vif)
{
174
	napi_disable(&vif->napi);
175
176
177
	disable_irq(vif->tx_irq);
	if (vif->tx_irq != vif->rx_irq)
		disable_irq(vif->rx_irq);
178
	del_timer_sync(&vif->credit_timeout);
Ian Campbell's avatar
Ian Campbell committed
179
180
181
182
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
}

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;
}

210
211
static netdev_features_t xenvif_fix_features(struct net_device *dev,
	netdev_features_t features)
Ian Campbell's avatar
Ian Campbell committed
212
213
214
{
	struct xenvif *vif = netdev_priv(dev);

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

226
	return features;
Ian Campbell's avatar
Ian Campbell committed
227
228
229
230
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
}

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;
	}
}

272
static const struct ethtool_ops xenvif_ethtool_ops = {
Ian Campbell's avatar
Ian Campbell committed
273
274
275
276
277
278
279
	.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,
};

280
static const struct net_device_ops xenvif_netdev_ops = {
Ian Campbell's avatar
Ian Campbell committed
281
282
283
284
285
	.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,
286
	.ndo_fix_features = xenvif_fix_features,
287
288
	.ndo_set_mac_address = eth_mac_addr,
	.ndo_validate_addr   = eth_validate_addr,
Ian Campbell's avatar
Ian Campbell committed
289
290
291
292
293
294
295
296
297
};

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] = {};
298
	int i;
Ian Campbell's avatar
Ian Campbell committed
299
300
301
302

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

	SET_NETDEV_DEV(dev, parent);

	vif = netdev_priv(dev);
	vif->domid  = domid;
	vif->handle = handle;
	vif->can_sg = 1;
313
	vif->ip_csum = 1;
Ian Campbell's avatar
Ian Campbell committed
314
315
316
317
318
	vif->dev = dev;

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

	dev->netdev_ops	= &xenvif_netdev_ops;
322
323
	dev->hw_features = NETIF_F_SG |
		NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
324
		NETIF_F_TSO | NETIF_F_TSO6;
325
	dev->features = dev->hw_features | NETIF_F_RXCSUM;
Ian Campbell's avatar
Ian Campbell committed
326
327
328
329
	SET_ETHTOOL_OPS(dev, &xenvif_ethtool_ops);

	dev->tx_queue_len = XENVIF_QUEUE_LENGTH;

330
331
332
333
334
335
336
337
338
339
	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;
	for (i = 0; i < MAX_PENDING_REQS; i++)
		vif->mmap_pages[i] = NULL;

Ian Campbell's avatar
Ian Campbell committed
340
341
342
343
344
345
346
347
348
	/*
	 * 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;

349
350
	netif_napi_add(dev, &vif->napi, xenvif_poll, XENVIF_NAPI_WEIGHT);

Ian Campbell's avatar
Ian Campbell committed
351
352
353
354
355
356
357
358
359
360
	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");
361
362
363

	__module_get(THIS_MODULE);

Ian Campbell's avatar
Ian Campbell committed
364
365
366
367
	return vif;
}

int xenvif_connect(struct xenvif *vif, unsigned long tx_ring_ref,
368
369
		   unsigned long rx_ring_ref, unsigned int tx_evtchn,
		   unsigned int rx_evtchn)
Ian Campbell's avatar
Ian Campbell committed
370
{
371
	struct task_struct *task;
Ian Campbell's avatar
Ian Campbell committed
372
373
	int err = -ENOMEM;

374
375
	BUG_ON(vif->tx_irq);
	BUG_ON(vif->task);
Ian Campbell's avatar
Ian Campbell committed
376

Wei Liu's avatar
Wei Liu committed
377
	err = xenvif_map_frontend_rings(vif, tx_ring_ref, rx_ring_ref);
Ian Campbell's avatar
Ian Campbell committed
378
379
380
	if (err < 0)
		goto err;

381
382
	init_waitqueue_head(&vif->wq);

383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
	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
414

415
416
417
	task = kthread_create(xenvif_kthread,
			      (void *)vif, "%s", vif->dev->name);
	if (IS_ERR(task)) {
418
		pr_warn("Could not allocate kthread for %s\n", vif->dev->name);
419
		err = PTR_ERR(task);
420
421
		goto err_rx_unbind;
	}
Ian Campbell's avatar
Ian Campbell committed
422

423
424
	vif->task = task;

Ian Campbell's avatar
Ian Campbell committed
425
	rtnl_lock();
426
427
428
429
	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);
430
431
	if (netif_running(vif->dev))
		xenvif_up(vif);
Ian Campbell's avatar
Ian Campbell committed
432
433
	rtnl_unlock();

434
435
	wake_up_process(vif->task);

Ian Campbell's avatar
Ian Campbell committed
436
	return 0;
437
438
439
440

err_rx_unbind:
	unbind_from_irqhandler(vif->rx_irq, vif);
	vif->rx_irq = 0;
441
442
443
err_tx_unbind:
	unbind_from_irqhandler(vif->tx_irq, vif);
	vif->tx_irq = 0;
Ian Campbell's avatar
Ian Campbell committed
444
err_unmap:
Wei Liu's avatar
Wei Liu committed
445
	xenvif_unmap_frontend_rings(vif);
Ian Campbell's avatar
Ian Campbell committed
446
err:
447
	module_put(THIS_MODULE);
Ian Campbell's avatar
Ian Campbell committed
448
449
450
	return err;
}

451
void xenvif_carrier_off(struct xenvif *vif)
Ian Campbell's avatar
Ian Campbell committed
452
453
{
	struct net_device *dev = vif->dev;
454
455
456
457
458
459
460
461
462
463
464
465

	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
466

467
	if (vif->task) {
468
		kthread_stop(vif->task);
469
470
		vif->task = NULL;
	}
471

472
473
474
475
476
477
478
	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);
		}
479
		vif->tx_irq = 0;
480
	}
Ian Campbell's avatar
Ian Campbell committed
481

482
483
484
485
486
	xenvif_unmap_frontend_rings(vif);
}

void xenvif_free(struct xenvif *vif)
{
487
488
	netif_napi_del(&vif->napi);

Ian Campbell's avatar
Ian Campbell committed
489
490
491
	unregister_netdev(vif->dev);

	free_netdev(vif->dev);
492

493
	module_put(THIS_MODULE);
Ian Campbell's avatar
Ian Campbell committed
494
}