xref: /openbmc/linux/net/atm/mpc.c (revision f42b3800)
1 #include <linux/kernel.h>
2 #include <linux/string.h>
3 #include <linux/timer.h>
4 #include <linux/init.h>
5 #include <linux/bitops.h>
6 #include <linux/capability.h>
7 #include <linux/seq_file.h>
8 
9 /* We are an ethernet device */
10 #include <linux/if_ether.h>
11 #include <linux/netdevice.h>
12 #include <linux/etherdevice.h>
13 #include <net/sock.h>
14 #include <linux/skbuff.h>
15 #include <linux/ip.h>
16 #include <asm/byteorder.h>
17 #include <asm/uaccess.h>
18 #include <net/checksum.h>   /* for ip_fast_csum() */
19 #include <net/arp.h>
20 #include <net/dst.h>
21 #include <linux/proc_fs.h>
22 
23 /* And atm device */
24 #include <linux/atmdev.h>
25 #include <linux/atmlec.h>
26 #include <linux/atmmpc.h>
27 /* Modular too */
28 #include <linux/module.h>
29 
30 #include "lec.h"
31 #include "mpc.h"
32 #include "resources.h"
33 
34 /*
35  * mpc.c: Implementation of MPOA client kernel part
36  */
37 
38 #if 0
39 #define dprintk printk   /* debug */
40 #else
41 #define dprintk(format,args...)
42 #endif
43 
44 #if 0
45 #define ddprintk printk  /* more debug */
46 #else
47 #define ddprintk(format,args...)
48 #endif
49 
50 
51 
52 #define MPOA_TAG_LEN 4
53 
54 /* mpc_daemon -> kernel */
55 static void MPOA_trigger_rcvd (struct k_message *msg, struct mpoa_client *mpc);
56 static void MPOA_res_reply_rcvd(struct k_message *msg, struct mpoa_client *mpc);
57 static void ingress_purge_rcvd(struct k_message *msg, struct mpoa_client *mpc);
58 static void egress_purge_rcvd(struct k_message *msg, struct mpoa_client *mpc);
59 static void mps_death(struct k_message *msg, struct mpoa_client *mpc);
60 static void clean_up(struct k_message *msg, struct mpoa_client *mpc, int action);
61 static void MPOA_cache_impos_rcvd(struct k_message *msg, struct mpoa_client *mpc);
62 static void set_mpc_ctrl_addr_rcvd(struct k_message *mesg, struct mpoa_client *mpc);
63 static void set_mps_mac_addr_rcvd(struct k_message *mesg, struct mpoa_client *mpc);
64 
65 static uint8_t *copy_macs(struct mpoa_client *mpc, uint8_t *router_mac,
66 			  uint8_t *tlvs, uint8_t mps_macs, uint8_t device_type);
67 static void purge_egress_shortcut(struct atm_vcc *vcc, eg_cache_entry *entry);
68 
69 static void send_set_mps_ctrl_addr(char *addr, struct mpoa_client *mpc);
70 static void mpoad_close(struct atm_vcc *vcc);
71 static int msg_from_mpoad(struct atm_vcc *vcc, struct sk_buff *skb);
72 
73 static void mpc_push(struct atm_vcc *vcc, struct sk_buff *skb);
74 static int mpc_send_packet(struct sk_buff *skb, struct net_device *dev);
75 static int mpoa_event_listener(struct notifier_block *mpoa_notifier, unsigned long event, void *dev);
76 static void mpc_timer_refresh(void);
77 static void mpc_cache_check( unsigned long checking_time  );
78 
79 static struct llc_snap_hdr llc_snap_mpoa_ctrl = {
80 	0xaa, 0xaa, 0x03,
81 	{0x00, 0x00, 0x5e},
82 	{0x00, 0x03}         /* For MPOA control PDUs */
83 };
84 static struct llc_snap_hdr llc_snap_mpoa_data = {
85 	0xaa, 0xaa, 0x03,
86 	{0x00, 0x00, 0x00},
87 	{0x08, 0x00}         /* This is for IP PDUs only */
88 };
89 static struct llc_snap_hdr llc_snap_mpoa_data_tagged = {
90 	0xaa, 0xaa, 0x03,
91 	{0x00, 0x00, 0x00},
92 	{0x88, 0x4c}         /* This is for tagged data PDUs */
93 };
94 
95 static struct notifier_block mpoa_notifier = {
96 	mpoa_event_listener,
97 	NULL,
98 	0
99 };
100 
101 struct mpoa_client *mpcs = NULL; /* FIXME */
102 static struct atm_mpoa_qos *qos_head = NULL;
103 static DEFINE_TIMER(mpc_timer, NULL, 0, 0);
104 
105 
106 static struct mpoa_client *find_mpc_by_itfnum(int itf)
107 {
108 	struct mpoa_client *mpc;
109 
110 	mpc = mpcs;  /* our global linked list */
111 	while (mpc != NULL) {
112 		if (mpc->dev_num == itf)
113 			return mpc;
114 		mpc = mpc->next;
115 	}
116 
117 	return NULL;   /* not found */
118 }
119 
120 static struct mpoa_client *find_mpc_by_vcc(struct atm_vcc *vcc)
121 {
122 	struct mpoa_client *mpc;
123 
124 	mpc = mpcs;  /* our global linked list */
125 	while (mpc != NULL) {
126 		if (mpc->mpoad_vcc == vcc)
127 			return mpc;
128 		mpc = mpc->next;
129 	}
130 
131 	return NULL;   /* not found */
132 }
133 
134 static struct mpoa_client *find_mpc_by_lec(struct net_device *dev)
135 {
136 	struct mpoa_client *mpc;
137 
138 	mpc = mpcs;  /* our global linked list */
139 	while (mpc != NULL) {
140 		if (mpc->dev == dev)
141 			return mpc;
142 		mpc = mpc->next;
143 	}
144 
145 	return NULL;   /* not found */
146 }
147 
148 /*
149  * Functions for managing QoS list
150  */
151 
152 /*
153  * Overwrites the old entry or makes a new one.
154  */
155 struct atm_mpoa_qos *atm_mpoa_add_qos(__be32 dst_ip, struct atm_qos *qos)
156 {
157 	struct atm_mpoa_qos *entry;
158 
159 	entry = atm_mpoa_search_qos(dst_ip);
160 	if (entry != NULL) {
161 		entry->qos = *qos;
162 		return entry;
163 	}
164 
165 	entry = kmalloc(sizeof(struct atm_mpoa_qos), GFP_KERNEL);
166 	if (entry == NULL) {
167 		printk("mpoa: atm_mpoa_add_qos: out of memory\n");
168 		return entry;
169 	}
170 
171 	entry->ipaddr = dst_ip;
172 	entry->qos = *qos;
173 
174 	entry->next = qos_head;
175 	qos_head = entry;
176 
177 	return entry;
178 }
179 
180 struct atm_mpoa_qos *atm_mpoa_search_qos(__be32 dst_ip)
181 {
182 	struct atm_mpoa_qos *qos;
183 
184 	qos = qos_head;
185 	while( qos != NULL ){
186 		if(qos->ipaddr == dst_ip) {
187 			break;
188 		}
189 		qos = qos->next;
190 	}
191 
192 	return qos;
193 }
194 
195 /*
196  * Returns 0 for failure
197  */
198 int atm_mpoa_delete_qos(struct atm_mpoa_qos *entry)
199 {
200 
201 	struct atm_mpoa_qos *curr;
202 
203 	if (entry == NULL) return 0;
204 	if (entry == qos_head) {
205 		qos_head = qos_head->next;
206 		kfree(entry);
207 		return 1;
208 	}
209 
210 	curr = qos_head;
211 	while (curr != NULL) {
212 		if (curr->next == entry) {
213 			curr->next = entry->next;
214 			kfree(entry);
215 			return 1;
216 		}
217 		curr = curr->next;
218 	}
219 
220 	return 0;
221 }
222 
223 /* this is buggered - we need locking for qos_head */
224 void atm_mpoa_disp_qos(struct seq_file *m)
225 {
226 	struct atm_mpoa_qos *qos;
227 
228 	qos = qos_head;
229 	seq_printf(m, "QoS entries for shortcuts:\n");
230 	seq_printf(m, "IP address\n  TX:max_pcr pcr     min_pcr max_cdv max_sdu\n  RX:max_pcr pcr     min_pcr max_cdv max_sdu\n");
231 
232 	while (qos != NULL) {
233 		seq_printf(m, "%u.%u.%u.%u\n     %-7d %-7d %-7d %-7d %-7d\n     %-7d %-7d %-7d %-7d %-7d\n",
234 				NIPQUAD(qos->ipaddr),
235 				qos->qos.txtp.max_pcr, qos->qos.txtp.pcr, qos->qos.txtp.min_pcr, qos->qos.txtp.max_cdv, qos->qos.txtp.max_sdu,
236 				qos->qos.rxtp.max_pcr, qos->qos.rxtp.pcr, qos->qos.rxtp.min_pcr, qos->qos.rxtp.max_cdv, qos->qos.rxtp.max_sdu);
237 		qos = qos->next;
238 	}
239 }
240 
241 static struct net_device *find_lec_by_itfnum(int itf)
242 {
243 	struct net_device *dev;
244 	char name[IFNAMSIZ];
245 
246 	sprintf(name, "lec%d", itf);
247 	dev = dev_get_by_name(&init_net, name);
248 
249 	return dev;
250 }
251 
252 static struct mpoa_client *alloc_mpc(void)
253 {
254 	struct mpoa_client *mpc;
255 
256 	mpc = kzalloc(sizeof (struct mpoa_client), GFP_KERNEL);
257 	if (mpc == NULL)
258 		return NULL;
259 	rwlock_init(&mpc->ingress_lock);
260 	rwlock_init(&mpc->egress_lock);
261 	mpc->next = mpcs;
262 	atm_mpoa_init_cache(mpc);
263 
264 	mpc->parameters.mpc_p1 = MPC_P1;
265 	mpc->parameters.mpc_p2 = MPC_P2;
266 	memset(mpc->parameters.mpc_p3,0,sizeof(mpc->parameters.mpc_p3));
267 	mpc->parameters.mpc_p4 = MPC_P4;
268 	mpc->parameters.mpc_p5 = MPC_P5;
269 	mpc->parameters.mpc_p6 = MPC_P6;
270 
271 	mpcs = mpc;
272 
273 	return mpc;
274 }
275 
276 /*
277  *
278  * start_mpc() puts the MPC on line. All the packets destined
279  * to the lec underneath us are now being monitored and
280  * shortcuts will be established.
281  *
282  */
283 static void start_mpc(struct mpoa_client *mpc, struct net_device *dev)
284 {
285 
286 	dprintk("mpoa: (%s) start_mpc:\n", mpc->dev->name);
287 	if (dev->hard_start_xmit == NULL) {
288 		printk("mpoa: (%s) start_mpc: dev->hard_start_xmit == NULL, not starting\n",
289 		       dev->name);
290 		return;
291 	}
292 	mpc->old_hard_start_xmit = dev->hard_start_xmit;
293 	dev->hard_start_xmit = mpc_send_packet;
294 
295 	return;
296 }
297 
298 static void stop_mpc(struct mpoa_client *mpc)
299 {
300 
301 	dprintk("mpoa: (%s) stop_mpc:", mpc->dev->name);
302 
303 	/* Lets not nullify lec device's dev->hard_start_xmit */
304 	if (mpc->dev->hard_start_xmit != mpc_send_packet) {
305 		dprintk(" mpc already stopped, not fatal\n");
306 		return;
307 	}
308 	dprintk("\n");
309 	mpc->dev->hard_start_xmit = mpc->old_hard_start_xmit;
310 	mpc->old_hard_start_xmit = NULL;
311 	/* close_shortcuts(mpc);    ??? FIXME */
312 
313 	return;
314 }
315 
316 static const char *mpoa_device_type_string(char type) __attribute__ ((unused));
317 
318 static const char *mpoa_device_type_string(char type)
319 {
320 	switch(type) {
321 	case NON_MPOA:
322 		return "non-MPOA device";
323 		break;
324 	case MPS:
325 		return "MPS";
326 		break;
327 	case MPC:
328 		return "MPC";
329 		break;
330 	case MPS_AND_MPC:
331 		return "both MPS and MPC";
332 		break;
333 	default:
334 		return "unspecified (non-MPOA) device";
335 		break;
336 	}
337 
338 	return ""; /* not reached */
339 }
340 
341 /*
342  * lec device calls this via its dev->priv->lane2_ops->associate_indicator()
343  * when it sees a TLV in LE_ARP packet.
344  * We fill in the pointer above when we see a LANE2 lec initializing
345  * See LANE2 spec 3.1.5
346  *
347  * Quite a big and ugly function but when you look at it
348  * all it does is to try to locate and parse MPOA Device
349  * Type TLV.
350  * We give our lec a pointer to this function and when the
351  * lec sees a TLV it uses the pointer to call this function.
352  *
353  */
354 static void lane2_assoc_ind(struct net_device *dev, uint8_t *mac_addr,
355 			    uint8_t *tlvs, uint32_t sizeoftlvs)
356 {
357 	uint32_t type;
358 	uint8_t length, mpoa_device_type, number_of_mps_macs;
359 	uint8_t *end_of_tlvs;
360 	struct mpoa_client *mpc;
361 
362 	mpoa_device_type = number_of_mps_macs = 0; /* silence gcc */
363 	dprintk("mpoa: (%s) lane2_assoc_ind: received TLV(s), ", dev->name);
364 	dprintk("total length of all TLVs %d\n", sizeoftlvs);
365 	mpc = find_mpc_by_lec(dev); /* Sampo-Fix: moved here from below */
366 	if (mpc == NULL) {
367 		printk("mpoa: (%s) lane2_assoc_ind: no mpc\n", dev->name);
368 		return;
369 	}
370 	end_of_tlvs = tlvs + sizeoftlvs;
371 	while (end_of_tlvs - tlvs >= 5) {
372 		type = (tlvs[0] << 24) | (tlvs[1] << 16) | (tlvs[2] << 8) | tlvs[3];
373 		length = tlvs[4];
374 		tlvs += 5;
375 		dprintk("    type 0x%x length %02x\n", type, length);
376 		if (tlvs + length > end_of_tlvs) {
377 			printk("TLV value extends past its buffer, aborting parse\n");
378 			return;
379 		}
380 
381 		if (type == 0) {
382 			printk("mpoa: (%s) lane2_assoc_ind: TLV type was 0, returning\n", dev->name);
383 			return;
384 		}
385 
386 		if (type != TLV_MPOA_DEVICE_TYPE) {
387 			tlvs += length;
388 			continue;  /* skip other TLVs */
389 		}
390 		mpoa_device_type = *tlvs++;
391 		number_of_mps_macs = *tlvs++;
392 		dprintk("mpoa: (%s) MPOA device type '%s', ", dev->name, mpoa_device_type_string(mpoa_device_type));
393 		if (mpoa_device_type == MPS_AND_MPC &&
394 		    length < (42 + number_of_mps_macs*ETH_ALEN)) { /* :) */
395 			printk("\nmpoa: (%s) lane2_assoc_ind: short MPOA Device Type TLV\n",
396 			       dev->name);
397 			continue;
398 		}
399 		if ((mpoa_device_type == MPS || mpoa_device_type == MPC)
400 		    && length < 22 + number_of_mps_macs*ETH_ALEN) {
401 			printk("\nmpoa: (%s) lane2_assoc_ind: short MPOA Device Type TLV\n",
402 				dev->name);
403 			continue;
404 		}
405 		if (mpoa_device_type != MPS && mpoa_device_type != MPS_AND_MPC) {
406 			dprintk("ignoring non-MPS device\n");
407 			if (mpoa_device_type == MPC) tlvs += 20;
408 			continue;  /* we are only interested in MPSs */
409 		}
410 		if (number_of_mps_macs == 0 && mpoa_device_type == MPS_AND_MPC) {
411 			printk("\nmpoa: (%s) lane2_assoc_ind: MPS_AND_MPC has zero MACs\n", dev->name);
412 			continue;  /* someone should read the spec */
413 		}
414 		dprintk("this MPS has %d MAC addresses\n", number_of_mps_macs);
415 
416 		/* ok, now we can go and tell our daemon the control address of MPS */
417 		send_set_mps_ctrl_addr(tlvs, mpc);
418 
419 		tlvs = copy_macs(mpc, mac_addr, tlvs, number_of_mps_macs, mpoa_device_type);
420 		if (tlvs == NULL) return;
421 	}
422 	if (end_of_tlvs - tlvs != 0)
423 		printk("mpoa: (%s) lane2_assoc_ind: ignoring %Zd bytes of trailing TLV carbage\n",
424 		       dev->name, end_of_tlvs - tlvs);
425 	return;
426 }
427 
428 /*
429  * Store at least advertizing router's MAC address
430  * plus the possible MAC address(es) to mpc->mps_macs.
431  * For a freshly allocated MPOA client mpc->mps_macs == 0.
432  */
433 static uint8_t *copy_macs(struct mpoa_client *mpc, uint8_t *router_mac,
434 			  uint8_t *tlvs, uint8_t mps_macs, uint8_t device_type)
435 {
436 	int num_macs;
437 	num_macs = (mps_macs > 1) ? mps_macs : 1;
438 
439 	if (mpc->number_of_mps_macs != num_macs) { /* need to reallocate? */
440 		if (mpc->number_of_mps_macs != 0) kfree(mpc->mps_macs);
441 		mpc->number_of_mps_macs = 0;
442 		mpc->mps_macs = kmalloc(num_macs*ETH_ALEN, GFP_KERNEL);
443 		if (mpc->mps_macs == NULL) {
444 			printk("mpoa: (%s) copy_macs: out of mem\n", mpc->dev->name);
445 			return NULL;
446 		}
447 	}
448 	memcpy(mpc->mps_macs, router_mac, ETH_ALEN);
449 	tlvs += 20; if (device_type == MPS_AND_MPC) tlvs += 20;
450 	if (mps_macs > 0)
451 		memcpy(mpc->mps_macs, tlvs, mps_macs*ETH_ALEN);
452 	tlvs += mps_macs*ETH_ALEN;
453 	mpc->number_of_mps_macs = num_macs;
454 
455 	return tlvs;
456 }
457 
458 static int send_via_shortcut(struct sk_buff *skb, struct mpoa_client *mpc)
459 {
460 	in_cache_entry *entry;
461 	struct iphdr *iph;
462 	char *buff;
463 	__be32 ipaddr = 0;
464 
465 	static struct {
466 		struct llc_snap_hdr hdr;
467 		__be32 tag;
468 	} tagged_llc_snap_hdr = {
469 		{0xaa, 0xaa, 0x03, {0x00, 0x00, 0x00}, {0x88, 0x4c}},
470 		0
471 	};
472 
473 	buff = skb->data + mpc->dev->hard_header_len;
474 	iph = (struct iphdr *)buff;
475 	ipaddr = iph->daddr;
476 
477 	ddprintk("mpoa: (%s) send_via_shortcut: ipaddr 0x%x\n", mpc->dev->name, ipaddr);
478 
479 	entry = mpc->in_ops->get(ipaddr, mpc);
480 	if (entry == NULL) {
481 		entry = mpc->in_ops->add_entry(ipaddr, mpc);
482 		if (entry != NULL) mpc->in_ops->put(entry);
483 		return 1;
484 	}
485 	if (mpc->in_ops->cache_hit(entry, mpc) != OPEN){   /* threshold not exceeded or VCC not ready */
486 		ddprintk("mpoa: (%s) send_via_shortcut: cache_hit: returns != OPEN\n", mpc->dev->name);
487 		mpc->in_ops->put(entry);
488 		return 1;
489 	}
490 
491 	ddprintk("mpoa: (%s) send_via_shortcut: using shortcut\n", mpc->dev->name);
492 	/* MPOA spec A.1.4, MPOA client must decrement IP ttl at least by one */
493 	if (iph->ttl <= 1) {
494 		ddprintk("mpoa: (%s) send_via_shortcut: IP ttl = %u, using LANE\n", mpc->dev->name, iph->ttl);
495 		mpc->in_ops->put(entry);
496 		return 1;
497 	}
498 	iph->ttl--;
499 	iph->check = 0;
500 	iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl);
501 
502 	if (entry->ctrl_info.tag != 0) {
503 		ddprintk("mpoa: (%s) send_via_shortcut: adding tag 0x%x\n", mpc->dev->name, entry->ctrl_info.tag);
504 		tagged_llc_snap_hdr.tag = entry->ctrl_info.tag;
505 		skb_pull(skb, ETH_HLEN);                       /* get rid of Eth header */
506 		skb_push(skb, sizeof(tagged_llc_snap_hdr));    /* add LLC/SNAP header   */
507 		skb_copy_to_linear_data(skb, &tagged_llc_snap_hdr,
508 					sizeof(tagged_llc_snap_hdr));
509 	} else {
510 		skb_pull(skb, ETH_HLEN);                        /* get rid of Eth header */
511 		skb_push(skb, sizeof(struct llc_snap_hdr));     /* add LLC/SNAP header + tag  */
512 		skb_copy_to_linear_data(skb, &llc_snap_mpoa_data,
513 					sizeof(struct llc_snap_hdr));
514 	}
515 
516 	atomic_add(skb->truesize, &sk_atm(entry->shortcut)->sk_wmem_alloc);
517 	ATM_SKB(skb)->atm_options = entry->shortcut->atm_options;
518 	entry->shortcut->send(entry->shortcut, skb);
519 	entry->packets_fwded++;
520 	mpc->in_ops->put(entry);
521 
522 	return 0;
523 }
524 
525 /*
526  * Probably needs some error checks and locking, not sure...
527  */
528 static int mpc_send_packet(struct sk_buff *skb, struct net_device *dev)
529 {
530 	int retval;
531 	struct mpoa_client *mpc;
532 	struct ethhdr *eth;
533 	int i = 0;
534 
535 	mpc = find_mpc_by_lec(dev); /* this should NEVER fail */
536 	if(mpc == NULL) {
537 		printk("mpoa: (%s) mpc_send_packet: no MPC found\n", dev->name);
538 		goto non_ip;
539 	}
540 
541 	eth = (struct ethhdr *)skb->data;
542 	if (eth->h_proto != htons(ETH_P_IP))
543 		goto non_ip; /* Multi-Protocol Over ATM :-) */
544 
545 	/* Weed out funny packets (e.g., AF_PACKET or raw). */
546 	if (skb->len < ETH_HLEN + sizeof(struct iphdr))
547 		goto non_ip;
548 	skb_set_network_header(skb, ETH_HLEN);
549 	if (skb->len < ETH_HLEN + ip_hdr(skb)->ihl * 4 || ip_hdr(skb)->ihl < 5)
550 		goto non_ip;
551 
552 	while (i < mpc->number_of_mps_macs) {
553 		if (!compare_ether_addr(eth->h_dest, (mpc->mps_macs + i*ETH_ALEN)))
554 			if ( send_via_shortcut(skb, mpc) == 0 )           /* try shortcut */
555 				return 0;                                 /* success!     */
556 		i++;
557 	}
558 
559  non_ip:
560 	retval = mpc->old_hard_start_xmit(skb,dev);
561 
562 	return retval;
563 }
564 
565 static int atm_mpoa_vcc_attach(struct atm_vcc *vcc, void __user *arg)
566 {
567 	int bytes_left;
568 	struct mpoa_client *mpc;
569 	struct atmmpc_ioc ioc_data;
570 	in_cache_entry *in_entry;
571 	__be32  ipaddr;
572 
573 	bytes_left = copy_from_user(&ioc_data, arg, sizeof(struct atmmpc_ioc));
574 	if (bytes_left != 0) {
575 		printk("mpoa: mpc_vcc_attach: Short read (missed %d bytes) from userland\n", bytes_left);
576 		return -EFAULT;
577 	}
578 	ipaddr = ioc_data.ipaddr;
579 	if (ioc_data.dev_num < 0 || ioc_data.dev_num >= MAX_LEC_ITF)
580 		return -EINVAL;
581 
582 	mpc = find_mpc_by_itfnum(ioc_data.dev_num);
583 	if (mpc == NULL)
584 		return -EINVAL;
585 
586 	if (ioc_data.type == MPC_SOCKET_INGRESS) {
587 		in_entry = mpc->in_ops->get(ipaddr, mpc);
588 		if (in_entry == NULL || in_entry->entry_state < INGRESS_RESOLVED) {
589 			printk("mpoa: (%s) mpc_vcc_attach: did not find RESOLVED entry from ingress cache\n",
590 				mpc->dev->name);
591 			if (in_entry != NULL) mpc->in_ops->put(in_entry);
592 			return -EINVAL;
593 		}
594 		printk("mpoa: (%s) mpc_vcc_attach: attaching ingress SVC, entry = %u.%u.%u.%u\n",
595 		       mpc->dev->name, NIPQUAD(in_entry->ctrl_info.in_dst_ip));
596 		in_entry->shortcut = vcc;
597 		mpc->in_ops->put(in_entry);
598 	} else {
599 		printk("mpoa: (%s) mpc_vcc_attach: attaching egress SVC\n", mpc->dev->name);
600 	}
601 
602 	vcc->proto_data = mpc->dev;
603 	vcc->push = mpc_push;
604 
605 	return 0;
606 }
607 
608 /*
609  *
610  */
611 static void mpc_vcc_close(struct atm_vcc *vcc, struct net_device *dev)
612 {
613 	struct mpoa_client *mpc;
614 	in_cache_entry *in_entry;
615 	eg_cache_entry *eg_entry;
616 
617 	mpc = find_mpc_by_lec(dev);
618 	if (mpc == NULL) {
619 		printk("mpoa: (%s) mpc_vcc_close: close for unknown MPC\n", dev->name);
620 		return;
621 	}
622 
623 	dprintk("mpoa: (%s) mpc_vcc_close:\n", dev->name);
624 	in_entry = mpc->in_ops->get_by_vcc(vcc, mpc);
625 	if (in_entry) {
626 		dprintk("mpoa: (%s) mpc_vcc_close: ingress SVC closed ip = %u.%u.%u.%u\n",
627 		       mpc->dev->name, NIPQUAD(in_entry->ctrl_info.in_dst_ip));
628 		in_entry->shortcut = NULL;
629 		mpc->in_ops->put(in_entry);
630 	}
631 	eg_entry = mpc->eg_ops->get_by_vcc(vcc, mpc);
632 	if (eg_entry) {
633 		dprintk("mpoa: (%s) mpc_vcc_close: egress SVC closed\n", mpc->dev->name);
634 		eg_entry->shortcut = NULL;
635 		mpc->eg_ops->put(eg_entry);
636 	}
637 
638 	if (in_entry == NULL && eg_entry == NULL)
639 		dprintk("mpoa: (%s) mpc_vcc_close:  unused vcc closed\n", dev->name);
640 
641 	return;
642 }
643 
644 static void mpc_push(struct atm_vcc *vcc, struct sk_buff *skb)
645 {
646 	struct net_device *dev = (struct net_device *)vcc->proto_data;
647 	struct sk_buff *new_skb;
648 	eg_cache_entry *eg;
649 	struct mpoa_client *mpc;
650 	__be32 tag;
651 	char *tmp;
652 
653 	ddprintk("mpoa: (%s) mpc_push:\n", dev->name);
654 	if (skb == NULL) {
655 		dprintk("mpoa: (%s) mpc_push: null skb, closing VCC\n", dev->name);
656 		mpc_vcc_close(vcc, dev);
657 		return;
658 	}
659 
660 	skb->dev = dev;
661 	if (memcmp(skb->data, &llc_snap_mpoa_ctrl, sizeof(struct llc_snap_hdr)) == 0) {
662 		struct sock *sk = sk_atm(vcc);
663 
664 		dprintk("mpoa: (%s) mpc_push: control packet arrived\n", dev->name);
665 		/* Pass control packets to daemon */
666 		skb_queue_tail(&sk->sk_receive_queue, skb);
667 		sk->sk_data_ready(sk, skb->len);
668 		return;
669 	}
670 
671 	/* data coming over the shortcut */
672 	atm_return(vcc, skb->truesize);
673 
674 	mpc = find_mpc_by_lec(dev);
675 	if (mpc == NULL) {
676 		printk("mpoa: (%s) mpc_push: unknown MPC\n", dev->name);
677 		return;
678 	}
679 
680 	if (memcmp(skb->data, &llc_snap_mpoa_data_tagged, sizeof(struct llc_snap_hdr)) == 0) { /* MPOA tagged data */
681 		ddprintk("mpoa: (%s) mpc_push: tagged data packet arrived\n", dev->name);
682 
683 	} else if (memcmp(skb->data, &llc_snap_mpoa_data, sizeof(struct llc_snap_hdr)) == 0) { /* MPOA data */
684 		printk("mpoa: (%s) mpc_push: non-tagged data packet arrived\n", dev->name);
685 		printk("           mpc_push: non-tagged data unsupported, purging\n");
686 		dev_kfree_skb_any(skb);
687 		return;
688 	} else {
689 		printk("mpoa: (%s) mpc_push: garbage arrived, purging\n", dev->name);
690 		dev_kfree_skb_any(skb);
691 		return;
692 	}
693 
694 	tmp = skb->data + sizeof(struct llc_snap_hdr);
695 	tag = *(__be32 *)tmp;
696 
697 	eg = mpc->eg_ops->get_by_tag(tag, mpc);
698 	if (eg == NULL) {
699 		printk("mpoa: (%s) mpc_push: Didn't find egress cache entry, tag = %u\n",
700 		       dev->name,tag);
701 		purge_egress_shortcut(vcc, NULL);
702 		dev_kfree_skb_any(skb);
703 		return;
704 	}
705 
706 	/*
707 	 * See if ingress MPC is using shortcut we opened as a return channel.
708 	 * This means we have a bi-directional vcc opened by us.
709 	 */
710 	if (eg->shortcut == NULL) {
711 		eg->shortcut = vcc;
712 		printk("mpoa: (%s) mpc_push: egress SVC in use\n", dev->name);
713 	}
714 
715 	skb_pull(skb, sizeof(struct llc_snap_hdr) + sizeof(tag)); /* get rid of LLC/SNAP header */
716 	new_skb = skb_realloc_headroom(skb, eg->ctrl_info.DH_length); /* LLC/SNAP is shorter than MAC header :( */
717 	dev_kfree_skb_any(skb);
718 	if (new_skb == NULL){
719 		mpc->eg_ops->put(eg);
720 		return;
721 	}
722 	skb_push(new_skb, eg->ctrl_info.DH_length);     /* add MAC header */
723 	skb_copy_to_linear_data(new_skb, eg->ctrl_info.DLL_header,
724 				eg->ctrl_info.DH_length);
725 	new_skb->protocol = eth_type_trans(new_skb, dev);
726 	skb_reset_network_header(new_skb);
727 
728 	eg->latest_ip_addr = ip_hdr(new_skb)->saddr;
729 	eg->packets_rcvd++;
730 	mpc->eg_ops->put(eg);
731 
732 	memset(ATM_SKB(skb), 0, sizeof(struct atm_skb_data));
733 	netif_rx(new_skb);
734 
735 	return;
736 }
737 
738 static struct atmdev_ops mpc_ops = { /* only send is required */
739 	.close	= mpoad_close,
740 	.send	= msg_from_mpoad
741 };
742 
743 static struct atm_dev mpc_dev = {
744 	.ops	= &mpc_ops,
745 	.type	= "mpc",
746 	.number	= 42,
747 	.lock	= __SPIN_LOCK_UNLOCKED(mpc_dev.lock)
748 	/* members not explicitly initialised will be 0 */
749 };
750 
751 static int atm_mpoa_mpoad_attach (struct atm_vcc *vcc, int arg)
752 {
753 	struct mpoa_client *mpc;
754 	struct lec_priv *priv;
755 	int err;
756 
757 	if (mpcs == NULL) {
758 		init_timer(&mpc_timer);
759 		mpc_timer_refresh();
760 
761 		/* This lets us now how our LECs are doing */
762 		err = register_netdevice_notifier(&mpoa_notifier);
763 		if (err < 0) {
764 			del_timer(&mpc_timer);
765 			return err;
766 		}
767 	}
768 
769 	mpc = find_mpc_by_itfnum(arg);
770 	if (mpc == NULL) {
771 		dprintk("mpoa: mpoad_attach: allocating new mpc for itf %d\n", arg);
772 		mpc = alloc_mpc();
773 		if (mpc == NULL)
774 			return -ENOMEM;
775 		mpc->dev_num = arg;
776 		mpc->dev = find_lec_by_itfnum(arg); /* NULL if there was no lec */
777 	}
778 	if (mpc->mpoad_vcc) {
779 		printk("mpoa: mpoad_attach: mpoad is already present for itf %d\n", arg);
780 		return -EADDRINUSE;
781 	}
782 
783 	if (mpc->dev) { /* check if the lec is LANE2 capable */
784 		priv = (struct lec_priv *)mpc->dev->priv;
785 		if (priv->lane_version < 2) {
786 			dev_put(mpc->dev);
787 			mpc->dev = NULL;
788 		} else
789 			priv->lane2_ops->associate_indicator = lane2_assoc_ind;
790 	}
791 
792 	mpc->mpoad_vcc = vcc;
793 	vcc->dev = &mpc_dev;
794 	vcc_insert_socket(sk_atm(vcc));
795 	set_bit(ATM_VF_META,&vcc->flags);
796 	set_bit(ATM_VF_READY,&vcc->flags);
797 
798 	if (mpc->dev) {
799 		char empty[ATM_ESA_LEN];
800 		memset(empty, 0, ATM_ESA_LEN);
801 
802 		start_mpc(mpc, mpc->dev);
803 		/* set address if mpcd e.g. gets killed and restarted.
804 		 * If we do not do it now we have to wait for the next LE_ARP
805 		 */
806 		if ( memcmp(mpc->mps_ctrl_addr, empty, ATM_ESA_LEN) != 0 )
807 			send_set_mps_ctrl_addr(mpc->mps_ctrl_addr, mpc);
808 	}
809 
810 	__module_get(THIS_MODULE);
811 	return arg;
812 }
813 
814 static void send_set_mps_ctrl_addr(char *addr, struct mpoa_client *mpc)
815 {
816 	struct k_message mesg;
817 
818 	memcpy (mpc->mps_ctrl_addr, addr, ATM_ESA_LEN);
819 
820 	mesg.type = SET_MPS_CTRL_ADDR;
821 	memcpy(mesg.MPS_ctrl, addr, ATM_ESA_LEN);
822 	msg_to_mpoad(&mesg, mpc);
823 
824 	return;
825 }
826 
827 static void mpoad_close(struct atm_vcc *vcc)
828 {
829 	struct mpoa_client *mpc;
830 	struct sk_buff *skb;
831 
832 	mpc = find_mpc_by_vcc(vcc);
833 	if (mpc == NULL) {
834 		printk("mpoa: mpoad_close: did not find MPC\n");
835 		return;
836 	}
837 	if (!mpc->mpoad_vcc) {
838 		printk("mpoa: mpoad_close: close for non-present mpoad\n");
839 		return;
840 	}
841 
842 	mpc->mpoad_vcc = NULL;
843 	if (mpc->dev) {
844 		struct lec_priv *priv = (struct lec_priv *)mpc->dev->priv;
845 		priv->lane2_ops->associate_indicator = NULL;
846 		stop_mpc(mpc);
847 		dev_put(mpc->dev);
848 	}
849 
850 	mpc->in_ops->destroy_cache(mpc);
851 	mpc->eg_ops->destroy_cache(mpc);
852 
853 	while ((skb = skb_dequeue(&sk_atm(vcc)->sk_receive_queue))) {
854 		atm_return(vcc, skb->truesize);
855 		kfree_skb(skb);
856 	}
857 
858 	printk("mpoa: (%s) going down\n",
859 		(mpc->dev) ? mpc->dev->name : "<unknown>");
860 	module_put(THIS_MODULE);
861 
862 	return;
863 }
864 
865 /*
866  *
867  */
868 static int msg_from_mpoad(struct atm_vcc *vcc, struct sk_buff *skb)
869 {
870 
871 	struct mpoa_client *mpc = find_mpc_by_vcc(vcc);
872 	struct k_message *mesg = (struct k_message*)skb->data;
873 	atomic_sub(skb->truesize, &sk_atm(vcc)->sk_wmem_alloc);
874 
875 	if (mpc == NULL) {
876 		printk("mpoa: msg_from_mpoad: no mpc found\n");
877 		return 0;
878 	}
879 	dprintk("mpoa: (%s) msg_from_mpoad:", (mpc->dev) ? mpc->dev->name : "<unknown>");
880 	switch(mesg->type) {
881 	case MPOA_RES_REPLY_RCVD:
882 		dprintk(" mpoa_res_reply_rcvd\n");
883 		MPOA_res_reply_rcvd(mesg, mpc);
884 		break;
885 	case MPOA_TRIGGER_RCVD:
886 		dprintk(" mpoa_trigger_rcvd\n");
887 		MPOA_trigger_rcvd(mesg, mpc);
888 		break;
889 	case INGRESS_PURGE_RCVD:
890 		dprintk(" nhrp_purge_rcvd\n");
891 		ingress_purge_rcvd(mesg, mpc);
892 		break;
893 	case EGRESS_PURGE_RCVD:
894 		dprintk(" egress_purge_reply_rcvd\n");
895 		egress_purge_rcvd(mesg, mpc);
896 		break;
897 	case MPS_DEATH:
898 		dprintk(" mps_death\n");
899 		mps_death(mesg, mpc);
900 		break;
901 	case CACHE_IMPOS_RCVD:
902 		dprintk(" cache_impos_rcvd\n");
903 		MPOA_cache_impos_rcvd(mesg, mpc);
904 		break;
905 	case SET_MPC_CTRL_ADDR:
906 		dprintk(" set_mpc_ctrl_addr\n");
907 		set_mpc_ctrl_addr_rcvd(mesg, mpc);
908 		break;
909 	case SET_MPS_MAC_ADDR:
910 		dprintk(" set_mps_mac_addr\n");
911 		set_mps_mac_addr_rcvd(mesg, mpc);
912 		break;
913 	case CLEAN_UP_AND_EXIT:
914 		dprintk(" clean_up_and_exit\n");
915 		clean_up(mesg, mpc, DIE);
916 		break;
917 	case RELOAD:
918 		dprintk(" reload\n");
919 		clean_up(mesg, mpc, RELOAD);
920 		break;
921 	case SET_MPC_PARAMS:
922 		dprintk(" set_mpc_params\n");
923 		mpc->parameters = mesg->content.params;
924 		break;
925 	default:
926 		dprintk(" unknown message %d\n", mesg->type);
927 		break;
928 	}
929 	kfree_skb(skb);
930 
931 	return 0;
932 }
933 
934 /* Remember that this function may not do things that sleep */
935 int msg_to_mpoad(struct k_message *mesg, struct mpoa_client *mpc)
936 {
937 	struct sk_buff *skb;
938 	struct sock *sk;
939 
940 	if (mpc == NULL || !mpc->mpoad_vcc) {
941 		printk("mpoa: msg_to_mpoad: mesg %d to a non-existent mpoad\n", mesg->type);
942 		return -ENXIO;
943 	}
944 
945 	skb = alloc_skb(sizeof(struct k_message), GFP_ATOMIC);
946 	if (skb == NULL)
947 		return -ENOMEM;
948 	skb_put(skb, sizeof(struct k_message));
949 	skb_copy_to_linear_data(skb, mesg, sizeof(*mesg));
950 	atm_force_charge(mpc->mpoad_vcc, skb->truesize);
951 
952 	sk = sk_atm(mpc->mpoad_vcc);
953 	skb_queue_tail(&sk->sk_receive_queue, skb);
954 	sk->sk_data_ready(sk, skb->len);
955 
956 	return 0;
957 }
958 
959 static int mpoa_event_listener(struct notifier_block *mpoa_notifier, unsigned long event, void *dev_ptr)
960 {
961 	struct net_device *dev;
962 	struct mpoa_client *mpc;
963 	struct lec_priv *priv;
964 
965 	dev = (struct net_device *)dev_ptr;
966 
967 	if (dev_net(dev) != &init_net)
968 		return NOTIFY_DONE;
969 
970 	if (dev->name == NULL || strncmp(dev->name, "lec", 3))
971 		return NOTIFY_DONE; /* we are only interested in lec:s */
972 
973 	switch (event) {
974 	case NETDEV_REGISTER:       /* a new lec device was allocated */
975 		priv = (struct lec_priv *)dev->priv;
976 		if (priv->lane_version < 2)
977 			break;
978 		priv->lane2_ops->associate_indicator = lane2_assoc_ind;
979 		mpc = find_mpc_by_itfnum(priv->itfnum);
980 		if (mpc == NULL) {
981 			dprintk("mpoa: mpoa_event_listener: allocating new mpc for %s\n",
982 			       dev->name);
983 			mpc = alloc_mpc();
984 			if (mpc == NULL) {
985 				printk("mpoa: mpoa_event_listener: no new mpc");
986 				break;
987 			}
988 		}
989 		mpc->dev_num = priv->itfnum;
990 		mpc->dev = dev;
991 		dev_hold(dev);
992 		dprintk("mpoa: (%s) was initialized\n", dev->name);
993 		break;
994 	case NETDEV_UNREGISTER:
995 		/* the lec device was deallocated */
996 		mpc = find_mpc_by_lec(dev);
997 		if (mpc == NULL)
998 			break;
999 		dprintk("mpoa: device (%s) was deallocated\n", dev->name);
1000 		stop_mpc(mpc);
1001 		dev_put(mpc->dev);
1002 		mpc->dev = NULL;
1003 		break;
1004 	case NETDEV_UP:
1005 		/* the dev was ifconfig'ed up */
1006 		mpc = find_mpc_by_lec(dev);
1007 		if (mpc == NULL)
1008 			break;
1009 		if (mpc->mpoad_vcc != NULL) {
1010 			start_mpc(mpc, dev);
1011 		}
1012 		break;
1013 	case NETDEV_DOWN:
1014 		/* the dev was ifconfig'ed down */
1015 		/* this means that the flow of packets from the
1016 		 * upper layer stops
1017 		 */
1018 		mpc = find_mpc_by_lec(dev);
1019 		if (mpc == NULL)
1020 			break;
1021 		if (mpc->mpoad_vcc != NULL) {
1022 			stop_mpc(mpc);
1023 		}
1024 		break;
1025 	case NETDEV_REBOOT:
1026 	case NETDEV_CHANGE:
1027 	case NETDEV_CHANGEMTU:
1028 	case NETDEV_CHANGEADDR:
1029 	case NETDEV_GOING_DOWN:
1030 		break;
1031 	default:
1032 		break;
1033 	}
1034 
1035 	return NOTIFY_DONE;
1036 }
1037 
1038 /*
1039  * Functions which are called after a message is received from mpcd.
1040  * Msg is reused on purpose.
1041  */
1042 
1043 
1044 static void MPOA_trigger_rcvd(struct k_message *msg, struct mpoa_client *mpc)
1045 {
1046 	__be32 dst_ip = msg->content.in_info.in_dst_ip;
1047 	in_cache_entry *entry;
1048 
1049 	entry = mpc->in_ops->get(dst_ip, mpc);
1050 	if(entry == NULL){
1051 		entry = mpc->in_ops->add_entry(dst_ip, mpc);
1052 		entry->entry_state = INGRESS_RESOLVING;
1053 		msg->type = SND_MPOA_RES_RQST;
1054 		msg->content.in_info = entry->ctrl_info;
1055 		msg_to_mpoad(msg, mpc);
1056 		do_gettimeofday(&(entry->reply_wait));
1057 		mpc->in_ops->put(entry);
1058 		return;
1059 	}
1060 
1061 	if(entry->entry_state == INGRESS_INVALID){
1062 		entry->entry_state = INGRESS_RESOLVING;
1063 		msg->type = SND_MPOA_RES_RQST;
1064 		msg->content.in_info = entry->ctrl_info;
1065 		msg_to_mpoad(msg, mpc);
1066 		do_gettimeofday(&(entry->reply_wait));
1067 		mpc->in_ops->put(entry);
1068 		return;
1069 	}
1070 
1071 	printk("mpoa: (%s) MPOA_trigger_rcvd: entry already in resolving state\n",
1072 		(mpc->dev) ? mpc->dev->name : "<unknown>");
1073 	mpc->in_ops->put(entry);
1074 	return;
1075 }
1076 
1077 /*
1078  * Things get complicated because we have to check if there's an egress
1079  * shortcut with suitable traffic parameters we could use.
1080  */
1081 static void check_qos_and_open_shortcut(struct k_message *msg, struct mpoa_client *client, in_cache_entry *entry)
1082 {
1083 	__be32 dst_ip = msg->content.in_info.in_dst_ip;
1084 	struct atm_mpoa_qos *qos = atm_mpoa_search_qos(dst_ip);
1085 	eg_cache_entry *eg_entry = client->eg_ops->get_by_src_ip(dst_ip, client);
1086 
1087 	if(eg_entry && eg_entry->shortcut){
1088 		if(eg_entry->shortcut->qos.txtp.traffic_class &
1089 		   msg->qos.txtp.traffic_class &
1090 		   (qos ? qos->qos.txtp.traffic_class : ATM_UBR | ATM_CBR)){
1091 			    if(eg_entry->shortcut->qos.txtp.traffic_class == ATM_UBR)
1092 				    entry->shortcut = eg_entry->shortcut;
1093 			    else if(eg_entry->shortcut->qos.txtp.max_pcr > 0)
1094 				    entry->shortcut = eg_entry->shortcut;
1095 		}
1096 		if(entry->shortcut){
1097 			dprintk("mpoa: (%s) using egress SVC to reach %u.%u.%u.%u\n",client->dev->name, NIPQUAD(dst_ip));
1098 			client->eg_ops->put(eg_entry);
1099 			return;
1100 		}
1101 	}
1102 	if (eg_entry != NULL)
1103 		client->eg_ops->put(eg_entry);
1104 
1105 	/* No luck in the egress cache we must open an ingress SVC */
1106 	msg->type = OPEN_INGRESS_SVC;
1107 	if (qos && (qos->qos.txtp.traffic_class == msg->qos.txtp.traffic_class))
1108 	{
1109 		msg->qos = qos->qos;
1110 		printk("mpoa: (%s) trying to get a CBR shortcut\n",client->dev->name);
1111 	}
1112 	else memset(&msg->qos,0,sizeof(struct atm_qos));
1113 	msg_to_mpoad(msg, client);
1114 	return;
1115 }
1116 
1117 static void MPOA_res_reply_rcvd(struct k_message *msg, struct mpoa_client *mpc)
1118 {
1119 	__be32 dst_ip = msg->content.in_info.in_dst_ip;
1120 	in_cache_entry *entry = mpc->in_ops->get(dst_ip, mpc);
1121 
1122 	dprintk("mpoa: (%s) MPOA_res_reply_rcvd: ip %u.%u.%u.%u\n", mpc->dev->name, NIPQUAD(dst_ip));
1123 	ddprintk("mpoa: (%s) MPOA_res_reply_rcvd() entry = %p", mpc->dev->name, entry);
1124 	if(entry == NULL){
1125 		printk("\nmpoa: (%s) ARGH, received res. reply for an entry that doesn't exist.\n", mpc->dev->name);
1126 		return;
1127 	}
1128 	ddprintk(" entry_state = %d ", entry->entry_state);
1129 
1130 	if (entry->entry_state == INGRESS_RESOLVED) {
1131 		printk("\nmpoa: (%s) MPOA_res_reply_rcvd for RESOLVED entry!\n", mpc->dev->name);
1132 		mpc->in_ops->put(entry);
1133 		return;
1134 	}
1135 
1136 	entry->ctrl_info = msg->content.in_info;
1137 	do_gettimeofday(&(entry->tv));
1138 	do_gettimeofday(&(entry->reply_wait)); /* Used in refreshing func from now on */
1139 	entry->refresh_time = 0;
1140 	ddprintk("entry->shortcut = %p\n", entry->shortcut);
1141 
1142 	if(entry->entry_state == INGRESS_RESOLVING && entry->shortcut != NULL){
1143 		entry->entry_state = INGRESS_RESOLVED;
1144 		mpc->in_ops->put(entry);
1145 		return; /* Shortcut already open... */
1146 	}
1147 
1148 	if (entry->shortcut != NULL) {
1149 		printk("mpoa: (%s) MPOA_res_reply_rcvd: entry->shortcut != NULL, impossible!\n",
1150 		       mpc->dev->name);
1151 		mpc->in_ops->put(entry);
1152 		return;
1153 	}
1154 
1155 	check_qos_and_open_shortcut(msg, mpc, entry);
1156 	entry->entry_state = INGRESS_RESOLVED;
1157 	mpc->in_ops->put(entry);
1158 
1159 	return;
1160 
1161 }
1162 
1163 static void ingress_purge_rcvd(struct k_message *msg, struct mpoa_client *mpc)
1164 {
1165 	__be32 dst_ip = msg->content.in_info.in_dst_ip;
1166 	__be32 mask = msg->ip_mask;
1167 	in_cache_entry *entry = mpc->in_ops->get_with_mask(dst_ip, mpc, mask);
1168 
1169 	if(entry == NULL){
1170 		printk("mpoa: (%s) ingress_purge_rcvd: purge for a non-existing entry, ", mpc->dev->name);
1171 		printk("ip = %u.%u.%u.%u\n", NIPQUAD(dst_ip));
1172 		return;
1173 	}
1174 
1175 	do {
1176 		dprintk("mpoa: (%s) ingress_purge_rcvd: removing an ingress entry, ip = %u.%u.%u.%u\n" ,
1177 			mpc->dev->name, NIPQUAD(dst_ip));
1178 		write_lock_bh(&mpc->ingress_lock);
1179 		mpc->in_ops->remove_entry(entry, mpc);
1180 		write_unlock_bh(&mpc->ingress_lock);
1181 		mpc->in_ops->put(entry);
1182 		entry = mpc->in_ops->get_with_mask(dst_ip, mpc, mask);
1183 	} while (entry != NULL);
1184 
1185 	return;
1186 }
1187 
1188 static void egress_purge_rcvd(struct k_message *msg, struct mpoa_client *mpc)
1189 {
1190 	__be32 cache_id = msg->content.eg_info.cache_id;
1191 	eg_cache_entry *entry = mpc->eg_ops->get_by_cache_id(cache_id, mpc);
1192 
1193 	if (entry == NULL) {
1194 		dprintk("mpoa: (%s) egress_purge_rcvd: purge for a non-existing entry\n", mpc->dev->name);
1195 		return;
1196 	}
1197 
1198 	write_lock_irq(&mpc->egress_lock);
1199 	mpc->eg_ops->remove_entry(entry, mpc);
1200 	write_unlock_irq(&mpc->egress_lock);
1201 
1202 	mpc->eg_ops->put(entry);
1203 
1204 	return;
1205 }
1206 
1207 static void purge_egress_shortcut(struct atm_vcc *vcc, eg_cache_entry *entry)
1208 {
1209 	struct sock *sk;
1210 	struct k_message *purge_msg;
1211 	struct sk_buff *skb;
1212 
1213 	dprintk("mpoa: purge_egress_shortcut: entering\n");
1214 	if (vcc == NULL) {
1215 		printk("mpoa: purge_egress_shortcut: vcc == NULL\n");
1216 		return;
1217 	}
1218 
1219 	skb = alloc_skb(sizeof(struct k_message), GFP_ATOMIC);
1220 	if (skb == NULL) {
1221 		 printk("mpoa: purge_egress_shortcut: out of memory\n");
1222 		return;
1223 	}
1224 
1225 	skb_put(skb, sizeof(struct k_message));
1226 	memset(skb->data, 0, sizeof(struct k_message));
1227 	purge_msg = (struct k_message *)skb->data;
1228 	purge_msg->type = DATA_PLANE_PURGE;
1229 	if (entry != NULL)
1230 		purge_msg->content.eg_info = entry->ctrl_info;
1231 
1232 	atm_force_charge(vcc, skb->truesize);
1233 
1234 	sk = sk_atm(vcc);
1235 	skb_queue_tail(&sk->sk_receive_queue, skb);
1236 	sk->sk_data_ready(sk, skb->len);
1237 	dprintk("mpoa: purge_egress_shortcut: exiting:\n");
1238 
1239 	return;
1240 }
1241 
1242 /*
1243  * Our MPS died. Tell our daemon to send NHRP data plane purge to each
1244  * of the egress shortcuts we have.
1245  */
1246 static void mps_death( struct k_message * msg, struct mpoa_client * mpc )
1247 {
1248 	eg_cache_entry *entry;
1249 
1250 	dprintk("mpoa: (%s) mps_death:\n", mpc->dev->name);
1251 
1252 	if(memcmp(msg->MPS_ctrl, mpc->mps_ctrl_addr, ATM_ESA_LEN)){
1253 		printk("mpoa: (%s) mps_death: wrong MPS\n", mpc->dev->name);
1254 		return;
1255 	}
1256 
1257 	/* FIXME: This knows too much of the cache structure */
1258 	read_lock_irq(&mpc->egress_lock);
1259 	entry = mpc->eg_cache;
1260 	while (entry != NULL) {
1261 		purge_egress_shortcut(entry->shortcut, entry);
1262 		entry = entry->next;
1263 	}
1264 	read_unlock_irq(&mpc->egress_lock);
1265 
1266 	mpc->in_ops->destroy_cache(mpc);
1267 	mpc->eg_ops->destroy_cache(mpc);
1268 
1269 	return;
1270 }
1271 
1272 static void MPOA_cache_impos_rcvd( struct k_message * msg, struct mpoa_client * mpc)
1273 {
1274 	uint16_t holding_time;
1275 	eg_cache_entry *entry = mpc->eg_ops->get_by_cache_id(msg->content.eg_info.cache_id, mpc);
1276 
1277 	holding_time = msg->content.eg_info.holding_time;
1278 	dprintk("mpoa: (%s) MPOA_cache_impos_rcvd: entry = %p, holding_time = %u\n",
1279 	       mpc->dev->name, entry, holding_time);
1280 	if(entry == NULL && holding_time) {
1281 		entry = mpc->eg_ops->add_entry(msg, mpc);
1282 		mpc->eg_ops->put(entry);
1283 		return;
1284 	}
1285 	if(holding_time){
1286 		mpc->eg_ops->update(entry, holding_time);
1287 		return;
1288 	}
1289 
1290 	write_lock_irq(&mpc->egress_lock);
1291 	mpc->eg_ops->remove_entry(entry, mpc);
1292 	write_unlock_irq(&mpc->egress_lock);
1293 
1294 	mpc->eg_ops->put(entry);
1295 
1296 	return;
1297 }
1298 
1299 static void set_mpc_ctrl_addr_rcvd(struct k_message *mesg, struct mpoa_client *mpc)
1300 {
1301 	struct lec_priv *priv;
1302 	int i, retval ;
1303 
1304 	uint8_t tlv[4 + 1 + 1 + 1 + ATM_ESA_LEN];
1305 
1306 	tlv[0] = 00; tlv[1] = 0xa0; tlv[2] = 0x3e; tlv[3] = 0x2a; /* type  */
1307 	tlv[4] = 1 + 1 + ATM_ESA_LEN;  /* length                           */
1308 	tlv[5] = 0x02;                 /* MPOA client                      */
1309 	tlv[6] = 0x00;                 /* number of MPS MAC addresses      */
1310 
1311 	memcpy(&tlv[7], mesg->MPS_ctrl, ATM_ESA_LEN); /* MPC ctrl ATM addr */
1312 	memcpy(mpc->our_ctrl_addr, mesg->MPS_ctrl, ATM_ESA_LEN);
1313 
1314 	dprintk("mpoa: (%s) setting MPC ctrl ATM address to ",
1315 	       (mpc->dev) ? mpc->dev->name : "<unknown>");
1316 	for (i = 7; i < sizeof(tlv); i++)
1317 		dprintk("%02x ", tlv[i]);
1318 	dprintk("\n");
1319 
1320 	if (mpc->dev) {
1321 		priv = (struct lec_priv *)mpc->dev->priv;
1322 		retval = priv->lane2_ops->associate_req(mpc->dev, mpc->dev->dev_addr, tlv, sizeof(tlv));
1323 		if (retval == 0)
1324 			printk("mpoa: (%s) MPOA device type TLV association failed\n", mpc->dev->name);
1325 		retval = priv->lane2_ops->resolve(mpc->dev, NULL, 1, NULL, NULL);
1326 		if (retval < 0)
1327 			printk("mpoa: (%s) targetless LE_ARP request failed\n", mpc->dev->name);
1328 	}
1329 
1330 	return;
1331 }
1332 
1333 static void set_mps_mac_addr_rcvd(struct k_message *msg, struct mpoa_client *client)
1334 {
1335 
1336 	if(client->number_of_mps_macs)
1337 		kfree(client->mps_macs);
1338 	client->number_of_mps_macs = 0;
1339 	client->mps_macs = kmemdup(msg->MPS_ctrl, ETH_ALEN, GFP_KERNEL);
1340 	if (client->mps_macs == NULL) {
1341 		printk("mpoa: set_mps_mac_addr_rcvd: out of memory\n");
1342 		return;
1343 	}
1344 	client->number_of_mps_macs = 1;
1345 
1346 	return;
1347 }
1348 
1349 /*
1350  * purge egress cache and tell daemon to 'action' (DIE, RELOAD)
1351  */
1352 static void clean_up(struct k_message *msg, struct mpoa_client *mpc, int action)
1353 {
1354 
1355 	eg_cache_entry *entry;
1356 	msg->type = SND_EGRESS_PURGE;
1357 
1358 
1359 	/* FIXME: This knows too much of the cache structure */
1360 	read_lock_irq(&mpc->egress_lock);
1361 	entry = mpc->eg_cache;
1362 	while (entry != NULL){
1363 		    msg->content.eg_info = entry->ctrl_info;
1364 		    dprintk("mpoa: cache_id %u\n", entry->ctrl_info.cache_id);
1365 		    msg_to_mpoad(msg, mpc);
1366 		    entry = entry->next;
1367 	}
1368 	read_unlock_irq(&mpc->egress_lock);
1369 
1370 	msg->type = action;
1371 	msg_to_mpoad(msg, mpc);
1372 	return;
1373 }
1374 
1375 static void mpc_timer_refresh(void)
1376 {
1377 	mpc_timer.expires = jiffies + (MPC_P2 * HZ);
1378 	mpc_timer.data = mpc_timer.expires;
1379 	mpc_timer.function = mpc_cache_check;
1380 	add_timer(&mpc_timer);
1381 
1382 	return;
1383 }
1384 
1385 static void mpc_cache_check( unsigned long checking_time  )
1386 {
1387 	struct mpoa_client *mpc = mpcs;
1388 	static unsigned long previous_resolving_check_time;
1389 	static unsigned long previous_refresh_time;
1390 
1391 	while( mpc != NULL ){
1392 		mpc->in_ops->clear_count(mpc);
1393 		mpc->eg_ops->clear_expired(mpc);
1394 		if(checking_time - previous_resolving_check_time > mpc->parameters.mpc_p4 * HZ ){
1395 			mpc->in_ops->check_resolving(mpc);
1396 			previous_resolving_check_time = checking_time;
1397 		}
1398 		if(checking_time - previous_refresh_time > mpc->parameters.mpc_p5 * HZ ){
1399 			mpc->in_ops->refresh(mpc);
1400 			previous_refresh_time = checking_time;
1401 		}
1402 		mpc = mpc->next;
1403 	}
1404 	mpc_timer_refresh();
1405 
1406 	return;
1407 }
1408 
1409 static int atm_mpoa_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1410 {
1411 	int err = 0;
1412 	struct atm_vcc *vcc = ATM_SD(sock);
1413 
1414 	if (cmd != ATMMPC_CTRL && cmd != ATMMPC_DATA)
1415 		return -ENOIOCTLCMD;
1416 
1417 	if (!capable(CAP_NET_ADMIN))
1418 		return -EPERM;
1419 
1420 	switch (cmd) {
1421 		case ATMMPC_CTRL:
1422 			err = atm_mpoa_mpoad_attach(vcc, (int)arg);
1423 			if (err >= 0)
1424 				sock->state = SS_CONNECTED;
1425 			break;
1426 		case ATMMPC_DATA:
1427 			err = atm_mpoa_vcc_attach(vcc, (void __user *)arg);
1428 			break;
1429 		default:
1430 			break;
1431 	}
1432 	return err;
1433 }
1434 
1435 
1436 static struct atm_ioctl atm_ioctl_ops = {
1437 	.owner	= THIS_MODULE,
1438 	.ioctl	= atm_mpoa_ioctl,
1439 };
1440 
1441 static __init int atm_mpoa_init(void)
1442 {
1443 	register_atm_ioctl(&atm_ioctl_ops);
1444 
1445 	if (mpc_proc_init() != 0)
1446 		printk(KERN_INFO "mpoa: failed to initialize /proc/mpoa\n");
1447 
1448 	printk("mpc.c: " __DATE__ " " __TIME__ " initialized\n");
1449 
1450 	return 0;
1451 }
1452 
1453 static void __exit atm_mpoa_cleanup(void)
1454 {
1455 	struct mpoa_client *mpc, *tmp;
1456 	struct atm_mpoa_qos *qos, *nextqos;
1457 	struct lec_priv *priv;
1458 
1459 	mpc_proc_clean();
1460 
1461 	del_timer(&mpc_timer);
1462 	unregister_netdevice_notifier(&mpoa_notifier);
1463 	deregister_atm_ioctl(&atm_ioctl_ops);
1464 
1465 	mpc = mpcs;
1466 	mpcs = NULL;
1467 	while (mpc != NULL) {
1468 		tmp = mpc->next;
1469 		if (mpc->dev != NULL) {
1470 			stop_mpc(mpc);
1471 			priv = (struct lec_priv *)mpc->dev->priv;
1472 			if (priv->lane2_ops != NULL)
1473 				priv->lane2_ops->associate_indicator = NULL;
1474 		}
1475 		ddprintk("mpoa: cleanup_module: about to clear caches\n");
1476 		mpc->in_ops->destroy_cache(mpc);
1477 		mpc->eg_ops->destroy_cache(mpc);
1478 		ddprintk("mpoa: cleanup_module: caches cleared\n");
1479 		kfree(mpc->mps_macs);
1480 		memset(mpc, 0, sizeof(struct mpoa_client));
1481 		ddprintk("mpoa: cleanup_module: about to kfree %p\n", mpc);
1482 		kfree(mpc);
1483 		ddprintk("mpoa: cleanup_module: next mpc is at %p\n", tmp);
1484 		mpc = tmp;
1485 	}
1486 
1487 	qos = qos_head;
1488 	qos_head = NULL;
1489 	while (qos != NULL) {
1490 		nextqos = qos->next;
1491 		dprintk("mpoa: cleanup_module: freeing qos entry %p\n", qos);
1492 		kfree(qos);
1493 		qos = nextqos;
1494 	}
1495 
1496 	return;
1497 }
1498 
1499 module_init(atm_mpoa_init);
1500 module_exit(atm_mpoa_cleanup);
1501 
1502 MODULE_LICENSE("GPL");
1503