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