1 #define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__
3 #include <linux/kernel.h>
4 #include <linux/string.h>
5 #include <linux/timer.h>
6 #include <linux/init.h>
7 #include <linux/bitops.h>
8 #include <linux/capability.h>
9 #include <linux/seq_file.h>
11 /* We are an ethernet device */
12 #include <linux/if_ether.h>
13 #include <linux/netdevice.h>
14 #include <linux/etherdevice.h>
16 #include <linux/skbuff.h>
18 #include <asm/byteorder.h>
19 #include <asm/uaccess.h>
20 #include <net/checksum.h> /* for ip_fast_csum() */
23 #include <linux/proc_fs.h>
26 #include <linux/atmdev.h>
27 #include <linux/atmlec.h>
28 #include <linux/atmmpc.h>
30 #include <linux/module.h>
34 #include "resources.h"
37 * mpc.c: Implementation of MPOA client kernel part
41 #define dprintk printk /* debug */
43 #define dprintk(format,args...)
47 #define ddprintk printk /* more debug */
49 #define ddprintk(format,args...)
54 #define MPOA_TAG_LEN 4
56 /* mpc_daemon -> kernel */
57 static void MPOA_trigger_rcvd (struct k_message
*msg
, struct mpoa_client
*mpc
);
58 static void MPOA_res_reply_rcvd(struct k_message
*msg
, struct mpoa_client
*mpc
);
59 static void ingress_purge_rcvd(struct k_message
*msg
, struct mpoa_client
*mpc
);
60 static void egress_purge_rcvd(struct k_message
*msg
, struct mpoa_client
*mpc
);
61 static void mps_death(struct k_message
*msg
, struct mpoa_client
*mpc
);
62 static void clean_up(struct k_message
*msg
, struct mpoa_client
*mpc
, int action
);
63 static void MPOA_cache_impos_rcvd(struct k_message
*msg
, struct mpoa_client
*mpc
);
64 static void set_mpc_ctrl_addr_rcvd(struct k_message
*mesg
, struct mpoa_client
*mpc
);
65 static void set_mps_mac_addr_rcvd(struct k_message
*mesg
, struct mpoa_client
*mpc
);
67 static const uint8_t *copy_macs(struct mpoa_client
*mpc
,
68 const uint8_t *router_mac
,
69 const uint8_t *tlvs
, uint8_t mps_macs
,
71 static void purge_egress_shortcut(struct atm_vcc
*vcc
, eg_cache_entry
*entry
);
73 static void send_set_mps_ctrl_addr(const char *addr
, struct mpoa_client
*mpc
);
74 static void mpoad_close(struct atm_vcc
*vcc
);
75 static int msg_from_mpoad(struct atm_vcc
*vcc
, struct sk_buff
*skb
);
77 static void mpc_push(struct atm_vcc
*vcc
, struct sk_buff
*skb
);
78 static netdev_tx_t
mpc_send_packet(struct sk_buff
*skb
,
79 struct net_device
*dev
);
80 static int mpoa_event_listener(struct notifier_block
*mpoa_notifier
, unsigned long event
, void *dev
);
81 static void mpc_timer_refresh(void);
82 static void mpc_cache_check( unsigned long checking_time
);
84 static struct llc_snap_hdr llc_snap_mpoa_ctrl
= {
87 {0x00, 0x03} /* For MPOA control PDUs */
89 static struct llc_snap_hdr llc_snap_mpoa_data
= {
92 {0x08, 0x00} /* This is for IP PDUs only */
94 static struct llc_snap_hdr llc_snap_mpoa_data_tagged
= {
97 {0x88, 0x4c} /* This is for tagged data PDUs */
100 static struct notifier_block mpoa_notifier
= {
106 struct mpoa_client
*mpcs
= NULL
; /* FIXME */
107 static struct atm_mpoa_qos
*qos_head
= NULL
;
108 static DEFINE_TIMER(mpc_timer
, NULL
, 0, 0);
111 static struct mpoa_client
*find_mpc_by_itfnum(int itf
)
113 struct mpoa_client
*mpc
;
115 mpc
= mpcs
; /* our global linked list */
116 while (mpc
!= NULL
) {
117 if (mpc
->dev_num
== itf
)
122 return NULL
; /* not found */
125 static struct mpoa_client
*find_mpc_by_vcc(struct atm_vcc
*vcc
)
127 struct mpoa_client
*mpc
;
129 mpc
= mpcs
; /* our global linked list */
130 while (mpc
!= NULL
) {
131 if (mpc
->mpoad_vcc
== vcc
)
136 return NULL
; /* not found */
139 static struct mpoa_client
*find_mpc_by_lec(struct net_device
*dev
)
141 struct mpoa_client
*mpc
;
143 mpc
= mpcs
; /* our global linked list */
144 while (mpc
!= NULL
) {
150 return NULL
; /* not found */
154 * Functions for managing QoS list
158 * Overwrites the old entry or makes a new one.
160 struct atm_mpoa_qos
*atm_mpoa_add_qos(__be32 dst_ip
, struct atm_qos
*qos
)
162 struct atm_mpoa_qos
*entry
;
164 entry
= atm_mpoa_search_qos(dst_ip
);
170 entry
= kmalloc(sizeof(struct atm_mpoa_qos
), GFP_KERNEL
);
172 printk("mpoa: atm_mpoa_add_qos: out of memory\n");
176 entry
->ipaddr
= dst_ip
;
179 entry
->next
= qos_head
;
185 struct atm_mpoa_qos
*atm_mpoa_search_qos(__be32 dst_ip
)
187 struct atm_mpoa_qos
*qos
;
190 while( qos
!= NULL
){
191 if(qos
->ipaddr
== dst_ip
) {
201 * Returns 0 for failure
203 int atm_mpoa_delete_qos(struct atm_mpoa_qos
*entry
)
206 struct atm_mpoa_qos
*curr
;
208 if (entry
== NULL
) return 0;
209 if (entry
== qos_head
) {
210 qos_head
= qos_head
->next
;
216 while (curr
!= NULL
) {
217 if (curr
->next
== entry
) {
218 curr
->next
= entry
->next
;
228 /* this is buggered - we need locking for qos_head */
229 void atm_mpoa_disp_qos(struct seq_file
*m
)
231 struct atm_mpoa_qos
*qos
;
234 seq_printf(m
, "QoS entries for shortcuts:\n");
235 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");
237 while (qos
!= NULL
) {
238 seq_printf(m
, "%pI4\n %-7d %-7d %-7d %-7d %-7d\n %-7d %-7d %-7d %-7d %-7d\n",
240 qos
->qos
.txtp
.max_pcr
, qos
->qos
.txtp
.pcr
, qos
->qos
.txtp
.min_pcr
, qos
->qos
.txtp
.max_cdv
, qos
->qos
.txtp
.max_sdu
,
241 qos
->qos
.rxtp
.max_pcr
, qos
->qos
.rxtp
.pcr
, qos
->qos
.rxtp
.min_pcr
, qos
->qos
.rxtp
.max_cdv
, qos
->qos
.rxtp
.max_sdu
);
246 static struct net_device
*find_lec_by_itfnum(int itf
)
248 struct net_device
*dev
;
251 sprintf(name
, "lec%d", itf
);
252 dev
= dev_get_by_name(&init_net
, name
);
257 static struct mpoa_client
*alloc_mpc(void)
259 struct mpoa_client
*mpc
;
261 mpc
= kzalloc(sizeof (struct mpoa_client
), GFP_KERNEL
);
264 rwlock_init(&mpc
->ingress_lock
);
265 rwlock_init(&mpc
->egress_lock
);
267 atm_mpoa_init_cache(mpc
);
269 mpc
->parameters
.mpc_p1
= MPC_P1
;
270 mpc
->parameters
.mpc_p2
= MPC_P2
;
271 memset(mpc
->parameters
.mpc_p3
,0,sizeof(mpc
->parameters
.mpc_p3
));
272 mpc
->parameters
.mpc_p4
= MPC_P4
;
273 mpc
->parameters
.mpc_p5
= MPC_P5
;
274 mpc
->parameters
.mpc_p6
= MPC_P6
;
283 * start_mpc() puts the MPC on line. All the packets destined
284 * to the lec underneath us are now being monitored and
285 * shortcuts will be established.
288 static void start_mpc(struct mpoa_client
*mpc
, struct net_device
*dev
)
291 dprintk("mpoa: (%s) start_mpc:\n", mpc
->dev
->name
);
292 if (!dev
->netdev_ops
)
293 printk("mpoa: (%s) start_mpc not starting\n", dev
->name
);
295 mpc
->old_ops
= dev
->netdev_ops
;
296 mpc
->new_ops
= *mpc
->old_ops
;
297 mpc
->new_ops
.ndo_start_xmit
= mpc_send_packet
;
298 dev
->netdev_ops
= &mpc
->new_ops
;
302 static void stop_mpc(struct mpoa_client
*mpc
)
304 struct net_device
*dev
= mpc
->dev
;
305 dprintk("mpoa: (%s) stop_mpc:", mpc
->dev
->name
);
307 /* Lets not nullify lec device's dev->hard_start_xmit */
308 if (dev
->netdev_ops
!= &mpc
->new_ops
) {
309 dprintk(" mpc already stopped, not fatal\n");
314 dev
->netdev_ops
= mpc
->old_ops
;
317 /* close_shortcuts(mpc); ??? FIXME */
320 static const char *mpoa_device_type_string(char type
) __attribute__ ((unused
));
322 static const char *mpoa_device_type_string(char type
)
326 return "non-MPOA device";
335 return "both MPS and MPC";
338 return "unspecified (non-MPOA) device";
342 return ""; /* not reached */
346 * lec device calls this via its netdev_priv(dev)->lane2_ops
347 * ->associate_indicator() when it sees a TLV in LE_ARP packet.
348 * We fill in the pointer above when we see a LANE2 lec initializing
349 * See LANE2 spec 3.1.5
351 * Quite a big and ugly function but when you look at it
352 * all it does is to try to locate and parse MPOA Device
354 * We give our lec a pointer to this function and when the
355 * lec sees a TLV it uses the pointer to call this function.
358 static void lane2_assoc_ind(struct net_device
*dev
, const u8
*mac_addr
,
359 const u8
*tlvs
, u32 sizeoftlvs
)
362 uint8_t length
, mpoa_device_type
, number_of_mps_macs
;
363 const uint8_t *end_of_tlvs
;
364 struct mpoa_client
*mpc
;
366 mpoa_device_type
= number_of_mps_macs
= 0; /* silence gcc */
367 dprintk("mpoa: (%s) lane2_assoc_ind: received TLV(s), ", dev
->name
);
368 dprintk("total length of all TLVs %d\n", sizeoftlvs
);
369 mpc
= find_mpc_by_lec(dev
); /* Sampo-Fix: moved here from below */
371 printk("mpoa: (%s) lane2_assoc_ind: no mpc\n", dev
->name
);
374 end_of_tlvs
= tlvs
+ sizeoftlvs
;
375 while (end_of_tlvs
- tlvs
>= 5) {
376 type
= (tlvs
[0] << 24) | (tlvs
[1] << 16) | (tlvs
[2] << 8) | tlvs
[3];
379 dprintk(" type 0x%x length %02x\n", type
, length
);
380 if (tlvs
+ length
> end_of_tlvs
) {
381 printk("TLV value extends past its buffer, aborting parse\n");
386 printk("mpoa: (%s) lane2_assoc_ind: TLV type was 0, returning\n", dev
->name
);
390 if (type
!= TLV_MPOA_DEVICE_TYPE
) {
392 continue; /* skip other TLVs */
394 mpoa_device_type
= *tlvs
++;
395 number_of_mps_macs
= *tlvs
++;
396 dprintk("mpoa: (%s) MPOA device type '%s', ", dev
->name
, mpoa_device_type_string(mpoa_device_type
));
397 if (mpoa_device_type
== MPS_AND_MPC
&&
398 length
< (42 + number_of_mps_macs
*ETH_ALEN
)) { /* :) */
399 printk("\nmpoa: (%s) lane2_assoc_ind: short MPOA Device Type TLV\n",
403 if ((mpoa_device_type
== MPS
|| mpoa_device_type
== MPC
)
404 && length
< 22 + number_of_mps_macs
*ETH_ALEN
) {
405 printk("\nmpoa: (%s) lane2_assoc_ind: short MPOA Device Type TLV\n",
409 if (mpoa_device_type
!= MPS
&& mpoa_device_type
!= MPS_AND_MPC
) {
410 dprintk("ignoring non-MPS device\n");
411 if (mpoa_device_type
== MPC
) tlvs
+= 20;
412 continue; /* we are only interested in MPSs */
414 if (number_of_mps_macs
== 0 && mpoa_device_type
== MPS_AND_MPC
) {
415 printk("\nmpoa: (%s) lane2_assoc_ind: MPS_AND_MPC has zero MACs\n", dev
->name
);
416 continue; /* someone should read the spec */
418 dprintk("this MPS has %d MAC addresses\n", number_of_mps_macs
);
420 /* ok, now we can go and tell our daemon the control address of MPS */
421 send_set_mps_ctrl_addr(tlvs
, mpc
);
423 tlvs
= copy_macs(mpc
, mac_addr
, tlvs
, number_of_mps_macs
, mpoa_device_type
);
424 if (tlvs
== NULL
) return;
426 if (end_of_tlvs
- tlvs
!= 0)
427 printk("mpoa: (%s) lane2_assoc_ind: ignoring %Zd bytes of trailing TLV carbage\n",
428 dev
->name
, end_of_tlvs
- tlvs
);
433 * Store at least advertizing router's MAC address
434 * plus the possible MAC address(es) to mpc->mps_macs.
435 * For a freshly allocated MPOA client mpc->mps_macs == 0.
437 static const uint8_t *copy_macs(struct mpoa_client
*mpc
,
438 const uint8_t *router_mac
,
439 const uint8_t *tlvs
, uint8_t mps_macs
,
443 num_macs
= (mps_macs
> 1) ? mps_macs
: 1;
445 if (mpc
->number_of_mps_macs
!= num_macs
) { /* need to reallocate? */
446 if (mpc
->number_of_mps_macs
!= 0) kfree(mpc
->mps_macs
);
447 mpc
->number_of_mps_macs
= 0;
448 mpc
->mps_macs
= kmalloc(num_macs
*ETH_ALEN
, GFP_KERNEL
);
449 if (mpc
->mps_macs
== NULL
) {
450 printk("mpoa: (%s) copy_macs: out of mem\n", mpc
->dev
->name
);
454 memcpy(mpc
->mps_macs
, router_mac
, ETH_ALEN
);
455 tlvs
+= 20; if (device_type
== MPS_AND_MPC
) tlvs
+= 20;
457 memcpy(mpc
->mps_macs
, tlvs
, mps_macs
*ETH_ALEN
);
458 tlvs
+= mps_macs
*ETH_ALEN
;
459 mpc
->number_of_mps_macs
= num_macs
;
464 static int send_via_shortcut(struct sk_buff
*skb
, struct mpoa_client
*mpc
)
466 in_cache_entry
*entry
;
472 struct llc_snap_hdr hdr
;
474 } tagged_llc_snap_hdr
= {
475 {0xaa, 0xaa, 0x03, {0x00, 0x00, 0x00}, {0x88, 0x4c}},
479 buff
= skb
->data
+ mpc
->dev
->hard_header_len
;
480 iph
= (struct iphdr
*)buff
;
483 ddprintk("mpoa: (%s) send_via_shortcut: ipaddr 0x%x\n", mpc
->dev
->name
, ipaddr
);
485 entry
= mpc
->in_ops
->get(ipaddr
, mpc
);
487 entry
= mpc
->in_ops
->add_entry(ipaddr
, mpc
);
488 if (entry
!= NULL
) mpc
->in_ops
->put(entry
);
491 if (mpc
->in_ops
->cache_hit(entry
, mpc
) != OPEN
){ /* threshold not exceeded or VCC not ready */
492 ddprintk("mpoa: (%s) send_via_shortcut: cache_hit: returns != OPEN\n", mpc
->dev
->name
);
493 mpc
->in_ops
->put(entry
);
497 ddprintk("mpoa: (%s) send_via_shortcut: using shortcut\n", mpc
->dev
->name
);
498 /* MPOA spec A.1.4, MPOA client must decrement IP ttl at least by one */
500 ddprintk("mpoa: (%s) send_via_shortcut: IP ttl = %u, using LANE\n", mpc
->dev
->name
, iph
->ttl
);
501 mpc
->in_ops
->put(entry
);
506 iph
->check
= ip_fast_csum((unsigned char *)iph
, iph
->ihl
);
508 if (entry
->ctrl_info
.tag
!= 0) {
509 ddprintk("mpoa: (%s) send_via_shortcut: adding tag 0x%x\n", mpc
->dev
->name
, entry
->ctrl_info
.tag
);
510 tagged_llc_snap_hdr
.tag
= entry
->ctrl_info
.tag
;
511 skb_pull(skb
, ETH_HLEN
); /* get rid of Eth header */
512 skb_push(skb
, sizeof(tagged_llc_snap_hdr
)); /* add LLC/SNAP header */
513 skb_copy_to_linear_data(skb
, &tagged_llc_snap_hdr
,
514 sizeof(tagged_llc_snap_hdr
));
516 skb_pull(skb
, ETH_HLEN
); /* get rid of Eth header */
517 skb_push(skb
, sizeof(struct llc_snap_hdr
)); /* add LLC/SNAP header + tag */
518 skb_copy_to_linear_data(skb
, &llc_snap_mpoa_data
,
519 sizeof(struct llc_snap_hdr
));
522 atomic_add(skb
->truesize
, &sk_atm(entry
->shortcut
)->sk_wmem_alloc
);
523 ATM_SKB(skb
)->atm_options
= entry
->shortcut
->atm_options
;
524 entry
->shortcut
->send(entry
->shortcut
, skb
);
525 entry
->packets_fwded
++;
526 mpc
->in_ops
->put(entry
);
532 * Probably needs some error checks and locking, not sure...
534 static netdev_tx_t
mpc_send_packet(struct sk_buff
*skb
,
535 struct net_device
*dev
)
537 struct mpoa_client
*mpc
;
541 mpc
= find_mpc_by_lec(dev
); /* this should NEVER fail */
543 printk("mpoa: (%s) mpc_send_packet: no MPC found\n", dev
->name
);
547 eth
= (struct ethhdr
*)skb
->data
;
548 if (eth
->h_proto
!= htons(ETH_P_IP
))
549 goto non_ip
; /* Multi-Protocol Over ATM :-) */
551 /* Weed out funny packets (e.g., AF_PACKET or raw). */
552 if (skb
->len
< ETH_HLEN
+ sizeof(struct iphdr
))
554 skb_set_network_header(skb
, ETH_HLEN
);
555 if (skb
->len
< ETH_HLEN
+ ip_hdr(skb
)->ihl
* 4 || ip_hdr(skb
)->ihl
< 5)
558 while (i
< mpc
->number_of_mps_macs
) {
559 if (!compare_ether_addr(eth
->h_dest
, (mpc
->mps_macs
+ i
*ETH_ALEN
)))
560 if ( send_via_shortcut(skb
, mpc
) == 0 ) /* try shortcut */
561 return NETDEV_TX_OK
; /* success! */
566 return mpc
->old_ops
->ndo_start_xmit(skb
,dev
);
569 static int atm_mpoa_vcc_attach(struct atm_vcc
*vcc
, void __user
*arg
)
572 struct mpoa_client
*mpc
;
573 struct atmmpc_ioc ioc_data
;
574 in_cache_entry
*in_entry
;
577 bytes_left
= copy_from_user(&ioc_data
, arg
, sizeof(struct atmmpc_ioc
));
578 if (bytes_left
!= 0) {
579 printk("mpoa: mpc_vcc_attach: Short read (missed %d bytes) from userland\n", bytes_left
);
582 ipaddr
= ioc_data
.ipaddr
;
583 if (ioc_data
.dev_num
< 0 || ioc_data
.dev_num
>= MAX_LEC_ITF
)
586 mpc
= find_mpc_by_itfnum(ioc_data
.dev_num
);
590 if (ioc_data
.type
== MPC_SOCKET_INGRESS
) {
591 in_entry
= mpc
->in_ops
->get(ipaddr
, mpc
);
592 if (in_entry
== NULL
|| in_entry
->entry_state
< INGRESS_RESOLVED
) {
593 printk("mpoa: (%s) mpc_vcc_attach: did not find RESOLVED entry from ingress cache\n",
595 if (in_entry
!= NULL
) mpc
->in_ops
->put(in_entry
);
598 printk("mpoa: (%s) mpc_vcc_attach: attaching ingress SVC, entry = %pI4\n",
599 mpc
->dev
->name
, &in_entry
->ctrl_info
.in_dst_ip
);
600 in_entry
->shortcut
= vcc
;
601 mpc
->in_ops
->put(in_entry
);
603 printk("mpoa: (%s) mpc_vcc_attach: attaching egress SVC\n", mpc
->dev
->name
);
606 vcc
->proto_data
= mpc
->dev
;
607 vcc
->push
= mpc_push
;
615 static void mpc_vcc_close(struct atm_vcc
*vcc
, struct net_device
*dev
)
617 struct mpoa_client
*mpc
;
618 in_cache_entry
*in_entry
;
619 eg_cache_entry
*eg_entry
;
621 mpc
= find_mpc_by_lec(dev
);
623 printk("mpoa: (%s) mpc_vcc_close: close for unknown MPC\n", dev
->name
);
627 dprintk("mpoa: (%s) mpc_vcc_close:\n", dev
->name
);
628 in_entry
= mpc
->in_ops
->get_by_vcc(vcc
, mpc
);
630 dprintk("mpoa: (%s) mpc_vcc_close: ingress SVC closed ip = %pI4\n",
631 mpc
->dev
->name
, &in_entry
->ctrl_info
.in_dst_ip
);
632 in_entry
->shortcut
= NULL
;
633 mpc
->in_ops
->put(in_entry
);
635 eg_entry
= mpc
->eg_ops
->get_by_vcc(vcc
, mpc
);
637 dprintk("mpoa: (%s) mpc_vcc_close: egress SVC closed\n", mpc
->dev
->name
);
638 eg_entry
->shortcut
= NULL
;
639 mpc
->eg_ops
->put(eg_entry
);
642 if (in_entry
== NULL
&& eg_entry
== NULL
)
643 dprintk("mpoa: (%s) mpc_vcc_close: unused vcc closed\n", dev
->name
);
648 static void mpc_push(struct atm_vcc
*vcc
, struct sk_buff
*skb
)
650 struct net_device
*dev
= (struct net_device
*)vcc
->proto_data
;
651 struct sk_buff
*new_skb
;
653 struct mpoa_client
*mpc
;
657 ddprintk("mpoa: (%s) mpc_push:\n", dev
->name
);
659 dprintk("mpoa: (%s) mpc_push: null skb, closing VCC\n", dev
->name
);
660 mpc_vcc_close(vcc
, dev
);
665 if (memcmp(skb
->data
, &llc_snap_mpoa_ctrl
, sizeof(struct llc_snap_hdr
)) == 0) {
666 struct sock
*sk
= sk_atm(vcc
);
668 dprintk("mpoa: (%s) mpc_push: control packet arrived\n", dev
->name
);
669 /* Pass control packets to daemon */
670 skb_queue_tail(&sk
->sk_receive_queue
, skb
);
671 sk
->sk_data_ready(sk
, skb
->len
);
675 /* data coming over the shortcut */
676 atm_return(vcc
, skb
->truesize
);
678 mpc
= find_mpc_by_lec(dev
);
680 printk("mpoa: (%s) mpc_push: unknown MPC\n", dev
->name
);
684 if (memcmp(skb
->data
, &llc_snap_mpoa_data_tagged
, sizeof(struct llc_snap_hdr
)) == 0) { /* MPOA tagged data */
685 ddprintk("mpoa: (%s) mpc_push: tagged data packet arrived\n", dev
->name
);
687 } else if (memcmp(skb
->data
, &llc_snap_mpoa_data
, sizeof(struct llc_snap_hdr
)) == 0) { /* MPOA data */
688 printk("mpoa: (%s) mpc_push: non-tagged data packet arrived\n", dev
->name
);
689 printk(" mpc_push: non-tagged data unsupported, purging\n");
690 dev_kfree_skb_any(skb
);
693 printk("mpoa: (%s) mpc_push: garbage arrived, purging\n", dev
->name
);
694 dev_kfree_skb_any(skb
);
698 tmp
= skb
->data
+ sizeof(struct llc_snap_hdr
);
699 tag
= *(__be32
*)tmp
;
701 eg
= mpc
->eg_ops
->get_by_tag(tag
, mpc
);
703 printk("mpoa: (%s) mpc_push: Didn't find egress cache entry, tag = %u\n",
705 purge_egress_shortcut(vcc
, NULL
);
706 dev_kfree_skb_any(skb
);
711 * See if ingress MPC is using shortcut we opened as a return channel.
712 * This means we have a bi-directional vcc opened by us.
714 if (eg
->shortcut
== NULL
) {
716 printk("mpoa: (%s) mpc_push: egress SVC in use\n", dev
->name
);
719 skb_pull(skb
, sizeof(struct llc_snap_hdr
) + sizeof(tag
)); /* get rid of LLC/SNAP header */
720 new_skb
= skb_realloc_headroom(skb
, eg
->ctrl_info
.DH_length
); /* LLC/SNAP is shorter than MAC header :( */
721 dev_kfree_skb_any(skb
);
722 if (new_skb
== NULL
){
723 mpc
->eg_ops
->put(eg
);
726 skb_push(new_skb
, eg
->ctrl_info
.DH_length
); /* add MAC header */
727 skb_copy_to_linear_data(new_skb
, eg
->ctrl_info
.DLL_header
,
728 eg
->ctrl_info
.DH_length
);
729 new_skb
->protocol
= eth_type_trans(new_skb
, dev
);
730 skb_reset_network_header(new_skb
);
732 eg
->latest_ip_addr
= ip_hdr(new_skb
)->saddr
;
734 mpc
->eg_ops
->put(eg
);
736 memset(ATM_SKB(skb
), 0, sizeof(struct atm_skb_data
));
742 static struct atmdev_ops mpc_ops
= { /* only send is required */
743 .close
= mpoad_close
,
744 .send
= msg_from_mpoad
747 static struct atm_dev mpc_dev
= {
751 .lock
= __SPIN_LOCK_UNLOCKED(mpc_dev
.lock
)
752 /* members not explicitly initialised will be 0 */
755 static int atm_mpoa_mpoad_attach (struct atm_vcc
*vcc
, int arg
)
757 struct mpoa_client
*mpc
;
758 struct lec_priv
*priv
;
762 init_timer(&mpc_timer
);
765 /* This lets us now how our LECs are doing */
766 err
= register_netdevice_notifier(&mpoa_notifier
);
768 del_timer(&mpc_timer
);
773 mpc
= find_mpc_by_itfnum(arg
);
775 dprintk("mpoa: mpoad_attach: allocating new mpc for itf %d\n", arg
);
780 mpc
->dev
= find_lec_by_itfnum(arg
); /* NULL if there was no lec */
782 if (mpc
->mpoad_vcc
) {
783 printk("mpoa: mpoad_attach: mpoad is already present for itf %d\n", arg
);
787 if (mpc
->dev
) { /* check if the lec is LANE2 capable */
788 priv
= netdev_priv(mpc
->dev
);
789 if (priv
->lane_version
< 2) {
793 priv
->lane2_ops
->associate_indicator
= lane2_assoc_ind
;
796 mpc
->mpoad_vcc
= vcc
;
798 vcc_insert_socket(sk_atm(vcc
));
799 set_bit(ATM_VF_META
,&vcc
->flags
);
800 set_bit(ATM_VF_READY
,&vcc
->flags
);
803 char empty
[ATM_ESA_LEN
];
804 memset(empty
, 0, ATM_ESA_LEN
);
806 start_mpc(mpc
, mpc
->dev
);
807 /* set address if mpcd e.g. gets killed and restarted.
808 * If we do not do it now we have to wait for the next LE_ARP
810 if ( memcmp(mpc
->mps_ctrl_addr
, empty
, ATM_ESA_LEN
) != 0 )
811 send_set_mps_ctrl_addr(mpc
->mps_ctrl_addr
, mpc
);
814 __module_get(THIS_MODULE
);
818 static void send_set_mps_ctrl_addr(const char *addr
, struct mpoa_client
*mpc
)
820 struct k_message mesg
;
822 memcpy (mpc
->mps_ctrl_addr
, addr
, ATM_ESA_LEN
);
824 mesg
.type
= SET_MPS_CTRL_ADDR
;
825 memcpy(mesg
.MPS_ctrl
, addr
, ATM_ESA_LEN
);
826 msg_to_mpoad(&mesg
, mpc
);
831 static void mpoad_close(struct atm_vcc
*vcc
)
833 struct mpoa_client
*mpc
;
836 mpc
= find_mpc_by_vcc(vcc
);
838 printk("mpoa: mpoad_close: did not find MPC\n");
841 if (!mpc
->mpoad_vcc
) {
842 printk("mpoa: mpoad_close: close for non-present mpoad\n");
846 mpc
->mpoad_vcc
= NULL
;
848 struct lec_priv
*priv
= netdev_priv(mpc
->dev
);
849 priv
->lane2_ops
->associate_indicator
= NULL
;
854 mpc
->in_ops
->destroy_cache(mpc
);
855 mpc
->eg_ops
->destroy_cache(mpc
);
857 while ((skb
= skb_dequeue(&sk_atm(vcc
)->sk_receive_queue
))) {
858 atm_return(vcc
, skb
->truesize
);
862 printk("mpoa: (%s) going down\n",
863 (mpc
->dev
) ? mpc
->dev
->name
: "<unknown>");
864 module_put(THIS_MODULE
);
872 static int msg_from_mpoad(struct atm_vcc
*vcc
, struct sk_buff
*skb
)
875 struct mpoa_client
*mpc
= find_mpc_by_vcc(vcc
);
876 struct k_message
*mesg
= (struct k_message
*)skb
->data
;
877 atomic_sub(skb
->truesize
, &sk_atm(vcc
)->sk_wmem_alloc
);
880 printk("mpoa: msg_from_mpoad: no mpc found\n");
883 dprintk("mpoa: (%s) msg_from_mpoad:", (mpc
->dev
) ? mpc
->dev
->name
: "<unknown>");
885 case MPOA_RES_REPLY_RCVD
:
886 dprintk(" mpoa_res_reply_rcvd\n");
887 MPOA_res_reply_rcvd(mesg
, mpc
);
889 case MPOA_TRIGGER_RCVD
:
890 dprintk(" mpoa_trigger_rcvd\n");
891 MPOA_trigger_rcvd(mesg
, mpc
);
893 case INGRESS_PURGE_RCVD
:
894 dprintk(" nhrp_purge_rcvd\n");
895 ingress_purge_rcvd(mesg
, mpc
);
897 case EGRESS_PURGE_RCVD
:
898 dprintk(" egress_purge_reply_rcvd\n");
899 egress_purge_rcvd(mesg
, mpc
);
902 dprintk(" mps_death\n");
903 mps_death(mesg
, mpc
);
905 case CACHE_IMPOS_RCVD
:
906 dprintk(" cache_impos_rcvd\n");
907 MPOA_cache_impos_rcvd(mesg
, mpc
);
909 case SET_MPC_CTRL_ADDR
:
910 dprintk(" set_mpc_ctrl_addr\n");
911 set_mpc_ctrl_addr_rcvd(mesg
, mpc
);
913 case SET_MPS_MAC_ADDR
:
914 dprintk(" set_mps_mac_addr\n");
915 set_mps_mac_addr_rcvd(mesg
, mpc
);
917 case CLEAN_UP_AND_EXIT
:
918 dprintk(" clean_up_and_exit\n");
919 clean_up(mesg
, mpc
, DIE
);
922 dprintk(" reload\n");
923 clean_up(mesg
, mpc
, RELOAD
);
926 dprintk(" set_mpc_params\n");
927 mpc
->parameters
= mesg
->content
.params
;
930 dprintk(" unknown message %d\n", mesg
->type
);
938 /* Remember that this function may not do things that sleep */
939 int msg_to_mpoad(struct k_message
*mesg
, struct mpoa_client
*mpc
)
944 if (mpc
== NULL
|| !mpc
->mpoad_vcc
) {
945 printk("mpoa: msg_to_mpoad: mesg %d to a non-existent mpoad\n", mesg
->type
);
949 skb
= alloc_skb(sizeof(struct k_message
), GFP_ATOMIC
);
952 skb_put(skb
, sizeof(struct k_message
));
953 skb_copy_to_linear_data(skb
, mesg
, sizeof(*mesg
));
954 atm_force_charge(mpc
->mpoad_vcc
, skb
->truesize
);
956 sk
= sk_atm(mpc
->mpoad_vcc
);
957 skb_queue_tail(&sk
->sk_receive_queue
, skb
);
958 sk
->sk_data_ready(sk
, skb
->len
);
963 static int mpoa_event_listener(struct notifier_block
*mpoa_notifier
, unsigned long event
, void *dev_ptr
)
965 struct net_device
*dev
;
966 struct mpoa_client
*mpc
;
967 struct lec_priv
*priv
;
969 dev
= (struct net_device
*)dev_ptr
;
971 if (!net_eq(dev_net(dev
), &init_net
))
974 if (dev
->name
== NULL
|| strncmp(dev
->name
, "lec", 3))
975 return NOTIFY_DONE
; /* we are only interested in lec:s */
978 case NETDEV_REGISTER
: /* a new lec device was allocated */
979 priv
= netdev_priv(dev
);
980 if (priv
->lane_version
< 2)
982 priv
->lane2_ops
->associate_indicator
= lane2_assoc_ind
;
983 mpc
= find_mpc_by_itfnum(priv
->itfnum
);
985 dprintk("mpoa: mpoa_event_listener: allocating new mpc for %s\n",
989 printk("mpoa: mpoa_event_listener: no new mpc");
993 mpc
->dev_num
= priv
->itfnum
;
996 dprintk("mpoa: (%s) was initialized\n", dev
->name
);
998 case NETDEV_UNREGISTER
:
999 /* the lec device was deallocated */
1000 mpc
= find_mpc_by_lec(dev
);
1003 dprintk("mpoa: device (%s) was deallocated\n", dev
->name
);
1009 /* the dev was ifconfig'ed up */
1010 mpc
= find_mpc_by_lec(dev
);
1013 if (mpc
->mpoad_vcc
!= NULL
) {
1014 start_mpc(mpc
, dev
);
1018 /* the dev was ifconfig'ed down */
1019 /* this means that the flow of packets from the
1022 mpc
= find_mpc_by_lec(dev
);
1025 if (mpc
->mpoad_vcc
!= NULL
) {
1031 case NETDEV_CHANGEMTU
:
1032 case NETDEV_CHANGEADDR
:
1033 case NETDEV_GOING_DOWN
:
1043 * Functions which are called after a message is received from mpcd.
1044 * Msg is reused on purpose.
1048 static void MPOA_trigger_rcvd(struct k_message
*msg
, struct mpoa_client
*mpc
)
1050 __be32 dst_ip
= msg
->content
.in_info
.in_dst_ip
;
1051 in_cache_entry
*entry
;
1053 entry
= mpc
->in_ops
->get(dst_ip
, mpc
);
1055 entry
= mpc
->in_ops
->add_entry(dst_ip
, mpc
);
1056 entry
->entry_state
= INGRESS_RESOLVING
;
1057 msg
->type
= SND_MPOA_RES_RQST
;
1058 msg
->content
.in_info
= entry
->ctrl_info
;
1059 msg_to_mpoad(msg
, mpc
);
1060 do_gettimeofday(&(entry
->reply_wait
));
1061 mpc
->in_ops
->put(entry
);
1065 if(entry
->entry_state
== INGRESS_INVALID
){
1066 entry
->entry_state
= INGRESS_RESOLVING
;
1067 msg
->type
= SND_MPOA_RES_RQST
;
1068 msg
->content
.in_info
= entry
->ctrl_info
;
1069 msg_to_mpoad(msg
, mpc
);
1070 do_gettimeofday(&(entry
->reply_wait
));
1071 mpc
->in_ops
->put(entry
);
1075 printk("mpoa: (%s) MPOA_trigger_rcvd: entry already in resolving state\n",
1076 (mpc
->dev
) ? mpc
->dev
->name
: "<unknown>");
1077 mpc
->in_ops
->put(entry
);
1082 * Things get complicated because we have to check if there's an egress
1083 * shortcut with suitable traffic parameters we could use.
1085 static void check_qos_and_open_shortcut(struct k_message
*msg
, struct mpoa_client
*client
, in_cache_entry
*entry
)
1087 __be32 dst_ip
= msg
->content
.in_info
.in_dst_ip
;
1088 struct atm_mpoa_qos
*qos
= atm_mpoa_search_qos(dst_ip
);
1089 eg_cache_entry
*eg_entry
= client
->eg_ops
->get_by_src_ip(dst_ip
, client
);
1091 if(eg_entry
&& eg_entry
->shortcut
){
1092 if(eg_entry
->shortcut
->qos
.txtp
.traffic_class
&
1093 msg
->qos
.txtp
.traffic_class
&
1094 (qos
? qos
->qos
.txtp
.traffic_class
: ATM_UBR
| ATM_CBR
)){
1095 if(eg_entry
->shortcut
->qos
.txtp
.traffic_class
== ATM_UBR
)
1096 entry
->shortcut
= eg_entry
->shortcut
;
1097 else if(eg_entry
->shortcut
->qos
.txtp
.max_pcr
> 0)
1098 entry
->shortcut
= eg_entry
->shortcut
;
1100 if(entry
->shortcut
){
1101 dprintk("mpoa: (%s) using egress SVC to reach %pI4\n",
1102 client
->dev
->name
, &dst_ip
);
1103 client
->eg_ops
->put(eg_entry
);
1107 if (eg_entry
!= NULL
)
1108 client
->eg_ops
->put(eg_entry
);
1110 /* No luck in the egress cache we must open an ingress SVC */
1111 msg
->type
= OPEN_INGRESS_SVC
;
1112 if (qos
&& (qos
->qos
.txtp
.traffic_class
== msg
->qos
.txtp
.traffic_class
))
1114 msg
->qos
= qos
->qos
;
1115 printk("mpoa: (%s) trying to get a CBR shortcut\n",client
->dev
->name
);
1117 else memset(&msg
->qos
,0,sizeof(struct atm_qos
));
1118 msg_to_mpoad(msg
, client
);
1122 static void MPOA_res_reply_rcvd(struct k_message
*msg
, struct mpoa_client
*mpc
)
1124 __be32 dst_ip
= msg
->content
.in_info
.in_dst_ip
;
1125 in_cache_entry
*entry
= mpc
->in_ops
->get(dst_ip
, mpc
);
1127 dprintk("mpoa: (%s) MPOA_res_reply_rcvd: ip %pI4\n",
1128 mpc
->dev
->name
, &dst_ip
);
1129 ddprintk("mpoa: (%s) MPOA_res_reply_rcvd() entry = %p", mpc
->dev
->name
, entry
);
1131 printk("\nmpoa: (%s) ARGH, received res. reply for an entry that doesn't exist.\n", mpc
->dev
->name
);
1134 ddprintk(" entry_state = %d ", entry
->entry_state
);
1136 if (entry
->entry_state
== INGRESS_RESOLVED
) {
1137 printk("\nmpoa: (%s) MPOA_res_reply_rcvd for RESOLVED entry!\n", mpc
->dev
->name
);
1138 mpc
->in_ops
->put(entry
);
1142 entry
->ctrl_info
= msg
->content
.in_info
;
1143 do_gettimeofday(&(entry
->tv
));
1144 do_gettimeofday(&(entry
->reply_wait
)); /* Used in refreshing func from now on */
1145 entry
->refresh_time
= 0;
1146 ddprintk("entry->shortcut = %p\n", entry
->shortcut
);
1148 if(entry
->entry_state
== INGRESS_RESOLVING
&& entry
->shortcut
!= NULL
){
1149 entry
->entry_state
= INGRESS_RESOLVED
;
1150 mpc
->in_ops
->put(entry
);
1151 return; /* Shortcut already open... */
1154 if (entry
->shortcut
!= NULL
) {
1155 printk("mpoa: (%s) MPOA_res_reply_rcvd: entry->shortcut != NULL, impossible!\n",
1157 mpc
->in_ops
->put(entry
);
1161 check_qos_and_open_shortcut(msg
, mpc
, entry
);
1162 entry
->entry_state
= INGRESS_RESOLVED
;
1163 mpc
->in_ops
->put(entry
);
1169 static void ingress_purge_rcvd(struct k_message
*msg
, struct mpoa_client
*mpc
)
1171 __be32 dst_ip
= msg
->content
.in_info
.in_dst_ip
;
1172 __be32 mask
= msg
->ip_mask
;
1173 in_cache_entry
*entry
= mpc
->in_ops
->get_with_mask(dst_ip
, mpc
, mask
);
1176 printk("mpoa: (%s) ingress_purge_rcvd: purge for a non-existing entry, ip = %pI4\n",
1177 mpc
->dev
->name
, &dst_ip
);
1182 dprintk("mpoa: (%s) ingress_purge_rcvd: removing an ingress entry, ip = %pI4\n",
1183 mpc
->dev
->name
, &dst_ip
);
1184 write_lock_bh(&mpc
->ingress_lock
);
1185 mpc
->in_ops
->remove_entry(entry
, mpc
);
1186 write_unlock_bh(&mpc
->ingress_lock
);
1187 mpc
->in_ops
->put(entry
);
1188 entry
= mpc
->in_ops
->get_with_mask(dst_ip
, mpc
, mask
);
1189 } while (entry
!= NULL
);
1194 static void egress_purge_rcvd(struct k_message
*msg
, struct mpoa_client
*mpc
)
1196 __be32 cache_id
= msg
->content
.eg_info
.cache_id
;
1197 eg_cache_entry
*entry
= mpc
->eg_ops
->get_by_cache_id(cache_id
, mpc
);
1199 if (entry
== NULL
) {
1200 dprintk("mpoa: (%s) egress_purge_rcvd: purge for a non-existing entry\n", mpc
->dev
->name
);
1204 write_lock_irq(&mpc
->egress_lock
);
1205 mpc
->eg_ops
->remove_entry(entry
, mpc
);
1206 write_unlock_irq(&mpc
->egress_lock
);
1208 mpc
->eg_ops
->put(entry
);
1213 static void purge_egress_shortcut(struct atm_vcc
*vcc
, eg_cache_entry
*entry
)
1216 struct k_message
*purge_msg
;
1217 struct sk_buff
*skb
;
1219 dprintk("mpoa: purge_egress_shortcut: entering\n");
1221 printk("mpoa: purge_egress_shortcut: vcc == NULL\n");
1225 skb
= alloc_skb(sizeof(struct k_message
), GFP_ATOMIC
);
1227 printk("mpoa: purge_egress_shortcut: out of memory\n");
1231 skb_put(skb
, sizeof(struct k_message
));
1232 memset(skb
->data
, 0, sizeof(struct k_message
));
1233 purge_msg
= (struct k_message
*)skb
->data
;
1234 purge_msg
->type
= DATA_PLANE_PURGE
;
1236 purge_msg
->content
.eg_info
= entry
->ctrl_info
;
1238 atm_force_charge(vcc
, skb
->truesize
);
1241 skb_queue_tail(&sk
->sk_receive_queue
, skb
);
1242 sk
->sk_data_ready(sk
, skb
->len
);
1243 dprintk("mpoa: purge_egress_shortcut: exiting:\n");
1249 * Our MPS died. Tell our daemon to send NHRP data plane purge to each
1250 * of the egress shortcuts we have.
1252 static void mps_death( struct k_message
* msg
, struct mpoa_client
* mpc
)
1254 eg_cache_entry
*entry
;
1256 dprintk("mpoa: (%s) mps_death:\n", mpc
->dev
->name
);
1258 if(memcmp(msg
->MPS_ctrl
, mpc
->mps_ctrl_addr
, ATM_ESA_LEN
)){
1259 printk("mpoa: (%s) mps_death: wrong MPS\n", mpc
->dev
->name
);
1263 /* FIXME: This knows too much of the cache structure */
1264 read_lock_irq(&mpc
->egress_lock
);
1265 entry
= mpc
->eg_cache
;
1266 while (entry
!= NULL
) {
1267 purge_egress_shortcut(entry
->shortcut
, entry
);
1268 entry
= entry
->next
;
1270 read_unlock_irq(&mpc
->egress_lock
);
1272 mpc
->in_ops
->destroy_cache(mpc
);
1273 mpc
->eg_ops
->destroy_cache(mpc
);
1278 static void MPOA_cache_impos_rcvd( struct k_message
* msg
, struct mpoa_client
* mpc
)
1280 uint16_t holding_time
;
1281 eg_cache_entry
*entry
= mpc
->eg_ops
->get_by_cache_id(msg
->content
.eg_info
.cache_id
, mpc
);
1283 holding_time
= msg
->content
.eg_info
.holding_time
;
1284 dprintk("mpoa: (%s) MPOA_cache_impos_rcvd: entry = %p, holding_time = %u\n",
1285 mpc
->dev
->name
, entry
, holding_time
);
1286 if(entry
== NULL
&& holding_time
) {
1287 entry
= mpc
->eg_ops
->add_entry(msg
, mpc
);
1288 mpc
->eg_ops
->put(entry
);
1292 mpc
->eg_ops
->update(entry
, holding_time
);
1296 write_lock_irq(&mpc
->egress_lock
);
1297 mpc
->eg_ops
->remove_entry(entry
, mpc
);
1298 write_unlock_irq(&mpc
->egress_lock
);
1300 mpc
->eg_ops
->put(entry
);
1305 static void set_mpc_ctrl_addr_rcvd(struct k_message
*mesg
, struct mpoa_client
*mpc
)
1307 struct lec_priv
*priv
;
1310 uint8_t tlv
[4 + 1 + 1 + 1 + ATM_ESA_LEN
];
1312 tlv
[0] = 00; tlv
[1] = 0xa0; tlv
[2] = 0x3e; tlv
[3] = 0x2a; /* type */
1313 tlv
[4] = 1 + 1 + ATM_ESA_LEN
; /* length */
1314 tlv
[5] = 0x02; /* MPOA client */
1315 tlv
[6] = 0x00; /* number of MPS MAC addresses */
1317 memcpy(&tlv
[7], mesg
->MPS_ctrl
, ATM_ESA_LEN
); /* MPC ctrl ATM addr */
1318 memcpy(mpc
->our_ctrl_addr
, mesg
->MPS_ctrl
, ATM_ESA_LEN
);
1320 dprintk("mpoa: (%s) setting MPC ctrl ATM address to ",
1321 (mpc
->dev
) ? mpc
->dev
->name
: "<unknown>");
1322 for (i
= 7; i
< sizeof(tlv
); i
++)
1323 dprintk("%02x ", tlv
[i
]);
1327 priv
= netdev_priv(mpc
->dev
);
1328 retval
= priv
->lane2_ops
->associate_req(mpc
->dev
, mpc
->dev
->dev_addr
, tlv
, sizeof(tlv
));
1330 printk("mpoa: (%s) MPOA device type TLV association failed\n", mpc
->dev
->name
);
1331 retval
= priv
->lane2_ops
->resolve(mpc
->dev
, NULL
, 1, NULL
, NULL
);
1333 printk("mpoa: (%s) targetless LE_ARP request failed\n", mpc
->dev
->name
);
1339 static void set_mps_mac_addr_rcvd(struct k_message
*msg
, struct mpoa_client
*client
)
1342 if(client
->number_of_mps_macs
)
1343 kfree(client
->mps_macs
);
1344 client
->number_of_mps_macs
= 0;
1345 client
->mps_macs
= kmemdup(msg
->MPS_ctrl
, ETH_ALEN
, GFP_KERNEL
);
1346 if (client
->mps_macs
== NULL
) {
1347 printk("mpoa: set_mps_mac_addr_rcvd: out of memory\n");
1350 client
->number_of_mps_macs
= 1;
1356 * purge egress cache and tell daemon to 'action' (DIE, RELOAD)
1358 static void clean_up(struct k_message
*msg
, struct mpoa_client
*mpc
, int action
)
1361 eg_cache_entry
*entry
;
1362 msg
->type
= SND_EGRESS_PURGE
;
1365 /* FIXME: This knows too much of the cache structure */
1366 read_lock_irq(&mpc
->egress_lock
);
1367 entry
= mpc
->eg_cache
;
1368 while (entry
!= NULL
){
1369 msg
->content
.eg_info
= entry
->ctrl_info
;
1370 dprintk("mpoa: cache_id %u\n", entry
->ctrl_info
.cache_id
);
1371 msg_to_mpoad(msg
, mpc
);
1372 entry
= entry
->next
;
1374 read_unlock_irq(&mpc
->egress_lock
);
1377 msg_to_mpoad(msg
, mpc
);
1381 static void mpc_timer_refresh(void)
1383 mpc_timer
.expires
= jiffies
+ (MPC_P2
* HZ
);
1384 mpc_timer
.data
= mpc_timer
.expires
;
1385 mpc_timer
.function
= mpc_cache_check
;
1386 add_timer(&mpc_timer
);
1391 static void mpc_cache_check( unsigned long checking_time
)
1393 struct mpoa_client
*mpc
= mpcs
;
1394 static unsigned long previous_resolving_check_time
;
1395 static unsigned long previous_refresh_time
;
1397 while( mpc
!= NULL
){
1398 mpc
->in_ops
->clear_count(mpc
);
1399 mpc
->eg_ops
->clear_expired(mpc
);
1400 if(checking_time
- previous_resolving_check_time
> mpc
->parameters
.mpc_p4
* HZ
){
1401 mpc
->in_ops
->check_resolving(mpc
);
1402 previous_resolving_check_time
= checking_time
;
1404 if(checking_time
- previous_refresh_time
> mpc
->parameters
.mpc_p5
* HZ
){
1405 mpc
->in_ops
->refresh(mpc
);
1406 previous_refresh_time
= checking_time
;
1410 mpc_timer_refresh();
1415 static int atm_mpoa_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
1418 struct atm_vcc
*vcc
= ATM_SD(sock
);
1420 if (cmd
!= ATMMPC_CTRL
&& cmd
!= ATMMPC_DATA
)
1421 return -ENOIOCTLCMD
;
1423 if (!capable(CAP_NET_ADMIN
))
1428 err
= atm_mpoa_mpoad_attach(vcc
, (int)arg
);
1430 sock
->state
= SS_CONNECTED
;
1433 err
= atm_mpoa_vcc_attach(vcc
, (void __user
*)arg
);
1442 static struct atm_ioctl atm_ioctl_ops
= {
1443 .owner
= THIS_MODULE
,
1444 .ioctl
= atm_mpoa_ioctl
,
1447 static __init
int atm_mpoa_init(void)
1449 register_atm_ioctl(&atm_ioctl_ops
);
1451 if (mpc_proc_init() != 0)
1452 pr_info("failed to initialize /proc/mpoa\n");
1454 printk("mpc.c: " __DATE__
" " __TIME__
" initialized\n");
1459 static void __exit
atm_mpoa_cleanup(void)
1461 struct mpoa_client
*mpc
, *tmp
;
1462 struct atm_mpoa_qos
*qos
, *nextqos
;
1463 struct lec_priv
*priv
;
1467 del_timer(&mpc_timer
);
1468 unregister_netdevice_notifier(&mpoa_notifier
);
1469 deregister_atm_ioctl(&atm_ioctl_ops
);
1473 while (mpc
!= NULL
) {
1475 if (mpc
->dev
!= NULL
) {
1477 priv
= netdev_priv(mpc
->dev
);
1478 if (priv
->lane2_ops
!= NULL
)
1479 priv
->lane2_ops
->associate_indicator
= NULL
;
1481 ddprintk("mpoa: cleanup_module: about to clear caches\n");
1482 mpc
->in_ops
->destroy_cache(mpc
);
1483 mpc
->eg_ops
->destroy_cache(mpc
);
1484 ddprintk("mpoa: cleanup_module: caches cleared\n");
1485 kfree(mpc
->mps_macs
);
1486 memset(mpc
, 0, sizeof(struct mpoa_client
));
1487 ddprintk("mpoa: cleanup_module: about to kfree %p\n", mpc
);
1489 ddprintk("mpoa: cleanup_module: next mpc is at %p\n", tmp
);
1495 while (qos
!= NULL
) {
1496 nextqos
= qos
->next
;
1497 dprintk("mpoa: cleanup_module: freeing qos entry %p\n", qos
);
1505 module_init(atm_mpoa_init
);
1506 module_exit(atm_mpoa_cleanup
);
1508 MODULE_LICENSE("GPL");