?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ACPI: thinkpad_acpi: use bool for boolean parameters
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / net / netrom / nr_route.c
blob8e6bd4e9d82c76e929ce1648c51456ce9da6e60f
1 /*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * Copyright Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
8 * Copyright Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk)
9 * Copyright Tomi Manninen OH2BNS (oh2bns@sral.fi)
10 */
11 #include <linux/errno.h>
12 #include <linux/types.h>
13 #include <linux/socket.h>
14 #include <linux/in.h>
15 #include <linux/kernel.h>
16 #include <linux/timer.h>
17 #include <linux/string.h>
18 #include <linux/sockios.h>
19 #include <linux/net.h>
20 #include <net/ax25.h>
21 #include <linux/inet.h>
22 #include <linux/netdevice.h>
23 #include <net/arp.h>
24 #include <linux/if_arp.h>
25 #include <linux/skbuff.h>
26 #include <net/sock.h>
27 #include <asm/uaccess.h>
28 #include <asm/system.h>
29 #include <linux/fcntl.h>
30 #include <linux/termios.h> /* For TIOCINQ/OUTQ */
31 #include <linux/mm.h>
32 #include <linux/interrupt.h>
33 #include <linux/notifier.h>
34 #include <linux/netfilter.h>
35 #include <linux/init.h>
36 #include <linux/spinlock.h>
37 #include <net/netrom.h>
38 #include <linux/seq_file.h>
39
40 static unsigned int nr_neigh_no = 1;
41
42 static HLIST_HEAD(nr_node_list);
43 static DEFINE_SPINLOCK(nr_node_list_lock);
44 static HLIST_HEAD(nr_neigh_list);
45 static DEFINE_SPINLOCK(nr_neigh_list_lock);
46
47 static struct nr_node *nr_node_get(ax25_address *callsign)
48 {
49 struct nr_node *found = NULL;
50 struct nr_node *nr_node;
51 struct hlist_node *node;
52
53 spin_lock_bh(&nr_node_list_lock);
54 nr_node_for_each(nr_node, node, &nr_node_list)
55 if (ax25cmp(callsign, &nr_node->callsign) == 0) {
56 nr_node_hold(nr_node);
57 found = nr_node;
58 break;
59 }
60 spin_unlock_bh(&nr_node_list_lock);
61 return found;
62 }
63
64 static struct nr_neigh *nr_neigh_get_dev(ax25_address *callsign,
65 struct net_device *dev)
66 {
67 struct nr_neigh *found = NULL;
68 struct nr_neigh *nr_neigh;
69 struct hlist_node *node;
70
71 spin_lock_bh(&nr_neigh_list_lock);
72 nr_neigh_for_each(nr_neigh, node, &nr_neigh_list)
73 if (ax25cmp(callsign, &nr_neigh->callsign) == 0 &&
74 nr_neigh->dev == dev) {
75 nr_neigh_hold(nr_neigh);
76 found = nr_neigh;
77 break;
78 }
79 spin_unlock_bh(&nr_neigh_list_lock);
80 return found;
81 }
82
83 static void nr_remove_neigh(struct nr_neigh *);
84
85 /*
86 * Add a new route to a node, and in the process add the node and the
87 * neighbour if it is new.
88 */
89 static int __must_check nr_add_node(ax25_address *nr, const char *mnemonic,
90 ax25_address *ax25, ax25_digi *ax25_digi, struct net_device *dev,
91 int quality, int obs_count)
92 {
93 struct nr_node *nr_node;
94 struct nr_neigh *nr_neigh;
95 struct nr_route nr_route;
96 int i, found;
97 struct net_device *odev;
98
99 if ((odev=nr_dev_get(nr)) != NULL) { /* Can't add routes to ourself */
100 dev_put(odev);
101 return -EINVAL;
102 }
103
104 nr_node = nr_node_get(nr);
105
106 nr_neigh = nr_neigh_get_dev(ax25, dev);
107
108 /*
109 * The L2 link to a neighbour has failed in the past
110 * and now a frame comes from this neighbour. We assume
111 * it was a temporary trouble with the link and reset the
112 * routes now (and not wait for a node broadcast).
113 */
114 if (nr_neigh != NULL && nr_neigh->failed != 0 && quality == 0) {
115 struct nr_node *nr_nodet;
116 struct hlist_node *node;
117
118 spin_lock_bh(&nr_node_list_lock);
119 nr_node_for_each(nr_nodet, node, &nr_node_list) {
120 nr_node_lock(nr_nodet);
121 for (i = 0; i < nr_nodet->count; i++)
122 if (nr_nodet->routes[i].neighbour == nr_neigh)
123 if (i < nr_nodet->which)
124 nr_nodet->which = i;
125 nr_node_unlock(nr_nodet);
126 }
127 spin_unlock_bh(&nr_node_list_lock);
128 }
129
130 if (nr_neigh != NULL)
131 nr_neigh->failed = 0;
132
133 if (quality == 0 && nr_neigh != NULL && nr_node != NULL) {
134 nr_neigh_put(nr_neigh);
135 nr_node_put(nr_node);
136 return 0;
137 }
138
139 if (nr_neigh == NULL) {
140 if ((nr_neigh = kmalloc(sizeof(*nr_neigh), GFP_ATOMIC)) == NULL) {
141 if (nr_node)
142 nr_node_put(nr_node);
143 return -ENOMEM;
144 }
145
146 nr_neigh->callsign = *ax25;
147 nr_neigh->digipeat = NULL;
148 nr_neigh->ax25 = NULL;
149 nr_neigh->dev = dev;
150 nr_neigh->quality = sysctl_netrom_default_path_quality;
151 nr_neigh->locked = 0;
152 nr_neigh->count = 0;
153 nr_neigh->number = nr_neigh_no++;
154 nr_neigh->failed = 0;
155 atomic_set(&nr_neigh->refcount, 1);
156
157 if (ax25_digi != NULL && ax25_digi->ndigi > 0) {
158 nr_neigh->digipeat = kmemdup(ax25_digi,
159 sizeof(*ax25_digi),
160 GFP_KERNEL);
161 if (nr_neigh->digipeat == NULL) {
162 kfree(nr_neigh);
163 if (nr_node)
164 nr_node_put(nr_node);
165 return -ENOMEM;
166 }
167 }
168
169 spin_lock_bh(&nr_neigh_list_lock);
170 hlist_add_head(&nr_neigh->neigh_node, &nr_neigh_list);
171 nr_neigh_hold(nr_neigh);
172 spin_unlock_bh(&nr_neigh_list_lock);
173 }
174
175 if (quality != 0 && ax25cmp(nr, ax25) == 0 && !nr_neigh->locked)
176 nr_neigh->quality = quality;
177
178 if (nr_node == NULL) {
179 if ((nr_node = kmalloc(sizeof(*nr_node), GFP_ATOMIC)) == NULL) {
180 if (nr_neigh)
181 nr_neigh_put(nr_neigh);
182 return -ENOMEM;
183 }
184
185 nr_node->callsign = *nr;
186 strcpy(nr_node->mnemonic, mnemonic);
187
188 nr_node->which = 0;
189 nr_node->count = 1;
190 atomic_set(&nr_node->refcount, 1);
191 spin_lock_init(&nr_node->node_lock);
192
193 nr_node->routes[0].quality = quality;
194 nr_node->routes[0].obs_count = obs_count;
195 nr_node->routes[0].neighbour = nr_neigh;
196
197 nr_neigh_hold(nr_neigh);
198 nr_neigh->count++;
199
200 spin_lock_bh(&nr_node_list_lock);
201 hlist_add_head(&nr_node->node_node, &nr_node_list);
202 /* refcount initialized at 1 */
203 spin_unlock_bh(&nr_node_list_lock);
204
205 return 0;
206 }
207 nr_node_lock(nr_node);
208
209 if (quality != 0)
210 strcpy(nr_node->mnemonic, mnemonic);
211
212 for (found = 0, i = 0; i < nr_node->count; i++) {
213 if (nr_node->routes[i].neighbour == nr_neigh) {
214 nr_node->routes[i].quality = quality;
215 nr_node->routes[i].obs_count = obs_count;
216 found = 1;
217 break;
218 }
219 }
220
221 if (!found) {
222 /* We have space at the bottom, slot it in */
223 if (nr_node->count < 3) {
224 nr_node->routes[2] = nr_node->routes[1];
225 nr_node->routes[1] = nr_node->routes[0];
226
227 nr_node->routes[0].quality = quality;
228 nr_node->routes[0].obs_count = obs_count;
229 nr_node->routes[0].neighbour = nr_neigh;
230
231 nr_node->which++;
232 nr_node->count++;
233 nr_neigh_hold(nr_neigh);
234 nr_neigh->count++;
235 } else {
236 /* It must be better than the worst */
237 if (quality > nr_node->routes[2].quality) {
238 nr_node->routes[2].neighbour->count--;
239 nr_neigh_put(nr_node->routes[2].neighbour);
240
241 if (nr_node->routes[2].neighbour->count == 0 && !nr_node->routes[2].neighbour->locked)
242 nr_remove_neigh(nr_node->routes[2].neighbour);
243
244 nr_node->routes[2].quality = quality;
245 nr_node->routes[2].obs_count = obs_count;
246 nr_node->routes[2].neighbour = nr_neigh;
247
248 nr_neigh_hold(nr_neigh);
249 nr_neigh->count++;
250 }
251 }
252 }
253
254 /* Now re-sort the routes in quality order */
255 switch (nr_node->count) {
256 case 3:
257 if (nr_node->routes[1].quality > nr_node->routes[0].quality) {
258 switch (nr_node->which) {
259 case 0: nr_node->which = 1; break;
260 case 1: nr_node->which = 0; break;
261 default: break;
262 }
263 nr_route = nr_node->routes[0];
264 nr_node->routes[0] = nr_node->routes[1];
265 nr_node->routes[1] = nr_route;
266 }
267 if (nr_node->routes[2].quality > nr_node->routes[1].quality) {
268 switch (nr_node->which) {
269 case 1: nr_node->which = 2;
270 break;
271
272 case 2: nr_node->which = 1;
273 break;
274
275 default:
276 break;
277 }
278 nr_route = nr_node->routes[1];
279 nr_node->routes[1] = nr_node->routes[2];
280 nr_node->routes[2] = nr_route;
281 }
282 case 2:
283 if (nr_node->routes[1].quality > nr_node->routes[0].quality) {
284 switch (nr_node->which) {
285 case 0: nr_node->which = 1;
286 break;
287
288 case 1: nr_node->which = 0;
289 break;
290
291 default: break;
292 }
293 nr_route = nr_node->routes[0];
294 nr_node->routes[0] = nr_node->routes[1];
295 nr_node->routes[1] = nr_route;
296 }
297 case 1:
298 break;
299 }
300
301 for (i = 0; i < nr_node->count; i++) {
302 if (nr_node->routes[i].neighbour == nr_neigh) {
303 if (i < nr_node->which)
304 nr_node->which = i;
305 break;
306 }
307 }
308
309 nr_neigh_put(nr_neigh);
310 nr_node_unlock(nr_node);
311 nr_node_put(nr_node);
312 return 0;
313 }
314
315 static inline void __nr_remove_node(struct nr_node *nr_node)
316 {
317 hlist_del_init(&nr_node->node_node);
318 nr_node_put(nr_node);
319 }
320
321 #define nr_remove_node_locked(__node) \
322 __nr_remove_node(__node)
323
324 static void nr_remove_node(struct nr_node *nr_node)
325 {
326 spin_lock_bh(&nr_node_list_lock);
327 __nr_remove_node(nr_node);
328 spin_unlock_bh(&nr_node_list_lock);
329 }
330
331 static inline void __nr_remove_neigh(struct nr_neigh *nr_neigh)
332 {
333 hlist_del_init(&nr_neigh->neigh_node);
334 nr_neigh_put(nr_neigh);
335 }
336
337 #define nr_remove_neigh_locked(__neigh) \
338 __nr_remove_neigh(__neigh)
339
340 static void nr_remove_neigh(struct nr_neigh *nr_neigh)
341 {
342 spin_lock_bh(&nr_neigh_list_lock);
343 __nr_remove_neigh(nr_neigh);
344 spin_unlock_bh(&nr_neigh_list_lock);
345 }
346
347 /*
348 * "Delete" a node. Strictly speaking remove a route to a node. The node
349 * is only deleted if no routes are left to it.
350 */
351 static int nr_del_node(ax25_address *callsign, ax25_address *neighbour, struct net_device *dev)
352 {
353 struct nr_node *nr_node;
354 struct nr_neigh *nr_neigh;
355 int i;
356
357 nr_node = nr_node_get(callsign);
358
359 if (nr_node == NULL)
360 return -EINVAL;
361
362 nr_neigh = nr_neigh_get_dev(neighbour, dev);
363
364 if (nr_neigh == NULL) {
365 nr_node_put(nr_node);
366 return -EINVAL;
367 }
368
369 nr_node_lock(nr_node);
370 for (i = 0; i < nr_node->count; i++) {
371 if (nr_node->routes[i].neighbour == nr_neigh) {
372 nr_neigh->count--;
373 nr_neigh_put(nr_neigh);
374
375 if (nr_neigh->count == 0 && !nr_neigh->locked)
376 nr_remove_neigh(nr_neigh);
377 nr_neigh_put(nr_neigh);
378
379 nr_node->count--;
380
381 if (nr_node->count == 0) {
382 nr_remove_node(nr_node);
383 } else {
384 switch (i) {
385 case 0:
386 nr_node->routes[0] = nr_node->routes[1];
387 case 1:
388 nr_node->routes[1] = nr_node->routes[2];
389 case 2:
390 break;
391 }
392 nr_node_put(nr_node);
393 }
394 nr_node_unlock(nr_node);
395
396 return 0;
397 }
398 }
399 nr_neigh_put(nr_neigh);
400 nr_node_unlock(nr_node);
401 nr_node_put(nr_node);
402
403 return -EINVAL;
404 }
405
406 /*
407 * Lock a neighbour with a quality.
408 */
409 static int __must_check nr_add_neigh(ax25_address *callsign,
410 ax25_digi *ax25_digi, struct net_device *dev, unsigned int quality)
411 {
412 struct nr_neigh *nr_neigh;
413
414 nr_neigh = nr_neigh_get_dev(callsign, dev);
415 if (nr_neigh) {
416 nr_neigh->quality = quality;
417 nr_neigh->locked = 1;
418 nr_neigh_put(nr_neigh);
419 return 0;
420 }
421
422 if ((nr_neigh = kmalloc(sizeof(*nr_neigh), GFP_ATOMIC)) == NULL)
423 return -ENOMEM;
424
425 nr_neigh->callsign = *callsign;
426 nr_neigh->digipeat = NULL;
427 nr_neigh->ax25 = NULL;
428 nr_neigh->dev = dev;
429 nr_neigh->quality = quality;
430 nr_neigh->locked = 1;
431 nr_neigh->count = 0;
432 nr_neigh->number = nr_neigh_no++;
433 nr_neigh->failed = 0;
434 atomic_set(&nr_neigh->refcount, 1);
435
436 if (ax25_digi != NULL && ax25_digi->ndigi > 0) {
437 nr_neigh->digipeat = kmemdup(ax25_digi, sizeof(*ax25_digi),
438 GFP_KERNEL);
439 if (nr_neigh->digipeat == NULL) {
440 kfree(nr_neigh);
441 return -ENOMEM;
442 }
443 }
444
445 spin_lock_bh(&nr_neigh_list_lock);
446 hlist_add_head(&nr_neigh->neigh_node, &nr_neigh_list);
447 /* refcount is initialized at 1 */
448 spin_unlock_bh(&nr_neigh_list_lock);
449
450 return 0;
451 }
452
453 /*
454 * "Delete" a neighbour. The neighbour is only removed if the number
455 * of nodes that may use it is zero.
456 */
457 static int nr_del_neigh(ax25_address *callsign, struct net_device *dev, unsigned int quality)
458 {
459 struct nr_neigh *nr_neigh;
460
461 nr_neigh = nr_neigh_get_dev(callsign, dev);
462
463 if (nr_neigh == NULL) return -EINVAL;
464
465 nr_neigh->quality = quality;
466 nr_neigh->locked = 0;
467
468 if (nr_neigh->count == 0)
469 nr_remove_neigh(nr_neigh);
470 nr_neigh_put(nr_neigh);
471
472 return 0;
473 }
474
475 /*
476 * Decrement the obsolescence count by one. If a route is reduced to a
477 * count of zero, remove it. Also remove any unlocked neighbours with
478 * zero nodes routing via it.
479 */
480 static int nr_dec_obs(void)
481 {
482 struct nr_neigh *nr_neigh;
483 struct nr_node *s;
484 struct hlist_node *node, *nodet;
485 int i;
486
487 spin_lock_bh(&nr_node_list_lock);
488 nr_node_for_each_safe(s, node, nodet, &nr_node_list) {
489 nr_node_lock(s);
490 for (i = 0; i < s->count; i++) {
491 switch (s->routes[i].obs_count) {
492 case 0: /* A locked entry */
493 break;
494
495 case 1: /* From 1 -> 0 */
496 nr_neigh = s->routes[i].neighbour;
497
498 nr_neigh->count--;
499 nr_neigh_put(nr_neigh);
500
501 if (nr_neigh->count == 0 && !nr_neigh->locked)
502 nr_remove_neigh(nr_neigh);
503
504 s->count--;
505
506 switch (i) {
507 case 0:
508 s->routes[0] = s->routes[1];
509 case 1:
510 s->routes[1] = s->routes[2];
511 case 2:
512 break;
513 }
514 break;
515
516 default:
517 s->routes[i].obs_count--;
518 break;
519
520 }
521 }
522
523 if (s->count <= 0)
524 nr_remove_node_locked(s);
525 nr_node_unlock(s);
526 }
527 spin_unlock_bh(&nr_node_list_lock);
528
529 return 0;
530 }
531
532 /*
533 * A device has been removed. Remove its routes and neighbours.
534 */
535 void nr_rt_device_down(struct net_device *dev)
536 {
537 struct nr_neigh *s;
538 struct hlist_node *node, *nodet, *node2, *node2t;
539 struct nr_node *t;
540 int i;
541
542 spin_lock_bh(&nr_neigh_list_lock);
543 nr_neigh_for_each_safe(s, node, nodet, &nr_neigh_list) {
544 if (s->dev == dev) {
545 spin_lock_bh(&nr_node_list_lock);
546 nr_node_for_each_safe(t, node2, node2t, &nr_node_list) {
547 nr_node_lock(t);
548 for (i = 0; i < t->count; i++) {
549 if (t->routes[i].neighbour == s) {
550 t->count--;
551
552 switch (i) {
553 case 0:
554 t->routes[0] = t->routes[1];
555 case 1:
556 t->routes[1] = t->routes[2];
557 case 2:
558 break;
559 }
560 }
561 }
562
563 if (t->count <= 0)
564 nr_remove_node_locked(t);
565 nr_node_unlock(t);
566 }
567 spin_unlock_bh(&nr_node_list_lock);
568
569 nr_remove_neigh_locked(s);
570 }
571 }
572 spin_unlock_bh(&nr_neigh_list_lock);
573 }
574
575 /*
576 * Check that the device given is a valid AX.25 interface that is "up".
577 * Or a valid ethernet interface with an AX.25 callsign binding.
578 */
579 static struct net_device *nr_ax25_dev_get(char *devname)
580 {
581 struct net_device *dev;
582
583 if ((dev = dev_get_by_name(devname)) == NULL)
584 return NULL;
585
586 if ((dev->flags & IFF_UP) && dev->type == ARPHRD_AX25)
587 return dev;
588
589 dev_put(dev);
590 return NULL;
591 }
592
593 /*
594 * Find the first active NET/ROM device, usually "nr0".
595 */
596 struct net_device *nr_dev_first(void)
597 {
598 struct net_device *dev, *first = NULL;
599
600 read_lock(&dev_base_lock);
601 for (dev = dev_base; dev != NULL; dev = dev->next) {
602 if ((dev->flags & IFF_UP) && dev->type == ARPHRD_NETROM)
603 if (first == NULL || strncmp(dev->name, first->name, 3) < 0)
604 first = dev;
605 }
606 if (first)
607 dev_hold(first);
608 read_unlock(&dev_base_lock);
609
610 return first;
611 }
612
613 /*
614 * Find the NET/ROM device for the given callsign.
615 */
616 struct net_device *nr_dev_get(ax25_address *addr)
617 {
618 struct net_device *dev;
619
620 read_lock(&dev_base_lock);
621 for (dev = dev_base; dev != NULL; dev = dev->next) {
622 if ((dev->flags & IFF_UP) && dev->type == ARPHRD_NETROM && ax25cmp(addr, (ax25_address *)dev->dev_addr) == 0) {
623 dev_hold(dev);
624 goto out;
625 }
626 }
627 out:
628 read_unlock(&dev_base_lock);
629 return dev;
630 }
631
632 static ax25_digi *nr_call_to_digi(int ndigis, ax25_address *digipeaters)
633 {
634 static ax25_digi ax25_digi;
635 int i;
636
637 if (ndigis == 0)
638 return NULL;
639
640 for (i = 0; i < ndigis; i++) {
641 ax25_digi.calls[i] = digipeaters[i];
642 ax25_digi.repeated[i] = 0;
643 }
644
645 ax25_digi.ndigi = ndigis;
646 ax25_digi.lastrepeat = -1;
647
648 return &ax25_digi;
649 }
650
651 /*
652 * Handle the ioctls that control the routing functions.
653 */
654 int nr_rt_ioctl(unsigned int cmd, void __user *arg)
655 {
656 struct nr_route_struct nr_route;
657 struct net_device *dev;
658 int ret;
659
660 switch (cmd) {
661 case SIOCADDRT:
662 if (copy_from_user(&nr_route, arg, sizeof(struct nr_route_struct)))
663 return -EFAULT;
664 if ((dev = nr_ax25_dev_get(nr_route.device)) == NULL)
665 return -EINVAL;
666 if (nr_route.ndigis < 0 || nr_route.ndigis > AX25_MAX_DIGIS) {
667 dev_put(dev);
668 return -EINVAL;
669 }
670 switch (nr_route.type) {
671 case NETROM_NODE:
672 ret = nr_add_node(&nr_route.callsign,
673 nr_route.mnemonic,
674 &nr_route.neighbour,
675 nr_call_to_digi(nr_route.ndigis, nr_route.digipeaters),
676 dev, nr_route.quality,
677 nr_route.obs_count);
678 break;
679 case NETROM_NEIGH:
680 ret = nr_add_neigh(&nr_route.callsign,
681 nr_call_to_digi(nr_route.ndigis, nr_route.digipeaters),
682 dev, nr_route.quality);
683 break;
684 default:
685 ret = -EINVAL;
686 }
687 dev_put(dev);
688 return ret;
689
690 case SIOCDELRT:
691 if (copy_from_user(&nr_route, arg, sizeof(struct nr_route_struct)))
692 return -EFAULT;
693 if ((dev = nr_ax25_dev_get(nr_route.device)) == NULL)
694 return -EINVAL;
695 switch (nr_route.type) {
696 case NETROM_NODE:
697 ret = nr_del_node(&nr_route.callsign,
698 &nr_route.neighbour, dev);
699 break;
700 case NETROM_NEIGH:
701 ret = nr_del_neigh(&nr_route.callsign,
702 dev, nr_route.quality);
703 break;
704 default:
705 ret = -EINVAL;
706 }
707 dev_put(dev);
708 return ret;
709
710 case SIOCNRDECOBS:
711 return nr_dec_obs();
712
713 default:
714 return -EINVAL;
715 }
716
717 return 0;
718 }
719
720 /*
721 * A level 2 link has timed out, therefore it appears to be a poor link,
722 * then don't use that neighbour until it is reset.
723 */
724 void nr_link_failed(ax25_cb *ax25, int reason)
725 {
726 struct nr_neigh *s, *nr_neigh = NULL;
727 struct hlist_node *node;
728 struct nr_node *nr_node = NULL;
729
730 spin_lock_bh(&nr_neigh_list_lock);
731 nr_neigh_for_each(s, node, &nr_neigh_list) {
732 if (s->ax25 == ax25) {
733 nr_neigh_hold(s);
734 nr_neigh = s;
735 break;
736 }
737 }
738 spin_unlock_bh(&nr_neigh_list_lock);
739
740 if (nr_neigh == NULL)
741 return;
742
743 nr_neigh->ax25 = NULL;
744 ax25_cb_put(ax25);
745
746 if (++nr_neigh->failed < sysctl_netrom_link_fails_count) {
747 nr_neigh_put(nr_neigh);
748 return;
749 }
750 spin_lock_bh(&nr_node_list_lock);
751 nr_node_for_each(nr_node, node, &nr_node_list) {
752 nr_node_lock(nr_node);
753 if (nr_node->which < nr_node->count &&
754 nr_node->routes[nr_node->which].neighbour == nr_neigh)
755 nr_node->which++;
756 nr_node_unlock(nr_node);
757 }
758 spin_unlock_bh(&nr_node_list_lock);
759 nr_neigh_put(nr_neigh);
760 }
761
762 /*
763 * Route a frame to an appropriate AX.25 connection. A NULL ax25_cb
764 * indicates an internally generated frame.
765 */
766 int nr_route_frame(struct sk_buff *skb, ax25_cb *ax25)
767 {
768 ax25_address *nr_src, *nr_dest;
769 struct nr_neigh *nr_neigh;
770 struct nr_node *nr_node;
771 struct net_device *dev;
772 unsigned char *dptr;
773 ax25_cb *ax25s;
774 int ret;
775 struct sk_buff *skbn;
776
777
778 nr_src = (ax25_address *)(skb->data + 0);
779 nr_dest = (ax25_address *)(skb->data + 7);
780
781 if (ax25 != NULL) {
782 ret = nr_add_node(nr_src, "", &ax25->dest_addr, ax25->digipeat,
783 ax25->ax25_dev->dev, 0,
784 sysctl_netrom_obsolescence_count_initialiser);
785 if (ret)
786 return ret;
787 }
788
789 if ((dev = nr_dev_get(nr_dest)) != NULL) { /* Its for me */
790 if (ax25 == NULL) /* Its from me */
791 ret = nr_loopback_queue(skb);
792 else
793 ret = nr_rx_frame(skb, dev);
794 dev_put(dev);
795 return ret;
796 }
797
798 if (!sysctl_netrom_routing_control && ax25 != NULL)
799 return 0;
800
801 /* Its Time-To-Live has expired */
802 if (skb->data[14] == 1) {
803 return 0;
804 }
805
806 nr_node = nr_node_get(nr_dest);
807 if (nr_node == NULL)
808 return 0;
809 nr_node_lock(nr_node);
810
811 if (nr_node->which >= nr_node->count) {
812 nr_node_unlock(nr_node);
813 nr_node_put(nr_node);
814 return 0;
815 }
816
817 nr_neigh = nr_node->routes[nr_node->which].neighbour;
818
819 if ((dev = nr_dev_first()) == NULL) {
820 nr_node_unlock(nr_node);
821 nr_node_put(nr_node);
822 return 0;
823 }
824
825 /* We are going to change the netrom headers so we should get our
826 own skb, we also did not know until now how much header space
827 we had to reserve... - RXQ */
828 if ((skbn=skb_copy_expand(skb, dev->hard_header_len, 0, GFP_ATOMIC)) == NULL) {
829 nr_node_unlock(nr_node);
830 nr_node_put(nr_node);
831 dev_put(dev);
832 return 0;
833 }
834 kfree_skb(skb);
835 skb=skbn;
836 skb->data[14]--;
837
838 dptr = skb_push(skb, 1);
839 *dptr = AX25_P_NETROM;
840
841 ax25s = ax25_send_frame(skb, 256, (ax25_address *)dev->dev_addr, &nr_neigh->callsign, nr_neigh->digipeat, nr_neigh->dev);
842 if (nr_neigh->ax25 && ax25s) {
843 /* We were already holding this ax25_cb */
844 ax25_cb_put(ax25s);
845 }
846 nr_neigh->ax25 = ax25s;
847
848 dev_put(dev);
849 ret = (nr_neigh->ax25 != NULL);
850 nr_node_unlock(nr_node);
851 nr_node_put(nr_node);
852
853 return ret;
854 }
855
856 #ifdef CONFIG_PROC_FS
857
858 static void *nr_node_start(struct seq_file *seq, loff_t *pos)
859 {
860 struct nr_node *nr_node;
861 struct hlist_node *node;
862 int i = 1;
863
864 spin_lock_bh(&nr_node_list_lock);
865 if (*pos == 0)
866 return SEQ_START_TOKEN;
867
868 nr_node_for_each(nr_node, node, &nr_node_list) {
869 if (i == *pos)
870 return nr_node;
871 ++i;
872 }
873
874 return NULL;
875 }
876
877 static void *nr_node_next(struct seq_file *seq, void *v, loff_t *pos)
878 {
879 struct hlist_node *node;
880 ++*pos;
881
882 node = (v == SEQ_START_TOKEN)
883 ? nr_node_list.first
884 : ((struct nr_node *)v)->node_node.next;
885
886 return hlist_entry(node, struct nr_node, node_node);
887 }
888
889 static void nr_node_stop(struct seq_file *seq, void *v)
890 {
891 spin_unlock_bh(&nr_node_list_lock);
892 }
893
894 static int nr_node_show(struct seq_file *seq, void *v)
895 {
896 char buf[11];
897 int i;
898
899 if (v == SEQ_START_TOKEN)
900 seq_puts(seq,
901 "callsign mnemonic w n qual obs neigh qual obs neigh qual obs neigh\n");
902 else {
903 struct nr_node *nr_node = v;
904 nr_node_lock(nr_node);
905 seq_printf(seq, "%-9s %-7s %d %d",
906 ax2asc(buf, &nr_node->callsign),
907 (nr_node->mnemonic[0] == '\0') ? "*" : nr_node->mnemonic,
908 nr_node->which + 1,
909 nr_node->count);
910
911 for (i = 0; i < nr_node->count; i++) {
912 seq_printf(seq, " %3d %d %05d",
913 nr_node->routes[i].quality,
914 nr_node->routes[i].obs_count,
915 nr_node->routes[i].neighbour->number);
916 }
917 nr_node_unlock(nr_node);
918
919 seq_puts(seq, "\n");
920 }
921 return 0;
922 }
923
924 static struct seq_operations nr_node_seqops = {
925 .start = nr_node_start,
926 .next = nr_node_next,
927 .stop = nr_node_stop,
928 .show = nr_node_show,
929 };
930
931 static int nr_node_info_open(struct inode *inode, struct file *file)
932 {
933 return seq_open(file, &nr_node_seqops);
934 }
935
936 const struct file_operations nr_nodes_fops = {
937 .owner = THIS_MODULE,
938 .open = nr_node_info_open,
939 .read = seq_read,
940 .llseek = seq_lseek,
941 .release = seq_release,
942 };
943
944 static void *nr_neigh_start(struct seq_file *seq, loff_t *pos)
945 {
946 struct nr_neigh *nr_neigh;
947 struct hlist_node *node;
948 int i = 1;
949
950 spin_lock_bh(&nr_neigh_list_lock);
951 if (*pos == 0)
952 return SEQ_START_TOKEN;
953
954 nr_neigh_for_each(nr_neigh, node, &nr_neigh_list) {
955 if (i == *pos)
956 return nr_neigh;
957 }
958 return NULL;
959 }
960
961 static void *nr_neigh_next(struct seq_file *seq, void *v, loff_t *pos)
962 {
963 struct hlist_node *node;
964 ++*pos;
965
966 node = (v == SEQ_START_TOKEN)
967 ? nr_neigh_list.first
968 : ((struct nr_neigh *)v)->neigh_node.next;
969
970 return hlist_entry(node, struct nr_neigh, neigh_node);
971 }
972
973 static void nr_neigh_stop(struct seq_file *seq, void *v)
974 {
975 spin_unlock_bh(&nr_neigh_list_lock);
976 }
977
978 static int nr_neigh_show(struct seq_file *seq, void *v)
979 {
980 char buf[11];
981 int i;
982
983 if (v == SEQ_START_TOKEN)
984 seq_puts(seq, "addr callsign dev qual lock count failed digipeaters\n");
985 else {
986 struct nr_neigh *nr_neigh = v;
987
988 seq_printf(seq, "%05d %-9s %-4s %3d %d %3d %3d",
989 nr_neigh->number,
990 ax2asc(buf, &nr_neigh->callsign),
991 nr_neigh->dev ? nr_neigh->dev->name : "???",
992 nr_neigh->quality,
993 nr_neigh->locked,
994 nr_neigh->count,
995 nr_neigh->failed);
996
997 if (nr_neigh->digipeat != NULL) {
998 for (i = 0; i < nr_neigh->digipeat->ndigi; i++)
999 seq_printf(seq, " %s",
1000 ax2asc(buf, &nr_neigh->digipeat->calls[i]));
1001 }
1002
1003 seq_puts(seq, "\n");
1004 }
1005 return 0;
1006 }
1007
1008 static struct seq_operations nr_neigh_seqops = {
1009 .start = nr_neigh_start,
1010 .next = nr_neigh_next,
1011 .stop = nr_neigh_stop,
1012 .show = nr_neigh_show,
1013 };
1014
1015 static int nr_neigh_info_open(struct inode *inode, struct file *file)
1016 {
1017 return seq_open(file, &nr_neigh_seqops);
1018 }
1019
1020 const struct file_operations nr_neigh_fops = {
1021 .owner = THIS_MODULE,
1022 .open = nr_neigh_info_open,
1023 .read = seq_read,
1024 .llseek = seq_lseek,
1025 .release = seq_release,
1026 };
1027
1028 #endif
1029
1030 /*
1031 * Free all memory associated with the nodes and routes lists.
1032 */
1033 void __exit nr_rt_free(void)
1034 {
1035 struct nr_neigh *s = NULL;
1036 struct nr_node *t = NULL;
1037 struct hlist_node *node, *nodet;
1038
1039 spin_lock_bh(&nr_neigh_list_lock);
1040 spin_lock_bh(&nr_node_list_lock);
1041 nr_node_for_each_safe(t, node, nodet, &nr_node_list) {
1042 nr_node_lock(t);
1043 nr_remove_node_locked(t);
1044 nr_node_unlock(t);
1045 }
1046 nr_neigh_for_each_safe(s, node, nodet, &nr_neigh_list) {
1047 while(s->count) {
1048 s->count--;
1049 nr_neigh_put(s);
1050 }
1051 nr_remove_neigh_locked(s);
1052 }
1053 spin_unlock_bh(&nr_node_list_lock);
1054 spin_unlock_bh(&nr_neigh_list_lock);
1055 }
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree