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