netpoll.c 30.6 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
5
6
7
8
9
10
11
/*
 * Common framework for low-level network console, dump, and debugger code
 *
 * Sep 8 2003  Matt Mackall <mpm@selenic.com>
 *
 * based on the netconsole code from:
 *
 * Copyright (C) 2001  Ingo Molnar <mingo@redhat.com>
 * Copyright (C) 2002  Red Hat, Inc.
 */

12
13
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

14
#include <linux/moduleparam.h>
15
#include <linux/kernel.h>
Linus Torvalds's avatar
Linus Torvalds committed
16
17
18
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/string.h>
19
#include <linux/if_arp.h>
Linus Torvalds's avatar
Linus Torvalds committed
20
21
22
23
24
25
26
27
#include <linux/inetdevice.h>
#include <linux/inet.h>
#include <linux/interrupt.h>
#include <linux/netpoll.h>
#include <linux/sched.h>
#include <linux/delay.h>
#include <linux/rcupdate.h>
#include <linux/workqueue.h>
28
#include <linux/slab.h>
29
#include <linux/export.h>
30
#include <linux/if_vlan.h>
Linus Torvalds's avatar
Linus Torvalds committed
31
32
#include <net/tcp.h>
#include <net/udp.h>
Cong Wang's avatar
Cong Wang committed
33
34
35
#include <net/addrconf.h>
#include <net/ndisc.h>
#include <net/ip6_checksum.h>
Linus Torvalds's avatar
Linus Torvalds committed
36
#include <asm/unaligned.h>
37
#include <trace/events/napi.h>
Linus Torvalds's avatar
Linus Torvalds committed
38
39
40
41
42
43
44
45
46

/*
 * We maintain a small pool of fully-sized skbs, to make sure the
 * message gets out even in extreme OOM situations.
 */

#define MAX_UDP_CHUNK 1460
#define MAX_SKBS 32

47
static struct sk_buff_head skb_pool;
Linus Torvalds's avatar
Linus Torvalds committed
48
49
50

static atomic_t trapped;

51
DEFINE_STATIC_SRCU(netpoll_srcu);
52

Stephen Hemminger's avatar
Stephen Hemminger committed
53
#define USEC_PER_POLL	50
54
55
#define NETPOLL_RX_ENABLED  1
#define NETPOLL_RX_DROP     2
Linus Torvalds's avatar
Linus Torvalds committed
56

57
58
59
60
61
#define MAX_SKB_SIZE							\
	(sizeof(struct ethhdr) +					\
	 sizeof(struct iphdr) +						\
	 sizeof(struct udphdr) +					\
	 MAX_UDP_CHUNK)
Linus Torvalds's avatar
Linus Torvalds committed
62

63
static void zap_completion_queue(void);
Cong Wang's avatar
Cong Wang committed
64
static void netpoll_neigh_reply(struct sk_buff *skb, struct netpoll_info *npinfo);
65
static void netpoll_async_cleanup(struct work_struct *work);
Linus Torvalds's avatar
Linus Torvalds committed
66

67
68
69
static unsigned int carrier_timeout = 4;
module_param(carrier_timeout, uint, 0644);

