?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
credits, sock/cpacket buffer accounting+resume, type of service, MSG_MORE delayed...
[cor_2_6_31.git] / net / cor / neighbor.c
blobaaf2c64d112d2e9afa92102d58e339056a6a9488
1 /*
2 * Connection oriented routing
3 * Copyright (C) 2007-2010 Michael Blizek
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version 2
8 * of the License, or (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
18 * 02110-1301, USA.
19 */
20
21 #include "cor.h"
22
23 /**
24 * Splited packet data format:
25 * announce proto version [4]
26 * is 0, may be increased if format changes
27 * packet version [4]
28 * starts with 0, increments every time the data field changes
29 * total size [4]
30 * total data size of all merged packets
31 * offset [4]
32 * used to determine the order when merging the split packet
33 * unit is bytes
34 * [data]
35 * commulative checksum [8] (not yet)
36 * chunk 1 contains the checksum of the data in chunk 1
37 * chunk 2 contains the checksum of the data in chunk 1+2
38 * ...
39 *
40 * Data format of the announce packet "data" field:
41 * min_announce_proto_version [4]
42 * max_announce_proto_version [4]
43 * min_cor_proto_version [4]
44 * max_cor_proto_version [4]
45 * versions which are understood
46 *
47 * command [4]
48 * commandlength [4]
49 * commanddata [commandlength]
50 */
51
52 /* Commands */
53
54 #define NEIGHCMD_ADDADDR 1
55
56 /**
57 * Parameter:
58 * addrtypelen [2]
59 * addrtype [addrtypelen]
60 * addrlen [2]
61 * addr [addrlen]
62 */
63
64
65 DEFINE_MUTEX(neighbor_operation_lock);
66
67 char *addrtype = "id";
68 char *addr;
69 int addrlen;
70
71
72 LIST_HEAD(nb_list);
73 struct kmem_cache *nb_slab;
74
75 LIST_HEAD(announce_out_list);
76
77 struct notifier_block netdev_notify;
78
79
80 #define ADDRTYPE_UNKNOWN 0
81 #define ADDRTYPE_ID 1
82
83 static int get_addrtype(__u32 addrtypelen, char *addrtype)
84 {
85 if (addrtypelen == 2 &&
86 (addrtype[0] == 'i' || addrtype[0] == 'I') &&
87 (addrtype[1] == 'd' || addrtype[1] == 'D'))
88 return ADDRTYPE_ID;
89
90 return ADDRTYPE_UNKNOWN;
91 }
92
93 void neighbor_free(struct kref *ref)
94 {
95 struct neighbor *nb = container_of(ref, struct neighbor, ref);
96 printk(KERN_ERR "neighbor free");
97 BUG_ON(nb->nb_list.next != LIST_POISON1);
98 BUG_ON(nb->nb_list.prev != LIST_POISON2);
99 if (nb->addr != 0)
100 kfree(nb->addr);
101 nb->addr = 0;
102 if (nb->dev != 0)
103 dev_put(nb->dev);
104 nb->dev = 0;
105 kmem_cache_free(nb_slab, nb);
106 }
107
108 static struct neighbor *alloc_neighbor(gfp_t allocflags)
109 {
110 struct neighbor *nb = kmem_cache_alloc(nb_slab, allocflags);
111 __u32 seqno;
112
113 if (unlikely(nb == 0))
114 return 0;
115
116 memset(nb, 0, sizeof(struct neighbor));
117
118 kref_init(&(nb->ref));
119 mutex_init(&(nb->cmsg_lock));
120 INIT_LIST_HEAD(&(nb->control_msgs_out));
121 INIT_LIST_HEAD(&(nb->ucontrol_msgs_out));
122 nb->last_ping_time = jiffies;
123 atomic_set(&(nb->ooo_packets), 0);
124 spin_lock_init(&(nb->credits_lock));
125 nb->jiffies_credit_update = nb->last_ping_time;
126 get_random_bytes((char *) &seqno, sizeof(seqno));
127 mutex_init(&(nb->pingcookie_lock));
128 atomic_set(&(nb->latency), 1000000);
129 atomic_set(&(nb->max_remote_cmsg_delay), 1000000);
130 spin_lock_init(&(nb->state_lock));
131 atomic_set(&(nb->kpacket_seqno), seqno);
132 mutex_init(&(nb->conn_list_lock));
133 INIT_LIST_HEAD(&(nb->rcv_conn_list));
134 INIT_LIST_HEAD(&(nb->snd_conn_list));
135 spin_lock_init(&(nb->retrans_lock));
136 INIT_LIST_HEAD(&(nb->retrans_list));
137 INIT_LIST_HEAD(&(nb->retrans_list_conn));
138
139 return nb;
140 }
141
142 struct neighbor *get_neigh_by_mac(struct sk_buff *skb)
143 {
144 struct list_head *currlh;
145 struct neighbor *ret = 0;
146
147
148 char source_hw[MAX_ADDR_LEN];
149 memset(source_hw, 0, MAX_ADDR_LEN);
150 if (skb->dev->header_ops != 0 &&
151 skb->dev->header_ops->parse != 0)
152 skb->dev->header_ops->parse(skb, source_hw);
153
154 mutex_lock(&(neighbor_operation_lock));
155
156 currlh = nb_list.next;
157
158 while (currlh != &nb_list) {
159 struct neighbor *curr = container_of(currlh, struct neighbor,
160 nb_list);
161
162 if (memcmp(curr->mac, source_hw, MAX_ADDR_LEN) == 0) {
163 ret = curr;
164 kref_get(&(ret->ref));
165 break;
166 }
167
168 currlh = currlh->next;
169 }
170
171 mutex_unlock(&(neighbor_operation_lock));
172
173 return ret;
174 }
175
176 struct neighbor *find_neigh(__u16 addrtypelen, __u8 *addrtype,
177 __u16 addrlen, __u8 *addr)
178 {
179 struct list_head *currlh;
180 struct neighbor *ret = 0;
181
182 if (get_addrtype(addrtypelen, addrtype) != ADDRTYPE_ID)
183 return 0;
184
185 mutex_lock(&(neighbor_operation_lock));
186
187 currlh = nb_list.next;
188
189 while (currlh != &nb_list) {
190 struct neighbor *curr = container_of(currlh, struct neighbor,
191 nb_list);
192
193 if (curr->addrlen == addrlen && memcmp(curr->addr, addr,
194 addrlen) == 0) {
195 ret = curr;
196 kref_get(&(ret->ref));
197
198 goto out;
199 }
200
201 currlh = currlh->next;
202 }
203
204 out:
205 mutex_unlock(&(neighbor_operation_lock));
206
207 return ret;
208 }
209
210
211 /*
212 * TODO:
213 *
214 * address flags
215 * credit exchange factor + unstable flag
216 * throughput bound conns: throughput,credits/msecs
217 * latency bound conns: latency (ms), credits/byte
218 */
219 #warning todo extend
220 __u32 generate_neigh_list(char *buf, __u32 buflen, __u32 limit, __u32 offset)
221 {
222 struct list_head *currlh;
223
224 char *p_totalneighs = buf;
225 char *p_response_rows = buf + 4;
226
227 int bufferfull = 0;
228
229 __u32 total = 0;
230 __u32 cnt = 0;
231
232 __u32 buf_offset = 8;
233
234 BUG_ON(buf == 0);
235 BUG_ON(buflen < 8);
236
237 mutex_lock(&(neighbor_operation_lock));
238
239 currlh = nb_list.next;
240
241 while (currlh != &nb_list) {
242 struct neighbor *curr = container_of(currlh, struct neighbor,
243 nb_list);
244
245 __u8 state;
246 unsigned long iflags;
247 /* get_neigh_state not used here because it would deadlock */
248 spin_lock_irqsave( &(curr->state_lock), iflags );
249 state = curr->state;
250 spin_unlock_irqrestore( &(curr->state_lock), iflags );
251
252 if (state != NEIGHBOR_STATE_ACTIVE)
253 goto cont2;
254
255 if (total < offset)
256 goto cont;
257
258 if (unlikely(buflen - buf_offset - 6 - 2 - curr->addrlen < 0))
259 bufferfull = 1;
260
261 if (bufferfull)
262 goto cont;
263
264 put_u16(buf + buf_offset, 1, 1);/* numaddr */
265 buf_offset += 2;
266 put_u16(buf + buf_offset, 2, 1);/* addrtypelen */
267 buf_offset += 2;
268 put_u16(buf + buf_offset, curr->addrlen, 1);/* addren */
269 buf_offset += 2;
270 buf[buf_offset] = 'i'; /* addrtype */
271 buf_offset += 1;
272 buf[buf_offset] = 'd';
273 buf_offset += 1;
274 memcpy(buf + buf_offset, curr->addr, curr->addrlen); /* addr */
275 buf_offset += curr->addrlen;
276
277 BUG_ON(buf_offset > buflen);
278
279 cnt++;
280
281 cont:
282 total++;
283 cont2:
284 currlh = currlh->next;
285 }
286
287 mutex_unlock(&(neighbor_operation_lock));
288
289 put_u32(p_totalneighs, total, 1);
290 put_u32(p_response_rows, cnt, 1);
291
292 return buf_offset;
293 }
294
295 void set_last_routdtrip(struct neighbor *nb, unsigned long time)
296 {
297 unsigned long iflags;
298
299 BUG_ON(nb == 0);
300
301 spin_lock_irqsave( &(nb->state_lock), iflags );
302
303 if(likely(nb->state == NEIGHBOR_STATE_ACTIVE) && time_after(time,
304 nb->state_time.last_roundtrip))
305 nb->state_time.last_roundtrip = time;
306
307 spin_unlock_irqrestore( &(nb->state_lock), iflags );
308 }
309
310 static void _refresh_initial_debitsrate(struct net_device *dev,
311 __u32 debitsrate)
312 {
313 __u32 neighbors = 0;
314 struct list_head *currlh;
315
316 currlh = nb_list.next;
317
318 while (currlh != &nb_list) {
319 struct neighbor *curr = container_of(currlh, struct neighbor,
320 nb_list);
321
322 if (curr->dev == dev)
323 neighbors++;
324
325 currlh = currlh->next;
326 }
327
328 currlh = nb_list.next;
329
330 while (currlh != &nb_list) {
331 struct neighbor *curr = container_of(currlh, struct neighbor,
332 nb_list);
333
334 if (curr->dev == dev)
335 set_debitrate_initial(curr,
336 debitsrate/neighbors);
337
338 currlh = currlh->next;
339 }
340 }
341
342 /* neighbor operation lock has to be held while calling this */
343 static void refresh_initial_debitsrate(void)
344 {
345 struct list_head *currlh1;
346 __u32 ifcnt = 0;
347
348 currlh1 = nb_list.next;
349
350 while (currlh1 != &nb_list) {
351 struct neighbor *curr1 = container_of(currlh1, struct neighbor,
352 nb_list);
353
354 struct list_head *currlh2;
355 currlh2 = nb_list.next;
356 while (currlh2 != currlh1) {
357 struct neighbor *curr2 = container_of(currlh2,
358 struct neighbor, nb_list);
359 if (curr1->dev == curr2->dev)
360 goto present1;
361 }
362
363 ifcnt++;
364
365 present1:
366
367 currlh1 = currlh1->next;
368 }
369
370 currlh1 = nb_list.next;
371
372 while (currlh1 != &nb_list) {
373 struct neighbor *curr1 = container_of(currlh1, struct neighbor,
374 nb_list);
375
376 struct list_head *currlh2;
377 currlh2 = nb_list.next;
378 while (currlh2 != currlh1) {
379 struct neighbor *curr2 = container_of(currlh2,
380 struct neighbor, nb_list);
381 if (curr1->dev == curr2->dev)
382 goto present2;
383 }
384
385 _refresh_initial_debitsrate(curr1->dev,
386 CREDIT_RATE_INITIAL/ifcnt);
387
388 present2:
389
390 currlh1 = currlh1->next;
391 }
392 }
393
394 static void reset_stall_conns(struct neighbor *nb,
395 int stall_time_ms, int resetall)
396 {
397 struct list_head *currlh;
398
399 start:
400 mutex_lock(&(nb->conn_list_lock));
401 currlh = nb->snd_conn_list.next;
402
403 while (currlh != &(nb->snd_conn_list)) {
404 struct conn *sconn = container_of(currlh, struct conn,
405 target.out.nb_list);
406 BUG_ON(sconn->targettype != TARGET_OUT);
407
408 if (resetall || stall_time_ms >=
409 sconn->target.out.stall_timeout_ms) {
410 /**
411 * reset_conn must not be called with conn_list_lock
412 * held
413 */
414 mutex_unlock(&(nb->conn_list_lock));
415 reset_conn(sconn);
416 goto start;
417 }
418 currlh = currlh->next;
419 }
420
421 BUG_ON(list_empty(&(nb->snd_conn_list)) && nb->num_send_conns != 0);
422 mutex_unlock(&(nb->conn_list_lock));
423 }
424
425 static void stall_timer(struct work_struct *work)
426 {
427 struct neighbor *nb = container_of(to_delayed_work(work),
428 struct neighbor, stalltimeout_timer);
429
430 int stall_time_ms;
431 __u8 nbstate;
432
433 int resetall;
434
435 unsigned long iflags;
436
437 spin_lock_irqsave( &(nb->state_lock), iflags );
438 stall_time_ms = jiffies_to_msecs(jiffies -
439 nb->state_time.last_roundtrip);
440 nbstate = nb->state;
441 spin_unlock_irqrestore( &(nb->state_lock), iflags );
442
443 if (unlikely(nbstate != NEIGHBOR_STATE_STALLED)) {
444 nb->str_timer_pending = 0;
445 kref_put(&(nb->ref), neighbor_free);
446 return;
447 }
448
449 resetall = (stall_time_ms > NB_KILL_TIME_MS);
450
451 /*if(resetall)
452 printk(KERN_ERR "reset_all");*/
453
454 reset_stall_conns(nb, stall_time_ms, resetall);
455
456 if (resetall) {
457 spin_lock_irqsave( &(nb->state_lock), iflags );
458 nb->state = NEIGHBOR_STATE_KILLED;
459 spin_unlock_irqrestore( &(nb->state_lock), iflags );
460
461 mutex_lock(&neighbor_operation_lock);
462 list_del(&(nb->nb_list));
463 refresh_initial_debitsrate();
464 mutex_unlock(&neighbor_operation_lock);
465 kref_put(&(nb->ref), neighbor_free); /* nb_list */
466
467 kref_put(&(nb->ref), neighbor_free); /* stall_timer */
468
469 } else {
470 INIT_DELAYED_WORK(&(nb->stalltimeout_timer), stall_timer);
471 schedule_delayed_work(&(nb->stalltimeout_timer),
472 msecs_to_jiffies(STALL_TIMER_INTERVAL_MS));
473 }
474 }
475
476 int get_neigh_state(struct neighbor *nb)
477 {
478 int ret;
479 int switchedtostalled = 0;
480 unsigned long iflags;
481
482 BUG_ON(nb == 0);
483
484 spin_lock_irqsave( &(nb->state_lock), iflags );
485
486 if (unlikely(likely(nb->state == NEIGHBOR_STATE_ACTIVE) && unlikely(
487 time_after_eq(jiffies, nb->state_time.last_roundtrip +
488 msecs_to_jiffies(NB_STALL_TIME_MS)) && (
489 nb->ping_intransit >= NB_STALL_MINPINGS ||
490 nb->ping_intransit >= PING_COOKIES_PER_NEIGH)))) {
491 nb->state = NEIGHBOR_STATE_STALLED;
492 switchedtostalled = 1;
493 printk(KERN_ERR "switched to stalled");
494 BUG_ON(nb->ping_intransit > PING_COOKIES_PER_NEIGH);
495 }
496
497 ret = nb->state;
498
499 spin_unlock_irqrestore( &(nb->state_lock), iflags );
500
501 if (unlikely(switchedtostalled)) {
502 /*printk(KERN_ERR "switched to stalled");*/
503 int pending;
504 spin_lock_irqsave( &(nb->state_lock), iflags );
505 pending = nb->str_timer_pending;
506 spin_unlock_irqrestore( &(nb->state_lock), iflags );
507
508 if (pending == 0) {
509 kref_get(&(nb->ref));
510 INIT_DELAYED_WORK(&(nb->stalltimeout_timer),
511 stall_timer);
512 schedule_delayed_work(&(nb->stalltimeout_timer), 1);
513 }
514 }
515
516 return ret;
517 }
518
519 static struct ping_cookie *find_cookie(struct neighbor *nb, __u32 cookie)
520 {
521 int i;
522
523 for(i=0;i<PING_COOKIES_PER_NEIGH;i++) {
524 if (nb->cookies[i].cookie == cookie)
525 return &(nb->cookies[i]);
526 }
527 return 0;
528 }
529
530 void ping_resp(struct neighbor *nb, __u32 cookie, __u32 respdelay)
531 {
532 struct ping_cookie *c;
533 int i;
534
535 unsigned long cookie_sendtime;
536 __s64 newlatency;
537
538 unsigned long iflags;
539
540 mutex_lock(&(nb->pingcookie_lock));
541
542 c = find_cookie(nb, cookie);
543
544 if (unlikely(c == 0))
545 goto out;
546
547 cookie_sendtime = c->time;
548
549 newlatency = ((((__s64) ((__u32)atomic_read(&(nb->latency)))) * 15 +
550 jiffies_to_usecs(jiffies - c->time) - respdelay) / 16);
551 if (unlikely(newlatency < 0))
552 newlatency = 0;
553 if (unlikely(newlatency > (((__s64)256)*256*256*256 - 1)))
554 newlatency = ((__s64)256)*256*256*256 - 1;
555
556 atomic_set(&(nb->latency), (__u32) newlatency);
557
558 c->cookie = 0;
559 nb->ping_intransit--;
560
561 for(i=0;i<PING_COOKIES_PER_NEIGH;i++) {
562 if (nb->cookies[i].cookie != 0 &&
563 time_before(nb->cookies[i].time, c->time)) {
564 nb->cookies[i].pongs++;
565 if (nb->cookies[i].pongs >= PING_PONGLIMIT) {
566 nb->cookies[i].cookie = 0;
567 nb->cookies[i].pongs = 0;
568 nb->ping_intransit--;
569 }
570 }
571 }
572
573 spin_lock_irqsave( &(nb->state_lock), iflags );
574
575 if (unlikely(nb->state == NEIGHBOR_STATE_INITIAL ||
576 nb->state == NEIGHBOR_STATE_STALLED)) {
577 nb->ping_success++;
578
579 if (nb->state == NEIGHBOR_STATE_INITIAL) {
580 __u64 jiffies64 = get_jiffies_64();
581 if (nb->state_time.last_state_change == 0)
582 nb->state_time.last_state_change = jiffies64;
583 if (jiffies64 <= (nb->state_time.last_state_change +
584 msecs_to_jiffies(INITIAL_TIME_MS)))
585 goto out2;
586 }
587
588 if (nb->ping_success >= PING_SUCCESS_CNT) {
589 /*if (nb->state == NEIGHBOR_STATE_INITIAL)
590 printk(KERN_ERR "switched from initial to active");
591 else
592 printk(KERN_ERR "switched from stalled to active");
593 */
594 nb->state = NEIGHBOR_STATE_ACTIVE;
595 nb->ping_success = 0;
596 nb->state_time.last_roundtrip = jiffies;
597 }
598 } else {
599 nb->state_time.last_roundtrip = cookie_sendtime;
600 }
601
602 out2:
603 spin_unlock_irqrestore( &(nb->state_lock), iflags );
604
605 out:
606 mutex_unlock(&(nb->pingcookie_lock));
607 }
608
609 __u32 add_ping_req(struct neighbor *nb)
610 {
611 struct ping_cookie *c;
612 __u32 i;
613
614 __u32 cookie;
615
616 mutex_lock(&(nb->pingcookie_lock));
617
618 for (i=0;i<PING_COOKIES_PER_NEIGH;i++) {
619 if (nb->cookies[i].cookie == 0)
620 goto found;
621 }
622
623 get_random_bytes((char *) &i, sizeof(i));
624 i = (i % (PING_COOKIES_PER_NEIGH - PING_COOKIES_FIFO)) +
625 PING_COOKIES_FIFO;
626
627 found:
628 c = &(nb->cookies[i]);
629 c->time = jiffies;
630 c->pongs = 0;
631 nb->lastcookie++;
632 if (unlikely(nb->lastcookie == 0))
633 nb->lastcookie++;
634 c->cookie = nb->lastcookie;
635
636 nb->ping_intransit++;
637
638 cookie = c->cookie;
639
640 nb->last_ping_time = jiffies;
641
642 mutex_unlock(&(nb->pingcookie_lock));
643
644 return cookie;
645 }
646
647 void unadd_ping_req(struct neighbor *nb, __u32 cookie)
648 {
649 int i;
650
651 if (cookie == 0)
652 return;
653
654 mutex_lock(&(nb->pingcookie_lock));
655
656 for (i=0;i<PING_COOKIES_PER_NEIGH;i++) {
657 if (nb->cookies[i].cookie == cookie) {
658 nb->cookies[i].cookie = 0;
659 nb->ping_intransit--;
660 break;
661 }
662 }
663
664 mutex_unlock(&(nb->pingcookie_lock));
665 }
666
667 static int neighbor_idle(struct neighbor *nb)
668 {
669 int ret;
670 mutex_lock(&(nb->conn_list_lock));
671 ret = (list_empty(&(nb->rcv_conn_list)) &&
672 list_empty(&(nb->snd_conn_list)));
673 BUG_ON(list_empty(&(nb->snd_conn_list)) && nb->num_send_conns != 0);
674 mutex_unlock(&(nb->conn_list_lock));
675 return ret;
676 }
677
678 /**
679 * Check additional to the checks and timings already done in kpacket_gen.c
680 * This is primarily to make sure that we do not invalidate other ping cookies
681 * which might still receive responses. It does this by requiring a certain
682 * mimimum delay between pings, depending on how many pings are already in
683 * transit.
684 */
685 int time_to_send_ping(struct neighbor *nb)
686 {
687 int rc = 1;
688
689 int state = get_neigh_state(nb);
690 int idle = (state != NEIGHBOR_STATE_ACTIVE ? 0 :
691 neighbor_idle(nb));
692 __u32 forcetime;
693
694 mutex_lock(&(nb->pingcookie_lock));
695 if (nb->ping_intransit >= PING_COOKIES_NOTHROTTLE) {
696 __u32 mindelay = (( ((__u32) atomic_read(&(nb->latency))) +
697 ((__u32) atomic_read(
698 &(nb->max_remote_cmsg_delay))) )/1000) <<
699 (nb->ping_intransit + 1 -
700 PING_COOKIES_NOTHROTTLE);
701
702 if (mindelay > PING_THROTTLE_LIMIT_MS)
703 mindelay = PING_THROTTLE_LIMIT_MS;
704
705 if (jiffies_to_msecs(jiffies - nb->last_ping_time) < mindelay)
706 rc = 0;
707 }
708
709 if (unlikely(state != NEIGHBOR_STATE_ACTIVE) ||
710 nb->ping_intransit != 0)
711 forcetime = PING_FORCETIME_MS;
712 else if (idle)
713 forcetime = PING_FORCETIME_ACTIVEIDLE_MS;
714 else
715 forcetime = PING_FORCETIME_ACTIVE_MS;
716
717 if (jiffies_to_msecs(jiffies - nb->last_ping_time) < (forcetime/2))
718 rc = 0;
719 else if (jiffies_to_msecs(jiffies - nb->last_ping_time) >= forcetime)
720 rc = 2;
721
722 mutex_unlock(&(nb->pingcookie_lock));
723
724 return rc;
725 }
726
727 static void add_neighbor(struct neighbor *nb)
728 {
729 struct list_head *currlh = nb_list.next;
730
731 BUG_ON((nb->addr == 0) != (nb->addrlen == 0));
732
733 while (currlh != &nb_list) {
734 struct neighbor *curr = container_of(currlh, struct neighbor,
735 nb_list);
736
737 if (curr->addrlen == nb->addrlen && memcmp(curr->addr, nb->addr,
738 curr->addrlen) == 0)
739 goto already_present;
740
741 currlh = currlh->next;
742 }
743
744 /* kref_get not needed here, because the caller leaves its ref to us */
745 printk(KERN_ERR "add_neigh");
746
747 list_add_tail(&(nb->nb_list), &nb_list);
748 refresh_initial_debitsrate();
749 schedule_controlmsg_timerfunc(nb);
750 INIT_DELAYED_WORK(&(nb->retrans_timer), retransmit_timerfunc);
751 INIT_DELAYED_WORK(&(nb->retrans_timer_conn), retransmit_conn_timerfunc);
752
753 if (0) {
754 already_present:
755 kmem_cache_free(nb_slab, nb);
756 }
757 }
758
759 static __u32 pull_u32(struct sk_buff *skb, int convbo)
760 {
761 char *ptr = cor_pull_skb(skb, 4);
762
763 __u32 ret = 0;
764
765 BUG_ON(0 == ptr);
766
767 ((char *)&ret)[0] = ptr[0];
768 ((char *)&ret)[1] = ptr[1];
769 ((char *)&ret)[2] = ptr[2];
770 ((char *)&ret)[3] = ptr[3];
771
772 if (convbo)
773 return be32_to_cpu(ret);
774 return ret;
775 }
776
777 static int apply_announce_addaddr(struct neighbor *nb, __u32 cmd, __u32 len,
778 char *cmddata)
779 {
780 __u16 addrtypelen;
781 char *addrtype;
782 __u16 addrlen;
783 char *addr;
784
785 BUG_ON((nb->addr == 0) != (nb->addrlen == 0));
786
787 if (nb->addr != 0)
788 return 0;
789
790 if (len < 4)
791 return 0;
792
793 addrtypelen = be16_to_cpu(*((__u16 *) cmddata));
794 cmddata += 2;
795 len -= 2;
796
797 if (len < 2)
798 return 0;
799
800 addrlen = be16_to_cpu(*((__u16 *) cmddata));
801 cmddata += 2;
802 len -= 2;
803
804 addrtype = cmddata;
805 cmddata += addrtypelen;
806 len -= addrtypelen;
807
808 addr = cmddata;
809 cmddata += addrlen;
810 len -= addrlen;
811
812 if (len < 0)
813 return 0;
814
815 if (get_addrtype(addrtypelen, addrtype) != ADDRTYPE_ID)
816 return 0;
817
818 nb->addr = kmalloc(addrlen, GFP_KERNEL);
819 if (unlikely(nb->addr == 0))
820 return 1;
821
822 memcpy(nb->addr, addr, addrlen);
823 nb->addrlen = addrlen;
824
825 return 0;
826 }
827
828 static void apply_announce_cmd(struct neighbor *nb, __u32 cmd, __u32 len,
829 char *cmddata)
830 {
831 if (cmd == NEIGHCMD_ADDADDR) {
832 apply_announce_addaddr(nb, cmd, len, cmddata);
833 } else {
834 /* ignore unknown cmds */
835 }
836 }
837
838 static void apply_announce_cmds(char *msg, __u32 len, struct net_device *dev,
839 char *source_hw)
840 {
841 struct neighbor *nb = alloc_neighbor(GFP_KERNEL);
842
843 if (unlikely(nb == 0))
844 return;
845
846 while (len >= 8) {
847 __u32 cmd;
848 __u32 cmdlen;
849
850 cmd = be32_to_cpu(*((__u32 *) msg));
851 msg += 4;
852 len -= 4;
853 cmdlen = be32_to_cpu(*((__u32 *) msg));
854 msg += 4;
855 len -= 4;
856
857 BUG_ON(cmdlen > len);
858
859 apply_announce_cmd(nb, cmd, cmdlen, msg);
860
861 msg += cmdlen;
862 len -= cmdlen;
863 }
864
865 BUG_ON(len != 0);
866
867 memcpy(nb->mac, source_hw, MAX_ADDR_LEN);
868
869 dev_hold(dev);
870 nb->dev = dev;
871 add_neighbor(nb);
872 }
873
874 static int check_announce_cmds(char *msg, __u32 len)
875 {
876 while (len >= 8) {
877 __u32 cmd;
878 __u32 cmdlen;
879
880 cmd = be32_to_cpu(*((__u32 *) msg));
881 msg += 4;
882 len -= 4;
883 cmdlen = be32_to_cpu(*((__u32 *) msg));
884 msg += 4;
885 len -= 4;
886
887 /* malformated packet */
888 if (unlikely(cmdlen > len))
889 return 1;
890
891 msg += cmdlen;
892 len -= cmdlen;
893 }
894
895 if (unlikely(len != 0))
896 return 1;
897
898 return 0;
899 }
900
901 static void parse_announce(char *msg, __u32 len, struct net_device *dev,
902 char *source_hw)
903 {
904 __u32 min_announce_version;
905 __u32 max_announce_version;
906 __u32 min_cor_version;
907 __u32 max_cor_version;
908
909 if (unlikely(len < 16))
910 return;
911
912 min_announce_version = be32_to_cpu(*((__u32 *) msg));
913 msg += 4;
914 len -= 4;
915 max_announce_version = be32_to_cpu(*((__u32 *) msg));
916 msg += 4;
917 len -= 4;
918 min_cor_version = be32_to_cpu(*((__u32 *) msg));
919 msg += 4;
920 len -= 4;
921 max_cor_version = be32_to_cpu(*((__u32 *) msg));
922 msg += 4;
923 len -= 4;
924
925 if (min_announce_version != 0)
926 return;
927 if (min_cor_version != 0)
928 return;
929 if (check_announce_cmds(msg, len)) {
930 return;
931 }
932 apply_announce_cmds(msg, len, dev, source_hw);
933 }
934
935 struct announce_in {
936 /* lh has to be first */
937 struct list_head lh;
938 struct sk_buff_head skbs; /* sorted by offset */
939 struct net_device *dev;
940 char source_hw[MAX_ADDR_LEN];
941 __u32 announce_proto_version;
942 __u32 packet_version;
943 __u32 total_size;
944 __u32 received_size;
945 __u64 last_received_packet;
946 };
947
948 LIST_HEAD(announce_list);
949
950 struct kmem_cache *announce_in_slab;
951
952 static void merge_announce(struct announce_in *ann)
953 {
954 char *msg = kmalloc(ann->total_size, GFP_KERNEL);
955 __u32 copy = 0;
956
957 if (msg == 0) {
958 /* try again when next packet arrives */
959 return;
960 }
961
962 while (copy != ann->total_size) {
963 __u32 currcpy;
964 __u32 offset = 0;
965 struct sk_buff *skb;
966 struct skb_procstate *ps;
967
968 if (unlikely(skb_queue_empty(&(ann->skbs)))) {
969 printk(KERN_ERR "net/cor/neighbor.c: sk_head ran "
970 "empty while merging packets\n");
971 goto free;
972 }
973
974 skb = skb_dequeue(&(ann->skbs));
975 ps = skb_pstate(skb);
976
977 currcpy = skb->len;
978 if (unlikely(ps->funcstate.announce.offset > copy)) {
979 printk(KERN_ERR "net/cor/neighbor.c: invalid offset"
980 "value found\n");
981 goto free;
982 }
983
984 if (unlikely(ps->funcstate.announce.offset < copy)) {
985 offset = copy - ps->funcstate.announce.offset;
986 currcpy -= offset;
987 }
988
989 if (unlikely(currcpy + copy > ann->total_size))
990 goto free;
991
992 memcpy(msg + copy, skb->data + offset, currcpy);
993 copy += currcpy;
994 kfree_skb(skb);
995 }
996
997 parse_announce(msg, ann->total_size, ann->dev, ann->source_hw);
998
999 free:
1000 if (msg != 0)
1001 kfree(msg);
1002
1003 dev_put(ann->dev);
1004 list_del(&(ann->lh));
1005 kmem_cache_free(announce_in_slab, ann);
1006 }
1007
1008 static int _rcv_announce(struct sk_buff *skb, struct announce_in *ann)
1009 {
1010 struct skb_procstate *ps = skb_pstate(skb);
1011
1012 __u32 offset = ps->funcstate.announce.offset;
1013 __u32 len = skb->len;
1014
1015 __u32 curroffset = 0;
1016 __u32 prevoffset = 0;
1017 __u32 prevlen = 0;
1018
1019 struct sk_buff *curr = ann->skbs.next;
1020
1021 if (unlikely(len + offset > ann->total_size)) {
1022 /* invalid header */
1023 kfree_skb(skb);
1024 return 0;
1025 }
1026
1027 /**
1028 * Try to find the right place to insert in the sorted list. This
1029 * means to process the list until we find a skb which has a greater
1030 * offset, so we can insert before it to keep the sort order. However,
1031 * this is complicated by the fact that the new skb must not be inserted
1032 * between 2 skbs if there is no data missing in between. So the loop
1033 * runs has to keep running until there is either a gap to insert or
1034 * we see that this data has already been received.
1035 */
1036 while ((void *) curr != (void *) &(ann->skbs)) {
1037 struct skb_procstate *currps = skb_pstate(skb);
1038
1039 curroffset = currps->funcstate.announce.offset;
1040
1041 if (curroffset > offset && (prevoffset + prevlen) < curroffset)
1042 break;
1043
1044 prevoffset = curroffset;
1045 prevlen = curr->len;
1046 curr = curr->next;
1047
1048 if ((offset+len) <= (prevoffset+prevlen)) {
1049 /* we already have this data */
1050 kfree_skb(skb);
1051 return 0;
1052 }
1053 }
1054
1055 /**
1056 * Calculate how much data was really received, by substracting
1057 * the bytes we already have.
1058 */
1059 if (unlikely(prevoffset + prevlen > offset)) {
1060 len -= (prevoffset + prevlen) - offset;
1061 offset = prevoffset + prevlen;
1062 }
1063
1064 if (unlikely((void *) curr != (void *) &(ann->skbs) &&
1065 (offset + len) > curroffset))
1066 len = curroffset - offset;
1067
1068 ann->received_size += len;
1069 BUG_ON(ann->received_size > ann->total_size);
1070 __skb_queue_before(&(ann->skbs), curr, skb);
1071 ann->last_received_packet = get_jiffies_64();
1072
1073 if (ann->received_size == ann->total_size)
1074 merge_announce(ann);
1075 else if (unlikely(ann->skbs.qlen >= 16))
1076 return 1;
1077
1078 return 0;
1079 }
1080
1081 void rcv_announce(struct sk_buff *skb)
1082 {
1083 struct skb_procstate *ps = skb_pstate(skb);
1084 struct announce_in *curr = 0;
1085 struct announce_in *leastactive = 0;
1086 __u32 list_size = 0;
1087
1088 __u32 announce_proto_version = pull_u32(skb, 1);
1089 __u32 packet_version = pull_u32(skb, 1);
1090 __u32 total_size = pull_u32(skb, 1);
1091
1092 char source_hw[MAX_ADDR_LEN];
1093 memset(source_hw, 0, MAX_ADDR_LEN);
1094 if (skb->dev->header_ops != 0 &&
1095 skb->dev->header_ops->parse != 0)
1096 skb->dev->header_ops->parse(skb, source_hw);
1097
1098 ps->funcstate.announce.offset = pull_u32(skb, 1);
1099
1100 if (total_size > 8192)
1101 goto discard;
1102
1103 mutex_lock(&(neighbor_operation_lock));
1104
1105 if (announce_proto_version != 0)
1106 goto discard;
1107
1108 curr = (struct announce_in *) announce_list.next;
1109
1110 while (((struct list_head *) curr) != &(announce_list)) {
1111 list_size++;
1112 if (curr->dev == skb->dev && memcmp(curr->source_hw, source_hw,
1113 MAX_ADDR_LEN) == 0 &&
1114 curr->announce_proto_version ==
1115 announce_proto_version &&
1116 curr->packet_version == packet_version &&
1117 curr->total_size == total_size)
1118 goto found;
1119
1120 if (leastactive == 0 || curr->last_received_packet <
1121 leastactive->last_received_packet)
1122 leastactive = curr;
1123
1124 curr = (struct announce_in *) curr->lh.next;
1125 }
1126
1127 if (list_size >= 128) {
1128 BUG_ON(leastactive == 0);
1129 curr = leastactive;
1130
1131 curr->last_received_packet = get_jiffies_64();
1132
1133 while (!skb_queue_empty(&(curr->skbs))) {
1134 struct sk_buff *skb2 = skb_dequeue(&(curr->skbs));
1135 kfree_skb(skb2);
1136 }
1137
1138 dev_put(curr->dev);
1139 } else {
1140 curr = kmem_cache_alloc(announce_in_slab,
1141 GFP_KERNEL);
1142 if (curr == 0)
1143 goto discard;
1144
1145 skb_queue_head_init(&(curr->skbs));
1146 list_add_tail((struct list_head *) curr, &announce_list);
1147 }
1148
1149 curr->packet_version = packet_version;
1150 curr->total_size = total_size;
1151 curr->received_size = 0;
1152 curr->announce_proto_version = announce_proto_version;
1153 curr->dev = skb->dev;
1154 dev_hold(curr->dev);
1155 memcpy(curr->source_hw, source_hw, MAX_ADDR_LEN);
1156
1157 found:
1158 if (_rcv_announce(skb, curr)) {
1159 list_del((struct list_head *) curr);
1160 dev_put(curr->dev);
1161 kmem_cache_free(announce_in_slab, curr);
1162 }
1163
1164 if (0) {
1165 discard:
1166 kfree_skb(skb);
1167 }
1168
1169 mutex_unlock(&(neighbor_operation_lock));
1170 }
1171
1172 struct announce{
1173 struct kref ref;
1174
1175 __u32 packet_version;
1176 char *announce_msg;
1177 __u32 announce_msg_len;
1178 };
1179
1180 struct announce *last_announce;
1181
1182 static int send_announce_chunk(struct announce_data *ann)
1183 {
1184 struct sk_buff *skb;
1185 __u32 packet_size = 256;
1186 __u32 remainingdata = ann->ann->announce_msg_len -
1187 ann->curr_announce_msg_offset;
1188 __u32 headroom = LL_ALLOCATED_SPACE(ann->dev);
1189 __u32 overhead = 17 + headroom;
1190 char *header;
1191 char *ptr;
1192 int rc = 0;
1193
1194 if (remainingdata < packet_size)
1195 packet_size = remainingdata;
1196
1197 skb = alloc_skb(packet_size + overhead, GFP_KERNEL);
1198 if (unlikely(skb == 0))
1199 return 0;
1200
1201 skb->protocol = htons(ETH_P_COR);
1202 skb->dev = ann->dev;
1203 skb_reserve(skb, headroom);
1204
1205 if(unlikely(dev_hard_header(skb, ann->dev, ETH_P_COR,
1206 ann->dev->broadcast, ann->dev->dev_addr, skb->len) < 0))
1207 goto out_err;
1208
1209 skb_reset_network_header(skb);
1210
1211 header = skb_put(skb, 17);
1212 if (unlikely(header == 0))
1213 goto out_err;
1214
1215 header[0] = PACKET_TYPE_ANNOUNCE;
1216
1217 put_u32(header + 1, 0, 1); /* announce proto version */
1218 put_u32(header + 5, ann->ann->packet_version, 1); /* packet version */
1219 put_u32(header + 9, ann->ann->announce_msg_len, 1); /* total size */
1220 put_u32(header + 13, ann->curr_announce_msg_offset, 1); /* offset */
1221
1222 ptr = skb_put(skb, packet_size);
1223 if (unlikely(ptr == 0))
1224 goto out_err;
1225
1226 memcpy(ptr, ann->ann->announce_msg + ann->curr_announce_msg_offset,
1227 packet_size);
1228
1229 rc = dev_queue_xmit(skb);
1230
1231 if (rc == 0) {
1232 ann->curr_announce_msg_offset += packet_size;
1233
1234 if (ann->curr_announce_msg_offset == ann->ann->announce_msg_len)
1235 ann->curr_announce_msg_offset = 0;
1236 }
1237
1238 if (0) {
1239 out_err:
1240 if (skb != 0)
1241 kfree_skb(skb);
1242 }
1243
1244 return rc;
1245 }
1246
1247 int send_announce_qos(struct announce_data *ann)
1248 {
1249 int rc;
1250 mutex_lock(&(neighbor_operation_lock));
1251 rc = send_announce_chunk(ann);
1252 mutex_unlock(&(neighbor_operation_lock));
1253 return rc;
1254 }
1255
1256 static void announce_free(struct kref *ref)
1257 {
1258 struct announce *ann = container_of(ref, struct announce, ref);
1259 kfree(&(ann->announce_msg));
1260 kfree(ann);
1261 }
1262
1263 void announce_data_free(struct kref *ref)
1264 {
1265 struct announce_data *ann = container_of(ref, struct announce_data,
1266 ref);
1267 if (ann->ann != 0)
1268 kref_put(&(ann->ann->ref), announce_free);
1269 kfree(ann);
1270 }
1271
1272 static void send_announce(struct work_struct *work)
1273 {
1274 struct announce_data *ann = container_of(to_delayed_work(work),
1275 struct announce_data, announce_work);
1276 int reschedule = 0;
1277 int rc = 0;
1278
1279 mutex_lock(&(neighbor_operation_lock));
1280
1281 if (unlikely(ann->dev == 0))
1282 goto out;
1283 reschedule = 1;
1284
1285 if (unlikely(ann->ann == 0 && last_announce == 0))
1286 goto out;
1287 if (ann->curr_announce_msg_offset == 0 &&
1288 unlikely(ann->ann != last_announce)) {
1289 if (ann->ann != 0)
1290 kref_put(&(ann->ann->ref), announce_free);
1291 ann->ann = last_announce;
1292 kref_get(&(ann->ann->ref));
1293 }
1294
1295 rc = send_announce_chunk(ann);
1296
1297 out:
1298 mutex_unlock(&(neighbor_operation_lock));
1299
1300 if (rc != 0)
1301 qos_enqueue(ann->dev, &(ann->rb), QOS_CALLER_ANNOUNCE);
1302
1303 if (unlikely(reschedule == 0)) {
1304 kref_put(&(ann->ref), announce_data_free);
1305 } else {
1306 __u64 jiffies = get_jiffies_64();
1307 int delay;
1308
1309 ann->scheduled_announce_timer += msecs_to_jiffies(
1310 ANNOUNCE_SEND_PACKETINTELVAL_MS);
1311
1312 delay = ann->scheduled_announce_timer - jiffies;
1313 if (delay < 0)
1314 delay = 0;
1315
1316 INIT_DELAYED_WORK(&(ann->announce_work), send_announce);
1317 schedule_delayed_work(&(ann->announce_work), delay);
1318 }
1319 }
1320
1321 static struct announce_data *get_announce_by_netdev(struct net_device *dev)
1322 {
1323 struct list_head *lh = announce_out_list.next;
1324
1325 while (lh != &announce_out_list) {
1326 struct announce_data *curr = (struct announce_data *)(
1327 ((char *) lh) -
1328 offsetof(struct announce_data, lh));
1329
1330 if (curr->dev == dev)
1331 return curr;
1332 }
1333
1334 return 0;
1335 }
1336
1337 static void announce_send_adddev(struct net_device *dev)
1338 {
1339 struct announce_data *ann;
1340
1341 ann = kmalloc(sizeof(struct announce_data), GFP_KERNEL);
1342
1343 if (unlikely(ann == 0)) {
1344 printk(KERN_ERR "cor cannot allocate memory for sending "
1345 "announces");
1346 return;
1347 }
1348
1349 memset(ann, 0, sizeof(struct announce_data));
1350
1351 kref_init(&(ann->ref));
1352
1353 dev_hold(dev);
1354 ann->dev = dev;
1355
1356 mutex_lock(&(neighbor_operation_lock));
1357 list_add_tail(&(ann->lh), &announce_out_list);
1358 mutex_unlock(&(neighbor_operation_lock));
1359
1360 ann->scheduled_announce_timer = get_jiffies_64();
1361 INIT_DELAYED_WORK(&(ann->announce_work), send_announce);
1362 schedule_delayed_work(&(ann->announce_work), 1);
1363 }
1364
1365 static void announce_send_rmdev(struct net_device *dev)
1366 {
1367 struct announce_data *ann;
1368
1369 mutex_lock(&(neighbor_operation_lock));
1370
1371 ann = get_announce_by_netdev(dev);
1372
1373 if (ann == 0)
1374 goto out;
1375
1376 dev_put(ann->dev);
1377 ann->dev = 0;
1378
1379 out:
1380 mutex_unlock(&(neighbor_operation_lock));
1381 }
1382
1383 int netdev_notify_func(struct notifier_block *not, unsigned long event,
1384 void *ptr)
1385 {
1386 struct net_device *dev = (struct net_device *) ptr;
1387 int rc;
1388
1389 switch(event){
1390 case NETDEV_UP:
1391 rc = create_queue(dev);
1392 if (rc == 1)
1393 return 1;
1394 announce_send_adddev(dev);
1395 break;
1396 case NETDEV_DOWN:
1397 destroy_queue(dev);
1398 announce_send_rmdev(dev);
1399 break;
1400 case NETDEV_REBOOT:
1401 case NETDEV_CHANGE:
1402 case NETDEV_REGISTER:
1403 case NETDEV_UNREGISTER:
1404 case NETDEV_CHANGEMTU:
1405 case NETDEV_CHANGEADDR:
1406 case NETDEV_GOING_DOWN:
1407 case NETDEV_CHANGENAME:
1408 case NETDEV_FEAT_CHANGE:
1409 case NETDEV_BONDING_FAILOVER:
1410 break;
1411 default:
1412 return 1;
1413 }
1414
1415 return 0;
1416 }
1417
1418 static int set_announce(char *msg, __u32 len)
1419 {
1420 struct announce *ann = kmalloc(sizeof(struct announce), GFP_KERNEL);
1421
1422 if (unlikely(ann == 0)) {
1423 kfree(msg);
1424 return 1;
1425 }
1426
1427 memset(ann, 0, sizeof(struct announce));
1428
1429 ann->announce_msg = msg;
1430 ann->announce_msg_len = len;
1431
1432 kref_init(&(ann->ref));
1433
1434 mutex_lock(&(neighbor_operation_lock));
1435
1436 if (last_announce != 0) {
1437 ann->packet_version = last_announce->packet_version + 1;
1438 kref_put(&(last_announce->ref), announce_free);
1439 }
1440
1441 last_announce = ann;
1442
1443 mutex_unlock(&(neighbor_operation_lock));
1444
1445 return 0;
1446 }
1447
1448 static int generate_announce(void)
1449 {
1450 __u32 addrtypelen = strlen(addrtype);
1451
1452 __u32 hdr_len = 16;
1453 __u32 cmd_hdr_len = 8;
1454 __u32 cmd_len = 2 + 2 + addrtypelen + addrlen;
1455
1456 __u32 len = hdr_len + cmd_hdr_len + cmd_len;
1457 __u32 offset = 0;
1458
1459 char *msg = kmalloc(len, GFP_KERNEL);
1460 if (unlikely(msg == 0))
1461 return 1;
1462
1463 put_u32(msg + offset, 0, 1); /* min_announce_proto_version */
1464 offset += 4;
1465 put_u32(msg + offset, 0, 1); /* max_announce_proto_version */
1466 offset += 4;
1467 put_u32(msg + offset, 0, 1); /* min_cor_proto_version */
1468 offset += 4;
1469 put_u32(msg + offset, 0, 1); /* max_cor_proto_version */
1470 offset += 4;
1471
1472
1473 put_u32(msg + offset, NEIGHCMD_ADDADDR, 1); /* command */
1474 offset += 4;
1475 put_u32(msg + offset, cmd_len, 1); /* command length */
1476 offset += 4;
1477
1478 /* addrtypelen, addrlen */
1479 put_u16(msg + offset, addrtypelen, 1);
1480 offset += 2;
1481 put_u16(msg + offset, addrlen, 1);
1482 offset += 2;
1483
1484 /* addrtype, addr */
1485 memcpy(msg + offset, addrtype, addrtypelen);
1486 offset += addrtypelen;
1487 memcpy(msg + offset, addr, addrlen);
1488 offset += addrlen;
1489
1490 BUG_ON(offset != len);
1491
1492 return set_announce(msg, len);
1493 }
1494
1495 int __init cor_neighbor_init(void)
1496 {
1497 addrlen = 16;
1498
1499 addr = kmalloc(addrlen, GFP_KERNEL);
1500 if (unlikely(addr == 0))
1501 goto error_free2;
1502
1503 get_random_bytes(addr, addrlen);
1504
1505 nb_slab = kmem_cache_create("cor_neighbor", sizeof(struct neighbor), 8,
1506 0, 0);
1507 announce_in_slab = kmem_cache_create("cor_announce_in",
1508 sizeof(struct announce_in), 8, 0, 0);
1509
1510 if (unlikely(generate_announce()))
1511 goto error_free1;
1512
1513 memset(&netdev_notify, 0, sizeof(netdev_notify));
1514 netdev_notify.notifier_call = netdev_notify_func;
1515 register_netdevice_notifier(&netdev_notify);
1516
1517 return 0;
1518
1519 error_free1:
1520 kfree(addr);
1521
1522 error_free2:
1523 return -ENOMEM;
1524 }
1525
1526 MODULE_LICENSE("GPL");
connection oriented routing - ARCHIVE NO UPDATES HERE