1 // SPDX-License-Identifier: GPL-2.0-only
3 * lec.c: Lan Emulation driver
5 * Marko Kiiskila <mkiiskila@yahoo.com>
8 #define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__
10 #include <linux/slab.h>
11 #include <linux/kernel.h>
12 #include <linux/bitops.h>
13 #include <linux/capability.h>
15 /* We are ethernet device */
16 #include <linux/if_ether.h>
17 #include <linux/netdevice.h>
18 #include <linux/etherdevice.h>
20 #include <linux/skbuff.h>
22 #include <asm/byteorder.h>
23 #include <linux/uaccess.h>
26 #include <linux/proc_fs.h>
27 #include <linux/spinlock.h>
28 #include <linux/seq_file.h>
31 #include <linux/atmdev.h>
32 #include <linux/atmlec.h>
34 /* Proxy LEC knows about bridging */
35 #if IS_ENABLED(CONFIG_BRIDGE)
36 #include "../bridge/br_private.h"
38 static unsigned char bridge_ula_lec
[] = { 0x01, 0x80, 0xc2, 0x00, 0x00 };
42 #include <linux/module.h>
43 #include <linux/init.h>
45 /* Hardening for Spectre-v1 */
46 #include <linux/nospec.h>
50 #include "resources.h"
52 #define DUMP_PACKETS 0 /*
58 #define LEC_UNRES_QUE_LEN 8 /*
59 * number of tx packets to queue for a
60 * single destination while waiting for SVC
63 static int lec_open(struct net_device
*dev
);
64 static netdev_tx_t
lec_start_xmit(struct sk_buff
*skb
,
65 struct net_device
*dev
);
66 static int lec_close(struct net_device
*dev
);
67 static struct lec_arp_table
*lec_arp_find(struct lec_priv
*priv
,
68 const unsigned char *mac_addr
);
69 static int lec_arp_remove(struct lec_priv
*priv
,
70 struct lec_arp_table
*to_remove
);
72 static void lane2_associate_ind(struct net_device
*dev
, const u8
*mac_address
,
73 const u8
*tlvs
, u32 sizeoftlvs
);
74 static int lane2_resolve(struct net_device
*dev
, const u8
*dst_mac
, int force
,
75 u8
**tlvs
, u32
*sizeoftlvs
);
76 static int lane2_associate_req(struct net_device
*dev
, const u8
*lan_dst
,
77 const u8
*tlvs
, u32 sizeoftlvs
);
79 static int lec_addr_delete(struct lec_priv
*priv
, const unsigned char *atm_addr
,
80 unsigned long permanent
);
81 static void lec_arp_check_empties(struct lec_priv
*priv
,
82 struct atm_vcc
*vcc
, struct sk_buff
*skb
);
83 static void lec_arp_destroy(struct lec_priv
*priv
);
84 static void lec_arp_init(struct lec_priv
*priv
);
85 static struct atm_vcc
*lec_arp_resolve(struct lec_priv
*priv
,
86 const unsigned char *mac_to_find
,
88 struct lec_arp_table
**ret_entry
);
89 static void lec_arp_update(struct lec_priv
*priv
, const unsigned char *mac_addr
,
90 const unsigned char *atm_addr
,
91 unsigned long remoteflag
,
92 unsigned int targetless_le_arp
);
93 static void lec_flush_complete(struct lec_priv
*priv
, unsigned long tran_id
);
94 static int lec_mcast_make(struct lec_priv
*priv
, struct atm_vcc
*vcc
);
95 static void lec_set_flush_tran_id(struct lec_priv
*priv
,
96 const unsigned char *atm_addr
,
97 unsigned long tran_id
);
98 static void lec_vcc_added(struct lec_priv
*priv
,
99 const struct atmlec_ioc
*ioc_data
,
101 void (*old_push
)(struct atm_vcc
*vcc
,
102 struct sk_buff
*skb
));
103 static void lec_vcc_close(struct lec_priv
*priv
, struct atm_vcc
*vcc
);
105 /* must be done under lec_arp_lock */
106 static inline void lec_arp_hold(struct lec_arp_table
*entry
)
108 refcount_inc(&entry
->usage
);
111 static inline void lec_arp_put(struct lec_arp_table
*entry
)
113 if (refcount_dec_and_test(&entry
->usage
))
117 static struct lane2_ops lane2_ops
= {
118 .resolve
= lane2_resolve
, /* spec 3.1.3 */
119 .associate_req
= lane2_associate_req
, /* spec 3.1.4 */
120 .associate_indicator
= NULL
/* spec 3.1.5 */
123 static unsigned char bus_mac
[ETH_ALEN
] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
125 /* Device structures */
126 static struct net_device
*dev_lec
[MAX_LEC_ITF
];
128 #if IS_ENABLED(CONFIG_BRIDGE)
129 static void lec_handle_bridge(struct sk_buff
*skb
, struct net_device
*dev
)
132 struct lec_priv
*priv
;
135 * Check if this is a BPDU. If so, ask zeppelin to send
136 * LE_TOPOLOGY_REQUEST with the same value of Topology Change bit
137 * as the Config BPDU has
139 buff
= skb
->data
+ skb
->dev
->hard_header_len
;
140 if (*buff
++ == 0x42 && *buff
++ == 0x42 && *buff
++ == 0x03) {
142 struct sk_buff
*skb2
;
143 struct atmlec_msg
*mesg
;
145 skb2
= alloc_skb(sizeof(struct atmlec_msg
), GFP_ATOMIC
);
148 skb2
->len
= sizeof(struct atmlec_msg
);
149 mesg
= (struct atmlec_msg
*)skb2
->data
;
150 mesg
->type
= l_topology_change
;
152 mesg
->content
.normal
.flag
= *buff
& 0x01;
153 /* 0x01 is topology change */
155 priv
= netdev_priv(dev
);
156 atm_force_charge(priv
->lecd
, skb2
->truesize
);
157 sk
= sk_atm(priv
->lecd
);
158 skb_queue_tail(&sk
->sk_receive_queue
, skb2
);
159 sk
->sk_data_ready(sk
);
162 #endif /* IS_ENABLED(CONFIG_BRIDGE) */
165 * Open/initialize the netdevice. This is called (in the current kernel)
166 * sometime after booting when the 'ifconfig' program is run.
168 * This routine should set everything up anew at each open, even
169 * registers that "should" only need to be set once at boot, so that
170 * there is non-reboot way to recover if something goes wrong.
173 static int lec_open(struct net_device
*dev
)
175 netif_start_queue(dev
);
181 lec_send(struct atm_vcc
*vcc
, struct sk_buff
*skb
)
183 struct net_device
*dev
= skb
->dev
;
185 ATM_SKB(skb
)->vcc
= vcc
;
186 atm_account_tx(vcc
, skb
);
188 if (vcc
->send(vcc
, skb
) < 0) {
189 dev
->stats
.tx_dropped
++;
193 dev
->stats
.tx_packets
++;
194 dev
->stats
.tx_bytes
+= skb
->len
;
197 static void lec_tx_timeout(struct net_device
*dev
, unsigned int txqueue
)
199 pr_info("%s\n", dev
->name
);
200 netif_trans_update(dev
);
201 netif_wake_queue(dev
);
204 static netdev_tx_t
lec_start_xmit(struct sk_buff
*skb
,
205 struct net_device
*dev
)
207 struct sk_buff
*skb2
;
208 struct lec_priv
*priv
= netdev_priv(dev
);
209 struct lecdatahdr_8023
*lec_h
;
211 struct lec_arp_table
*entry
;
216 pr_debug("called\n");
218 pr_info("%s:No lecd attached\n", dev
->name
);
219 dev
->stats
.tx_errors
++;
220 netif_stop_queue(dev
);
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
);
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
)) {
246 /* Put le header to place */
247 lec_h
= (struct lecdatahdr_8023
*)skb
->data
;
248 lec_h
->le_header
= htons(priv
->lecid
);
250 #if DUMP_PACKETS >= 2
251 #define MAX_DUMP_SKB 99
252 #elif DUMP_PACKETS >= 1
253 #define MAX_DUMP_SKB 30
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 */
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
,
271 dev
->stats
.tx_dropped
++;
276 skb_put(skb
, min_frame_size
- skb
->len
);
279 /* Send to right vcc */
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
);
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
++;
300 printk(KERN_DEBUG
"%s:sending to vpi:%d vci:%d\n",
301 dev
->name
, vcc
->vpi
, vcc
->vci
);
302 #endif /* DUMP_PACKETS > 0 */
304 while (entry
&& (skb2
= skb_dequeue(&entry
->tx_wait
))) {
305 pr_debug("emptying tx queue, MAC address %pM\n", lec_h
->h_dest
);
311 if (!atm_may_send(vcc
, 0)) {
312 struct lec_vcc_priv
*vpriv
= LEC_VCC_PRIV(vcc
);
315 netif_stop_queue(dev
);
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.
323 if (atm_may_send(vcc
, 0))
324 netif_wake_queue(dev
);
330 netif_trans_update(dev
);
334 /* The inverse routine to net_open(). */
335 static int lec_close(struct net_device
*dev
)
337 netif_stop_queue(dev
);
341 static int lec_atm_send(struct atm_vcc
*vcc
, struct sk_buff
*skb
)
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
;
349 char *tmp
; /* FIXME */
351 WARN_ON(refcount_sub_and_test(skb
->truesize
, &sk_atm(vcc
)->sk_wmem_alloc
));
352 mesg
= (struct atmlec_msg
*)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
) {
358 for (i
= 0; i
< 6; i
++)
359 dev
->dev_addr
[i
] = mesg
->content
.normal
.mac_addr
[i
];
362 for (i
= 0; i
< 6; i
++)
363 dev
->dev_addr
[i
] = 0;
366 lec_addr_delete(priv
, mesg
->content
.normal
.atm_addr
,
367 mesg
->content
.normal
.flag
);
369 case l_topology_change
:
370 priv
->topology_change
= mesg
->content
.normal
.flag
;
372 case l_flush_complete
:
373 lec_flush_complete(priv
, mesg
->content
.normal
.flag
);
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
);
381 if (mesg
->content
.normal
.no_source_le_narp
)
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",
393 lane2_associate_ind(dev
, mesg
->content
.normal
.mac_addr
,
394 tmp
, mesg
->sizeoftlvs
);
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
;
413 priv
->lane2_ops
= NULL
;
414 if (priv
->lane_version
> 1)
415 priv
->lane2_ops
= &lane2_ops
;
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
);
421 priv
->is_proxy
= mesg
->content
.config
.is_proxy
;
423 case l_flush_tran_id
:
424 lec_set_flush_tran_id(priv
, mesg
->content
.normal
.atm_addr
,
425 mesg
->content
.normal
.flag
);
429 (unsigned short)(0xffff & mesg
->content
.normal
.flag
);
431 case l_should_bridge
:
432 #if IS_ENABLED(CONFIG_BRIDGE)
434 pr_debug("%s: bridge zeppelin asks about %pM\n",
435 dev
->name
, mesg
->content
.proxy
.mac_addr
);
437 if (br_fdb_test_addr_hook
== NULL
)
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
;
445 pr_debug("%s: entry found, responding to zeppelin\n",
447 skb2
= alloc_skb(sizeof(struct atmlec_msg
), GFP_ATOMIC
);
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
);
458 #endif /* IS_ENABLED(CONFIG_BRIDGE) */
461 pr_info("%s: Unknown message type %d\n", dev
->name
, mesg
->type
);
469 static void lec_atm_close(struct atm_vcc
*vcc
)
472 struct net_device
*dev
= (struct net_device
*)vcc
->proto_data
;
473 struct lec_priv
*priv
= netdev_priv(dev
);
476 /* Do something needful? */
478 netif_stop_queue(dev
);
479 lec_arp_destroy(priv
);
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
);
488 pr_info("%s: Shut down!\n", dev
->name
);
489 module_put(THIS_MODULE
);
492 static const struct atmdev_ops lecdev_ops
= {
493 .close
= lec_atm_close
,
497 static struct atm_dev lecatm_dev
= {
500 .number
= 999, /* dummy device number */
501 .lock
= __SPIN_LOCK_UNLOCKED(lecatm_dev
.lock
)
505 * LANE2: new argument struct sk_buff *data contains
506 * the LE_ARP based TLVs introduced in the LANE2 spec
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
)
515 struct atmlec_msg
*mesg
;
517 if (!priv
|| !priv
->lecd
)
519 skb
= alloc_skb(sizeof(struct atmlec_msg
), GFP_ATOMIC
);
522 skb
->len
= sizeof(struct atmlec_msg
);
523 mesg
= (struct atmlec_msg
*)skb
->data
;
524 memset(mesg
, 0, sizeof(struct atmlec_msg
));
527 mesg
->sizeoftlvs
= data
->len
;
529 ether_addr_copy(mesg
->content
.normal
.mac_addr
, mac_addr
);
531 mesg
->content
.normal
.targetless_le_arp
= 1;
533 memcpy(&mesg
->content
.normal
.atm_addr
, atm_addr
, ATM_ESA_LEN
);
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
);
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
);
550 static void lec_set_multicast_list(struct net_device
*dev
)
553 * by default, all multicast frames arrive over the bus.
554 * eventually support selective multicast service
558 static const struct net_device_ops lec_netdev_ops
= {
559 .ndo_open
= lec_open
,
560 .ndo_stop
= lec_close
,
561 .ndo_start_xmit
= lec_start_xmit
,
562 .ndo_tx_timeout
= lec_tx_timeout
,
563 .ndo_set_rx_mode
= lec_set_multicast_list
,
566 static const unsigned char lec_ctrl_magic
[] = {
573 #define LEC_DATA_DIRECT_8023 2
574 #define LEC_DATA_DIRECT_8025 3
576 static int lec_is_data_direct(struct atm_vcc
*vcc
)
578 return ((vcc
->sap
.blli
[0].l3
.tr9577
.snap
[4] == LEC_DATA_DIRECT_8023
) ||
579 (vcc
->sap
.blli
[0].l3
.tr9577
.snap
[4] == LEC_DATA_DIRECT_8025
));
582 static void lec_push(struct atm_vcc
*vcc
, struct sk_buff
*skb
)
585 struct net_device
*dev
= (struct net_device
*)vcc
->proto_data
;
586 struct lec_priv
*priv
= netdev_priv(dev
);
589 printk(KERN_DEBUG
"%s: vcc vpi:%d vci:%d\n",
590 dev
->name
, vcc
->vpi
, vcc
->vci
);
593 pr_debug("%s: null skb\n", dev
->name
);
594 lec_vcc_close(priv
, vcc
);
597 #if DUMP_PACKETS >= 2
598 #define MAX_SKB_DUMP 99
599 #elif DUMP_PACKETS >= 1
600 #define MAX_SKB_DUMP 30
603 printk(KERN_DEBUG
"%s: rcv datalen:%ld lecid:%4.4x\n",
604 dev
->name
, skb
->len
, priv
->lecid
);
605 print_hex_dump(KERN_DEBUG
, "", DUMP_OFFSET
, 16, 1,
606 skb
->data
, min(MAX_SKB_DUMP
, skb
->len
), true);
607 #endif /* DUMP_PACKETS > 0 */
608 if (memcmp(skb
->data
, lec_ctrl_magic
, 4) == 0) {
609 /* Control frame, to daemon */
610 struct sock
*sk
= sk_atm(vcc
);
612 pr_debug("%s: To daemon\n", dev
->name
);
613 skb_queue_tail(&sk
->sk_receive_queue
, skb
);
614 sk
->sk_data_ready(sk
);
615 } else { /* Data frame, queue to protocol handlers */
616 struct lec_arp_table
*entry
;
617 unsigned char *src
, *dst
;
619 atm_return(vcc
, skb
->truesize
);
620 if (*(__be16
*) skb
->data
== htons(priv
->lecid
) ||
621 !priv
->lecd
|| !(dev
->flags
& IFF_UP
)) {
623 * Probably looping back, or if lecd is missing,
626 pr_debug("Ignoring frame...\n");
630 dst
= ((struct lecdatahdr_8023
*)skb
->data
)->h_dest
;
633 * If this is a Data Direct VCC, and the VCC does not match
634 * the LE_ARP cache entry, delete the LE_ARP cache entry.
636 spin_lock_irqsave(&priv
->lec_arp_lock
, flags
);
637 if (lec_is_data_direct(vcc
)) {
638 src
= ((struct lecdatahdr_8023
*)skb
->data
)->h_source
;
639 entry
= lec_arp_find(priv
, src
);
640 if (entry
&& entry
->vcc
!= vcc
) {
641 lec_arp_remove(priv
, entry
);
645 spin_unlock_irqrestore(&priv
->lec_arp_lock
, flags
);
647 if (!(dst
[0] & 0x01) && /* Never filter Multi/Broadcast */
648 !priv
->is_proxy
&& /* Proxy wants all the packets */
649 memcmp(dst
, dev
->dev_addr
, dev
->addr_len
)) {
653 if (!hlist_empty(&priv
->lec_arp_empty_ones
))
654 lec_arp_check_empties(priv
, vcc
, skb
);
655 skb_pull(skb
, 2); /* skip lec_id */
656 skb
->protocol
= eth_type_trans(skb
, dev
);
657 dev
->stats
.rx_packets
++;
658 dev
->stats
.rx_bytes
+= skb
->len
;
659 memset(ATM_SKB(skb
), 0, sizeof(struct atm_skb_data
));
664 static void lec_pop(struct atm_vcc
*vcc
, struct sk_buff
*skb
)
666 struct lec_vcc_priv
*vpriv
= LEC_VCC_PRIV(vcc
);
667 struct net_device
*dev
= skb
->dev
;
670 pr_info("vpriv = NULL!?!?!?\n");
674 vpriv
->old_pop(vcc
, skb
);
676 if (vpriv
->xoff
&& atm_may_send(vcc
, 0)) {
678 if (netif_running(dev
) && netif_queue_stopped(dev
))
679 netif_wake_queue(dev
);
683 static int lec_vcc_attach(struct atm_vcc
*vcc
, void __user
*arg
)
685 struct lec_vcc_priv
*vpriv
;
687 struct atmlec_ioc ioc_data
;
689 /* Lecd must be up in this case */
690 bytes_left
= copy_from_user(&ioc_data
, arg
, sizeof(struct atmlec_ioc
));
692 pr_info("copy from user failed for %d bytes\n", bytes_left
);
693 if (ioc_data
.dev_num
< 0 || ioc_data
.dev_num
>= MAX_LEC_ITF
)
695 ioc_data
.dev_num
= array_index_nospec(ioc_data
.dev_num
, MAX_LEC_ITF
);
696 if (!dev_lec
[ioc_data
.dev_num
])
698 vpriv
= kmalloc(sizeof(struct lec_vcc_priv
), GFP_KERNEL
);
702 vpriv
->old_pop
= vcc
->pop
;
703 vcc
->user_back
= vpriv
;
705 lec_vcc_added(netdev_priv(dev_lec
[ioc_data
.dev_num
]),
706 &ioc_data
, vcc
, vcc
->push
);
707 vcc
->proto_data
= dev_lec
[ioc_data
.dev_num
];
708 vcc
->push
= lec_push
;
712 static int lec_mcast_attach(struct atm_vcc
*vcc
, int arg
)
714 if (arg
< 0 || arg
>= MAX_LEC_ITF
)
716 arg
= array_index_nospec(arg
, MAX_LEC_ITF
);
719 vcc
->proto_data
= dev_lec
[arg
];
720 return lec_mcast_make(netdev_priv(dev_lec
[arg
]), vcc
);
723 /* Initialize device. */
724 static int lecd_attach(struct atm_vcc
*vcc
, int arg
)
727 struct lec_priv
*priv
;
731 if (arg
>= MAX_LEC_ITF
)
733 i
= array_index_nospec(arg
, MAX_LEC_ITF
);
737 size
= sizeof(struct lec_priv
);
738 dev_lec
[i
] = alloc_etherdev(size
);
741 dev_lec
[i
]->netdev_ops
= &lec_netdev_ops
;
742 dev_lec
[i
]->max_mtu
= 18190;
743 snprintf(dev_lec
[i
]->name
, IFNAMSIZ
, "lec%d", i
);
744 if (register_netdev(dev_lec
[i
])) {
745 free_netdev(dev_lec
[i
]);
749 priv
= netdev_priv(dev_lec
[i
]);
751 priv
= netdev_priv(dev_lec
[i
]);
756 priv
->itfnum
= i
; /* LANE2 addition */
758 vcc
->dev
= &lecatm_dev
;
759 vcc_insert_socket(sk_atm(vcc
));
761 vcc
->proto_data
= dev_lec
[i
];
762 set_bit(ATM_VF_META
, &vcc
->flags
);
763 set_bit(ATM_VF_READY
, &vcc
->flags
);
765 /* Set default values to these variables */
766 priv
->maximum_unknown_frame_count
= 1;
767 priv
->max_unknown_frame_time
= (1 * HZ
);
768 priv
->vcc_timeout_period
= (1200 * HZ
);
769 priv
->max_retry_count
= 1;
770 priv
->aging_time
= (300 * HZ
);
771 priv
->forward_delay_time
= (15 * HZ
);
772 priv
->topology_change
= 0;
773 priv
->arp_response_time
= (1 * HZ
);
774 priv
->flush_timeout
= (4 * HZ
);
775 priv
->path_switching_delay
= (6 * HZ
);
777 if (dev_lec
[i
]->flags
& IFF_UP
)
778 netif_start_queue(dev_lec
[i
]);
779 __module_get(THIS_MODULE
);
783 #ifdef CONFIG_PROC_FS
784 static const char *lec_arp_get_status_string(unsigned char status
)
786 static const char *const lec_arp_status_string
[] = {
791 "ESI_FLUSH_PENDING ",
795 if (status
> ESI_FORWARD_DIRECT
)
796 status
= 3; /* ESI_UNDEFINED */
797 return lec_arp_status_string
[status
];
800 static void lec_info(struct seq_file
*seq
, struct lec_arp_table
*entry
)
802 seq_printf(seq
, "%pM ", entry
->mac_addr
);
803 seq_printf(seq
, "%*phN ", ATM_ESA_LEN
, entry
->atm_addr
);
804 seq_printf(seq
, "%s %4.4x", lec_arp_get_status_string(entry
->status
),
805 entry
->flags
& 0xffff);
807 seq_printf(seq
, "%3d %3d ", entry
->vcc
->vpi
, entry
->vcc
->vci
);
809 seq_printf(seq
, " ");
810 if (entry
->recv_vcc
) {
811 seq_printf(seq
, " %3d %3d", entry
->recv_vcc
->vpi
,
812 entry
->recv_vcc
->vci
);
819 struct lec_priv
*locked
;
820 struct hlist_node
*node
;
821 struct net_device
*dev
;
827 static void *lec_tbl_walk(struct lec_state
*state
, struct hlist_head
*tbl
,
830 struct hlist_node
*e
= state
->node
;
834 if (e
== SEQ_START_TOKEN
) {
839 for (; e
; e
= e
->next
) {
845 return (*l
< 0) ? state
: NULL
;
848 static void *lec_arp_walk(struct lec_state
*state
, loff_t
*l
,
849 struct lec_priv
*priv
)
854 for (p
= state
->arp_table
; p
< LEC_ARP_TABLE_SIZE
; p
++) {
855 v
= lec_tbl_walk(state
, &priv
->lec_arp_tables
[p
], l
);
859 state
->arp_table
= p
;
863 static void *lec_misc_walk(struct lec_state
*state
, loff_t
*l
,
864 struct lec_priv
*priv
)
866 struct hlist_head
*lec_misc_tables
[] = {
867 &priv
->lec_arp_empty_ones
,
868 &priv
->lec_no_forward
,
874 for (q
= state
->misc_table
; q
< ARRAY_SIZE(lec_misc_tables
); q
++) {
875 v
= lec_tbl_walk(state
, lec_misc_tables
[q
], l
);
879 state
->misc_table
= q
;
883 static void *lec_priv_walk(struct lec_state
*state
, loff_t
*l
,
884 struct lec_priv
*priv
)
886 if (!state
->locked
) {
887 state
->locked
= priv
;
888 spin_lock_irqsave(&priv
->lec_arp_lock
, state
->flags
);
890 if (!lec_arp_walk(state
, l
, priv
) && !lec_misc_walk(state
, l
, priv
)) {
891 spin_unlock_irqrestore(&priv
->lec_arp_lock
, state
->flags
);
892 state
->locked
= NULL
;
893 /* Partial state reset for the next time we get called */
894 state
->arp_table
= state
->misc_table
= 0;
896 return state
->locked
;
899 static void *lec_itf_walk(struct lec_state
*state
, loff_t
*l
)
901 struct net_device
*dev
;
904 dev
= state
->dev
? state
->dev
: dev_lec
[state
->itf
];
905 v
= (dev
&& netdev_priv(dev
)) ?
906 lec_priv_walk(state
, l
, netdev_priv(dev
)) : NULL
;
909 /* Partial state reset for the next time we get called */
916 static void *lec_get_idx(struct lec_state
*state
, loff_t l
)
920 for (; state
->itf
< MAX_LEC_ITF
; state
->itf
++) {
921 v
= lec_itf_walk(state
, &l
);
928 static void *lec_seq_start(struct seq_file
*seq
, loff_t
*pos
)
930 struct lec_state
*state
= seq
->private;
934 state
->locked
= NULL
;
935 state
->arp_table
= 0;
936 state
->misc_table
= 0;
937 state
->node
= SEQ_START_TOKEN
;
939 return *pos
? lec_get_idx(state
, *pos
) : SEQ_START_TOKEN
;
942 static void lec_seq_stop(struct seq_file
*seq
, void *v
)
944 struct lec_state
*state
= seq
->private;
947 spin_unlock_irqrestore(&state
->locked
->lec_arp_lock
,
953 static void *lec_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
955 struct lec_state
*state
= seq
->private;
957 v
= lec_get_idx(state
, 1);
958 *pos
+= !!PTR_ERR(v
);
962 static int lec_seq_show(struct seq_file
*seq
, void *v
)
964 static const char lec_banner
[] =
965 "Itf MAC ATM destination"
967 "VPI/VCI Recv VPI/VCI\n";
969 if (v
== SEQ_START_TOKEN
)
970 seq_puts(seq
, lec_banner
);
972 struct lec_state
*state
= seq
->private;
973 struct net_device
*dev
= state
->dev
;
974 struct lec_arp_table
*entry
= hlist_entry(state
->node
,
975 struct lec_arp_table
,
978 seq_printf(seq
, "%s ", dev
->name
);
979 lec_info(seq
, entry
);
984 static const struct seq_operations lec_seq_ops
= {
985 .start
= lec_seq_start
,
986 .next
= lec_seq_next
,
987 .stop
= lec_seq_stop
,
988 .show
= lec_seq_show
,
992 static int lane_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
994 struct atm_vcc
*vcc
= ATM_SD(sock
);
1001 if (!capable(CAP_NET_ADMIN
))
1005 return -ENOIOCTLCMD
;
1010 err
= lecd_attach(vcc
, (int)arg
);
1012 sock
->state
= SS_CONNECTED
;
1015 err
= lec_mcast_attach(vcc
, (int)arg
);
1018 err
= lec_vcc_attach(vcc
, (void __user
*)arg
);
1025 static struct atm_ioctl lane_ioctl_ops
= {
1026 .owner
= THIS_MODULE
,
1027 .ioctl
= lane_ioctl
,
1030 static int __init
lane_module_init(void)
1032 #ifdef CONFIG_PROC_FS
1033 struct proc_dir_entry
*p
;
1035 p
= proc_create_seq_private("lec", 0444, atm_proc_root
, &lec_seq_ops
,
1036 sizeof(struct lec_state
), NULL
);
1038 pr_err("Unable to initialize /proc/net/atm/lec\n");
1043 register_atm_ioctl(&lane_ioctl_ops
);
1044 pr_info("lec.c: initialized\n");
1048 static void __exit
lane_module_cleanup(void)
1052 #ifdef CONFIG_PROC_FS
1053 remove_proc_entry("lec", atm_proc_root
);
1056 deregister_atm_ioctl(&lane_ioctl_ops
);
1058 for (i
= 0; i
< MAX_LEC_ITF
; i
++) {
1059 if (dev_lec
[i
] != NULL
) {
1060 unregister_netdev(dev_lec
[i
]);
1061 free_netdev(dev_lec
[i
]);
1067 module_init(lane_module_init
);
1068 module_exit(lane_module_cleanup
);
1071 * LANE2: 3.1.3, LE_RESOLVE.request
1072 * Non force allocates memory and fills in *tlvs, fills in *sizeoftlvs.
1073 * If sizeoftlvs == NULL the default TLVs associated with with this
1075 * If dst_mac == NULL, targetless LE_ARP will be sent
1077 static int lane2_resolve(struct net_device
*dev
, const u8
*dst_mac
, int force
,
1078 u8
**tlvs
, u32
*sizeoftlvs
)
1080 unsigned long flags
;
1081 struct lec_priv
*priv
= netdev_priv(dev
);
1082 struct lec_arp_table
*table
;
1083 struct sk_buff
*skb
;
1087 spin_lock_irqsave(&priv
->lec_arp_lock
, flags
);
1088 table
= lec_arp_find(priv
, dst_mac
);
1089 spin_unlock_irqrestore(&priv
->lec_arp_lock
, flags
);
1093 *tlvs
= kmemdup(table
->tlvs
, table
->sizeoftlvs
, GFP_ATOMIC
);
1097 *sizeoftlvs
= table
->sizeoftlvs
;
1102 if (sizeoftlvs
== NULL
)
1103 retval
= send_to_lecd(priv
, l_arp_xmt
, dst_mac
, NULL
, NULL
);
1106 skb
= alloc_skb(*sizeoftlvs
, GFP_ATOMIC
);
1109 skb
->len
= *sizeoftlvs
;
1110 skb_copy_to_linear_data(skb
, *tlvs
, *sizeoftlvs
);
1111 retval
= send_to_lecd(priv
, l_arp_xmt
, dst_mac
, NULL
, skb
);
1117 * LANE2: 3.1.4, LE_ASSOCIATE.request
1118 * Associate the *tlvs with the *lan_dst address.
1119 * Will overwrite any previous association
1120 * Returns 1 for success, 0 for failure (out of memory)
1123 static int lane2_associate_req(struct net_device
*dev
, const u8
*lan_dst
,
1124 const u8
*tlvs
, u32 sizeoftlvs
)
1127 struct sk_buff
*skb
;
1128 struct lec_priv
*priv
= netdev_priv(dev
);
1130 if (!ether_addr_equal(lan_dst
, dev
->dev_addr
))
1131 return 0; /* not our mac address */
1133 kfree(priv
->tlvs
); /* NULL if there was no previous association */
1135 priv
->tlvs
= kmemdup(tlvs
, sizeoftlvs
, GFP_KERNEL
);
1136 if (priv
->tlvs
== NULL
)
1138 priv
->sizeoftlvs
= sizeoftlvs
;
1140 skb
= alloc_skb(sizeoftlvs
, GFP_ATOMIC
);
1143 skb
->len
= sizeoftlvs
;
1144 skb_copy_to_linear_data(skb
, tlvs
, sizeoftlvs
);
1145 retval
= send_to_lecd(priv
, l_associate_req
, NULL
, NULL
, skb
);
1147 pr_info("lec.c: lane2_associate_req() failed\n");
1149 * If the previous association has changed we must
1150 * somehow notify other LANE entities about the change
1156 * LANE2: 3.1.5, LE_ASSOCIATE.indication
1159 static void lane2_associate_ind(struct net_device
*dev
, const u8
*mac_addr
,
1160 const u8
*tlvs
, u32 sizeoftlvs
)
1165 struct lec_priv
*priv
= netdev_priv(dev
);
1167 * Why have the TLVs in LE_ARP entries
1168 * since we do not use them? When you
1169 * uncomment this code, make sure the
1170 * TLVs get freed when entry is killed
1172 struct lec_arp_table
*entry
= lec_arp_find(priv
, mac_addr
);
1175 return; /* should not happen */
1179 entry
->tlvs
= kmemdup(tlvs
, sizeoftlvs
, GFP_KERNEL
);
1180 if (entry
->tlvs
== NULL
)
1182 entry
->sizeoftlvs
= sizeoftlvs
;
1186 pr_info("dump of tlvs, sizeoftlvs=%d\n", sizeoftlvs
);
1187 while (i
< sizeoftlvs
)
1188 pr_cont("%02x ", tlvs
[i
++]);
1193 /* tell MPOA about the TLVs we saw */
1194 if (priv
->lane2_ops
&& priv
->lane2_ops
->associate_indicator
) {
1195 priv
->lane2_ops
->associate_indicator(dev
, mac_addr
,
1201 * Here starts what used to lec_arpc.c
1203 * lec_arpc.c was added here when making
1204 * lane client modular. October 1997
1207 #include <linux/types.h>
1208 #include <linux/timer.h>
1209 #include <linux/param.h>
1210 #include <linux/atomic.h>
1211 #include <linux/inetdevice.h>
1212 #include <net/route.h>
1215 #define pr_debug(format, args...)
1217 #define pr_debug printk
1220 #define DEBUG_ARP_TABLE 0
1222 #define LEC_ARP_REFRESH_INTERVAL (3*HZ)
1224 static void lec_arp_check_expire(struct work_struct
*work
);
1225 static void lec_arp_expire_arp(struct timer_list
*t
);
1231 #define HASH(ch) (ch & (LEC_ARP_TABLE_SIZE - 1))
1234 * Initialization of arp-cache
1236 static void lec_arp_init(struct lec_priv
*priv
)
1240 for (i
= 0; i
< LEC_ARP_TABLE_SIZE
; i
++)
1241 INIT_HLIST_HEAD(&priv
->lec_arp_tables
[i
]);
1242 INIT_HLIST_HEAD(&priv
->lec_arp_empty_ones
);
1243 INIT_HLIST_HEAD(&priv
->lec_no_forward
);
1244 INIT_HLIST_HEAD(&priv
->mcast_fwds
);
1245 spin_lock_init(&priv
->lec_arp_lock
);
1246 INIT_DELAYED_WORK(&priv
->lec_arp_work
, lec_arp_check_expire
);
1247 schedule_delayed_work(&priv
->lec_arp_work
, LEC_ARP_REFRESH_INTERVAL
);
1250 static void lec_arp_clear_vccs(struct lec_arp_table
*entry
)
1253 struct atm_vcc
*vcc
= entry
->vcc
;
1254 struct lec_vcc_priv
*vpriv
= LEC_VCC_PRIV(vcc
);
1255 struct net_device
*dev
= (struct net_device
*)vcc
->proto_data
;
1257 vcc
->pop
= vpriv
->old_pop
;
1259 netif_wake_queue(dev
);
1261 vcc
->user_back
= NULL
;
1262 vcc
->push
= entry
->old_push
;
1263 vcc_release_async(vcc
, -EPIPE
);
1266 if (entry
->recv_vcc
) {
1267 struct atm_vcc
*vcc
= entry
->recv_vcc
;
1268 struct lec_vcc_priv
*vpriv
= LEC_VCC_PRIV(vcc
);
1271 vcc
->user_back
= NULL
;
1273 entry
->recv_vcc
->push
= entry
->old_recv_push
;
1274 vcc_release_async(entry
->recv_vcc
, -EPIPE
);
1275 entry
->recv_vcc
= NULL
;
1280 * Insert entry to lec_arp_table
1281 * LANE2: Add to the end of the list to satisfy 8.1.13
1284 lec_arp_add(struct lec_priv
*priv
, struct lec_arp_table
*entry
)
1286 struct hlist_head
*tmp
;
1288 tmp
= &priv
->lec_arp_tables
[HASH(entry
->mac_addr
[ETH_ALEN
- 1])];
1289 hlist_add_head(&entry
->next
, tmp
);
1291 pr_debug("Added entry:%pM\n", entry
->mac_addr
);
1295 * Remove entry from lec_arp_table
1298 lec_arp_remove(struct lec_priv
*priv
, struct lec_arp_table
*to_remove
)
1300 struct lec_arp_table
*entry
;
1301 int i
, remove_vcc
= 1;
1306 hlist_del(&to_remove
->next
);
1307 del_timer(&to_remove
->timer
);
1310 * If this is the only MAC connected to this VCC,
1311 * also tear down the VCC
1313 if (to_remove
->status
>= ESI_FLUSH_PENDING
) {
1315 * ESI_FLUSH_PENDING, ESI_FORWARD_DIRECT
1317 for (i
= 0; i
< LEC_ARP_TABLE_SIZE
; i
++) {
1318 hlist_for_each_entry(entry
,
1319 &priv
->lec_arp_tables
[i
], next
) {
1320 if (memcmp(to_remove
->atm_addr
,
1321 entry
->atm_addr
, ATM_ESA_LEN
) == 0) {
1328 lec_arp_clear_vccs(to_remove
);
1330 skb_queue_purge(&to_remove
->tx_wait
); /* FIXME: good place for this? */
1332 pr_debug("Removed entry:%pM\n", to_remove
->mac_addr
);
1337 static const char *get_status_string(unsigned char st
)
1341 return "ESI_UNKNOWN";
1342 case ESI_ARP_PENDING
:
1343 return "ESI_ARP_PENDING";
1344 case ESI_VC_PENDING
:
1345 return "ESI_VC_PENDING";
1346 case ESI_FLUSH_PENDING
:
1347 return "ESI_FLUSH_PENDING";
1348 case ESI_FORWARD_DIRECT
:
1349 return "ESI_FORWARD_DIRECT";
1354 static void dump_arp_table(struct lec_priv
*priv
)
1356 struct lec_arp_table
*rulla
;
1360 pr_info("Dump %p:\n", priv
);
1361 for (i
= 0; i
< LEC_ARP_TABLE_SIZE
; i
++) {
1362 hlist_for_each_entry(rulla
,
1363 &priv
->lec_arp_tables
[i
], next
) {
1365 offset
+= sprintf(buf
, "%d: %p\n", i
, rulla
);
1366 offset
+= sprintf(buf
+ offset
, "Mac: %pM ",
1368 offset
+= sprintf(buf
+ offset
, "Atm: %*ph ", ATM_ESA_LEN
,
1370 offset
+= sprintf(buf
+ offset
,
1371 "Vcc vpi:%d vci:%d, Recv_vcc vpi:%d vci:%d Last_used:%lx, Timestamp:%lx, No_tries:%d ",
1372 rulla
->vcc
? rulla
->vcc
->vpi
: 0,
1373 rulla
->vcc
? rulla
->vcc
->vci
: 0,
1374 rulla
->recv_vcc
? rulla
->recv_vcc
->
1376 rulla
->recv_vcc
? rulla
->recv_vcc
->
1377 vci
: 0, rulla
->last_used
,
1378 rulla
->timestamp
, rulla
->no_tries
);
1380 sprintf(buf
+ offset
,
1381 "Flags:%x, Packets_flooded:%x, Status: %s ",
1382 rulla
->flags
, rulla
->packets_flooded
,
1383 get_status_string(rulla
->status
));
1384 pr_info("%s\n", buf
);
1388 if (!hlist_empty(&priv
->lec_no_forward
))
1389 pr_info("No forward\n");
1390 hlist_for_each_entry(rulla
, &priv
->lec_no_forward
, next
) {
1392 offset
+= sprintf(buf
+ offset
, "Mac: %pM ", rulla
->mac_addr
);
1393 offset
+= sprintf(buf
+ offset
, "Atm: %*ph ", ATM_ESA_LEN
,
1395 offset
+= sprintf(buf
+ offset
,
1396 "Vcc vpi:%d vci:%d, Recv_vcc vpi:%d vci:%d Last_used:%lx, Timestamp:%lx, No_tries:%d ",
1397 rulla
->vcc
? rulla
->vcc
->vpi
: 0,
1398 rulla
->vcc
? rulla
->vcc
->vci
: 0,
1399 rulla
->recv_vcc
? rulla
->recv_vcc
->vpi
: 0,
1400 rulla
->recv_vcc
? rulla
->recv_vcc
->vci
: 0,
1402 rulla
->timestamp
, rulla
->no_tries
);
1403 offset
+= sprintf(buf
+ offset
,
1404 "Flags:%x, Packets_flooded:%x, Status: %s ",
1405 rulla
->flags
, rulla
->packets_flooded
,
1406 get_status_string(rulla
->status
));
1407 pr_info("%s\n", buf
);
1410 if (!hlist_empty(&priv
->lec_arp_empty_ones
))
1411 pr_info("Empty ones\n");
1412 hlist_for_each_entry(rulla
, &priv
->lec_arp_empty_ones
, next
) {
1414 offset
+= sprintf(buf
+ offset
, "Mac: %pM ", rulla
->mac_addr
);
1415 offset
+= sprintf(buf
+ offset
, "Atm: %*ph ", ATM_ESA_LEN
,
1417 offset
+= sprintf(buf
+ offset
,
1418 "Vcc vpi:%d vci:%d, Recv_vcc vpi:%d vci:%d Last_used:%lx, Timestamp:%lx, No_tries:%d ",
1419 rulla
->vcc
? rulla
->vcc
->vpi
: 0,
1420 rulla
->vcc
? rulla
->vcc
->vci
: 0,
1421 rulla
->recv_vcc
? rulla
->recv_vcc
->vpi
: 0,
1422 rulla
->recv_vcc
? rulla
->recv_vcc
->vci
: 0,
1424 rulla
->timestamp
, rulla
->no_tries
);
1425 offset
+= sprintf(buf
+ offset
,
1426 "Flags:%x, Packets_flooded:%x, Status: %s ",
1427 rulla
->flags
, rulla
->packets_flooded
,
1428 get_status_string(rulla
->status
));
1432 if (!hlist_empty(&priv
->mcast_fwds
))
1433 pr_info("Multicast Forward VCCs\n");
1434 hlist_for_each_entry(rulla
, &priv
->mcast_fwds
, next
) {
1436 offset
+= sprintf(buf
+ offset
, "Mac: %pM ", rulla
->mac_addr
);
1437 offset
+= sprintf(buf
+ offset
, "Atm: %*ph ", ATM_ESA_LEN
,
1439 offset
+= sprintf(buf
+ offset
,
1440 "Vcc vpi:%d vci:%d, Recv_vcc vpi:%d vci:%d Last_used:%lx, Timestamp:%lx, No_tries:%d ",
1441 rulla
->vcc
? rulla
->vcc
->vpi
: 0,
1442 rulla
->vcc
? rulla
->vcc
->vci
: 0,
1443 rulla
->recv_vcc
? rulla
->recv_vcc
->vpi
: 0,
1444 rulla
->recv_vcc
? rulla
->recv_vcc
->vci
: 0,
1446 rulla
->timestamp
, rulla
->no_tries
);
1447 offset
+= sprintf(buf
+ offset
,
1448 "Flags:%x, Packets_flooded:%x, Status: %s ",
1449 rulla
->flags
, rulla
->packets_flooded
,
1450 get_status_string(rulla
->status
));
1451 pr_info("%s\n", buf
);
1456 #define dump_arp_table(priv) do { } while (0)
1460 * Destruction of arp-cache
1462 static void lec_arp_destroy(struct lec_priv
*priv
)
1464 unsigned long flags
;
1465 struct hlist_node
*next
;
1466 struct lec_arp_table
*entry
;
1469 cancel_delayed_work_sync(&priv
->lec_arp_work
);
1472 * Remove all entries
1475 spin_lock_irqsave(&priv
->lec_arp_lock
, flags
);
1476 for (i
= 0; i
< LEC_ARP_TABLE_SIZE
; i
++) {
1477 hlist_for_each_entry_safe(entry
, next
,
1478 &priv
->lec_arp_tables
[i
], next
) {
1479 lec_arp_remove(priv
, entry
);
1482 INIT_HLIST_HEAD(&priv
->lec_arp_tables
[i
]);
1485 hlist_for_each_entry_safe(entry
, next
,
1486 &priv
->lec_arp_empty_ones
, next
) {
1487 del_timer_sync(&entry
->timer
);
1488 lec_arp_clear_vccs(entry
);
1489 hlist_del(&entry
->next
);
1492 INIT_HLIST_HEAD(&priv
->lec_arp_empty_ones
);
1494 hlist_for_each_entry_safe(entry
, next
,
1495 &priv
->lec_no_forward
, next
) {
1496 del_timer_sync(&entry
->timer
);
1497 lec_arp_clear_vccs(entry
);
1498 hlist_del(&entry
->next
);
1501 INIT_HLIST_HEAD(&priv
->lec_no_forward
);
1503 hlist_for_each_entry_safe(entry
, next
, &priv
->mcast_fwds
, next
) {
1504 /* No timer, LANEv2 7.1.20 and 2.3.5.3 */
1505 lec_arp_clear_vccs(entry
);
1506 hlist_del(&entry
->next
);
1509 INIT_HLIST_HEAD(&priv
->mcast_fwds
);
1510 priv
->mcast_vcc
= NULL
;
1511 spin_unlock_irqrestore(&priv
->lec_arp_lock
, flags
);
1515 * Find entry by mac_address
1517 static struct lec_arp_table
*lec_arp_find(struct lec_priv
*priv
,
1518 const unsigned char *mac_addr
)
1520 struct hlist_head
*head
;
1521 struct lec_arp_table
*entry
;
1523 pr_debug("%pM\n", mac_addr
);
1525 head
= &priv
->lec_arp_tables
[HASH(mac_addr
[ETH_ALEN
- 1])];
1526 hlist_for_each_entry(entry
, head
, next
) {
1527 if (ether_addr_equal(mac_addr
, entry
->mac_addr
))
1533 static struct lec_arp_table
*make_entry(struct lec_priv
*priv
,
1534 const unsigned char *mac_addr
)
1536 struct lec_arp_table
*to_return
;
1538 to_return
= kzalloc(sizeof(struct lec_arp_table
), GFP_ATOMIC
);
1540 pr_info("LEC: Arp entry kmalloc failed\n");
1543 ether_addr_copy(to_return
->mac_addr
, mac_addr
);
1544 INIT_HLIST_NODE(&to_return
->next
);
1545 timer_setup(&to_return
->timer
, lec_arp_expire_arp
, 0);
1546 to_return
->last_used
= jiffies
;
1547 to_return
->priv
= priv
;
1548 skb_queue_head_init(&to_return
->tx_wait
);
1549 refcount_set(&to_return
->usage
, 1);
1553 /* Arp sent timer expired */
1554 static void lec_arp_expire_arp(struct timer_list
*t
)
1556 struct lec_arp_table
*entry
;
1558 entry
= from_timer(entry
, t
, timer
);
1561 if (entry
->status
== ESI_ARP_PENDING
) {
1562 if (entry
->no_tries
<= entry
->priv
->max_retry_count
) {
1563 if (entry
->is_rdesc
)
1564 send_to_lecd(entry
->priv
, l_rdesc_arp_xmt
,
1565 entry
->mac_addr
, NULL
, NULL
);
1567 send_to_lecd(entry
->priv
, l_arp_xmt
,
1568 entry
->mac_addr
, NULL
, NULL
);
1571 mod_timer(&entry
->timer
, jiffies
+ (1 * HZ
));
1575 /* Unknown/unused vcc expire, remove associated entry */
1576 static void lec_arp_expire_vcc(struct timer_list
*t
)
1578 unsigned long flags
;
1579 struct lec_arp_table
*to_remove
= from_timer(to_remove
, t
, timer
);
1580 struct lec_priv
*priv
= to_remove
->priv
;
1582 del_timer(&to_remove
->timer
);
1584 pr_debug("%p %p: vpi:%d vci:%d\n",
1586 to_remove
->vcc
? to_remove
->recv_vcc
->vpi
: 0,
1587 to_remove
->vcc
? to_remove
->recv_vcc
->vci
: 0);
1589 spin_lock_irqsave(&priv
->lec_arp_lock
, flags
);
1590 hlist_del(&to_remove
->next
);
1591 spin_unlock_irqrestore(&priv
->lec_arp_lock
, flags
);
1593 lec_arp_clear_vccs(to_remove
);
1594 lec_arp_put(to_remove
);
1597 static bool __lec_arp_check_expire(struct lec_arp_table
*entry
,
1599 struct lec_priv
*priv
)
1601 unsigned long time_to_check
;
1603 if ((entry
->flags
) & LEC_REMOTE_FLAG
&& priv
->topology_change
)
1604 time_to_check
= priv
->forward_delay_time
;
1606 time_to_check
= priv
->aging_time
;
1608 pr_debug("About to expire: %lx - %lx > %lx\n",
1609 now
, entry
->last_used
, time_to_check
);
1610 if (time_after(now
, entry
->last_used
+ time_to_check
) &&
1611 !(entry
->flags
& LEC_PERMANENT_FLAG
) &&
1612 !(entry
->mac_addr
[0] & 0x01)) { /* LANE2: 7.1.20 */
1614 pr_debug("Entry timed out\n");
1615 lec_arp_remove(priv
, entry
);
1618 /* Something else */
1619 if ((entry
->status
== ESI_VC_PENDING
||
1620 entry
->status
== ESI_ARP_PENDING
) &&
1621 time_after_eq(now
, entry
->timestamp
+
1622 priv
->max_unknown_frame_time
)) {
1623 entry
->timestamp
= jiffies
;
1624 entry
->packets_flooded
= 0;
1625 if (entry
->status
== ESI_VC_PENDING
)
1626 send_to_lecd(priv
, l_svc_setup
,
1631 if (entry
->status
== ESI_FLUSH_PENDING
&&
1632 time_after_eq(now
, entry
->timestamp
+
1633 priv
->path_switching_delay
)) {
1634 lec_arp_hold(entry
);
1644 * 2. For each entry, delete entries that have aged past the age limit.
1645 * 3. For each entry, depending on the status of the entry, perform
1646 * the following maintenance.
1647 * a. If status is ESI_VC_PENDING or ESI_ARP_PENDING then if the
1648 * tick_count is above the max_unknown_frame_time, clear
1649 * the tick_count to zero and clear the packets_flooded counter
1650 * to zero. This supports the packet rate limit per address
1651 * while flooding unknowns.
1652 * b. If the status is ESI_FLUSH_PENDING and the tick_count is greater
1653 * than or equal to the path_switching_delay, change the status
1654 * to ESI_FORWARD_DIRECT. This causes the flush period to end
1655 * regardless of the progress of the flush protocol.
1657 static void lec_arp_check_expire(struct work_struct
*work
)
1659 unsigned long flags
;
1660 struct lec_priv
*priv
=
1661 container_of(work
, struct lec_priv
, lec_arp_work
.work
);
1662 struct hlist_node
*next
;
1663 struct lec_arp_table
*entry
;
1667 pr_debug("%p\n", priv
);
1670 spin_lock_irqsave(&priv
->lec_arp_lock
, flags
);
1671 for (i
= 0; i
< LEC_ARP_TABLE_SIZE
; i
++) {
1672 hlist_for_each_entry_safe(entry
, next
,
1673 &priv
->lec_arp_tables
[i
], next
) {
1674 if (__lec_arp_check_expire(entry
, now
, priv
)) {
1675 struct sk_buff
*skb
;
1676 struct atm_vcc
*vcc
= entry
->vcc
;
1678 spin_unlock_irqrestore(&priv
->lec_arp_lock
,
1680 while ((skb
= skb_dequeue(&entry
->tx_wait
)))
1682 entry
->last_used
= jiffies
;
1683 entry
->status
= ESI_FORWARD_DIRECT
;
1690 spin_unlock_irqrestore(&priv
->lec_arp_lock
, flags
);
1692 schedule_delayed_work(&priv
->lec_arp_work
, LEC_ARP_REFRESH_INTERVAL
);
1696 * Try to find vcc where mac_address is attached.
1699 static struct atm_vcc
*lec_arp_resolve(struct lec_priv
*priv
,
1700 const unsigned char *mac_to_find
,
1702 struct lec_arp_table
**ret_entry
)
1704 unsigned long flags
;
1705 struct lec_arp_table
*entry
;
1706 struct atm_vcc
*found
;
1708 if (mac_to_find
[0] & 0x01) {
1709 switch (priv
->lane_version
) {
1711 return priv
->mcast_vcc
;
1712 case 2: /* LANE2 wants arp for multicast addresses */
1713 if (ether_addr_equal(mac_to_find
, bus_mac
))
1714 return priv
->mcast_vcc
;
1721 spin_lock_irqsave(&priv
->lec_arp_lock
, flags
);
1722 entry
= lec_arp_find(priv
, mac_to_find
);
1725 if (entry
->status
== ESI_FORWARD_DIRECT
) {
1727 entry
->last_used
= jiffies
;
1728 lec_arp_hold(entry
);
1734 * If the LE_ARP cache entry is still pending, reset count to 0
1735 * so another LE_ARP request can be made for this frame.
1737 if (entry
->status
== ESI_ARP_PENDING
)
1738 entry
->no_tries
= 0;
1740 * Data direct VC not yet set up, check to see if the unknown
1741 * frame count is greater than the limit. If the limit has
1742 * not been reached, allow the caller to send packet to
1745 if (entry
->status
!= ESI_FLUSH_PENDING
&&
1746 entry
->packets_flooded
<
1747 priv
->maximum_unknown_frame_count
) {
1748 entry
->packets_flooded
++;
1749 pr_debug("Flooding..\n");
1750 found
= priv
->mcast_vcc
;
1754 * We got here because entry->status == ESI_FLUSH_PENDING
1755 * or BUS flood limit was reached for an entry which is
1756 * in ESI_ARP_PENDING or ESI_VC_PENDING state.
1758 lec_arp_hold(entry
);
1760 pr_debug("entry->status %d entry->vcc %p\n", entry
->status
,
1764 /* No matching entry was found */
1765 entry
= make_entry(priv
, mac_to_find
);
1766 pr_debug("Making entry\n");
1768 found
= priv
->mcast_vcc
;
1771 lec_arp_add(priv
, entry
);
1772 /* We want arp-request(s) to be sent */
1773 entry
->packets_flooded
= 1;
1774 entry
->status
= ESI_ARP_PENDING
;
1775 entry
->no_tries
= 1;
1776 entry
->last_used
= entry
->timestamp
= jiffies
;
1777 entry
->is_rdesc
= is_rdesc
;
1778 if (entry
->is_rdesc
)
1779 send_to_lecd(priv
, l_rdesc_arp_xmt
, mac_to_find
, NULL
,
1782 send_to_lecd(priv
, l_arp_xmt
, mac_to_find
, NULL
, NULL
);
1783 entry
->timer
.expires
= jiffies
+ (1 * HZ
);
1784 entry
->timer
.function
= lec_arp_expire_arp
;
1785 add_timer(&entry
->timer
);
1786 found
= priv
->mcast_vcc
;
1790 spin_unlock_irqrestore(&priv
->lec_arp_lock
, flags
);
1795 lec_addr_delete(struct lec_priv
*priv
, const unsigned char *atm_addr
,
1796 unsigned long permanent
)
1798 unsigned long flags
;
1799 struct hlist_node
*next
;
1800 struct lec_arp_table
*entry
;
1804 spin_lock_irqsave(&priv
->lec_arp_lock
, flags
);
1805 for (i
= 0; i
< LEC_ARP_TABLE_SIZE
; i
++) {
1806 hlist_for_each_entry_safe(entry
, next
,
1807 &priv
->lec_arp_tables
[i
], next
) {
1808 if (!memcmp(atm_addr
, entry
->atm_addr
, ATM_ESA_LEN
) &&
1810 !(entry
->flags
& LEC_PERMANENT_FLAG
))) {
1811 lec_arp_remove(priv
, entry
);
1814 spin_unlock_irqrestore(&priv
->lec_arp_lock
, flags
);
1818 spin_unlock_irqrestore(&priv
->lec_arp_lock
, flags
);
1823 * Notifies: Response to arp_request (atm_addr != NULL)
1826 lec_arp_update(struct lec_priv
*priv
, const unsigned char *mac_addr
,
1827 const unsigned char *atm_addr
, unsigned long remoteflag
,
1828 unsigned int targetless_le_arp
)
1830 unsigned long flags
;
1831 struct hlist_node
*next
;
1832 struct lec_arp_table
*entry
, *tmp
;
1835 pr_debug("%smac:%pM\n",
1836 (targetless_le_arp
) ? "targetless " : "", mac_addr
);
1838 spin_lock_irqsave(&priv
->lec_arp_lock
, flags
);
1839 entry
= lec_arp_find(priv
, mac_addr
);
1840 if (entry
== NULL
&& targetless_le_arp
)
1842 * LANE2: ignore targetless LE_ARPs for which
1843 * we have no entry in the cache. 7.1.30
1845 if (!hlist_empty(&priv
->lec_arp_empty_ones
)) {
1846 hlist_for_each_entry_safe(entry
, next
,
1847 &priv
->lec_arp_empty_ones
, next
) {
1848 if (memcmp(entry
->atm_addr
, atm_addr
, ATM_ESA_LEN
) == 0) {
1849 hlist_del(&entry
->next
);
1850 del_timer(&entry
->timer
);
1851 tmp
= lec_arp_find(priv
, mac_addr
);
1853 del_timer(&tmp
->timer
);
1854 tmp
->status
= ESI_FORWARD_DIRECT
;
1855 memcpy(tmp
->atm_addr
, atm_addr
, ATM_ESA_LEN
);
1856 tmp
->vcc
= entry
->vcc
;
1857 tmp
->old_push
= entry
->old_push
;
1858 tmp
->last_used
= jiffies
;
1859 del_timer(&entry
->timer
);
1863 entry
->status
= ESI_FORWARD_DIRECT
;
1864 ether_addr_copy(entry
->mac_addr
,
1866 entry
->last_used
= jiffies
;
1867 lec_arp_add(priv
, entry
);
1870 entry
->flags
|= LEC_REMOTE_FLAG
;
1872 entry
->flags
&= ~LEC_REMOTE_FLAG
;
1873 pr_debug("After update\n");
1874 dump_arp_table(priv
);
1880 entry
= lec_arp_find(priv
, mac_addr
);
1882 entry
= make_entry(priv
, mac_addr
);
1885 entry
->status
= ESI_UNKNOWN
;
1886 lec_arp_add(priv
, entry
);
1887 /* Temporary, changes before end of function */
1889 memcpy(entry
->atm_addr
, atm_addr
, ATM_ESA_LEN
);
1890 del_timer(&entry
->timer
);
1891 for (i
= 0; i
< LEC_ARP_TABLE_SIZE
; i
++) {
1892 hlist_for_each_entry(tmp
,
1893 &priv
->lec_arp_tables
[i
], next
) {
1895 !memcmp(tmp
->atm_addr
, atm_addr
, ATM_ESA_LEN
)) {
1896 /* Vcc to this host exists */
1897 if (tmp
->status
> ESI_VC_PENDING
) {
1899 * ESI_FLUSH_PENDING,
1900 * ESI_FORWARD_DIRECT
1902 entry
->vcc
= tmp
->vcc
;
1903 entry
->old_push
= tmp
->old_push
;
1905 entry
->status
= tmp
->status
;
1911 entry
->flags
|= LEC_REMOTE_FLAG
;
1913 entry
->flags
&= ~LEC_REMOTE_FLAG
;
1914 if (entry
->status
== ESI_ARP_PENDING
|| entry
->status
== ESI_UNKNOWN
) {
1915 entry
->status
= ESI_VC_PENDING
;
1916 send_to_lecd(priv
, l_svc_setup
, entry
->mac_addr
, atm_addr
, NULL
);
1918 pr_debug("After update2\n");
1919 dump_arp_table(priv
);
1921 spin_unlock_irqrestore(&priv
->lec_arp_lock
, flags
);
1925 * Notifies: Vcc setup ready
1928 lec_vcc_added(struct lec_priv
*priv
, const struct atmlec_ioc
*ioc_data
,
1929 struct atm_vcc
*vcc
,
1930 void (*old_push
) (struct atm_vcc
*vcc
, struct sk_buff
*skb
))
1932 unsigned long flags
;
1933 struct lec_arp_table
*entry
;
1934 int i
, found_entry
= 0;
1936 spin_lock_irqsave(&priv
->lec_arp_lock
, flags
);
1937 /* Vcc for Multicast Forward. No timer, LANEv2 7.1.20 and 2.3.5.3 */
1938 if (ioc_data
->receive
== 2) {
1939 pr_debug("LEC_ARP: Attaching mcast forward\n");
1941 entry
= lec_arp_find(priv
, bus_mac
);
1943 pr_info("LEC_ARP: Multicast entry not found!\n");
1946 memcpy(entry
->atm_addr
, ioc_data
->atm_addr
, ATM_ESA_LEN
);
1947 entry
->recv_vcc
= vcc
;
1948 entry
->old_recv_push
= old_push
;
1950 entry
= make_entry(priv
, bus_mac
);
1953 del_timer(&entry
->timer
);
1954 memcpy(entry
->atm_addr
, ioc_data
->atm_addr
, ATM_ESA_LEN
);
1955 entry
->recv_vcc
= vcc
;
1956 entry
->old_recv_push
= old_push
;
1957 hlist_add_head(&entry
->next
, &priv
->mcast_fwds
);
1959 } else if (ioc_data
->receive
== 1) {
1961 * Vcc which we don't want to make default vcc,
1964 pr_debug("LEC_ARP:Attaching data direct, not default: %*phN\n",
1965 ATM_ESA_LEN
, ioc_data
->atm_addr
);
1966 entry
= make_entry(priv
, bus_mac
);
1969 memcpy(entry
->atm_addr
, ioc_data
->atm_addr
, ATM_ESA_LEN
);
1970 eth_zero_addr(entry
->mac_addr
);
1971 entry
->recv_vcc
= vcc
;
1972 entry
->old_recv_push
= old_push
;
1973 entry
->status
= ESI_UNKNOWN
;
1974 entry
->timer
.expires
= jiffies
+ priv
->vcc_timeout_period
;
1975 entry
->timer
.function
= lec_arp_expire_vcc
;
1976 hlist_add_head(&entry
->next
, &priv
->lec_no_forward
);
1977 add_timer(&entry
->timer
);
1978 dump_arp_table(priv
);
1981 pr_debug("LEC_ARP:Attaching data direct, default: %*phN\n",
1982 ATM_ESA_LEN
, ioc_data
->atm_addr
);
1983 for (i
= 0; i
< LEC_ARP_TABLE_SIZE
; i
++) {
1984 hlist_for_each_entry(entry
,
1985 &priv
->lec_arp_tables
[i
], next
) {
1987 (ioc_data
->atm_addr
, entry
->atm_addr
,
1988 ATM_ESA_LEN
) == 0) {
1989 pr_debug("LEC_ARP: Attaching data direct\n");
1990 pr_debug("Currently -> Vcc: %d, Rvcc:%d\n",
1991 entry
->vcc
? entry
->vcc
->vci
: 0,
1992 entry
->recv_vcc
? entry
->recv_vcc
->
1995 del_timer(&entry
->timer
);
1997 entry
->old_push
= old_push
;
1998 if (entry
->status
== ESI_VC_PENDING
) {
1999 if (priv
->maximum_unknown_frame_count
2004 entry
->timestamp
= jiffies
;
2008 send_to_lecd(priv
, l_flush_xmt
,
2016 * They were forming a connection
2017 * to us, and we to them. Our
2018 * ATM address is numerically lower
2019 * than theirs, so we make connection
2020 * we formed into default VCC (8.1.11).
2021 * Connection they made gets torn
2022 * down. This might confuse some
2023 * clients. Can be changed if
2024 * someone reports trouble...
2032 pr_debug("After vcc was added\n");
2033 dump_arp_table(priv
);
2037 * Not found, snatch address from first data packet that arrives
2040 entry
= make_entry(priv
, bus_mac
);
2044 entry
->old_push
= old_push
;
2045 memcpy(entry
->atm_addr
, ioc_data
->atm_addr
, ATM_ESA_LEN
);
2046 eth_zero_addr(entry
->mac_addr
);
2047 entry
->status
= ESI_UNKNOWN
;
2048 hlist_add_head(&entry
->next
, &priv
->lec_arp_empty_ones
);
2049 entry
->timer
.expires
= jiffies
+ priv
->vcc_timeout_period
;
2050 entry
->timer
.function
= lec_arp_expire_vcc
;
2051 add_timer(&entry
->timer
);
2052 pr_debug("After vcc was added\n");
2053 dump_arp_table(priv
);
2055 spin_unlock_irqrestore(&priv
->lec_arp_lock
, flags
);
2058 static void lec_flush_complete(struct lec_priv
*priv
, unsigned long tran_id
)
2060 unsigned long flags
;
2061 struct lec_arp_table
*entry
;
2064 pr_debug("%lx\n", tran_id
);
2066 spin_lock_irqsave(&priv
->lec_arp_lock
, flags
);
2067 for (i
= 0; i
< LEC_ARP_TABLE_SIZE
; i
++) {
2068 hlist_for_each_entry(entry
,
2069 &priv
->lec_arp_tables
[i
], next
) {
2070 if (entry
->flush_tran_id
== tran_id
&&
2071 entry
->status
== ESI_FLUSH_PENDING
) {
2072 struct sk_buff
*skb
;
2073 struct atm_vcc
*vcc
= entry
->vcc
;
2075 lec_arp_hold(entry
);
2076 spin_unlock_irqrestore(&priv
->lec_arp_lock
,
2078 while ((skb
= skb_dequeue(&entry
->tx_wait
)))
2080 entry
->last_used
= jiffies
;
2081 entry
->status
= ESI_FORWARD_DIRECT
;
2083 pr_debug("LEC_ARP: Flushed\n");
2088 spin_unlock_irqrestore(&priv
->lec_arp_lock
, flags
);
2089 dump_arp_table(priv
);
2093 lec_set_flush_tran_id(struct lec_priv
*priv
,
2094 const unsigned char *atm_addr
, unsigned long tran_id
)
2096 unsigned long flags
;
2097 struct lec_arp_table
*entry
;
2100 spin_lock_irqsave(&priv
->lec_arp_lock
, flags
);
2101 for (i
= 0; i
< LEC_ARP_TABLE_SIZE
; i
++)
2102 hlist_for_each_entry(entry
,
2103 &priv
->lec_arp_tables
[i
], next
) {
2104 if (!memcmp(atm_addr
, entry
->atm_addr
, ATM_ESA_LEN
)) {
2105 entry
->flush_tran_id
= tran_id
;
2106 pr_debug("Set flush transaction id to %lx for %p\n",
2110 spin_unlock_irqrestore(&priv
->lec_arp_lock
, flags
);
2113 static int lec_mcast_make(struct lec_priv
*priv
, struct atm_vcc
*vcc
)
2115 unsigned long flags
;
2116 unsigned char mac_addr
[] = {
2117 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2119 struct lec_arp_table
*to_add
;
2120 struct lec_vcc_priv
*vpriv
;
2123 vpriv
= kmalloc(sizeof(struct lec_vcc_priv
), GFP_KERNEL
);
2127 vpriv
->old_pop
= vcc
->pop
;
2128 vcc
->user_back
= vpriv
;
2130 spin_lock_irqsave(&priv
->lec_arp_lock
, flags
);
2131 to_add
= make_entry(priv
, mac_addr
);
2133 vcc
->pop
= vpriv
->old_pop
;
2138 memcpy(to_add
->atm_addr
, vcc
->remote
.sas_addr
.prv
, ATM_ESA_LEN
);
2139 to_add
->status
= ESI_FORWARD_DIRECT
;
2140 to_add
->flags
|= LEC_PERMANENT_FLAG
;
2142 to_add
->old_push
= vcc
->push
;
2143 vcc
->push
= lec_push
;
2144 priv
->mcast_vcc
= vcc
;
2145 lec_arp_add(priv
, to_add
);
2147 spin_unlock_irqrestore(&priv
->lec_arp_lock
, flags
);
2151 static void lec_vcc_close(struct lec_priv
*priv
, struct atm_vcc
*vcc
)
2153 unsigned long flags
;
2154 struct hlist_node
*next
;
2155 struct lec_arp_table
*entry
;
2158 pr_debug("LEC_ARP: lec_vcc_close vpi:%d vci:%d\n", vcc
->vpi
, vcc
->vci
);
2159 dump_arp_table(priv
);
2161 spin_lock_irqsave(&priv
->lec_arp_lock
, flags
);
2163 for (i
= 0; i
< LEC_ARP_TABLE_SIZE
; i
++) {
2164 hlist_for_each_entry_safe(entry
, next
,
2165 &priv
->lec_arp_tables
[i
], next
) {
2166 if (vcc
== entry
->vcc
) {
2167 lec_arp_remove(priv
, entry
);
2169 if (priv
->mcast_vcc
== vcc
)
2170 priv
->mcast_vcc
= NULL
;
2175 hlist_for_each_entry_safe(entry
, next
,
2176 &priv
->lec_arp_empty_ones
, next
) {
2177 if (entry
->vcc
== vcc
) {
2178 lec_arp_clear_vccs(entry
);
2179 del_timer(&entry
->timer
);
2180 hlist_del(&entry
->next
);
2185 hlist_for_each_entry_safe(entry
, next
,
2186 &priv
->lec_no_forward
, next
) {
2187 if (entry
->recv_vcc
== vcc
) {
2188 lec_arp_clear_vccs(entry
);
2189 del_timer(&entry
->timer
);
2190 hlist_del(&entry
->next
);
2195 hlist_for_each_entry_safe(entry
, next
, &priv
->mcast_fwds
, next
) {
2196 if (entry
->recv_vcc
== vcc
) {
2197 lec_arp_clear_vccs(entry
);
2198 /* No timer, LANEv2 7.1.20 and 2.3.5.3 */
2199 hlist_del(&entry
->next
);
2204 spin_unlock_irqrestore(&priv
->lec_arp_lock
, flags
);
2205 dump_arp_table(priv
);
2209 lec_arp_check_empties(struct lec_priv
*priv
,
2210 struct atm_vcc
*vcc
, struct sk_buff
*skb
)
2212 unsigned long flags
;
2213 struct hlist_node
*next
;
2214 struct lec_arp_table
*entry
, *tmp
;
2215 struct lecdatahdr_8023
*hdr
= (struct lecdatahdr_8023
*)skb
->data
;
2216 unsigned char *src
= hdr
->h_source
;
2218 spin_lock_irqsave(&priv
->lec_arp_lock
, flags
);
2219 hlist_for_each_entry_safe(entry
, next
,
2220 &priv
->lec_arp_empty_ones
, next
) {
2221 if (vcc
== entry
->vcc
) {
2222 del_timer(&entry
->timer
);
2223 ether_addr_copy(entry
->mac_addr
, src
);
2224 entry
->status
= ESI_FORWARD_DIRECT
;
2225 entry
->last_used
= jiffies
;
2226 /* We might have got an entry */
2227 tmp
= lec_arp_find(priv
, src
);
2229 lec_arp_remove(priv
, tmp
);
2232 hlist_del(&entry
->next
);
2233 lec_arp_add(priv
, entry
);
2237 pr_debug("LEC_ARP: Arp_check_empties: entry not found!\n");
2239 spin_unlock_irqrestore(&priv
->lec_arp_lock
, flags
);
2242 MODULE_LICENSE("GPL");