70
71
72
73
74
75
76
#define np_info(np, fmt, ...)				\
	pr_info("%s: " fmt, np->name, ##__VA_ARGS__)
#define np_err(np, fmt, ...)				\
	pr_err("%s: " fmt, np->name, ##__VA_ARGS__)
#define np_notice(np, fmt, ...)				\
	pr_notice("%s: " fmt, np->name, ##__VA_ARGS__)

David Howells's avatar
David Howells committed
77
static void queue_process(struct work_struct *work)
Linus Torvalds's avatar
Linus Torvalds committed
78
{
79
80
	struct netpoll_info *npinfo =
		container_of(work, struct netpoll_info, tx_work.work);
Linus Torvalds's avatar
Linus Torvalds committed
81
	struct sk_buff *skb;
82
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
83

84
85
	while ((skb = skb_dequeue(&npinfo->txq))) {
		struct net_device *dev = skb->dev;
86
		const struct net_device_ops *ops = dev->netdev_ops;
87
		struct netdev_queue *txq;
Linus Torvalds's avatar
Linus Torvalds committed
88

89
90
91
92
		if (!netif_device_present(dev) || !netif_running(dev)) {
			__kfree_skb(skb);
			continue;
		}
Linus Torvalds's avatar
Linus Torvalds committed
93

94
95
		txq = netdev_get_tx_queue(dev, skb_get_queue_mapping(skb));

96
		local_irq_save(flags);
97
		__netif_tx_lock(txq, smp_processor_id());
98
		if (netif_xmit_frozen_or_stopped(txq) ||
99
		    ops->ndo_start_xmit(skb, dev) != NETDEV_TX_OK) {
100
			skb_queue_head(&npinfo->txq, skb);
101
			__netif_tx_unlock(txq);
102
			local_irq_restore(flags);
Linus Torvalds's avatar
Linus Torvalds committed
103

104
			schedule_delayed_work(&npinfo->tx_work, HZ/10);
105
106
			return;
		}
107
		__netif_tx_unlock(txq);
108
		local_irq_restore(flags);
Linus Torvalds's avatar
Linus Torvalds committed
109
110
111
	}
}

112
113
static __sum16 checksum_udp(struct sk_buff *skb, struct udphdr *uh,
			    unsigned short ulen, __be32 saddr, __be32 daddr)
Linus Torvalds's avatar
Linus Torvalds committed
114
{
115
	__wsum psum;
116

117
	if (uh->check == 0 || skb_csum_unnecessary(skb))
Linus Torvalds's avatar
Linus Torvalds committed
118
119
		return 0;

120
121
	psum = csum_tcpudp_nofold(saddr, daddr, ulen, IPPROTO_UDP, 0);

122
	if (skb->ip_summed == CHECKSUM_COMPLETE &&
123
	    !csum_fold(csum_add(psum, skb->csum)))
124
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
125

126
	skb->csum = psum;
Linus Torvalds's avatar
Linus Torvalds committed
127

128
	return __skb_checksum_complete(skb);
Linus Torvalds's avatar
Linus Torvalds committed
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
}

/*
 * Check whether delayed processing was scheduled for our NIC. If so,
 * we attempt to grab the poll lock and use ->poll() to pump the card.
 * If this fails, either we've recursed in ->poll() or it's already
 * running on another CPU.
 *
 * Note: we don't mask interrupts with this lock because we're using
 * trylock here and interrupts are already disabled in the softirq
 * case. Further, we test the poll_owner to avoid recursion on UP
 * systems where the lock doesn't exist.
 *
 * In cases where there is bi-directional communications, reading only
 * one message at a time can lead to packets being dropped by the
 * network adapter, forcing superfluous retries and possibly timeouts.
 * Thus, we set our budget to greater than 1.
 */
147
148
149
150
151
152
153
154
155
156
157
158
static int poll_one_napi(struct netpoll_info *npinfo,
			 struct napi_struct *napi, int budget)
{
	int work;

	/* net_rx_action's ->poll() invocations and our's are
	 * synchronized by this test which is only made while
	 * holding the napi->poll_lock.
	 */
	if (!test_bit(NAPI_STATE_SCHED, &napi->state))
		return budget;

159
	npinfo->rx_flags |= NETPOLL_RX_DROP;
160
	atomic_inc(&trapped);
161
	set_bit(NAPI_STATE_NPSVC, &napi->state);
162
163

	work = napi->poll(napi, budget);
164
	trace_napi_poll(napi);
165

166
	clear_bit(NAPI_STATE_NPSVC, &napi->state);
167
	atomic_dec(&trapped);
168
	npinfo->rx_flags &= ~NETPOLL_RX_DROP;
169
170
171
172

	return budget - work;
}

173
static void poll_napi(struct net_device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
174
{
175
	struct napi_struct *napi;
Linus Torvalds's avatar
Linus Torvalds committed
176
177
	int budget = 16;

178
	list_for_each_entry(napi, &dev->napi_list, dev_list) {
179
		if (napi->poll_owner != smp_processor_id() &&
180
		    spin_trylock(&napi->poll_lock)) {
181
182
			budget = poll_one_napi(rcu_dereference_bh(dev->npinfo),
					       napi, budget);
183
			spin_unlock(&napi->poll_lock);
184

185
			if (!budget)
186
				break;
187
		}
Linus Torvalds's avatar
Linus Torvalds committed
188
189
190
	}
}

Cong Wang's avatar
Cong Wang committed
191
static void service_neigh_queue(struct netpoll_info *npi)
192
{
193
194
	if (npi) {
		struct sk_buff *skb;
195

Cong Wang's avatar
Cong Wang committed
196
197
		while ((skb = skb_dequeue(&npi->neigh_tx)))
			netpoll_neigh_reply(skb, npi);
198
199
200
	}
}

201
static void netpoll_poll_dev(struct net_device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
202
{
203
	const struct net_device_ops *ops;
204
	struct netpoll_info *ni = rcu_dereference_bh(dev->npinfo);
205

206
207
208
209
	/* Don't do any rx activity if the dev_lock mutex is held
	 * the dev_open/close paths use this to block netpoll activity
	 * while changing device state
	 */
210
	if (down_trylock(&ni->dev_lock))
211
212
		return;

213
	if (!netif_running(dev)) {
214
		up(&ni->dev_lock);
215
		return;
216
	}
217
218

	ops = dev->netdev_ops;
219
	if (!ops->ndo_poll_controller) {
220
		up(&ni->dev_lock);
Linus Torvalds's avatar
Linus Torvalds committed
221
		return;
222
	}
Linus Torvalds's avatar
Linus Torvalds committed
223
224

	/* Process pending work on NIC */
225
	ops->ndo_poll_controller(dev);
226
227

	poll_napi(dev);
Linus Torvalds's avatar
Linus Torvalds committed
228

229
	up(&ni->dev_lock);
230

231
	if (dev->flags & IFF_SLAVE) {
232
		if (ni) {
233
			struct net_device *bond_dev;
234
			struct sk_buff *skb;
235
236
237
238
			struct netpoll_info *bond_ni;

			bond_dev = netdev_master_upper_dev_get_rcu(dev);
			bond_ni = rcu_dereference_bh(bond_dev->npinfo);
Cong Wang's avatar
Cong Wang committed
239
			while ((skb = skb_dequeue(&ni->neigh_tx))) {
240
				skb->dev = bond_dev;
Cong Wang's avatar
Cong Wang committed
241
				skb_queue_tail(&bond_ni->neigh_tx, skb);
242
243
244
245
			}
		}
	}

Cong Wang's avatar
Cong Wang committed
246
	service_neigh_queue(ni);
247

248
	zap_completion_queue();
Linus Torvalds's avatar
Linus Torvalds committed
249
250
}

251
252
253
254
255
256
257
258
int netpoll_rx_disable(struct net_device *dev)
{
	struct netpoll_info *ni;
	int idx;
	might_sleep();
	idx = srcu_read_lock(&netpoll_srcu);
	ni = srcu_dereference(dev->npinfo, &netpoll_srcu);
	if (ni)
259
		down(&ni->dev_lock);
260
261
262
263
264
265
266
267
268
269
270
	srcu_read_unlock(&netpoll_srcu, idx);
	return 0;
}
EXPORT_SYMBOL(netpoll_rx_disable);

void netpoll_rx_enable(struct net_device *dev)
{
	struct netpoll_info *ni;
	rcu_read_lock();
	ni = rcu_dereference(dev->npinfo);
	if (ni)
271
		up(&ni->dev_lock);
272
273
274
275
	rcu_read_unlock();
}
EXPORT_SYMBOL(netpoll_rx_enable);

Linus Torvalds's avatar
Linus Torvalds committed
276
277
278
279
280
static void refill_skbs(void)
{
	struct sk_buff *skb;
	unsigned long flags;

281
282
	spin_lock_irqsave(&skb_pool.lock, flags);
	while (skb_pool.qlen < MAX_SKBS) {
Linus Torvalds's avatar
Linus Torvalds committed
283
284
285
286
		skb = alloc_skb(MAX_SKB_SIZE, GFP_ATOMIC);
		if (!skb)
			break;

287
		__skb_queue_tail(&skb_pool, skb);
Linus Torvalds's avatar
Linus Torvalds committed
288
	}
289
	spin_unlock_irqrestore(&skb_pool.lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
290
291
}

292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
static void zap_completion_queue(void)
{
	unsigned long flags;
	struct softnet_data *sd = &get_cpu_var(softnet_data);

	if (sd->completion_queue) {
		struct sk_buff *clist;

		local_irq_save(flags);
		clist = sd->completion_queue;
		sd->completion_queue = NULL;
		local_irq_restore(flags);

		while (clist != NULL) {
			struct sk_buff *skb = clist;
			clist = clist->next;
			if (skb->destructor) {
				atomic_inc(&skb->users);
				dev_kfree_skb_any(skb); /* put this one back */
			} else {
				__kfree_skb(skb);
			}
		}
	}

	put_cpu_var(softnet_data);
}

320
static struct sk_buff *find_skb(struct netpoll *np, int len, int reserve)
Linus Torvalds's avatar
Linus Torvalds committed
321
{
322
323
	int count = 0;
	struct sk_buff *skb;
Linus Torvalds's avatar
Linus Torvalds committed
324

325
	zap_completion_queue();
326
	refill_skbs();
Linus Torvalds's avatar
Linus Torvalds committed
327
328
329
repeat:

	skb = alloc_skb(len, GFP_ATOMIC);
330
331
	if (!skb)
		skb = skb_dequeue(&skb_pool);
Linus Torvalds's avatar
Linus Torvalds committed
332
333

	if (!skb) {
334
		if (++count < 10) {
335
			netpoll_poll_dev(np->dev);
336
			goto repeat;
Linus Torvalds's avatar
Linus Torvalds committed
337
		}
338
		return NULL;
Linus Torvalds's avatar
Linus Torvalds committed
339
340
341
342
343
344
345
	}

	atomic_set(&skb->users, 1);
	skb_reserve(skb, reserve);
	return skb;
}

346
347
348
349
350
351
352
353
354
355
356
static int netpoll_owner_active(struct net_device *dev)
{
	struct napi_struct *napi;

	list_for_each_entry(napi, &dev->napi_list, dev_list) {
		if (napi->poll_owner == smp_processor_id())
			return 1;
	}
	return 0;
}

357
/* call with IRQ disabled */
358
359
void netpoll_send_skb_on_dev(struct netpoll *np, struct sk_buff *skb,
			     struct net_device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
360
{
Stephen Hemminger's avatar
Stephen Hemminger committed
361
362
	int status = NETDEV_TX_BUSY;
	unsigned long tries;
363
	const struct net_device_ops *ops = dev->netdev_ops;
Herbert Xu's avatar
Herbert Xu committed
364
	/* It is up to the caller to keep npinfo alive. */
365
	struct netpoll_info *npinfo;
Stephen Hemminger's avatar
Stephen Hemminger committed
366

367
368
369
	WARN_ON_ONCE(!irqs_disabled());

	npinfo = rcu_dereference_bh(np->dev->npinfo);
370
371
372
373
	if (!npinfo || !netif_running(dev) || !netif_device_present(dev)) {
		__kfree_skb(skb);
		return;
	}
Stephen Hemminger's avatar
Stephen Hemminger committed
374
375

	/* don't get messages out of order, and no recursion */
376
	if (skb_queue_len(&npinfo->txq) == 0 && !netpoll_owner_active(dev)) {
377
		struct netdev_queue *txq;
378

379
		txq = netdev_pick_tx(dev, skb);
380

381
382
383
		/* try until next clock tick */
		for (tries = jiffies_to_usecs(1)/USEC_PER_POLL;
		     tries > 0; --tries) {
384
			if (__netif_tx_trylock(txq)) {
385
				if (!netif_xmit_stopped(txq)) {
386
					if (vlan_tx_tag_present(skb) &&
387
388
389
					    !vlan_hw_offload_capable(netif_skb_features(skb),
								     skb->vlan_proto)) {
						skb = __vlan_put_tag(skb, skb->vlan_proto, vlan_tx_tag_get(skb));
390
391
392
393
394
						if (unlikely(!skb))
							break;
						skb->vlan_tci = 0;
					}

395
					status = ops->ndo_start_xmit(skb, dev);
Eric Dumazet's avatar
Eric Dumazet committed
396
397
398
					if (status == NETDEV_TX_OK)
						txq_trans_update(txq);
				}
399
				__netif_tx_unlock(txq);
400
401
402
403
404

				if (status == NETDEV_TX_OK)
					break;

			}
405
406

			/* tickle device maybe there is some cleanup */
407
			netpoll_poll_dev(np->dev);
408
409

			udelay(USEC_PER_POLL);
Matt Mackall's avatar
Matt Mackall committed
410
		}
411
412

		WARN_ONCE(!irqs_disabled(),
413
			"netpoll_send_skb_on_dev(): %s enabled interrupts in poll (%pF)\n",
414
415
			dev->name, ops->ndo_start_xmit);

Linus Torvalds's avatar
Linus Torvalds committed
416
417
	}

Stephen Hemminger's avatar
Stephen Hemminger committed
418
	if (status != NETDEV_TX_OK) {
Stephen Hemminger's avatar
Stephen Hemminger committed
419
		skb_queue_tail(&npinfo->txq, skb);
420
		schedule_delayed_work(&npinfo->tx_work,0);
Linus Torvalds's avatar
Linus Torvalds committed
421
422
	}
}
423
EXPORT_SYMBOL(netpoll_send_skb_on_dev);
Linus Torvalds's avatar
Linus Torvalds committed
424
425
426

void netpoll_send_udp(struct netpoll *np, const char *msg, int len)
{
427
	int total_len, ip_len, udp_len;
Linus Torvalds's avatar
Linus Torvalds committed
428
429
430
431
	struct sk_buff *skb;
	struct udphdr *udph;
	struct iphdr *iph;
	struct ethhdr *eth;
432
	static atomic_t ip_ident;
Cong Wang's avatar
Cong Wang committed
433
	struct ipv6hdr *ip6h;
Linus Torvalds's avatar
Linus Torvalds committed
434
435

	udp_len = len + sizeof(*udph);
Cong Wang's avatar
Cong Wang committed
436
437
438
	if (np->ipv6)
		ip_len = udp_len + sizeof(*ip6h);
	else
Cong Wang's avatar
Cong Wang committed
439
440
		ip_len = udp_len + sizeof(*iph);

441
	total_len = ip_len + LL_RESERVED_SPACE(np->dev);
Linus Torvalds's avatar
Linus Torvalds committed
442

443
444
	skb = find_skb(np, total_len + np->dev->needed_tailroom,
		       total_len - len);
Linus Torvalds's avatar
Linus Torvalds committed
445
446
447
	if (!skb)
		return;

448
	skb_copy_to_linear_data(skb, msg, len);
449
	skb_put(skb, len);
Linus Torvalds's avatar
Linus Torvalds committed
450

451
452
453
	skb_push(skb, sizeof(*udph));
	skb_reset_transport_header(skb);
	udph = udp_hdr(skb);
Linus Torvalds's avatar
Linus Torvalds committed
454
455
456
	udph->source = htons(np->local_port);
	udph->dest = htons(np->remote_port);
	udph->len = htons(udp_len);
Cong Wang's avatar
Cong Wang committed
457

Cong Wang's avatar
Cong Wang committed
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
	if (np->ipv6) {
		udph->check = 0;
		udph->check = csum_ipv6_magic(&np->local_ip.in6,
					      &np->remote_ip.in6,
					      udp_len, IPPROTO_UDP,
					      csum_partial(udph, udp_len, 0));
		if (udph->check == 0)
			udph->check = CSUM_MANGLED_0;

		skb_push(skb, sizeof(*ip6h));
		skb_reset_network_header(skb);
		ip6h = ipv6_hdr(skb);

		/* ip6h->version = 6; ip6h->priority = 0; */
		put_unaligned(0x60, (unsigned char *)ip6h);
		ip6h->flow_lbl[0] = 0;
		ip6h->flow_lbl[1] = 0;
		ip6h->flow_lbl[2] = 0;

		ip6h->payload_len = htons(sizeof(struct udphdr) + len);
		ip6h->nexthdr = IPPROTO_UDP;
		ip6h->hop_limit = 32;
		ip6h->saddr = np->local_ip.in6;
		ip6h->daddr = np->remote_ip.in6;

		eth = (struct ethhdr *) skb_push(skb, ETH_HLEN);
		skb_reset_mac_header(skb);
		skb->protocol = eth->h_proto = htons(ETH_P_IPV6);
	} else {
Cong Wang's avatar
Cong Wang committed
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
		udph->check = 0;
		udph->check = csum_tcpudp_magic(np->local_ip.ip,
						np->remote_ip.ip,
						udp_len, IPPROTO_UDP,
						csum_partial(udph, udp_len, 0));
		if (udph->check == 0)
			udph->check = CSUM_MANGLED_0;

		skb_push(skb, sizeof(*iph));
		skb_reset_network_header(skb);
		iph = ip_hdr(skb);

		/* iph->version = 4; iph->ihl = 5; */
		put_unaligned(0x45, (unsigned char *)iph);
		iph->tos      = 0;
		put_unaligned(htons(ip_len), &(iph->tot_len));
		iph->id       = htons(atomic_inc_return(&ip_ident));
		iph->frag_off = 0;
		iph->ttl      = 64;
		iph->protocol = IPPROTO_UDP;
		iph->check    = 0;
		put_unaligned(np->local_ip.ip, &(iph->saddr));
		put_unaligned(np->remote_ip.ip, &(iph->daddr));
		iph->check    = ip_fast_csum((unsigned char *)iph, iph->ihl);

		eth = (struct ethhdr *) skb_push(skb, ETH_HLEN);
		skb_reset_mac_header(skb);
		skb->protocol = eth->h_proto = htons(ETH_P_IP);
	}

517
518
	memcpy(eth->h_source, np->dev->dev_addr, ETH_ALEN);
	memcpy(eth->h_dest, np->remote_mac, ETH_ALEN);
Linus Torvalds's avatar
Linus Torvalds committed
519
520
521
522
523

	skb->dev = np->dev;

	netpoll_send_skb(np, skb);
}
524
EXPORT_SYMBOL(netpoll_send_udp);
Linus Torvalds's avatar
Linus Torvalds committed
525

Cong Wang's avatar
Cong Wang committed
526
static void netpoll_neigh_reply(struct sk_buff *skb, struct netpoll_info *npinfo)
Linus Torvalds's avatar
Linus Torvalds committed
527
{
Cong Wang's avatar
Cong Wang committed
528
	int size, type = ARPOP_REPLY;
Al Viro's avatar
Al Viro committed
529
	__be32 sip, tip;
530
	unsigned char *sha;
Linus Torvalds's avatar
Linus Torvalds committed
531
	struct sk_buff *send_skb;
532
533
	struct netpoll *np, *tmp;
	unsigned long flags;
534
	int hlen, tlen;
Cong Wang's avatar
Cong Wang committed
535
	int hits = 0, proto;
536
537
538
539
540
541
542
543
544
545
546
547

	if (list_empty(&npinfo->rx_np))
		return;

	/* Before checking the packet, we do some early
	   inspection whether this is interesting at all */
	spin_lock_irqsave(&npinfo->rx_lock, flags);
	list_for_each_entry_safe(np, tmp, &npinfo->rx_np, rx) {
		if (np->dev == skb->dev)
			hits++;
	}
	spin_unlock_irqrestore(&npinfo->rx_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
548

549
550
	/* No netpoll struct is using this dev */
	if (!hits)
551
		return;
Linus Torvalds's avatar
Linus Torvalds committed
552

Cong Wang's avatar
Cong Wang committed
553
554
	proto = ntohs(eth_hdr(skb)->h_proto);
	if (proto == ETH_P_IP) {
Cong Wang's avatar
Cong Wang committed
555
556
		struct arphdr *arp;
		unsigned char *arp_ptr;
Cong Wang's avatar
Cong Wang committed
557
558
559
		/* No arp on this interface */
		if (skb->dev->flags & IFF_NOARP)
			return;
Linus Torvalds's avatar
Linus Torvalds committed
560

Cong Wang's avatar
Cong Wang committed
561
562
		if (!pskb_may_pull(skb, arp_hdr_len(skb->dev)))
			return;
Linus Torvalds's avatar
Linus Torvalds committed
563

Cong Wang's avatar
Cong Wang committed
564
565
566
		skb_reset_network_header(skb);
		skb_reset_transport_header(skb);
		arp = arp_hdr(skb);
Linus Torvalds's avatar
Linus Torvalds committed
567

Cong Wang's avatar
Cong Wang committed
568
569
570
571
572
		if ((arp->ar_hrd != htons(ARPHRD_ETHER) &&
		     arp->ar_hrd != htons(ARPHRD_IEEE802)) ||
		    arp->ar_pro != htons(ETH_P_IP) ||
		    arp->ar_op != htons(ARPOP_REQUEST))
			return;
Linus Torvalds's avatar
Linus Torvalds committed
573

Cong Wang's avatar
Cong Wang committed
574
575
576
577
578
579
580
581
582
583
		arp_ptr = (unsigned char *)(arp+1);
		/* save the location of the src hw addr */
		sha = arp_ptr;
		arp_ptr += skb->dev->addr_len;
		memcpy(&sip, arp_ptr, 4);
		arp_ptr += 4;
		/* If we actually cared about dst hw addr,
		   it would get copied here */
		arp_ptr += skb->dev->addr_len;
		memcpy(&tip, arp_ptr, 4);
Linus Torvalds's avatar
Linus Torvalds committed
584

Cong Wang's avatar
Cong Wang committed
585
586
587
		/* Should we ignore arp? */
		if (ipv4_is_loopback(tip) || ipv4_is_multicast(tip))
			return;
Linus Torvalds's avatar
Linus Torvalds committed
588

Cong Wang's avatar
Cong Wang committed
589
		size = arp_hdr_len(skb->dev);
Linus Torvalds's avatar
Linus Torvalds committed
590

Cong Wang's avatar
Cong Wang committed
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
		spin_lock_irqsave(&npinfo->rx_lock, flags);
		list_for_each_entry_safe(np, tmp, &npinfo->rx_np, rx) {
			if (tip != np->local_ip.ip)
				continue;

			hlen = LL_RESERVED_SPACE(np->dev);
			tlen = np->dev->needed_tailroom;
			send_skb = find_skb(np, size + hlen + tlen, hlen);
			if (!send_skb)
				continue;

			skb_reset_network_header(send_skb);
			arp = (struct arphdr *) skb_put(send_skb, size);
			send_skb->dev = skb->dev;
			send_skb->protocol = htons(ETH_P_ARP);

			/* Fill the device header for the ARP frame */
Cong Wang's avatar
Cong Wang committed
608
			if (dev_hard_header(send_skb, skb->dev, ETH_P_ARP,
Cong Wang's avatar
Cong Wang committed
609
610
611
612
613
					    sha, np->dev->dev_addr,
					    send_skb->len) < 0) {
				kfree_skb(send_skb);
				continue;
			}
Linus Torvalds's avatar
Linus Torvalds committed
614

Cong Wang's avatar
Cong Wang committed
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
			/*
			 * Fill out the arp protocol part.
			 *
			 * we only support ethernet device type,
			 * which (according to RFC 1390) should
			 * always equal 1 (Ethernet).
			 */

			arp->ar_hrd = htons(np->dev->type);
			arp->ar_pro = htons(ETH_P_IP);
			arp->ar_hln = np->dev->addr_len;
			arp->ar_pln = 4;
			arp->ar_op = htons(type);

			arp_ptr = (unsigned char *)(arp + 1);
			memcpy(arp_ptr, np->dev->dev_addr, np->dev->addr_len);
			arp_ptr += np->dev->addr_len;
			memcpy(arp_ptr, &tip, 4);
			arp_ptr += 4;
			memcpy(arp_ptr, sha, np->dev->addr_len);
			arp_ptr += np->dev->addr_len;
			memcpy(arp_ptr, &sip, 4);

			netpoll_send_skb(np, send_skb);

			/* If there are several rx_hooks for the same address,
			   we're fine by sending a single reply */
			break;
643
		}
Cong Wang's avatar
Cong Wang committed
644
		spin_unlock_irqrestore(&npinfo->rx_lock, flags);
Cong Wang's avatar
Cong Wang committed
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
	} else if( proto == ETH_P_IPV6) {
#if IS_ENABLED(CONFIG_IPV6)
		struct nd_msg *msg;
		u8 *lladdr = NULL;
		struct ipv6hdr *hdr;
		struct icmp6hdr *icmp6h;
		const struct in6_addr *saddr;
		const struct in6_addr *daddr;
		struct inet6_dev *in6_dev = NULL;
		struct in6_addr *target;

		in6_dev = in6_dev_get(skb->dev);
		if (!in6_dev || !in6_dev->cnf.accept_ra)
			return;

		if (!pskb_may_pull(skb, skb->len))
			return;

		msg = (struct nd_msg *)skb_transport_header(skb);

		__skb_push(skb, skb->data - skb_transport_header(skb));

		if (ipv6_hdr(skb)->hop_limit != 255)
			return;
		if (msg->icmph.icmp6_code != 0)
			return;
		if (msg->icmph.icmp6_type != NDISC_NEIGHBOUR_SOLICITATION)
			return;

		saddr = &ipv6_hdr(skb)->saddr;
		daddr = &ipv6_hdr(skb)->daddr;

		size = sizeof(struct icmp6hdr) + sizeof(struct in6_addr);

		spin_lock_irqsave(&npinfo->rx_lock, flags);
		list_for_each_entry_safe(np, tmp, &npinfo->rx_np, rx) {
681
			if (!ipv6_addr_equal(daddr, &np->local_ip.in6))
Cong Wang's avatar
Cong Wang committed
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
				continue;

			hlen = LL_RESERVED_SPACE(np->dev);
			tlen = np->dev->needed_tailroom;
			send_skb = find_skb(np, size + hlen + tlen, hlen);
			if (!send_skb)
				continue;

			send_skb->protocol = htons(ETH_P_IPV6);
			send_skb->dev = skb->dev;

			skb_reset_network_header(send_skb);
			skb_put(send_skb, sizeof(struct ipv6hdr));
			hdr = ipv6_hdr(send_skb);

			*(__be32*)hdr = htonl(0x60000000);

			hdr->payload_len = htons(size);
			hdr->nexthdr = IPPROTO_ICMPV6;
			hdr->hop_limit = 255;
			hdr->saddr = *saddr;
			hdr->daddr = *daddr;

			send_skb->transport_header = send_skb->tail;
			skb_put(send_skb, size);

			icmp6h = (struct icmp6hdr *)skb_transport_header(skb);
			icmp6h->icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT;
			icmp6h->icmp6_router = 0;
			icmp6h->icmp6_solicited = 1;
712
			target = (struct in6_addr *)(skb_transport_header(send_skb) + sizeof(struct icmp6hdr));
Cong Wang's avatar
Cong Wang committed
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
			*target = msg->target;
			icmp6h->icmp6_cksum = csum_ipv6_magic(saddr, daddr, size,
							      IPPROTO_ICMPV6,
							      csum_partial(icmp6h,
									   size, 0));

			if (dev_hard_header(send_skb, skb->dev, ETH_P_IPV6,
					    lladdr, np->dev->dev_addr,
					    send_skb->len) < 0) {
				kfree_skb(send_skb);
				continue;
			}

			netpoll_send_skb(np, send_skb);

			/* If there are several rx_hooks for the same address,
			   we're fine by sending a single reply */
			break;
		}
		spin_unlock_irqrestore(&npinfo->rx_lock, flags);
#endif
734
	}
Linus Torvalds's avatar
Linus Torvalds committed
735
736
}

Cong Wang's avatar
Cong Wang committed
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
static bool pkt_is_ns(struct sk_buff *skb)
{
	struct nd_msg *msg;
	struct ipv6hdr *hdr;

	if (skb->protocol != htons(ETH_P_ARP))
		return false;
	if (!pskb_may_pull(skb, sizeof(struct ipv6hdr) + sizeof(struct nd_msg)))
		return false;

	msg = (struct nd_msg *)skb_transport_header(skb);
	__skb_push(skb, skb->data - skb_transport_header(skb));
	hdr = ipv6_hdr(skb);

	if (hdr->nexthdr != IPPROTO_ICMPV6)
		return false;
	if (hdr->hop_limit != 255)
		return false;
	if (msg->icmph.icmp6_code != 0)
		return false;
	if (msg->icmph.icmp6_type != NDISC_NEIGHBOUR_SOLICITATION)
		return false;

	return true;
}

763
int __netpoll_rx(struct sk_buff *skb, struct netpoll_info *npinfo)
Linus Torvalds's avatar
Linus Torvalds committed
764
765
{
	int proto, len, ulen;
766
	int hits = 0;
767
	const struct iphdr *iph;
Linus Torvalds's avatar
Linus Torvalds committed
768
	struct udphdr *uh;
769
	struct netpoll *np, *tmp;
770

771
	if (list_empty(&npinfo->rx_np))
Linus Torvalds's avatar
Linus Torvalds committed
772
		goto out;
773

Linus Torvalds's avatar
Linus Torvalds committed
774
775
776
	if (skb->dev->type != ARPHRD_ETHER)
		goto out;

777
	/* check if netpoll clients need ARP */
Cong Wang's avatar
Cong Wang committed
778
779
780
781
	if (skb->protocol == htons(ETH_P_ARP) && atomic_read(&trapped)) {
		skb_queue_tail(&npinfo->neigh_tx, skb);
		return 1;
	} else if (pkt_is_ns(skb) && atomic_read(&trapped)) {
Cong Wang's avatar
Cong Wang committed
782
		skb_queue_tail(&npinfo->neigh_tx, skb);
Linus Torvalds's avatar
Linus Torvalds committed
783
784
785
		return 1;
	}

786
787
788
789
790
791
	if (skb->protocol == cpu_to_be16(ETH_P_8021Q)) {
		skb = vlan_untag(skb);
		if (unlikely(!skb))
			goto out;
	}

Linus Torvalds's avatar
Linus Torvalds committed
792
	proto = ntohs(eth_hdr(skb)->h_proto);
Cong Wang's avatar
Cong Wang committed
793
	if (proto != ETH_P_IP && proto != ETH_P_IPV6)
Linus Torvalds's avatar
Linus Torvalds committed
794
795
796
797
798
799
		goto out;
	if (skb->pkt_type == PACKET_OTHERHOST)
		goto out;
	if (skb_shared(skb))
		goto out;

Cong Wang's avatar
Cong Wang committed
800
801
802
803
804
805
806
807
808
809
810
	if (proto == ETH_P_IP) {
		if (!pskb_may_pull(skb, sizeof(struct iphdr)))
			goto out;
		iph = (struct iphdr *)skb->data;
		if (iph->ihl < 5 || iph->version != 4)
			goto out;
		if (!pskb_may_pull(skb, iph->ihl*4))
			goto out;
		iph = (struct iphdr *)skb->data;
		if (ip_fast_csum((u8 *)iph, iph->ihl) != 0)
			goto out;
811

Cong Wang's avatar
Cong Wang committed
812
813
814
		len = ntohs(iph->tot_len);
		if (skb->len < len || len < iph->ihl*4)
			goto out;
Linus Torvalds's avatar
Linus Torvalds committed
815

Cong Wang's avatar
Cong Wang committed
816
817
818
819
820
821
		/*
		 * Our transport medium may have padded the buffer out.
		 * Now We trim to the true length of the frame.
		 */
		if (pskb_trim_rcsum(skb, len))
			goto out;
Linus Torvalds's avatar
Linus Torvalds committed
822

Cong Wang's avatar
Cong Wang committed
823
824
825
		iph = (struct iphdr *)skb->data;
		if (iph->protocol != IPPROTO_UDP)
			goto out;
Linus Torvalds's avatar
Linus Torvalds committed
826

Cong Wang's avatar
Cong Wang committed
827
828
829
		len -= iph->ihl*4;
		uh = (struct udphdr *)(((char *)iph) + iph->ihl*4);
		ulen = ntohs(uh->len);
830

Cong Wang's avatar
Cong Wang committed
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
		if (ulen != len)
			goto out;
		if (checksum_udp(skb, uh, ulen, iph->saddr, iph->daddr))
			goto out;
		list_for_each_entry_safe(np, tmp, &npinfo->rx_np, rx) {
			if (np->local_ip.ip && np->local_ip.ip != iph->daddr)
				continue;
			if (np->remote_ip.ip && np->remote_ip.ip != iph->saddr)
				continue;
			if (np->local_port && np->local_port != ntohs(uh->dest))
				continue;

			np->rx_hook(np, ntohs(uh->source),
				       (char *)(uh+1),
				       ulen - sizeof(struct udphdr));
			hits++;
		}
Cong Wang's avatar
Cong Wang committed
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
	} else {
#if IS_ENABLED(CONFIG_IPV6)
		const struct ipv6hdr *ip6h;

		if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
			goto out;
		ip6h = (struct ipv6hdr *)skb->data;
		if (ip6h->version != 6)
			goto out;
		len = ntohs(ip6h->payload_len);
		if (!len)
			goto out;
		if (len + sizeof(struct ipv6hdr) > skb->len)
			goto out;
		if (pskb_trim_rcsum(skb, len + sizeof(struct ipv6hdr)))
			goto out;
		ip6h = ipv6_hdr(skb);
		if (!pskb_may_pull(skb, sizeof(struct udphdr)))
			goto out;
		uh = udp_hdr(skb);
		ulen = ntohs(uh->len);
		if (ulen != skb->len)
			goto out;
		if (udp6_csum_init(skb, uh, IPPROTO_UDP))
			goto out;
		list_for_each_entry_safe(np, tmp, &npinfo->rx_np, rx) {
874
			if (!ipv6_addr_equal(&np->local_ip.in6, &ip6h->daddr))
Cong Wang's avatar
Cong Wang committed
875
				continue;
876
			if (!ipv6_addr_equal(&np->remote_ip.in6, &ip6h->saddr))
Cong Wang's avatar
Cong Wang committed
877
878
879
880
881
882
883
884
885
886
				continue;
			if (np->local_port && np->local_port != ntohs(uh->dest))
				continue;

			np->rx_hook(np, ntohs(uh->source),
				       (char *)(uh+1),
				       ulen - sizeof(struct udphdr));
			hits++;
		}
#endif
887
888
889
890
	}

	if (!hits)
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
891
892
893
894
895
896
897
898
899
900
901
902
903

	kfree_skb(skb);
	return 1;

out:
	if (atomic_read(&trapped)) {
		kfree_skb(skb);
		return 1;
	}

	return 0;
}

904
905
void netpoll_print_options(struct netpoll *np)
{
906
	np_info(np, "local port %d\n", np->local_port);
Cong Wang's avatar
Cong Wang committed
907
908
909
	if (np->ipv6)
		np_info(np, "local IPv6 address %pI6c\n", &np->local_ip.in6);
	else
Cong Wang's avatar
Cong Wang committed
910
		np_info(np, "local IPv4 address %pI4\n", &np->local_ip.ip);
911
912
	np_info(np, "interface '%s'\n", np->dev_name);
	np_info(np, "remote port %d\n", np->remote_port);
Cong Wang's avatar
Cong Wang committed
913
914
915
	if (np->ipv6)
		np_info(np, "remote IPv6 address %pI6c\n", &np->remote_ip.in6);
	else
Cong Wang's avatar
Cong Wang committed
916
		np_info(np, "remote IPv4 address %pI4\n", &np->remote_ip.ip);
917
	np_info(np, "remote ethernet address %pM\n", np->remote_mac);
918
}
919
EXPORT_SYMBOL(netpoll_print_options);
920

Cong Wang's avatar
Cong Wang committed
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
static int netpoll_parse_ip_addr(const char *str, union inet_addr *addr)
{
	const char *end;

	if (!strchr(str, ':') &&
	    in4_pton(str, -1, (void *)addr, -1, &end) > 0) {
		if (!*end)
			return 0;
	}
	if (in6_pton(str, -1, addr->in6.s6_addr, -1, &end) > 0) {
#if IS_ENABLED(CONFIG_IPV6)
		if (!*end)
			return 1;
#else
		return -1;
#endif
	}
	return -1;
}

Linus Torvalds's avatar
Linus Torvalds committed
941
942
943
int netpoll_parse_options(struct netpoll *np, char *opt)
{
	char *cur=opt, *delim;
Cong Wang's avatar
Cong Wang committed
944
	int ipv6;
Linus Torvalds's avatar
Linus Torvalds committed
945

946
	if (*cur != '@') {
Linus Torvalds's avatar
Linus Torvalds committed
947
948
		if ((delim = strchr(cur, '@')) == NULL)
			goto parse_failed;
949
		*delim = 0;
950
951
		if (kstrtou16(cur, 10, &np->local_port))
			goto parse_failed;
952
		cur = delim;
Linus Torvalds's avatar
Linus Torvalds committed
953
954
955
	}
	cur++;

956
	if (*cur != '/') {
Linus Torvalds's avatar
Linus Torvalds committed
957
958
		if ((delim = strchr(cur, '/')) == NULL)
			goto parse_failed;
959
		*delim = 0;
Cong Wang's avatar
Cong Wang committed
960
961
962
963
964
		ipv6 = netpoll_parse_ip_addr(cur, &np->local_ip);
		if (ipv6 < 0)
			goto parse_failed;
		else
			np->ipv6 = (bool)ipv6;
965
		cur = delim;
Linus Torvalds's avatar
Linus Torvalds committed
966
967
968
	}
	cur++;

969
	if (*cur != ',') {
Linus Torvalds's avatar
Linus Torvalds committed
970
971
972
		/* parse out dev name */
		if ((delim = strchr(cur, ',')) == NULL)
			goto parse_failed;
973
		*delim = 0;
Linus Torvalds's avatar
Linus Torvalds committed
974
		strlcpy(np->dev_name, cur, sizeof(np->dev_name));
975
		cur = delim;
Linus Torvalds's avatar
Linus Torvalds committed
976
977
978
	}
	cur++;

979
	if (*cur != '@') {
Linus Torvalds's avatar
Linus Torvalds committed
980
981
982
		/* dst port */
		if ((delim = strchr(cur, '@')) == NULL)
			goto parse_failed;
983
		*delim = 0;
984
		if (*cur == ' ' || *cur == '\t')
985
			np_info(np, "warning: whitespace is not allowed\n");
986
987
		if (kstrtou16(cur, 10, &np->remote_port))
			goto parse_failed;
988
		cur = delim;
Linus Torvalds's avatar
Linus Torvalds committed
989
990
991
992
993
994
	}
	cur++;

	/* dst ip */
	if ((delim = strchr(cur, '/')) == NULL)
		goto parse_failed;
995
	*delim = 0;
Cong Wang's avatar
Cong Wang committed
996
997
998
999
1000
1001
1002
	ipv6 = netpoll_parse_ip_addr(cur, &np->remote_ip);
	if (ipv6 < 0)
		goto parse_failed;
	else if (np->ipv6 != (bool)ipv6)
		goto parse_failed;
	else
		np->ipv6 = (bool)ipv6;
1003
	cur = delim + 1;
Linus Torvalds's avatar
Linus Torvalds committed
1004

1005
	if (*cur != 0) {
Linus Torvalds's avatar
Linus Torvalds committed
1006
		/* MAC address */
1007
		if (!mac_pton(cur, np->remote_mac))
Linus Torvalds's avatar
Linus Torvalds committed
1008
1009
1010
			goto parse_failed;
	}

1011
	netpoll_print_options(np);
Linus Torvalds's avatar
Linus Torvalds committed
1012
1013
1014
1015

	return 0;

 parse_failed:
1016
	np_info(np, "couldn't parse config at '%s'!\n", cur);
Linus Torvalds's avatar
Linus Torvalds committed
1017
1018
	return -1;
}
1019
EXPORT_SYMBOL(netpoll_parse_options);
Linus Torvalds's avatar
Linus Torvalds committed
1020

1021
int __netpoll_setup(struct netpoll *np, struct net_device *ndev, gfp_t gfp)
Linus Torvalds's avatar
Linus Torvalds committed
1022
{
1023
	struct netpoll_info *npinfo;
Herbert Xu's avatar
Herbert Xu committed
1024
	const struct net_device_ops *ops;
1025
	unsigned long flags;
1026
	int err;
Linus Torvalds's avatar
Linus Torvalds committed
1027

1028
1029
	np->dev = ndev;
	strlcpy(np->dev_name, ndev->name, IFNAMSIZ);
1030
	INIT_WORK(&np->cleanup_work, netpoll_async_cleanup);
1031

1032
1033
	if ((ndev->priv_flags & IFF_DISABLE_NETPOLL) ||
	    !ndev->netdev_ops->ndo_poll_controller) {
1034
1035
		np_err(np, "%s doesn't support polling, aborting\n",
		       np->dev_name);
1036
1037
1038
1039
1040
		err = -ENOTSUPP;
		goto out;
	}

	if (!ndev->npinfo) {
1041
		npinfo = kmalloc(sizeof(*npinfo), gfp);
1042
1043
1044
1045
1046
1047
1048
1049
1050
		if (!npinfo) {
			err = -ENOMEM;
			goto out;
		}

		npinfo->rx_flags = 0;
		INIT_LIST_HEAD(&npinfo->rx_np);

		spin_lock_init(&npinfo->rx_lock);
1051
		sema_init(&npinfo->dev_lock, 1);
Cong Wang's avatar
Cong Wang committed
1052
		skb_queue_head_init(&npinfo->neigh_tx);
1053
1054
1055
1056
1057
1058
1059
		skb_queue_head_init(&npinfo->txq);
		INIT_DELAYED_WORK(&npinfo->tx_work, queue_process);

		atomic_set(&npinfo->refcnt, 1);

		ops = np->dev->netdev_ops;
		if (ops->ndo_netpoll_setup) {
1060
			err = ops->ndo_netpoll_setup(ndev, npinfo, gfp);
1061
1062
1063
1064
			if (err)
				goto free_npinfo;
		}
	} else {
Neil Horman's avatar
Neil Horman committed
1065
		npinfo = rtnl_dereference(ndev->npinfo);
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
		atomic_inc(&npinfo->refcnt);
	}

	npinfo->netpoll = np;

	if (np->rx_hook) {
		spin_lock_irqsave(&npinfo->rx_lock, flags);
		npinfo->rx_flags |= NETPOLL_RX_ENABLED;
		list_add_tail(&np->rx, &npinfo->rx_np);
		spin_unlock_irqrestore(&npinfo->rx_lock, flags);
	}

	/* last thing to do is link it to the net device structure */
1079
	rcu_assign_pointer(ndev->npinfo, npinfo);
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095

	return 0;

free_npinfo:
	kfree(npinfo);
out:
	return err;
}
EXPORT_SYMBOL_GPL(__netpoll_setup);

int netpoll_setup(struct netpoll *np)
{
	struct net_device *ndev = NULL;
	struct in_device *in_dev;
	int err;

1096
	rtnl_lock();
1097
1098
1099
1100
	if (np->dev_name) {
		struct net *net = current->nsproxy->net_ns;
		ndev = __dev_get_by_name(net, np->dev_name);
	}
Linus Torvalds's avatar
Linus Torvalds committed
1101
	if (!ndev) {
1102
		np_err(np, "%s doesn't exist, aborting\n", np->dev_name);
1103
1104
		err = -ENODEV;
		goto unlock;
Linus Torvalds's avatar
Linus Torvalds committed
1105
	}
1106
	dev_hold(ndev);
Linus Torvalds's avatar
Linus Torvalds committed
1107

1108
	if (netdev_master_upper_dev_get(ndev)) {
1109
		np_err(np, "%s is a slave device, aborting\n", np->dev_name);
1110
1111
		err = -EBUSY;
		goto put;
1112
1113
	}

Linus Torvalds's avatar
Linus Torvalds committed
1114
1115
1116
	if (!netif_running(ndev)) {
		unsigned long atmost, atleast;

1117
		np_info(np, "device %s not up yet, forcing it\n", np->dev_name);
Linus Torvalds's avatar
Linus Torvalds committed
1118

1119
1120
1121
		err = dev_open(ndev);

		if (err) {
1122
			np_err(np, "failed to open %s\n", ndev->name);
1123
			goto put;
Linus Torvalds's avatar
Linus Torvalds committed
1124
1125
		}

1126
		rtnl_unlock();
Linus Torvalds's avatar
Linus Torvalds committed
1127
		atleast = jiffies + HZ/10;
1128
		atmost = jiffies + carrier_timeout * HZ;
Linus Torvalds's avatar
Linus Torvalds committed
1129
1130
		while (!netif_carrier_ok(ndev)) {
			if (time_after(jiffies, atmost)) {
1131
				np_notice(np, "timeout waiting for carrier\n");
Linus Torvalds's avatar
Linus Torvalds committed
1132
1133
				break;
			}
1134
			msleep(1);
Linus Torvalds's avatar
Linus Torvalds committed
1135
1136
1137
1138
1139
1140
1141
1142
		}

		/* If carrier appears to come up instantly, we don't
		 * trust it and pause so that we don't pump all our
		 * queued console messages into the bitbucket.
		 */

		if (time_before(jiffies, atleast)) {
1143
			np_notice(np, "carrier detect appears untrustworthy, waiting 4 seconds\n");
Linus Torvalds's avatar
Linus Torvalds committed
1144
1145
			msleep(4000);
		}
1146
		rtnl_lock();
Linus Torvalds's avatar
Linus Torvalds committed
1147
1148
	}

Cong Wang's avatar
Cong Wang committed
1149
1150
	if (!np->local_ip.ip) {
		if (!np->ipv6) {
1151
			in_dev = __in_dev_get_rtnl(ndev);
Cong Wang's avatar
Cong Wang committed
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161

			if (!in_dev || !in_dev->ifa_list) {
				np_err(np, "no IP address for %s, aborting\n",
				       np->dev_name);
				err = -EDESTADDRREQ;
				goto put;
			}

			np->local_ip.ip = in_dev->ifa_list->ifa_local;
			np_info(np, "local IP %pI4\n", &np->local_ip.ip);
Cong Wang's avatar
Cong Wang committed
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
		} else {
#if IS_ENABLED(CONFIG_IPV6)
			struct inet6_dev *idev;

			err = -EDESTADDRREQ;
			idev = __in6_dev_get(ndev);
			if (idev) {
				struct inet6_ifaddr *ifp;

				read_lock_bh(&idev->lock);
				list_for_each_entry(ifp, &idev->addr_list, if_list) {
					if (ipv6_addr_type(&ifp->addr) & IPV6_ADDR_LINKLOCAL)
						continue;
					np->local_ip.in6 = ifp->addr;
					err = 0;
					break;
				}
				read_unlock_bh(&idev->lock);
			}
			if (err) {
				np_err(np, "no IPv6 address for %s, aborting\n",
				       np->dev_name);
				goto put;
			} else
				np_info(np, "local IPv6 %pI6c\n", &np->local_ip.in6);
#else
			np_err(np, "IPv6 is not supported %s, aborting\n",
			       np->dev_name);
1190
			err = -EINVAL;
Cong Wang's avatar
Cong Wang committed
1191
1192
			goto put;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
1193
1194
1195
		}
	}

1196
1197
1198
	/* fill up the skb queue */
	refill_skbs();

1199
	err = __netpoll_setup(np, ndev, GFP_KERNEL);