Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : * Common framework for low-level network console, dump, and debugger code
4 : : *
5 : : * Sep 8 2003 Matt Mackall <mpm@selenic.com>
6 : : *
7 : : * based on the netconsole code from:
8 : : *
9 : : * Copyright (C) 2001 Ingo Molnar <mingo@redhat.com>
10 : : * Copyright (C) 2002 Red Hat, Inc.
11 : : */
12 : :
13 : : #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14 : :
15 : : #include <linux/moduleparam.h>
16 : : #include <linux/kernel.h>
17 : : #include <linux/netdevice.h>
18 : : #include <linux/etherdevice.h>
19 : : #include <linux/string.h>
20 : : #include <linux/if_arp.h>
21 : : #include <linux/inetdevice.h>
22 : : #include <linux/inet.h>
23 : : #include <linux/interrupt.h>
24 : : #include <linux/netpoll.h>
25 : : #include <linux/sched.h>
26 : : #include <linux/delay.h>
27 : : #include <linux/rcupdate.h>
28 : : #include <linux/workqueue.h>
29 : : #include <linux/slab.h>
30 : : #include <linux/export.h>
31 : : #include <linux/if_vlan.h>
32 : : #include <net/tcp.h>
33 : : #include <net/udp.h>
34 : : #include <net/addrconf.h>
35 : : #include <net/ndisc.h>
36 : : #include <net/ip6_checksum.h>
37 : : #include <asm/unaligned.h>
38 : : #include <trace/events/napi.h>
39 : :
40 : : /*
41 : : * We maintain a small pool of fully-sized skbs, to make sure the
42 : : * message gets out even in extreme OOM situations.
43 : : */
44 : :
45 : : #define MAX_UDP_CHUNK 1460
46 : : #define MAX_SKBS 32
47 : :
48 : : static struct sk_buff_head skb_pool;
49 : :
50 : : DEFINE_STATIC_SRCU(netpoll_srcu);
51 : :
52 : : #define USEC_PER_POLL 50
53 : :
54 : : #define MAX_SKB_SIZE \
55 : : (sizeof(struct ethhdr) + \
56 : : sizeof(struct iphdr) + \
57 : : sizeof(struct udphdr) + \
58 : : MAX_UDP_CHUNK)
59 : :
60 : : static void zap_completion_queue(void);
61 : :
62 : : static unsigned int carrier_timeout = 4;
63 : : module_param(carrier_timeout, uint, 0644);
64 : :
65 : : #define np_info(np, fmt, ...) \
66 : : pr_info("%s: " fmt, np->name, ##__VA_ARGS__)
67 : : #define np_err(np, fmt, ...) \
68 : : pr_err("%s: " fmt, np->name, ##__VA_ARGS__)
69 : : #define np_notice(np, fmt, ...) \
70 : : pr_notice("%s: " fmt, np->name, ##__VA_ARGS__)
71 : :
72 : 0 : static int netpoll_start_xmit(struct sk_buff *skb, struct net_device *dev,
73 : : struct netdev_queue *txq)
74 : : {
75 : : int status = NETDEV_TX_OK;
76 : : netdev_features_t features;
77 : :
78 : 0 : features = netif_skb_features(skb);
79 : :
80 [ # # # # ]: 0 : if (skb_vlan_tag_present(skb) &&
81 : 0 : !vlan_hw_offload_capable(features, skb->vlan_proto)) {
82 : 0 : skb = __vlan_hwaccel_push_inside(skb);
83 [ # # ]: 0 : if (unlikely(!skb)) {
84 : : /* This is actually a packet drop, but we
85 : : * don't want the code that calls this
86 : : * function to try and operate on a NULL skb.
87 : : */
88 : : goto out;
89 : : }
90 : : }
91 : :
92 : 0 : status = netdev_start_xmit(skb, dev, txq, false);
93 : :
94 : : out:
95 : 0 : return status;
96 : : }
97 : :
98 : 0 : static void queue_process(struct work_struct *work)
99 : : {
100 : : struct netpoll_info *npinfo =
101 : : container_of(work, struct netpoll_info, tx_work.work);
102 : : struct sk_buff *skb;
103 : : unsigned long flags;
104 : :
105 [ # # ]: 0 : while ((skb = skb_dequeue(&npinfo->txq))) {
106 : 0 : struct net_device *dev = skb->dev;
107 : : struct netdev_queue *txq;
108 : : unsigned int q_index;
109 : :
110 [ # # # # ]: 0 : if (!netif_device_present(dev) || !netif_running(dev)) {
111 : 0 : kfree_skb(skb);
112 : 0 : continue;
113 : : }
114 : :
115 : 0 : local_irq_save(flags);
116 : : /* check if skb->queue_mapping is still valid */
117 : 0 : q_index = skb_get_queue_mapping(skb);
118 [ # # ]: 0 : if (unlikely(q_index >= dev->real_num_tx_queues)) {
119 : 0 : q_index = q_index % dev->real_num_tx_queues;
120 : 0 : skb_set_queue_mapping(skb, q_index);
121 : : }
122 : : txq = netdev_get_tx_queue(dev, q_index);
123 [ # # ]: 0 : HARD_TX_LOCK(dev, txq, smp_processor_id());
124 [ # # # # ]: 0 : if (netif_xmit_frozen_or_stopped(txq) ||
125 : 0 : !dev_xmit_complete(netpoll_start_xmit(skb, dev, txq))) {
126 : 0 : skb_queue_head(&npinfo->txq, skb);
127 [ # # ]: 0 : HARD_TX_UNLOCK(dev, txq);
128 [ # # ]: 0 : local_irq_restore(flags);
129 : :
130 : 0 : schedule_delayed_work(&npinfo->tx_work, HZ/10);
131 : 0 : return;
132 : : }
133 [ # # ]: 0 : HARD_TX_UNLOCK(dev, txq);
134 [ # # ]: 0 : local_irq_restore(flags);
135 : : }
136 : : }
137 : :
138 : 0 : static void poll_one_napi(struct napi_struct *napi)
139 : : {
140 : : int work;
141 : :
142 : : /* If we set this bit but see that it has already been set,
143 : : * that indicates that napi has been disabled and we need
144 : : * to abort this operation
145 : : */
146 [ # # ]: 0 : if (test_and_set_bit(NAPI_STATE_NPSVC, &napi->state))
147 : 0 : return;
148 : :
149 : : /* We explicilty pass the polling call a budget of 0 to
150 : : * indicate that we are clearing the Tx path only.
151 : : */
152 : 0 : work = napi->poll(napi, 0);
153 [ # # # # ]: 0 : WARN_ONCE(work, "%pS exceeded budget in poll\n", napi->poll);
154 : 0 : trace_napi_poll(napi, work, 0);
155 : :
156 : 0 : clear_bit(NAPI_STATE_NPSVC, &napi->state);
157 : : }
158 : :
159 : 0 : static void poll_napi(struct net_device *dev)
160 : : {
161 : : struct napi_struct *napi;
162 : 0 : int cpu = smp_processor_id();
163 : :
164 [ # # ]: 0 : list_for_each_entry(napi, &dev->napi_list, dev_list) {
165 [ # # ]: 0 : if (cmpxchg(&napi->poll_owner, -1, cpu) == -1) {
166 : 0 : poll_one_napi(napi);
167 : 0 : smp_store_release(&napi->poll_owner, -1);
168 : : }
169 : : }
170 : 0 : }
171 : :
172 : 0 : void netpoll_poll_dev(struct net_device *dev)
173 : : {
174 : 0 : struct netpoll_info *ni = rcu_dereference_bh(dev->npinfo);
175 : : const struct net_device_ops *ops;
176 : :
177 : : /* Don't do any rx activity if the dev_lock mutex is held
178 : : * the dev_open/close paths use this to block netpoll activity
179 : : * while changing device state
180 : : */
181 [ # # # # ]: 0 : if (!ni || down_trylock(&ni->dev_lock))
182 : : return;
183 : :
184 [ # # ]: 0 : if (!netif_running(dev)) {
185 : 0 : up(&ni->dev_lock);
186 : 0 : return;
187 : : }
188 : :
189 : 0 : ops = dev->netdev_ops;
190 [ # # ]: 0 : if (ops->ndo_poll_controller)
191 : 0 : ops->ndo_poll_controller(dev);
192 : :
193 : 0 : poll_napi(dev);
194 : :
195 : 0 : up(&ni->dev_lock);
196 : :
197 : 0 : zap_completion_queue();
198 : : }
199 : : EXPORT_SYMBOL(netpoll_poll_dev);
200 : :
201 : 414 : void netpoll_poll_disable(struct net_device *dev)
202 : : {
203 : : struct netpoll_info *ni;
204 : : int idx;
205 : 414 : might_sleep();
206 : : idx = srcu_read_lock(&netpoll_srcu);
207 : 414 : ni = srcu_dereference(dev->npinfo, &netpoll_srcu);
208 [ - + ]: 414 : if (ni)
209 : 0 : down(&ni->dev_lock);
210 : 414 : srcu_read_unlock(&netpoll_srcu, idx);
211 : 414 : }
212 : : EXPORT_SYMBOL(netpoll_poll_disable);
213 : :
214 : 414 : void netpoll_poll_enable(struct net_device *dev)
215 : : {
216 : : struct netpoll_info *ni;
217 : : rcu_read_lock();
218 : 414 : ni = rcu_dereference(dev->npinfo);
219 [ - + ]: 414 : if (ni)
220 : 0 : up(&ni->dev_lock);
221 : : rcu_read_unlock();
222 : 414 : }
223 : : EXPORT_SYMBOL(netpoll_poll_enable);
224 : :
225 : 0 : static void refill_skbs(void)
226 : : {
227 : : struct sk_buff *skb;
228 : : unsigned long flags;
229 : :
230 : 0 : spin_lock_irqsave(&skb_pool.lock, flags);
231 [ # # ]: 0 : while (skb_pool.qlen < MAX_SKBS) {
232 : : skb = alloc_skb(MAX_SKB_SIZE, GFP_ATOMIC);
233 [ # # ]: 0 : if (!skb)
234 : : break;
235 : :
236 : : __skb_queue_tail(&skb_pool, skb);
237 : : }
238 : : spin_unlock_irqrestore(&skb_pool.lock, flags);
239 : 0 : }
240 : :
241 : 0 : static void zap_completion_queue(void)
242 : : {
243 : : unsigned long flags;
244 : 0 : struct softnet_data *sd = &get_cpu_var(softnet_data);
245 : :
246 [ # # ]: 0 : if (sd->completion_queue) {
247 : : struct sk_buff *clist;
248 : :
249 : 0 : local_irq_save(flags);
250 : 0 : clist = sd->completion_queue;
251 : 0 : sd->completion_queue = NULL;
252 [ # # ]: 0 : local_irq_restore(flags);
253 : :
254 [ # # ]: 0 : while (clist != NULL) {
255 : : struct sk_buff *skb = clist;
256 : 0 : clist = clist->next;
257 [ # # ]: 0 : if (!skb_irq_freeable(skb)) {
258 : : refcount_set(&skb->users, 1);
259 : : dev_kfree_skb_any(skb); /* put this one back */
260 : : } else {
261 : 0 : __kfree_skb(skb);
262 : : }
263 : : }
264 : : }
265 : :
266 : 0 : put_cpu_var(softnet_data);
267 : 0 : }
268 : :
269 : 0 : static struct sk_buff *find_skb(struct netpoll *np, int len, int reserve)
270 : : {
271 : : int count = 0;
272 : : struct sk_buff *skb;
273 : :
274 : 0 : zap_completion_queue();
275 : 0 : refill_skbs();
276 : : repeat:
277 : :
278 : 0 : skb = alloc_skb(len, GFP_ATOMIC);
279 [ # # ]: 0 : if (!skb)
280 : 0 : skb = skb_dequeue(&skb_pool);
281 : :
282 [ # # ]: 0 : if (!skb) {
283 [ # # ]: 0 : if (++count < 10) {
284 : 0 : netpoll_poll_dev(np->dev);
285 : 0 : goto repeat;
286 : : }
287 : : return NULL;
288 : : }
289 : :
290 : : refcount_set(&skb->users, 1);
291 : : skb_reserve(skb, reserve);
292 : 0 : return skb;
293 : : }
294 : :
295 : : static int netpoll_owner_active(struct net_device *dev)
296 : : {
297 : : struct napi_struct *napi;
298 : :
299 [ # # ]: 0 : list_for_each_entry(napi, &dev->napi_list, dev_list) {
300 [ # # ]: 0 : if (napi->poll_owner == smp_processor_id())
301 : : return 1;
302 : : }
303 : : return 0;
304 : : }
305 : :
306 : : /* call with IRQ disabled */
307 : 0 : void netpoll_send_skb_on_dev(struct netpoll *np, struct sk_buff *skb,
308 : : struct net_device *dev)
309 : : {
310 : : int status = NETDEV_TX_BUSY;
311 : : unsigned long tries;
312 : : /* It is up to the caller to keep npinfo alive. */
313 : : struct netpoll_info *npinfo;
314 : :
315 : : lockdep_assert_irqs_disabled();
316 : :
317 : 0 : npinfo = rcu_dereference_bh(np->dev->npinfo);
318 [ # # # # : 0 : if (!npinfo || !netif_running(dev) || !netif_device_present(dev)) {
# # ]
319 : : dev_kfree_skb_irq(skb);
320 : 0 : return;
321 : : }
322 : :
323 : : /* don't get messages out of order, and no recursion */
324 [ # # # # ]: 0 : if (skb_queue_len(&npinfo->txq) == 0 && !netpoll_owner_active(dev)) {
325 : : struct netdev_queue *txq;
326 : :
327 : 0 : txq = netdev_core_pick_tx(dev, skb, NULL);
328 : :
329 : : /* try until next clock tick */
330 [ # # ]: 0 : for (tries = jiffies_to_usecs(1)/USEC_PER_POLL;
331 : 0 : tries > 0; --tries) {
332 [ # # # # ]: 0 : if (HARD_TX_TRYLOCK(dev, txq)) {
333 [ # # ]: 0 : if (!netif_xmit_stopped(txq))
334 : 0 : status = netpoll_start_xmit(skb, dev, txq);
335 : :
336 [ # # ]: 0 : HARD_TX_UNLOCK(dev, txq);
337 : :
338 [ # # ]: 0 : if (dev_xmit_complete(status))
339 : : break;
340 : :
341 : : }
342 : :
343 : : /* tickle device maybe there is some cleanup */
344 : 0 : netpoll_poll_dev(np->dev);
345 : :
346 : 0 : udelay(USEC_PER_POLL);
347 : : }
348 : :
349 [ # # # # ]: 0 : WARN_ONCE(!irqs_disabled(),
350 : : "netpoll_send_skb_on_dev(): %s enabled interrupts in poll (%pS)\n",
351 : : dev->name, dev->netdev_ops->ndo_start_xmit);
352 : :
353 : : }
354 : :
355 [ # # ]: 0 : if (!dev_xmit_complete(status)) {
356 : 0 : skb_queue_tail(&npinfo->txq, skb);
357 : 0 : schedule_delayed_work(&npinfo->tx_work,0);
358 : : }
359 : : }
360 : : EXPORT_SYMBOL(netpoll_send_skb_on_dev);
361 : :
362 : 0 : void netpoll_send_udp(struct netpoll *np, const char *msg, int len)
363 : : {
364 : : int total_len, ip_len, udp_len;
365 : : struct sk_buff *skb;
366 : : struct udphdr *udph;
367 : : struct iphdr *iph;
368 : : struct ethhdr *eth;
369 : : static atomic_t ip_ident;
370 : : struct ipv6hdr *ip6h;
371 : :
372 [ # # # # ]: 0 : WARN_ON_ONCE(!irqs_disabled());
373 : :
374 : 0 : udp_len = len + sizeof(*udph);
375 [ # # ]: 0 : if (np->ipv6)
376 : 0 : ip_len = udp_len + sizeof(*ip6h);
377 : : else
378 : 0 : ip_len = udp_len + sizeof(*iph);
379 : :
380 : 0 : total_len = ip_len + LL_RESERVED_SPACE(np->dev);
381 : :
382 : 0 : skb = find_skb(np, total_len + np->dev->needed_tailroom,
383 : : total_len - len);
384 [ # # ]: 0 : if (!skb)
385 : 0 : return;
386 : :
387 : : skb_copy_to_linear_data(skb, msg, len);
388 : 0 : skb_put(skb, len);
389 : :
390 : 0 : skb_push(skb, sizeof(*udph));
391 : : skb_reset_transport_header(skb);
392 : : udph = udp_hdr(skb);
393 : 0 : udph->source = htons(np->local_port);
394 : 0 : udph->dest = htons(np->remote_port);
395 : 0 : udph->len = htons(udp_len);
396 : :
397 [ # # ]: 0 : if (np->ipv6) {
398 : 0 : udph->check = 0;
399 : 0 : udph->check = csum_ipv6_magic(&np->local_ip.in6,
400 : 0 : &np->remote_ip.in6,
401 : : udp_len, IPPROTO_UDP,
402 : : csum_partial(udph, udp_len, 0));
403 [ # # ]: 0 : if (udph->check == 0)
404 : 0 : udph->check = CSUM_MANGLED_0;
405 : :
406 : 0 : skb_push(skb, sizeof(*ip6h));
407 : : skb_reset_network_header(skb);
408 : : ip6h = ipv6_hdr(skb);
409 : :
410 : : /* ip6h->version = 6; ip6h->priority = 0; */
411 : 0 : put_unaligned(0x60, (unsigned char *)ip6h);
412 : 0 : ip6h->flow_lbl[0] = 0;
413 : 0 : ip6h->flow_lbl[1] = 0;
414 : 0 : ip6h->flow_lbl[2] = 0;
415 : :
416 : 0 : ip6h->payload_len = htons(sizeof(struct udphdr) + len);
417 : 0 : ip6h->nexthdr = IPPROTO_UDP;
418 : 0 : ip6h->hop_limit = 32;
419 : 0 : ip6h->saddr = np->local_ip.in6;
420 : 0 : ip6h->daddr = np->remote_ip.in6;
421 : :
422 : 0 : eth = skb_push(skb, ETH_HLEN);
423 : : skb_reset_mac_header(skb);
424 : 0 : skb->protocol = eth->h_proto = htons(ETH_P_IPV6);
425 : : } else {
426 : 0 : udph->check = 0;
427 : 0 : udph->check = csum_tcpudp_magic(np->local_ip.ip,
428 : : np->remote_ip.ip,
429 : : udp_len, IPPROTO_UDP,
430 : : csum_partial(udph, udp_len, 0));
431 [ # # ]: 0 : if (udph->check == 0)
432 : 0 : udph->check = CSUM_MANGLED_0;
433 : :
434 : 0 : skb_push(skb, sizeof(*iph));
435 : : skb_reset_network_header(skb);
436 : : iph = ip_hdr(skb);
437 : :
438 : : /* iph->version = 4; iph->ihl = 5; */
439 : 0 : put_unaligned(0x45, (unsigned char *)iph);
440 : 0 : iph->tos = 0;
441 : 0 : put_unaligned(htons(ip_len), &(iph->tot_len));
442 : 0 : iph->id = htons(atomic_inc_return(&ip_ident));
443 : 0 : iph->frag_off = 0;
444 : 0 : iph->ttl = 64;
445 : 0 : iph->protocol = IPPROTO_UDP;
446 : 0 : iph->check = 0;
447 : 0 : put_unaligned(np->local_ip.ip, &(iph->saddr));
448 : 0 : put_unaligned(np->remote_ip.ip, &(iph->daddr));
449 : 0 : iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl);
450 : :
451 : 0 : eth = skb_push(skb, ETH_HLEN);
452 : : skb_reset_mac_header(skb);
453 : 0 : skb->protocol = eth->h_proto = htons(ETH_P_IP);
454 : : }
455 : :
456 : 0 : ether_addr_copy(eth->h_source, np->dev->dev_addr);
457 : : ether_addr_copy(eth->h_dest, np->remote_mac);
458 : :
459 : 0 : skb->dev = np->dev;
460 : :
461 : 0 : netpoll_send_skb(np, skb);
462 : : }
463 : : EXPORT_SYMBOL(netpoll_send_udp);
464 : :
465 : 0 : void netpoll_print_options(struct netpoll *np)
466 : : {
467 : 0 : np_info(np, "local port %d\n", np->local_port);
468 [ # # ]: 0 : if (np->ipv6)
469 : 0 : np_info(np, "local IPv6 address %pI6c\n", &np->local_ip.in6);
470 : : else
471 : 0 : np_info(np, "local IPv4 address %pI4\n", &np->local_ip.ip);
472 : 0 : np_info(np, "interface '%s'\n", np->dev_name);
473 : 0 : np_info(np, "remote port %d\n", np->remote_port);
474 [ # # ]: 0 : if (np->ipv6)
475 : 0 : np_info(np, "remote IPv6 address %pI6c\n", &np->remote_ip.in6);
476 : : else
477 : 0 : np_info(np, "remote IPv4 address %pI4\n", &np->remote_ip.ip);
478 : 0 : np_info(np, "remote ethernet address %pM\n", np->remote_mac);
479 : 0 : }
480 : : EXPORT_SYMBOL(netpoll_print_options);
481 : :
482 : 0 : static int netpoll_parse_ip_addr(const char *str, union inet_addr *addr)
483 : : {
484 : : const char *end;
485 : :
486 [ # # # # ]: 0 : if (!strchr(str, ':') &&
487 : 0 : in4_pton(str, -1, (void *)addr, -1, &end) > 0) {
488 [ # # ]: 0 : if (!*end)
489 : : return 0;
490 : : }
491 [ # # ]: 0 : if (in6_pton(str, -1, addr->in6.s6_addr, -1, &end) > 0) {
492 : : #if IS_ENABLED(CONFIG_IPV6)
493 [ # # ]: 0 : if (!*end)
494 : : return 1;
495 : : #else
496 : : return -1;
497 : : #endif
498 : : }
499 : 0 : return -1;
500 : : }
501 : :
502 : 0 : int netpoll_parse_options(struct netpoll *np, char *opt)
503 : : {
504 : : char *cur=opt, *delim;
505 : : int ipv6;
506 : : bool ipversion_set = false;
507 : :
508 [ # # ]: 0 : if (*cur != '@') {
509 [ # # ]: 0 : if ((delim = strchr(cur, '@')) == NULL)
510 : : goto parse_failed;
511 : 0 : *delim = 0;
512 [ # # ]: 0 : if (kstrtou16(cur, 10, &np->local_port))
513 : : goto parse_failed;
514 : : cur = delim;
515 : : }
516 : 0 : cur++;
517 : :
518 [ # # ]: 0 : if (*cur != '/') {
519 : : ipversion_set = true;
520 [ # # ]: 0 : if ((delim = strchr(cur, '/')) == NULL)
521 : : goto parse_failed;
522 : 0 : *delim = 0;
523 : 0 : ipv6 = netpoll_parse_ip_addr(cur, &np->local_ip);
524 [ # # ]: 0 : if (ipv6 < 0)
525 : : goto parse_failed;
526 : : else
527 : 0 : np->ipv6 = (bool)ipv6;
528 : : cur = delim;
529 : : }
530 : 0 : cur++;
531 : :
532 [ # # ]: 0 : if (*cur != ',') {
533 : : /* parse out dev name */
534 [ # # ]: 0 : if ((delim = strchr(cur, ',')) == NULL)
535 : : goto parse_failed;
536 : 0 : *delim = 0;
537 : 0 : strlcpy(np->dev_name, cur, sizeof(np->dev_name));
538 : : cur = delim;
539 : : }
540 : 0 : cur++;
541 : :
542 [ # # ]: 0 : if (*cur != '@') {
543 : : /* dst port */
544 [ # # ]: 0 : if ((delim = strchr(cur, '@')) == NULL)
545 : : goto parse_failed;
546 : 0 : *delim = 0;
547 [ # # ]: 0 : if (*cur == ' ' || *cur == '\t')
548 : 0 : np_info(np, "warning: whitespace is not allowed\n");
549 [ # # ]: 0 : if (kstrtou16(cur, 10, &np->remote_port))
550 : : goto parse_failed;
551 : : cur = delim;
552 : : }
553 : 0 : cur++;
554 : :
555 : : /* dst ip */
556 [ # # ]: 0 : if ((delim = strchr(cur, '/')) == NULL)
557 : : goto parse_failed;
558 : 0 : *delim = 0;
559 : 0 : ipv6 = netpoll_parse_ip_addr(cur, &np->remote_ip);
560 [ # # ]: 0 : if (ipv6 < 0)
561 : : goto parse_failed;
562 [ # # # # ]: 0 : else if (ipversion_set && np->ipv6 != (bool)ipv6)
563 : : goto parse_failed;
564 : : else
565 : 0 : np->ipv6 = (bool)ipv6;
566 : 0 : cur = delim + 1;
567 : :
568 [ # # ]: 0 : if (*cur != 0) {
569 : : /* MAC address */
570 [ # # ]: 0 : if (!mac_pton(cur, np->remote_mac))
571 : : goto parse_failed;
572 : : }
573 : :
574 : 0 : netpoll_print_options(np);
575 : :
576 : 0 : return 0;
577 : :
578 : : parse_failed:
579 : 0 : np_info(np, "couldn't parse config at '%s'!\n", cur);
580 : 0 : return -1;
581 : : }
582 : : EXPORT_SYMBOL(netpoll_parse_options);
583 : :
584 : 0 : int __netpoll_setup(struct netpoll *np, struct net_device *ndev)
585 : : {
586 : : struct netpoll_info *npinfo;
587 : : const struct net_device_ops *ops;
588 : : int err;
589 : :
590 : 0 : np->dev = ndev;
591 : 0 : strlcpy(np->dev_name, ndev->name, IFNAMSIZ);
592 : :
593 [ # # ]: 0 : if (ndev->priv_flags & IFF_DISABLE_NETPOLL) {
594 : 0 : np_err(np, "%s doesn't support polling, aborting\n",
595 : : np->dev_name);
596 : : err = -ENOTSUPP;
597 : 0 : goto out;
598 : : }
599 : :
600 [ # # ]: 0 : if (!ndev->npinfo) {
601 : : npinfo = kmalloc(sizeof(*npinfo), GFP_KERNEL);
602 [ # # ]: 0 : if (!npinfo) {
603 : : err = -ENOMEM;
604 : : goto out;
605 : : }
606 : :
607 : : sema_init(&npinfo->dev_lock, 1);
608 : 0 : skb_queue_head_init(&npinfo->txq);
609 : 0 : INIT_DELAYED_WORK(&npinfo->tx_work, queue_process);
610 : :
611 : : refcount_set(&npinfo->refcnt, 1);
612 : :
613 : 0 : ops = np->dev->netdev_ops;
614 [ # # ]: 0 : if (ops->ndo_netpoll_setup) {
615 : 0 : err = ops->ndo_netpoll_setup(ndev, npinfo);
616 [ # # ]: 0 : if (err)
617 : : goto free_npinfo;
618 : : }
619 : : } else {
620 : : npinfo = rtnl_dereference(ndev->npinfo);
621 : 0 : refcount_inc(&npinfo->refcnt);
622 : : }
623 : :
624 : 0 : npinfo->netpoll = np;
625 : :
626 : : /* last thing to do is link it to the net device structure */
627 : 0 : rcu_assign_pointer(ndev->npinfo, npinfo);
628 : :
629 : 0 : return 0;
630 : :
631 : : free_npinfo:
632 : 0 : kfree(npinfo);
633 : : out:
634 : 0 : return err;
635 : : }
636 : : EXPORT_SYMBOL_GPL(__netpoll_setup);
637 : :
638 : 0 : int netpoll_setup(struct netpoll *np)
639 : : {
640 : : struct net_device *ndev = NULL;
641 : : struct in_device *in_dev;
642 : : int err;
643 : :
644 : 0 : rtnl_lock();
645 [ # # ]: 0 : if (np->dev_name[0]) {
646 : 0 : struct net *net = current->nsproxy->net_ns;
647 : 0 : ndev = __dev_get_by_name(net, np->dev_name);
648 : : }
649 [ # # ]: 0 : if (!ndev) {
650 : 0 : np_err(np, "%s doesn't exist, aborting\n", np->dev_name);
651 : : err = -ENODEV;
652 : 0 : goto unlock;
653 : : }
654 : 0 : dev_hold(ndev);
655 : :
656 [ # # ]: 0 : if (netdev_master_upper_dev_get(ndev)) {
657 : 0 : np_err(np, "%s is a slave device, aborting\n", np->dev_name);
658 : : err = -EBUSY;
659 : 0 : goto put;
660 : : }
661 : :
662 [ # # ]: 0 : if (!netif_running(ndev)) {
663 : : unsigned long atmost, atleast;
664 : :
665 : 0 : np_info(np, "device %s not up yet, forcing it\n", np->dev_name);
666 : :
667 : 0 : err = dev_open(ndev, NULL);
668 : :
669 [ # # ]: 0 : if (err) {
670 : 0 : np_err(np, "failed to open %s\n", ndev->name);
671 : 0 : goto put;
672 : : }
673 : :
674 : 0 : rtnl_unlock();
675 : 0 : atleast = jiffies + HZ/10;
676 : 0 : atmost = jiffies + carrier_timeout * HZ;
677 [ # # ]: 0 : while (!netif_carrier_ok(ndev)) {
678 [ # # ]: 0 : if (time_after(jiffies, atmost)) {
679 : 0 : np_notice(np, "timeout waiting for carrier\n");
680 : 0 : break;
681 : : }
682 : 0 : msleep(1);
683 : : }
684 : :
685 : : /* If carrier appears to come up instantly, we don't
686 : : * trust it and pause so that we don't pump all our
687 : : * queued console messages into the bitbucket.
688 : : */
689 : :
690 [ # # ]: 0 : if (time_before(jiffies, atleast)) {
691 : 0 : np_notice(np, "carrier detect appears untrustworthy, waiting 4 seconds\n");
692 : 0 : msleep(4000);
693 : : }
694 : 0 : rtnl_lock();
695 : : }
696 : :
697 [ # # ]: 0 : if (!np->local_ip.ip) {
698 [ # # ]: 0 : if (!np->ipv6) {
699 : : const struct in_ifaddr *ifa;
700 : :
701 : : in_dev = __in_dev_get_rtnl(ndev);
702 [ # # ]: 0 : if (!in_dev)
703 : : goto put_noaddr;
704 : :
705 : 0 : ifa = rtnl_dereference(in_dev->ifa_list);
706 [ # # ]: 0 : if (!ifa) {
707 : : put_noaddr:
708 : 0 : np_err(np, "no IP address for %s, aborting\n",
709 : : np->dev_name);
710 : : err = -EDESTADDRREQ;
711 : 0 : goto put;
712 : : }
713 : :
714 : 0 : np->local_ip.ip = ifa->ifa_local;
715 : 0 : np_info(np, "local IP %pI4\n", &np->local_ip.ip);
716 : : } else {
717 : : #if IS_ENABLED(CONFIG_IPV6)
718 : : struct inet6_dev *idev;
719 : :
720 : : err = -EDESTADDRREQ;
721 : : idev = __in6_dev_get(ndev);
722 [ # # ]: 0 : if (idev) {
723 : : struct inet6_ifaddr *ifp;
724 : :
725 : 0 : read_lock_bh(&idev->lock);
726 [ # # ]: 0 : list_for_each_entry(ifp, &idev->addr_list, if_list) {
727 [ # # ]: 0 : if (!!(ipv6_addr_type(&ifp->addr) & IPV6_ADDR_LINKLOCAL) !=
728 : 0 : !!(ipv6_addr_type(&np->remote_ip.in6) & IPV6_ADDR_LINKLOCAL))
729 : 0 : continue;
730 : 0 : np->local_ip.in6 = ifp->addr;
731 : : err = 0;
732 : 0 : break;
733 : : }
734 : 0 : read_unlock_bh(&idev->lock);
735 : : }
736 [ # # ]: 0 : if (err) {
737 : 0 : np_err(np, "no IPv6 address for %s, aborting\n",
738 : : np->dev_name);
739 : 0 : goto put;
740 : : } else
741 : 0 : np_info(np, "local IPv6 %pI6c\n", &np->local_ip.in6);
742 : : #else
743 : : np_err(np, "IPv6 is not supported %s, aborting\n",
744 : : np->dev_name);
745 : : err = -EINVAL;
746 : : goto put;
747 : : #endif
748 : : }
749 : : }
750 : :
751 : : /* fill up the skb queue */
752 : 0 : refill_skbs();
753 : :
754 : 0 : err = __netpoll_setup(np, ndev);
755 [ # # ]: 0 : if (err)
756 : : goto put;
757 : :
758 : 0 : rtnl_unlock();
759 : 0 : return 0;
760 : :
761 : : put:
762 : 0 : dev_put(ndev);
763 : : unlock:
764 : 0 : rtnl_unlock();
765 : 0 : return err;
766 : : }
767 : : EXPORT_SYMBOL(netpoll_setup);
768 : :
769 : 207 : static int __init netpoll_init(void)
770 : : {
771 : : skb_queue_head_init(&skb_pool);
772 : 207 : return 0;
773 : : }
774 : : core_initcall(netpoll_init);
775 : :
776 : 0 : static void rcu_cleanup_netpoll_info(struct rcu_head *rcu_head)
777 : : {
778 : : struct netpoll_info *npinfo =
779 : 0 : container_of(rcu_head, struct netpoll_info, rcu);
780 : :
781 : 0 : skb_queue_purge(&npinfo->txq);
782 : :
783 : : /* we can't call cancel_delayed_work_sync here, as we are in softirq */
784 : 0 : cancel_delayed_work(&npinfo->tx_work);
785 : :
786 : : /* clean after last, unfinished work */
787 : 0 : __skb_queue_purge(&npinfo->txq);
788 : : /* now cancel it again */
789 : 0 : cancel_delayed_work(&npinfo->tx_work);
790 : 0 : kfree(npinfo);
791 : 0 : }
792 : :
793 : 0 : void __netpoll_cleanup(struct netpoll *np)
794 : : {
795 : : struct netpoll_info *npinfo;
796 : :
797 : 0 : npinfo = rtnl_dereference(np->dev->npinfo);
798 [ # # ]: 0 : if (!npinfo)
799 : 0 : return;
800 : :
801 : 0 : synchronize_srcu(&netpoll_srcu);
802 : :
803 [ # # ]: 0 : if (refcount_dec_and_test(&npinfo->refcnt)) {
804 : : const struct net_device_ops *ops;
805 : :
806 : 0 : ops = np->dev->netdev_ops;
807 [ # # ]: 0 : if (ops->ndo_netpoll_cleanup)
808 : 0 : ops->ndo_netpoll_cleanup(np->dev);
809 : :
810 : 0 : RCU_INIT_POINTER(np->dev->npinfo, NULL);
811 : 0 : call_rcu(&npinfo->rcu, rcu_cleanup_netpoll_info);
812 : : } else
813 : 0 : RCU_INIT_POINTER(np->dev->npinfo, NULL);
814 : : }
815 : : EXPORT_SYMBOL_GPL(__netpoll_cleanup);
816 : :
817 : 0 : void __netpoll_free(struct netpoll *np)
818 : : {
819 [ # # # # ]: 0 : ASSERT_RTNL();
820 : :
821 : : /* Wait for transmitting packets to finish before freeing. */
822 : 0 : synchronize_rcu();
823 : 0 : __netpoll_cleanup(np);
824 : 0 : kfree(np);
825 : 0 : }
826 : : EXPORT_SYMBOL_GPL(__netpoll_free);
827 : :
828 : 0 : void netpoll_cleanup(struct netpoll *np)
829 : : {
830 : 0 : rtnl_lock();
831 [ # # ]: 0 : if (!np->dev)
832 : : goto out;
833 : 0 : __netpoll_cleanup(np);
834 : 0 : dev_put(np->dev);
835 : 0 : np->dev = NULL;
836 : : out:
837 : 0 : rtnl_unlock();
838 : 0 : }
839 : : EXPORT_SYMBOL(netpoll_cleanup);
|
