1 /*
2 * lec.c: Lan Emulation driver
3 * Marko Kiiskila mkiiskila@yahoo.com
4 *
5 */
6
7 #include <linux/config.h>
8 #include <linux/kernel.h>
9 #include <linux/bitops.h>
10
11 /* We are ethernet device */
12 #include <linux/if_ether.h>
13 #include <linux/netdevice.h>
14 #include <linux/etherdevice.h>
15 #include <net/sock.h>
16 #include <linux/skbuff.h>
17 #include <linux/ip.h>
18 #include <asm/byteorder.h>
19 #include <asm/uaccess.h>
20 #include <net/arp.h>
21 #include <net/dst.h>
22 #include <linux/proc_fs.h>
23 #include <linux/spinlock.h>
24 #include <linux/proc_fs.h>
25 #include <linux/seq_file.h>
26
27 /* TokenRing if needed */
28 #ifdef CONFIG_TR
29 #include <linux/trdevice.h>
30 #endif
31
32 /* And atm device */
33 #include <linux/atmdev.h>
34 #include <linux/atmlec.h>
35
36 /* Proxy LEC knows about bridging */
37 #if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
38 #include <linux/if_bridge.h>
39 #include "../bridge/br_private.h"
40 static unsigned char bridge_ula_lec[] = {0x01, 0x80, 0xc2, 0x00, 0x00};
41
42 extern struct net_bridge_fdb_entry *(*br_fdb_get_hook)(struct net_bridge *br,
43 unsigned char *addr);
44 extern void (*br_fdb_put_hook)(struct net_bridge_fdb_entry *ent);
45 #endif
46
47 /* Modular too */
48 #include <linux/module.h>
49 #include <linux/init.h>
50
51 #include "lec.h"
52 #include "lec_arpc.h"
53 #include "resources.h"
54
55 #if 0
56 #define DPRINTK printk
57 #else
58 #define DPRINTK(format,args...)
59 #endif
60
61 #define DUMP_PACKETS 0 /* 0 = None,
62 * 1 = 30 first bytes
63 * 2 = Whole packet
64 */
65
66 #define LEC_UNRES_QUE_LEN 8 /* number of tx packets to queue for a
67 single destination while waiting for SVC */
68
69 static int lec_open(struct net_device *dev);
70 static int lec_start_xmit(struct sk_buff *skb, struct net_device *dev);
71 static int lec_close(struct net_device *dev);
72 static struct net_device_stats *lec_get_stats(struct net_device *dev);
73 static void lec_init(struct net_device *dev);
74 static struct lec_arp_table* lec_arp_find(struct lec_priv *priv,
75 unsigned char *mac_addr);
76 static int lec_arp_remove(struct lec_priv *priv,
77 struct lec_arp_table *to_remove);
78 /* LANE2 functions */
79 static void lane2_associate_ind (struct net_device *dev, u8 *mac_address,
80 u8 *tlvs, u32 sizeoftlvs);
81 static int lane2_resolve(struct net_device *dev, u8 *dst_mac, int force,
82 u8 **tlvs, u32 *sizeoftlvs);
83 static int lane2_associate_req (struct net_device *dev, u8 *lan_dst,
84 u8 *tlvs, u32 sizeoftlvs);
85
86 static struct lane2_ops lane2_ops = {
87 lane2_resolve, /* resolve, spec 3.1.3 */
88 lane2_associate_req, /* associate_req, spec 3.1.4 */
89 NULL /* associate indicator, spec 3.1.5 */
90 };
91
92 static unsigned char bus_mac[ETH_ALEN] = {0xff,0xff,0xff,0xff,0xff,0xff};
93
94 /* Device structures */
95 static struct net_device *dev_lec[MAX_LEC_ITF];
96
97 /* This will be called from proc.c via function pointer */
98 struct net_device *get_dev_lec(int itf)
99 {
100 struct net_device *dev;
101
102 if (itf >= MAX_LEC_ITF)
103 return NULL;
104 rtnl_lock();
105 dev = dev_lec[itf];
106 if (dev)
107 dev_hold(dev);
108 rtnl_unlock();
109 return dev;
110 }
111
112 #if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
113 static void lec_handle_bridge(struct sk_buff *skb, struct net_device *dev)
114 {
115 struct ethhdr *eth;
116 char *buff;
117 struct lec_priv *priv;
118
119 /* Check if this is a BPDU. If so, ask zeppelin to send
120 * LE_TOPOLOGY_REQUEST with the same value of Topology Change bit
121 * as the Config BPDU has */
122 eth = (struct ethhdr *)skb->data;
123 buff = skb->data + skb->dev->hard_header_len;
124 if (*buff++ == 0x42 && *buff++ == 0x42 && *buff++ == 0x03) {
125 struct sk_buff *skb2;
126 struct atmlec_msg *mesg;
127
128 skb2 = alloc_skb(sizeof(struct atmlec_msg), GFP_ATOMIC);
129 if (skb2 == NULL) return;
130 skb2->len = sizeof(struct atmlec_msg);
131 mesg = (struct atmlec_msg *)skb2->data;
132 mesg->type = l_topology_change;
133 buff += 4;
134 mesg->content.normal.flag = *buff & 0x01; /* 0x01 is topology change */
135
136 priv = (struct lec_priv *)dev->priv;
137 atm_force_charge(priv->lecd, skb2->truesize);
138 skb_queue_tail(&priv->lecd->sk->sk_receive_queue, skb2);
139 priv->lecd->sk->sk_data_ready(priv->lecd->sk, skb2->len);
140 }
141
142 return;
143 }
144 #endif /* defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE) */
145
146 /*
147 * Modelled after tr_type_trans
148 * All multicast and ARE or STE frames go to BUS.
149 * Non source routed frames go by destination address.
150 * Last hop source routed frames go by destination address.
151 * Not last hop source routed frames go by _next_ route descriptor.
152 * Returns pointer to destination MAC address or fills in rdesc
153 * and returns NULL.
154 */
155 #ifdef CONFIG_TR
156 unsigned char *get_tr_dst(unsigned char *packet, unsigned char *rdesc)
157 {
158 struct trh_hdr *trh;
159 int riflen, num_rdsc;
160
161 trh = (struct trh_hdr *)packet;
162 if (trh->daddr[0] & (uint8_t)0x80)
163 return bus_mac; /* multicast */
164
165 if (trh->saddr[0] & TR_RII) {
166 riflen = (ntohs(trh->rcf) & TR_RCF_LEN_MASK) >> 8;
167 if ((ntohs(trh->rcf) >> 13) != 0)
168 return bus_mac; /* ARE or STE */
169 }
170 else
171 return trh->daddr; /* not source routed */
172
173 if (riflen < 6)
174 return trh->daddr; /* last hop, source routed */
175
176 /* riflen is 6 or more, packet has more than one route descriptor */
177 num_rdsc = (riflen/2) - 1;
178 memset(rdesc, 0, ETH_ALEN);
179 /* offset 4 comes from LAN destination field in LE control frames */
180 if (trh->rcf & htons((uint16_t)TR_RCF_DIR_BIT))
181 memcpy(&rdesc[4], &trh->rseg[num_rdsc-2], sizeof(uint16_t));
182 else {
183 memcpy(&rdesc[4], &trh->rseg[1], sizeof(uint16_t));
184 rdesc[5] = ((ntohs(trh->rseg[0]) & 0x000f) | (rdesc[5] & 0xf0));
185 }
186
187 return NULL;
188 }
189 #endif /* CONFIG_TR */
190
191 /*
192 * Open/initialize the netdevice. This is called (in the current kernel)
193 * sometime after booting when the 'ifconfig' program is run.
194 *
195 * This routine should set everything up anew at each open, even
196 * registers that "should" only need to be set once at boot, so that
197 * there is non-reboot way to recover if something goes wrong.
198 */
199
200 static int
201 lec_open(struct net_device *dev)
202 {
203 struct lec_priv *priv = (struct lec_priv *)dev->priv;
204
205 netif_start_queue(dev);
206 memset(&priv->stats,0,sizeof(struct net_device_stats));
207
208 return 0;
209 }
210
211 static __inline__ void
212 lec_send(struct atm_vcc *vcc, struct sk_buff *skb, struct lec_priv *priv)
213 {
214 ATM_SKB(skb)->vcc = vcc;
215 ATM_SKB(skb)->atm_options = vcc->atm_options;
216
217 atomic_add(skb->truesize, &vcc->sk->sk_wmem_alloc);
218 if (vcc->send(vcc, skb) < 0) {
219 priv->stats.tx_dropped++;
220 return;
221 }
222
223 priv->stats.tx_packets++;
224 priv->stats.tx_bytes += skb->len;
225 }
226
227 static void
228 lec_tx_timeout(struct net_device *dev)
229 {
230 printk(KERN_INFO "%s: tx timeout\n", dev->name);
231 dev->trans_start = jiffies;
232 netif_wake_queue(dev);
233 }
234
235 static int
236 lec_start_xmit(struct sk_buff *skb, struct net_device *dev)
237 {
238 struct sk_buff *skb2;
239 struct lec_priv *priv = (struct lec_priv *)dev->priv;
240 struct lecdatahdr_8023 *lec_h;
241 struct atm_vcc *vcc;
242 struct lec_arp_table *entry;
243 unsigned char *dst;
244 int min_frame_size;
245 #ifdef CONFIG_TR
246 unsigned char rdesc[ETH_ALEN]; /* Token Ring route descriptor */
247 #endif
248 int is_rdesc;
249 #if DUMP_PACKETS > 0
250 char buf[300];
251 int i=0;
252 #endif /* DUMP_PACKETS >0 */
253
254 DPRINTK("lec_start_xmit called\n");
255 if (!priv->lecd) {
256 printk("%s:No lecd attached\n",dev->name);
257 priv->stats.tx_errors++;
258 netif_stop_queue(dev);
259 return -EUNATCH;
260 }
261
262 DPRINTK("skbuff head:%lx data:%lx tail:%lx end:%lx\n",
263 (long)skb->head, (long)skb->data, (long)skb->tail,
264 (long)skb->end);
265 #if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
266 if (memcmp(skb->data, bridge_ula_lec, sizeof(bridge_ula_lec)) == 0)
267 lec_handle_bridge(skb, dev);
268 #endif
269
270 /* Make sure we have room for lec_id */
271 if (skb_headroom(skb) < 2) {
272
273 DPRINTK("lec_start_xmit: reallocating skb\n");
274 skb2 = skb_realloc_headroom(skb, LEC_HEADER_LEN);
275 kfree_skb(skb);
276 if (skb2 == NULL) return 0;
277 skb = skb2;
278 }
279 skb_push(skb, 2);
280
281 /* Put le header to place, works for TokenRing too */
282 lec_h = (struct lecdatahdr_8023*)skb->data;
283 lec_h->le_header = htons(priv->lecid);
284
285 #ifdef CONFIG_TR
286 /* Ugly. Use this to realign Token Ring packets for
287 * e.g. PCA-200E driver. */
288 if (priv->is_trdev) {
289 skb2 = skb_realloc_headroom(skb, LEC_HEADER_LEN);
290 kfree_skb(skb);
291 if (skb2 == NULL) return 0;
292 skb = skb2;
293 }
294 #endif
295
296 #if DUMP_PACKETS > 0
297 printk("%s: send datalen:%ld lecid:%4.4x\n", dev->name,
298 skb->len, priv->lecid);
299 #if DUMP_PACKETS >= 2
300 for(i=0;i<skb->len && i <99;i++) {
301 sprintf(buf+i*3,"%2.2x ",0xff&skb->data[i]);
302 }
303 #elif DUMP_PACKETS >= 1
304 for(i=0;i<skb->len && i < 30;i++) {
305 sprintf(buf+i*3,"%2.2x ", 0xff&skb->data[i]);
306 }
307 #endif /* DUMP_PACKETS >= 1 */
308 if (i==skb->len)
309 printk("%s\n",buf);
310 else
311 printk("%s...\n",buf);
312 #endif /* DUMP_PACKETS > 0 */
313
314 /* Minimum ethernet-frame size */
315 #ifdef CONFIG_TR
316 if (priv->is_trdev)
317 min_frame_size = LEC_MINIMUM_8025_SIZE;
318 else
319 #endif
320 min_frame_size = LEC_MINIMUM_8023_SIZE;
321 if (skb->len < min_frame_size) {
322 if ((skb->len + skb_tailroom(skb)) < min_frame_size) {
323 skb2 = skb_copy_expand(skb, 0,
324 min_frame_size - skb->truesize, GFP_ATOMIC);
325 dev_kfree_skb(skb);
326 if (skb2 == NULL) {
327 priv->stats.tx_dropped++;
328 return 0;
329 }
330 skb = skb2;
331 }
332 skb_put(skb, min_frame_size - skb->len);
333 }
334
335 /* Send to right vcc */
336 is_rdesc = 0;
337 dst = lec_h->h_dest;
338 #ifdef CONFIG_TR
339 if (priv->is_trdev) {
340 dst = get_tr_dst(skb->data+2, rdesc);
341 if (dst == NULL) {
342 dst = rdesc;
343 is_rdesc = 1;
344 }
345 }
346 #endif
347 entry = NULL;
348 vcc = lec_arp_resolve(priv, dst, is_rdesc, &entry);
349 DPRINTK("%s:vcc:%p vcc_flags:%x, entry:%p\n", dev->name,
350 vcc, vcc?vcc->flags:0, entry);
351 if (!vcc || !test_bit(ATM_VF_READY,&vcc->flags)) {
352 if (entry && (entry->tx_wait.qlen < LEC_UNRES_QUE_LEN)) {
353 DPRINTK("%s:lec_start_xmit: queuing packet, ", dev->name);
354 DPRINTK("MAC address 0x%02x:%02x:%02x:%02x:%02x:%02x\n",
355 lec_h->h_dest[0], lec_h->h_dest[1], lec_h->h_dest[2],
356 lec_h->h_dest[3], lec_h->h_dest[4], lec_h->h_dest[5]);
357 skb_queue_tail(&entry->tx_wait, skb);
358 } else {
359 DPRINTK("%s:lec_start_xmit: tx queue full or no arp entry, dropping, ", dev->name);
360 DPRINTK("MAC address 0x%02x:%02x:%02x:%02x:%02x:%02x\n",
361 lec_h->h_dest[0], lec_h->h_dest[1], lec_h->h_dest[2],
362 lec_h->h_dest[3], lec_h->h_dest[4], lec_h->h_dest[5]);
363 priv->stats.tx_dropped++;
364 dev_kfree_skb(skb);
365 }
366 return 0;
367 }
368
369 #if DUMP_PACKETS > 0
370 printk("%s:sending to vpi:%d vci:%d\n", dev->name,
371 vcc->vpi, vcc->vci);
372 #endif /* DUMP_PACKETS > 0 */
373
374 while (entry && (skb2 = skb_dequeue(&entry->tx_wait))) {
375 DPRINTK("lec.c: emptying tx queue, ");
376 DPRINTK("MAC address 0x%02x:%02x:%02x:%02x:%02x:%02x\n",
377 lec_h->h_dest[0], lec_h->h_dest[1], lec_h->h_dest[2],
378 lec_h->h_dest[3], lec_h->h_dest[4], lec_h->h_dest[5]);
379 lec_send(vcc, skb2, priv);
380 }
381
382 lec_send(vcc, skb, priv);
383
384 if (!atm_may_send(vcc, 0)) {
385 struct lec_vcc_priv *vpriv = LEC_VCC_PRIV(vcc);
386
387 vpriv->xoff = 1;
388 netif_stop_queue(dev);
389
390 /*
391 * vcc->pop() might have occurred in between, making
392 * the vcc usuable again. Since xmit is serialized,
393 * this is the only situation we have to re-test.
394 */
395
396 if (atm_may_send(vcc, 0))
397 netif_wake_queue(dev);
398 }
399
400 dev->trans_start = jiffies;
401 return 0;
402 }
403
404 /* The inverse routine to net_open(). */
405 static int
406 lec_close(struct net_device *dev)
407 {
408 netif_stop_queue(dev);
409 return 0;
410 }
411
412 /*
413 * Get the current statistics.
414 * This may be called with the card open or closed.
415 */
416 static struct net_device_stats *
417 lec_get_stats(struct net_device *dev)
418 {
419 return &((struct lec_priv *)dev->priv)->stats;
420 }
421
422 static int
423 lec_atm_send(struct atm_vcc *vcc, struct sk_buff *skb)
424 {
425 unsigned long flags;
426 struct net_device *dev = (struct net_device*)vcc->proto_data;
427 struct lec_priv *priv = (struct lec_priv*)dev->priv;
428 struct atmlec_msg *mesg;
429 struct lec_arp_table *entry;
430 int i;
431 char *tmp; /* FIXME */
432
433 atomic_sub(skb->truesize, &vcc->sk->sk_wmem_alloc);
434 mesg = (struct atmlec_msg *)skb->data;
435 tmp = skb->data;
436 tmp += sizeof(struct atmlec_msg);
437 DPRINTK("%s: msg from zeppelin:%d\n", dev->name, mesg->type);
438 switch(mesg->type) {
439 case l_set_mac_addr:
440 for (i=0;i<6;i++) {
441 dev->dev_addr[i] = mesg->content.normal.mac_addr[i];
442 }
443 break;
444 case l_del_mac_addr:
445 for(i=0;i<6;i++) {
446 dev->dev_addr[i] = 0;
447 }
448 break;
449 case l_addr_delete:
450 lec_addr_delete(priv, mesg->content.normal.atm_addr,
451 mesg->content.normal.flag);
452 break;
453 case l_topology_change:
454 priv->topology_change = mesg->content.normal.flag;
455 break;
456 case l_flush_complete:
457 lec_flush_complete(priv, mesg->content.normal.flag);
458 break;
459 case l_narp_req: /* LANE2: see 7.1.35 in the lane2 spec */
460 spin_lock_irqsave(&priv->lec_arp_lock, flags);
461 entry = lec_arp_find(priv, mesg->content.normal.mac_addr);
462 lec_arp_remove(priv, entry);
463 spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
464
465 if (mesg->content.normal.no_source_le_narp)
466 break;
467 /* FALL THROUGH */
468 case l_arp_update:
469 lec_arp_update(priv, mesg->content.normal.mac_addr,
470 mesg->content.normal.atm_addr,
471 mesg->content.normal.flag,
472 mesg->content.normal.targetless_le_arp);
473 DPRINTK("lec: in l_arp_update\n");
474 if (mesg->sizeoftlvs != 0) { /* LANE2 3.1.5 */
475 DPRINTK("lec: LANE2 3.1.5, got tlvs, size %d\n", mesg->sizeoftlvs);
476 lane2_associate_ind(dev,
477 mesg->content.normal.mac_addr,
478 tmp, mesg->sizeoftlvs);
479 }
480 break;
481 case l_config:
482 priv->maximum_unknown_frame_count =
483 mesg->content.config.maximum_unknown_frame_count;
484 priv->max_unknown_frame_time =
485 (mesg->content.config.max_unknown_frame_time*HZ);
486 priv->max_retry_count =
487 mesg->content.config.max_retry_count;
488 priv->aging_time = (mesg->content.config.aging_time*HZ);
489 priv->forward_delay_time =
490 (mesg->content.config.forward_delay_time*HZ);
491 priv->arp_response_time =
492 (mesg->content.config.arp_response_time*HZ);
493 priv->flush_timeout = (mesg->content.config.flush_timeout*HZ);
494 priv->path_switching_delay =
495 (mesg->content.config.path_switching_delay*HZ);
496 priv->lane_version = mesg->content.config.lane_version; /* LANE2 */
497 priv->lane2_ops = NULL;
498 if (priv->lane_version > 1)
499 priv->lane2_ops = &lane2_ops;
500 if (dev->change_mtu(dev, mesg->content.config.mtu))
501 printk("%s: change_mtu to %d failed\n", dev->name,
502 mesg->content.config.mtu);
503 priv->is_proxy = mesg->content.config.is_proxy;
504 break;
505 case l_flush_tran_id:
506 lec_set_flush_tran_id(priv, mesg->content.normal.atm_addr,
507 mesg->content.normal.flag);
508 break;
509 case l_set_lecid:
510 priv->lecid=(unsigned short)(0xffff&mesg->content.normal.flag);
511 break;
512 case l_should_bridge: {
513 #if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
514 struct net_bridge_fdb_entry *f;
515
516 DPRINTK("%s: bridge zeppelin asks about 0x%02x:%02x:%02x:%02x:%02x:%02x\n",
517 dev->name,
518 mesg->content.proxy.mac_addr[0], mesg->content.proxy.mac_addr[1],
519 mesg->content.proxy.mac_addr[2], mesg->content.proxy.mac_addr[3],
520 mesg->content.proxy.mac_addr[4], mesg->content.proxy.mac_addr[5]);
521
522 if (br_fdb_get_hook == NULL || dev->br_port == NULL)
523 break;
524
525 f = br_fdb_get_hook(dev->br_port->br, mesg->content.proxy.mac_addr);
526 if (f != NULL &&
527 f->dst->dev != dev &&
528 f->dst->state == BR_STATE_FORWARDING) {
529 /* hit from bridge table, send LE_ARP_RESPONSE */
530 struct sk_buff *skb2;
531
532 DPRINTK("%s: entry found, responding to zeppelin\n", dev->name);
533 skb2 = alloc_skb(sizeof(struct atmlec_msg), GFP_ATOMIC);
534 if (skb2 == NULL) {
535 br_fdb_put_hook(f);
536 break;
537 }
538 skb2->len = sizeof(struct atmlec_msg);
539 memcpy(skb2->data, mesg, sizeof(struct atmlec_msg));
540 atm_force_charge(priv->lecd, skb2->truesize);
541 skb_queue_tail(&priv->lecd->sk->sk_receive_queue, skb2);
542 priv->lecd->sk->sk_data_ready(priv->lecd->sk, skb2->len);
543 }
544 if (f != NULL) br_fdb_put_hook(f);
545 #endif /* defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE) */
546 }
547 break;
548 default:
549 printk("%s: Unknown message type %d\n", dev->name, mesg->type);
550 dev_kfree_skb(skb);
551 return -EINVAL;
552 }
553 dev_kfree_skb(skb);
554 return 0;
555 }
556
557 static void
558 lec_atm_close(struct atm_vcc *vcc)
559 {
560 struct sk_buff *skb;
561 struct net_device *dev = (struct net_device *)vcc->proto_data;
562 struct lec_priv *priv = (struct lec_priv *)dev->priv;
563
564 priv->lecd = NULL;
565 /* Do something needful? */
566
567 netif_stop_queue(dev);
568 lec_arp_destroy(priv);
569
570 if (skb_peek(&vcc->sk->sk_receive_queue))
571 printk("%s lec_atm_close: closing with messages pending\n",
572 dev->name);
573 while ((skb = skb_dequeue(&vcc->sk->sk_receive_queue)) != NULL) {
574 atm_return(vcc, skb->truesize);
575 dev_kfree_skb(skb);
576 }
577
578 printk("%s: Shut down!\n", dev->name);
579 module_put(THIS_MODULE);
580 }
581
582 static struct atmdev_ops lecdev_ops = {
583 .close = lec_atm_close,
584 .send = lec_atm_send
585 };
586
587 static struct atm_dev lecatm_dev = {
588 .ops = &lecdev_ops,
589 .type = "lec",
590 .number = 999, /* dummy device number */
591 .lock = SPIN_LOCK_UNLOCKED
592 };
593
594 /*
595 * LANE2: new argument struct sk_buff *data contains
596 * the LE_ARP based TLVs introduced in the LANE2 spec
597 */
598 int
599 send_to_lecd(struct lec_priv *priv, atmlec_msg_type type,
600 unsigned char *mac_addr, unsigned char *atm_addr,
601 struct sk_buff *data)
602 {
603 struct sk_buff *skb;
604 struct atmlec_msg *mesg;
605
606 if (!priv || !priv->lecd) {
607 return -1;
608 }
609 skb = alloc_skb(sizeof(struct atmlec_msg), GFP_ATOMIC);
610 if (!skb)
611 return -1;
612 skb->len = sizeof(struct atmlec_msg);
613 mesg = (struct atmlec_msg *)skb->data;
614 memset(mesg, 0, sizeof(struct atmlec_msg));
615 mesg->type = type;
616 if (data != NULL)
617 mesg->sizeoftlvs = data->len;
618 if (mac_addr)
619 memcpy(&mesg->content.normal.mac_addr, mac_addr, ETH_ALEN);
620 else
621 mesg->content.normal.targetless_le_arp = 1;
622 if (atm_addr)
623 memcpy(&mesg->content.normal.atm_addr, atm_addr, ATM_ESA_LEN);
624
625 atm_force_charge(priv->lecd, skb->truesize);
626 skb_queue_tail(&priv->lecd->sk->sk_receive_queue, skb);
627 priv->lecd->sk->sk_data_ready(priv->lecd->sk, skb->len);
628
629 if (data != NULL) {
630 DPRINTK("lec: about to send %d bytes of data\n", data->len);
631 atm_force_charge(priv->lecd, data->truesize);
632 skb_queue_tail(&priv->lecd->sk->sk_receive_queue, data);
633 priv->lecd->sk->sk_data_ready(priv->lecd->sk, skb->len);
634 }
635
636 return 0;
637 }
638
639 /* shamelessly stolen from drivers/net/net_init.c */
640 static int lec_change_mtu(struct net_device *dev, int new_mtu)
641 {
642 if ((new_mtu < 68) || (new_mtu > 18190))
643 return -EINVAL;
644 dev->mtu = new_mtu;
645 return 0;
646 }
647
648 static void lec_set_multicast_list(struct net_device *dev)
649 {
650 /* by default, all multicast frames arrive over the bus.
651 * eventually support selective multicast service
652 */
653 return;
654 }
655
656 static void
657 lec_init(struct net_device *dev)
658 {
659 dev->change_mtu = lec_change_mtu;
660 dev->open = lec_open;
661 dev->stop = lec_close;
662 dev->hard_start_xmit = lec_start_xmit;
663 dev->tx_timeout = lec_tx_timeout;
664
665 dev->get_stats = lec_get_stats;
666 dev->set_multicast_list = lec_set_multicast_list;
667 dev->do_ioctl = NULL;
668 printk("%s: Initialized!\n",dev->name);
669 return;
670 }
671
672 static unsigned char lec_ctrl_magic[] = {
673 0xff,
674 0x00,
675 0x01,
676 0x01 };
677
678 void
679 lec_push(struct atm_vcc *vcc, struct sk_buff *skb)
680 {
681 struct net_device *dev = (struct net_device *)vcc->proto_data;
682 struct lec_priv *priv = (struct lec_priv *)dev->priv;
683
684 #if DUMP_PACKETS >0
685 int i=0;
686 char buf[300];
687
688 printk("%s: lec_push vcc vpi:%d vci:%d\n", dev->name,
689 vcc->vpi, vcc->vci);
690 #endif
691 if (!skb) {
692 DPRINTK("%s: null skb\n",dev->name);
693 lec_vcc_close(priv, vcc);
694 return;
695 }
696 #if DUMP_PACKETS > 0
697 printk("%s: rcv datalen:%ld lecid:%4.4x\n", dev->name,
698 skb->len, priv->lecid);
699 #if DUMP_PACKETS >= 2
700 for(i=0;i<skb->len && i <99;i++) {
701 sprintf(buf+i*3,"%2.2x ",0xff&skb->data[i]);
702 }
703 #elif DUMP_PACKETS >= 1
704 for(i=0;i<skb->len && i < 30;i++) {
705 sprintf(buf+i*3,"%2.2x ", 0xff&skb->data[i]);
706 }
707 #endif /* DUMP_PACKETS >= 1 */
708 if (i==skb->len)
709 printk("%s\n",buf);
710 else
711 printk("%s...\n",buf);
712 #endif /* DUMP_PACKETS > 0 */
713 if (memcmp(skb->data, lec_ctrl_magic, 4) ==0) { /* Control frame, to daemon*/
714 DPRINTK("%s: To daemon\n",dev->name);
715 skb_queue_tail(&vcc->sk->sk_receive_queue, skb);
716 vcc->sk->sk_data_ready(vcc->sk, skb->len);
717 } else { /* Data frame, queue to protocol handlers */
718 unsigned char *dst;
719
720 atm_return(vcc,skb->truesize);
721 if (*(uint16_t *)skb->data == htons(priv->lecid) ||
722 !priv->lecd ||
723 !(dev->flags & IFF_UP)) {
724 /* Probably looping back, or if lecd is missing,
725 lecd has gone down */
726 DPRINTK("Ignoring frame...\n");
727 dev_kfree_skb(skb);
728 return;
729 }
730 #ifdef CONFIG_TR
731 if (priv->is_trdev) dst = ((struct lecdatahdr_8025 *)skb->data)->h_dest;
732 else
733 #endif
734 dst = ((struct lecdatahdr_8023 *)skb->data)->h_dest;
735
736 if (!(dst[0]&0x01) && /* Never filter Multi/Broadcast */
737 !priv->is_proxy && /* Proxy wants all the packets */
738 memcmp(dst, dev->dev_addr, dev->addr_len)) {
739 dev_kfree_skb(skb);
740 return;
741 }
742 if (priv->lec_arp_empty_ones) {
743 lec_arp_check_empties(priv, vcc, skb);
744 }
745 skb->dev = dev;
746 skb_pull(skb, 2); /* skip lec_id */
747 #ifdef CONFIG_TR
748 if (priv->is_trdev) skb->protocol = tr_type_trans(skb, dev);
749 else
750 #endif
751 skb->protocol = eth_type_trans(skb, dev);
752 priv->stats.rx_packets++;
753 priv->stats.rx_bytes += skb->len;
754 memset(ATM_SKB(skb), 0, sizeof(struct atm_skb_data));
755 netif_rx(skb);
756 }
757 }
758
759 void
760 lec_pop(struct atm_vcc *vcc, struct sk_buff *skb)
761 {
762 struct lec_vcc_priv *vpriv = LEC_VCC_PRIV(vcc);
763 struct net_device *dev = skb->dev;
764
765 if (vpriv == NULL) {
766 printk("lec_pop(): vpriv = NULL!?!?!?\n");
767 return;
768 }
769
770 vpriv->old_pop(vcc, skb);
771
772 if (vpriv->xoff && atm_may_send(vcc, 0)) {
773 vpriv->xoff = 0;
774 if (netif_running(dev) && netif_queue_stopped(dev))
775 netif_wake_queue(dev);
776 }
777 }
778
779 int
780 lec_vcc_attach(struct atm_vcc *vcc, void __user *arg)
781 {
782 struct lec_vcc_priv *vpriv;
783 int bytes_left;
784 struct atmlec_ioc ioc_data;
785
786 /* Lecd must be up in this case */
787 bytes_left = copy_from_user(&ioc_data, arg, sizeof(struct atmlec_ioc));
788 if (bytes_left != 0) {
789 printk("lec: lec_vcc_attach, copy from user failed for %d bytes\n",
790 bytes_left);
791 }
792 if (ioc_data.dev_num < 0 || ioc_data.dev_num >= MAX_LEC_ITF ||
793 !dev_lec[ioc_data.dev_num])
794 return -EINVAL;
795 if (!(vpriv = kmalloc(sizeof(struct lec_vcc_priv), GFP_KERNEL)))
796 return -ENOMEM;
797 vpriv->xoff = 0;
798 vpriv->old_pop = vcc->pop;
799 vcc->user_back = vpriv;
800 vcc->pop = lec_pop;
801 lec_vcc_added(dev_lec[ioc_data.dev_num]->priv,
802 &ioc_data, vcc, vcc->push);
803 vcc->proto_data = dev_lec[ioc_data.dev_num];
804 vcc->push = lec_push;
805 return 0;
806 }
807
808 int
809 lec_mcast_attach(struct atm_vcc *vcc, int arg)
810 {
811 if (arg <0 || arg >= MAX_LEC_ITF || !dev_lec[arg])
812 return -EINVAL;
813 vcc->proto_data = dev_lec[arg];
814 return (lec_mcast_make((struct lec_priv*)dev_lec[arg]->priv, vcc));
815 }
816
817 /* Initialize device. */
818 int
819 lecd_attach(struct atm_vcc *vcc, int arg)
820 {
821 int i;
822 struct lec_priv *priv;
823
824 if (arg<0)
825 i = 0;
826 else
827 i = arg;
828 #ifdef CONFIG_TR
829 if (arg >= MAX_LEC_ITF)
830 return -EINVAL;
831 #else /* Reserve the top NUM_TR_DEVS for TR */
832 if (arg >= (MAX_LEC_ITF-NUM_TR_DEVS))
833 return -EINVAL;
834 #endif
835 if (!dev_lec[i]) {
836 int is_trdev, size;
837
838 is_trdev = 0;
839 if (i >= (MAX_LEC_ITF - NUM_TR_DEVS))
840 is_trdev = 1;
841
842 size = sizeof(struct lec_priv);
843 #ifdef CONFIG_TR
844 if (is_trdev)
845 dev_lec[i] = alloc_trdev(size);
846 else
847 #endif
848 dev_lec[i] = alloc_etherdev(size);
849 if (!dev_lec[i])
850 return -ENOMEM;
851 snprintf(dev_lec[i]->name, IFNAMSIZ, "lec%d", i);
852 if (register_netdev(dev_lec[i])) {
853 free_netdev(dev_lec[i]);
854 return -EINVAL;
855 }
856
857 priv = dev_lec[i]->priv;
858 priv->is_trdev = is_trdev;
859 lec_init(dev_lec[i]);
860 } else {
861 priv = dev_lec[i]->priv;
862 if (priv->lecd)
863 return -EADDRINUSE;
864 }
865 lec_arp_init(priv);
866 priv->itfnum = i; /* LANE2 addition */
867 priv->lecd = vcc;
868 vcc->dev = &lecatm_dev;
869 vcc_insert_socket(vcc->sk);
870
871 vcc->proto_data = dev_lec[i];
872 set_bit(ATM_VF_META,&vcc->flags);
873 set_bit(ATM_VF_READY,&vcc->flags);
874
875 /* Set default values to these variables */
876 priv->maximum_unknown_frame_count = 1;
877 priv->max_unknown_frame_time = (1*HZ);
878 priv->vcc_timeout_period = (1200*HZ);
879 priv->max_retry_count = 1;
880 priv->aging_time = (300*HZ);
881 priv->forward_delay_time = (15*HZ);
882 priv->topology_change = 0;
883 priv->arp_response_time = (1*HZ);
884 priv->flush_timeout = (4*HZ);
885 priv->path_switching_delay = (6*HZ);
886
887 if (dev_lec[i]->flags & IFF_UP) {
888 netif_start_queue(dev_lec[i]);
889 }
890 __module_get(THIS_MODULE);
891 return i;
892 }
893
894 #ifdef CONFIG_PROC_FS
895 static char* lec_arp_get_status_string(unsigned char status)
896 {
897 static char *lec_arp_status_string[] = {
898 "ESI_UNKNOWN ",
899 "ESI_ARP_PENDING ",
900 "ESI_VC_PENDING ",
901 "<Undefined> ",
902 "ESI_FLUSH_PENDING ",
903 "ESI_FORWARD_DIRECT"
904 };
905
906 if (status > ESI_FORWARD_DIRECT)
907 status = 3; /* ESI_UNDEFINED */
908 return lec_arp_status_string[status];
909 }
910
911 static void lec_info(struct seq_file *seq, struct lec_arp_table *entry)
912 {
913 int i;
914
915 for (i = 0; i < ETH_ALEN; i++)
916 seq_printf(seq, "%2.2x", entry->mac_addr[i] & 0xff);
917 seq_printf(seq, " ");
918 for (i = 0; i < ATM_ESA_LEN; i++)
919 seq_printf(seq, "%2.2x", entry->atm_addr[i] & 0xff);
920 seq_printf(seq, " %s %4.4x", lec_arp_get_status_string(entry->status),
921 entry->flags & 0xffff);
922 if (entry->vcc)
923 seq_printf(seq, "%3d %3d ", entry->vcc->vpi, entry->vcc->vci);
924 else
925 seq_printf(seq, " ");
926 if (entry->recv_vcc) {
927 seq_printf(seq, " %3d %3d", entry->recv_vcc->vpi,
928 entry->recv_vcc->vci);
929 }
930 seq_putc(seq, '\n');
931 }
932
933
934 struct lec_state {
935 unsigned long flags;
936 struct lec_priv *locked;
937 struct lec_arp_table *entry;
938 struct net_device *dev;
939 int itf;
940 int arp_table;
941 int misc_table;
942 };
943
944 static void *lec_tbl_walk(struct lec_state *state, struct lec_arp_table *tbl,
945 loff_t *l)
946 {
947 struct lec_arp_table *e = state->entry;
948
949 if (!e)
950 e = tbl;
951 if (e == (void *)1) {
952 e = tbl;
953 --*l;
954 }
955 for (; e; e = e->next) {
956 if (--*l < 0)
957 break;
958 }
959 state->entry = e;
960 return (*l < 0) ? state : NULL;
961 }
962
963 static void *lec_arp_walk(struct lec_state *state, loff_t *l,
964 struct lec_priv *priv)
965 {
966 void *v = NULL;
967 int p;
968
969 for (p = state->arp_table; p < LEC_ARP_TABLE_SIZE; p++) {
970 v = lec_tbl_walk(state, priv->lec_arp_tables[p], l);
971 if (v)
972 break;
973 }
974 state->arp_table = p;
975 return v;
976 }
977
978 static void *lec_misc_walk(struct lec_state *state, loff_t *l,
979 struct lec_priv *priv)
980 {
981 struct lec_arp_table *lec_misc_tables[] = {
982 priv->lec_arp_empty_ones,
983 priv->lec_no_forward,
984 priv->mcast_fwds
985 };
986 void *v = NULL;
987 int q;
988
989 for (q = state->misc_table; q < ARRAY_SIZE(lec_misc_tables); q++) {
990 v = lec_tbl_walk(state, lec_misc_tables[q], l);
991 if (v)
992 break;
993 }
994 state->misc_table = q;
995 return v;
996 }
997
998 static void *lec_priv_walk(struct lec_state *state, loff_t *l,
999 struct lec_priv *priv)
1000 {
1001 if (!state->locked) {
1002 state->locked = priv;
1003 spin_lock_irqsave(&priv->lec_arp_lock, state->flags);
1004 }
1005 if (!lec_arp_walk(state, l, priv) &&
1006 !lec_misc_walk(state, l, priv)) {
1007 spin_unlock_irqrestore(&priv->lec_arp_lock, state->flags);
1008 state->locked = NULL;
1009 /* Partial state reset for the next time we get called */
1010 state->arp_table = state->misc_table = 0;
1011 }
1012 return state->locked;
1013 }
1014
1015 static void *lec_itf_walk(struct lec_state *state, loff_t *l)
1016 {
1017 struct net_device *dev;
1018 void *v;
1019
1020 dev = state->dev ? state->dev : dev_lec[state->itf];
1021 v = (dev && dev->priv) ? lec_priv_walk(state, l, dev->priv) : NULL;
1022 if (!v && dev) {
1023 dev_put(dev);
1024 /* Partial state reset for the next time we get called */
1025 dev = NULL;
1026 }
1027 state->dev = dev;
1028 return v;
1029 }
1030
1031 static void *lec_get_idx(struct lec_state *state, loff_t l)
1032 {
1033 void *v = NULL;
1034
1035 for (; state->itf < MAX_LEC_ITF; state->itf++) {
1036 v = lec_itf_walk(state, &l);
1037 if (v)
1038 break;
1039 }
1040 return v;
1041 }
1042
1043 static void *lec_seq_start(struct seq_file *seq, loff_t *pos)
1044 {
1045 struct lec_state *state = seq->private;
1046
1047 state->itf = 0;
1048 state->dev = NULL;
1049 state->locked = NULL;
1050 state->arp_table = 0;
1051 state->misc_table = 0;
1052 state->entry = (void *)1;
1053
1054 return *pos ? lec_get_idx(state, *pos) : (void*)1;
1055 }
1056
1057 static void lec_seq_stop(struct seq_file *seq, void *v)
1058 {
1059 struct lec_state *state = seq->private;
1060
1061 if (state->dev) {
1062 spin_unlock_irqrestore(&state->locked->lec_arp_lock,
1063 state->flags);
1064 dev_put(state->dev);
1065 }
1066 }
1067
1068 static void *lec_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1069 {
1070 struct lec_state *state = seq->private;
1071
1072 v = lec_get_idx(state, 1);
1073 *pos += !!PTR_ERR(v);
1074 return v;
1075 }
1076
1077 static int lec_seq_show(struct seq_file *seq, void *v)
1078 {
1079 static char lec_banner[] = "Itf MAC ATM destination"
1080 " Status Flags "
1081 "VPI/VCI Recv VPI/VCI\n";
1082
1083 if (v == (void *)1)
1084 seq_puts(seq, lec_banner);
1085 else {
1086 struct lec_state *state = seq->private;
1087 struct net_device *dev = state->dev;
1088
1089 seq_printf(seq, "%s ", dev->name);
1090 lec_info(seq, state->entry);
1091 }
1092 return 0;
1093 }
1094
1095 static struct seq_operations lec_seq_ops = {
1096 .start = lec_seq_start,
1097 .next = lec_seq_next,
1098 .stop = lec_seq_stop,
1099 .show = lec_seq_show,
1100 };
1101
1102 static int lec_seq_open(struct inode *inode, struct file *file)
1103 {
1104 struct lec_state *state;
1105 struct seq_file *seq;
1106 int rc = -EAGAIN;
1107
1108 state = kmalloc(sizeof(*state), GFP_KERNEL);
1109 if (!state) {
1110 rc = -ENOMEM;
1111 goto out;
1112 }
1113
1114 rc = seq_open(file, &lec_seq_ops);
1115 if (rc)
1116 goto out_kfree;
1117 seq = file->private_data;
1118 seq->private = state;
1119 out:
1120 return rc;
1121
1122 out_kfree:
1123 kfree(state);
1124 goto out;
1125 }
1126
1127 static int lec_seq_release(struct inode *inode, struct file *file)
1128 {
1129 return seq_release_private(inode, file);
1130 }
1131
1132 static struct file_operations lec_seq_fops = {
1133 .owner = THIS_MODULE,
1134 .open = lec_seq_open,
1135 .read = seq_read,
1136 .llseek = seq_lseek,
1137 .release = lec_seq_release,
1138 };
1139 #endif
1140
1141 static int lane_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1142 {
1143 struct atm_vcc *vcc = ATM_SD(sock);
1144 int err = 0;
1145
1146 switch (cmd) {
1147 case ATMLEC_CTRL:
1148 case ATMLEC_MCAST:
1149 case ATMLEC_DATA:
1150 if (!capable(CAP_NET_ADMIN))
1151 return -EPERM;
1152 break;
1153 default:
1154 return -ENOIOCTLCMD;
1155 }
1156
1157 switch (cmd) {
1158 case ATMLEC_CTRL:
1159 err = lecd_attach(vcc, (int) arg);
1160 if (err >= 0)
1161 sock->state = SS_CONNECTED;
1162 break;
1163 case ATMLEC_MCAST:
1164 err = lec_mcast_attach(vcc, (int) arg);
1165 break;
1166 case ATMLEC_DATA:
1167 err = lec_vcc_attach(vcc, (void __user *) arg);
1168 break;
1169 }
1170
1171 return err;
1172 }
1173
1174 static struct atm_ioctl lane_ioctl_ops = {
1175 .owner = THIS_MODULE,
1176 .ioctl = lane_ioctl,
1177 };
1178
1179 static int __init lane_module_init(void)
1180 {
1181 #ifdef CONFIG_PROC_FS
1182 struct proc_dir_entry *p;
1183
1184 p = create_proc_entry("lec", S_IRUGO, atm_proc_root);
1185 if (p)
1186 p->proc_fops = &lec_seq_fops;
1187 #endif
1188
1189 register_atm_ioctl(&lane_ioctl_ops);
1190 printk("lec.c: " __DATE__ " " __TIME__ " initialized\n");
1191 return 0;
1192 }
1193
1194 static void __exit lane_module_cleanup(void)
1195 {
1196 int i;
1197 struct lec_priv *priv;
1198
1199 remove_proc_entry("lec", atm_proc_root);
1200
1201 deregister_atm_ioctl(&lane_ioctl_ops);
1202
1203 for (i = 0; i < MAX_LEC_ITF; i++) {
1204 if (dev_lec[i] != NULL) {
1205 priv = (struct lec_priv *)dev_lec[i]->priv;
1206 unregister_netdev(dev_lec[i]);
1207 free_netdev(dev_lec[i]);
1208 dev_lec[i] = NULL;
1209 }
1210 }
1211
1212 return;
1213 }
1214
1215 module_init(lane_module_init);
1216 module_exit(lane_module_cleanup);
1217
1218 /*
1219 * LANE2: 3.1.3, LE_RESOLVE.request
1220 * Non force allocates memory and fills in *tlvs, fills in *sizeoftlvs.
1221 * If sizeoftlvs == NULL the default TLVs associated with with this
1222 * lec will be used.
1223 * If dst_mac == NULL, targetless LE_ARP will be sent
1224 */
1225 static int lane2_resolve(struct net_device *dev, u8 *dst_mac, int force,
1226 u8 **tlvs, u32 *sizeoftlvs)
1227 {
1228 unsigned long flags;
1229 struct lec_priv *priv = (struct lec_priv *)dev->priv;
1230 struct lec_arp_table *table;
1231 struct sk_buff *skb;
1232 int retval;
1233
1234 if (force == 0) {
1235 spin_lock_irqsave(&priv->lec_arp_lock, flags);
1236 table = lec_arp_find(priv, dst_mac);
1237 spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
1238 if(table == NULL)
1239 return -1;
1240
1241 *tlvs = kmalloc(table->sizeoftlvs, GFP_ATOMIC);
1242 if (*tlvs == NULL)
1243 return -1;
1244
1245 memcpy(*tlvs, table->tlvs, table->sizeoftlvs);
1246 *sizeoftlvs = table->sizeoftlvs;
1247
1248 return 0;
1249 }
1250
1251 if (sizeoftlvs == NULL)
1252 retval = send_to_lecd(priv, l_arp_xmt, dst_mac, NULL, NULL);
1253
1254 else {
1255 skb = alloc_skb(*sizeoftlvs, GFP_ATOMIC);
1256 if (skb == NULL)
1257 return -1;
1258 skb->len = *sizeoftlvs;
1259 memcpy(skb->data, *tlvs, *sizeoftlvs);
1260 retval = send_to_lecd(priv, l_arp_xmt, dst_mac, NULL, skb);
1261 }
1262 return retval;
1263 }
1264
1265
1266 /*
1267 * LANE2: 3.1.4, LE_ASSOCIATE.request
1268 * Associate the *tlvs with the *lan_dst address.
1269 * Will overwrite any previous association
1270 * Returns 1 for success, 0 for failure (out of memory)
1271 *
1272 */
1273 static int lane2_associate_req (struct net_device *dev, u8 *lan_dst,
1274 u8 *tlvs, u32 sizeoftlvs)
1275 {
1276 int retval;
1277 struct sk_buff *skb;
1278 struct lec_priv *priv = (struct lec_priv*)dev->priv;
1279
1280 if ( memcmp(lan_dst, dev->dev_addr, ETH_ALEN) != 0 )
1281 return (0); /* not our mac address */
1282
1283 kfree(priv->tlvs); /* NULL if there was no previous association */
1284
1285 priv->tlvs = kmalloc(sizeoftlvs, GFP_KERNEL);
1286 if (priv->tlvs == NULL)
1287 return (0);
1288 priv->sizeoftlvs = sizeoftlvs;
1289 memcpy(priv->tlvs, tlvs, sizeoftlvs);
1290
1291 skb = alloc_skb(sizeoftlvs, GFP_ATOMIC);
1292 if (skb == NULL)
1293 return 0;
1294 skb->len = sizeoftlvs;
1295 memcpy(skb->data, tlvs, sizeoftlvs);
1296 retval = send_to_lecd(priv, l_associate_req, NULL, NULL, skb);
1297 if (retval != 0)
1298 printk("lec.c: lane2_associate_req() failed\n");
1299 /* If the previous association has changed we must
1300 * somehow notify other LANE entities about the change
1301 */
1302 return (1);
1303 }
1304
1305 /*
1306 * LANE2: 3.1.5, LE_ASSOCIATE.indication
1307 *
1308 */
1309 static void lane2_associate_ind (struct net_device *dev, u8 *mac_addr,
1310 u8 *tlvs, u32 sizeoftlvs)
1311 {
1312 #if 0
1313 int i = 0;
1314 #endif
1315 struct lec_priv *priv = (struct lec_priv *)dev->priv;
1316 #if 0 /* Why have the TLVs in LE_ARP entries since we do not use them? When you
1317 uncomment this code, make sure the TLVs get freed when entry is killed */
1318 struct lec_arp_table *entry = lec_arp_find(priv, mac_addr);
1319
1320 if (entry == NULL)
1321 return; /* should not happen */
1322
1323 kfree(entry->tlvs);
1324
1325 entry->tlvs = kmalloc(sizeoftlvs, GFP_KERNEL);
1326 if (entry->tlvs == NULL)
1327 return;
1328
1329 entry->sizeoftlvs = sizeoftlvs;
1330 memcpy(entry->tlvs, tlvs, sizeoftlvs);
1331 #endif
1332 #if 0
1333 printk("lec.c: lane2_associate_ind()\n");
1334 printk("dump of tlvs, sizeoftlvs=%d\n", sizeoftlvs);
1335 while (i < sizeoftlvs)
1336 printk("%02x ", tlvs[i++]);
1337
1338 printk("\n");
1339 #endif
1340
1341 /* tell MPOA about the TLVs we saw */
1342 if (priv->lane2_ops && priv->lane2_ops->associate_indicator) {
1343 priv->lane2_ops->associate_indicator(dev, mac_addr,
1344 tlvs, sizeoftlvs);
1345 }
1346 return;
1347 }
1348
1349 /*
1350 * Here starts what used to lec_arpc.c
1351 *
1352 * lec_arpc.c was added here when making
1353 * lane client modular. October 1997
1354 *
1355 */
1356
1357 #include <linux/types.h>
1358 #include <linux/sched.h>
1359 #include <linux/timer.h>
1360 #include <asm/param.h>
1361 #include <asm/atomic.h>
1362 #include <linux/inetdevice.h>
1363 #include <net/route.h>
1364
1365
1366 #if 0
1367 #define DPRINTK(format,args...)
1368 /*
1369 #define DPRINTK printk
1370 */
1371 #endif
1372 #define DEBUG_ARP_TABLE 0
1373
1374 #define LEC_ARP_REFRESH_INTERVAL (3*HZ)
1375
1376 static void lec_arp_check_expire(unsigned long data);
1377 static void lec_arp_expire_arp(unsigned long data);
1378 void dump_arp_table(struct lec_priv *priv);
1379
1380 /*
1381 * Arp table funcs
1382 */
1383
1384 #define HASH(ch) (ch & (LEC_ARP_TABLE_SIZE -1))
1385
1386 /*
1387 * Initialization of arp-cache
1388 */
1389 void
1390 lec_arp_init(struct lec_priv *priv)
1391 {
1392 unsigned short i;
1393
1394 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) {
1395 priv->lec_arp_tables[i] = NULL;
1396 }
1397 spin_lock_init(&priv->lec_arp_lock);
1398 init_timer(&priv->lec_arp_timer);
1399 priv->lec_arp_timer.expires = jiffies + LEC_ARP_REFRESH_INTERVAL;
1400 priv->lec_arp_timer.data = (unsigned long)priv;
1401 priv->lec_arp_timer.function = lec_arp_check_expire;
1402 add_timer(&priv->lec_arp_timer);
1403 }
1404
1405 void
1406 lec_arp_clear_vccs(struct lec_arp_table *entry)
1407 {
1408 if (entry->vcc) {
1409 struct atm_vcc *vcc = entry->vcc;
1410 struct lec_vcc_priv *vpriv = LEC_VCC_PRIV(vcc);
1411 struct net_device *dev = (struct net_device*) vcc->proto_data;
1412
1413 vcc->pop = vpriv->old_pop;
1414 if (vpriv->xoff)
1415 netif_wake_queue(dev);
1416 kfree(vpriv);
1417 vcc->user_back = NULL;
1418 vcc->push = entry->old_push;
1419 vcc_release_async(vcc, -EPIPE);
1420 vcc = NULL;
1421 }
1422 if (entry->recv_vcc) {
1423 entry->recv_vcc->push = entry->old_recv_push;
1424 vcc_release_async(entry->recv_vcc, -EPIPE);
1425 entry->recv_vcc = NULL;
1426 }
1427 }
1428
1429 /*
1430 * Insert entry to lec_arp_table
1431 * LANE2: Add to the end of the list to satisfy 8.1.13
1432 */
1433 static inline void
1434 lec_arp_add(struct lec_priv *priv, struct lec_arp_table *to_add)
1435 {
1436 unsigned short place;
1437 struct lec_arp_table *tmp;
1438
1439 place = HASH(to_add->mac_addr[ETH_ALEN-1]);
1440 tmp = priv->lec_arp_tables[place];
1441 to_add->next = NULL;
1442 if (tmp == NULL)
1443 priv->lec_arp_tables[place] = to_add;
1444
1445 else { /* add to the end */
1446 while (tmp->next)
1447 tmp = tmp->next;
1448 tmp->next = to_add;
1449 }
1450
1451 DPRINTK("LEC_ARP: Added entry:%2.2x %2.2x %2.2x %2.2x %2.2x %2.2x\n",
1452 0xff&to_add->mac_addr[0], 0xff&to_add->mac_addr[1],
1453 0xff&to_add->mac_addr[2], 0xff&to_add->mac_addr[3],
1454 0xff&to_add->mac_addr[4], 0xff&to_add->mac_addr[5]);
1455 }
1456
1457 /*
1458 * Remove entry from lec_arp_table
1459 */
1460 static int
1461 lec_arp_remove(struct lec_priv *priv,
1462 struct lec_arp_table *to_remove)
1463 {
1464 unsigned short place;
1465 struct lec_arp_table *tmp;
1466 int remove_vcc=1;
1467
1468 if (!to_remove) {
1469 return -1;
1470 }
1471 place = HASH(to_remove->mac_addr[ETH_ALEN-1]);
1472 tmp = priv->lec_arp_tables[place];
1473 if (tmp == to_remove) {
1474 priv->lec_arp_tables[place] = tmp->next;
1475 } else {
1476 while(tmp && tmp->next != to_remove) {
1477 tmp = tmp->next;
1478 }
1479 if (!tmp) {/* Entry was not found */
1480 return -1;
1481 }
1482 }
1483 tmp->next = to_remove->next;
1484 del_timer(&to_remove->timer);
1485
1486 /* If this is the only MAC connected to this VCC, also tear down
1487 the VCC */
1488 if (to_remove->status >= ESI_FLUSH_PENDING) {
1489 /*
1490 * ESI_FLUSH_PENDING, ESI_FORWARD_DIRECT
1491 */
1492 for(place = 0; place < LEC_ARP_TABLE_SIZE; place++) {
1493 for(tmp = priv->lec_arp_tables[place]; tmp != NULL; tmp = tmp->next) {
1494 if (memcmp(tmp->atm_addr, to_remove->atm_addr,
1495 ATM_ESA_LEN)==0) {
1496 remove_vcc=0;
1497 break;
1498 }
1499 }
1500 }
1501 if (remove_vcc)
1502 lec_arp_clear_vccs(to_remove);
1503 }
1504 skb_queue_purge(&to_remove->tx_wait); /* FIXME: good place for this? */
1505
1506 DPRINTK("LEC_ARP: Removed entry:%2.2x %2.2x %2.2x %2.2x %2.2x %2.2x\n",
1507 0xff&to_remove->mac_addr[0], 0xff&to_remove->mac_addr[1],
1508 0xff&to_remove->mac_addr[2], 0xff&to_remove->mac_addr[3],
1509 0xff&to_remove->mac_addr[4], 0xff&to_remove->mac_addr[5]);
1510 return 0;
1511 }
1512
1513 #if DEBUG_ARP_TABLE
1514 static char*
1515 get_status_string(unsigned char st)
1516 {
1517 switch(st) {
1518 case ESI_UNKNOWN:
1519 return "ESI_UNKNOWN";
1520 case ESI_ARP_PENDING:
1521 return "ESI_ARP_PENDING";
1522 case ESI_VC_PENDING:
1523 return "ESI_VC_PENDING";
1524 case ESI_FLUSH_PENDING:
1525 return "ESI_FLUSH_PENDING";
1526 case ESI_FORWARD_DIRECT:
1527 return "ESI_FORWARD_DIRECT";
1528 default:
1529 return "<UNKNOWN>";
1530 }
1531 }
1532 #endif
1533
1534 void
1535 dump_arp_table(struct lec_priv *priv)
1536 {
1537 #if DEBUG_ARP_TABLE
1538 int i,j, offset;
1539 struct lec_arp_table *rulla;
1540 char buf[1024];
1541 struct lec_arp_table **lec_arp_tables =
1542 (struct lec_arp_table **)priv->lec_arp_tables;
1543 struct lec_arp_table *lec_arp_empty_ones =
1544 (struct lec_arp_table *)priv->lec_arp_empty_ones;
1545 struct lec_arp_table *lec_no_forward =
1546 (struct lec_arp_table *)priv->lec_no_forward;
1547 struct lec_arp_table *mcast_fwds = priv->mcast_fwds;
1548
1549
1550 printk("Dump %p:\n",priv);
1551 for (i=0;i<LEC_ARP_TABLE_SIZE;i++) {
1552 rulla = lec_arp_tables[i];
1553 offset = 0;
1554 offset += sprintf(buf,"%d: %p\n",i, rulla);
1555 while (rulla) {
1556 offset += sprintf(buf+offset,"Mac:");
1557 for(j=0;j<ETH_ALEN;j++) {
1558 offset+=sprintf(buf+offset,
1559 "%2.2x ",
1560 rulla->mac_addr[j]&0xff);
1561 }
1562 offset +=sprintf(buf+offset,"Atm:");
1563 for(j=0;j<ATM_ESA_LEN;j++) {
1564 offset+=sprintf(buf+offset,
1565 "%2.2x ",
1566 rulla->atm_addr[j]&0xff);
1567 }
1568 offset+=sprintf(buf+offset,
1569 "Vcc vpi:%d vci:%d, Recv_vcc vpi:%d vci:%d Last_used:%lx, Timestamp:%lx, No_tries:%d ",
1570 rulla->vcc?rulla->vcc->vpi:0,
1571 rulla->vcc?rulla->vcc->vci:0,
1572 rulla->recv_vcc?rulla->recv_vcc->vpi:0,
1573 rulla->recv_vcc?rulla->recv_vcc->vci:0,
1574 rulla->last_used,
1575 rulla->timestamp, rulla->no_tries);
1576 offset+=sprintf(buf+offset,
1577 "Flags:%x, Packets_flooded:%x, Status: %s ",
1578 rulla->flags, rulla->packets_flooded,
1579 get_status_string(rulla->status));
1580 offset+=sprintf(buf+offset,"->%p\n",rulla->next);
1581 rulla = rulla->next;
1582 }
1583 printk("%s",buf);
1584 }
1585 rulla = lec_no_forward;
1586 if (rulla)
1587 printk("No forward\n");
1588 while(rulla) {
1589 offset=0;
1590 offset += sprintf(buf+offset,"Mac:");
1591 for(j=0;j<ETH_ALEN;j++) {
1592 offset+=sprintf(buf+offset,"%2.2x ",
1593 rulla->mac_addr[j]&0xff);
1594 }
1595 offset +=sprintf(buf+offset,"Atm:");
1596 for(j=0;j<ATM_ESA_LEN;j++) {
1597 offset+=sprintf(buf+offset,"%2.2x ",
1598 rulla->atm_addr[j]&0xff);
1599 }
1600 offset+=sprintf(buf+offset,
1601 "Vcc vpi:%d vci:%d, Recv_vcc vpi:%d vci:%d Last_used:%lx, Timestamp:%lx, No_tries:%d ",
1602 rulla->vcc?rulla->vcc->vpi:0,
1603 rulla->vcc?rulla->vcc->vci:0,
1604 rulla->recv_vcc?rulla->recv_vcc->vpi:0,
1605 rulla->recv_vcc?rulla->recv_vcc->vci:0,
1606 rulla->last_used,
1607 rulla->timestamp, rulla->no_tries);
1608 offset+=sprintf(buf+offset,
1609 "Flags:%x, Packets_flooded:%x, Status: %s ",
1610 rulla->flags, rulla->packets_flooded,
1611 get_status_string(rulla->status));
1612 offset+=sprintf(buf+offset,"->%lx\n",(long)rulla->next);
1613 rulla = rulla->next;
1614 printk("%s",buf);
1615 }
1616 rulla = lec_arp_empty_ones;
1617 if (rulla)
1618 printk("Empty ones\n");
1619 while(rulla) {
1620 offset=0;
1621 offset += sprintf(buf+offset,"Mac:");
1622 for(j=0;j<ETH_ALEN;j++) {
1623 offset+=sprintf(buf+offset,"%2.2x ",
1624 rulla->mac_addr[j]&0xff);
1625 }
1626 offset +=sprintf(buf+offset,"Atm:");
1627 for(j=0;j<ATM_ESA_LEN;j++) {
1628 offset+=sprintf(buf+offset,"%2.2x ",
1629 rulla->atm_addr[j]&0xff);
1630 }
1631 offset+=sprintf(buf+offset,
1632 "Vcc vpi:%d vci:%d, Recv_vcc vpi:%d vci:%d Last_used:%lx, Timestamp:%lx, No_tries:%d ",
1633 rulla->vcc?rulla->vcc->vpi:0,
1634 rulla->vcc?rulla->vcc->vci:0,
1635 rulla->recv_vcc?rulla->recv_vcc->vpi:0,
1636 rulla->recv_vcc?rulla->recv_vcc->vci:0,
1637 rulla->last_used,
1638 rulla->timestamp, rulla->no_tries);
1639 offset+=sprintf(buf+offset,
1640 "Flags:%x, Packets_flooded:%x, Status: %s ",
1641 rulla->flags, rulla->packets_flooded,
1642 get_status_string(rulla->status));
1643 offset+=sprintf(buf+offset,"->%lx\n",(long)rulla->next);
1644 rulla = rulla->next;
1645 printk("%s",buf);
1646 }
1647
1648 rulla = mcast_fwds;
1649 if (rulla)
1650 printk("Multicast Forward VCCs\n");
1651 while(rulla) {
1652 offset=0;
1653 offset += sprintf(buf+offset,"Mac:");
1654 for(j=0;j<ETH_ALEN;j++) {
1655 offset+=sprintf(buf+offset,"%2.2x ",
1656 rulla->mac_addr[j]&0xff);
1657 }
1658 offset +=sprintf(buf+offset,"Atm:");
1659 for(j=0;j<ATM_ESA_LEN;j++) {
1660 offset+=sprintf(buf+offset,"%2.2x ",
1661 rulla->atm_addr[j]&0xff);
1662 }
1663 offset+=sprintf(buf+offset,
1664 "Vcc vpi:%d vci:%d, Recv_vcc vpi:%d vci:%d Last_used:%lx, Timestamp:%lx, No_tries:%d ",
1665 rulla->vcc?rulla->vcc->vpi:0,
1666 rulla->vcc?rulla->vcc->vci:0,
1667 rulla->recv_vcc?rulla->recv_vcc->vpi:0,
1668 rulla->recv_vcc?rulla->recv_vcc->vci:0,
1669 rulla->last_used,
1670 rulla->timestamp, rulla->no_tries);
1671 offset+=sprintf(buf+offset,
1672 "Flags:%x, Packets_flooded:%x, Status: %s ",
1673 rulla->flags, rulla->packets_flooded,
1674 get_status_string(rulla->status));
1675 offset+=sprintf(buf+offset,"->%lx\n",(long)rulla->next);
1676 rulla = rulla->next;
1677 printk("%s",buf);
1678 }
1679
1680 #endif
1681 }
1682
1683 /*
1684 * Destruction of arp-cache
1685 */
1686 void
1687 lec_arp_destroy(struct lec_priv *priv)
1688 {
1689 unsigned long flags;
1690 struct lec_arp_table *entry, *next;
1691 int i;
1692
1693 del_timer_sync(&priv->lec_arp_timer);
1694
1695 /*
1696 * Remove all entries
1697 */
1698
1699 spin_lock_irqsave(&priv->lec_arp_lock, flags);
1700 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) {
1701 for(entry = priv->lec_arp_tables[i]; entry != NULL; entry=next) {
1702 next = entry->next;
1703 lec_arp_remove(priv, entry);
1704 kfree(entry);
1705 }
1706 }
1707 entry = priv->lec_arp_empty_ones;
1708 while(entry) {
1709 next = entry->next;
1710 del_timer_sync(&entry->timer);
1711 lec_arp_clear_vccs(entry);
1712 kfree(entry);
1713 entry = next;
1714 }
1715 priv->lec_arp_empty_ones = NULL;
1716 entry = priv->lec_no_forward;
1717 while(entry) {
1718 next = entry->next;
1719 del_timer_sync(&entry->timer);
1720 lec_arp_clear_vccs(entry);
1721 kfree(entry);
1722 entry = next;
1723 }
1724 priv->lec_no_forward = NULL;
1725 entry = priv->mcast_fwds;
1726 while(entry) {
1727 next = entry->next;
1728 /* No timer, LANEv2 7.1.20 and 2.3.5.3 */
1729 lec_arp_clear_vccs(entry);
1730 kfree(entry);
1731 entry = next;
1732 }
1733 priv->mcast_fwds = NULL;
1734 priv->mcast_vcc = NULL;
1735 memset(priv->lec_arp_tables, 0,
1736 sizeof(struct lec_arp_table *) * LEC_ARP_TABLE_SIZE);
1737 spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
1738 }
1739
1740
1741 /*
1742 * Find entry by mac_address
1743 */
1744 static struct lec_arp_table*
1745 lec_arp_find(struct lec_priv *priv,
1746 unsigned char *mac_addr)
1747 {
1748 unsigned short place;
1749 struct lec_arp_table *to_return;
1750
1751 DPRINTK("LEC_ARP: lec_arp_find :%2.2x %2.2x %2.2x %2.2x %2.2x %2.2x\n",
1752 mac_addr[0]&0xff, mac_addr[1]&0xff, mac_addr[2]&0xff,
1753 mac_addr[3]&0xff, mac_addr[4]&0xff, mac_addr[5]&0xff);
1754 place = HASH(mac_addr[ETH_ALEN-1]);
1755
1756 to_return = priv->lec_arp_tables[place];
1757 while(to_return) {
1758 if (memcmp(mac_addr, to_return->mac_addr, ETH_ALEN) == 0) {
1759 return to_return;
1760 }
1761 to_return = to_return->next;
1762 }
1763 return NULL;
1764 }
1765
1766 static struct lec_arp_table*
1767 make_entry(struct lec_priv *priv, unsigned char *mac_addr)
1768 {
1769 struct lec_arp_table *to_return;
1770
1771 to_return = (struct lec_arp_table *) kmalloc(sizeof(struct lec_arp_table),
1772 GFP_ATOMIC);
1773 if (!to_return) {
1774 printk("LEC: Arp entry kmalloc failed\n");
1775 return NULL;
1776 }
1777 memset(to_return, 0, sizeof(struct lec_arp_table));
1778 memcpy(to_return->mac_addr, mac_addr, ETH_ALEN);
1779 init_timer(&to_return->timer);
1780 to_return->timer.function = lec_arp_expire_arp;
1781 to_return->timer.data = (unsigned long) to_return;
1782 to_return->last_used = jiffies;
1783 to_return->priv = priv;
1784 skb_queue_head_init(&to_return->tx_wait);
1785 return to_return;
1786 }
1787
1788 /*
1789 *
1790 * Arp sent timer expired
1791 *
1792 */
1793 static void
1794 lec_arp_expire_arp(unsigned long data)
1795 {
1796 struct lec_arp_table *entry;
1797
1798 entry = (struct lec_arp_table *)data;
1799
1800 DPRINTK("lec_arp_expire_arp\n");
1801 if (entry->status == ESI_ARP_PENDING) {
1802 if (entry->no_tries <= entry->priv->max_retry_count) {
1803 if (entry->is_rdesc)
1804 send_to_lecd(entry->priv, l_rdesc_arp_xmt, entry->mac_addr, NULL, NULL);
1805 else
1806 send_to_lecd(entry->priv, l_arp_xmt, entry->mac_addr, NULL, NULL);
1807 entry->no_tries++;
1808 }
1809 mod_timer(&entry->timer, jiffies + (1*HZ));
1810 }
1811 }
1812
1813 /*
1814 *
1815 * Unknown/unused vcc expire, remove associated entry
1816 *
1817 */
1818 static void
1819 lec_arp_expire_vcc(unsigned long data)
1820 {
1821 unsigned long flags;
1822 struct lec_arp_table *to_remove = (struct lec_arp_table*)data;
1823 struct lec_priv *priv = (struct lec_priv *)to_remove->priv;
1824 struct lec_arp_table *entry = NULL;
1825
1826 del_timer(&to_remove->timer);
1827
1828 DPRINTK("LEC_ARP %p %p: lec_arp_expire_vcc vpi:%d vci:%d\n",
1829 to_remove, priv,
1830 to_remove->vcc?to_remove->recv_vcc->vpi:0,
1831 to_remove->vcc?to_remove->recv_vcc->vci:0);
1832 DPRINTK("eo:%p nf:%p\n",priv->lec_arp_empty_ones,priv->lec_no_forward);
1833
1834 spin_lock_irqsave(&priv->lec_arp_lock, flags);
1835 if (to_remove == priv->lec_arp_empty_ones)
1836 priv->lec_arp_empty_ones = to_remove->next;
1837 else {
1838 entry = priv->lec_arp_empty_ones;
1839 while (entry && entry->next != to_remove)
1840 entry = entry->next;
1841 if (entry)
1842 entry->next = to_remove->next;
1843 }
1844 if (!entry) {
1845 if (to_remove == priv->lec_no_forward) {
1846 priv->lec_no_forward = to_remove->next;
1847 } else {
1848 entry = priv->lec_no_forward;
1849 while (entry && entry->next != to_remove)
1850 entry = entry->next;
1851 if (entry)
1852 entry->next = to_remove->next;
1853 }
1854 }
1855 spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
1856
1857 lec_arp_clear_vccs(to_remove);
1858 kfree(to_remove);
1859 }
1860
1861 /*
1862 * Expire entries.
1863 * 1. Re-set timer
1864 * 2. For each entry, delete entries that have aged past the age limit.
1865 * 3. For each entry, depending on the status of the entry, perform
1866 * the following maintenance.
1867 * a. If status is ESI_VC_PENDING or ESI_ARP_PENDING then if the
1868 * tick_count is above the max_unknown_frame_time, clear
1869 * the tick_count to zero and clear the packets_flooded counter
1870 * to zero. This supports the packet rate limit per address
1871 * while flooding unknowns.
1872 * b. If the status is ESI_FLUSH_PENDING and the tick_count is greater
1873 * than or equal to the path_switching_delay, change the status
1874 * to ESI_FORWARD_DIRECT. This causes the flush period to end
1875 * regardless of the progress of the flush protocol.
1876 */
1877 static void
1878 lec_arp_check_expire(unsigned long data)
1879 {
1880 unsigned long flags;
1881 struct lec_priv *priv = (struct lec_priv *)data;
1882 struct lec_arp_table *entry, *next;
1883 unsigned long now;
1884 unsigned long time_to_check;
1885 int i;
1886
1887 DPRINTK("lec_arp_check_expire %p\n",priv);
1888 DPRINTK("expire: eo:%p nf:%p\n",priv->lec_arp_empty_ones,
1889 priv->lec_no_forward);
1890 now = jiffies;
1891 spin_lock_irqsave(&priv->lec_arp_lock, flags);
1892 for(i = 0; i < LEC_ARP_TABLE_SIZE; i++) {
1893 for(entry = priv->lec_arp_tables[i]; entry != NULL; ) {
1894 if ((entry->flags) & LEC_REMOTE_FLAG &&
1895 priv->topology_change)
1896 time_to_check = priv->forward_delay_time;
1897 else
1898 time_to_check = priv->aging_time;
1899
1900 DPRINTK("About to expire: %lx - %lx > %lx\n",
1901 now,entry->last_used, time_to_check);
1902 if( time_after(now, entry->last_used+
1903 time_to_check) &&
1904 !(entry->flags & LEC_PERMANENT_FLAG) &&
1905 !(entry->mac_addr[0] & 0x01) ) { /* LANE2: 7.1.20 */
1906 /* Remove entry */
1907 DPRINTK("LEC:Entry timed out\n");
1908 next = entry->next;
1909 lec_arp_remove(priv, entry);
1910 kfree(entry);
1911 entry = next;
1912 } else {
1913 /* Something else */
1914 if ((entry->status == ESI_VC_PENDING ||
1915 entry->status == ESI_ARP_PENDING)
1916 && time_after_eq(now,
1917 entry->timestamp +
1918 priv->max_unknown_frame_time)) {
1919 entry->timestamp = jiffies;
1920 entry->packets_flooded = 0;
1921 if (entry->status == ESI_VC_PENDING)
1922 send_to_lecd(priv, l_svc_setup, entry->mac_addr, entry->atm_addr, NULL);
1923 }
1924 if (entry->status == ESI_FLUSH_PENDING
1925 &&
1926 time_after_eq(now, entry->timestamp+
1927 priv->path_switching_delay)) {
1928 struct sk_buff *skb;
1929
1930 while ((skb = skb_dequeue(&entry->tx_wait)) != NULL)
1931 lec_send(entry->vcc, skb, entry->priv);
1932 entry->last_used = jiffies;
1933 entry->status =
1934 ESI_FORWARD_DIRECT;
1935 }
1936 entry = entry->next;
1937 }
1938 }
1939 }
1940 spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
1941
1942 mod_timer(&priv->lec_arp_timer, jiffies + LEC_ARP_REFRESH_INTERVAL);
1943 }
1944 /*
1945 * Try to find vcc where mac_address is attached.
1946 *
1947 */
1948 struct atm_vcc*
1949 lec_arp_resolve(struct lec_priv *priv, unsigned char *mac_to_find, int is_rdesc,
1950 struct lec_arp_table **ret_entry)
1951 {
1952 unsigned long flags;
1953 struct lec_arp_table *entry;
1954 struct atm_vcc *found;
1955
1956 if (mac_to_find[0] & 0x01) {
1957 switch (priv->lane_version) {
1958 case 1:
1959 return priv->mcast_vcc;
1960 break;
1961 case 2: /* LANE2 wants arp for multicast addresses */
1962 if ( memcmp(mac_to_find, bus_mac, ETH_ALEN) == 0)
1963 return priv->mcast_vcc;
1964 break;
1965 default:
1966 break;
1967 }
1968 }
1969
1970 spin_lock_irqsave(&priv->lec_arp_lock, flags);
1971 entry = lec_arp_find(priv, mac_to_find);
1972
1973 if (entry) {
1974 if (entry->status == ESI_FORWARD_DIRECT) {
1975 /* Connection Ok */
1976 entry->last_used = jiffies;
1977 *ret_entry = entry;
1978 found = entry->vcc;
1979 goto out;
1980 }
1981 /* Data direct VC not yet set up, check to see if the unknown
1982 frame count is greater than the limit. If the limit has
1983 not been reached, allow the caller to send packet to
1984 BUS. */
1985 if (entry->status != ESI_FLUSH_PENDING &&
1986 entry->packets_flooded<priv->maximum_unknown_frame_count) {
1987 entry->packets_flooded++;
1988 DPRINTK("LEC_ARP: Flooding..\n");
1989 found = priv->mcast_vcc;
1990 goto out;
1991 }
1992 /* We got here because entry->status == ESI_FLUSH_PENDING
1993 * or BUS flood limit was reached for an entry which is
1994 * in ESI_ARP_PENDING or ESI_VC_PENDING state.
1995 */
1996 *ret_entry = entry;
1997 DPRINTK("lec: entry->status %d entry->vcc %p\n", entry->status, entry->vcc);
1998 found = NULL;
1999 } else {
2000 /* No matching entry was found */
2001 entry = make_entry(priv, mac_to_find);
2002 DPRINTK("LEC_ARP: Making entry\n");
2003 if (!entry) {
2004 found = priv->mcast_vcc;
2005 goto out;
2006 }
2007 lec_arp_add(priv, entry);
2008 /* We want arp-request(s) to be sent */
2009 entry->packets_flooded =1;
2010 entry->status = ESI_ARP_PENDING;
2011 entry->no_tries = 1;
2012 entry->last_used = entry->timestamp = jiffies;
2013 entry->is_rdesc = is_rdesc;
2014 if (entry->is_rdesc)
2015 send_to_lecd(priv, l_rdesc_arp_xmt, mac_to_find, NULL, NULL);
2016 else
2017 send_to_lecd(priv, l_arp_xmt, mac_to_find, NULL, NULL);
2018 entry->timer.expires = jiffies + (1*HZ);
2019 entry->timer.function = lec_arp_expire_arp;
2020 add_timer(&entry->timer);
2021 found = priv->mcast_vcc;
2022 }
2023
2024 out:
2025 spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
2026 return found;
2027 }
2028
2029 int
2030 lec_addr_delete(struct lec_priv *priv, unsigned char *atm_addr,
2031 unsigned long permanent)
2032 {
2033 unsigned long flags;
2034 struct lec_arp_table *entry, *next;
2035 int i;
2036
2037 DPRINTK("lec_addr_delete\n");
2038 spin_lock_irqsave(&priv->lec_arp_lock, flags);
2039 for(i = 0; i < LEC_ARP_TABLE_SIZE; i++) {
2040 for(entry = priv->lec_arp_tables[i]; entry != NULL; entry = next) {
2041 next = entry->next;
2042 if (!memcmp(atm_addr, entry->atm_addr, ATM_ESA_LEN)
2043 && (permanent ||
2044 !(entry->flags & LEC_PERMANENT_FLAG))) {
2045 lec_arp_remove(priv, entry);
2046 kfree(entry);
2047 }
2048 spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
2049 return 0;
2050 }
2051 }
2052 spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
2053 return -1;
2054 }
2055
2056 /*
2057 * Notifies: Response to arp_request (atm_addr != NULL)
2058 */
2059 void
2060 lec_arp_update(struct lec_priv *priv, unsigned char *mac_addr,
2061 unsigned char *atm_addr, unsigned long remoteflag,
2062 unsigned int targetless_le_arp)
2063 {
2064 unsigned long flags;
2065 struct lec_arp_table *entry, *tmp;
2066 int i;
2067
2068 DPRINTK("lec:%s", (targetless_le_arp) ? "targetless ": " ");
2069 DPRINTK("lec_arp_update mac:%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x\n",
2070 mac_addr[0],mac_addr[1],mac_addr[2],mac_addr[3],
2071 mac_addr[4],mac_addr[5]);
2072
2073 spin_lock_irqsave(&priv->lec_arp_lock, flags);
2074 entry = lec_arp_find(priv, mac_addr);
2075 if (entry == NULL && targetless_le_arp)
2076 goto out; /* LANE2: ignore targetless LE_ARPs for which
2077 * we have no entry in the cache. 7.1.30
2078 */
2079 if (priv->lec_arp_empty_ones) {
2080 entry = priv->lec_arp_empty_ones;
2081 if (!memcmp(entry->atm_addr, atm_addr, ATM_ESA_LEN)) {
2082 priv->lec_arp_empty_ones = entry->next;
2083 } else {
2084 while(entry->next && memcmp(entry->next->atm_addr,
2085 atm_addr, ATM_ESA_LEN))
2086 entry = entry->next;
2087 if (entry->next) {
2088 tmp = entry;
2089 entry = entry->next;
2090 tmp->next = entry->next;
2091 } else
2092 entry = NULL;
2093
2094 }
2095 if (entry) {
2096 del_timer(&entry->timer);
2097 tmp = lec_arp_find(priv, mac_addr);
2098 if (tmp) {
2099 del_timer(&tmp->timer);
2100 tmp->status = ESI_FORWARD_DIRECT;
2101 memcpy(tmp->atm_addr, atm_addr, ATM_ESA_LEN);
2102 tmp->vcc = entry->vcc;
2103 tmp->old_push = entry->old_push;
2104 tmp->last_used = jiffies;
2105 del_timer(&entry->timer);
2106 kfree(entry);
2107 entry=tmp;
2108 } else {
2109 entry->status = ESI_FORWARD_DIRECT;
2110 memcpy(entry->mac_addr, mac_addr, ETH_ALEN);
2111 entry->last_used = jiffies;
2112 lec_arp_add(priv, entry);
2113 }
2114 if (remoteflag)
2115 entry->flags|=LEC_REMOTE_FLAG;
2116 else
2117 entry->flags&=~LEC_REMOTE_FLAG;
2118 DPRINTK("After update\n");
2119 dump_arp_table(priv);
2120 goto out;
2121 }
2122 }
2123 entry = lec_arp_find(priv, mac_addr);
2124 if (!entry) {
2125 entry = make_entry(priv, mac_addr);
2126 if (!entry)
2127 goto out;
2128 entry->status = ESI_UNKNOWN;
2129 lec_arp_add(priv, entry);
2130 /* Temporary, changes before end of function */
2131 }
2132 memcpy(entry->atm_addr, atm_addr, ATM_ESA_LEN);
2133 del_timer(&entry->timer);
2134 for(i = 0; i < LEC_ARP_TABLE_SIZE; i++) {
2135 for(tmp = priv->lec_arp_tables[i]; tmp; tmp=tmp->next) {
2136 if (entry != tmp &&
2137 !memcmp(tmp->atm_addr, atm_addr,
2138 ATM_ESA_LEN)) {
2139 /* Vcc to this host exists */
2140 if (tmp->status > ESI_VC_PENDING) {
2141 /*
2142 * ESI_FLUSH_PENDING,
2143 * ESI_FORWARD_DIRECT
2144 */
2145 entry->vcc = tmp->vcc;
2146 entry->old_push=tmp->old_push;
2147 }
2148 entry->status=tmp->status;
2149 break;
2150 }
2151 }
2152 }
2153 if (remoteflag)
2154 entry->flags|=LEC_REMOTE_FLAG;
2155 else
2156 entry->flags&=~LEC_REMOTE_FLAG;
2157 if (entry->status == ESI_ARP_PENDING ||
2158 entry->status == ESI_UNKNOWN) {
2159 entry->status = ESI_VC_PENDING;
2160 send_to_lecd(priv, l_svc_setup, entry->mac_addr, atm_addr, NULL);
2161 }
2162 DPRINTK("After update2\n");
2163 dump_arp_table(priv);
2164 out:
2165 spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
2166 }
2167
2168 /*
2169 * Notifies: Vcc setup ready
2170 */
2171 void
2172 lec_vcc_added(struct lec_priv *priv, struct atmlec_ioc *ioc_data,
2173 struct atm_vcc *vcc,
2174 void (*old_push)(struct atm_vcc *vcc, struct sk_buff *skb))
2175 {
2176 unsigned long flags;
2177 struct lec_arp_table *entry;
2178 int i, found_entry=0;
2179
2180 spin_lock_irqsave(&priv->lec_arp_lock, flags);
2181 if (ioc_data->receive == 2) {
2182 /* Vcc for Multicast Forward. No timer, LANEv2 7.1.20 and 2.3.5.3 */
2183
2184 DPRINTK("LEC_ARP: Attaching mcast forward\n");
2185 #if 0
2186 entry = lec_arp_find(priv, bus_mac);
2187 if (!entry) {
2188 printk("LEC_ARP: Multicast entry not found!\n");
2189 goto out;
2190 }
2191 memcpy(entry->atm_addr, ioc_data->atm_addr, ATM_ESA_LEN);
2192 entry->recv_vcc = vcc;
2193 entry->old_recv_push = old_push;
2194 #endif
2195 entry = make_entry(priv, bus_mac);
2196 if (entry == NULL)
2197 goto out;
2198 del_timer(&entry->timer);
2199 memcpy(entry->atm_addr, ioc_data->atm_addr, ATM_ESA_LEN);
2200 entry->recv_vcc = vcc;
2201 entry->old_recv_push = old_push;
2202 entry->next = priv->mcast_fwds;
2203 priv->mcast_fwds = entry;
2204 goto out;
2205 } else if (ioc_data->receive == 1) {
2206 /* Vcc which we don't want to make default vcc, attach it
2207 anyway. */
2208 DPRINTK("LEC_ARP:Attaching data direct, not default :%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x\n",
2209 ioc_data->atm_addr[0],ioc_data->atm_addr[1],
2210 ioc_data->atm_addr[2],ioc_data->atm_addr[3],
2211 ioc_data->atm_addr[4],ioc_data->atm_addr[5],
2212 ioc_data->atm_addr[6],ioc_data->atm_addr[7],
2213 ioc_data->atm_addr[8],ioc_data->atm_addr[9],
2214 ioc_data->atm_addr[10],ioc_data->atm_addr[11],
2215 ioc_data->atm_addr[12],ioc_data->atm_addr[13],
2216 ioc_data->atm_addr[14],ioc_data->atm_addr[15],
2217 ioc_data->atm_addr[16],ioc_data->atm_addr[17],
2218 ioc_data->atm_addr[18],ioc_data->atm_addr[19]);
2219 entry = make_entry(priv, bus_mac);
2220 if (entry == NULL)
2221 goto out;
2222 memcpy(entry->atm_addr, ioc_data->atm_addr, ATM_ESA_LEN);
2223 memset(entry->mac_addr, 0, ETH_ALEN);
2224 entry->recv_vcc = vcc;
2225 entry->old_recv_push = old_push;
2226 entry->status = ESI_UNKNOWN;
2227 entry->timer.expires = jiffies + priv->vcc_timeout_period;
2228 entry->timer.function = lec_arp_expire_vcc;
2229 add_timer(&entry->timer);
2230 entry->next = priv->lec_no_forward;
2231 priv->lec_no_forward = entry;
2232 dump_arp_table(priv);
2233 goto out;
2234 }
2235 DPRINTK("LEC_ARP:Attaching data direct, default:%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x\n",
2236 ioc_data->atm_addr[0],ioc_data->atm_addr[1],
2237 ioc_data->atm_addr[2],ioc_data->atm_addr[3],
2238 ioc_data->atm_addr[4],ioc_data->atm_addr[5],
2239 ioc_data->atm_addr[6],ioc_data->atm_addr[7],
2240 ioc_data->atm_addr[8],ioc_data->atm_addr[9],
2241 ioc_data->atm_addr[10],ioc_data->atm_addr[11],
2242 ioc_data->atm_addr[12],ioc_data->atm_addr[13],
2243 ioc_data->atm_addr[14],ioc_data->atm_addr[15],
2244 ioc_data->atm_addr[16],ioc_data->atm_addr[17],
2245 ioc_data->atm_addr[18],ioc_data->atm_addr[19]);
2246 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) {
2247 for (entry = priv->lec_arp_tables[i]; entry; entry=entry->next) {
2248 if (memcmp(ioc_data->atm_addr, entry->atm_addr,
2249 ATM_ESA_LEN)==0) {
2250 DPRINTK("LEC_ARP: Attaching data direct\n");
2251 DPRINTK("Currently -> Vcc: %d, Rvcc:%d\n",
2252 entry->vcc?entry->vcc->vci:0,
2253 entry->recv_vcc?entry->recv_vcc->vci:0);
2254 found_entry=1;
2255 del_timer(&entry->timer);
2256 entry->vcc = vcc;
2257 entry->old_push = old_push;
2258 if (entry->status == ESI_VC_PENDING) {
2259 if(priv->maximum_unknown_frame_count
2260 ==0)
2261 entry->status =
2262 ESI_FORWARD_DIRECT;
2263 else {
2264 entry->timestamp = jiffies;
2265 entry->status =
2266 ESI_FLUSH_PENDING;
2267 #if 0
2268 send_to_lecd(priv,l_flush_xmt,
2269 NULL,
2270 entry->atm_addr,
2271 NULL);
2272 #endif
2273 }
2274 } else {
2275 /* They were forming a connection
2276 to us, and we to them. Our
2277 ATM address is numerically lower
2278 than theirs, so we make connection
2279 we formed into default VCC (8.1.11).
2280 Connection they made gets torn
2281 down. This might confuse some
2282 clients. Can be changed if
2283 someone reports trouble... */
2284 ;
2285 }
2286 }
2287 }
2288 }
2289 if (found_entry) {
2290 DPRINTK("After vcc was added\n");
2291 dump_arp_table(priv);
2292 goto out;
2293 }
2294 /* Not found, snatch address from first data packet that arrives from
2295 this vcc */
2296 entry = make_entry(priv, bus_mac);
2297 if (!entry)
2298 goto out;
2299 entry->vcc = vcc;
2300 entry->old_push = old_push;
2301 memcpy(entry->atm_addr, ioc_data->atm_addr, ATM_ESA_LEN);
2302 memset(entry->mac_addr, 0, ETH_ALEN);
2303 entry->status = ESI_UNKNOWN;
2304 entry->next = priv->lec_arp_empty_ones;
2305 priv->lec_arp_empty_ones = entry;
2306 entry->timer.expires = jiffies + priv->vcc_timeout_period;
2307 entry->timer.function = lec_arp_expire_vcc;
2308 add_timer(&entry->timer);
2309 DPRINTK("After vcc was added\n");
2310 dump_arp_table(priv);
2311 out:
2312 spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
2313 }
2314
2315 void
2316 lec_flush_complete(struct lec_priv *priv, unsigned long tran_id)
2317 {
2318 unsigned long flags;
2319 struct lec_arp_table *entry;
2320 int i;
2321
2322 DPRINTK("LEC:lec_flush_complete %lx\n",tran_id);
2323 spin_lock_irqsave(&priv->lec_arp_lock, flags);
2324 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) {
2325 for (entry = priv->lec_arp_tables[i]; entry; entry=entry->next) {
2326 if (entry->flush_tran_id == tran_id &&
2327 entry->status == ESI_FLUSH_PENDING) {
2328 struct sk_buff *skb;
2329
2330 while ((skb = skb_dequeue(&entry->tx_wait)) != NULL)
2331 lec_send(entry->vcc, skb, entry->priv);
2332 entry->status = ESI_FORWARD_DIRECT;
2333 DPRINTK("LEC_ARP: Flushed\n");
2334 }
2335 }
2336 }
2337 spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
2338 dump_arp_table(priv);
2339 }
2340
2341 void
2342 lec_set_flush_tran_id(struct lec_priv *priv,
2343 unsigned char *atm_addr, unsigned long tran_id)
2344 {
2345 unsigned long flags;
2346 struct lec_arp_table *entry;
2347 int i;
2348
2349 spin_lock_irqsave(&priv->lec_arp_lock, flags);
2350 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++)
2351 for(entry = priv->lec_arp_tables[i]; entry; entry=entry->next)
2352 if (!memcmp(atm_addr, entry->atm_addr, ATM_ESA_LEN)) {
2353 entry->flush_tran_id = tran_id;
2354 DPRINTK("Set flush transaction id to %lx for %p\n",tran_id,entry);
2355 }
2356 spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
2357 }
2358
2359 int
2360 lec_mcast_make(struct lec_priv *priv, struct atm_vcc *vcc)
2361 {
2362 unsigned long flags;
2363 unsigned char mac_addr[] = {
2364 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
2365 struct lec_arp_table *to_add;
2366 struct lec_vcc_priv *vpriv;
2367 int err = 0;
2368
2369 if (!(vpriv = kmalloc(sizeof(struct lec_vcc_priv), GFP_KERNEL)))
2370 return -ENOMEM;
2371 vpriv->xoff = 0;
2372 vpriv->old_pop = vcc->pop;
2373 vcc->user_back = vpriv;
2374 vcc->pop = lec_pop;
2375 spin_lock_irqsave(&priv->lec_arp_lock, flags);
2376 to_add = make_entry(priv, mac_addr);
2377 if (!to_add) {
2378 vcc->pop = vpriv->old_pop;
2379 kfree(vpriv);
2380 err = -ENOMEM;
2381 goto out;
2382 }
2383 memcpy(to_add->atm_addr, vcc->remote.sas_addr.prv, ATM_ESA_LEN);
2384 to_add->status = ESI_FORWARD_DIRECT;
2385 to_add->flags |= LEC_PERMANENT_FLAG;
2386 to_add->vcc = vcc;
2387 to_add->old_push = vcc->push;
2388 vcc->push = lec_push;
2389 priv->mcast_vcc = vcc;
2390 lec_arp_add(priv, to_add);
2391 out:
2392 spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
2393 return err;
2394 }
2395
2396 void
2397 lec_vcc_close(struct lec_priv *priv, struct atm_vcc *vcc)
2398 {
2399 unsigned long flags;
2400 struct lec_arp_table *entry, *next;
2401 int i;
2402
2403 DPRINTK("LEC_ARP: lec_vcc_close vpi:%d vci:%d\n",vcc->vpi,vcc->vci);
2404 dump_arp_table(priv);
2405 spin_lock_irqsave(&priv->lec_arp_lock, flags);
2406 for(i=0;i<LEC_ARP_TABLE_SIZE;i++) {
2407 for(entry = priv->lec_arp_tables[i];entry; entry=next) {
2408 next = entry->next;
2409 if (vcc == entry->vcc) {
2410 lec_arp_remove(priv, entry);
2411 kfree(entry);
2412 if (priv->mcast_vcc == vcc) {
2413 priv->mcast_vcc = NULL;
2414 }
2415 }
2416 }
2417 }
2418
2419 entry = priv->lec_arp_empty_ones;
2420 priv->lec_arp_empty_ones = NULL;
2421 while (entry != NULL) {
2422 next = entry->next;
2423 if (entry->vcc == vcc) { /* leave it out from the list */
2424 lec_arp_clear_vccs(entry);
2425 del_timer(&entry->timer);
2426 kfree(entry);
2427 }
2428 else { /* put it back to the list */
2429 entry->next = priv->lec_arp_empty_ones;
2430 priv->lec_arp_empty_ones = entry;
2431 }
2432 entry = next;
2433 }
2434
2435 entry = priv->lec_no_forward;
2436 priv->lec_no_forward = NULL;
2437 while (entry != NULL) {
2438 next = entry->next;
2439 if (entry->recv_vcc == vcc) {
2440 lec_arp_clear_vccs(entry);
2441 del_timer(&entry->timer);
2442 kfree(entry);
2443 }
2444 else {
2445 entry->next = priv->lec_no_forward;
2446 priv->lec_no_forward = entry;
2447 }
2448 entry = next;
2449 }
2450
2451 entry = priv->mcast_fwds;
2452 priv->mcast_fwds = NULL;
2453 while (entry != NULL) {
2454 next = entry->next;
2455 if (entry->recv_vcc == vcc) {
2456 lec_arp_clear_vccs(entry);
2457 /* No timer, LANEv2 7.1.20 and 2.3.5.3 */
2458 kfree(entry);
2459 }
2460 else {
2461 entry->next = priv->mcast_fwds;
2462 priv->mcast_fwds = entry;
2463 }
2464 entry = next;
2465 }
2466
2467 spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
2468 dump_arp_table(priv);
2469 }
2470
2471 void
2472 lec_arp_check_empties(struct lec_priv *priv,
2473 struct atm_vcc *vcc, struct sk_buff *skb)
2474 {
2475 unsigned long flags;
2476 struct lec_arp_table *entry, *prev;
2477 struct lecdatahdr_8023 *hdr = (struct lecdatahdr_8023 *)skb->data;
2478 unsigned char *src;
2479 #ifdef CONFIG_TR
2480 struct lecdatahdr_8025 *tr_hdr = (struct lecdatahdr_8025 *)skb->data;
2481
2482 if (priv->is_trdev) src = tr_hdr->h_source;
2483 else
2484 #endif
2485 src = hdr->h_source;
2486
2487 spin_lock_irqsave(&priv->lec_arp_lock, flags);
2488 entry = priv->lec_arp_empty_ones;
2489 if (vcc == entry->vcc) {
2490 del_timer(&entry->timer);
2491 memcpy(entry->mac_addr, src, ETH_ALEN);
2492 entry->status = ESI_FORWARD_DIRECT;
2493 entry->last_used = jiffies;
2494 priv->lec_arp_empty_ones = entry->next;
2495 /* We might have got an entry */
2496 if ((prev = lec_arp_find(priv,src))) {
2497 lec_arp_remove(priv, prev);
2498 kfree(prev);
2499 }
2500 lec_arp_add(priv, entry);
2501 goto out;
2502 }
2503 prev = entry;
2504 entry = entry->next;
2505 while (entry && entry->vcc != vcc) {
2506 prev= entry;
2507 entry = entry->next;
2508 }
2509 if (!entry) {
2510 DPRINTK("LEC_ARP: Arp_check_empties: entry not found!\n");
2511 goto out;
2512 }
2513 del_timer(&entry->timer);
2514 memcpy(entry->mac_addr, src, ETH_ALEN);
2515 entry->status = ESI_FORWARD_DIRECT;
2516 entry->last_used = jiffies;
2517 prev->next = entry->next;
2518 if ((prev = lec_arp_find(priv, src))) {
2519 lec_arp_remove(priv, prev);
2520 kfree(prev);
2521 }
2522 lec_arp_add(priv, entry);
2523 out:
2524 spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
2525 }
2526 MODULE_LICENSE("GPL");
2527
|
This page was automatically generated by the
LXR engine.
|